@aws-sdk/client-pinpoint 3.476.0 → 3.478.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 +743 -1667
  2. package/dist-es/protocols/Aws_restJson1.js +744 -1668
  3. package/package.json +7 -6
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, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { BadRequestException, ConflictException, ForbiddenException, InternalServerErrorException, MethodNotAllowedException, NotFoundException, PayloadTooLargeException, TooManyRequestsException, } from "../models/models_0";
4
4
  import { PinpointServiceException as __BaseException } from "../models/PinpointServiceException";
5
5
  export const se_CreateAppCommand = 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/apps";
10
+ b.bp("/v1/apps");
11
11
  let body;
12
12
  if (input.CreateApplicationRequest !== undefined) {
13
13
  body = se_CreateApplicationRequest(input.CreateApplicationRequest, context);
@@ -16,23 +16,16 @@ export const se_CreateAppCommand = async (input, context) => {
16
16
  body = {};
17
17
  }
18
18
  body = JSON.stringify(body);
19
- return new __HttpRequest({
20
- protocol,
21
- hostname,
22
- port,
23
- method: "POST",
24
- headers,
25
- path: resolvedPath,
26
- body,
27
- });
19
+ b.m("POST").h(headers).b(body);
20
+ return b.build();
28
21
  };
29
22
  export const se_CreateCampaignCommand = async (input, context) => {
30
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
23
+ const b = rb(input, context);
31
24
  const headers = {
32
25
  "content-type": "application/json",
33
26
  };
34
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/campaigns";
35
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
27
+ b.bp("/v1/apps/{ApplicationId}/campaigns");
28
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
36
29
  let body;
37
30
  if (input.WriteCampaignRequest !== undefined) {
38
31
  body = se_WriteCampaignRequest(input.WriteCampaignRequest, context);
@@ -41,23 +34,16 @@ export const se_CreateCampaignCommand = async (input, context) => {
41
34
  body = {};
42
35
  }
43
36
  body = JSON.stringify(body);
44
- return new __HttpRequest({
45
- protocol,
46
- hostname,
47
- port,
48
- method: "POST",
49
- headers,
50
- path: resolvedPath,
51
- body,
52
- });
37
+ b.m("POST").h(headers).b(body);
38
+ return b.build();
53
39
  };
54
40
  export const se_CreateEmailTemplateCommand = async (input, context) => {
55
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
41
+ const b = rb(input, context);
56
42
  const headers = {
57
43
  "content-type": "application/json",
58
44
  };
59
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/email";
60
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
45
+ b.bp("/v1/templates/{TemplateName}/email");
46
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
61
47
  let body;
62
48
  if (input.EmailTemplateRequest !== undefined) {
63
49
  body = se_EmailTemplateRequest(input.EmailTemplateRequest, context);
@@ -66,23 +52,16 @@ export const se_CreateEmailTemplateCommand = async (input, context) => {
66
52
  body = {};
67
53
  }
68
54
  body = JSON.stringify(body);
69
- return new __HttpRequest({
70
- protocol,
71
- hostname,
72
- port,
73
- method: "POST",
74
- headers,
75
- path: resolvedPath,
76
- body,
77
- });
55
+ b.m("POST").h(headers).b(body);
56
+ return b.build();
78
57
  };
79
58
  export const se_CreateExportJobCommand = async (input, context) => {
80
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
59
+ const b = rb(input, context);
81
60
  const headers = {
82
61
  "content-type": "application/json",
83
62
  };
84
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/jobs/export";
85
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
63
+ b.bp("/v1/apps/{ApplicationId}/jobs/export");
64
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
86
65
  let body;
87
66
  if (input.ExportJobRequest !== undefined) {
88
67
  body = _json(input.ExportJobRequest);
@@ -91,23 +70,16 @@ export const se_CreateExportJobCommand = async (input, context) => {
91
70
  body = {};
92
71
  }
93
72
  body = JSON.stringify(body);
94
- return new __HttpRequest({
95
- protocol,
96
- hostname,
97
- port,
98
- method: "POST",
99
- headers,
100
- path: resolvedPath,
101
- body,
102
- });
73
+ b.m("POST").h(headers).b(body);
74
+ return b.build();
103
75
  };
104
76
  export const se_CreateImportJobCommand = async (input, context) => {
105
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
77
+ const b = rb(input, context);
106
78
  const headers = {
107
79
  "content-type": "application/json",
108
80
  };
109
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/jobs/import";
110
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
81
+ b.bp("/v1/apps/{ApplicationId}/jobs/import");
82
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
111
83
  let body;
112
84
  if (input.ImportJobRequest !== undefined) {
113
85
  body = _json(input.ImportJobRequest);
@@ -116,23 +88,16 @@ export const se_CreateImportJobCommand = async (input, context) => {
116
88
  body = {};
117
89
  }
118
90
  body = JSON.stringify(body);
119
- return new __HttpRequest({
120
- protocol,
121
- hostname,
122
- port,
123
- method: "POST",
124
- headers,
125
- path: resolvedPath,
126
- body,
127
- });
91
+ b.m("POST").h(headers).b(body);
92
+ return b.build();
128
93
  };
129
94
  export const se_CreateInAppTemplateCommand = async (input, context) => {
130
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
95
+ const b = rb(input, context);
131
96
  const headers = {
132
97
  "content-type": "application/json",
133
98
  };
134
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/inapp";
135
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
99
+ b.bp("/v1/templates/{TemplateName}/inapp");
100
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
136
101
  let body;
137
102
  if (input.InAppTemplateRequest !== undefined) {
138
103
  body = se_InAppTemplateRequest(input.InAppTemplateRequest, context);
@@ -141,23 +106,16 @@ export const se_CreateInAppTemplateCommand = async (input, context) => {
141
106
  body = {};
142
107
  }
143
108
  body = JSON.stringify(body);
144
- return new __HttpRequest({
145
- protocol,
146
- hostname,
147
- port,
148
- method: "POST",
149
- headers,
150
- path: resolvedPath,
151
- body,
152
- });
109
+ b.m("POST").h(headers).b(body);
110
+ return b.build();
153
111
  };
154
112
  export const se_CreateJourneyCommand = async (input, context) => {
155
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
113
+ const b = rb(input, context);
156
114
  const headers = {
157
115
  "content-type": "application/json",
158
116
  };
159
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/journeys";
160
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
117
+ b.bp("/v1/apps/{ApplicationId}/journeys");
118
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
161
119
  let body;
162
120
  if (input.WriteJourneyRequest !== undefined) {
163
121
  body = se_WriteJourneyRequest(input.WriteJourneyRequest, context);
@@ -166,23 +124,16 @@ export const se_CreateJourneyCommand = async (input, context) => {
166
124
  body = {};
167
125
  }
168
126
  body = JSON.stringify(body);
169
- return new __HttpRequest({
170
- protocol,
171
- hostname,
172
- port,
173
- method: "POST",
174
- headers,
175
- path: resolvedPath,
176
- body,
177
- });
127
+ b.m("POST").h(headers).b(body);
128
+ return b.build();
178
129
  };
179
130
  export const se_CreatePushTemplateCommand = async (input, context) => {
180
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
131
+ const b = rb(input, context);
181
132
  const headers = {
182
133
  "content-type": "application/json",
183
134
  };
184
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/push";
185
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
135
+ b.bp("/v1/templates/{TemplateName}/push");
136
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
186
137
  let body;
187
138
  if (input.PushNotificationTemplateRequest !== undefined) {
188
139
  body = se_PushNotificationTemplateRequest(input.PushNotificationTemplateRequest, context);
@@ -191,22 +142,15 @@ export const se_CreatePushTemplateCommand = async (input, context) => {
191
142
  body = {};
192
143
  }
193
144
  body = JSON.stringify(body);
194
- return new __HttpRequest({
195
- protocol,
196
- hostname,
197
- port,
198
- method: "POST",
199
- headers,
200
- path: resolvedPath,
201
- body,
202
- });
145
+ b.m("POST").h(headers).b(body);
146
+ return b.build();
203
147
  };
204
148
  export const se_CreateRecommenderConfigurationCommand = async (input, context) => {
205
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
149
+ const b = rb(input, context);
206
150
  const headers = {
207
151
  "content-type": "application/json",
208
152
  };
209
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/recommenders";
153
+ b.bp("/v1/recommenders");
210
154
  let body;
211
155
  if (input.CreateRecommenderConfiguration !== undefined) {
212
156
  body = _json(input.CreateRecommenderConfiguration);
@@ -215,23 +159,16 @@ export const se_CreateRecommenderConfigurationCommand = async (input, context) =
215
159
  body = {};
216
160
  }
217
161
  body = JSON.stringify(body);
218
- return new __HttpRequest({
219
- protocol,
220
- hostname,
221
- port,
222
- method: "POST",
223
- headers,
224
- path: resolvedPath,
225
- body,
226
- });
162
+ b.m("POST").h(headers).b(body);
163
+ return b.build();
227
164
  };
228
165
  export const se_CreateSegmentCommand = async (input, context) => {
229
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
166
+ const b = rb(input, context);
230
167
  const headers = {
231
168
  "content-type": "application/json",
232
169
  };
233
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/segments";
234
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
170
+ b.bp("/v1/apps/{ApplicationId}/segments");
171
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
235
172
  let body;
236
173
  if (input.WriteSegmentRequest !== undefined) {
237
174
  body = se_WriteSegmentRequest(input.WriteSegmentRequest, context);
@@ -240,23 +177,16 @@ export const se_CreateSegmentCommand = async (input, context) => {
240
177
  body = {};
241
178
  }
242
179
  body = JSON.stringify(body);
243
- return new __HttpRequest({
244
- protocol,
245
- hostname,
246
- port,
247
- method: "POST",
248
- headers,
249
- path: resolvedPath,
250
- body,
251
- });
180
+ b.m("POST").h(headers).b(body);
181
+ return b.build();
252
182
  };
253
183
  export const se_CreateSmsTemplateCommand = async (input, context) => {
254
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
184
+ const b = rb(input, context);
255
185
  const headers = {
256
186
  "content-type": "application/json",
257
187
  };
258
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/sms";
259
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
188
+ b.bp("/v1/templates/{TemplateName}/sms");
189
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
260
190
  let body;
261
191
  if (input.SMSTemplateRequest !== undefined) {
262
192
  body = se_SMSTemplateRequest(input.SMSTemplateRequest, context);
@@ -265,23 +195,16 @@ export const se_CreateSmsTemplateCommand = async (input, context) => {
265
195
  body = {};
266
196
  }
267
197
  body = JSON.stringify(body);
268
- return new __HttpRequest({
269
- protocol,
270
- hostname,
271
- port,
272
- method: "POST",
273
- headers,
274
- path: resolvedPath,
275
- body,
276
- });
198
+ b.m("POST").h(headers).b(body);
199
+ return b.build();
277
200
  };
278
201
  export const se_CreateVoiceTemplateCommand = async (input, context) => {
279
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
202
+ const b = rb(input, context);
280
203
  const headers = {
281
204
  "content-type": "application/json",
282
205
  };
283
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/voice";
284
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
206
+ b.bp("/v1/templates/{TemplateName}/voice");
207
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
285
208
  let body;
286
209
  if (input.VoiceTemplateRequest !== undefined) {
287
210
  body = se_VoiceTemplateRequest(input.VoiceTemplateRequest, context);
@@ -290,1472 +213,859 @@ export const se_CreateVoiceTemplateCommand = async (input, context) => {
290
213
  body = {};
291
214
  }
292
215
  body = JSON.stringify(body);
293
- return new __HttpRequest({
294
- protocol,
295
- hostname,
296
- port,
297
- method: "POST",
298
- headers,
299
- path: resolvedPath,
300
- body,
301
- });
216
+ b.m("POST").h(headers).b(body);
217
+ return b.build();
302
218
  };
303
219
  export const se_DeleteAdmChannelCommand = async (input, context) => {
304
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
220
+ const b = rb(input, context);
305
221
  const headers = {};
306
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/adm";
307
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
222
+ b.bp("/v1/apps/{ApplicationId}/channels/adm");
223
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
308
224
  let body;
309
- return new __HttpRequest({
310
- protocol,
311
- hostname,
312
- port,
313
- method: "DELETE",
314
- headers,
315
- path: resolvedPath,
316
- body,
317
- });
225
+ b.m("DELETE").h(headers).b(body);
226
+ return b.build();
318
227
  };
319
228
  export const se_DeleteApnsChannelCommand = async (input, context) => {
320
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
229
+ const b = rb(input, context);
321
230
  const headers = {};
322
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/apns";
323
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
231
+ b.bp("/v1/apps/{ApplicationId}/channels/apns");
232
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
324
233
  let body;
325
- return new __HttpRequest({
326
- protocol,
327
- hostname,
328
- port,
329
- method: "DELETE",
330
- headers,
331
- path: resolvedPath,
332
- body,
333
- });
234
+ b.m("DELETE").h(headers).b(body);
235
+ return b.build();
334
236
  };
335
237
  export const se_DeleteApnsSandboxChannelCommand = async (input, context) => {
336
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
238
+ const b = rb(input, context);
337
239
  const headers = {};
338
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
339
- "/v1/apps/{ApplicationId}/channels/apns_sandbox";
340
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
240
+ b.bp("/v1/apps/{ApplicationId}/channels/apns_sandbox");
241
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
341
242
  let body;
342
- return new __HttpRequest({
343
- protocol,
344
- hostname,
345
- port,
346
- method: "DELETE",
347
- headers,
348
- path: resolvedPath,
349
- body,
350
- });
243
+ b.m("DELETE").h(headers).b(body);
244
+ return b.build();
351
245
  };
352
246
  export const se_DeleteApnsVoipChannelCommand = async (input, context) => {
353
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
247
+ const b = rb(input, context);
354
248
  const headers = {};
355
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
356
- "/v1/apps/{ApplicationId}/channels/apns_voip";
357
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
249
+ b.bp("/v1/apps/{ApplicationId}/channels/apns_voip");
250
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
358
251
  let body;
359
- return new __HttpRequest({
360
- protocol,
361
- hostname,
362
- port,
363
- method: "DELETE",
364
- headers,
365
- path: resolvedPath,
366
- body,
367
- });
252
+ b.m("DELETE").h(headers).b(body);
253
+ return b.build();
368
254
  };
369
255
  export const se_DeleteApnsVoipSandboxChannelCommand = async (input, context) => {
370
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
256
+ const b = rb(input, context);
371
257
  const headers = {};
372
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
373
- "/v1/apps/{ApplicationId}/channels/apns_voip_sandbox";
374
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
258
+ b.bp("/v1/apps/{ApplicationId}/channels/apns_voip_sandbox");
259
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
375
260
  let body;
376
- return new __HttpRequest({
377
- protocol,
378
- hostname,
379
- port,
380
- method: "DELETE",
381
- headers,
382
- path: resolvedPath,
383
- body,
384
- });
261
+ b.m("DELETE").h(headers).b(body);
262
+ return b.build();
385
263
  };
386
264
  export const se_DeleteAppCommand = async (input, context) => {
387
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
265
+ const b = rb(input, context);
388
266
  const headers = {};
389
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}";
390
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
267
+ b.bp("/v1/apps/{ApplicationId}");
268
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
391
269
  let body;
392
- return new __HttpRequest({
393
- protocol,
394
- hostname,
395
- port,
396
- method: "DELETE",
397
- headers,
398
- path: resolvedPath,
399
- body,
400
- });
270
+ b.m("DELETE").h(headers).b(body);
271
+ return b.build();
401
272
  };
402
273
  export const se_DeleteBaiduChannelCommand = async (input, context) => {
403
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
274
+ const b = rb(input, context);
404
275
  const headers = {};
405
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/baidu";
406
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
276
+ b.bp("/v1/apps/{ApplicationId}/channels/baidu");
277
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
407
278
  let body;
408
- return new __HttpRequest({
409
- protocol,
410
- hostname,
411
- port,
412
- method: "DELETE",
413
- headers,
414
- path: resolvedPath,
415
- body,
416
- });
279
+ b.m("DELETE").h(headers).b(body);
280
+ return b.build();
417
281
  };
418
282
  export const se_DeleteCampaignCommand = async (input, context) => {
419
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
283
+ const b = rb(input, context);
420
284
  const headers = {};
421
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
422
- "/v1/apps/{ApplicationId}/campaigns/{CampaignId}";
423
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
424
- resolvedPath = __resolvedPath(resolvedPath, input, "CampaignId", () => input.CampaignId, "{CampaignId}", false);
285
+ b.bp("/v1/apps/{ApplicationId}/campaigns/{CampaignId}");
286
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
287
+ b.p("CampaignId", () => input.CampaignId, "{CampaignId}", false);
425
288
  let body;
426
- return new __HttpRequest({
427
- protocol,
428
- hostname,
429
- port,
430
- method: "DELETE",
431
- headers,
432
- path: resolvedPath,
433
- body,
434
- });
289
+ b.m("DELETE").h(headers).b(body);
290
+ return b.build();
435
291
  };
436
292
  export const se_DeleteEmailChannelCommand = async (input, context) => {
437
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
293
+ const b = rb(input, context);
438
294
  const headers = {};
439
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/email";
440
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
295
+ b.bp("/v1/apps/{ApplicationId}/channels/email");
296
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
441
297
  let body;
442
- return new __HttpRequest({
443
- protocol,
444
- hostname,
445
- port,
446
- method: "DELETE",
447
- headers,
448
- path: resolvedPath,
449
- body,
450
- });
298
+ b.m("DELETE").h(headers).b(body);
299
+ return b.build();
451
300
  };
452
301
  export const se_DeleteEmailTemplateCommand = async (input, context) => {
453
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
302
+ const b = rb(input, context);
454
303
  const headers = {};
455
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/email";
456
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
304
+ b.bp("/v1/templates/{TemplateName}/email");
305
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
457
306
  const query = map({
458
- version: [, input.Version],
307
+ [_v]: [, input[_V]],
459
308
  });
460
309
  let body;
461
- return new __HttpRequest({
462
- protocol,
463
- hostname,
464
- port,
465
- method: "DELETE",
466
- headers,
467
- path: resolvedPath,
468
- query,
469
- body,
470
- });
310
+ b.m("DELETE").h(headers).q(query).b(body);
311
+ return b.build();
471
312
  };
472
313
  export const se_DeleteEndpointCommand = async (input, context) => {
473
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
314
+ const b = rb(input, context);
474
315
  const headers = {};
475
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
476
- "/v1/apps/{ApplicationId}/endpoints/{EndpointId}";
477
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
478
- resolvedPath = __resolvedPath(resolvedPath, input, "EndpointId", () => input.EndpointId, "{EndpointId}", false);
316
+ b.bp("/v1/apps/{ApplicationId}/endpoints/{EndpointId}");
317
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
318
+ b.p("EndpointId", () => input.EndpointId, "{EndpointId}", false);
479
319
  let body;
480
- return new __HttpRequest({
481
- protocol,
482
- hostname,
483
- port,
484
- method: "DELETE",
485
- headers,
486
- path: resolvedPath,
487
- body,
488
- });
320
+ b.m("DELETE").h(headers).b(body);
321
+ return b.build();
489
322
  };
490
323
  export const se_DeleteEventStreamCommand = async (input, context) => {
491
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
324
+ const b = rb(input, context);
492
325
  const headers = {};
493
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/eventstream";
494
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
326
+ b.bp("/v1/apps/{ApplicationId}/eventstream");
327
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
495
328
  let body;
496
- return new __HttpRequest({
497
- protocol,
498
- hostname,
499
- port,
500
- method: "DELETE",
501
- headers,
502
- path: resolvedPath,
503
- body,
504
- });
329
+ b.m("DELETE").h(headers).b(body);
330
+ return b.build();
505
331
  };
506
332
  export const se_DeleteGcmChannelCommand = async (input, context) => {
507
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
333
+ const b = rb(input, context);
508
334
  const headers = {};
509
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/gcm";
510
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
335
+ b.bp("/v1/apps/{ApplicationId}/channels/gcm");
336
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
511
337
  let body;
512
- return new __HttpRequest({
513
- protocol,
514
- hostname,
515
- port,
516
- method: "DELETE",
517
- headers,
518
- path: resolvedPath,
519
- body,
520
- });
338
+ b.m("DELETE").h(headers).b(body);
339
+ return b.build();
521
340
  };
522
341
  export const se_DeleteInAppTemplateCommand = async (input, context) => {
523
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
342
+ const b = rb(input, context);
524
343
  const headers = {};
525
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/inapp";
526
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
344
+ b.bp("/v1/templates/{TemplateName}/inapp");
345
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
527
346
  const query = map({
528
- version: [, input.Version],
347
+ [_v]: [, input[_V]],
529
348
  });
530
349
  let body;
531
- return new __HttpRequest({
532
- protocol,
533
- hostname,
534
- port,
535
- method: "DELETE",
536
- headers,
537
- path: resolvedPath,
538
- query,
539
- body,
540
- });
350
+ b.m("DELETE").h(headers).q(query).b(body);
351
+ return b.build();
541
352
  };
542
353
  export const se_DeleteJourneyCommand = async (input, context) => {
543
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
354
+ const b = rb(input, context);
544
355
  const headers = {};
545
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
546
- "/v1/apps/{ApplicationId}/journeys/{JourneyId}";
547
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
548
- resolvedPath = __resolvedPath(resolvedPath, input, "JourneyId", () => input.JourneyId, "{JourneyId}", false);
356
+ b.bp("/v1/apps/{ApplicationId}/journeys/{JourneyId}");
357
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
358
+ b.p("JourneyId", () => input.JourneyId, "{JourneyId}", false);
549
359
  let body;
550
- return new __HttpRequest({
551
- protocol,
552
- hostname,
553
- port,
554
- method: "DELETE",
555
- headers,
556
- path: resolvedPath,
557
- body,
558
- });
360
+ b.m("DELETE").h(headers).b(body);
361
+ return b.build();
559
362
  };
560
363
  export const se_DeletePushTemplateCommand = async (input, context) => {
561
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
364
+ const b = rb(input, context);
562
365
  const headers = {};
563
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/push";
564
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
366
+ b.bp("/v1/templates/{TemplateName}/push");
367
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
565
368
  const query = map({
566
- version: [, input.Version],
369
+ [_v]: [, input[_V]],
567
370
  });
568
371
  let body;
569
- return new __HttpRequest({
570
- protocol,
571
- hostname,
572
- port,
573
- method: "DELETE",
574
- headers,
575
- path: resolvedPath,
576
- query,
577
- body,
578
- });
372
+ b.m("DELETE").h(headers).q(query).b(body);
373
+ return b.build();
579
374
  };
580
375
  export const se_DeleteRecommenderConfigurationCommand = async (input, context) => {
581
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
376
+ const b = rb(input, context);
582
377
  const headers = {};
583
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/recommenders/{RecommenderId}";
584
- resolvedPath = __resolvedPath(resolvedPath, input, "RecommenderId", () => input.RecommenderId, "{RecommenderId}", false);
378
+ b.bp("/v1/recommenders/{RecommenderId}");
379
+ b.p("RecommenderId", () => input.RecommenderId, "{RecommenderId}", false);
585
380
  let body;
586
- return new __HttpRequest({
587
- protocol,
588
- hostname,
589
- port,
590
- method: "DELETE",
591
- headers,
592
- path: resolvedPath,
593
- body,
594
- });
381
+ b.m("DELETE").h(headers).b(body);
382
+ return b.build();
595
383
  };
596
384
  export const se_DeleteSegmentCommand = async (input, context) => {
597
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
385
+ const b = rb(input, context);
598
386
  const headers = {};
599
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
600
- "/v1/apps/{ApplicationId}/segments/{SegmentId}";
601
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
602
- resolvedPath = __resolvedPath(resolvedPath, input, "SegmentId", () => input.SegmentId, "{SegmentId}", false);
387
+ b.bp("/v1/apps/{ApplicationId}/segments/{SegmentId}");
388
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
389
+ b.p("SegmentId", () => input.SegmentId, "{SegmentId}", false);
603
390
  let body;
604
- return new __HttpRequest({
605
- protocol,
606
- hostname,
607
- port,
608
- method: "DELETE",
609
- headers,
610
- path: resolvedPath,
611
- body,
612
- });
391
+ b.m("DELETE").h(headers).b(body);
392
+ return b.build();
613
393
  };
614
394
  export const se_DeleteSmsChannelCommand = async (input, context) => {
615
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
395
+ const b = rb(input, context);
616
396
  const headers = {};
617
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/sms";
618
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
397
+ b.bp("/v1/apps/{ApplicationId}/channels/sms");
398
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
619
399
  let body;
620
- return new __HttpRequest({
621
- protocol,
622
- hostname,
623
- port,
624
- method: "DELETE",
625
- headers,
626
- path: resolvedPath,
627
- body,
628
- });
400
+ b.m("DELETE").h(headers).b(body);
401
+ return b.build();
629
402
  };
630
403
  export const se_DeleteSmsTemplateCommand = async (input, context) => {
631
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
404
+ const b = rb(input, context);
632
405
  const headers = {};
633
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/sms";
634
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
406
+ b.bp("/v1/templates/{TemplateName}/sms");
407
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
635
408
  const query = map({
636
- version: [, input.Version],
409
+ [_v]: [, input[_V]],
637
410
  });
638
411
  let body;
639
- return new __HttpRequest({
640
- protocol,
641
- hostname,
642
- port,
643
- method: "DELETE",
644
- headers,
645
- path: resolvedPath,
646
- query,
647
- body,
648
- });
412
+ b.m("DELETE").h(headers).q(query).b(body);
413
+ return b.build();
649
414
  };
650
415
  export const se_DeleteUserEndpointsCommand = async (input, context) => {
651
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
416
+ const b = rb(input, context);
652
417
  const headers = {};
653
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/users/{UserId}";
654
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
655
- resolvedPath = __resolvedPath(resolvedPath, input, "UserId", () => input.UserId, "{UserId}", false);
418
+ b.bp("/v1/apps/{ApplicationId}/users/{UserId}");
419
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
420
+ b.p("UserId", () => input.UserId, "{UserId}", false);
656
421
  let body;
657
- return new __HttpRequest({
658
- protocol,
659
- hostname,
660
- port,
661
- method: "DELETE",
662
- headers,
663
- path: resolvedPath,
664
- body,
665
- });
422
+ b.m("DELETE").h(headers).b(body);
423
+ return b.build();
666
424
  };
667
425
  export const se_DeleteVoiceChannelCommand = async (input, context) => {
668
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
426
+ const b = rb(input, context);
669
427
  const headers = {};
670
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/voice";
671
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
428
+ b.bp("/v1/apps/{ApplicationId}/channels/voice");
429
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
672
430
  let body;
673
- return new __HttpRequest({
674
- protocol,
675
- hostname,
676
- port,
677
- method: "DELETE",
678
- headers,
679
- path: resolvedPath,
680
- body,
681
- });
431
+ b.m("DELETE").h(headers).b(body);
432
+ return b.build();
682
433
  };
683
434
  export const se_DeleteVoiceTemplateCommand = async (input, context) => {
684
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
435
+ const b = rb(input, context);
685
436
  const headers = {};
686
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/voice";
687
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
437
+ b.bp("/v1/templates/{TemplateName}/voice");
438
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
688
439
  const query = map({
689
- version: [, input.Version],
440
+ [_v]: [, input[_V]],
690
441
  });
691
442
  let body;
692
- return new __HttpRequest({
693
- protocol,
694
- hostname,
695
- port,
696
- method: "DELETE",
697
- headers,
698
- path: resolvedPath,
699
- query,
700
- body,
701
- });
443
+ b.m("DELETE").h(headers).q(query).b(body);
444
+ return b.build();
702
445
  };
703
446
  export const se_GetAdmChannelCommand = async (input, context) => {
704
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
447
+ const b = rb(input, context);
705
448
  const headers = {};
706
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/adm";
707
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
449
+ b.bp("/v1/apps/{ApplicationId}/channels/adm");
450
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
708
451
  let body;
709
- return new __HttpRequest({
710
- protocol,
711
- hostname,
712
- port,
713
- method: "GET",
714
- headers,
715
- path: resolvedPath,
716
- body,
717
- });
452
+ b.m("GET").h(headers).b(body);
453
+ return b.build();
718
454
  };
719
455
  export const se_GetApnsChannelCommand = async (input, context) => {
720
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
456
+ const b = rb(input, context);
721
457
  const headers = {};
722
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/apns";
723
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
458
+ b.bp("/v1/apps/{ApplicationId}/channels/apns");
459
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
724
460
  let body;
725
- return new __HttpRequest({
726
- protocol,
727
- hostname,
728
- port,
729
- method: "GET",
730
- headers,
731
- path: resolvedPath,
732
- body,
733
- });
461
+ b.m("GET").h(headers).b(body);
462
+ return b.build();
734
463
  };
735
464
  export const se_GetApnsSandboxChannelCommand = async (input, context) => {
736
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
465
+ const b = rb(input, context);
737
466
  const headers = {};
738
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
739
- "/v1/apps/{ApplicationId}/channels/apns_sandbox";
740
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
467
+ b.bp("/v1/apps/{ApplicationId}/channels/apns_sandbox");
468
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
741
469
  let body;
742
- return new __HttpRequest({
743
- protocol,
744
- hostname,
745
- port,
746
- method: "GET",
747
- headers,
748
- path: resolvedPath,
749
- body,
750
- });
470
+ b.m("GET").h(headers).b(body);
471
+ return b.build();
751
472
  };
752
473
  export const se_GetApnsVoipChannelCommand = async (input, context) => {
753
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
474
+ const b = rb(input, context);
754
475
  const headers = {};
755
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
756
- "/v1/apps/{ApplicationId}/channels/apns_voip";
757
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
476
+ b.bp("/v1/apps/{ApplicationId}/channels/apns_voip");
477
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
758
478
  let body;
759
- return new __HttpRequest({
760
- protocol,
761
- hostname,
762
- port,
763
- method: "GET",
764
- headers,
765
- path: resolvedPath,
766
- body,
767
- });
479
+ b.m("GET").h(headers).b(body);
480
+ return b.build();
768
481
  };
769
482
  export const se_GetApnsVoipSandboxChannelCommand = async (input, context) => {
770
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
483
+ const b = rb(input, context);
771
484
  const headers = {};
772
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
773
- "/v1/apps/{ApplicationId}/channels/apns_voip_sandbox";
774
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
485
+ b.bp("/v1/apps/{ApplicationId}/channels/apns_voip_sandbox");
486
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
775
487
  let body;
776
- return new __HttpRequest({
777
- protocol,
778
- hostname,
779
- port,
780
- method: "GET",
781
- headers,
782
- path: resolvedPath,
783
- body,
784
- });
488
+ b.m("GET").h(headers).b(body);
489
+ return b.build();
785
490
  };
786
491
  export const se_GetAppCommand = async (input, context) => {
787
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
492
+ const b = rb(input, context);
788
493
  const headers = {};
789
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}";
790
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
494
+ b.bp("/v1/apps/{ApplicationId}");
495
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
791
496
  let body;
792
- return new __HttpRequest({
793
- protocol,
794
- hostname,
795
- port,
796
- method: "GET",
797
- headers,
798
- path: resolvedPath,
799
- body,
800
- });
497
+ b.m("GET").h(headers).b(body);
498
+ return b.build();
801
499
  };
802
500
  export const se_GetApplicationDateRangeKpiCommand = async (input, context) => {
803
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
501
+ const b = rb(input, context);
804
502
  const headers = {};
805
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
806
- "/v1/apps/{ApplicationId}/kpis/daterange/{KpiName}";
807
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
808
- resolvedPath = __resolvedPath(resolvedPath, input, "KpiName", () => input.KpiName, "{KpiName}", false);
503
+ b.bp("/v1/apps/{ApplicationId}/kpis/daterange/{KpiName}");
504
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
505
+ b.p("KpiName", () => input.KpiName, "{KpiName}", false);
809
506
  const query = map({
810
- "end-time": [() => input.EndTime !== void 0, () => (input.EndTime.toISOString().split(".")[0] + "Z").toString()],
811
- "next-token": [, input.NextToken],
812
- "page-size": [, input.PageSize],
813
- "start-time": [
814
- () => input.StartTime !== void 0,
815
- () => (input.StartTime.toISOString().split(".")[0] + "Z").toString(),
816
- ],
507
+ [_et]: [() => input.EndTime !== void 0, () => (input[_ET].toISOString().split(".")[0] + "Z").toString()],
508
+ [_nt]: [, input[_NT]],
509
+ [_ps]: [, input[_PS]],
510
+ [_st]: [() => input.StartTime !== void 0, () => (input[_ST].toISOString().split(".")[0] + "Z").toString()],
817
511
  });
818
512
  let body;
819
- return new __HttpRequest({
820
- protocol,
821
- hostname,
822
- port,
823
- method: "GET",
824
- headers,
825
- path: resolvedPath,
826
- query,
827
- body,
828
- });
513
+ b.m("GET").h(headers).q(query).b(body);
514
+ return b.build();
829
515
  };
830
516
  export const se_GetApplicationSettingsCommand = async (input, context) => {
831
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
517
+ const b = rb(input, context);
832
518
  const headers = {};
833
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/settings";
834
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
519
+ b.bp("/v1/apps/{ApplicationId}/settings");
520
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
835
521
  let body;
836
- return new __HttpRequest({
837
- protocol,
838
- hostname,
839
- port,
840
- method: "GET",
841
- headers,
842
- path: resolvedPath,
843
- body,
844
- });
522
+ b.m("GET").h(headers).b(body);
523
+ return b.build();
845
524
  };
846
525
  export const se_GetAppsCommand = async (input, context) => {
847
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
526
+ const b = rb(input, context);
848
527
  const headers = {};
849
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps";
528
+ b.bp("/v1/apps");
850
529
  const query = map({
851
- "page-size": [, input.PageSize],
852
- token: [, input.Token],
530
+ [_ps]: [, input[_PS]],
531
+ [_t]: [, input[_T]],
853
532
  });
854
533
  let body;
855
- return new __HttpRequest({
856
- protocol,
857
- hostname,
858
- port,
859
- method: "GET",
860
- headers,
861
- path: resolvedPath,
862
- query,
863
- body,
864
- });
534
+ b.m("GET").h(headers).q(query).b(body);
535
+ return b.build();
865
536
  };
866
537
  export const se_GetBaiduChannelCommand = async (input, context) => {
867
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
538
+ const b = rb(input, context);
868
539
  const headers = {};
869
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/baidu";
870
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
540
+ b.bp("/v1/apps/{ApplicationId}/channels/baidu");
541
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
871
542
  let body;
872
- return new __HttpRequest({
873
- protocol,
874
- hostname,
875
- port,
876
- method: "GET",
877
- headers,
878
- path: resolvedPath,
879
- body,
880
- });
543
+ b.m("GET").h(headers).b(body);
544
+ return b.build();
881
545
  };
882
546
  export const se_GetCampaignCommand = async (input, context) => {
883
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
547
+ const b = rb(input, context);
884
548
  const headers = {};
885
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
886
- "/v1/apps/{ApplicationId}/campaigns/{CampaignId}";
887
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
888
- resolvedPath = __resolvedPath(resolvedPath, input, "CampaignId", () => input.CampaignId, "{CampaignId}", false);
549
+ b.bp("/v1/apps/{ApplicationId}/campaigns/{CampaignId}");
550
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
551
+ b.p("CampaignId", () => input.CampaignId, "{CampaignId}", false);
889
552
  let body;
890
- return new __HttpRequest({
891
- protocol,
892
- hostname,
893
- port,
894
- method: "GET",
895
- headers,
896
- path: resolvedPath,
897
- body,
898
- });
553
+ b.m("GET").h(headers).b(body);
554
+ return b.build();
899
555
  };
900
556
  export const se_GetCampaignActivitiesCommand = async (input, context) => {
901
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
557
+ const b = rb(input, context);
902
558
  const headers = {};
903
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
904
- "/v1/apps/{ApplicationId}/campaigns/{CampaignId}/activities";
905
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
906
- resolvedPath = __resolvedPath(resolvedPath, input, "CampaignId", () => input.CampaignId, "{CampaignId}", false);
559
+ b.bp("/v1/apps/{ApplicationId}/campaigns/{CampaignId}/activities");
560
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
561
+ b.p("CampaignId", () => input.CampaignId, "{CampaignId}", false);
907
562
  const query = map({
908
- "page-size": [, input.PageSize],
909
- token: [, input.Token],
563
+ [_ps]: [, input[_PS]],
564
+ [_t]: [, input[_T]],
910
565
  });
911
566
  let body;
912
- return new __HttpRequest({
913
- protocol,
914
- hostname,
915
- port,
916
- method: "GET",
917
- headers,
918
- path: resolvedPath,
919
- query,
920
- body,
921
- });
567
+ b.m("GET").h(headers).q(query).b(body);
568
+ return b.build();
922
569
  };
923
570
  export const se_GetCampaignDateRangeKpiCommand = async (input, context) => {
924
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
571
+ const b = rb(input, context);
925
572
  const headers = {};
926
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
927
- "/v1/apps/{ApplicationId}/campaigns/{CampaignId}/kpis/daterange/{KpiName}";
928
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
929
- resolvedPath = __resolvedPath(resolvedPath, input, "CampaignId", () => input.CampaignId, "{CampaignId}", false);
930
- resolvedPath = __resolvedPath(resolvedPath, input, "KpiName", () => input.KpiName, "{KpiName}", false);
573
+ b.bp("/v1/apps/{ApplicationId}/campaigns/{CampaignId}/kpis/daterange/{KpiName}");
574
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
575
+ b.p("CampaignId", () => input.CampaignId, "{CampaignId}", false);
576
+ b.p("KpiName", () => input.KpiName, "{KpiName}", false);
931
577
  const query = map({
932
- "end-time": [() => input.EndTime !== void 0, () => (input.EndTime.toISOString().split(".")[0] + "Z").toString()],
933
- "next-token": [, input.NextToken],
934
- "page-size": [, input.PageSize],
935
- "start-time": [
936
- () => input.StartTime !== void 0,
937
- () => (input.StartTime.toISOString().split(".")[0] + "Z").toString(),
938
- ],
578
+ [_et]: [() => input.EndTime !== void 0, () => (input[_ET].toISOString().split(".")[0] + "Z").toString()],
579
+ [_nt]: [, input[_NT]],
580
+ [_ps]: [, input[_PS]],
581
+ [_st]: [() => input.StartTime !== void 0, () => (input[_ST].toISOString().split(".")[0] + "Z").toString()],
939
582
  });
940
583
  let body;
941
- return new __HttpRequest({
942
- protocol,
943
- hostname,
944
- port,
945
- method: "GET",
946
- headers,
947
- path: resolvedPath,
948
- query,
949
- body,
950
- });
584
+ b.m("GET").h(headers).q(query).b(body);
585
+ return b.build();
951
586
  };
952
587
  export const se_GetCampaignsCommand = async (input, context) => {
953
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
588
+ const b = rb(input, context);
954
589
  const headers = {};
955
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/campaigns";
956
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
590
+ b.bp("/v1/apps/{ApplicationId}/campaigns");
591
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
957
592
  const query = map({
958
- "page-size": [, input.PageSize],
959
- token: [, input.Token],
593
+ [_ps]: [, input[_PS]],
594
+ [_t]: [, input[_T]],
960
595
  });
961
596
  let body;
962
- return new __HttpRequest({
963
- protocol,
964
- hostname,
965
- port,
966
- method: "GET",
967
- headers,
968
- path: resolvedPath,
969
- query,
970
- body,
971
- });
597
+ b.m("GET").h(headers).q(query).b(body);
598
+ return b.build();
972
599
  };
973
600
  export const se_GetCampaignVersionCommand = async (input, context) => {
974
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
601
+ const b = rb(input, context);
975
602
  const headers = {};
976
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
977
- "/v1/apps/{ApplicationId}/campaigns/{CampaignId}/versions/{Version}";
978
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
979
- resolvedPath = __resolvedPath(resolvedPath, input, "CampaignId", () => input.CampaignId, "{CampaignId}", false);
980
- resolvedPath = __resolvedPath(resolvedPath, input, "Version", () => input.Version, "{Version}", false);
603
+ b.bp("/v1/apps/{ApplicationId}/campaigns/{CampaignId}/versions/{Version}");
604
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
605
+ b.p("CampaignId", () => input.CampaignId, "{CampaignId}", false);
606
+ b.p("Version", () => input.Version, "{Version}", false);
981
607
  let body;
982
- return new __HttpRequest({
983
- protocol,
984
- hostname,
985
- port,
986
- method: "GET",
987
- headers,
988
- path: resolvedPath,
989
- body,
990
- });
608
+ b.m("GET").h(headers).b(body);
609
+ return b.build();
991
610
  };
992
611
  export const se_GetCampaignVersionsCommand = async (input, context) => {
993
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
612
+ const b = rb(input, context);
994
613
  const headers = {};
995
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
996
- "/v1/apps/{ApplicationId}/campaigns/{CampaignId}/versions";
997
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
998
- resolvedPath = __resolvedPath(resolvedPath, input, "CampaignId", () => input.CampaignId, "{CampaignId}", false);
614
+ b.bp("/v1/apps/{ApplicationId}/campaigns/{CampaignId}/versions");
615
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
616
+ b.p("CampaignId", () => input.CampaignId, "{CampaignId}", false);
999
617
  const query = map({
1000
- "page-size": [, input.PageSize],
1001
- token: [, input.Token],
618
+ [_ps]: [, input[_PS]],
619
+ [_t]: [, input[_T]],
1002
620
  });
1003
621
  let body;
1004
- return new __HttpRequest({
1005
- protocol,
1006
- hostname,
1007
- port,
1008
- method: "GET",
1009
- headers,
1010
- path: resolvedPath,
1011
- query,
1012
- body,
1013
- });
622
+ b.m("GET").h(headers).q(query).b(body);
623
+ return b.build();
1014
624
  };
1015
625
  export const se_GetChannelsCommand = async (input, context) => {
1016
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
626
+ const b = rb(input, context);
1017
627
  const headers = {};
1018
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels";
1019
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
628
+ b.bp("/v1/apps/{ApplicationId}/channels");
629
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1020
630
  let body;
1021
- return new __HttpRequest({
1022
- protocol,
1023
- hostname,
1024
- port,
1025
- method: "GET",
1026
- headers,
1027
- path: resolvedPath,
1028
- body,
1029
- });
631
+ b.m("GET").h(headers).b(body);
632
+ return b.build();
1030
633
  };
1031
634
  export const se_GetEmailChannelCommand = async (input, context) => {
1032
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
635
+ const b = rb(input, context);
1033
636
  const headers = {};
1034
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/email";
1035
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
637
+ b.bp("/v1/apps/{ApplicationId}/channels/email");
638
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1036
639
  let body;
1037
- return new __HttpRequest({
1038
- protocol,
1039
- hostname,
1040
- port,
1041
- method: "GET",
1042
- headers,
1043
- path: resolvedPath,
1044
- body,
1045
- });
640
+ b.m("GET").h(headers).b(body);
641
+ return b.build();
1046
642
  };
1047
643
  export const se_GetEmailTemplateCommand = async (input, context) => {
1048
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
644
+ const b = rb(input, context);
1049
645
  const headers = {};
1050
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/email";
1051
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
646
+ b.bp("/v1/templates/{TemplateName}/email");
647
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
1052
648
  const query = map({
1053
- version: [, input.Version],
649
+ [_v]: [, input[_V]],
1054
650
  });
1055
651
  let body;
1056
- return new __HttpRequest({
1057
- protocol,
1058
- hostname,
1059
- port,
1060
- method: "GET",
1061
- headers,
1062
- path: resolvedPath,
1063
- query,
1064
- body,
1065
- });
652
+ b.m("GET").h(headers).q(query).b(body);
653
+ return b.build();
1066
654
  };
1067
655
  export const se_GetEndpointCommand = async (input, context) => {
1068
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
656
+ const b = rb(input, context);
1069
657
  const headers = {};
1070
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1071
- "/v1/apps/{ApplicationId}/endpoints/{EndpointId}";
1072
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1073
- resolvedPath = __resolvedPath(resolvedPath, input, "EndpointId", () => input.EndpointId, "{EndpointId}", false);
658
+ b.bp("/v1/apps/{ApplicationId}/endpoints/{EndpointId}");
659
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
660
+ b.p("EndpointId", () => input.EndpointId, "{EndpointId}", false);
1074
661
  let body;
1075
- return new __HttpRequest({
1076
- protocol,
1077
- hostname,
1078
- port,
1079
- method: "GET",
1080
- headers,
1081
- path: resolvedPath,
1082
- body,
1083
- });
662
+ b.m("GET").h(headers).b(body);
663
+ return b.build();
1084
664
  };
1085
665
  export const se_GetEventStreamCommand = async (input, context) => {
1086
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
666
+ const b = rb(input, context);
1087
667
  const headers = {};
1088
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/eventstream";
1089
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
668
+ b.bp("/v1/apps/{ApplicationId}/eventstream");
669
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1090
670
  let body;
1091
- return new __HttpRequest({
1092
- protocol,
1093
- hostname,
1094
- port,
1095
- method: "GET",
1096
- headers,
1097
- path: resolvedPath,
1098
- body,
1099
- });
671
+ b.m("GET").h(headers).b(body);
672
+ return b.build();
1100
673
  };
1101
674
  export const se_GetExportJobCommand = async (input, context) => {
1102
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
675
+ const b = rb(input, context);
1103
676
  const headers = {};
1104
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1105
- "/v1/apps/{ApplicationId}/jobs/export/{JobId}";
1106
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1107
- resolvedPath = __resolvedPath(resolvedPath, input, "JobId", () => input.JobId, "{JobId}", false);
677
+ b.bp("/v1/apps/{ApplicationId}/jobs/export/{JobId}");
678
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
679
+ b.p("JobId", () => input.JobId, "{JobId}", false);
1108
680
  let body;
1109
- return new __HttpRequest({
1110
- protocol,
1111
- hostname,
1112
- port,
1113
- method: "GET",
1114
- headers,
1115
- path: resolvedPath,
1116
- body,
1117
- });
681
+ b.m("GET").h(headers).b(body);
682
+ return b.build();
1118
683
  };
1119
684
  export const se_GetExportJobsCommand = async (input, context) => {
1120
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
685
+ const b = rb(input, context);
1121
686
  const headers = {};
1122
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/jobs/export";
1123
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
687
+ b.bp("/v1/apps/{ApplicationId}/jobs/export");
688
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1124
689
  const query = map({
1125
- "page-size": [, input.PageSize],
1126
- token: [, input.Token],
690
+ [_ps]: [, input[_PS]],
691
+ [_t]: [, input[_T]],
1127
692
  });
1128
693
  let body;
1129
- return new __HttpRequest({
1130
- protocol,
1131
- hostname,
1132
- port,
1133
- method: "GET",
1134
- headers,
1135
- path: resolvedPath,
1136
- query,
1137
- body,
1138
- });
694
+ b.m("GET").h(headers).q(query).b(body);
695
+ return b.build();
1139
696
  };
1140
697
  export const se_GetGcmChannelCommand = async (input, context) => {
1141
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
698
+ const b = rb(input, context);
1142
699
  const headers = {};
1143
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/gcm";
1144
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
700
+ b.bp("/v1/apps/{ApplicationId}/channels/gcm");
701
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1145
702
  let body;
1146
- return new __HttpRequest({
1147
- protocol,
1148
- hostname,
1149
- port,
1150
- method: "GET",
1151
- headers,
1152
- path: resolvedPath,
1153
- body,
1154
- });
703
+ b.m("GET").h(headers).b(body);
704
+ return b.build();
1155
705
  };
1156
706
  export const se_GetImportJobCommand = async (input, context) => {
1157
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
707
+ const b = rb(input, context);
1158
708
  const headers = {};
1159
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1160
- "/v1/apps/{ApplicationId}/jobs/import/{JobId}";
1161
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1162
- resolvedPath = __resolvedPath(resolvedPath, input, "JobId", () => input.JobId, "{JobId}", false);
709
+ b.bp("/v1/apps/{ApplicationId}/jobs/import/{JobId}");
710
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
711
+ b.p("JobId", () => input.JobId, "{JobId}", false);
1163
712
  let body;
1164
- return new __HttpRequest({
1165
- protocol,
1166
- hostname,
1167
- port,
1168
- method: "GET",
1169
- headers,
1170
- path: resolvedPath,
1171
- body,
1172
- });
713
+ b.m("GET").h(headers).b(body);
714
+ return b.build();
1173
715
  };
1174
716
  export const se_GetImportJobsCommand = async (input, context) => {
1175
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
717
+ const b = rb(input, context);
1176
718
  const headers = {};
1177
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/jobs/import";
1178
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
719
+ b.bp("/v1/apps/{ApplicationId}/jobs/import");
720
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1179
721
  const query = map({
1180
- "page-size": [, input.PageSize],
1181
- token: [, input.Token],
722
+ [_ps]: [, input[_PS]],
723
+ [_t]: [, input[_T]],
1182
724
  });
1183
725
  let body;
1184
- return new __HttpRequest({
1185
- protocol,
1186
- hostname,
1187
- port,
1188
- method: "GET",
1189
- headers,
1190
- path: resolvedPath,
1191
- query,
1192
- body,
1193
- });
726
+ b.m("GET").h(headers).q(query).b(body);
727
+ return b.build();
1194
728
  };
1195
729
  export const se_GetInAppMessagesCommand = async (input, context) => {
1196
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
730
+ const b = rb(input, context);
1197
731
  const headers = {};
1198
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1199
- "/v1/apps/{ApplicationId}/endpoints/{EndpointId}/inappmessages";
1200
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1201
- resolvedPath = __resolvedPath(resolvedPath, input, "EndpointId", () => input.EndpointId, "{EndpointId}", false);
732
+ b.bp("/v1/apps/{ApplicationId}/endpoints/{EndpointId}/inappmessages");
733
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
734
+ b.p("EndpointId", () => input.EndpointId, "{EndpointId}", false);
1202
735
  let body;
1203
- return new __HttpRequest({
1204
- protocol,
1205
- hostname,
1206
- port,
1207
- method: "GET",
1208
- headers,
1209
- path: resolvedPath,
1210
- body,
1211
- });
736
+ b.m("GET").h(headers).b(body);
737
+ return b.build();
1212
738
  };
1213
739
  export const se_GetInAppTemplateCommand = async (input, context) => {
1214
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
740
+ const b = rb(input, context);
1215
741
  const headers = {};
1216
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/inapp";
1217
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
742
+ b.bp("/v1/templates/{TemplateName}/inapp");
743
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
1218
744
  const query = map({
1219
- version: [, input.Version],
745
+ [_v]: [, input[_V]],
1220
746
  });
1221
747
  let body;
1222
- return new __HttpRequest({
1223
- protocol,
1224
- hostname,
1225
- port,
1226
- method: "GET",
1227
- headers,
1228
- path: resolvedPath,
1229
- query,
1230
- body,
1231
- });
748
+ b.m("GET").h(headers).q(query).b(body);
749
+ return b.build();
1232
750
  };
1233
751
  export const se_GetJourneyCommand = async (input, context) => {
1234
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
752
+ const b = rb(input, context);
1235
753
  const headers = {};
1236
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1237
- "/v1/apps/{ApplicationId}/journeys/{JourneyId}";
1238
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1239
- resolvedPath = __resolvedPath(resolvedPath, input, "JourneyId", () => input.JourneyId, "{JourneyId}", false);
754
+ b.bp("/v1/apps/{ApplicationId}/journeys/{JourneyId}");
755
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
756
+ b.p("JourneyId", () => input.JourneyId, "{JourneyId}", false);
1240
757
  let body;
1241
- return new __HttpRequest({
1242
- protocol,
1243
- hostname,
1244
- port,
1245
- method: "GET",
1246
- headers,
1247
- path: resolvedPath,
1248
- body,
1249
- });
758
+ b.m("GET").h(headers).b(body);
759
+ return b.build();
1250
760
  };
1251
761
  export const se_GetJourneyDateRangeKpiCommand = async (input, context) => {
1252
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
762
+ const b = rb(input, context);
1253
763
  const headers = {};
1254
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1255
- "/v1/apps/{ApplicationId}/journeys/{JourneyId}/kpis/daterange/{KpiName}";
1256
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1257
- resolvedPath = __resolvedPath(resolvedPath, input, "JourneyId", () => input.JourneyId, "{JourneyId}", false);
1258
- resolvedPath = __resolvedPath(resolvedPath, input, "KpiName", () => input.KpiName, "{KpiName}", false);
764
+ b.bp("/v1/apps/{ApplicationId}/journeys/{JourneyId}/kpis/daterange/{KpiName}");
765
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
766
+ b.p("JourneyId", () => input.JourneyId, "{JourneyId}", false);
767
+ b.p("KpiName", () => input.KpiName, "{KpiName}", false);
1259
768
  const query = map({
1260
- "end-time": [() => input.EndTime !== void 0, () => (input.EndTime.toISOString().split(".")[0] + "Z").toString()],
1261
- "next-token": [, input.NextToken],
1262
- "page-size": [, input.PageSize],
1263
- "start-time": [
1264
- () => input.StartTime !== void 0,
1265
- () => (input.StartTime.toISOString().split(".")[0] + "Z").toString(),
1266
- ],
769
+ [_et]: [() => input.EndTime !== void 0, () => (input[_ET].toISOString().split(".")[0] + "Z").toString()],
770
+ [_nt]: [, input[_NT]],
771
+ [_ps]: [, input[_PS]],
772
+ [_st]: [() => input.StartTime !== void 0, () => (input[_ST].toISOString().split(".")[0] + "Z").toString()],
1267
773
  });
1268
774
  let body;
1269
- return new __HttpRequest({
1270
- protocol,
1271
- hostname,
1272
- port,
1273
- method: "GET",
1274
- headers,
1275
- path: resolvedPath,
1276
- query,
1277
- body,
1278
- });
775
+ b.m("GET").h(headers).q(query).b(body);
776
+ return b.build();
1279
777
  };
1280
778
  export const se_GetJourneyExecutionActivityMetricsCommand = async (input, context) => {
1281
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
779
+ const b = rb(input, context);
1282
780
  const headers = {};
1283
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1284
- "/v1/apps/{ApplicationId}/journeys/{JourneyId}/activities/{JourneyActivityId}/execution-metrics";
1285
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1286
- resolvedPath = __resolvedPath(resolvedPath, input, "JourneyActivityId", () => input.JourneyActivityId, "{JourneyActivityId}", false);
1287
- resolvedPath = __resolvedPath(resolvedPath, input, "JourneyId", () => input.JourneyId, "{JourneyId}", false);
781
+ b.bp("/v1/apps/{ApplicationId}/journeys/{JourneyId}/activities/{JourneyActivityId}/execution-metrics");
782
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
783
+ b.p("JourneyActivityId", () => input.JourneyActivityId, "{JourneyActivityId}", false);
784
+ b.p("JourneyId", () => input.JourneyId, "{JourneyId}", false);
1288
785
  const query = map({
1289
- "next-token": [, input.NextToken],
1290
- "page-size": [, input.PageSize],
786
+ [_nt]: [, input[_NT]],
787
+ [_ps]: [, input[_PS]],
1291
788
  });
1292
789
  let body;
1293
- return new __HttpRequest({
1294
- protocol,
1295
- hostname,
1296
- port,
1297
- method: "GET",
1298
- headers,
1299
- path: resolvedPath,
1300
- query,
1301
- body,
1302
- });
790
+ b.m("GET").h(headers).q(query).b(body);
791
+ return b.build();
1303
792
  };
1304
793
  export const se_GetJourneyExecutionMetricsCommand = async (input, context) => {
1305
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
794
+ const b = rb(input, context);
1306
795
  const headers = {};
1307
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1308
- "/v1/apps/{ApplicationId}/journeys/{JourneyId}/execution-metrics";
1309
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1310
- resolvedPath = __resolvedPath(resolvedPath, input, "JourneyId", () => input.JourneyId, "{JourneyId}", false);
796
+ b.bp("/v1/apps/{ApplicationId}/journeys/{JourneyId}/execution-metrics");
797
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
798
+ b.p("JourneyId", () => input.JourneyId, "{JourneyId}", false);
1311
799
  const query = map({
1312
- "next-token": [, input.NextToken],
1313
- "page-size": [, input.PageSize],
800
+ [_nt]: [, input[_NT]],
801
+ [_ps]: [, input[_PS]],
1314
802
  });
1315
803
  let body;
1316
- return new __HttpRequest({
1317
- protocol,
1318
- hostname,
1319
- port,
1320
- method: "GET",
1321
- headers,
1322
- path: resolvedPath,
1323
- query,
1324
- body,
1325
- });
804
+ b.m("GET").h(headers).q(query).b(body);
805
+ return b.build();
1326
806
  };
1327
807
  export const se_GetJourneyRunExecutionActivityMetricsCommand = async (input, context) => {
1328
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
808
+ const b = rb(input, context);
1329
809
  const headers = {};
1330
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1331
- "/v1/apps/{ApplicationId}/journeys/{JourneyId}/runs/{RunId}/activities/{JourneyActivityId}/execution-metrics";
1332
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1333
- resolvedPath = __resolvedPath(resolvedPath, input, "JourneyActivityId", () => input.JourneyActivityId, "{JourneyActivityId}", false);
1334
- resolvedPath = __resolvedPath(resolvedPath, input, "JourneyId", () => input.JourneyId, "{JourneyId}", false);
1335
- resolvedPath = __resolvedPath(resolvedPath, input, "RunId", () => input.RunId, "{RunId}", false);
810
+ b.bp("/v1/apps/{ApplicationId}/journeys/{JourneyId}/runs/{RunId}/activities/{JourneyActivityId}/execution-metrics");
811
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
812
+ b.p("JourneyActivityId", () => input.JourneyActivityId, "{JourneyActivityId}", false);
813
+ b.p("JourneyId", () => input.JourneyId, "{JourneyId}", false);
814
+ b.p("RunId", () => input.RunId, "{RunId}", false);
1336
815
  const query = map({
1337
- "next-token": [, input.NextToken],
1338
- "page-size": [, input.PageSize],
816
+ [_nt]: [, input[_NT]],
817
+ [_ps]: [, input[_PS]],
1339
818
  });
1340
819
  let body;
1341
- return new __HttpRequest({
1342
- protocol,
1343
- hostname,
1344
- port,
1345
- method: "GET",
1346
- headers,
1347
- path: resolvedPath,
1348
- query,
1349
- body,
1350
- });
820
+ b.m("GET").h(headers).q(query).b(body);
821
+ return b.build();
1351
822
  };
1352
823
  export const se_GetJourneyRunExecutionMetricsCommand = async (input, context) => {
1353
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
824
+ const b = rb(input, context);
1354
825
  const headers = {};
1355
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1356
- "/v1/apps/{ApplicationId}/journeys/{JourneyId}/runs/{RunId}/execution-metrics";
1357
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1358
- resolvedPath = __resolvedPath(resolvedPath, input, "JourneyId", () => input.JourneyId, "{JourneyId}", false);
1359
- resolvedPath = __resolvedPath(resolvedPath, input, "RunId", () => input.RunId, "{RunId}", false);
826
+ b.bp("/v1/apps/{ApplicationId}/journeys/{JourneyId}/runs/{RunId}/execution-metrics");
827
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
828
+ b.p("JourneyId", () => input.JourneyId, "{JourneyId}", false);
829
+ b.p("RunId", () => input.RunId, "{RunId}", false);
1360
830
  const query = map({
1361
- "next-token": [, input.NextToken],
1362
- "page-size": [, input.PageSize],
831
+ [_nt]: [, input[_NT]],
832
+ [_ps]: [, input[_PS]],
1363
833
  });
1364
834
  let body;
1365
- return new __HttpRequest({
1366
- protocol,
1367
- hostname,
1368
- port,
1369
- method: "GET",
1370
- headers,
1371
- path: resolvedPath,
1372
- query,
1373
- body,
1374
- });
835
+ b.m("GET").h(headers).q(query).b(body);
836
+ return b.build();
1375
837
  };
1376
838
  export const se_GetJourneyRunsCommand = async (input, context) => {
1377
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
839
+ const b = rb(input, context);
1378
840
  const headers = {};
1379
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1380
- "/v1/apps/{ApplicationId}/journeys/{JourneyId}/runs";
1381
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1382
- resolvedPath = __resolvedPath(resolvedPath, input, "JourneyId", () => input.JourneyId, "{JourneyId}", false);
841
+ b.bp("/v1/apps/{ApplicationId}/journeys/{JourneyId}/runs");
842
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
843
+ b.p("JourneyId", () => input.JourneyId, "{JourneyId}", false);
1383
844
  const query = map({
1384
- "page-size": [, input.PageSize],
1385
- token: [, input.Token],
845
+ [_ps]: [, input[_PS]],
846
+ [_t]: [, input[_T]],
1386
847
  });
1387
848
  let body;
1388
- return new __HttpRequest({
1389
- protocol,
1390
- hostname,
1391
- port,
1392
- method: "GET",
1393
- headers,
1394
- path: resolvedPath,
1395
- query,
1396
- body,
1397
- });
849
+ b.m("GET").h(headers).q(query).b(body);
850
+ return b.build();
1398
851
  };
1399
852
  export const se_GetPushTemplateCommand = async (input, context) => {
1400
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
853
+ const b = rb(input, context);
1401
854
  const headers = {};
1402
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/push";
1403
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
855
+ b.bp("/v1/templates/{TemplateName}/push");
856
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
1404
857
  const query = map({
1405
- version: [, input.Version],
858
+ [_v]: [, input[_V]],
1406
859
  });
1407
860
  let body;
1408
- return new __HttpRequest({
1409
- protocol,
1410
- hostname,
1411
- port,
1412
- method: "GET",
1413
- headers,
1414
- path: resolvedPath,
1415
- query,
1416
- body,
1417
- });
861
+ b.m("GET").h(headers).q(query).b(body);
862
+ return b.build();
1418
863
  };
1419
864
  export const se_GetRecommenderConfigurationCommand = async (input, context) => {
1420
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
865
+ const b = rb(input, context);
1421
866
  const headers = {};
1422
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/recommenders/{RecommenderId}";
1423
- resolvedPath = __resolvedPath(resolvedPath, input, "RecommenderId", () => input.RecommenderId, "{RecommenderId}", false);
867
+ b.bp("/v1/recommenders/{RecommenderId}");
868
+ b.p("RecommenderId", () => input.RecommenderId, "{RecommenderId}", false);
1424
869
  let body;
1425
- return new __HttpRequest({
1426
- protocol,
1427
- hostname,
1428
- port,
1429
- method: "GET",
1430
- headers,
1431
- path: resolvedPath,
1432
- body,
1433
- });
870
+ b.m("GET").h(headers).b(body);
871
+ return b.build();
1434
872
  };
1435
873
  export const se_GetRecommenderConfigurationsCommand = async (input, context) => {
1436
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
874
+ const b = rb(input, context);
1437
875
  const headers = {};
1438
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/recommenders";
876
+ b.bp("/v1/recommenders");
1439
877
  const query = map({
1440
- "page-size": [, input.PageSize],
1441
- token: [, input.Token],
878
+ [_ps]: [, input[_PS]],
879
+ [_t]: [, input[_T]],
1442
880
  });
1443
881
  let body;
1444
- return new __HttpRequest({
1445
- protocol,
1446
- hostname,
1447
- port,
1448
- method: "GET",
1449
- headers,
1450
- path: resolvedPath,
1451
- query,
1452
- body,
1453
- });
882
+ b.m("GET").h(headers).q(query).b(body);
883
+ return b.build();
1454
884
  };
1455
885
  export const se_GetSegmentCommand = async (input, context) => {
1456
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
886
+ const b = rb(input, context);
1457
887
  const headers = {};
1458
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1459
- "/v1/apps/{ApplicationId}/segments/{SegmentId}";
1460
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1461
- resolvedPath = __resolvedPath(resolvedPath, input, "SegmentId", () => input.SegmentId, "{SegmentId}", false);
888
+ b.bp("/v1/apps/{ApplicationId}/segments/{SegmentId}");
889
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
890
+ b.p("SegmentId", () => input.SegmentId, "{SegmentId}", false);
1462
891
  let body;
1463
- return new __HttpRequest({
1464
- protocol,
1465
- hostname,
1466
- port,
1467
- method: "GET",
1468
- headers,
1469
- path: resolvedPath,
1470
- body,
1471
- });
892
+ b.m("GET").h(headers).b(body);
893
+ return b.build();
1472
894
  };
1473
895
  export const se_GetSegmentExportJobsCommand = async (input, context) => {
1474
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
896
+ const b = rb(input, context);
1475
897
  const headers = {};
1476
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1477
- "/v1/apps/{ApplicationId}/segments/{SegmentId}/jobs/export";
1478
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1479
- resolvedPath = __resolvedPath(resolvedPath, input, "SegmentId", () => input.SegmentId, "{SegmentId}", false);
898
+ b.bp("/v1/apps/{ApplicationId}/segments/{SegmentId}/jobs/export");
899
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
900
+ b.p("SegmentId", () => input.SegmentId, "{SegmentId}", false);
1480
901
  const query = map({
1481
- "page-size": [, input.PageSize],
1482
- token: [, input.Token],
902
+ [_ps]: [, input[_PS]],
903
+ [_t]: [, input[_T]],
1483
904
  });
1484
905
  let body;
1485
- return new __HttpRequest({
1486
- protocol,
1487
- hostname,
1488
- port,
1489
- method: "GET",
1490
- headers,
1491
- path: resolvedPath,
1492
- query,
1493
- body,
1494
- });
906
+ b.m("GET").h(headers).q(query).b(body);
907
+ return b.build();
1495
908
  };
1496
909
  export const se_GetSegmentImportJobsCommand = async (input, context) => {
1497
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
910
+ const b = rb(input, context);
1498
911
  const headers = {};
1499
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1500
- "/v1/apps/{ApplicationId}/segments/{SegmentId}/jobs/import";
1501
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1502
- resolvedPath = __resolvedPath(resolvedPath, input, "SegmentId", () => input.SegmentId, "{SegmentId}", false);
912
+ b.bp("/v1/apps/{ApplicationId}/segments/{SegmentId}/jobs/import");
913
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
914
+ b.p("SegmentId", () => input.SegmentId, "{SegmentId}", false);
1503
915
  const query = map({
1504
- "page-size": [, input.PageSize],
1505
- token: [, input.Token],
916
+ [_ps]: [, input[_PS]],
917
+ [_t]: [, input[_T]],
1506
918
  });
1507
919
  let body;
1508
- return new __HttpRequest({
1509
- protocol,
1510
- hostname,
1511
- port,
1512
- method: "GET",
1513
- headers,
1514
- path: resolvedPath,
1515
- query,
1516
- body,
1517
- });
920
+ b.m("GET").h(headers).q(query).b(body);
921
+ return b.build();
1518
922
  };
1519
923
  export const se_GetSegmentsCommand = async (input, context) => {
1520
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
924
+ const b = rb(input, context);
1521
925
  const headers = {};
1522
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/segments";
1523
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
926
+ b.bp("/v1/apps/{ApplicationId}/segments");
927
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1524
928
  const query = map({
1525
- "page-size": [, input.PageSize],
1526
- token: [, input.Token],
929
+ [_ps]: [, input[_PS]],
930
+ [_t]: [, input[_T]],
1527
931
  });
1528
932
  let body;
1529
- return new __HttpRequest({
1530
- protocol,
1531
- hostname,
1532
- port,
1533
- method: "GET",
1534
- headers,
1535
- path: resolvedPath,
1536
- query,
1537
- body,
1538
- });
933
+ b.m("GET").h(headers).q(query).b(body);
934
+ return b.build();
1539
935
  };
1540
936
  export const se_GetSegmentVersionCommand = async (input, context) => {
1541
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
937
+ const b = rb(input, context);
1542
938
  const headers = {};
1543
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1544
- "/v1/apps/{ApplicationId}/segments/{SegmentId}/versions/{Version}";
1545
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1546
- resolvedPath = __resolvedPath(resolvedPath, input, "SegmentId", () => input.SegmentId, "{SegmentId}", false);
1547
- resolvedPath = __resolvedPath(resolvedPath, input, "Version", () => input.Version, "{Version}", false);
939
+ b.bp("/v1/apps/{ApplicationId}/segments/{SegmentId}/versions/{Version}");
940
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
941
+ b.p("SegmentId", () => input.SegmentId, "{SegmentId}", false);
942
+ b.p("Version", () => input.Version, "{Version}", false);
1548
943
  let body;
1549
- return new __HttpRequest({
1550
- protocol,
1551
- hostname,
1552
- port,
1553
- method: "GET",
1554
- headers,
1555
- path: resolvedPath,
1556
- body,
1557
- });
944
+ b.m("GET").h(headers).b(body);
945
+ return b.build();
1558
946
  };
1559
947
  export const se_GetSegmentVersionsCommand = async (input, context) => {
1560
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
948
+ const b = rb(input, context);
1561
949
  const headers = {};
1562
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1563
- "/v1/apps/{ApplicationId}/segments/{SegmentId}/versions";
1564
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1565
- resolvedPath = __resolvedPath(resolvedPath, input, "SegmentId", () => input.SegmentId, "{SegmentId}", false);
950
+ b.bp("/v1/apps/{ApplicationId}/segments/{SegmentId}/versions");
951
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
952
+ b.p("SegmentId", () => input.SegmentId, "{SegmentId}", false);
1566
953
  const query = map({
1567
- "page-size": [, input.PageSize],
1568
- token: [, input.Token],
954
+ [_ps]: [, input[_PS]],
955
+ [_t]: [, input[_T]],
1569
956
  });
1570
957
  let body;
1571
- return new __HttpRequest({
1572
- protocol,
1573
- hostname,
1574
- port,
1575
- method: "GET",
1576
- headers,
1577
- path: resolvedPath,
1578
- query,
1579
- body,
1580
- });
958
+ b.m("GET").h(headers).q(query).b(body);
959
+ return b.build();
1581
960
  };
1582
961
  export const se_GetSmsChannelCommand = async (input, context) => {
1583
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
962
+ const b = rb(input, context);
1584
963
  const headers = {};
1585
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/sms";
1586
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
964
+ b.bp("/v1/apps/{ApplicationId}/channels/sms");
965
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1587
966
  let body;
1588
- return new __HttpRequest({
1589
- protocol,
1590
- hostname,
1591
- port,
1592
- method: "GET",
1593
- headers,
1594
- path: resolvedPath,
1595
- body,
1596
- });
967
+ b.m("GET").h(headers).b(body);
968
+ return b.build();
1597
969
  };
1598
970
  export const se_GetSmsTemplateCommand = async (input, context) => {
1599
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
971
+ const b = rb(input, context);
1600
972
  const headers = {};
1601
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/sms";
1602
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
973
+ b.bp("/v1/templates/{TemplateName}/sms");
974
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
1603
975
  const query = map({
1604
- version: [, input.Version],
976
+ [_v]: [, input[_V]],
1605
977
  });
1606
978
  let body;
1607
- return new __HttpRequest({
1608
- protocol,
1609
- hostname,
1610
- port,
1611
- method: "GET",
1612
- headers,
1613
- path: resolvedPath,
1614
- query,
1615
- body,
1616
- });
979
+ b.m("GET").h(headers).q(query).b(body);
980
+ return b.build();
1617
981
  };
1618
982
  export const se_GetUserEndpointsCommand = async (input, context) => {
1619
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
983
+ const b = rb(input, context);
1620
984
  const headers = {};
1621
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/users/{UserId}";
1622
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1623
- resolvedPath = __resolvedPath(resolvedPath, input, "UserId", () => input.UserId, "{UserId}", false);
985
+ b.bp("/v1/apps/{ApplicationId}/users/{UserId}");
986
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
987
+ b.p("UserId", () => input.UserId, "{UserId}", false);
1624
988
  let body;
1625
- return new __HttpRequest({
1626
- protocol,
1627
- hostname,
1628
- port,
1629
- method: "GET",
1630
- headers,
1631
- path: resolvedPath,
1632
- body,
1633
- });
989
+ b.m("GET").h(headers).b(body);
990
+ return b.build();
1634
991
  };
1635
992
  export const se_GetVoiceChannelCommand = async (input, context) => {
1636
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
993
+ const b = rb(input, context);
1637
994
  const headers = {};
1638
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/voice";
1639
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
995
+ b.bp("/v1/apps/{ApplicationId}/channels/voice");
996
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1640
997
  let body;
1641
- return new __HttpRequest({
1642
- protocol,
1643
- hostname,
1644
- port,
1645
- method: "GET",
1646
- headers,
1647
- path: resolvedPath,
1648
- body,
1649
- });
998
+ b.m("GET").h(headers).b(body);
999
+ return b.build();
1650
1000
  };
1651
1001
  export const se_GetVoiceTemplateCommand = async (input, context) => {
1652
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1002
+ const b = rb(input, context);
1653
1003
  const headers = {};
1654
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/voice";
1655
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
1004
+ b.bp("/v1/templates/{TemplateName}/voice");
1005
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
1656
1006
  const query = map({
1657
- version: [, input.Version],
1007
+ [_v]: [, input[_V]],
1658
1008
  });
1659
1009
  let body;
1660
- return new __HttpRequest({
1661
- protocol,
1662
- hostname,
1663
- port,
1664
- method: "GET",
1665
- headers,
1666
- path: resolvedPath,
1667
- query,
1668
- body,
1669
- });
1010
+ b.m("GET").h(headers).q(query).b(body);
1011
+ return b.build();
1670
1012
  };
1671
1013
  export const se_ListJourneysCommand = async (input, context) => {
1672
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1014
+ const b = rb(input, context);
1673
1015
  const headers = {};
1674
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/journeys";
1675
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1016
+ b.bp("/v1/apps/{ApplicationId}/journeys");
1017
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1676
1018
  const query = map({
1677
- "page-size": [, input.PageSize],
1678
- token: [, input.Token],
1019
+ [_ps]: [, input[_PS]],
1020
+ [_t]: [, input[_T]],
1679
1021
  });
1680
1022
  let body;
1681
- return new __HttpRequest({
1682
- protocol,
1683
- hostname,
1684
- port,
1685
- method: "GET",
1686
- headers,
1687
- path: resolvedPath,
1688
- query,
1689
- body,
1690
- });
1023
+ b.m("GET").h(headers).q(query).b(body);
1024
+ return b.build();
1691
1025
  };
1692
1026
  export const se_ListTagsForResourceCommand = async (input, context) => {
1693
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1027
+ const b = rb(input, context);
1694
1028
  const headers = {};
1695
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/tags/{ResourceArn}";
1696
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1029
+ b.bp("/v1/tags/{ResourceArn}");
1030
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1697
1031
  let body;
1698
- return new __HttpRequest({
1699
- protocol,
1700
- hostname,
1701
- port,
1702
- method: "GET",
1703
- headers,
1704
- path: resolvedPath,
1705
- body,
1706
- });
1032
+ b.m("GET").h(headers).b(body);
1033
+ return b.build();
1707
1034
  };
1708
1035
  export const se_ListTemplatesCommand = async (input, context) => {
1709
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1036
+ const b = rb(input, context);
1710
1037
  const headers = {};
1711
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates";
1038
+ b.bp("/v1/templates");
1712
1039
  const query = map({
1713
- "next-token": [, input.NextToken],
1714
- "page-size": [, input.PageSize],
1715
- prefix: [, input.Prefix],
1716
- "template-type": [, input.TemplateType],
1040
+ [_nt]: [, input[_NT]],
1041
+ [_ps]: [, input[_PS]],
1042
+ [_p]: [, input[_P]],
1043
+ [_tt]: [, input[_TT]],
1717
1044
  });
1718
1045
  let body;
1719
- return new __HttpRequest({
1720
- protocol,
1721
- hostname,
1722
- port,
1723
- method: "GET",
1724
- headers,
1725
- path: resolvedPath,
1726
- query,
1727
- body,
1728
- });
1046
+ b.m("GET").h(headers).q(query).b(body);
1047
+ return b.build();
1729
1048
  };
1730
1049
  export const se_ListTemplateVersionsCommand = async (input, context) => {
1731
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1050
+ const b = rb(input, context);
1732
1051
  const headers = {};
1733
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1734
- "/v1/templates/{TemplateName}/{TemplateType}/versions";
1735
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
1736
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateType", () => input.TemplateType, "{TemplateType}", false);
1052
+ b.bp("/v1/templates/{TemplateName}/{TemplateType}/versions");
1053
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
1054
+ b.p("TemplateType", () => input.TemplateType, "{TemplateType}", false);
1737
1055
  const query = map({
1738
- "next-token": [, input.NextToken],
1739
- "page-size": [, input.PageSize],
1056
+ [_nt]: [, input[_NT]],
1057
+ [_ps]: [, input[_PS]],
1740
1058
  });
1741
1059
  let body;
1742
- return new __HttpRequest({
1743
- protocol,
1744
- hostname,
1745
- port,
1746
- method: "GET",
1747
- headers,
1748
- path: resolvedPath,
1749
- query,
1750
- body,
1751
- });
1060
+ b.m("GET").h(headers).q(query).b(body);
1061
+ return b.build();
1752
1062
  };
1753
1063
  export const se_PhoneNumberValidateCommand = async (input, context) => {
1754
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1064
+ const b = rb(input, context);
1755
1065
  const headers = {
1756
1066
  "content-type": "application/json",
1757
1067
  };
1758
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/phone/number/validate";
1068
+ b.bp("/v1/phone/number/validate");
1759
1069
  let body;
1760
1070
  if (input.NumberValidateRequest !== undefined) {
1761
1071
  body = _json(input.NumberValidateRequest);
@@ -1764,23 +1074,16 @@ export const se_PhoneNumberValidateCommand = async (input, context) => {
1764
1074
  body = {};
1765
1075
  }
1766
1076
  body = JSON.stringify(body);
1767
- return new __HttpRequest({
1768
- protocol,
1769
- hostname,
1770
- port,
1771
- method: "POST",
1772
- headers,
1773
- path: resolvedPath,
1774
- body,
1775
- });
1077
+ b.m("POST").h(headers).b(body);
1078
+ return b.build();
1776
1079
  };
1777
1080
  export const se_PutEventsCommand = async (input, context) => {
1778
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1081
+ const b = rb(input, context);
1779
1082
  const headers = {
1780
1083
  "content-type": "application/json",
1781
1084
  };
1782
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/events";
1783
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1085
+ b.bp("/v1/apps/{ApplicationId}/events");
1086
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1784
1087
  let body;
1785
1088
  if (input.EventsRequest !== undefined) {
1786
1089
  body = se_EventsRequest(input.EventsRequest, context);
@@ -1789,23 +1092,16 @@ export const se_PutEventsCommand = async (input, context) => {
1789
1092
  body = {};
1790
1093
  }
1791
1094
  body = JSON.stringify(body);
1792
- return new __HttpRequest({
1793
- protocol,
1794
- hostname,
1795
- port,
1796
- method: "POST",
1797
- headers,
1798
- path: resolvedPath,
1799
- body,
1800
- });
1095
+ b.m("POST").h(headers).b(body);
1096
+ return b.build();
1801
1097
  };
1802
1098
  export const se_PutEventStreamCommand = async (input, context) => {
1803
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1099
+ const b = rb(input, context);
1804
1100
  const headers = {
1805
1101
  "content-type": "application/json",
1806
1102
  };
1807
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/eventstream";
1808
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1103
+ b.bp("/v1/apps/{ApplicationId}/eventstream");
1104
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1809
1105
  let body;
1810
1106
  if (input.WriteEventStream !== undefined) {
1811
1107
  body = _json(input.WriteEventStream);
@@ -1814,25 +1110,17 @@ export const se_PutEventStreamCommand = async (input, context) => {
1814
1110
  body = {};
1815
1111
  }
1816
1112
  body = JSON.stringify(body);
1817
- return new __HttpRequest({
1818
- protocol,
1819
- hostname,
1820
- port,
1821
- method: "POST",
1822
- headers,
1823
- path: resolvedPath,
1824
- body,
1825
- });
1113
+ b.m("POST").h(headers).b(body);
1114
+ return b.build();
1826
1115
  };
1827
1116
  export const se_RemoveAttributesCommand = async (input, context) => {
1828
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1117
+ const b = rb(input, context);
1829
1118
  const headers = {
1830
1119
  "content-type": "application/json",
1831
1120
  };
1832
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1833
- "/v1/apps/{ApplicationId}/attributes/{AttributeType}";
1834
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1835
- resolvedPath = __resolvedPath(resolvedPath, input, "AttributeType", () => input.AttributeType, "{AttributeType}", false);
1121
+ b.bp("/v1/apps/{ApplicationId}/attributes/{AttributeType}");
1122
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1123
+ b.p("AttributeType", () => input.AttributeType, "{AttributeType}", false);
1836
1124
  let body;
1837
1125
  if (input.UpdateAttributesRequest !== undefined) {
1838
1126
  body = _json(input.UpdateAttributesRequest);
@@ -1841,23 +1129,16 @@ export const se_RemoveAttributesCommand = async (input, context) => {
1841
1129
  body = {};
1842
1130
  }
1843
1131
  body = JSON.stringify(body);
1844
- return new __HttpRequest({
1845
- protocol,
1846
- hostname,
1847
- port,
1848
- method: "PUT",
1849
- headers,
1850
- path: resolvedPath,
1851
- body,
1852
- });
1132
+ b.m("PUT").h(headers).b(body);
1133
+ return b.build();
1853
1134
  };
1854
1135
  export const se_SendMessagesCommand = async (input, context) => {
1855
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1136
+ const b = rb(input, context);
1856
1137
  const headers = {
1857
1138
  "content-type": "application/json",
1858
1139
  };
1859
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/messages";
1860
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1140
+ b.bp("/v1/apps/{ApplicationId}/messages");
1141
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1861
1142
  let body;
1862
1143
  if (input.MessageRequest !== undefined) {
1863
1144
  body = se_MessageRequest(input.MessageRequest, context);
@@ -1866,23 +1147,16 @@ export const se_SendMessagesCommand = async (input, context) => {
1866
1147
  body = {};
1867
1148
  }
1868
1149
  body = JSON.stringify(body);
1869
- return new __HttpRequest({
1870
- protocol,
1871
- hostname,
1872
- port,
1873
- method: "POST",
1874
- headers,
1875
- path: resolvedPath,
1876
- body,
1877
- });
1150
+ b.m("POST").h(headers).b(body);
1151
+ return b.build();
1878
1152
  };
1879
1153
  export const se_SendOTPMessageCommand = async (input, context) => {
1880
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1154
+ const b = rb(input, context);
1881
1155
  const headers = {
1882
1156
  "content-type": "application/json",
1883
1157
  };
1884
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/otp";
1885
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1158
+ b.bp("/v1/apps/{ApplicationId}/otp");
1159
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1886
1160
  let body;
1887
1161
  if (input.SendOTPMessageRequestParameters !== undefined) {
1888
1162
  body = _json(input.SendOTPMessageRequestParameters);
@@ -1891,23 +1165,16 @@ export const se_SendOTPMessageCommand = async (input, context) => {
1891
1165
  body = {};
1892
1166
  }
1893
1167
  body = JSON.stringify(body);
1894
- return new __HttpRequest({
1895
- protocol,
1896
- hostname,
1897
- port,
1898
- method: "POST",
1899
- headers,
1900
- path: resolvedPath,
1901
- body,
1902
- });
1168
+ b.m("POST").h(headers).b(body);
1169
+ return b.build();
1903
1170
  };
1904
1171
  export const se_SendUsersMessagesCommand = async (input, context) => {
1905
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1172
+ const b = rb(input, context);
1906
1173
  const headers = {
1907
1174
  "content-type": "application/json",
1908
1175
  };
1909
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/users-messages";
1910
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1176
+ b.bp("/v1/apps/{ApplicationId}/users-messages");
1177
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1911
1178
  let body;
1912
1179
  if (input.SendUsersMessageRequest !== undefined) {
1913
1180
  body = se_SendUsersMessageRequest(input.SendUsersMessageRequest, context);
@@ -1916,23 +1183,16 @@ export const se_SendUsersMessagesCommand = async (input, context) => {
1916
1183
  body = {};
1917
1184
  }
1918
1185
  body = JSON.stringify(body);
1919
- return new __HttpRequest({
1920
- protocol,
1921
- hostname,
1922
- port,
1923
- method: "POST",
1924
- headers,
1925
- path: resolvedPath,
1926
- body,
1927
- });
1186
+ b.m("POST").h(headers).b(body);
1187
+ return b.build();
1928
1188
  };
1929
1189
  export const se_TagResourceCommand = async (input, context) => {
1930
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1190
+ const b = rb(input, context);
1931
1191
  const headers = {
1932
1192
  "content-type": "application/json",
1933
1193
  };
1934
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/tags/{ResourceArn}";
1935
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1194
+ b.bp("/v1/tags/{ResourceArn}");
1195
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1936
1196
  let body;
1937
1197
  if (input.TagsModel !== undefined) {
1938
1198
  body = se_TagsModel(input.TagsModel, context);
@@ -1941,46 +1201,31 @@ export const se_TagResourceCommand = async (input, context) => {
1941
1201
  body = {};
1942
1202
  }
1943
1203
  body = JSON.stringify(body);
1944
- return new __HttpRequest({
1945
- protocol,
1946
- hostname,
1947
- port,
1948
- method: "POST",
1949
- headers,
1950
- path: resolvedPath,
1951
- body,
1952
- });
1204
+ b.m("POST").h(headers).b(body);
1205
+ return b.build();
1953
1206
  };
1954
1207
  export const se_UntagResourceCommand = async (input, context) => {
1955
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1208
+ const b = rb(input, context);
1956
1209
  const headers = {};
1957
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/tags/{ResourceArn}";
1958
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1210
+ b.bp("/v1/tags/{ResourceArn}");
1211
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1959
1212
  const query = map({
1960
- tagKeys: [
1213
+ [_tK]: [
1961
1214
  __expectNonNull(input.TagKeys, `TagKeys`) != null,
1962
- () => (input.TagKeys || []).map((_entry) => _entry),
1215
+ () => (input[_TK] || []).map((_entry) => _entry),
1963
1216
  ],
1964
1217
  });
1965
1218
  let body;
1966
- return new __HttpRequest({
1967
- protocol,
1968
- hostname,
1969
- port,
1970
- method: "DELETE",
1971
- headers,
1972
- path: resolvedPath,
1973
- query,
1974
- body,
1975
- });
1219
+ b.m("DELETE").h(headers).q(query).b(body);
1220
+ return b.build();
1976
1221
  };
1977
1222
  export const se_UpdateAdmChannelCommand = async (input, context) => {
1978
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1223
+ const b = rb(input, context);
1979
1224
  const headers = {
1980
1225
  "content-type": "application/json",
1981
1226
  };
1982
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/adm";
1983
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1227
+ b.bp("/v1/apps/{ApplicationId}/channels/adm");
1228
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1984
1229
  let body;
1985
1230
  if (input.ADMChannelRequest !== undefined) {
1986
1231
  body = _json(input.ADMChannelRequest);
@@ -1989,23 +1234,16 @@ export const se_UpdateAdmChannelCommand = async (input, context) => {
1989
1234
  body = {};
1990
1235
  }
1991
1236
  body = JSON.stringify(body);
1992
- return new __HttpRequest({
1993
- protocol,
1994
- hostname,
1995
- port,
1996
- method: "PUT",
1997
- headers,
1998
- path: resolvedPath,
1999
- body,
2000
- });
1237
+ b.m("PUT").h(headers).b(body);
1238
+ return b.build();
2001
1239
  };
2002
1240
  export const se_UpdateApnsChannelCommand = async (input, context) => {
2003
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1241
+ const b = rb(input, context);
2004
1242
  const headers = {
2005
1243
  "content-type": "application/json",
2006
1244
  };
2007
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/apns";
2008
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1245
+ b.bp("/v1/apps/{ApplicationId}/channels/apns");
1246
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2009
1247
  let body;
2010
1248
  if (input.APNSChannelRequest !== undefined) {
2011
1249
  body = _json(input.APNSChannelRequest);
@@ -2014,24 +1252,16 @@ export const se_UpdateApnsChannelCommand = async (input, context) => {
2014
1252
  body = {};
2015
1253
  }
2016
1254
  body = JSON.stringify(body);
2017
- return new __HttpRequest({
2018
- protocol,
2019
- hostname,
2020
- port,
2021
- method: "PUT",
2022
- headers,
2023
- path: resolvedPath,
2024
- body,
2025
- });
1255
+ b.m("PUT").h(headers).b(body);
1256
+ return b.build();
2026
1257
  };
2027
1258
  export const se_UpdateApnsSandboxChannelCommand = async (input, context) => {
2028
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1259
+ const b = rb(input, context);
2029
1260
  const headers = {
2030
1261
  "content-type": "application/json",
2031
1262
  };
2032
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2033
- "/v1/apps/{ApplicationId}/channels/apns_sandbox";
2034
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1263
+ b.bp("/v1/apps/{ApplicationId}/channels/apns_sandbox");
1264
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2035
1265
  let body;
2036
1266
  if (input.APNSSandboxChannelRequest !== undefined) {
2037
1267
  body = _json(input.APNSSandboxChannelRequest);
@@ -2040,24 +1270,16 @@ export const se_UpdateApnsSandboxChannelCommand = async (input, context) => {
2040
1270
  body = {};
2041
1271
  }
2042
1272
  body = JSON.stringify(body);
2043
- return new __HttpRequest({
2044
- protocol,
2045
- hostname,
2046
- port,
2047
- method: "PUT",
2048
- headers,
2049
- path: resolvedPath,
2050
- body,
2051
- });
1273
+ b.m("PUT").h(headers).b(body);
1274
+ return b.build();
2052
1275
  };
2053
1276
  export const se_UpdateApnsVoipChannelCommand = async (input, context) => {
2054
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1277
+ const b = rb(input, context);
2055
1278
  const headers = {
2056
1279
  "content-type": "application/json",
2057
1280
  };
2058
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2059
- "/v1/apps/{ApplicationId}/channels/apns_voip";
2060
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1281
+ b.bp("/v1/apps/{ApplicationId}/channels/apns_voip");
1282
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2061
1283
  let body;
2062
1284
  if (input.APNSVoipChannelRequest !== undefined) {
2063
1285
  body = _json(input.APNSVoipChannelRequest);
@@ -2066,24 +1288,16 @@ export const se_UpdateApnsVoipChannelCommand = async (input, context) => {
2066
1288
  body = {};
2067
1289
  }
2068
1290
  body = JSON.stringify(body);
2069
- return new __HttpRequest({
2070
- protocol,
2071
- hostname,
2072
- port,
2073
- method: "PUT",
2074
- headers,
2075
- path: resolvedPath,
2076
- body,
2077
- });
1291
+ b.m("PUT").h(headers).b(body);
1292
+ return b.build();
2078
1293
  };
2079
1294
  export const se_UpdateApnsVoipSandboxChannelCommand = async (input, context) => {
2080
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1295
+ const b = rb(input, context);
2081
1296
  const headers = {
2082
1297
  "content-type": "application/json",
2083
1298
  };
2084
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2085
- "/v1/apps/{ApplicationId}/channels/apns_voip_sandbox";
2086
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1299
+ b.bp("/v1/apps/{ApplicationId}/channels/apns_voip_sandbox");
1300
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2087
1301
  let body;
2088
1302
  if (input.APNSVoipSandboxChannelRequest !== undefined) {
2089
1303
  body = _json(input.APNSVoipSandboxChannelRequest);
@@ -2092,23 +1306,16 @@ export const se_UpdateApnsVoipSandboxChannelCommand = async (input, context) =>
2092
1306
  body = {};
2093
1307
  }
2094
1308
  body = JSON.stringify(body);
2095
- return new __HttpRequest({
2096
- protocol,
2097
- hostname,
2098
- port,
2099
- method: "PUT",
2100
- headers,
2101
- path: resolvedPath,
2102
- body,
2103
- });
1309
+ b.m("PUT").h(headers).b(body);
1310
+ return b.build();
2104
1311
  };
2105
1312
  export const se_UpdateApplicationSettingsCommand = async (input, context) => {
2106
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1313
+ const b = rb(input, context);
2107
1314
  const headers = {
2108
1315
  "content-type": "application/json",
2109
1316
  };
2110
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/settings";
2111
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1317
+ b.bp("/v1/apps/{ApplicationId}/settings");
1318
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2112
1319
  let body;
2113
1320
  if (input.WriteApplicationSettingsRequest !== undefined) {
2114
1321
  body = _json(input.WriteApplicationSettingsRequest);
@@ -2117,23 +1324,16 @@ export const se_UpdateApplicationSettingsCommand = async (input, context) => {
2117
1324
  body = {};
2118
1325
  }
2119
1326
  body = JSON.stringify(body);
2120
- return new __HttpRequest({
2121
- protocol,
2122
- hostname,
2123
- port,
2124
- method: "PUT",
2125
- headers,
2126
- path: resolvedPath,
2127
- body,
2128
- });
1327
+ b.m("PUT").h(headers).b(body);
1328
+ return b.build();
2129
1329
  };
2130
1330
  export const se_UpdateBaiduChannelCommand = async (input, context) => {
2131
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1331
+ const b = rb(input, context);
2132
1332
  const headers = {
2133
1333
  "content-type": "application/json",
2134
1334
  };
2135
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/baidu";
2136
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1335
+ b.bp("/v1/apps/{ApplicationId}/channels/baidu");
1336
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2137
1337
  let body;
2138
1338
  if (input.BaiduChannelRequest !== undefined) {
2139
1339
  body = _json(input.BaiduChannelRequest);
@@ -2142,25 +1342,17 @@ export const se_UpdateBaiduChannelCommand = async (input, context) => {
2142
1342
  body = {};
2143
1343
  }
2144
1344
  body = JSON.stringify(body);
2145
- return new __HttpRequest({
2146
- protocol,
2147
- hostname,
2148
- port,
2149
- method: "PUT",
2150
- headers,
2151
- path: resolvedPath,
2152
- body,
2153
- });
1345
+ b.m("PUT").h(headers).b(body);
1346
+ return b.build();
2154
1347
  };
2155
1348
  export const se_UpdateCampaignCommand = async (input, context) => {
2156
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1349
+ const b = rb(input, context);
2157
1350
  const headers = {
2158
1351
  "content-type": "application/json",
2159
1352
  };
2160
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2161
- "/v1/apps/{ApplicationId}/campaigns/{CampaignId}";
2162
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2163
- resolvedPath = __resolvedPath(resolvedPath, input, "CampaignId", () => input.CampaignId, "{CampaignId}", false);
1353
+ b.bp("/v1/apps/{ApplicationId}/campaigns/{CampaignId}");
1354
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1355
+ b.p("CampaignId", () => input.CampaignId, "{CampaignId}", false);
2164
1356
  let body;
2165
1357
  if (input.WriteCampaignRequest !== undefined) {
2166
1358
  body = se_WriteCampaignRequest(input.WriteCampaignRequest, context);
@@ -2169,23 +1361,16 @@ export const se_UpdateCampaignCommand = async (input, context) => {
2169
1361
  body = {};
2170
1362
  }
2171
1363
  body = JSON.stringify(body);
2172
- return new __HttpRequest({
2173
- protocol,
2174
- hostname,
2175
- port,
2176
- method: "PUT",
2177
- headers,
2178
- path: resolvedPath,
2179
- body,
2180
- });
1364
+ b.m("PUT").h(headers).b(body);
1365
+ return b.build();
2181
1366
  };
2182
1367
  export const se_UpdateEmailChannelCommand = async (input, context) => {
2183
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1368
+ const b = rb(input, context);
2184
1369
  const headers = {
2185
1370
  "content-type": "application/json",
2186
1371
  };
2187
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/email";
2188
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1372
+ b.bp("/v1/apps/{ApplicationId}/channels/email");
1373
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2189
1374
  let body;
2190
1375
  if (input.EmailChannelRequest !== undefined) {
2191
1376
  body = _json(input.EmailChannelRequest);
@@ -2194,26 +1379,19 @@ export const se_UpdateEmailChannelCommand = async (input, context) => {
2194
1379
  body = {};
2195
1380
  }
2196
1381
  body = JSON.stringify(body);
2197
- return new __HttpRequest({
2198
- protocol,
2199
- hostname,
2200
- port,
2201
- method: "PUT",
2202
- headers,
2203
- path: resolvedPath,
2204
- body,
2205
- });
1382
+ b.m("PUT").h(headers).b(body);
1383
+ return b.build();
2206
1384
  };
2207
1385
  export const se_UpdateEmailTemplateCommand = async (input, context) => {
2208
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1386
+ const b = rb(input, context);
2209
1387
  const headers = {
2210
1388
  "content-type": "application/json",
2211
1389
  };
2212
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/email";
2213
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
1390
+ b.bp("/v1/templates/{TemplateName}/email");
1391
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
2214
1392
  const query = map({
2215
- "create-new-version": [() => input.CreateNewVersion !== void 0, () => input.CreateNewVersion.toString()],
2216
- version: [, input.Version],
1393
+ [_cnv]: [() => input.CreateNewVersion !== void 0, () => input[_CNV].toString()],
1394
+ [_v]: [, input[_V]],
2217
1395
  });
2218
1396
  let body;
2219
1397
  if (input.EmailTemplateRequest !== undefined) {
@@ -2223,26 +1401,17 @@ export const se_UpdateEmailTemplateCommand = async (input, context) => {
2223
1401
  body = {};
2224
1402
  }
2225
1403
  body = JSON.stringify(body);
2226
- return new __HttpRequest({
2227
- protocol,
2228
- hostname,
2229
- port,
2230
- method: "PUT",
2231
- headers,
2232
- path: resolvedPath,
2233
- query,
2234
- body,
2235
- });
1404
+ b.m("PUT").h(headers).q(query).b(body);
1405
+ return b.build();
2236
1406
  };
2237
1407
  export const se_UpdateEndpointCommand = async (input, context) => {
2238
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1408
+ const b = rb(input, context);
2239
1409
  const headers = {
2240
1410
  "content-type": "application/json",
2241
1411
  };
2242
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2243
- "/v1/apps/{ApplicationId}/endpoints/{EndpointId}";
2244
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2245
- resolvedPath = __resolvedPath(resolvedPath, input, "EndpointId", () => input.EndpointId, "{EndpointId}", false);
1412
+ b.bp("/v1/apps/{ApplicationId}/endpoints/{EndpointId}");
1413
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1414
+ b.p("EndpointId", () => input.EndpointId, "{EndpointId}", false);
2246
1415
  let body;
2247
1416
  if (input.EndpointRequest !== undefined) {
2248
1417
  body = se_EndpointRequest(input.EndpointRequest, context);
@@ -2251,23 +1420,16 @@ export const se_UpdateEndpointCommand = async (input, context) => {
2251
1420
  body = {};
2252
1421
  }
2253
1422
  body = JSON.stringify(body);
2254
- return new __HttpRequest({
2255
- protocol,
2256
- hostname,
2257
- port,
2258
- method: "PUT",
2259
- headers,
2260
- path: resolvedPath,
2261
- body,
2262
- });
1423
+ b.m("PUT").h(headers).b(body);
1424
+ return b.build();
2263
1425
  };
2264
1426
  export const se_UpdateEndpointsBatchCommand = async (input, context) => {
2265
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1427
+ const b = rb(input, context);
2266
1428
  const headers = {
2267
1429
  "content-type": "application/json",
2268
1430
  };
2269
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/endpoints";
2270
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1431
+ b.bp("/v1/apps/{ApplicationId}/endpoints");
1432
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2271
1433
  let body;
2272
1434
  if (input.EndpointBatchRequest !== undefined) {
2273
1435
  body = se_EndpointBatchRequest(input.EndpointBatchRequest, context);
@@ -2276,23 +1438,16 @@ export const se_UpdateEndpointsBatchCommand = async (input, context) => {
2276
1438
  body = {};
2277
1439
  }
2278
1440
  body = JSON.stringify(body);
2279
- return new __HttpRequest({
2280
- protocol,
2281
- hostname,
2282
- port,
2283
- method: "PUT",
2284
- headers,
2285
- path: resolvedPath,
2286
- body,
2287
- });
1441
+ b.m("PUT").h(headers).b(body);
1442
+ return b.build();
2288
1443
  };
2289
1444
  export const se_UpdateGcmChannelCommand = async (input, context) => {
2290
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1445
+ const b = rb(input, context);
2291
1446
  const headers = {
2292
1447
  "content-type": "application/json",
2293
1448
  };
2294
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/gcm";
2295
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1449
+ b.bp("/v1/apps/{ApplicationId}/channels/gcm");
1450
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2296
1451
  let body;
2297
1452
  if (input.GCMChannelRequest !== undefined) {
2298
1453
  body = _json(input.GCMChannelRequest);
@@ -2301,26 +1456,19 @@ export const se_UpdateGcmChannelCommand = async (input, context) => {
2301
1456
  body = {};
2302
1457
  }
2303
1458
  body = JSON.stringify(body);
2304
- return new __HttpRequest({
2305
- protocol,
2306
- hostname,
2307
- port,
2308
- method: "PUT",
2309
- headers,
2310
- path: resolvedPath,
2311
- body,
2312
- });
1459
+ b.m("PUT").h(headers).b(body);
1460
+ return b.build();
2313
1461
  };
2314
1462
  export const se_UpdateInAppTemplateCommand = async (input, context) => {
2315
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1463
+ const b = rb(input, context);
2316
1464
  const headers = {
2317
1465
  "content-type": "application/json",
2318
1466
  };
2319
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/inapp";
2320
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
1467
+ b.bp("/v1/templates/{TemplateName}/inapp");
1468
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
2321
1469
  const query = map({
2322
- "create-new-version": [() => input.CreateNewVersion !== void 0, () => input.CreateNewVersion.toString()],
2323
- version: [, input.Version],
1470
+ [_cnv]: [() => input.CreateNewVersion !== void 0, () => input[_CNV].toString()],
1471
+ [_v]: [, input[_V]],
2324
1472
  });
2325
1473
  let body;
2326
1474
  if (input.InAppTemplateRequest !== undefined) {
@@ -2330,26 +1478,17 @@ export const se_UpdateInAppTemplateCommand = async (input, context) => {
2330
1478
  body = {};
2331
1479
  }
2332
1480
  body = JSON.stringify(body);
2333
- return new __HttpRequest({
2334
- protocol,
2335
- hostname,
2336
- port,
2337
- method: "PUT",
2338
- headers,
2339
- path: resolvedPath,
2340
- query,
2341
- body,
2342
- });
1481
+ b.m("PUT").h(headers).q(query).b(body);
1482
+ return b.build();
2343
1483
  };
2344
1484
  export const se_UpdateJourneyCommand = async (input, context) => {
2345
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1485
+ const b = rb(input, context);
2346
1486
  const headers = {
2347
1487
  "content-type": "application/json",
2348
1488
  };
2349
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2350
- "/v1/apps/{ApplicationId}/journeys/{JourneyId}";
2351
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2352
- resolvedPath = __resolvedPath(resolvedPath, input, "JourneyId", () => input.JourneyId, "{JourneyId}", false);
1489
+ b.bp("/v1/apps/{ApplicationId}/journeys/{JourneyId}");
1490
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1491
+ b.p("JourneyId", () => input.JourneyId, "{JourneyId}", false);
2353
1492
  let body;
2354
1493
  if (input.WriteJourneyRequest !== undefined) {
2355
1494
  body = se_WriteJourneyRequest(input.WriteJourneyRequest, context);
@@ -2358,25 +1497,17 @@ export const se_UpdateJourneyCommand = async (input, context) => {
2358
1497
  body = {};
2359
1498
  }
2360
1499
  body = JSON.stringify(body);
2361
- return new __HttpRequest({
2362
- protocol,
2363
- hostname,
2364
- port,
2365
- method: "PUT",
2366
- headers,
2367
- path: resolvedPath,
2368
- body,
2369
- });
1500
+ b.m("PUT").h(headers).b(body);
1501
+ return b.build();
2370
1502
  };
2371
1503
  export const se_UpdateJourneyStateCommand = async (input, context) => {
2372
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1504
+ const b = rb(input, context);
2373
1505
  const headers = {
2374
1506
  "content-type": "application/json",
2375
1507
  };
2376
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2377
- "/v1/apps/{ApplicationId}/journeys/{JourneyId}/state";
2378
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2379
- resolvedPath = __resolvedPath(resolvedPath, input, "JourneyId", () => input.JourneyId, "{JourneyId}", false);
1508
+ b.bp("/v1/apps/{ApplicationId}/journeys/{JourneyId}/state");
1509
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1510
+ b.p("JourneyId", () => input.JourneyId, "{JourneyId}", false);
2380
1511
  let body;
2381
1512
  if (input.JourneyStateRequest !== undefined) {
2382
1513
  body = _json(input.JourneyStateRequest);
@@ -2385,26 +1516,19 @@ export const se_UpdateJourneyStateCommand = async (input, context) => {
2385
1516
  body = {};
2386
1517
  }
2387
1518
  body = JSON.stringify(body);
2388
- return new __HttpRequest({
2389
- protocol,
2390
- hostname,
2391
- port,
2392
- method: "PUT",
2393
- headers,
2394
- path: resolvedPath,
2395
- body,
2396
- });
1519
+ b.m("PUT").h(headers).b(body);
1520
+ return b.build();
2397
1521
  };
2398
1522
  export const se_UpdatePushTemplateCommand = async (input, context) => {
2399
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1523
+ const b = rb(input, context);
2400
1524
  const headers = {
2401
1525
  "content-type": "application/json",
2402
1526
  };
2403
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/push";
2404
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
1527
+ b.bp("/v1/templates/{TemplateName}/push");
1528
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
2405
1529
  const query = map({
2406
- "create-new-version": [() => input.CreateNewVersion !== void 0, () => input.CreateNewVersion.toString()],
2407
- version: [, input.Version],
1530
+ [_cnv]: [() => input.CreateNewVersion !== void 0, () => input[_CNV].toString()],
1531
+ [_v]: [, input[_V]],
2408
1532
  });
2409
1533
  let body;
2410
1534
  if (input.PushNotificationTemplateRequest !== undefined) {
@@ -2414,24 +1538,16 @@ export const se_UpdatePushTemplateCommand = async (input, context) => {
2414
1538
  body = {};
2415
1539
  }
2416
1540
  body = JSON.stringify(body);
2417
- return new __HttpRequest({
2418
- protocol,
2419
- hostname,
2420
- port,
2421
- method: "PUT",
2422
- headers,
2423
- path: resolvedPath,
2424
- query,
2425
- body,
2426
- });
1541
+ b.m("PUT").h(headers).q(query).b(body);
1542
+ return b.build();
2427
1543
  };
2428
1544
  export const se_UpdateRecommenderConfigurationCommand = async (input, context) => {
2429
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1545
+ const b = rb(input, context);
2430
1546
  const headers = {
2431
1547
  "content-type": "application/json",
2432
1548
  };
2433
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/recommenders/{RecommenderId}";
2434
- resolvedPath = __resolvedPath(resolvedPath, input, "RecommenderId", () => input.RecommenderId, "{RecommenderId}", false);
1549
+ b.bp("/v1/recommenders/{RecommenderId}");
1550
+ b.p("RecommenderId", () => input.RecommenderId, "{RecommenderId}", false);
2435
1551
  let body;
2436
1552
  if (input.UpdateRecommenderConfiguration !== undefined) {
2437
1553
  body = _json(input.UpdateRecommenderConfiguration);
@@ -2440,25 +1556,17 @@ export const se_UpdateRecommenderConfigurationCommand = async (input, context) =
2440
1556
  body = {};
2441
1557
  }
2442
1558
  body = JSON.stringify(body);
2443
- return new __HttpRequest({
2444
- protocol,
2445
- hostname,
2446
- port,
2447
- method: "PUT",
2448
- headers,
2449
- path: resolvedPath,
2450
- body,
2451
- });
1559
+ b.m("PUT").h(headers).b(body);
1560
+ return b.build();
2452
1561
  };
2453
1562
  export const se_UpdateSegmentCommand = async (input, context) => {
2454
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1563
+ const b = rb(input, context);
2455
1564
  const headers = {
2456
1565
  "content-type": "application/json",
2457
1566
  };
2458
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2459
- "/v1/apps/{ApplicationId}/segments/{SegmentId}";
2460
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2461
- resolvedPath = __resolvedPath(resolvedPath, input, "SegmentId", () => input.SegmentId, "{SegmentId}", false);
1567
+ b.bp("/v1/apps/{ApplicationId}/segments/{SegmentId}");
1568
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1569
+ b.p("SegmentId", () => input.SegmentId, "{SegmentId}", false);
2462
1570
  let body;
2463
1571
  if (input.WriteSegmentRequest !== undefined) {
2464
1572
  body = se_WriteSegmentRequest(input.WriteSegmentRequest, context);
@@ -2467,23 +1575,16 @@ export const se_UpdateSegmentCommand = async (input, context) => {
2467
1575
  body = {};
2468
1576
  }
2469
1577
  body = JSON.stringify(body);
2470
- return new __HttpRequest({
2471
- protocol,
2472
- hostname,
2473
- port,
2474
- method: "PUT",
2475
- headers,
2476
- path: resolvedPath,
2477
- body,
2478
- });
1578
+ b.m("PUT").h(headers).b(body);
1579
+ return b.build();
2479
1580
  };
2480
1581
  export const se_UpdateSmsChannelCommand = async (input, context) => {
2481
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1582
+ const b = rb(input, context);
2482
1583
  const headers = {
2483
1584
  "content-type": "application/json",
2484
1585
  };
2485
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/sms";
2486
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1586
+ b.bp("/v1/apps/{ApplicationId}/channels/sms");
1587
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2487
1588
  let body;
2488
1589
  if (input.SMSChannelRequest !== undefined) {
2489
1590
  body = _json(input.SMSChannelRequest);
@@ -2492,26 +1593,19 @@ export const se_UpdateSmsChannelCommand = async (input, context) => {
2492
1593
  body = {};
2493
1594
  }
2494
1595
  body = JSON.stringify(body);
2495
- return new __HttpRequest({
2496
- protocol,
2497
- hostname,
2498
- port,
2499
- method: "PUT",
2500
- headers,
2501
- path: resolvedPath,
2502
- body,
2503
- });
1596
+ b.m("PUT").h(headers).b(body);
1597
+ return b.build();
2504
1598
  };
2505
1599
  export const se_UpdateSmsTemplateCommand = async (input, context) => {
2506
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1600
+ const b = rb(input, context);
2507
1601
  const headers = {
2508
1602
  "content-type": "application/json",
2509
1603
  };
2510
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/sms";
2511
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
1604
+ b.bp("/v1/templates/{TemplateName}/sms");
1605
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
2512
1606
  const query = map({
2513
- "create-new-version": [() => input.CreateNewVersion !== void 0, () => input.CreateNewVersion.toString()],
2514
- version: [, input.Version],
1607
+ [_cnv]: [() => input.CreateNewVersion !== void 0, () => input[_CNV].toString()],
1608
+ [_v]: [, input[_V]],
2515
1609
  });
2516
1610
  let body;
2517
1611
  if (input.SMSTemplateRequest !== undefined) {
@@ -2521,26 +1615,17 @@ export const se_UpdateSmsTemplateCommand = async (input, context) => {
2521
1615
  body = {};
2522
1616
  }
2523
1617
  body = JSON.stringify(body);
2524
- return new __HttpRequest({
2525
- protocol,
2526
- hostname,
2527
- port,
2528
- method: "PUT",
2529
- headers,
2530
- path: resolvedPath,
2531
- query,
2532
- body,
2533
- });
1618
+ b.m("PUT").h(headers).q(query).b(body);
1619
+ return b.build();
2534
1620
  };
2535
1621
  export const se_UpdateTemplateActiveVersionCommand = async (input, context) => {
2536
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1622
+ const b = rb(input, context);
2537
1623
  const headers = {
2538
1624
  "content-type": "application/json",
2539
1625
  };
2540
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
2541
- "/v1/templates/{TemplateName}/{TemplateType}/active-version";
2542
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
2543
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateType", () => input.TemplateType, "{TemplateType}", false);
1626
+ b.bp("/v1/templates/{TemplateName}/{TemplateType}/active-version");
1627
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
1628
+ b.p("TemplateType", () => input.TemplateType, "{TemplateType}", false);
2544
1629
  let body;
2545
1630
  if (input.TemplateActiveVersionRequest !== undefined) {
2546
1631
  body = _json(input.TemplateActiveVersionRequest);
@@ -2549,23 +1634,16 @@ export const se_UpdateTemplateActiveVersionCommand = async (input, context) => {
2549
1634
  body = {};
2550
1635
  }
2551
1636
  body = JSON.stringify(body);
2552
- return new __HttpRequest({
2553
- protocol,
2554
- hostname,
2555
- port,
2556
- method: "PUT",
2557
- headers,
2558
- path: resolvedPath,
2559
- body,
2560
- });
1637
+ b.m("PUT").h(headers).b(body);
1638
+ return b.build();
2561
1639
  };
2562
1640
  export const se_UpdateVoiceChannelCommand = async (input, context) => {
2563
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1641
+ const b = rb(input, context);
2564
1642
  const headers = {
2565
1643
  "content-type": "application/json",
2566
1644
  };
2567
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/channels/voice";
2568
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1645
+ b.bp("/v1/apps/{ApplicationId}/channels/voice");
1646
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2569
1647
  let body;
2570
1648
  if (input.VoiceChannelRequest !== undefined) {
2571
1649
  body = _json(input.VoiceChannelRequest);
@@ -2574,26 +1652,19 @@ export const se_UpdateVoiceChannelCommand = async (input, context) => {
2574
1652
  body = {};
2575
1653
  }
2576
1654
  body = JSON.stringify(body);
2577
- return new __HttpRequest({
2578
- protocol,
2579
- hostname,
2580
- port,
2581
- method: "PUT",
2582
- headers,
2583
- path: resolvedPath,
2584
- body,
2585
- });
1655
+ b.m("PUT").h(headers).b(body);
1656
+ return b.build();
2586
1657
  };
2587
1658
  export const se_UpdateVoiceTemplateCommand = async (input, context) => {
2588
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1659
+ const b = rb(input, context);
2589
1660
  const headers = {
2590
1661
  "content-type": "application/json",
2591
1662
  };
2592
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/templates/{TemplateName}/voice";
2593
- resolvedPath = __resolvedPath(resolvedPath, input, "TemplateName", () => input.TemplateName, "{TemplateName}", false);
1663
+ b.bp("/v1/templates/{TemplateName}/voice");
1664
+ b.p("TemplateName", () => input.TemplateName, "{TemplateName}", false);
2594
1665
  const query = map({
2595
- "create-new-version": [() => input.CreateNewVersion !== void 0, () => input.CreateNewVersion.toString()],
2596
- version: [, input.Version],
1666
+ [_cnv]: [() => input.CreateNewVersion !== void 0, () => input[_CNV].toString()],
1667
+ [_v]: [, input[_V]],
2597
1668
  });
2598
1669
  let body;
2599
1670
  if (input.VoiceTemplateRequest !== undefined) {
@@ -2603,24 +1674,16 @@ export const se_UpdateVoiceTemplateCommand = async (input, context) => {
2603
1674
  body = {};
2604
1675
  }
2605
1676
  body = JSON.stringify(body);
2606
- return new __HttpRequest({
2607
- protocol,
2608
- hostname,
2609
- port,
2610
- method: "PUT",
2611
- headers,
2612
- path: resolvedPath,
2613
- query,
2614
- body,
2615
- });
1677
+ b.m("PUT").h(headers).q(query).b(body);
1678
+ return b.build();
2616
1679
  };
2617
1680
  export const se_VerifyOTPMessageCommand = async (input, context) => {
2618
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1681
+ const b = rb(input, context);
2619
1682
  const headers = {
2620
1683
  "content-type": "application/json",
2621
1684
  };
2622
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apps/{ApplicationId}/verify-otp";
2623
- resolvedPath = __resolvedPath(resolvedPath, input, "ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
1685
+ b.bp("/v1/apps/{ApplicationId}/verify-otp");
1686
+ b.p("ApplicationId", () => input.ApplicationId, "{ApplicationId}", false);
2624
1687
  let body;
2625
1688
  if (input.VerifyOTPMessageRequestParameters !== undefined) {
2626
1689
  body = _json(input.VerifyOTPMessageRequestParameters);
@@ -2629,15 +1692,8 @@ export const se_VerifyOTPMessageCommand = async (input, context) => {
2629
1692
  body = {};
2630
1693
  }
2631
1694
  body = JSON.stringify(body);
2632
- return new __HttpRequest({
2633
- protocol,
2634
- hostname,
2635
- port,
2636
- method: "POST",
2637
- headers,
2638
- path: resolvedPath,
2639
- body,
2640
- });
1695
+ b.m("POST").h(headers).b(body);
1696
+ return b.build();
2641
1697
  };
2642
1698
  export const de_CreateAppCommand = async (output, context) => {
2643
1699
  if (output.statusCode !== 201 && output.statusCode >= 300) {
@@ -9602,6 +8658,26 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
9602
8658
  value !== "" &&
9603
8659
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
9604
8660
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
8661
+ const _CNV = "CreateNewVersion";
8662
+ const _ET = "EndTime";
8663
+ const _NT = "NextToken";
8664
+ const _P = "Prefix";
8665
+ const _PS = "PageSize";
8666
+ const _ST = "StartTime";
8667
+ const _T = "Token";
8668
+ const _TK = "TagKeys";
8669
+ const _TT = "TemplateType";
8670
+ const _V = "Version";
8671
+ const _cnv = "create-new-version";
8672
+ const _et = "end-time";
8673
+ const _nt = "next-token";
8674
+ const _p = "prefix";
8675
+ const _ps = "page-size";
8676
+ const _st = "start-time";
8677
+ const _t = "token";
8678
+ const _tK = "tagKeys";
8679
+ const _tt = "template-type";
8680
+ const _v = "version";
9605
8681
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
9606
8682
  if (encoded.length) {
9607
8683
  return JSON.parse(encoded);