@aws-sdk/client-chime-sdk-voice 3.476.0 → 3.477.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/protocols/Aws_restJson1.js +530 -1222
  2. package/dist-es/protocols/Aws_restJson1.js +531 -1223
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,138 +1,97 @@
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, limitedParseFloat32 as __limitedParseFloat32, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseFloat32 as __limitedParseFloat32, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { ChimeSDKVoiceServiceException as __BaseException } from "../models/ChimeSDKVoiceServiceException";
4
4
  import { AccessDeniedException, BadRequestException, ConflictException, ForbiddenException, GoneException, NotFoundException, ResourceLimitExceededException, ServiceFailureException, ServiceUnavailableException, ThrottledClientException, UnauthorizedClientException, UnprocessableEntityException, } from "../models/models_0";
5
5
  export const se_AssociatePhoneNumbersWithVoiceConnectorCommand = 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
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-connectors/{VoiceConnectorId}";
11
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
10
+ b.bp("/voice-connectors/{VoiceConnectorId}");
11
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
12
12
  const query = map({
13
- operation: [, "associate-phone-numbers"],
13
+ [_o]: [, "associate-phone-numbers"],
14
14
  });
15
15
  let body;
16
16
  body = JSON.stringify(take(input, {
17
17
  E164PhoneNumbers: (_) => _json(_),
18
18
  ForceAssociate: [],
19
19
  }));
20
- return new __HttpRequest({
21
- protocol,
22
- hostname,
23
- port,
24
- method: "POST",
25
- headers,
26
- path: resolvedPath,
27
- query,
28
- body,
29
- });
20
+ b.m("POST").h(headers).q(query).b(body);
21
+ return b.build();
30
22
  };
31
23
  export const se_AssociatePhoneNumbersWithVoiceConnectorGroupCommand = async (input, context) => {
32
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
24
+ const b = rb(input, context);
33
25
  const headers = {
34
26
  "content-type": "application/json",
35
27
  };
36
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
37
- "/voice-connector-groups/{VoiceConnectorGroupId}";
38
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorGroupId", () => input.VoiceConnectorGroupId, "{VoiceConnectorGroupId}", false);
28
+ b.bp("/voice-connector-groups/{VoiceConnectorGroupId}");
29
+ b.p("VoiceConnectorGroupId", () => input.VoiceConnectorGroupId, "{VoiceConnectorGroupId}", false);
39
30
  const query = map({
40
- operation: [, "associate-phone-numbers"],
31
+ [_o]: [, "associate-phone-numbers"],
41
32
  });
42
33
  let body;
43
34
  body = JSON.stringify(take(input, {
44
35
  E164PhoneNumbers: (_) => _json(_),
45
36
  ForceAssociate: [],
46
37
  }));
47
- return new __HttpRequest({
48
- protocol,
49
- hostname,
50
- port,
51
- method: "POST",
52
- headers,
53
- path: resolvedPath,
54
- query,
55
- body,
56
- });
38
+ b.m("POST").h(headers).q(query).b(body);
39
+ return b.build();
57
40
  };
58
41
  export const se_BatchDeletePhoneNumberCommand = async (input, context) => {
59
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
42
+ const b = rb(input, context);
60
43
  const headers = {
61
44
  "content-type": "application/json",
62
45
  };
63
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/phone-numbers";
46
+ b.bp("/phone-numbers");
64
47
  const query = map({
65
- operation: [, "batch-delete"],
48
+ [_o]: [, "batch-delete"],
66
49
  });
67
50
  let body;
68
51
  body = JSON.stringify(take(input, {
69
52
  PhoneNumberIds: (_) => _json(_),
70
53
  }));
71
- return new __HttpRequest({
72
- protocol,
73
- hostname,
74
- port,
75
- method: "POST",
76
- headers,
77
- path: resolvedPath,
78
- query,
79
- body,
80
- });
54
+ b.m("POST").h(headers).q(query).b(body);
55
+ return b.build();
81
56
  };
82
57
  export const se_BatchUpdatePhoneNumberCommand = async (input, context) => {
83
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
58
+ const b = rb(input, context);
84
59
  const headers = {
85
60
  "content-type": "application/json",
86
61
  };
87
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/phone-numbers";
62
+ b.bp("/phone-numbers");
88
63
  const query = map({
89
- operation: [, "batch-update"],
64
+ [_o]: [, "batch-update"],
90
65
  });
91
66
  let body;
92
67
  body = JSON.stringify(take(input, {
93
68
  UpdatePhoneNumberRequestItems: (_) => _json(_),
94
69
  }));
95
- return new __HttpRequest({
96
- protocol,
97
- hostname,
98
- port,
99
- method: "POST",
100
- headers,
101
- path: resolvedPath,
102
- query,
103
- body,
104
- });
70
+ b.m("POST").h(headers).q(query).b(body);
71
+ return b.build();
105
72
  };
106
73
  export const se_CreatePhoneNumberOrderCommand = async (input, context) => {
107
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
74
+ const b = rb(input, context);
108
75
  const headers = {
109
76
  "content-type": "application/json",
110
77
  };
111
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/phone-number-orders";
78
+ b.bp("/phone-number-orders");
112
79
  let body;
113
80
  body = JSON.stringify(take(input, {
114
81
  E164PhoneNumbers: (_) => _json(_),
115
82
  Name: [],
116
83
  ProductType: [],
117
84
  }));
118
- return new __HttpRequest({
119
- protocol,
120
- hostname,
121
- port,
122
- method: "POST",
123
- headers,
124
- path: resolvedPath,
125
- body,
126
- });
85
+ b.m("POST").h(headers).b(body);
86
+ return b.build();
127
87
  };
128
88
  export const se_CreateProxySessionCommand = async (input, context) => {
129
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
89
+ const b = rb(input, context);
130
90
  const headers = {
131
91
  "content-type": "application/json",
132
92
  };
133
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
134
- "/voice-connectors/{VoiceConnectorId}/proxy-sessions";
135
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
93
+ b.bp("/voice-connectors/{VoiceConnectorId}/proxy-sessions");
94
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
136
95
  let body;
137
96
  body = JSON.stringify(take(input, {
138
97
  Capabilities: (_) => _json(_),
@@ -143,22 +102,15 @@ export const se_CreateProxySessionCommand = async (input, context) => {
143
102
  NumberSelectionBehavior: [],
144
103
  ParticipantPhoneNumbers: (_) => _json(_),
145
104
  }));
146
- return new __HttpRequest({
147
- protocol,
148
- hostname,
149
- port,
150
- method: "POST",
151
- headers,
152
- path: resolvedPath,
153
- body,
154
- });
105
+ b.m("POST").h(headers).b(body);
106
+ return b.build();
155
107
  };
156
108
  export const se_CreateSipMediaApplicationCommand = async (input, context) => {
157
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
109
+ const b = rb(input, context);
158
110
  const headers = {
159
111
  "content-type": "application/json",
160
112
  };
161
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sip-media-applications";
113
+ b.bp("/sip-media-applications");
162
114
  let body;
163
115
  body = JSON.stringify(take(input, {
164
116
  AwsRegion: [],
@@ -166,24 +118,16 @@ export const se_CreateSipMediaApplicationCommand = async (input, context) => {
166
118
  Name: [],
167
119
  Tags: (_) => _json(_),
168
120
  }));
169
- return new __HttpRequest({
170
- protocol,
171
- hostname,
172
- port,
173
- method: "POST",
174
- headers,
175
- path: resolvedPath,
176
- body,
177
- });
121
+ b.m("POST").h(headers).b(body);
122
+ return b.build();
178
123
  };
179
124
  export const se_CreateSipMediaApplicationCallCommand = async (input, context) => {
180
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
125
+ const b = rb(input, context);
181
126
  const headers = {
182
127
  "content-type": "application/json",
183
128
  };
184
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
185
- "/sip-media-applications/{SipMediaApplicationId}/calls";
186
- resolvedPath = __resolvedPath(resolvedPath, input, "SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
129
+ b.bp("/sip-media-applications/{SipMediaApplicationId}/calls");
130
+ b.p("SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
187
131
  let body;
188
132
  body = JSON.stringify(take(input, {
189
133
  ArgumentsMap: (_) => _json(_),
@@ -191,22 +135,15 @@ export const se_CreateSipMediaApplicationCallCommand = async (input, context) =>
191
135
  SipHeaders: (_) => _json(_),
192
136
  ToPhoneNumber: [],
193
137
  }));
194
- return new __HttpRequest({
195
- protocol,
196
- hostname,
197
- port,
198
- method: "POST",
199
- headers,
200
- path: resolvedPath,
201
- body,
202
- });
138
+ b.m("POST").h(headers).b(body);
139
+ return b.build();
203
140
  };
204
141
  export const se_CreateSipRuleCommand = async (input, context) => {
205
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
142
+ const b = rb(input, context);
206
143
  const headers = {
207
144
  "content-type": "application/json",
208
145
  };
209
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sip-rules";
146
+ b.bp("/sip-rules");
210
147
  let body;
211
148
  body = JSON.stringify(take(input, {
212
149
  Disabled: [],
@@ -215,22 +152,15 @@ export const se_CreateSipRuleCommand = async (input, context) => {
215
152
  TriggerType: [],
216
153
  TriggerValue: [],
217
154
  }));
218
- return new __HttpRequest({
219
- protocol,
220
- hostname,
221
- port,
222
- method: "POST",
223
- headers,
224
- path: resolvedPath,
225
- body,
226
- });
155
+ b.m("POST").h(headers).b(body);
156
+ return b.build();
227
157
  };
228
158
  export const se_CreateVoiceConnectorCommand = async (input, context) => {
229
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
159
+ const b = rb(input, context);
230
160
  const headers = {
231
161
  "content-type": "application/json",
232
162
  };
233
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-connectors";
163
+ b.bp("/voice-connectors");
234
164
  let body;
235
165
  body = JSON.stringify(take(input, {
236
166
  AwsRegion: [],
@@ -238,63 +168,42 @@ export const se_CreateVoiceConnectorCommand = async (input, context) => {
238
168
  RequireEncryption: [],
239
169
  Tags: (_) => _json(_),
240
170
  }));
241
- return new __HttpRequest({
242
- protocol,
243
- hostname,
244
- port,
245
- method: "POST",
246
- headers,
247
- path: resolvedPath,
248
- body,
249
- });
171
+ b.m("POST").h(headers).b(body);
172
+ return b.build();
250
173
  };
251
174
  export const se_CreateVoiceConnectorGroupCommand = async (input, context) => {
252
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
175
+ const b = rb(input, context);
253
176
  const headers = {
254
177
  "content-type": "application/json",
255
178
  };
256
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-connector-groups";
179
+ b.bp("/voice-connector-groups");
257
180
  let body;
258
181
  body = JSON.stringify(take(input, {
259
182
  Name: [],
260
183
  VoiceConnectorItems: (_) => _json(_),
261
184
  }));
262
- return new __HttpRequest({
263
- protocol,
264
- hostname,
265
- port,
266
- method: "POST",
267
- headers,
268
- path: resolvedPath,
269
- body,
270
- });
185
+ b.m("POST").h(headers).b(body);
186
+ return b.build();
271
187
  };
272
188
  export const se_CreateVoiceProfileCommand = async (input, context) => {
273
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
189
+ const b = rb(input, context);
274
190
  const headers = {
275
191
  "content-type": "application/json",
276
192
  };
277
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-profiles";
193
+ b.bp("/voice-profiles");
278
194
  let body;
279
195
  body = JSON.stringify(take(input, {
280
196
  SpeakerSearchTaskId: [],
281
197
  }));
282
- return new __HttpRequest({
283
- protocol,
284
- hostname,
285
- port,
286
- method: "POST",
287
- headers,
288
- path: resolvedPath,
289
- body,
290
- });
198
+ b.m("POST").h(headers).b(body);
199
+ return b.build();
291
200
  };
292
201
  export const se_CreateVoiceProfileDomainCommand = async (input, context) => {
293
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
202
+ const b = rb(input, context);
294
203
  const headers = {
295
204
  "content-type": "application/json",
296
205
  };
297
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-profile-domains";
206
+ b.bp("/voice-profile-domains");
298
207
  let body;
299
208
  body = JSON.stringify(take(input, {
300
209
  ClientRequestToken: [],
@@ -303,1069 +212,621 @@ export const se_CreateVoiceProfileDomainCommand = async (input, context) => {
303
212
  ServerSideEncryptionConfiguration: (_) => _json(_),
304
213
  Tags: (_) => _json(_),
305
214
  }));
306
- return new __HttpRequest({
307
- protocol,
308
- hostname,
309
- port,
310
- method: "POST",
311
- headers,
312
- path: resolvedPath,
313
- body,
314
- });
215
+ b.m("POST").h(headers).b(body);
216
+ return b.build();
315
217
  };
316
218
  export const se_DeletePhoneNumberCommand = async (input, context) => {
317
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
219
+ const b = rb(input, context);
318
220
  const headers = {};
319
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/phone-numbers/{PhoneNumberId}";
320
- resolvedPath = __resolvedPath(resolvedPath, input, "PhoneNumberId", () => input.PhoneNumberId, "{PhoneNumberId}", false);
221
+ b.bp("/phone-numbers/{PhoneNumberId}");
222
+ b.p("PhoneNumberId", () => input.PhoneNumberId, "{PhoneNumberId}", false);
321
223
  let body;
322
- return new __HttpRequest({
323
- protocol,
324
- hostname,
325
- port,
326
- method: "DELETE",
327
- headers,
328
- path: resolvedPath,
329
- body,
330
- });
224
+ b.m("DELETE").h(headers).b(body);
225
+ return b.build();
331
226
  };
332
227
  export const se_DeleteProxySessionCommand = async (input, context) => {
333
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
228
+ const b = rb(input, context);
334
229
  const headers = {};
335
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
336
- "/voice-connectors/{VoiceConnectorId}/proxy-sessions/{ProxySessionId}";
337
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
338
- resolvedPath = __resolvedPath(resolvedPath, input, "ProxySessionId", () => input.ProxySessionId, "{ProxySessionId}", false);
230
+ b.bp("/voice-connectors/{VoiceConnectorId}/proxy-sessions/{ProxySessionId}");
231
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
232
+ b.p("ProxySessionId", () => input.ProxySessionId, "{ProxySessionId}", false);
339
233
  let body;
340
- return new __HttpRequest({
341
- protocol,
342
- hostname,
343
- port,
344
- method: "DELETE",
345
- headers,
346
- path: resolvedPath,
347
- body,
348
- });
234
+ b.m("DELETE").h(headers).b(body);
235
+ return b.build();
349
236
  };
350
237
  export const se_DeleteSipMediaApplicationCommand = async (input, context) => {
351
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
238
+ const b = rb(input, context);
352
239
  const headers = {};
353
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
354
- "/sip-media-applications/{SipMediaApplicationId}";
355
- resolvedPath = __resolvedPath(resolvedPath, input, "SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
240
+ b.bp("/sip-media-applications/{SipMediaApplicationId}");
241
+ b.p("SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
356
242
  let body;
357
- return new __HttpRequest({
358
- protocol,
359
- hostname,
360
- port,
361
- method: "DELETE",
362
- headers,
363
- path: resolvedPath,
364
- body,
365
- });
243
+ b.m("DELETE").h(headers).b(body);
244
+ return b.build();
366
245
  };
367
246
  export const se_DeleteSipRuleCommand = async (input, context) => {
368
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
247
+ const b = rb(input, context);
369
248
  const headers = {};
370
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sip-rules/{SipRuleId}";
371
- resolvedPath = __resolvedPath(resolvedPath, input, "SipRuleId", () => input.SipRuleId, "{SipRuleId}", false);
249
+ b.bp("/sip-rules/{SipRuleId}");
250
+ b.p("SipRuleId", () => input.SipRuleId, "{SipRuleId}", false);
372
251
  let body;
373
- return new __HttpRequest({
374
- protocol,
375
- hostname,
376
- port,
377
- method: "DELETE",
378
- headers,
379
- path: resolvedPath,
380
- body,
381
- });
252
+ b.m("DELETE").h(headers).b(body);
253
+ return b.build();
382
254
  };
383
255
  export const se_DeleteVoiceConnectorCommand = async (input, context) => {
384
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
256
+ const b = rb(input, context);
385
257
  const headers = {};
386
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-connectors/{VoiceConnectorId}";
387
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
258
+ b.bp("/voice-connectors/{VoiceConnectorId}");
259
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
388
260
  let body;
389
- return new __HttpRequest({
390
- protocol,
391
- hostname,
392
- port,
393
- method: "DELETE",
394
- headers,
395
- path: resolvedPath,
396
- body,
397
- });
261
+ b.m("DELETE").h(headers).b(body);
262
+ return b.build();
398
263
  };
399
264
  export const se_DeleteVoiceConnectorEmergencyCallingConfigurationCommand = async (input, context) => {
400
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
265
+ const b = rb(input, context);
401
266
  const headers = {};
402
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
403
- "/voice-connectors/{VoiceConnectorId}/emergency-calling-configuration";
404
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
267
+ b.bp("/voice-connectors/{VoiceConnectorId}/emergency-calling-configuration");
268
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
405
269
  let body;
406
- return new __HttpRequest({
407
- protocol,
408
- hostname,
409
- port,
410
- method: "DELETE",
411
- headers,
412
- path: resolvedPath,
413
- body,
414
- });
270
+ b.m("DELETE").h(headers).b(body);
271
+ return b.build();
415
272
  };
416
273
  export const se_DeleteVoiceConnectorGroupCommand = async (input, context) => {
417
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
274
+ const b = rb(input, context);
418
275
  const headers = {};
419
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
420
- "/voice-connector-groups/{VoiceConnectorGroupId}";
421
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorGroupId", () => input.VoiceConnectorGroupId, "{VoiceConnectorGroupId}", false);
276
+ b.bp("/voice-connector-groups/{VoiceConnectorGroupId}");
277
+ b.p("VoiceConnectorGroupId", () => input.VoiceConnectorGroupId, "{VoiceConnectorGroupId}", false);
422
278
  let body;
423
- return new __HttpRequest({
424
- protocol,
425
- hostname,
426
- port,
427
- method: "DELETE",
428
- headers,
429
- path: resolvedPath,
430
- body,
431
- });
279
+ b.m("DELETE").h(headers).b(body);
280
+ return b.build();
432
281
  };
433
282
  export const se_DeleteVoiceConnectorOriginationCommand = async (input, context) => {
434
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
283
+ const b = rb(input, context);
435
284
  const headers = {};
436
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
437
- "/voice-connectors/{VoiceConnectorId}/origination";
438
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
285
+ b.bp("/voice-connectors/{VoiceConnectorId}/origination");
286
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
439
287
  let body;
440
- return new __HttpRequest({
441
- protocol,
442
- hostname,
443
- port,
444
- method: "DELETE",
445
- headers,
446
- path: resolvedPath,
447
- body,
448
- });
288
+ b.m("DELETE").h(headers).b(body);
289
+ return b.build();
449
290
  };
450
291
  export const se_DeleteVoiceConnectorProxyCommand = async (input, context) => {
451
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
292
+ const b = rb(input, context);
452
293
  const headers = {};
453
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
454
- "/voice-connectors/{VoiceConnectorId}/programmable-numbers/proxy";
455
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
294
+ b.bp("/voice-connectors/{VoiceConnectorId}/programmable-numbers/proxy");
295
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
456
296
  let body;
457
- return new __HttpRequest({
458
- protocol,
459
- hostname,
460
- port,
461
- method: "DELETE",
462
- headers,
463
- path: resolvedPath,
464
- body,
465
- });
297
+ b.m("DELETE").h(headers).b(body);
298
+ return b.build();
466
299
  };
467
300
  export const se_DeleteVoiceConnectorStreamingConfigurationCommand = async (input, context) => {
468
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
301
+ const b = rb(input, context);
469
302
  const headers = {};
470
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
471
- "/voice-connectors/{VoiceConnectorId}/streaming-configuration";
472
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
303
+ b.bp("/voice-connectors/{VoiceConnectorId}/streaming-configuration");
304
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
473
305
  let body;
474
- return new __HttpRequest({
475
- protocol,
476
- hostname,
477
- port,
478
- method: "DELETE",
479
- headers,
480
- path: resolvedPath,
481
- body,
482
- });
306
+ b.m("DELETE").h(headers).b(body);
307
+ return b.build();
483
308
  };
484
309
  export const se_DeleteVoiceConnectorTerminationCommand = async (input, context) => {
485
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
310
+ const b = rb(input, context);
486
311
  const headers = {};
487
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
488
- "/voice-connectors/{VoiceConnectorId}/termination";
489
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
312
+ b.bp("/voice-connectors/{VoiceConnectorId}/termination");
313
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
490
314
  let body;
491
- return new __HttpRequest({
492
- protocol,
493
- hostname,
494
- port,
495
- method: "DELETE",
496
- headers,
497
- path: resolvedPath,
498
- body,
499
- });
315
+ b.m("DELETE").h(headers).b(body);
316
+ return b.build();
500
317
  };
501
318
  export const se_DeleteVoiceConnectorTerminationCredentialsCommand = async (input, context) => {
502
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
319
+ const b = rb(input, context);
503
320
  const headers = {
504
321
  "content-type": "application/json",
505
322
  };
506
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
507
- "/voice-connectors/{VoiceConnectorId}/termination/credentials";
508
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
323
+ b.bp("/voice-connectors/{VoiceConnectorId}/termination/credentials");
324
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
509
325
  const query = map({
510
- operation: [, "delete"],
326
+ [_o]: [, "delete"],
511
327
  });
512
328
  let body;
513
329
  body = JSON.stringify(take(input, {
514
330
  Usernames: (_) => _json(_),
515
331
  }));
516
- return new __HttpRequest({
517
- protocol,
518
- hostname,
519
- port,
520
- method: "POST",
521
- headers,
522
- path: resolvedPath,
523
- query,
524
- body,
525
- });
332
+ b.m("POST").h(headers).q(query).b(body);
333
+ return b.build();
526
334
  };
527
335
  export const se_DeleteVoiceProfileCommand = async (input, context) => {
528
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
336
+ const b = rb(input, context);
529
337
  const headers = {};
530
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-profiles/{VoiceProfileId}";
531
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceProfileId", () => input.VoiceProfileId, "{VoiceProfileId}", false);
338
+ b.bp("/voice-profiles/{VoiceProfileId}");
339
+ b.p("VoiceProfileId", () => input.VoiceProfileId, "{VoiceProfileId}", false);
532
340
  let body;
533
- return new __HttpRequest({
534
- protocol,
535
- hostname,
536
- port,
537
- method: "DELETE",
538
- headers,
539
- path: resolvedPath,
540
- body,
541
- });
341
+ b.m("DELETE").h(headers).b(body);
342
+ return b.build();
542
343
  };
543
344
  export const se_DeleteVoiceProfileDomainCommand = async (input, context) => {
544
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
345
+ const b = rb(input, context);
545
346
  const headers = {};
546
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
547
- "/voice-profile-domains/{VoiceProfileDomainId}";
548
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceProfileDomainId", () => input.VoiceProfileDomainId, "{VoiceProfileDomainId}", false);
347
+ b.bp("/voice-profile-domains/{VoiceProfileDomainId}");
348
+ b.p("VoiceProfileDomainId", () => input.VoiceProfileDomainId, "{VoiceProfileDomainId}", false);
549
349
  let body;
550
- return new __HttpRequest({
551
- protocol,
552
- hostname,
553
- port,
554
- method: "DELETE",
555
- headers,
556
- path: resolvedPath,
557
- body,
558
- });
350
+ b.m("DELETE").h(headers).b(body);
351
+ return b.build();
559
352
  };
560
353
  export const se_DisassociatePhoneNumbersFromVoiceConnectorCommand = async (input, context) => {
561
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
354
+ const b = rb(input, context);
562
355
  const headers = {
563
356
  "content-type": "application/json",
564
357
  };
565
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-connectors/{VoiceConnectorId}";
566
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
358
+ b.bp("/voice-connectors/{VoiceConnectorId}");
359
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
567
360
  const query = map({
568
- operation: [, "disassociate-phone-numbers"],
361
+ [_o]: [, "disassociate-phone-numbers"],
569
362
  });
570
363
  let body;
571
364
  body = JSON.stringify(take(input, {
572
365
  E164PhoneNumbers: (_) => _json(_),
573
366
  }));
574
- return new __HttpRequest({
575
- protocol,
576
- hostname,
577
- port,
578
- method: "POST",
579
- headers,
580
- path: resolvedPath,
581
- query,
582
- body,
583
- });
367
+ b.m("POST").h(headers).q(query).b(body);
368
+ return b.build();
584
369
  };
585
370
  export const se_DisassociatePhoneNumbersFromVoiceConnectorGroupCommand = async (input, context) => {
586
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
371
+ const b = rb(input, context);
587
372
  const headers = {
588
373
  "content-type": "application/json",
589
374
  };
590
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
591
- "/voice-connector-groups/{VoiceConnectorGroupId}";
592
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorGroupId", () => input.VoiceConnectorGroupId, "{VoiceConnectorGroupId}", false);
375
+ b.bp("/voice-connector-groups/{VoiceConnectorGroupId}");
376
+ b.p("VoiceConnectorGroupId", () => input.VoiceConnectorGroupId, "{VoiceConnectorGroupId}", false);
593
377
  const query = map({
594
- operation: [, "disassociate-phone-numbers"],
378
+ [_o]: [, "disassociate-phone-numbers"],
595
379
  });
596
380
  let body;
597
381
  body = JSON.stringify(take(input, {
598
382
  E164PhoneNumbers: (_) => _json(_),
599
383
  }));
600
- return new __HttpRequest({
601
- protocol,
602
- hostname,
603
- port,
604
- method: "POST",
605
- headers,
606
- path: resolvedPath,
607
- query,
608
- body,
609
- });
384
+ b.m("POST").h(headers).q(query).b(body);
385
+ return b.build();
610
386
  };
611
387
  export const se_GetGlobalSettingsCommand = async (input, context) => {
612
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
388
+ const b = rb(input, context);
613
389
  const headers = {
614
390
  "content-type": "application/json",
615
391
  };
616
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/settings";
392
+ b.bp("/settings");
617
393
  let body;
618
394
  body = "";
619
- return new __HttpRequest({
620
- protocol,
621
- hostname,
622
- port,
623
- method: "GET",
624
- headers,
625
- path: resolvedPath,
626
- body,
627
- });
395
+ b.m("GET").h(headers).b(body);
396
+ return b.build();
628
397
  };
629
398
  export const se_GetPhoneNumberCommand = async (input, context) => {
630
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
399
+ const b = rb(input, context);
631
400
  const headers = {};
632
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/phone-numbers/{PhoneNumberId}";
633
- resolvedPath = __resolvedPath(resolvedPath, input, "PhoneNumberId", () => input.PhoneNumberId, "{PhoneNumberId}", false);
401
+ b.bp("/phone-numbers/{PhoneNumberId}");
402
+ b.p("PhoneNumberId", () => input.PhoneNumberId, "{PhoneNumberId}", false);
634
403
  let body;
635
- return new __HttpRequest({
636
- protocol,
637
- hostname,
638
- port,
639
- method: "GET",
640
- headers,
641
- path: resolvedPath,
642
- body,
643
- });
404
+ b.m("GET").h(headers).b(body);
405
+ return b.build();
644
406
  };
645
407
  export const se_GetPhoneNumberOrderCommand = async (input, context) => {
646
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
408
+ const b = rb(input, context);
647
409
  const headers = {};
648
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/phone-number-orders/{PhoneNumberOrderId}";
649
- resolvedPath = __resolvedPath(resolvedPath, input, "PhoneNumberOrderId", () => input.PhoneNumberOrderId, "{PhoneNumberOrderId}", false);
410
+ b.bp("/phone-number-orders/{PhoneNumberOrderId}");
411
+ b.p("PhoneNumberOrderId", () => input.PhoneNumberOrderId, "{PhoneNumberOrderId}", false);
650
412
  let body;
651
- return new __HttpRequest({
652
- protocol,
653
- hostname,
654
- port,
655
- method: "GET",
656
- headers,
657
- path: resolvedPath,
658
- body,
659
- });
413
+ b.m("GET").h(headers).b(body);
414
+ return b.build();
660
415
  };
661
416
  export const se_GetPhoneNumberSettingsCommand = async (input, context) => {
662
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
417
+ const b = rb(input, context);
663
418
  const headers = {
664
419
  "content-type": "application/json",
665
420
  };
666
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/settings/phone-number";
421
+ b.bp("/settings/phone-number");
667
422
  let body;
668
423
  body = "";
669
- return new __HttpRequest({
670
- protocol,
671
- hostname,
672
- port,
673
- method: "GET",
674
- headers,
675
- path: resolvedPath,
676
- body,
677
- });
424
+ b.m("GET").h(headers).b(body);
425
+ return b.build();
678
426
  };
679
427
  export const se_GetProxySessionCommand = async (input, context) => {
680
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
428
+ const b = rb(input, context);
681
429
  const headers = {};
682
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
683
- "/voice-connectors/{VoiceConnectorId}/proxy-sessions/{ProxySessionId}";
684
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
685
- resolvedPath = __resolvedPath(resolvedPath, input, "ProxySessionId", () => input.ProxySessionId, "{ProxySessionId}", false);
430
+ b.bp("/voice-connectors/{VoiceConnectorId}/proxy-sessions/{ProxySessionId}");
431
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
432
+ b.p("ProxySessionId", () => input.ProxySessionId, "{ProxySessionId}", false);
686
433
  let body;
687
- return new __HttpRequest({
688
- protocol,
689
- hostname,
690
- port,
691
- method: "GET",
692
- headers,
693
- path: resolvedPath,
694
- body,
695
- });
434
+ b.m("GET").h(headers).b(body);
435
+ return b.build();
696
436
  };
697
437
  export const se_GetSipMediaApplicationCommand = async (input, context) => {
698
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
438
+ const b = rb(input, context);
699
439
  const headers = {};
700
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
701
- "/sip-media-applications/{SipMediaApplicationId}";
702
- resolvedPath = __resolvedPath(resolvedPath, input, "SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
440
+ b.bp("/sip-media-applications/{SipMediaApplicationId}");
441
+ b.p("SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
703
442
  let body;
704
- return new __HttpRequest({
705
- protocol,
706
- hostname,
707
- port,
708
- method: "GET",
709
- headers,
710
- path: resolvedPath,
711
- body,
712
- });
443
+ b.m("GET").h(headers).b(body);
444
+ return b.build();
713
445
  };
714
446
  export const se_GetSipMediaApplicationAlexaSkillConfigurationCommand = async (input, context) => {
715
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
447
+ const b = rb(input, context);
716
448
  const headers = {};
717
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
718
- "/sip-media-applications/{SipMediaApplicationId}/alexa-skill-configuration";
719
- resolvedPath = __resolvedPath(resolvedPath, input, "SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
449
+ b.bp("/sip-media-applications/{SipMediaApplicationId}/alexa-skill-configuration");
450
+ b.p("SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
720
451
  let body;
721
- return new __HttpRequest({
722
- protocol,
723
- hostname,
724
- port,
725
- method: "GET",
726
- headers,
727
- path: resolvedPath,
728
- body,
729
- });
452
+ b.m("GET").h(headers).b(body);
453
+ return b.build();
730
454
  };
731
455
  export const se_GetSipMediaApplicationLoggingConfigurationCommand = async (input, context) => {
732
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
456
+ const b = rb(input, context);
733
457
  const headers = {};
734
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
735
- "/sip-media-applications/{SipMediaApplicationId}/logging-configuration";
736
- resolvedPath = __resolvedPath(resolvedPath, input, "SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
458
+ b.bp("/sip-media-applications/{SipMediaApplicationId}/logging-configuration");
459
+ b.p("SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
737
460
  let body;
738
- return new __HttpRequest({
739
- protocol,
740
- hostname,
741
- port,
742
- method: "GET",
743
- headers,
744
- path: resolvedPath,
745
- body,
746
- });
461
+ b.m("GET").h(headers).b(body);
462
+ return b.build();
747
463
  };
748
464
  export const se_GetSipRuleCommand = async (input, context) => {
749
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
465
+ const b = rb(input, context);
750
466
  const headers = {};
751
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sip-rules/{SipRuleId}";
752
- resolvedPath = __resolvedPath(resolvedPath, input, "SipRuleId", () => input.SipRuleId, "{SipRuleId}", false);
467
+ b.bp("/sip-rules/{SipRuleId}");
468
+ b.p("SipRuleId", () => input.SipRuleId, "{SipRuleId}", false);
753
469
  let body;
754
- return new __HttpRequest({
755
- protocol,
756
- hostname,
757
- port,
758
- method: "GET",
759
- headers,
760
- path: resolvedPath,
761
- body,
762
- });
470
+ b.m("GET").h(headers).b(body);
471
+ return b.build();
763
472
  };
764
473
  export const se_GetSpeakerSearchTaskCommand = async (input, context) => {
765
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
474
+ const b = rb(input, context);
766
475
  const headers = {};
767
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
768
- "/voice-connectors/{VoiceConnectorId}/speaker-search-tasks/{SpeakerSearchTaskId}";
769
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
770
- resolvedPath = __resolvedPath(resolvedPath, input, "SpeakerSearchTaskId", () => input.SpeakerSearchTaskId, "{SpeakerSearchTaskId}", false);
476
+ b.bp("/voice-connectors/{VoiceConnectorId}/speaker-search-tasks/{SpeakerSearchTaskId}");
477
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
478
+ b.p("SpeakerSearchTaskId", () => input.SpeakerSearchTaskId, "{SpeakerSearchTaskId}", false);
771
479
  let body;
772
- return new __HttpRequest({
773
- protocol,
774
- hostname,
775
- port,
776
- method: "GET",
777
- headers,
778
- path: resolvedPath,
779
- body,
780
- });
480
+ b.m("GET").h(headers).b(body);
481
+ return b.build();
781
482
  };
782
483
  export const se_GetVoiceConnectorCommand = async (input, context) => {
783
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
484
+ const b = rb(input, context);
784
485
  const headers = {};
785
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-connectors/{VoiceConnectorId}";
786
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
486
+ b.bp("/voice-connectors/{VoiceConnectorId}");
487
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
787
488
  let body;
788
- return new __HttpRequest({
789
- protocol,
790
- hostname,
791
- port,
792
- method: "GET",
793
- headers,
794
- path: resolvedPath,
795
- body,
796
- });
489
+ b.m("GET").h(headers).b(body);
490
+ return b.build();
797
491
  };
798
492
  export const se_GetVoiceConnectorEmergencyCallingConfigurationCommand = async (input, context) => {
799
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
493
+ const b = rb(input, context);
800
494
  const headers = {};
801
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
802
- "/voice-connectors/{VoiceConnectorId}/emergency-calling-configuration";
803
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
495
+ b.bp("/voice-connectors/{VoiceConnectorId}/emergency-calling-configuration");
496
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
804
497
  let body;
805
- return new __HttpRequest({
806
- protocol,
807
- hostname,
808
- port,
809
- method: "GET",
810
- headers,
811
- path: resolvedPath,
812
- body,
813
- });
498
+ b.m("GET").h(headers).b(body);
499
+ return b.build();
814
500
  };
815
501
  export const se_GetVoiceConnectorGroupCommand = async (input, context) => {
816
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
502
+ const b = rb(input, context);
817
503
  const headers = {};
818
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
819
- "/voice-connector-groups/{VoiceConnectorGroupId}";
820
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorGroupId", () => input.VoiceConnectorGroupId, "{VoiceConnectorGroupId}", false);
504
+ b.bp("/voice-connector-groups/{VoiceConnectorGroupId}");
505
+ b.p("VoiceConnectorGroupId", () => input.VoiceConnectorGroupId, "{VoiceConnectorGroupId}", false);
821
506
  let body;
822
- return new __HttpRequest({
823
- protocol,
824
- hostname,
825
- port,
826
- method: "GET",
827
- headers,
828
- path: resolvedPath,
829
- body,
830
- });
507
+ b.m("GET").h(headers).b(body);
508
+ return b.build();
831
509
  };
832
510
  export const se_GetVoiceConnectorLoggingConfigurationCommand = async (input, context) => {
833
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
511
+ const b = rb(input, context);
834
512
  const headers = {};
835
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
836
- "/voice-connectors/{VoiceConnectorId}/logging-configuration";
837
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
513
+ b.bp("/voice-connectors/{VoiceConnectorId}/logging-configuration");
514
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
838
515
  let body;
839
- return new __HttpRequest({
840
- protocol,
841
- hostname,
842
- port,
843
- method: "GET",
844
- headers,
845
- path: resolvedPath,
846
- body,
847
- });
516
+ b.m("GET").h(headers).b(body);
517
+ return b.build();
848
518
  };
849
519
  export const se_GetVoiceConnectorOriginationCommand = async (input, context) => {
850
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
520
+ const b = rb(input, context);
851
521
  const headers = {};
852
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
853
- "/voice-connectors/{VoiceConnectorId}/origination";
854
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
522
+ b.bp("/voice-connectors/{VoiceConnectorId}/origination");
523
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
855
524
  let body;
856
- return new __HttpRequest({
857
- protocol,
858
- hostname,
859
- port,
860
- method: "GET",
861
- headers,
862
- path: resolvedPath,
863
- body,
864
- });
525
+ b.m("GET").h(headers).b(body);
526
+ return b.build();
865
527
  };
866
528
  export const se_GetVoiceConnectorProxyCommand = async (input, context) => {
867
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
529
+ const b = rb(input, context);
868
530
  const headers = {};
869
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
870
- "/voice-connectors/{VoiceConnectorId}/programmable-numbers/proxy";
871
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
531
+ b.bp("/voice-connectors/{VoiceConnectorId}/programmable-numbers/proxy");
532
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
872
533
  let body;
873
- return new __HttpRequest({
874
- protocol,
875
- hostname,
876
- port,
877
- method: "GET",
878
- headers,
879
- path: resolvedPath,
880
- body,
881
- });
534
+ b.m("GET").h(headers).b(body);
535
+ return b.build();
882
536
  };
883
537
  export const se_GetVoiceConnectorStreamingConfigurationCommand = async (input, context) => {
884
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
538
+ const b = rb(input, context);
885
539
  const headers = {};
886
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
887
- "/voice-connectors/{VoiceConnectorId}/streaming-configuration";
888
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
540
+ b.bp("/voice-connectors/{VoiceConnectorId}/streaming-configuration");
541
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
889
542
  let body;
890
- return new __HttpRequest({
891
- protocol,
892
- hostname,
893
- port,
894
- method: "GET",
895
- headers,
896
- path: resolvedPath,
897
- body,
898
- });
543
+ b.m("GET").h(headers).b(body);
544
+ return b.build();
899
545
  };
900
546
  export const se_GetVoiceConnectorTerminationCommand = async (input, context) => {
901
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
547
+ const b = rb(input, context);
902
548
  const headers = {};
903
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
904
- "/voice-connectors/{VoiceConnectorId}/termination";
905
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
549
+ b.bp("/voice-connectors/{VoiceConnectorId}/termination");
550
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
906
551
  let body;
907
- return new __HttpRequest({
908
- protocol,
909
- hostname,
910
- port,
911
- method: "GET",
912
- headers,
913
- path: resolvedPath,
914
- body,
915
- });
552
+ b.m("GET").h(headers).b(body);
553
+ return b.build();
916
554
  };
917
555
  export const se_GetVoiceConnectorTerminationHealthCommand = async (input, context) => {
918
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
556
+ const b = rb(input, context);
919
557
  const headers = {};
920
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
921
- "/voice-connectors/{VoiceConnectorId}/termination/health";
922
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
558
+ b.bp("/voice-connectors/{VoiceConnectorId}/termination/health");
559
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
923
560
  let body;
924
- return new __HttpRequest({
925
- protocol,
926
- hostname,
927
- port,
928
- method: "GET",
929
- headers,
930
- path: resolvedPath,
931
- body,
932
- });
561
+ b.m("GET").h(headers).b(body);
562
+ return b.build();
933
563
  };
934
564
  export const se_GetVoiceProfileCommand = async (input, context) => {
935
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
565
+ const b = rb(input, context);
936
566
  const headers = {};
937
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-profiles/{VoiceProfileId}";
938
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceProfileId", () => input.VoiceProfileId, "{VoiceProfileId}", false);
567
+ b.bp("/voice-profiles/{VoiceProfileId}");
568
+ b.p("VoiceProfileId", () => input.VoiceProfileId, "{VoiceProfileId}", false);
939
569
  let body;
940
- return new __HttpRequest({
941
- protocol,
942
- hostname,
943
- port,
944
- method: "GET",
945
- headers,
946
- path: resolvedPath,
947
- body,
948
- });
570
+ b.m("GET").h(headers).b(body);
571
+ return b.build();
949
572
  };
950
573
  export const se_GetVoiceProfileDomainCommand = async (input, context) => {
951
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
574
+ const b = rb(input, context);
952
575
  const headers = {};
953
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
954
- "/voice-profile-domains/{VoiceProfileDomainId}";
955
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceProfileDomainId", () => input.VoiceProfileDomainId, "{VoiceProfileDomainId}", false);
576
+ b.bp("/voice-profile-domains/{VoiceProfileDomainId}");
577
+ b.p("VoiceProfileDomainId", () => input.VoiceProfileDomainId, "{VoiceProfileDomainId}", false);
956
578
  let body;
957
- return new __HttpRequest({
958
- protocol,
959
- hostname,
960
- port,
961
- method: "GET",
962
- headers,
963
- path: resolvedPath,
964
- body,
965
- });
579
+ b.m("GET").h(headers).b(body);
580
+ return b.build();
966
581
  };
967
582
  export const se_GetVoiceToneAnalysisTaskCommand = async (input, context) => {
968
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
583
+ const b = rb(input, context);
969
584
  const headers = {};
970
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
971
- "/voice-connectors/{VoiceConnectorId}/voice-tone-analysis-tasks/{VoiceToneAnalysisTaskId}";
972
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
973
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceToneAnalysisTaskId", () => input.VoiceToneAnalysisTaskId, "{VoiceToneAnalysisTaskId}", false);
585
+ b.bp("/voice-connectors/{VoiceConnectorId}/voice-tone-analysis-tasks/{VoiceToneAnalysisTaskId}");
586
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
587
+ b.p("VoiceToneAnalysisTaskId", () => input.VoiceToneAnalysisTaskId, "{VoiceToneAnalysisTaskId}", false);
974
588
  const query = map({
975
- isCaller: [__expectNonNull(input.IsCaller, `IsCaller`) != null, () => input.IsCaller.toString()],
589
+ [_iC]: [__expectNonNull(input.IsCaller, `IsCaller`) != null, () => input[_IC].toString()],
976
590
  });
977
591
  let body;
978
- return new __HttpRequest({
979
- protocol,
980
- hostname,
981
- port,
982
- method: "GET",
983
- headers,
984
- path: resolvedPath,
985
- query,
986
- body,
987
- });
592
+ b.m("GET").h(headers).q(query).b(body);
593
+ return b.build();
988
594
  };
989
595
  export const se_ListAvailableVoiceConnectorRegionsCommand = async (input, context) => {
990
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
596
+ const b = rb(input, context);
991
597
  const headers = {
992
598
  "content-type": "application/json",
993
599
  };
994
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-connector-regions";
600
+ b.bp("/voice-connector-regions");
995
601
  let body;
996
602
  body = "";
997
- return new __HttpRequest({
998
- protocol,
999
- hostname,
1000
- port,
1001
- method: "GET",
1002
- headers,
1003
- path: resolvedPath,
1004
- body,
1005
- });
603
+ b.m("GET").h(headers).b(body);
604
+ return b.build();
1006
605
  };
1007
606
  export const se_ListPhoneNumberOrdersCommand = async (input, context) => {
1008
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
607
+ const b = rb(input, context);
1009
608
  const headers = {};
1010
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/phone-number-orders";
609
+ b.bp("/phone-number-orders");
1011
610
  const query = map({
1012
- "next-token": [, input.NextToken],
1013
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
611
+ [_nt]: [, input[_NT]],
612
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1014
613
  });
1015
614
  let body;
1016
- return new __HttpRequest({
1017
- protocol,
1018
- hostname,
1019
- port,
1020
- method: "GET",
1021
- headers,
1022
- path: resolvedPath,
1023
- query,
1024
- body,
1025
- });
615
+ b.m("GET").h(headers).q(query).b(body);
616
+ return b.build();
1026
617
  };
1027
618
  export const se_ListPhoneNumbersCommand = async (input, context) => {
1028
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
619
+ const b = rb(input, context);
1029
620
  const headers = {};
1030
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/phone-numbers";
621
+ b.bp("/phone-numbers");
1031
622
  const query = map({
1032
- status: [, input.Status],
1033
- "product-type": [, input.ProductType],
1034
- "filter-name": [, input.FilterName],
1035
- "filter-value": [, input.FilterValue],
1036
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1037
- "next-token": [, input.NextToken],
623
+ [_s]: [, input[_S]],
624
+ [_pt]: [, input[_PT]],
625
+ [_fn]: [, input[_FN]],
626
+ [_fv]: [, input[_FV]],
627
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
628
+ [_nt]: [, input[_NT]],
1038
629
  });
1039
630
  let body;
1040
- return new __HttpRequest({
1041
- protocol,
1042
- hostname,
1043
- port,
1044
- method: "GET",
1045
- headers,
1046
- path: resolvedPath,
1047
- query,
1048
- body,
1049
- });
631
+ b.m("GET").h(headers).q(query).b(body);
632
+ return b.build();
1050
633
  };
1051
634
  export const se_ListProxySessionsCommand = async (input, context) => {
1052
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
635
+ const b = rb(input, context);
1053
636
  const headers = {};
1054
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1055
- "/voice-connectors/{VoiceConnectorId}/proxy-sessions";
1056
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
637
+ b.bp("/voice-connectors/{VoiceConnectorId}/proxy-sessions");
638
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1057
639
  const query = map({
1058
- status: [, input.Status],
1059
- "next-token": [, input.NextToken],
1060
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
640
+ [_s]: [, input[_S]],
641
+ [_nt]: [, input[_NT]],
642
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1061
643
  });
1062
644
  let body;
1063
- return new __HttpRequest({
1064
- protocol,
1065
- hostname,
1066
- port,
1067
- method: "GET",
1068
- headers,
1069
- path: resolvedPath,
1070
- query,
1071
- body,
1072
- });
645
+ b.m("GET").h(headers).q(query).b(body);
646
+ return b.build();
1073
647
  };
1074
648
  export const se_ListSipMediaApplicationsCommand = async (input, context) => {
1075
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
649
+ const b = rb(input, context);
1076
650
  const headers = {};
1077
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sip-media-applications";
651
+ b.bp("/sip-media-applications");
1078
652
  const query = map({
1079
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1080
- "next-token": [, input.NextToken],
653
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
654
+ [_nt]: [, input[_NT]],
1081
655
  });
1082
656
  let body;
1083
- return new __HttpRequest({
1084
- protocol,
1085
- hostname,
1086
- port,
1087
- method: "GET",
1088
- headers,
1089
- path: resolvedPath,
1090
- query,
1091
- body,
1092
- });
657
+ b.m("GET").h(headers).q(query).b(body);
658
+ return b.build();
1093
659
  };
1094
660
  export const se_ListSipRulesCommand = async (input, context) => {
1095
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
661
+ const b = rb(input, context);
1096
662
  const headers = {};
1097
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sip-rules";
663
+ b.bp("/sip-rules");
1098
664
  const query = map({
1099
- "sip-media-application": [, input.SipMediaApplicationId],
1100
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1101
- "next-token": [, input.NextToken],
665
+ [_sma]: [, input[_SMAI]],
666
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
667
+ [_nt]: [, input[_NT]],
1102
668
  });
1103
669
  let body;
1104
- return new __HttpRequest({
1105
- protocol,
1106
- hostname,
1107
- port,
1108
- method: "GET",
1109
- headers,
1110
- path: resolvedPath,
1111
- query,
1112
- body,
1113
- });
670
+ b.m("GET").h(headers).q(query).b(body);
671
+ return b.build();
1114
672
  };
1115
673
  export const se_ListSupportedPhoneNumberCountriesCommand = async (input, context) => {
1116
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
674
+ const b = rb(input, context);
1117
675
  const headers = {};
1118
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/phone-number-countries";
676
+ b.bp("/phone-number-countries");
1119
677
  const query = map({
1120
- "product-type": [, __expectNonNull(input.ProductType, `ProductType`)],
678
+ [_pt]: [, __expectNonNull(input[_PT], `ProductType`)],
1121
679
  });
1122
680
  let body;
1123
- return new __HttpRequest({
1124
- protocol,
1125
- hostname,
1126
- port,
1127
- method: "GET",
1128
- headers,
1129
- path: resolvedPath,
1130
- query,
1131
- body,
1132
- });
681
+ b.m("GET").h(headers).q(query).b(body);
682
+ return b.build();
1133
683
  };
1134
684
  export const se_ListTagsForResourceCommand = async (input, context) => {
1135
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
685
+ const b = rb(input, context);
1136
686
  const headers = {};
1137
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
687
+ b.bp("/tags");
1138
688
  const query = map({
1139
- arn: [, __expectNonNull(input.ResourceARN, `ResourceARN`)],
689
+ [_a]: [, __expectNonNull(input[_RARN], `ResourceARN`)],
1140
690
  });
1141
691
  let body;
1142
- return new __HttpRequest({
1143
- protocol,
1144
- hostname,
1145
- port,
1146
- method: "GET",
1147
- headers,
1148
- path: resolvedPath,
1149
- query,
1150
- body,
1151
- });
692
+ b.m("GET").h(headers).q(query).b(body);
693
+ return b.build();
1152
694
  };
1153
695
  export const se_ListVoiceConnectorGroupsCommand = async (input, context) => {
1154
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
696
+ const b = rb(input, context);
1155
697
  const headers = {};
1156
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-connector-groups";
698
+ b.bp("/voice-connector-groups");
1157
699
  const query = map({
1158
- "next-token": [, input.NextToken],
1159
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
700
+ [_nt]: [, input[_NT]],
701
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1160
702
  });
1161
703
  let body;
1162
- return new __HttpRequest({
1163
- protocol,
1164
- hostname,
1165
- port,
1166
- method: "GET",
1167
- headers,
1168
- path: resolvedPath,
1169
- query,
1170
- body,
1171
- });
704
+ b.m("GET").h(headers).q(query).b(body);
705
+ return b.build();
1172
706
  };
1173
707
  export const se_ListVoiceConnectorsCommand = async (input, context) => {
1174
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
708
+ const b = rb(input, context);
1175
709
  const headers = {};
1176
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-connectors";
710
+ b.bp("/voice-connectors");
1177
711
  const query = map({
1178
- "next-token": [, input.NextToken],
1179
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
712
+ [_nt]: [, input[_NT]],
713
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1180
714
  });
1181
715
  let body;
1182
- return new __HttpRequest({
1183
- protocol,
1184
- hostname,
1185
- port,
1186
- method: "GET",
1187
- headers,
1188
- path: resolvedPath,
1189
- query,
1190
- body,
1191
- });
716
+ b.m("GET").h(headers).q(query).b(body);
717
+ return b.build();
1192
718
  };
1193
719
  export const se_ListVoiceConnectorTerminationCredentialsCommand = async (input, context) => {
1194
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
720
+ const b = rb(input, context);
1195
721
  const headers = {};
1196
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1197
- "/voice-connectors/{VoiceConnectorId}/termination/credentials";
1198
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
722
+ b.bp("/voice-connectors/{VoiceConnectorId}/termination/credentials");
723
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1199
724
  let body;
1200
- return new __HttpRequest({
1201
- protocol,
1202
- hostname,
1203
- port,
1204
- method: "GET",
1205
- headers,
1206
- path: resolvedPath,
1207
- body,
1208
- });
725
+ b.m("GET").h(headers).b(body);
726
+ return b.build();
1209
727
  };
1210
728
  export const se_ListVoiceProfileDomainsCommand = async (input, context) => {
1211
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
729
+ const b = rb(input, context);
1212
730
  const headers = {};
1213
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-profile-domains";
731
+ b.bp("/voice-profile-domains");
1214
732
  const query = map({
1215
- "next-token": [, input.NextToken],
1216
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
733
+ [_nt]: [, input[_NT]],
734
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1217
735
  });
1218
736
  let body;
1219
- return new __HttpRequest({
1220
- protocol,
1221
- hostname,
1222
- port,
1223
- method: "GET",
1224
- headers,
1225
- path: resolvedPath,
1226
- query,
1227
- body,
1228
- });
737
+ b.m("GET").h(headers).q(query).b(body);
738
+ return b.build();
1229
739
  };
1230
740
  export const se_ListVoiceProfilesCommand = async (input, context) => {
1231
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
741
+ const b = rb(input, context);
1232
742
  const headers = {};
1233
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-profiles";
743
+ b.bp("/voice-profiles");
1234
744
  const query = map({
1235
- "voice-profile-domain-id": [, __expectNonNull(input.VoiceProfileDomainId, `VoiceProfileDomainId`)],
1236
- "next-token": [, input.NextToken],
1237
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
745
+ [_vpdi]: [, __expectNonNull(input[_VPDI], `VoiceProfileDomainId`)],
746
+ [_nt]: [, input[_NT]],
747
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1238
748
  });
1239
749
  let body;
1240
- return new __HttpRequest({
1241
- protocol,
1242
- hostname,
1243
- port,
1244
- method: "GET",
1245
- headers,
1246
- path: resolvedPath,
1247
- query,
1248
- body,
1249
- });
750
+ b.m("GET").h(headers).q(query).b(body);
751
+ return b.build();
1250
752
  };
1251
753
  export const se_PutSipMediaApplicationAlexaSkillConfigurationCommand = async (input, context) => {
1252
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
754
+ const b = rb(input, context);
1253
755
  const headers = {
1254
756
  "content-type": "application/json",
1255
757
  };
1256
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1257
- "/sip-media-applications/{SipMediaApplicationId}/alexa-skill-configuration";
1258
- resolvedPath = __resolvedPath(resolvedPath, input, "SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
758
+ b.bp("/sip-media-applications/{SipMediaApplicationId}/alexa-skill-configuration");
759
+ b.p("SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
1259
760
  let body;
1260
761
  body = JSON.stringify(take(input, {
1261
762
  SipMediaApplicationAlexaSkillConfiguration: (_) => _json(_),
1262
763
  }));
1263
- return new __HttpRequest({
1264
- protocol,
1265
- hostname,
1266
- port,
1267
- method: "PUT",
1268
- headers,
1269
- path: resolvedPath,
1270
- body,
1271
- });
764
+ b.m("PUT").h(headers).b(body);
765
+ return b.build();
1272
766
  };
1273
767
  export const se_PutSipMediaApplicationLoggingConfigurationCommand = async (input, context) => {
1274
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
768
+ const b = rb(input, context);
1275
769
  const headers = {
1276
770
  "content-type": "application/json",
1277
771
  };
1278
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1279
- "/sip-media-applications/{SipMediaApplicationId}/logging-configuration";
1280
- resolvedPath = __resolvedPath(resolvedPath, input, "SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
772
+ b.bp("/sip-media-applications/{SipMediaApplicationId}/logging-configuration");
773
+ b.p("SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
1281
774
  let body;
1282
775
  body = JSON.stringify(take(input, {
1283
776
  SipMediaApplicationLoggingConfiguration: (_) => _json(_),
1284
777
  }));
1285
- return new __HttpRequest({
1286
- protocol,
1287
- hostname,
1288
- port,
1289
- method: "PUT",
1290
- headers,
1291
- path: resolvedPath,
1292
- body,
1293
- });
778
+ b.m("PUT").h(headers).b(body);
779
+ return b.build();
1294
780
  };
1295
781
  export const se_PutVoiceConnectorEmergencyCallingConfigurationCommand = async (input, context) => {
1296
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
782
+ const b = rb(input, context);
1297
783
  const headers = {
1298
784
  "content-type": "application/json",
1299
785
  };
1300
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1301
- "/voice-connectors/{VoiceConnectorId}/emergency-calling-configuration";
1302
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
786
+ b.bp("/voice-connectors/{VoiceConnectorId}/emergency-calling-configuration");
787
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1303
788
  let body;
1304
789
  body = JSON.stringify(take(input, {
1305
790
  EmergencyCallingConfiguration: (_) => _json(_),
1306
791
  }));
1307
- return new __HttpRequest({
1308
- protocol,
1309
- hostname,
1310
- port,
1311
- method: "PUT",
1312
- headers,
1313
- path: resolvedPath,
1314
- body,
1315
- });
792
+ b.m("PUT").h(headers).b(body);
793
+ return b.build();
1316
794
  };
1317
795
  export const se_PutVoiceConnectorLoggingConfigurationCommand = async (input, context) => {
1318
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
796
+ const b = rb(input, context);
1319
797
  const headers = {
1320
798
  "content-type": "application/json",
1321
799
  };
1322
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1323
- "/voice-connectors/{VoiceConnectorId}/logging-configuration";
1324
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
800
+ b.bp("/voice-connectors/{VoiceConnectorId}/logging-configuration");
801
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1325
802
  let body;
1326
803
  body = JSON.stringify(take(input, {
1327
804
  LoggingConfiguration: (_) => _json(_),
1328
805
  }));
1329
- return new __HttpRequest({
1330
- protocol,
1331
- hostname,
1332
- port,
1333
- method: "PUT",
1334
- headers,
1335
- path: resolvedPath,
1336
- body,
1337
- });
806
+ b.m("PUT").h(headers).b(body);
807
+ return b.build();
1338
808
  };
1339
809
  export const se_PutVoiceConnectorOriginationCommand = async (input, context) => {
1340
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
810
+ const b = rb(input, context);
1341
811
  const headers = {
1342
812
  "content-type": "application/json",
1343
813
  };
1344
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1345
- "/voice-connectors/{VoiceConnectorId}/origination";
1346
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
814
+ b.bp("/voice-connectors/{VoiceConnectorId}/origination");
815
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1347
816
  let body;
1348
817
  body = JSON.stringify(take(input, {
1349
818
  Origination: (_) => _json(_),
1350
819
  }));
1351
- return new __HttpRequest({
1352
- protocol,
1353
- hostname,
1354
- port,
1355
- method: "PUT",
1356
- headers,
1357
- path: resolvedPath,
1358
- body,
1359
- });
820
+ b.m("PUT").h(headers).b(body);
821
+ return b.build();
1360
822
  };
1361
823
  export const se_PutVoiceConnectorProxyCommand = async (input, context) => {
1362
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
824
+ const b = rb(input, context);
1363
825
  const headers = {
1364
826
  "content-type": "application/json",
1365
827
  };
1366
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1367
- "/voice-connectors/{VoiceConnectorId}/programmable-numbers/proxy";
1368
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
828
+ b.bp("/voice-connectors/{VoiceConnectorId}/programmable-numbers/proxy");
829
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1369
830
  let body;
1370
831
  body = JSON.stringify(take(input, {
1371
832
  DefaultSessionExpiryMinutes: [],
@@ -1373,141 +834,92 @@ export const se_PutVoiceConnectorProxyCommand = async (input, context) => {
1373
834
  FallBackPhoneNumber: [],
1374
835
  PhoneNumberPoolCountries: (_) => _json(_),
1375
836
  }));
1376
- return new __HttpRequest({
1377
- protocol,
1378
- hostname,
1379
- port,
1380
- method: "PUT",
1381
- headers,
1382
- path: resolvedPath,
1383
- body,
1384
- });
837
+ b.m("PUT").h(headers).b(body);
838
+ return b.build();
1385
839
  };
1386
840
  export const se_PutVoiceConnectorStreamingConfigurationCommand = async (input, context) => {
1387
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
841
+ const b = rb(input, context);
1388
842
  const headers = {
1389
843
  "content-type": "application/json",
1390
844
  };
1391
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1392
- "/voice-connectors/{VoiceConnectorId}/streaming-configuration";
1393
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
845
+ b.bp("/voice-connectors/{VoiceConnectorId}/streaming-configuration");
846
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1394
847
  let body;
1395
848
  body = JSON.stringify(take(input, {
1396
849
  StreamingConfiguration: (_) => _json(_),
1397
850
  }));
1398
- return new __HttpRequest({
1399
- protocol,
1400
- hostname,
1401
- port,
1402
- method: "PUT",
1403
- headers,
1404
- path: resolvedPath,
1405
- body,
1406
- });
851
+ b.m("PUT").h(headers).b(body);
852
+ return b.build();
1407
853
  };
1408
854
  export const se_PutVoiceConnectorTerminationCommand = async (input, context) => {
1409
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
855
+ const b = rb(input, context);
1410
856
  const headers = {
1411
857
  "content-type": "application/json",
1412
858
  };
1413
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1414
- "/voice-connectors/{VoiceConnectorId}/termination";
1415
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
859
+ b.bp("/voice-connectors/{VoiceConnectorId}/termination");
860
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1416
861
  let body;
1417
862
  body = JSON.stringify(take(input, {
1418
863
  Termination: (_) => _json(_),
1419
864
  }));
1420
- return new __HttpRequest({
1421
- protocol,
1422
- hostname,
1423
- port,
1424
- method: "PUT",
1425
- headers,
1426
- path: resolvedPath,
1427
- body,
1428
- });
865
+ b.m("PUT").h(headers).b(body);
866
+ return b.build();
1429
867
  };
1430
868
  export const se_PutVoiceConnectorTerminationCredentialsCommand = async (input, context) => {
1431
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
869
+ const b = rb(input, context);
1432
870
  const headers = {
1433
871
  "content-type": "application/json",
1434
872
  };
1435
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1436
- "/voice-connectors/{VoiceConnectorId}/termination/credentials";
1437
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
873
+ b.bp("/voice-connectors/{VoiceConnectorId}/termination/credentials");
874
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1438
875
  const query = map({
1439
- operation: [, "put"],
876
+ [_o]: [, "put"],
1440
877
  });
1441
878
  let body;
1442
879
  body = JSON.stringify(take(input, {
1443
880
  Credentials: (_) => _json(_),
1444
881
  }));
1445
- return new __HttpRequest({
1446
- protocol,
1447
- hostname,
1448
- port,
1449
- method: "POST",
1450
- headers,
1451
- path: resolvedPath,
1452
- query,
1453
- body,
1454
- });
882
+ b.m("POST").h(headers).q(query).b(body);
883
+ return b.build();
1455
884
  };
1456
885
  export const se_RestorePhoneNumberCommand = async (input, context) => {
1457
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
886
+ const b = rb(input, context);
1458
887
  const headers = {};
1459
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/phone-numbers/{PhoneNumberId}";
1460
- resolvedPath = __resolvedPath(resolvedPath, input, "PhoneNumberId", () => input.PhoneNumberId, "{PhoneNumberId}", false);
888
+ b.bp("/phone-numbers/{PhoneNumberId}");
889
+ b.p("PhoneNumberId", () => input.PhoneNumberId, "{PhoneNumberId}", false);
1461
890
  const query = map({
1462
- operation: [, "restore"],
891
+ [_o]: [, "restore"],
1463
892
  });
1464
893
  let body;
1465
- return new __HttpRequest({
1466
- protocol,
1467
- hostname,
1468
- port,
1469
- method: "POST",
1470
- headers,
1471
- path: resolvedPath,
1472
- query,
1473
- body,
1474
- });
894
+ b.m("POST").h(headers).q(query).b(body);
895
+ return b.build();
1475
896
  };
1476
897
  export const se_SearchAvailablePhoneNumbersCommand = async (input, context) => {
1477
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
898
+ const b = rb(input, context);
1478
899
  const headers = {};
1479
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/search";
900
+ b.bp("/search");
1480
901
  const query = map({
1481
- type: [, "phone-numbers"],
1482
- "area-code": [, input.AreaCode],
1483
- city: [, input.City],
1484
- country: [, input.Country],
1485
- state: [, input.State],
1486
- "toll-free-prefix": [, input.TollFreePrefix],
1487
- "phone-number-type": [, input.PhoneNumberType],
1488
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1489
- "next-token": [, input.NextToken],
902
+ [_t]: [, "phone-numbers"],
903
+ [_ac]: [, input[_AC]],
904
+ [_c]: [, input[_C]],
905
+ [_co]: [, input[_Co]],
906
+ [_st]: [, input[_St]],
907
+ [_tfp]: [, input[_TFP]],
908
+ [_pnt]: [, input[_PNT]],
909
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
910
+ [_nt]: [, input[_NT]],
1490
911
  });
1491
912
  let body;
1492
- return new __HttpRequest({
1493
- protocol,
1494
- hostname,
1495
- port,
1496
- method: "GET",
1497
- headers,
1498
- path: resolvedPath,
1499
- query,
1500
- body,
1501
- });
913
+ b.m("GET").h(headers).q(query).b(body);
914
+ return b.build();
1502
915
  };
1503
916
  export const se_StartSpeakerSearchTaskCommand = async (input, context) => {
1504
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
917
+ const b = rb(input, context);
1505
918
  const headers = {
1506
919
  "content-type": "application/json",
1507
920
  };
1508
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1509
- "/voice-connectors/{VoiceConnectorId}/speaker-search-tasks";
1510
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
921
+ b.bp("/voice-connectors/{VoiceConnectorId}/speaker-search-tasks");
922
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1511
923
  let body;
1512
924
  body = JSON.stringify(take(input, {
1513
925
  CallLeg: [],
@@ -1515,385 +927,254 @@ export const se_StartSpeakerSearchTaskCommand = async (input, context) => {
1515
927
  TransactionId: [],
1516
928
  VoiceProfileDomainId: [],
1517
929
  }));
1518
- return new __HttpRequest({
1519
- protocol,
1520
- hostname,
1521
- port,
1522
- method: "POST",
1523
- headers,
1524
- path: resolvedPath,
1525
- body,
1526
- });
930
+ b.m("POST").h(headers).b(body);
931
+ return b.build();
1527
932
  };
1528
933
  export const se_StartVoiceToneAnalysisTaskCommand = async (input, context) => {
1529
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
934
+ const b = rb(input, context);
1530
935
  const headers = {
1531
936
  "content-type": "application/json",
1532
937
  };
1533
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1534
- "/voice-connectors/{VoiceConnectorId}/voice-tone-analysis-tasks";
1535
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
938
+ b.bp("/voice-connectors/{VoiceConnectorId}/voice-tone-analysis-tasks");
939
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1536
940
  let body;
1537
941
  body = JSON.stringify(take(input, {
1538
942
  ClientRequestToken: [],
1539
943
  LanguageCode: [],
1540
944
  TransactionId: [],
1541
945
  }));
1542
- return new __HttpRequest({
1543
- protocol,
1544
- hostname,
1545
- port,
1546
- method: "POST",
1547
- headers,
1548
- path: resolvedPath,
1549
- body,
1550
- });
946
+ b.m("POST").h(headers).b(body);
947
+ return b.build();
1551
948
  };
1552
949
  export const se_StopSpeakerSearchTaskCommand = async (input, context) => {
1553
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
950
+ const b = rb(input, context);
1554
951
  const headers = {};
1555
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1556
- "/voice-connectors/{VoiceConnectorId}/speaker-search-tasks/{SpeakerSearchTaskId}";
1557
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1558
- resolvedPath = __resolvedPath(resolvedPath, input, "SpeakerSearchTaskId", () => input.SpeakerSearchTaskId, "{SpeakerSearchTaskId}", false);
952
+ b.bp("/voice-connectors/{VoiceConnectorId}/speaker-search-tasks/{SpeakerSearchTaskId}");
953
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
954
+ b.p("SpeakerSearchTaskId", () => input.SpeakerSearchTaskId, "{SpeakerSearchTaskId}", false);
1559
955
  const query = map({
1560
- operation: [, "stop"],
956
+ [_o]: [, "stop"],
1561
957
  });
1562
958
  let body;
1563
- return new __HttpRequest({
1564
- protocol,
1565
- hostname,
1566
- port,
1567
- method: "POST",
1568
- headers,
1569
- path: resolvedPath,
1570
- query,
1571
- body,
1572
- });
959
+ b.m("POST").h(headers).q(query).b(body);
960
+ return b.build();
1573
961
  };
1574
962
  export const se_StopVoiceToneAnalysisTaskCommand = async (input, context) => {
1575
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
963
+ const b = rb(input, context);
1576
964
  const headers = {};
1577
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1578
- "/voice-connectors/{VoiceConnectorId}/voice-tone-analysis-tasks/{VoiceToneAnalysisTaskId}";
1579
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1580
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceToneAnalysisTaskId", () => input.VoiceToneAnalysisTaskId, "{VoiceToneAnalysisTaskId}", false);
965
+ b.bp("/voice-connectors/{VoiceConnectorId}/voice-tone-analysis-tasks/{VoiceToneAnalysisTaskId}");
966
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
967
+ b.p("VoiceToneAnalysisTaskId", () => input.VoiceToneAnalysisTaskId, "{VoiceToneAnalysisTaskId}", false);
1581
968
  const query = map({
1582
- operation: [, "stop"],
969
+ [_o]: [, "stop"],
1583
970
  });
1584
971
  let body;
1585
- return new __HttpRequest({
1586
- protocol,
1587
- hostname,
1588
- port,
1589
- method: "POST",
1590
- headers,
1591
- path: resolvedPath,
1592
- query,
1593
- body,
1594
- });
972
+ b.m("POST").h(headers).q(query).b(body);
973
+ return b.build();
1595
974
  };
1596
975
  export const se_TagResourceCommand = async (input, context) => {
1597
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
976
+ const b = rb(input, context);
1598
977
  const headers = {
1599
978
  "content-type": "application/json",
1600
979
  };
1601
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
980
+ b.bp("/tags");
1602
981
  const query = map({
1603
- operation: [, "tag-resource"],
982
+ [_o]: [, "tag-resource"],
1604
983
  });
1605
984
  let body;
1606
985
  body = JSON.stringify(take(input, {
1607
986
  ResourceARN: [],
1608
987
  Tags: (_) => _json(_),
1609
988
  }));
1610
- return new __HttpRequest({
1611
- protocol,
1612
- hostname,
1613
- port,
1614
- method: "POST",
1615
- headers,
1616
- path: resolvedPath,
1617
- query,
1618
- body,
1619
- });
989
+ b.m("POST").h(headers).q(query).b(body);
990
+ return b.build();
1620
991
  };
1621
992
  export const se_UntagResourceCommand = async (input, context) => {
1622
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
993
+ const b = rb(input, context);
1623
994
  const headers = {
1624
995
  "content-type": "application/json",
1625
996
  };
1626
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
997
+ b.bp("/tags");
1627
998
  const query = map({
1628
- operation: [, "untag-resource"],
999
+ [_o]: [, "untag-resource"],
1629
1000
  });
1630
1001
  let body;
1631
1002
  body = JSON.stringify(take(input, {
1632
1003
  ResourceARN: [],
1633
1004
  TagKeys: (_) => _json(_),
1634
1005
  }));
1635
- return new __HttpRequest({
1636
- protocol,
1637
- hostname,
1638
- port,
1639
- method: "POST",
1640
- headers,
1641
- path: resolvedPath,
1642
- query,
1643
- body,
1644
- });
1006
+ b.m("POST").h(headers).q(query).b(body);
1007
+ return b.build();
1645
1008
  };
1646
1009
  export const se_UpdateGlobalSettingsCommand = async (input, context) => {
1647
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1010
+ const b = rb(input, context);
1648
1011
  const headers = {
1649
1012
  "content-type": "application/json",
1650
1013
  };
1651
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/settings";
1014
+ b.bp("/settings");
1652
1015
  let body;
1653
1016
  body = JSON.stringify(take(input, {
1654
1017
  VoiceConnector: (_) => _json(_),
1655
1018
  }));
1656
- return new __HttpRequest({
1657
- protocol,
1658
- hostname,
1659
- port,
1660
- method: "PUT",
1661
- headers,
1662
- path: resolvedPath,
1663
- body,
1664
- });
1019
+ b.m("PUT").h(headers).b(body);
1020
+ return b.build();
1665
1021
  };
1666
1022
  export const se_UpdatePhoneNumberCommand = async (input, context) => {
1667
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1023
+ const b = rb(input, context);
1668
1024
  const headers = {
1669
1025
  "content-type": "application/json",
1670
1026
  };
1671
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/phone-numbers/{PhoneNumberId}";
1672
- resolvedPath = __resolvedPath(resolvedPath, input, "PhoneNumberId", () => input.PhoneNumberId, "{PhoneNumberId}", false);
1027
+ b.bp("/phone-numbers/{PhoneNumberId}");
1028
+ b.p("PhoneNumberId", () => input.PhoneNumberId, "{PhoneNumberId}", false);
1673
1029
  let body;
1674
1030
  body = JSON.stringify(take(input, {
1675
1031
  CallingName: [],
1676
1032
  Name: [],
1677
1033
  ProductType: [],
1678
1034
  }));
1679
- return new __HttpRequest({
1680
- protocol,
1681
- hostname,
1682
- port,
1683
- method: "POST",
1684
- headers,
1685
- path: resolvedPath,
1686
- body,
1687
- });
1035
+ b.m("POST").h(headers).b(body);
1036
+ return b.build();
1688
1037
  };
1689
1038
  export const se_UpdatePhoneNumberSettingsCommand = async (input, context) => {
1690
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1039
+ const b = rb(input, context);
1691
1040
  const headers = {
1692
1041
  "content-type": "application/json",
1693
1042
  };
1694
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/settings/phone-number";
1043
+ b.bp("/settings/phone-number");
1695
1044
  let body;
1696
1045
  body = JSON.stringify(take(input, {
1697
1046
  CallingName: [],
1698
1047
  }));
1699
- return new __HttpRequest({
1700
- protocol,
1701
- hostname,
1702
- port,
1703
- method: "PUT",
1704
- headers,
1705
- path: resolvedPath,
1706
- body,
1707
- });
1048
+ b.m("PUT").h(headers).b(body);
1049
+ return b.build();
1708
1050
  };
1709
1051
  export const se_UpdateProxySessionCommand = async (input, context) => {
1710
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1052
+ const b = rb(input, context);
1711
1053
  const headers = {
1712
1054
  "content-type": "application/json",
1713
1055
  };
1714
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1715
- "/voice-connectors/{VoiceConnectorId}/proxy-sessions/{ProxySessionId}";
1716
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1717
- resolvedPath = __resolvedPath(resolvedPath, input, "ProxySessionId", () => input.ProxySessionId, "{ProxySessionId}", false);
1056
+ b.bp("/voice-connectors/{VoiceConnectorId}/proxy-sessions/{ProxySessionId}");
1057
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1058
+ b.p("ProxySessionId", () => input.ProxySessionId, "{ProxySessionId}", false);
1718
1059
  let body;
1719
1060
  body = JSON.stringify(take(input, {
1720
1061
  Capabilities: (_) => _json(_),
1721
1062
  ExpiryMinutes: [],
1722
1063
  }));
1723
- return new __HttpRequest({
1724
- protocol,
1725
- hostname,
1726
- port,
1727
- method: "POST",
1728
- headers,
1729
- path: resolvedPath,
1730
- body,
1731
- });
1064
+ b.m("POST").h(headers).b(body);
1065
+ return b.build();
1732
1066
  };
1733
1067
  export const se_UpdateSipMediaApplicationCommand = async (input, context) => {
1734
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1068
+ const b = rb(input, context);
1735
1069
  const headers = {
1736
1070
  "content-type": "application/json",
1737
1071
  };
1738
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1739
- "/sip-media-applications/{SipMediaApplicationId}";
1740
- resolvedPath = __resolvedPath(resolvedPath, input, "SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
1072
+ b.bp("/sip-media-applications/{SipMediaApplicationId}");
1073
+ b.p("SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
1741
1074
  let body;
1742
1075
  body = JSON.stringify(take(input, {
1743
1076
  Endpoints: (_) => _json(_),
1744
1077
  Name: [],
1745
1078
  }));
1746
- return new __HttpRequest({
1747
- protocol,
1748
- hostname,
1749
- port,
1750
- method: "PUT",
1751
- headers,
1752
- path: resolvedPath,
1753
- body,
1754
- });
1079
+ b.m("PUT").h(headers).b(body);
1080
+ return b.build();
1755
1081
  };
1756
1082
  export const se_UpdateSipMediaApplicationCallCommand = async (input, context) => {
1757
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1083
+ const b = rb(input, context);
1758
1084
  const headers = {
1759
1085
  "content-type": "application/json",
1760
1086
  };
1761
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1762
- "/sip-media-applications/{SipMediaApplicationId}/calls/{TransactionId}";
1763
- resolvedPath = __resolvedPath(resolvedPath, input, "SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
1764
- resolvedPath = __resolvedPath(resolvedPath, input, "TransactionId", () => input.TransactionId, "{TransactionId}", false);
1087
+ b.bp("/sip-media-applications/{SipMediaApplicationId}/calls/{TransactionId}");
1088
+ b.p("SipMediaApplicationId", () => input.SipMediaApplicationId, "{SipMediaApplicationId}", false);
1089
+ b.p("TransactionId", () => input.TransactionId, "{TransactionId}", false);
1765
1090
  let body;
1766
1091
  body = JSON.stringify(take(input, {
1767
1092
  Arguments: (_) => _json(_),
1768
1093
  }));
1769
- return new __HttpRequest({
1770
- protocol,
1771
- hostname,
1772
- port,
1773
- method: "POST",
1774
- headers,
1775
- path: resolvedPath,
1776
- body,
1777
- });
1094
+ b.m("POST").h(headers).b(body);
1095
+ return b.build();
1778
1096
  };
1779
1097
  export const se_UpdateSipRuleCommand = async (input, context) => {
1780
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1098
+ const b = rb(input, context);
1781
1099
  const headers = {
1782
1100
  "content-type": "application/json",
1783
1101
  };
1784
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sip-rules/{SipRuleId}";
1785
- resolvedPath = __resolvedPath(resolvedPath, input, "SipRuleId", () => input.SipRuleId, "{SipRuleId}", false);
1102
+ b.bp("/sip-rules/{SipRuleId}");
1103
+ b.p("SipRuleId", () => input.SipRuleId, "{SipRuleId}", false);
1786
1104
  let body;
1787
1105
  body = JSON.stringify(take(input, {
1788
1106
  Disabled: [],
1789
1107
  Name: [],
1790
1108
  TargetApplications: (_) => _json(_),
1791
1109
  }));
1792
- return new __HttpRequest({
1793
- protocol,
1794
- hostname,
1795
- port,
1796
- method: "PUT",
1797
- headers,
1798
- path: resolvedPath,
1799
- body,
1800
- });
1110
+ b.m("PUT").h(headers).b(body);
1111
+ return b.build();
1801
1112
  };
1802
1113
  export const se_UpdateVoiceConnectorCommand = async (input, context) => {
1803
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1114
+ const b = rb(input, context);
1804
1115
  const headers = {
1805
1116
  "content-type": "application/json",
1806
1117
  };
1807
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-connectors/{VoiceConnectorId}";
1808
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1118
+ b.bp("/voice-connectors/{VoiceConnectorId}");
1119
+ b.p("VoiceConnectorId", () => input.VoiceConnectorId, "{VoiceConnectorId}", false);
1809
1120
  let body;
1810
1121
  body = JSON.stringify(take(input, {
1811
1122
  Name: [],
1812
1123
  RequireEncryption: [],
1813
1124
  }));
1814
- return new __HttpRequest({
1815
- protocol,
1816
- hostname,
1817
- port,
1818
- method: "PUT",
1819
- headers,
1820
- path: resolvedPath,
1821
- body,
1822
- });
1125
+ b.m("PUT").h(headers).b(body);
1126
+ return b.build();
1823
1127
  };
1824
1128
  export const se_UpdateVoiceConnectorGroupCommand = async (input, context) => {
1825
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1129
+ const b = rb(input, context);
1826
1130
  const headers = {
1827
1131
  "content-type": "application/json",
1828
1132
  };
1829
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1830
- "/voice-connector-groups/{VoiceConnectorGroupId}";
1831
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceConnectorGroupId", () => input.VoiceConnectorGroupId, "{VoiceConnectorGroupId}", false);
1133
+ b.bp("/voice-connector-groups/{VoiceConnectorGroupId}");
1134
+ b.p("VoiceConnectorGroupId", () => input.VoiceConnectorGroupId, "{VoiceConnectorGroupId}", false);
1832
1135
  let body;
1833
1136
  body = JSON.stringify(take(input, {
1834
1137
  Name: [],
1835
1138
  VoiceConnectorItems: (_) => _json(_),
1836
1139
  }));
1837
- return new __HttpRequest({
1838
- protocol,
1839
- hostname,
1840
- port,
1841
- method: "PUT",
1842
- headers,
1843
- path: resolvedPath,
1844
- body,
1845
- });
1140
+ b.m("PUT").h(headers).b(body);
1141
+ return b.build();
1846
1142
  };
1847
1143
  export const se_UpdateVoiceProfileCommand = async (input, context) => {
1848
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1144
+ const b = rb(input, context);
1849
1145
  const headers = {
1850
1146
  "content-type": "application/json",
1851
1147
  };
1852
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/voice-profiles/{VoiceProfileId}";
1853
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceProfileId", () => input.VoiceProfileId, "{VoiceProfileId}", false);
1148
+ b.bp("/voice-profiles/{VoiceProfileId}");
1149
+ b.p("VoiceProfileId", () => input.VoiceProfileId, "{VoiceProfileId}", false);
1854
1150
  let body;
1855
1151
  body = JSON.stringify(take(input, {
1856
1152
  SpeakerSearchTaskId: [],
1857
1153
  }));
1858
- return new __HttpRequest({
1859
- protocol,
1860
- hostname,
1861
- port,
1862
- method: "PUT",
1863
- headers,
1864
- path: resolvedPath,
1865
- body,
1866
- });
1154
+ b.m("PUT").h(headers).b(body);
1155
+ return b.build();
1867
1156
  };
1868
1157
  export const se_UpdateVoiceProfileDomainCommand = async (input, context) => {
1869
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1158
+ const b = rb(input, context);
1870
1159
  const headers = {
1871
1160
  "content-type": "application/json",
1872
1161
  };
1873
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1874
- "/voice-profile-domains/{VoiceProfileDomainId}";
1875
- resolvedPath = __resolvedPath(resolvedPath, input, "VoiceProfileDomainId", () => input.VoiceProfileDomainId, "{VoiceProfileDomainId}", false);
1162
+ b.bp("/voice-profile-domains/{VoiceProfileDomainId}");
1163
+ b.p("VoiceProfileDomainId", () => input.VoiceProfileDomainId, "{VoiceProfileDomainId}", false);
1876
1164
  let body;
1877
1165
  body = JSON.stringify(take(input, {
1878
1166
  Description: [],
1879
1167
  Name: [],
1880
1168
  }));
1881
- return new __HttpRequest({
1882
- protocol,
1883
- hostname,
1884
- port,
1885
- method: "PUT",
1886
- headers,
1887
- path: resolvedPath,
1888
- body,
1889
- });
1169
+ b.m("PUT").h(headers).b(body);
1170
+ return b.build();
1890
1171
  };
1891
1172
  export const se_ValidateE911AddressCommand = async (input, context) => {
1892
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1173
+ const b = rb(input, context);
1893
1174
  const headers = {
1894
1175
  "content-type": "application/json",
1895
1176
  };
1896
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/emergency-calling/address";
1177
+ b.bp("/emergency-calling/address");
1897
1178
  let body;
1898
1179
  body = JSON.stringify(take(input, {
1899
1180
  AwsAccountId: [],
@@ -1904,15 +1185,8 @@ export const se_ValidateE911AddressCommand = async (input, context) => {
1904
1185
  StreetInfo: [],
1905
1186
  StreetNumber: [],
1906
1187
  }));
1907
- return new __HttpRequest({
1908
- protocol,
1909
- hostname,
1910
- port,
1911
- method: "POST",
1912
- headers,
1913
- path: resolvedPath,
1914
- body,
1915
- });
1188
+ b.m("POST").h(headers).b(body);
1189
+ return b.build();
1916
1190
  };
1917
1191
  export const de_AssociatePhoneNumbersWithVoiceConnectorCommand = async (output, context) => {
1918
1192
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -7178,6 +6452,40 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
7178
6452
  value !== "" &&
7179
6453
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
7180
6454
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
6455
+ const _AC = "AreaCode";
6456
+ const _C = "City";
6457
+ const _Co = "Country";
6458
+ const _FN = "FilterName";
6459
+ const _FV = "FilterValue";
6460
+ const _IC = "IsCaller";
6461
+ const _MR = "MaxResults";
6462
+ const _NT = "NextToken";
6463
+ const _PNT = "PhoneNumberType";
6464
+ const _PT = "ProductType";
6465
+ const _RARN = "ResourceARN";
6466
+ const _S = "Status";
6467
+ const _SMAI = "SipMediaApplicationId";
6468
+ const _St = "State";
6469
+ const _TFP = "TollFreePrefix";
6470
+ const _VPDI = "VoiceProfileDomainId";
6471
+ const _a = "arn";
6472
+ const _ac = "area-code";
6473
+ const _c = "city";
6474
+ const _co = "country";
6475
+ const _fn = "filter-name";
6476
+ const _fv = "filter-value";
6477
+ const _iC = "isCaller";
6478
+ const _mr = "max-results";
6479
+ const _nt = "next-token";
6480
+ const _o = "operation";
6481
+ const _pnt = "phone-number-type";
6482
+ const _pt = "product-type";
6483
+ const _s = "status";
6484
+ const _sma = "sip-media-application";
6485
+ const _st = "state";
6486
+ const _t = "type";
6487
+ const _tfp = "toll-free-prefix";
6488
+ const _vpdi = "voice-profile-domain-id";
7181
6489
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
7182
6490
  if (encoded.length) {
7183
6491
  return JSON.parse(encoded);