@aws-sdk/client-ivs 3.474.0 → 3.477.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/protocols/Aws_restJson1.js +127 -337
  2. package/dist-es/protocols/Aws_restJson1.js +128 -338
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,73 +1,52 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, 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, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { IvsServiceException as __BaseException } from "../models/IvsServiceException";
4
4
  import { AccessDeniedException, ChannelNotBroadcasting, ConflictException, InternalServerException, PendingVerification, ResourceNotFoundException, ServiceQuotaExceededException, StreamUnavailable, ThrottlingException, ValidationException, } from "../models/models_0";
5
5
  export const se_BatchGetChannelCommand = async (input, context) => {
6
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
6
+ const b = rb(input, context);
7
7
  const headers = {
8
8
  "content-type": "application/json",
9
9
  };
10
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/BatchGetChannel";
10
+ b.bp("/BatchGetChannel");
11
11
  let body;
12
12
  body = JSON.stringify(take(input, {
13
13
  arns: (_) => _json(_),
14
14
  }));
15
- return new __HttpRequest({
16
- protocol,
17
- hostname,
18
- port,
19
- method: "POST",
20
- headers,
21
- path: resolvedPath,
22
- body,
23
- });
15
+ b.m("POST").h(headers).b(body);
16
+ return b.build();
24
17
  };
25
18
  export const se_BatchGetStreamKeyCommand = async (input, context) => {
26
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
19
+ const b = rb(input, context);
27
20
  const headers = {
28
21
  "content-type": "application/json",
29
22
  };
30
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/BatchGetStreamKey";
23
+ b.bp("/BatchGetStreamKey");
31
24
  let body;
32
25
  body = JSON.stringify(take(input, {
33
26
  arns: (_) => _json(_),
34
27
  }));
35
- return new __HttpRequest({
36
- protocol,
37
- hostname,
38
- port,
39
- method: "POST",
40
- headers,
41
- path: resolvedPath,
42
- body,
43
- });
28
+ b.m("POST").h(headers).b(body);
29
+ return b.build();
44
30
  };
45
31
  export const se_BatchStartViewerSessionRevocationCommand = async (input, context) => {
46
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
32
+ const b = rb(input, context);
47
33
  const headers = {
48
34
  "content-type": "application/json",
49
35
  };
50
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/BatchStartViewerSessionRevocation";
36
+ b.bp("/BatchStartViewerSessionRevocation");
51
37
  let body;
52
38
  body = JSON.stringify(take(input, {
53
39
  viewerSessions: (_) => _json(_),
54
40
  }));
55
- return new __HttpRequest({
56
- protocol,
57
- hostname,
58
- port,
59
- method: "POST",
60
- headers,
61
- path: resolvedPath,
62
- body,
63
- });
41
+ b.m("POST").h(headers).b(body);
42
+ return b.build();
64
43
  };
65
44
  export const se_CreateChannelCommand = async (input, context) => {
66
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
45
+ const b = rb(input, context);
67
46
  const headers = {
68
47
  "content-type": "application/json",
69
48
  };
70
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateChannel";
49
+ b.bp("/CreateChannel");
71
50
  let body;
72
51
  body = JSON.stringify(take(input, {
73
52
  authorized: [],
@@ -79,22 +58,15 @@ export const se_CreateChannelCommand = async (input, context) => {
79
58
  tags: (_) => _json(_),
80
59
  type: [],
81
60
  }));
82
- return new __HttpRequest({
83
- protocol,
84
- hostname,
85
- port,
86
- method: "POST",
87
- headers,
88
- path: resolvedPath,
89
- body,
90
- });
61
+ b.m("POST").h(headers).b(body);
62
+ return b.build();
91
63
  };
92
64
  export const se_CreateRecordingConfigurationCommand = async (input, context) => {
93
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
65
+ const b = rb(input, context);
94
66
  const headers = {
95
67
  "content-type": "application/json",
96
68
  };
97
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateRecordingConfiguration";
69
+ b.bp("/CreateRecordingConfiguration");
98
70
  let body;
99
71
  body = JSON.stringify(take(input, {
100
72
  destinationConfiguration: (_) => _json(_),
@@ -104,266 +76,175 @@ export const se_CreateRecordingConfigurationCommand = async (input, context) =>
104
76
  tags: (_) => _json(_),
105
77
  thumbnailConfiguration: (_) => _json(_),
106
78
  }));
107
- return new __HttpRequest({
108
- protocol,
109
- hostname,
110
- port,
111
- method: "POST",
112
- headers,
113
- path: resolvedPath,
114
- body,
115
- });
79
+ b.m("POST").h(headers).b(body);
80
+ return b.build();
116
81
  };
117
82
  export const se_CreateStreamKeyCommand = async (input, context) => {
118
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
83
+ const b = rb(input, context);
119
84
  const headers = {
120
85
  "content-type": "application/json",
121
86
  };
122
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/CreateStreamKey";
87
+ b.bp("/CreateStreamKey");
123
88
  let body;
124
89
  body = JSON.stringify(take(input, {
125
90
  channelArn: [],
126
91
  tags: (_) => _json(_),
127
92
  }));
128
- return new __HttpRequest({
129
- protocol,
130
- hostname,
131
- port,
132
- method: "POST",
133
- headers,
134
- path: resolvedPath,
135
- body,
136
- });
93
+ b.m("POST").h(headers).b(body);
94
+ return b.build();
137
95
  };
138
96
  export const se_DeleteChannelCommand = async (input, context) => {
139
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
97
+ const b = rb(input, context);
140
98
  const headers = {
141
99
  "content-type": "application/json",
142
100
  };
143
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteChannel";
101
+ b.bp("/DeleteChannel");
144
102
  let body;
145
103
  body = JSON.stringify(take(input, {
146
104
  arn: [],
147
105
  }));
148
- return new __HttpRequest({
149
- protocol,
150
- hostname,
151
- port,
152
- method: "POST",
153
- headers,
154
- path: resolvedPath,
155
- body,
156
- });
106
+ b.m("POST").h(headers).b(body);
107
+ return b.build();
157
108
  };
158
109
  export const se_DeletePlaybackKeyPairCommand = async (input, context) => {
159
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
110
+ const b = rb(input, context);
160
111
  const headers = {
161
112
  "content-type": "application/json",
162
113
  };
163
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeletePlaybackKeyPair";
114
+ b.bp("/DeletePlaybackKeyPair");
164
115
  let body;
165
116
  body = JSON.stringify(take(input, {
166
117
  arn: [],
167
118
  }));
168
- return new __HttpRequest({
169
- protocol,
170
- hostname,
171
- port,
172
- method: "POST",
173
- headers,
174
- path: resolvedPath,
175
- body,
176
- });
119
+ b.m("POST").h(headers).b(body);
120
+ return b.build();
177
121
  };
178
122
  export const se_DeleteRecordingConfigurationCommand = async (input, context) => {
179
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
123
+ const b = rb(input, context);
180
124
  const headers = {
181
125
  "content-type": "application/json",
182
126
  };
183
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteRecordingConfiguration";
127
+ b.bp("/DeleteRecordingConfiguration");
184
128
  let body;
185
129
  body = JSON.stringify(take(input, {
186
130
  arn: [],
187
131
  }));
188
- return new __HttpRequest({
189
- protocol,
190
- hostname,
191
- port,
192
- method: "POST",
193
- headers,
194
- path: resolvedPath,
195
- body,
196
- });
132
+ b.m("POST").h(headers).b(body);
133
+ return b.build();
197
134
  };
198
135
  export const se_DeleteStreamKeyCommand = async (input, context) => {
199
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
136
+ const b = rb(input, context);
200
137
  const headers = {
201
138
  "content-type": "application/json",
202
139
  };
203
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteStreamKey";
140
+ b.bp("/DeleteStreamKey");
204
141
  let body;
205
142
  body = JSON.stringify(take(input, {
206
143
  arn: [],
207
144
  }));
208
- return new __HttpRequest({
209
- protocol,
210
- hostname,
211
- port,
212
- method: "POST",
213
- headers,
214
- path: resolvedPath,
215
- body,
216
- });
145
+ b.m("POST").h(headers).b(body);
146
+ return b.build();
217
147
  };
218
148
  export const se_GetChannelCommand = async (input, context) => {
219
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
149
+ const b = rb(input, context);
220
150
  const headers = {
221
151
  "content-type": "application/json",
222
152
  };
223
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetChannel";
153
+ b.bp("/GetChannel");
224
154
  let body;
225
155
  body = JSON.stringify(take(input, {
226
156
  arn: [],
227
157
  }));
228
- return new __HttpRequest({
229
- protocol,
230
- hostname,
231
- port,
232
- method: "POST",
233
- headers,
234
- path: resolvedPath,
235
- body,
236
- });
158
+ b.m("POST").h(headers).b(body);
159
+ return b.build();
237
160
  };
238
161
  export const se_GetPlaybackKeyPairCommand = async (input, context) => {
239
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
162
+ const b = rb(input, context);
240
163
  const headers = {
241
164
  "content-type": "application/json",
242
165
  };
243
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetPlaybackKeyPair";
166
+ b.bp("/GetPlaybackKeyPair");
244
167
  let body;
245
168
  body = JSON.stringify(take(input, {
246
169
  arn: [],
247
170
  }));
248
- return new __HttpRequest({
249
- protocol,
250
- hostname,
251
- port,
252
- method: "POST",
253
- headers,
254
- path: resolvedPath,
255
- body,
256
- });
171
+ b.m("POST").h(headers).b(body);
172
+ return b.build();
257
173
  };
258
174
  export const se_GetRecordingConfigurationCommand = async (input, context) => {
259
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
175
+ const b = rb(input, context);
260
176
  const headers = {
261
177
  "content-type": "application/json",
262
178
  };
263
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetRecordingConfiguration";
179
+ b.bp("/GetRecordingConfiguration");
264
180
  let body;
265
181
  body = JSON.stringify(take(input, {
266
182
  arn: [],
267
183
  }));
268
- return new __HttpRequest({
269
- protocol,
270
- hostname,
271
- port,
272
- method: "POST",
273
- headers,
274
- path: resolvedPath,
275
- body,
276
- });
184
+ b.m("POST").h(headers).b(body);
185
+ return b.build();
277
186
  };
278
187
  export const se_GetStreamCommand = async (input, context) => {
279
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
188
+ const b = rb(input, context);
280
189
  const headers = {
281
190
  "content-type": "application/json",
282
191
  };
283
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetStream";
192
+ b.bp("/GetStream");
284
193
  let body;
285
194
  body = JSON.stringify(take(input, {
286
195
  channelArn: [],
287
196
  }));
288
- return new __HttpRequest({
289
- protocol,
290
- hostname,
291
- port,
292
- method: "POST",
293
- headers,
294
- path: resolvedPath,
295
- body,
296
- });
197
+ b.m("POST").h(headers).b(body);
198
+ return b.build();
297
199
  };
298
200
  export const se_GetStreamKeyCommand = async (input, context) => {
299
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
201
+ const b = rb(input, context);
300
202
  const headers = {
301
203
  "content-type": "application/json",
302
204
  };
303
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetStreamKey";
205
+ b.bp("/GetStreamKey");
304
206
  let body;
305
207
  body = JSON.stringify(take(input, {
306
208
  arn: [],
307
209
  }));
308
- return new __HttpRequest({
309
- protocol,
310
- hostname,
311
- port,
312
- method: "POST",
313
- headers,
314
- path: resolvedPath,
315
- body,
316
- });
210
+ b.m("POST").h(headers).b(body);
211
+ return b.build();
317
212
  };
318
213
  export const se_GetStreamSessionCommand = async (input, context) => {
319
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
214
+ const b = rb(input, context);
320
215
  const headers = {
321
216
  "content-type": "application/json",
322
217
  };
323
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/GetStreamSession";
218
+ b.bp("/GetStreamSession");
324
219
  let body;
325
220
  body = JSON.stringify(take(input, {
326
221
  channelArn: [],
327
222
  streamId: [],
328
223
  }));
329
- return new __HttpRequest({
330
- protocol,
331
- hostname,
332
- port,
333
- method: "POST",
334
- headers,
335
- path: resolvedPath,
336
- body,
337
- });
224
+ b.m("POST").h(headers).b(body);
225
+ return b.build();
338
226
  };
339
227
  export const se_ImportPlaybackKeyPairCommand = async (input, context) => {
340
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
228
+ const b = rb(input, context);
341
229
  const headers = {
342
230
  "content-type": "application/json",
343
231
  };
344
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ImportPlaybackKeyPair";
232
+ b.bp("/ImportPlaybackKeyPair");
345
233
  let body;
346
234
  body = JSON.stringify(take(input, {
347
235
  name: [],
348
236
  publicKeyMaterial: [],
349
237
  tags: (_) => _json(_),
350
238
  }));
351
- return new __HttpRequest({
352
- protocol,
353
- hostname,
354
- port,
355
- method: "POST",
356
- headers,
357
- path: resolvedPath,
358
- body,
359
- });
239
+ b.m("POST").h(headers).b(body);
240
+ return b.build();
360
241
  };
361
242
  export const se_ListChannelsCommand = async (input, context) => {
362
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
243
+ const b = rb(input, context);
363
244
  const headers = {
364
245
  "content-type": "application/json",
365
246
  };
366
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListChannels";
247
+ b.bp("/ListChannels");
367
248
  let body;
368
249
  body = JSON.stringify(take(input, {
369
250
  filterByName: [],
@@ -371,253 +252,168 @@ export const se_ListChannelsCommand = async (input, context) => {
371
252
  maxResults: [],
372
253
  nextToken: [],
373
254
  }));
374
- return new __HttpRequest({
375
- protocol,
376
- hostname,
377
- port,
378
- method: "POST",
379
- headers,
380
- path: resolvedPath,
381
- body,
382
- });
255
+ b.m("POST").h(headers).b(body);
256
+ return b.build();
383
257
  };
384
258
  export const se_ListPlaybackKeyPairsCommand = async (input, context) => {
385
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
259
+ const b = rb(input, context);
386
260
  const headers = {
387
261
  "content-type": "application/json",
388
262
  };
389
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListPlaybackKeyPairs";
263
+ b.bp("/ListPlaybackKeyPairs");
390
264
  let body;
391
265
  body = JSON.stringify(take(input, {
392
266
  maxResults: [],
393
267
  nextToken: [],
394
268
  }));
395
- return new __HttpRequest({
396
- protocol,
397
- hostname,
398
- port,
399
- method: "POST",
400
- headers,
401
- path: resolvedPath,
402
- body,
403
- });
269
+ b.m("POST").h(headers).b(body);
270
+ return b.build();
404
271
  };
405
272
  export const se_ListRecordingConfigurationsCommand = async (input, context) => {
406
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
273
+ const b = rb(input, context);
407
274
  const headers = {
408
275
  "content-type": "application/json",
409
276
  };
410
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListRecordingConfigurations";
277
+ b.bp("/ListRecordingConfigurations");
411
278
  let body;
412
279
  body = JSON.stringify(take(input, {
413
280
  maxResults: [],
414
281
  nextToken: [],
415
282
  }));
416
- return new __HttpRequest({
417
- protocol,
418
- hostname,
419
- port,
420
- method: "POST",
421
- headers,
422
- path: resolvedPath,
423
- body,
424
- });
283
+ b.m("POST").h(headers).b(body);
284
+ return b.build();
425
285
  };
426
286
  export const se_ListStreamKeysCommand = async (input, context) => {
427
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
287
+ const b = rb(input, context);
428
288
  const headers = {
429
289
  "content-type": "application/json",
430
290
  };
431
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListStreamKeys";
291
+ b.bp("/ListStreamKeys");
432
292
  let body;
433
293
  body = JSON.stringify(take(input, {
434
294
  channelArn: [],
435
295
  maxResults: [],
436
296
  nextToken: [],
437
297
  }));
438
- return new __HttpRequest({
439
- protocol,
440
- hostname,
441
- port,
442
- method: "POST",
443
- headers,
444
- path: resolvedPath,
445
- body,
446
- });
298
+ b.m("POST").h(headers).b(body);
299
+ return b.build();
447
300
  };
448
301
  export const se_ListStreamsCommand = async (input, context) => {
449
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
302
+ const b = rb(input, context);
450
303
  const headers = {
451
304
  "content-type": "application/json",
452
305
  };
453
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListStreams";
306
+ b.bp("/ListStreams");
454
307
  let body;
455
308
  body = JSON.stringify(take(input, {
456
309
  filterBy: (_) => _json(_),
457
310
  maxResults: [],
458
311
  nextToken: [],
459
312
  }));
460
- return new __HttpRequest({
461
- protocol,
462
- hostname,
463
- port,
464
- method: "POST",
465
- headers,
466
- path: resolvedPath,
467
- body,
468
- });
313
+ b.m("POST").h(headers).b(body);
314
+ return b.build();
469
315
  };
470
316
  export const se_ListStreamSessionsCommand = async (input, context) => {
471
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
317
+ const b = rb(input, context);
472
318
  const headers = {
473
319
  "content-type": "application/json",
474
320
  };
475
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListStreamSessions";
321
+ b.bp("/ListStreamSessions");
476
322
  let body;
477
323
  body = JSON.stringify(take(input, {
478
324
  channelArn: [],
479
325
  maxResults: [],
480
326
  nextToken: [],
481
327
  }));
482
- return new __HttpRequest({
483
- protocol,
484
- hostname,
485
- port,
486
- method: "POST",
487
- headers,
488
- path: resolvedPath,
489
- body,
490
- });
328
+ b.m("POST").h(headers).b(body);
329
+ return b.build();
491
330
  };
492
331
  export const se_ListTagsForResourceCommand = async (input, context) => {
493
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
332
+ const b = rb(input, context);
494
333
  const headers = {};
495
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
496
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
334
+ b.bp("/tags/{resourceArn}");
335
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
497
336
  let body;
498
- return new __HttpRequest({
499
- protocol,
500
- hostname,
501
- port,
502
- method: "GET",
503
- headers,
504
- path: resolvedPath,
505
- body,
506
- });
337
+ b.m("GET").h(headers).b(body);
338
+ return b.build();
507
339
  };
508
340
  export const se_PutMetadataCommand = async (input, context) => {
509
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
341
+ const b = rb(input, context);
510
342
  const headers = {
511
343
  "content-type": "application/json",
512
344
  };
513
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/PutMetadata";
345
+ b.bp("/PutMetadata");
514
346
  let body;
515
347
  body = JSON.stringify(take(input, {
516
348
  channelArn: [],
517
349
  metadata: [],
518
350
  }));
519
- return new __HttpRequest({
520
- protocol,
521
- hostname,
522
- port,
523
- method: "POST",
524
- headers,
525
- path: resolvedPath,
526
- body,
527
- });
351
+ b.m("POST").h(headers).b(body);
352
+ return b.build();
528
353
  };
529
354
  export const se_StartViewerSessionRevocationCommand = async (input, context) => {
530
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
355
+ const b = rb(input, context);
531
356
  const headers = {
532
357
  "content-type": "application/json",
533
358
  };
534
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/StartViewerSessionRevocation";
359
+ b.bp("/StartViewerSessionRevocation");
535
360
  let body;
536
361
  body = JSON.stringify(take(input, {
537
362
  channelArn: [],
538
363
  viewerId: [],
539
364
  viewerSessionVersionsLessThanOrEqualTo: [],
540
365
  }));
541
- return new __HttpRequest({
542
- protocol,
543
- hostname,
544
- port,
545
- method: "POST",
546
- headers,
547
- path: resolvedPath,
548
- body,
549
- });
366
+ b.m("POST").h(headers).b(body);
367
+ return b.build();
550
368
  };
551
369
  export const se_StopStreamCommand = async (input, context) => {
552
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
370
+ const b = rb(input, context);
553
371
  const headers = {
554
372
  "content-type": "application/json",
555
373
  };
556
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/StopStream";
374
+ b.bp("/StopStream");
557
375
  let body;
558
376
  body = JSON.stringify(take(input, {
559
377
  channelArn: [],
560
378
  }));
561
- return new __HttpRequest({
562
- protocol,
563
- hostname,
564
- port,
565
- method: "POST",
566
- headers,
567
- path: resolvedPath,
568
- body,
569
- });
379
+ b.m("POST").h(headers).b(body);
380
+ return b.build();
570
381
  };
571
382
  export const se_TagResourceCommand = async (input, context) => {
572
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
383
+ const b = rb(input, context);
573
384
  const headers = {
574
385
  "content-type": "application/json",
575
386
  };
576
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
577
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
387
+ b.bp("/tags/{resourceArn}");
388
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
578
389
  let body;
579
390
  body = JSON.stringify(take(input, {
580
391
  tags: (_) => _json(_),
581
392
  }));
582
- return new __HttpRequest({
583
- protocol,
584
- hostname,
585
- port,
586
- method: "POST",
587
- headers,
588
- path: resolvedPath,
589
- body,
590
- });
393
+ b.m("POST").h(headers).b(body);
394
+ return b.build();
591
395
  };
592
396
  export const se_UntagResourceCommand = async (input, context) => {
593
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
397
+ const b = rb(input, context);
594
398
  const headers = {};
595
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
596
- resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
399
+ b.bp("/tags/{resourceArn}");
400
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
597
401
  const query = map({
598
- tagKeys: [
402
+ [_tK]: [
599
403
  __expectNonNull(input.tagKeys, `tagKeys`) != null,
600
- () => (input.tagKeys || []).map((_entry) => _entry),
404
+ () => (input[_tK] || []).map((_entry) => _entry),
601
405
  ],
602
406
  });
603
407
  let body;
604
- return new __HttpRequest({
605
- protocol,
606
- hostname,
607
- port,
608
- method: "DELETE",
609
- headers,
610
- path: resolvedPath,
611
- query,
612
- body,
613
- });
408
+ b.m("DELETE").h(headers).q(query).b(body);
409
+ return b.build();
614
410
  };
615
411
  export const se_UpdateChannelCommand = async (input, context) => {
616
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
412
+ const b = rb(input, context);
617
413
  const headers = {
618
414
  "content-type": "application/json",
619
415
  };
620
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/UpdateChannel";
416
+ b.bp("/UpdateChannel");
621
417
  let body;
622
418
  body = JSON.stringify(take(input, {
623
419
  arn: [],
@@ -629,15 +425,8 @@ export const se_UpdateChannelCommand = async (input, context) => {
629
425
  recordingConfigurationArn: [],
630
426
  type: [],
631
427
  }));
632
- return new __HttpRequest({
633
- protocol,
634
- hostname,
635
- port,
636
- method: "POST",
637
- headers,
638
- path: resolvedPath,
639
- body,
640
- });
428
+ b.m("POST").h(headers).b(body);
429
+ return b.build();
641
430
  };
642
431
  export const de_BatchGetChannelCommand = async (output, context) => {
643
432
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2047,6 +1836,7 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
2047
1836
  value !== "" &&
2048
1837
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
2049
1838
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
1839
+ const _tK = "tagKeys";
2050
1840
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
2051
1841
  if (encoded.length) {
2052
1842
  return JSON.parse(encoded);