@aws-sdk/client-medialive 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 +396 -829
  2. package/dist-es/protocols/Aws_restJson1.js +397 -830
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,30 +1,23 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, parseRfc7231DateTime as __parseRfc7231DateTime, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, strictParseLong as __strictParseLong, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, parseRfc7231DateTime as __parseRfc7231DateTime, serializeFloat as __serializeFloat, strictParseLong as __strictParseLong, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { v4 as generateIdempotencyToken } from "uuid";
4
4
  import { MediaLiveServiceException as __BaseException } from "../models/MediaLiveServiceException";
5
5
  import { BadGatewayException, BadRequestException, ConflictException, ForbiddenException, GatewayTimeoutException, InternalServerErrorException, NotFoundException, TooManyRequestsException, UnprocessableEntityException, } from "../models/models_1";
6
6
  export const se_AcceptInputDeviceTransferCommand = async (input, context) => {
7
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
7
+ const b = rb(input, context);
8
8
  const headers = {};
9
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputDevices/{InputDeviceId}/accept";
10
- resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
9
+ b.bp("/prod/inputDevices/{InputDeviceId}/accept");
10
+ b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
11
11
  let body;
12
- return new __HttpRequest({
13
- protocol,
14
- hostname,
15
- port,
16
- method: "POST",
17
- headers,
18
- path: resolvedPath,
19
- body,
20
- });
12
+ b.m("POST").h(headers).b(body);
13
+ return b.build();
21
14
  };
22
15
  export const se_BatchDeleteCommand = async (input, context) => {
23
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
16
+ const b = rb(input, context);
24
17
  const headers = {
25
18
  "content-type": "application/json",
26
19
  };
27
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/batch/delete";
20
+ b.bp("/prod/batch/delete");
28
21
  let body;
29
22
  body = JSON.stringify(take(input, {
30
23
  channelIds: [, (_) => _json(_), `ChannelIds`],
@@ -32,122 +25,80 @@ export const se_BatchDeleteCommand = async (input, context) => {
32
25
  inputSecurityGroupIds: [, (_) => _json(_), `InputSecurityGroupIds`],
33
26
  multiplexIds: [, (_) => _json(_), `MultiplexIds`],
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_BatchStartCommand = 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 || ""}` + "/prod/batch/start";
36
+ b.bp("/prod/batch/start");
51
37
  let body;
52
38
  body = JSON.stringify(take(input, {
53
39
  channelIds: [, (_) => _json(_), `ChannelIds`],
54
40
  multiplexIds: [, (_) => _json(_), `MultiplexIds`],
55
41
  }));
56
- return new __HttpRequest({
57
- protocol,
58
- hostname,
59
- port,
60
- method: "POST",
61
- headers,
62
- path: resolvedPath,
63
- body,
64
- });
42
+ b.m("POST").h(headers).b(body);
43
+ return b.build();
65
44
  };
66
45
  export const se_BatchStopCommand = async (input, context) => {
67
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
46
+ const b = rb(input, context);
68
47
  const headers = {
69
48
  "content-type": "application/json",
70
49
  };
71
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/batch/stop";
50
+ b.bp("/prod/batch/stop");
72
51
  let body;
73
52
  body = JSON.stringify(take(input, {
74
53
  channelIds: [, (_) => _json(_), `ChannelIds`],
75
54
  multiplexIds: [, (_) => _json(_), `MultiplexIds`],
76
55
  }));
77
- return new __HttpRequest({
78
- protocol,
79
- hostname,
80
- port,
81
- method: "POST",
82
- headers,
83
- path: resolvedPath,
84
- body,
85
- });
56
+ b.m("POST").h(headers).b(body);
57
+ return b.build();
86
58
  };
87
59
  export const se_BatchUpdateScheduleCommand = async (input, context) => {
88
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
60
+ const b = rb(input, context);
89
61
  const headers = {
90
62
  "content-type": "application/json",
91
63
  };
92
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/channels/{ChannelId}/schedule";
93
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
64
+ b.bp("/prod/channels/{ChannelId}/schedule");
65
+ b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
94
66
  let body;
95
67
  body = JSON.stringify(take(input, {
96
68
  creates: [, (_) => se_BatchScheduleActionCreateRequest(_, context), `Creates`],
97
69
  deletes: [, (_) => se_BatchScheduleActionDeleteRequest(_, context), `Deletes`],
98
70
  }));
99
- return new __HttpRequest({
100
- protocol,
101
- hostname,
102
- port,
103
- method: "PUT",
104
- headers,
105
- path: resolvedPath,
106
- body,
107
- });
71
+ b.m("PUT").h(headers).b(body);
72
+ return b.build();
108
73
  };
109
74
  export const se_CancelInputDeviceTransferCommand = async (input, context) => {
110
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
75
+ const b = rb(input, context);
111
76
  const headers = {};
112
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputDevices/{InputDeviceId}/cancel";
113
- resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
77
+ b.bp("/prod/inputDevices/{InputDeviceId}/cancel");
78
+ b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
114
79
  let body;
115
- return new __HttpRequest({
116
- protocol,
117
- hostname,
118
- port,
119
- method: "POST",
120
- headers,
121
- path: resolvedPath,
122
- body,
123
- });
80
+ b.m("POST").h(headers).b(body);
81
+ return b.build();
124
82
  };
125
83
  export const se_ClaimDeviceCommand = async (input, context) => {
126
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
84
+ const b = rb(input, context);
127
85
  const headers = {
128
86
  "content-type": "application/json",
129
87
  };
130
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/claimDevice";
88
+ b.bp("/prod/claimDevice");
131
89
  let body;
132
90
  body = JSON.stringify(take(input, {
133
91
  id: [, , `Id`],
134
92
  }));
135
- return new __HttpRequest({
136
- protocol,
137
- hostname,
138
- port,
139
- method: "POST",
140
- headers,
141
- path: resolvedPath,
142
- body,
143
- });
93
+ b.m("POST").h(headers).b(body);
94
+ return b.build();
144
95
  };
145
96
  export const se_CreateChannelCommand = async (input, context) => {
146
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
97
+ const b = rb(input, context);
147
98
  const headers = {
148
99
  "content-type": "application/json",
149
100
  };
150
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/channels";
101
+ b.bp("/prod/channels");
151
102
  let body;
152
103
  body = JSON.stringify(take(input, {
153
104
  cdiInputSpecification: [, (_) => se_CdiInputSpecification(_, context), `CdiInputSpecification`],
@@ -165,22 +116,15 @@ export const se_CreateChannelCommand = async (input, context) => {
165
116
  tags: [, (_) => _json(_), `Tags`],
166
117
  vpc: [, (_) => se_VpcOutputSettings(_, context), `Vpc`],
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_CreateInputCommand = 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 || ""}` + "/prod/inputs";
127
+ b.bp("/prod/inputs");
184
128
  let body;
185
129
  body = JSON.stringify(take(input, {
186
130
  destinations: [, (_) => se___listOfInputDestinationRequest(_, context), `Destinations`],
@@ -195,43 +139,29 @@ export const se_CreateInputCommand = async (input, context) => {
195
139
  type: [, , `Type`],
196
140
  vpc: [, (_) => se_InputVpcRequest(_, context), `Vpc`],
197
141
  }));
198
- return new __HttpRequest({
199
- protocol,
200
- hostname,
201
- port,
202
- method: "POST",
203
- headers,
204
- path: resolvedPath,
205
- body,
206
- });
142
+ b.m("POST").h(headers).b(body);
143
+ return b.build();
207
144
  };
208
145
  export const se_CreateInputSecurityGroupCommand = async (input, context) => {
209
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
146
+ const b = rb(input, context);
210
147
  const headers = {
211
148
  "content-type": "application/json",
212
149
  };
213
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputSecurityGroups";
150
+ b.bp("/prod/inputSecurityGroups");
214
151
  let body;
215
152
  body = JSON.stringify(take(input, {
216
153
  tags: [, (_) => _json(_), `Tags`],
217
154
  whitelistRules: [, (_) => se___listOfInputWhitelistRuleCidr(_, context), `WhitelistRules`],
218
155
  }));
219
- return new __HttpRequest({
220
- protocol,
221
- hostname,
222
- port,
223
- method: "POST",
224
- headers,
225
- path: resolvedPath,
226
- body,
227
- });
156
+ b.m("POST").h(headers).b(body);
157
+ return b.build();
228
158
  };
229
159
  export const se_CreateMultiplexCommand = async (input, context) => {
230
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
160
+ const b = rb(input, context);
231
161
  const headers = {
232
162
  "content-type": "application/json",
233
163
  };
234
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/multiplexes";
164
+ b.bp("/prod/multiplexes");
235
165
  let body;
236
166
  body = JSON.stringify(take(input, {
237
167
  availabilityZones: [, (_) => _json(_), `AvailabilityZones`],
@@ -240,653 +170,398 @@ export const se_CreateMultiplexCommand = async (input, context) => {
240
170
  requestId: [true, (_) => _ ?? generateIdempotencyToken(), `RequestId`],
241
171
  tags: [, (_) => _json(_), `Tags`],
242
172
  }));
243
- return new __HttpRequest({
244
- protocol,
245
- hostname,
246
- port,
247
- method: "POST",
248
- headers,
249
- path: resolvedPath,
250
- body,
251
- });
173
+ b.m("POST").h(headers).b(body);
174
+ return b.build();
252
175
  };
253
176
  export const se_CreateMultiplexProgramCommand = async (input, context) => {
254
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
177
+ const b = rb(input, context);
255
178
  const headers = {
256
179
  "content-type": "application/json",
257
180
  };
258
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/multiplexes/{MultiplexId}/programs";
259
- resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
181
+ b.bp("/prod/multiplexes/{MultiplexId}/programs");
182
+ b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
260
183
  let body;
261
184
  body = JSON.stringify(take(input, {
262
185
  multiplexProgramSettings: [, (_) => se_MultiplexProgramSettings(_, context), `MultiplexProgramSettings`],
263
186
  programName: [, , `ProgramName`],
264
187
  requestId: [true, (_) => _ ?? generateIdempotencyToken(), `RequestId`],
265
188
  }));
266
- return new __HttpRequest({
267
- protocol,
268
- hostname,
269
- port,
270
- method: "POST",
271
- headers,
272
- path: resolvedPath,
273
- body,
274
- });
189
+ b.m("POST").h(headers).b(body);
190
+ return b.build();
275
191
  };
276
192
  export const se_CreatePartnerInputCommand = async (input, context) => {
277
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
193
+ const b = rb(input, context);
278
194
  const headers = {
279
195
  "content-type": "application/json",
280
196
  };
281
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputs/{InputId}/partners";
282
- resolvedPath = __resolvedPath(resolvedPath, input, "InputId", () => input.InputId, "{InputId}", false);
197
+ b.bp("/prod/inputs/{InputId}/partners");
198
+ b.p("InputId", () => input.InputId, "{InputId}", false);
283
199
  let body;
284
200
  body = JSON.stringify(take(input, {
285
201
  requestId: [true, (_) => _ ?? generateIdempotencyToken(), `RequestId`],
286
202
  tags: [, (_) => _json(_), `Tags`],
287
203
  }));
288
- return new __HttpRequest({
289
- protocol,
290
- hostname,
291
- port,
292
- method: "POST",
293
- headers,
294
- path: resolvedPath,
295
- body,
296
- });
204
+ b.m("POST").h(headers).b(body);
205
+ return b.build();
297
206
  };
298
207
  export const se_CreateTagsCommand = async (input, context) => {
299
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
208
+ const b = rb(input, context);
300
209
  const headers = {
301
210
  "content-type": "application/json",
302
211
  };
303
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/tags/{ResourceArn}";
304
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
212
+ b.bp("/prod/tags/{ResourceArn}");
213
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
305
214
  let body;
306
215
  body = JSON.stringify(take(input, {
307
216
  tags: [, (_) => _json(_), `Tags`],
308
217
  }));
309
- return new __HttpRequest({
310
- protocol,
311
- hostname,
312
- port,
313
- method: "POST",
314
- headers,
315
- path: resolvedPath,
316
- body,
317
- });
218
+ b.m("POST").h(headers).b(body);
219
+ return b.build();
318
220
  };
319
221
  export const se_DeleteChannelCommand = async (input, context) => {
320
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
222
+ const b = rb(input, context);
321
223
  const headers = {};
322
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/channels/{ChannelId}";
323
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
224
+ b.bp("/prod/channels/{ChannelId}");
225
+ b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
324
226
  let body;
325
- return new __HttpRequest({
326
- protocol,
327
- hostname,
328
- port,
329
- method: "DELETE",
330
- headers,
331
- path: resolvedPath,
332
- body,
333
- });
227
+ b.m("DELETE").h(headers).b(body);
228
+ return b.build();
334
229
  };
335
230
  export const se_DeleteInputCommand = async (input, context) => {
336
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
231
+ const b = rb(input, context);
337
232
  const headers = {};
338
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputs/{InputId}";
339
- resolvedPath = __resolvedPath(resolvedPath, input, "InputId", () => input.InputId, "{InputId}", false);
233
+ b.bp("/prod/inputs/{InputId}");
234
+ b.p("InputId", () => input.InputId, "{InputId}", false);
340
235
  let body;
341
- return new __HttpRequest({
342
- protocol,
343
- hostname,
344
- port,
345
- method: "DELETE",
346
- headers,
347
- path: resolvedPath,
348
- body,
349
- });
236
+ b.m("DELETE").h(headers).b(body);
237
+ return b.build();
350
238
  };
351
239
  export const se_DeleteInputSecurityGroupCommand = async (input, context) => {
352
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
240
+ const b = rb(input, context);
353
241
  const headers = {};
354
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
355
- "/prod/inputSecurityGroups/{InputSecurityGroupId}";
356
- resolvedPath = __resolvedPath(resolvedPath, input, "InputSecurityGroupId", () => input.InputSecurityGroupId, "{InputSecurityGroupId}", false);
242
+ b.bp("/prod/inputSecurityGroups/{InputSecurityGroupId}");
243
+ b.p("InputSecurityGroupId", () => input.InputSecurityGroupId, "{InputSecurityGroupId}", false);
357
244
  let body;
358
- return new __HttpRequest({
359
- protocol,
360
- hostname,
361
- port,
362
- method: "DELETE",
363
- headers,
364
- path: resolvedPath,
365
- body,
366
- });
245
+ b.m("DELETE").h(headers).b(body);
246
+ return b.build();
367
247
  };
368
248
  export const se_DeleteMultiplexCommand = async (input, context) => {
369
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
249
+ const b = rb(input, context);
370
250
  const headers = {};
371
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/multiplexes/{MultiplexId}";
372
- resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
251
+ b.bp("/prod/multiplexes/{MultiplexId}");
252
+ b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
373
253
  let body;
374
- return new __HttpRequest({
375
- protocol,
376
- hostname,
377
- port,
378
- method: "DELETE",
379
- headers,
380
- path: resolvedPath,
381
- body,
382
- });
254
+ b.m("DELETE").h(headers).b(body);
255
+ return b.build();
383
256
  };
384
257
  export const se_DeleteMultiplexProgramCommand = async (input, context) => {
385
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
258
+ const b = rb(input, context);
386
259
  const headers = {};
387
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
388
- "/prod/multiplexes/{MultiplexId}/programs/{ProgramName}";
389
- resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
390
- resolvedPath = __resolvedPath(resolvedPath, input, "ProgramName", () => input.ProgramName, "{ProgramName}", false);
260
+ b.bp("/prod/multiplexes/{MultiplexId}/programs/{ProgramName}");
261
+ b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
262
+ b.p("ProgramName", () => input.ProgramName, "{ProgramName}", false);
391
263
  let body;
392
- return new __HttpRequest({
393
- protocol,
394
- hostname,
395
- port,
396
- method: "DELETE",
397
- headers,
398
- path: resolvedPath,
399
- body,
400
- });
264
+ b.m("DELETE").h(headers).b(body);
265
+ return b.build();
401
266
  };
402
267
  export const se_DeleteReservationCommand = async (input, context) => {
403
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
268
+ const b = rb(input, context);
404
269
  const headers = {};
405
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/reservations/{ReservationId}";
406
- resolvedPath = __resolvedPath(resolvedPath, input, "ReservationId", () => input.ReservationId, "{ReservationId}", false);
270
+ b.bp("/prod/reservations/{ReservationId}");
271
+ b.p("ReservationId", () => input.ReservationId, "{ReservationId}", false);
407
272
  let body;
408
- return new __HttpRequest({
409
- protocol,
410
- hostname,
411
- port,
412
- method: "DELETE",
413
- headers,
414
- path: resolvedPath,
415
- body,
416
- });
273
+ b.m("DELETE").h(headers).b(body);
274
+ return b.build();
417
275
  };
418
276
  export const se_DeleteScheduleCommand = async (input, context) => {
419
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
277
+ const b = rb(input, context);
420
278
  const headers = {};
421
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/channels/{ChannelId}/schedule";
422
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
279
+ b.bp("/prod/channels/{ChannelId}/schedule");
280
+ b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
423
281
  let body;
424
- return new __HttpRequest({
425
- protocol,
426
- hostname,
427
- port,
428
- method: "DELETE",
429
- headers,
430
- path: resolvedPath,
431
- body,
432
- });
282
+ b.m("DELETE").h(headers).b(body);
283
+ return b.build();
433
284
  };
434
285
  export const se_DeleteTagsCommand = async (input, context) => {
435
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
286
+ const b = rb(input, context);
436
287
  const headers = {};
437
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/tags/{ResourceArn}";
438
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
288
+ b.bp("/prod/tags/{ResourceArn}");
289
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
439
290
  const query = map({
440
- tagKeys: [
291
+ [_tK]: [
441
292
  __expectNonNull(input.TagKeys, `TagKeys`) != null,
442
- () => (input.TagKeys || []).map((_entry) => _entry),
293
+ () => (input[_TK] || []).map((_entry) => _entry),
443
294
  ],
444
295
  });
445
296
  let body;
446
- return new __HttpRequest({
447
- protocol,
448
- hostname,
449
- port,
450
- method: "DELETE",
451
- headers,
452
- path: resolvedPath,
453
- query,
454
- body,
455
- });
297
+ b.m("DELETE").h(headers).q(query).b(body);
298
+ return b.build();
456
299
  };
457
300
  export const se_DescribeAccountConfigurationCommand = async (input, context) => {
458
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
301
+ const b = rb(input, context);
459
302
  const headers = {
460
303
  "content-type": "application/json",
461
304
  };
462
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/accountConfiguration";
305
+ b.bp("/prod/accountConfiguration");
463
306
  let body;
464
307
  body = "";
465
- return new __HttpRequest({
466
- protocol,
467
- hostname,
468
- port,
469
- method: "GET",
470
- headers,
471
- path: resolvedPath,
472
- body,
473
- });
308
+ b.m("GET").h(headers).b(body);
309
+ return b.build();
474
310
  };
475
311
  export const se_DescribeChannelCommand = async (input, context) => {
476
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
312
+ const b = rb(input, context);
477
313
  const headers = {};
478
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/channels/{ChannelId}";
479
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
314
+ b.bp("/prod/channels/{ChannelId}");
315
+ b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
480
316
  let body;
481
- return new __HttpRequest({
482
- protocol,
483
- hostname,
484
- port,
485
- method: "GET",
486
- headers,
487
- path: resolvedPath,
488
- body,
489
- });
317
+ b.m("GET").h(headers).b(body);
318
+ return b.build();
490
319
  };
491
320
  export const se_DescribeInputCommand = async (input, context) => {
492
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
321
+ const b = rb(input, context);
493
322
  const headers = {};
494
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputs/{InputId}";
495
- resolvedPath = __resolvedPath(resolvedPath, input, "InputId", () => input.InputId, "{InputId}", false);
323
+ b.bp("/prod/inputs/{InputId}");
324
+ b.p("InputId", () => input.InputId, "{InputId}", false);
496
325
  let body;
497
- return new __HttpRequest({
498
- protocol,
499
- hostname,
500
- port,
501
- method: "GET",
502
- headers,
503
- path: resolvedPath,
504
- body,
505
- });
326
+ b.m("GET").h(headers).b(body);
327
+ return b.build();
506
328
  };
507
329
  export const se_DescribeInputDeviceCommand = async (input, context) => {
508
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
330
+ const b = rb(input, context);
509
331
  const headers = {};
510
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputDevices/{InputDeviceId}";
511
- resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
332
+ b.bp("/prod/inputDevices/{InputDeviceId}");
333
+ b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
512
334
  let body;
513
- return new __HttpRequest({
514
- protocol,
515
- hostname,
516
- port,
517
- method: "GET",
518
- headers,
519
- path: resolvedPath,
520
- body,
521
- });
335
+ b.m("GET").h(headers).b(body);
336
+ return b.build();
522
337
  };
523
338
  export const se_DescribeInputDeviceThumbnailCommand = async (input, context) => {
524
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
339
+ const b = rb(input, context);
525
340
  const headers = map({}, isSerializableHeaderValue, {
526
- accept: input.Accept,
341
+ [_a]: input[_A],
527
342
  });
528
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
529
- "/prod/inputDevices/{InputDeviceId}/thumbnailData";
530
- resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
343
+ b.bp("/prod/inputDevices/{InputDeviceId}/thumbnailData");
344
+ b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
531
345
  let body;
532
- return new __HttpRequest({
533
- protocol,
534
- hostname,
535
- port,
536
- method: "GET",
537
- headers,
538
- path: resolvedPath,
539
- body,
540
- });
346
+ b.m("GET").h(headers).b(body);
347
+ return b.build();
541
348
  };
542
349
  export const se_DescribeInputSecurityGroupCommand = async (input, context) => {
543
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
350
+ const b = rb(input, context);
544
351
  const headers = {};
545
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
546
- "/prod/inputSecurityGroups/{InputSecurityGroupId}";
547
- resolvedPath = __resolvedPath(resolvedPath, input, "InputSecurityGroupId", () => input.InputSecurityGroupId, "{InputSecurityGroupId}", false);
352
+ b.bp("/prod/inputSecurityGroups/{InputSecurityGroupId}");
353
+ b.p("InputSecurityGroupId", () => input.InputSecurityGroupId, "{InputSecurityGroupId}", false);
548
354
  let body;
549
- return new __HttpRequest({
550
- protocol,
551
- hostname,
552
- port,
553
- method: "GET",
554
- headers,
555
- path: resolvedPath,
556
- body,
557
- });
355
+ b.m("GET").h(headers).b(body);
356
+ return b.build();
558
357
  };
559
358
  export const se_DescribeMultiplexCommand = async (input, context) => {
560
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
359
+ const b = rb(input, context);
561
360
  const headers = {};
562
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/multiplexes/{MultiplexId}";
563
- resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
361
+ b.bp("/prod/multiplexes/{MultiplexId}");
362
+ b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
564
363
  let body;
565
- return new __HttpRequest({
566
- protocol,
567
- hostname,
568
- port,
569
- method: "GET",
570
- headers,
571
- path: resolvedPath,
572
- body,
573
- });
364
+ b.m("GET").h(headers).b(body);
365
+ return b.build();
574
366
  };
575
367
  export const se_DescribeMultiplexProgramCommand = async (input, context) => {
576
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
368
+ const b = rb(input, context);
577
369
  const headers = {};
578
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
579
- "/prod/multiplexes/{MultiplexId}/programs/{ProgramName}";
580
- resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
581
- resolvedPath = __resolvedPath(resolvedPath, input, "ProgramName", () => input.ProgramName, "{ProgramName}", false);
370
+ b.bp("/prod/multiplexes/{MultiplexId}/programs/{ProgramName}");
371
+ b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
372
+ b.p("ProgramName", () => input.ProgramName, "{ProgramName}", false);
582
373
  let body;
583
- return new __HttpRequest({
584
- protocol,
585
- hostname,
586
- port,
587
- method: "GET",
588
- headers,
589
- path: resolvedPath,
590
- body,
591
- });
374
+ b.m("GET").h(headers).b(body);
375
+ return b.build();
592
376
  };
593
377
  export const se_DescribeOfferingCommand = async (input, context) => {
594
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
378
+ const b = rb(input, context);
595
379
  const headers = {};
596
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/offerings/{OfferingId}";
597
- resolvedPath = __resolvedPath(resolvedPath, input, "OfferingId", () => input.OfferingId, "{OfferingId}", false);
380
+ b.bp("/prod/offerings/{OfferingId}");
381
+ b.p("OfferingId", () => input.OfferingId, "{OfferingId}", false);
598
382
  let body;
599
- return new __HttpRequest({
600
- protocol,
601
- hostname,
602
- port,
603
- method: "GET",
604
- headers,
605
- path: resolvedPath,
606
- body,
607
- });
383
+ b.m("GET").h(headers).b(body);
384
+ return b.build();
608
385
  };
609
386
  export const se_DescribeReservationCommand = async (input, context) => {
610
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
387
+ const b = rb(input, context);
611
388
  const headers = {};
612
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/reservations/{ReservationId}";
613
- resolvedPath = __resolvedPath(resolvedPath, input, "ReservationId", () => input.ReservationId, "{ReservationId}", false);
389
+ b.bp("/prod/reservations/{ReservationId}");
390
+ b.p("ReservationId", () => input.ReservationId, "{ReservationId}", false);
614
391
  let body;
615
- return new __HttpRequest({
616
- protocol,
617
- hostname,
618
- port,
619
- method: "GET",
620
- headers,
621
- path: resolvedPath,
622
- body,
623
- });
392
+ b.m("GET").h(headers).b(body);
393
+ return b.build();
624
394
  };
625
395
  export const se_DescribeScheduleCommand = async (input, context) => {
626
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
396
+ const b = rb(input, context);
627
397
  const headers = {};
628
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/channels/{ChannelId}/schedule";
629
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
398
+ b.bp("/prod/channels/{ChannelId}/schedule");
399
+ b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
630
400
  const query = map({
631
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
632
- nextToken: [, input.NextToken],
401
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
402
+ [_nT]: [, input[_NT]],
633
403
  });
634
404
  let body;
635
- return new __HttpRequest({
636
- protocol,
637
- hostname,
638
- port,
639
- method: "GET",
640
- headers,
641
- path: resolvedPath,
642
- query,
643
- body,
644
- });
405
+ b.m("GET").h(headers).q(query).b(body);
406
+ return b.build();
645
407
  };
646
408
  export const se_DescribeThumbnailsCommand = async (input, context) => {
647
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
409
+ const b = rb(input, context);
648
410
  const headers = {};
649
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/channels/{ChannelId}/thumbnails";
650
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
411
+ b.bp("/prod/channels/{ChannelId}/thumbnails");
412
+ b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
651
413
  const query = map({
652
- pipelineId: [, __expectNonNull(input.PipelineId, `PipelineId`)],
653
- thumbnailType: [, __expectNonNull(input.ThumbnailType, `ThumbnailType`)],
414
+ [_pI]: [, __expectNonNull(input[_PI], `PipelineId`)],
415
+ [_tT]: [, __expectNonNull(input[_TT], `ThumbnailType`)],
654
416
  });
655
417
  let body;
656
- return new __HttpRequest({
657
- protocol,
658
- hostname,
659
- port,
660
- method: "GET",
661
- headers,
662
- path: resolvedPath,
663
- query,
664
- body,
665
- });
418
+ b.m("GET").h(headers).q(query).b(body);
419
+ return b.build();
666
420
  };
667
421
  export const se_ListChannelsCommand = async (input, context) => {
668
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
422
+ const b = rb(input, context);
669
423
  const headers = {};
670
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/channels";
424
+ b.bp("/prod/channels");
671
425
  const query = map({
672
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
673
- nextToken: [, input.NextToken],
426
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
427
+ [_nT]: [, input[_NT]],
674
428
  });
675
429
  let body;
676
- return new __HttpRequest({
677
- protocol,
678
- hostname,
679
- port,
680
- method: "GET",
681
- headers,
682
- path: resolvedPath,
683
- query,
684
- body,
685
- });
430
+ b.m("GET").h(headers).q(query).b(body);
431
+ return b.build();
686
432
  };
687
433
  export const se_ListInputDevicesCommand = async (input, context) => {
688
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
434
+ const b = rb(input, context);
689
435
  const headers = {};
690
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputDevices";
436
+ b.bp("/prod/inputDevices");
691
437
  const query = map({
692
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
693
- nextToken: [, input.NextToken],
438
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
439
+ [_nT]: [, input[_NT]],
694
440
  });
695
441
  let body;
696
- return new __HttpRequest({
697
- protocol,
698
- hostname,
699
- port,
700
- method: "GET",
701
- headers,
702
- path: resolvedPath,
703
- query,
704
- body,
705
- });
442
+ b.m("GET").h(headers).q(query).b(body);
443
+ return b.build();
706
444
  };
707
445
  export const se_ListInputDeviceTransfersCommand = async (input, context) => {
708
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
446
+ const b = rb(input, context);
709
447
  const headers = {};
710
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputDeviceTransfers";
448
+ b.bp("/prod/inputDeviceTransfers");
711
449
  const query = map({
712
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
713
- nextToken: [, input.NextToken],
714
- transferType: [, __expectNonNull(input.TransferType, `TransferType`)],
450
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
451
+ [_nT]: [, input[_NT]],
452
+ [_tTr]: [, __expectNonNull(input[_TTr], `TransferType`)],
715
453
  });
716
454
  let body;
717
- return new __HttpRequest({
718
- protocol,
719
- hostname,
720
- port,
721
- method: "GET",
722
- headers,
723
- path: resolvedPath,
724
- query,
725
- body,
726
- });
455
+ b.m("GET").h(headers).q(query).b(body);
456
+ return b.build();
727
457
  };
728
458
  export const se_ListInputsCommand = async (input, context) => {
729
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
459
+ const b = rb(input, context);
730
460
  const headers = {};
731
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputs";
461
+ b.bp("/prod/inputs");
732
462
  const query = map({
733
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
734
- nextToken: [, input.NextToken],
463
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
464
+ [_nT]: [, input[_NT]],
735
465
  });
736
466
  let body;
737
- return new __HttpRequest({
738
- protocol,
739
- hostname,
740
- port,
741
- method: "GET",
742
- headers,
743
- path: resolvedPath,
744
- query,
745
- body,
746
- });
467
+ b.m("GET").h(headers).q(query).b(body);
468
+ return b.build();
747
469
  };
748
470
  export const se_ListInputSecurityGroupsCommand = async (input, context) => {
749
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
471
+ const b = rb(input, context);
750
472
  const headers = {};
751
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputSecurityGroups";
473
+ b.bp("/prod/inputSecurityGroups");
752
474
  const query = map({
753
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
754
- nextToken: [, input.NextToken],
475
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
476
+ [_nT]: [, input[_NT]],
755
477
  });
756
478
  let body;
757
- return new __HttpRequest({
758
- protocol,
759
- hostname,
760
- port,
761
- method: "GET",
762
- headers,
763
- path: resolvedPath,
764
- query,
765
- body,
766
- });
479
+ b.m("GET").h(headers).q(query).b(body);
480
+ return b.build();
767
481
  };
768
482
  export const se_ListMultiplexesCommand = async (input, context) => {
769
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
483
+ const b = rb(input, context);
770
484
  const headers = {};
771
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/multiplexes";
485
+ b.bp("/prod/multiplexes");
772
486
  const query = map({
773
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
774
- nextToken: [, input.NextToken],
487
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
488
+ [_nT]: [, input[_NT]],
775
489
  });
776
490
  let body;
777
- return new __HttpRequest({
778
- protocol,
779
- hostname,
780
- port,
781
- method: "GET",
782
- headers,
783
- path: resolvedPath,
784
- query,
785
- body,
786
- });
491
+ b.m("GET").h(headers).q(query).b(body);
492
+ return b.build();
787
493
  };
788
494
  export const se_ListMultiplexProgramsCommand = async (input, context) => {
789
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
495
+ const b = rb(input, context);
790
496
  const headers = {};
791
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/multiplexes/{MultiplexId}/programs";
792
- resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
497
+ b.bp("/prod/multiplexes/{MultiplexId}/programs");
498
+ b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
793
499
  const query = map({
794
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
795
- nextToken: [, input.NextToken],
500
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
501
+ [_nT]: [, input[_NT]],
796
502
  });
797
503
  let body;
798
- return new __HttpRequest({
799
- protocol,
800
- hostname,
801
- port,
802
- method: "GET",
803
- headers,
804
- path: resolvedPath,
805
- query,
806
- body,
807
- });
504
+ b.m("GET").h(headers).q(query).b(body);
505
+ return b.build();
808
506
  };
809
507
  export const se_ListOfferingsCommand = async (input, context) => {
810
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
508
+ const b = rb(input, context);
811
509
  const headers = {};
812
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/offerings";
510
+ b.bp("/prod/offerings");
813
511
  const query = map({
814
- channelClass: [, input.ChannelClass],
815
- channelConfiguration: [, input.ChannelConfiguration],
816
- codec: [, input.Codec],
817
- duration: [, input.Duration],
818
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
819
- maximumBitrate: [, input.MaximumBitrate],
820
- maximumFramerate: [, input.MaximumFramerate],
821
- nextToken: [, input.NextToken],
822
- resolution: [, input.Resolution],
823
- resourceType: [, input.ResourceType],
824
- specialFeature: [, input.SpecialFeature],
825
- videoQuality: [, input.VideoQuality],
512
+ [_cC]: [, input[_CC]],
513
+ [_cCh]: [, input[_CCh]],
514
+ [_c]: [, input[_C]],
515
+ [_d]: [, input[_D]],
516
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
517
+ [_mB]: [, input[_MB]],
518
+ [_mF]: [, input[_MF]],
519
+ [_nT]: [, input[_NT]],
520
+ [_r]: [, input[_R]],
521
+ [_rT]: [, input[_RT]],
522
+ [_sF]: [, input[_SF]],
523
+ [_vQ]: [, input[_VQ]],
826
524
  });
827
525
  let body;
828
- return new __HttpRequest({
829
- protocol,
830
- hostname,
831
- port,
832
- method: "GET",
833
- headers,
834
- path: resolvedPath,
835
- query,
836
- body,
837
- });
526
+ b.m("GET").h(headers).q(query).b(body);
527
+ return b.build();
838
528
  };
839
529
  export const se_ListReservationsCommand = async (input, context) => {
840
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
530
+ const b = rb(input, context);
841
531
  const headers = {};
842
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/reservations";
532
+ b.bp("/prod/reservations");
843
533
  const query = map({
844
- channelClass: [, input.ChannelClass],
845
- codec: [, input.Codec],
846
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
847
- maximumBitrate: [, input.MaximumBitrate],
848
- maximumFramerate: [, input.MaximumFramerate],
849
- nextToken: [, input.NextToken],
850
- resolution: [, input.Resolution],
851
- resourceType: [, input.ResourceType],
852
- specialFeature: [, input.SpecialFeature],
853
- videoQuality: [, input.VideoQuality],
534
+ [_cC]: [, input[_CC]],
535
+ [_c]: [, input[_C]],
536
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
537
+ [_mB]: [, input[_MB]],
538
+ [_mF]: [, input[_MF]],
539
+ [_nT]: [, input[_NT]],
540
+ [_r]: [, input[_R]],
541
+ [_rT]: [, input[_RT]],
542
+ [_sF]: [, input[_SF]],
543
+ [_vQ]: [, input[_VQ]],
854
544
  });
855
545
  let body;
856
- return new __HttpRequest({
857
- protocol,
858
- hostname,
859
- port,
860
- method: "GET",
861
- headers,
862
- path: resolvedPath,
863
- query,
864
- body,
865
- });
546
+ b.m("GET").h(headers).q(query).b(body);
547
+ return b.build();
866
548
  };
867
549
  export const se_ListTagsForResourceCommand = async (input, context) => {
868
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
550
+ const b = rb(input, context);
869
551
  const headers = {};
870
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/tags/{ResourceArn}";
871
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
552
+ b.bp("/prod/tags/{ResourceArn}");
553
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
872
554
  let body;
873
- return new __HttpRequest({
874
- protocol,
875
- hostname,
876
- port,
877
- method: "GET",
878
- headers,
879
- path: resolvedPath,
880
- body,
881
- });
555
+ b.m("GET").h(headers).b(body);
556
+ return b.build();
882
557
  };
883
558
  export const se_PurchaseOfferingCommand = async (input, context) => {
884
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
559
+ const b = rb(input, context);
885
560
  const headers = {
886
561
  "content-type": "application/json",
887
562
  };
888
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/offerings/{OfferingId}/purchase";
889
- resolvedPath = __resolvedPath(resolvedPath, input, "OfferingId", () => input.OfferingId, "{OfferingId}", false);
563
+ b.bp("/prod/offerings/{OfferingId}/purchase");
564
+ b.p("OfferingId", () => input.OfferingId, "{OfferingId}", false);
890
565
  let body;
891
566
  body = JSON.stringify(take(input, {
892
567
  count: [, , `Count`],
@@ -896,217 +571,131 @@ export const se_PurchaseOfferingCommand = async (input, context) => {
896
571
  start: [, , `Start`],
897
572
  tags: [, (_) => _json(_), `Tags`],
898
573
  }));
899
- return new __HttpRequest({
900
- protocol,
901
- hostname,
902
- port,
903
- method: "POST",
904
- headers,
905
- path: resolvedPath,
906
- body,
907
- });
574
+ b.m("POST").h(headers).b(body);
575
+ return b.build();
908
576
  };
909
577
  export const se_RebootInputDeviceCommand = async (input, context) => {
910
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
578
+ const b = rb(input, context);
911
579
  const headers = {
912
580
  "content-type": "application/json",
913
581
  };
914
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputDevices/{InputDeviceId}/reboot";
915
- resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
582
+ b.bp("/prod/inputDevices/{InputDeviceId}/reboot");
583
+ b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
916
584
  let body;
917
585
  body = JSON.stringify(take(input, {
918
586
  force: [, , `Force`],
919
587
  }));
920
- return new __HttpRequest({
921
- protocol,
922
- hostname,
923
- port,
924
- method: "POST",
925
- headers,
926
- path: resolvedPath,
927
- body,
928
- });
588
+ b.m("POST").h(headers).b(body);
589
+ return b.build();
929
590
  };
930
591
  export const se_RejectInputDeviceTransferCommand = async (input, context) => {
931
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
592
+ const b = rb(input, context);
932
593
  const headers = {};
933
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputDevices/{InputDeviceId}/reject";
934
- resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
594
+ b.bp("/prod/inputDevices/{InputDeviceId}/reject");
595
+ b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
935
596
  let body;
936
- return new __HttpRequest({
937
- protocol,
938
- hostname,
939
- port,
940
- method: "POST",
941
- headers,
942
- path: resolvedPath,
943
- body,
944
- });
597
+ b.m("POST").h(headers).b(body);
598
+ return b.build();
945
599
  };
946
600
  export const se_StartChannelCommand = async (input, context) => {
947
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
601
+ const b = rb(input, context);
948
602
  const headers = {};
949
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/channels/{ChannelId}/start";
950
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
603
+ b.bp("/prod/channels/{ChannelId}/start");
604
+ b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
951
605
  let body;
952
- return new __HttpRequest({
953
- protocol,
954
- hostname,
955
- port,
956
- method: "POST",
957
- headers,
958
- path: resolvedPath,
959
- body,
960
- });
606
+ b.m("POST").h(headers).b(body);
607
+ return b.build();
961
608
  };
962
609
  export const se_StartInputDeviceCommand = async (input, context) => {
963
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
610
+ const b = rb(input, context);
964
611
  const headers = {};
965
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputDevices/{InputDeviceId}/start";
966
- resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
612
+ b.bp("/prod/inputDevices/{InputDeviceId}/start");
613
+ b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
967
614
  let body;
968
- return new __HttpRequest({
969
- protocol,
970
- hostname,
971
- port,
972
- method: "POST",
973
- headers,
974
- path: resolvedPath,
975
- body,
976
- });
615
+ b.m("POST").h(headers).b(body);
616
+ return b.build();
977
617
  };
978
618
  export const se_StartInputDeviceMaintenanceWindowCommand = async (input, context) => {
979
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
619
+ const b = rb(input, context);
980
620
  const headers = {};
981
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
982
- "/prod/inputDevices/{InputDeviceId}/startInputDeviceMaintenanceWindow";
983
- resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
621
+ b.bp("/prod/inputDevices/{InputDeviceId}/startInputDeviceMaintenanceWindow");
622
+ b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
984
623
  let body;
985
- return new __HttpRequest({
986
- protocol,
987
- hostname,
988
- port,
989
- method: "POST",
990
- headers,
991
- path: resolvedPath,
992
- body,
993
- });
624
+ b.m("POST").h(headers).b(body);
625
+ return b.build();
994
626
  };
995
627
  export const se_StartMultiplexCommand = async (input, context) => {
996
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
628
+ const b = rb(input, context);
997
629
  const headers = {};
998
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/multiplexes/{MultiplexId}/start";
999
- resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
630
+ b.bp("/prod/multiplexes/{MultiplexId}/start");
631
+ b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
1000
632
  let body;
1001
- return new __HttpRequest({
1002
- protocol,
1003
- hostname,
1004
- port,
1005
- method: "POST",
1006
- headers,
1007
- path: resolvedPath,
1008
- body,
1009
- });
633
+ b.m("POST").h(headers).b(body);
634
+ return b.build();
1010
635
  };
1011
636
  export const se_StopChannelCommand = async (input, context) => {
1012
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
637
+ const b = rb(input, context);
1013
638
  const headers = {};
1014
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/channels/{ChannelId}/stop";
1015
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
639
+ b.bp("/prod/channels/{ChannelId}/stop");
640
+ b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
1016
641
  let body;
1017
- return new __HttpRequest({
1018
- protocol,
1019
- hostname,
1020
- port,
1021
- method: "POST",
1022
- headers,
1023
- path: resolvedPath,
1024
- body,
1025
- });
642
+ b.m("POST").h(headers).b(body);
643
+ return b.build();
1026
644
  };
1027
645
  export const se_StopInputDeviceCommand = async (input, context) => {
1028
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
646
+ const b = rb(input, context);
1029
647
  const headers = {};
1030
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputDevices/{InputDeviceId}/stop";
1031
- resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
648
+ b.bp("/prod/inputDevices/{InputDeviceId}/stop");
649
+ b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
1032
650
  let body;
1033
- return new __HttpRequest({
1034
- protocol,
1035
- hostname,
1036
- port,
1037
- method: "POST",
1038
- headers,
1039
- path: resolvedPath,
1040
- body,
1041
- });
651
+ b.m("POST").h(headers).b(body);
652
+ return b.build();
1042
653
  };
1043
654
  export const se_StopMultiplexCommand = async (input, context) => {
1044
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
655
+ const b = rb(input, context);
1045
656
  const headers = {};
1046
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/multiplexes/{MultiplexId}/stop";
1047
- resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
657
+ b.bp("/prod/multiplexes/{MultiplexId}/stop");
658
+ b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
1048
659
  let body;
1049
- return new __HttpRequest({
1050
- protocol,
1051
- hostname,
1052
- port,
1053
- method: "POST",
1054
- headers,
1055
- path: resolvedPath,
1056
- body,
1057
- });
660
+ b.m("POST").h(headers).b(body);
661
+ return b.build();
1058
662
  };
1059
663
  export const se_TransferInputDeviceCommand = async (input, context) => {
1060
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
664
+ const b = rb(input, context);
1061
665
  const headers = {
1062
666
  "content-type": "application/json",
1063
667
  };
1064
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1065
- "/prod/inputDevices/{InputDeviceId}/transfer";
1066
- resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
668
+ b.bp("/prod/inputDevices/{InputDeviceId}/transfer");
669
+ b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
1067
670
  let body;
1068
671
  body = JSON.stringify(take(input, {
1069
672
  targetCustomerId: [, , `TargetCustomerId`],
1070
673
  targetRegion: [, , `TargetRegion`],
1071
674
  transferMessage: [, , `TransferMessage`],
1072
675
  }));
1073
- return new __HttpRequest({
1074
- protocol,
1075
- hostname,
1076
- port,
1077
- method: "POST",
1078
- headers,
1079
- path: resolvedPath,
1080
- body,
1081
- });
676
+ b.m("POST").h(headers).b(body);
677
+ return b.build();
1082
678
  };
1083
679
  export const se_UpdateAccountConfigurationCommand = async (input, context) => {
1084
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
680
+ const b = rb(input, context);
1085
681
  const headers = {
1086
682
  "content-type": "application/json",
1087
683
  };
1088
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/accountConfiguration";
684
+ b.bp("/prod/accountConfiguration");
1089
685
  let body;
1090
686
  body = JSON.stringify(take(input, {
1091
687
  accountConfiguration: [, (_) => se_AccountConfiguration(_, context), `AccountConfiguration`],
1092
688
  }));
1093
- return new __HttpRequest({
1094
- protocol,
1095
- hostname,
1096
- port,
1097
- method: "PUT",
1098
- headers,
1099
- path: resolvedPath,
1100
- body,
1101
- });
689
+ b.m("PUT").h(headers).b(body);
690
+ return b.build();
1102
691
  };
1103
692
  export const se_UpdateChannelCommand = async (input, context) => {
1104
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
693
+ const b = rb(input, context);
1105
694
  const headers = {
1106
695
  "content-type": "application/json",
1107
696
  };
1108
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/channels/{ChannelId}";
1109
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
697
+ b.bp("/prod/channels/{ChannelId}");
698
+ b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
1110
699
  let body;
1111
700
  body = JSON.stringify(take(input, {
1112
701
  cdiInputSpecification: [, (_) => se_CdiInputSpecification(_, context), `CdiInputSpecification`],
@@ -1119,45 +708,31 @@ export const se_UpdateChannelCommand = async (input, context) => {
1119
708
  name: [, , `Name`],
1120
709
  roleArn: [, , `RoleArn`],
1121
710
  }));
1122
- return new __HttpRequest({
1123
- protocol,
1124
- hostname,
1125
- port,
1126
- method: "PUT",
1127
- headers,
1128
- path: resolvedPath,
1129
- body,
1130
- });
711
+ b.m("PUT").h(headers).b(body);
712
+ return b.build();
1131
713
  };
1132
714
  export const se_UpdateChannelClassCommand = async (input, context) => {
1133
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
715
+ const b = rb(input, context);
1134
716
  const headers = {
1135
717
  "content-type": "application/json",
1136
718
  };
1137
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/channels/{ChannelId}/channelClass";
1138
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
719
+ b.bp("/prod/channels/{ChannelId}/channelClass");
720
+ b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
1139
721
  let body;
1140
722
  body = JSON.stringify(take(input, {
1141
723
  channelClass: [, , `ChannelClass`],
1142
724
  destinations: [, (_) => se___listOfOutputDestination(_, context), `Destinations`],
1143
725
  }));
1144
- return new __HttpRequest({
1145
- protocol,
1146
- hostname,
1147
- port,
1148
- method: "PUT",
1149
- headers,
1150
- path: resolvedPath,
1151
- body,
1152
- });
726
+ b.m("PUT").h(headers).b(body);
727
+ return b.build();
1153
728
  };
1154
729
  export const se_UpdateInputCommand = async (input, context) => {
1155
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
730
+ const b = rb(input, context);
1156
731
  const headers = {
1157
732
  "content-type": "application/json",
1158
733
  };
1159
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputs/{InputId}";
1160
- resolvedPath = __resolvedPath(resolvedPath, input, "InputId", () => input.InputId, "{InputId}", false);
734
+ b.bp("/prod/inputs/{InputId}");
735
+ b.p("InputId", () => input.InputId, "{InputId}", false);
1161
736
  let body;
1162
737
  body = JSON.stringify(take(input, {
1163
738
  destinations: [, (_) => se___listOfInputDestinationRequest(_, context), `Destinations`],
@@ -1168,23 +743,16 @@ export const se_UpdateInputCommand = async (input, context) => {
1168
743
  roleArn: [, , `RoleArn`],
1169
744
  sources: [, (_) => se___listOfInputSourceRequest(_, context), `Sources`],
1170
745
  }));
1171
- return new __HttpRequest({
1172
- protocol,
1173
- hostname,
1174
- port,
1175
- method: "PUT",
1176
- headers,
1177
- path: resolvedPath,
1178
- body,
1179
- });
746
+ b.m("PUT").h(headers).b(body);
747
+ return b.build();
1180
748
  };
1181
749
  export const se_UpdateInputDeviceCommand = async (input, context) => {
1182
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
750
+ const b = rb(input, context);
1183
751
  const headers = {
1184
752
  "content-type": "application/json",
1185
753
  };
1186
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/inputDevices/{InputDeviceId}";
1187
- resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
754
+ b.bp("/prod/inputDevices/{InputDeviceId}");
755
+ b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
1188
756
  let body;
1189
757
  body = JSON.stringify(take(input, {
1190
758
  availabilityZone: [, , `AvailabilityZone`],
@@ -1192,105 +760,68 @@ export const se_UpdateInputDeviceCommand = async (input, context) => {
1192
760
  name: [, , `Name`],
1193
761
  uhdDeviceSettings: [, (_) => se_InputDeviceConfigurableSettings(_, context), `UhdDeviceSettings`],
1194
762
  }));
1195
- return new __HttpRequest({
1196
- protocol,
1197
- hostname,
1198
- port,
1199
- method: "PUT",
1200
- headers,
1201
- path: resolvedPath,
1202
- body,
1203
- });
763
+ b.m("PUT").h(headers).b(body);
764
+ return b.build();
1204
765
  };
1205
766
  export const se_UpdateInputSecurityGroupCommand = async (input, context) => {
1206
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
767
+ const b = rb(input, context);
1207
768
  const headers = {
1208
769
  "content-type": "application/json",
1209
770
  };
1210
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1211
- "/prod/inputSecurityGroups/{InputSecurityGroupId}";
1212
- resolvedPath = __resolvedPath(resolvedPath, input, "InputSecurityGroupId", () => input.InputSecurityGroupId, "{InputSecurityGroupId}", false);
771
+ b.bp("/prod/inputSecurityGroups/{InputSecurityGroupId}");
772
+ b.p("InputSecurityGroupId", () => input.InputSecurityGroupId, "{InputSecurityGroupId}", false);
1213
773
  let body;
1214
774
  body = JSON.stringify(take(input, {
1215
775
  tags: [, (_) => _json(_), `Tags`],
1216
776
  whitelistRules: [, (_) => se___listOfInputWhitelistRuleCidr(_, context), `WhitelistRules`],
1217
777
  }));
1218
- return new __HttpRequest({
1219
- protocol,
1220
- hostname,
1221
- port,
1222
- method: "PUT",
1223
- headers,
1224
- path: resolvedPath,
1225
- body,
1226
- });
778
+ b.m("PUT").h(headers).b(body);
779
+ return b.build();
1227
780
  };
1228
781
  export const se_UpdateMultiplexCommand = async (input, context) => {
1229
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
782
+ const b = rb(input, context);
1230
783
  const headers = {
1231
784
  "content-type": "application/json",
1232
785
  };
1233
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/multiplexes/{MultiplexId}";
1234
- resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
786
+ b.bp("/prod/multiplexes/{MultiplexId}");
787
+ b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
1235
788
  let body;
1236
789
  body = JSON.stringify(take(input, {
1237
790
  multiplexSettings: [, (_) => se_MultiplexSettings(_, context), `MultiplexSettings`],
1238
791
  name: [, , `Name`],
1239
792
  }));
1240
- return new __HttpRequest({
1241
- protocol,
1242
- hostname,
1243
- port,
1244
- method: "PUT",
1245
- headers,
1246
- path: resolvedPath,
1247
- body,
1248
- });
793
+ b.m("PUT").h(headers).b(body);
794
+ return b.build();
1249
795
  };
1250
796
  export const se_UpdateMultiplexProgramCommand = async (input, context) => {
1251
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
797
+ const b = rb(input, context);
1252
798
  const headers = {
1253
799
  "content-type": "application/json",
1254
800
  };
1255
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1256
- "/prod/multiplexes/{MultiplexId}/programs/{ProgramName}";
1257
- resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
1258
- resolvedPath = __resolvedPath(resolvedPath, input, "ProgramName", () => input.ProgramName, "{ProgramName}", false);
801
+ b.bp("/prod/multiplexes/{MultiplexId}/programs/{ProgramName}");
802
+ b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
803
+ b.p("ProgramName", () => input.ProgramName, "{ProgramName}", false);
1259
804
  let body;
1260
805
  body = JSON.stringify(take(input, {
1261
806
  multiplexProgramSettings: [, (_) => se_MultiplexProgramSettings(_, context), `MultiplexProgramSettings`],
1262
807
  }));
1263
- return new __HttpRequest({
1264
- protocol,
1265
- hostname,
1266
- port,
1267
- method: "PUT",
1268
- headers,
1269
- path: resolvedPath,
1270
- body,
1271
- });
808
+ b.m("PUT").h(headers).b(body);
809
+ return b.build();
1272
810
  };
1273
811
  export const se_UpdateReservationCommand = async (input, context) => {
1274
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
812
+ const b = rb(input, context);
1275
813
  const headers = {
1276
814
  "content-type": "application/json",
1277
815
  };
1278
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/prod/reservations/{ReservationId}";
1279
- resolvedPath = __resolvedPath(resolvedPath, input, "ReservationId", () => input.ReservationId, "{ReservationId}", false);
816
+ b.bp("/prod/reservations/{ReservationId}");
817
+ b.p("ReservationId", () => input.ReservationId, "{ReservationId}", false);
1280
818
  let body;
1281
819
  body = JSON.stringify(take(input, {
1282
820
  name: [, , `Name`],
1283
821
  renewalSettings: [, (_) => se_RenewalSettings(_, context), `RenewalSettings`],
1284
822
  }));
1285
- return new __HttpRequest({
1286
- protocol,
1287
- hostname,
1288
- port,
1289
- method: "PUT",
1290
- headers,
1291
- path: resolvedPath,
1292
- body,
1293
- });
823
+ b.m("PUT").h(headers).b(body);
824
+ return b.build();
1294
825
  };
1295
826
  export const de_AcceptInputDeviceTransferCommand = async (output, context) => {
1296
827
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2712,16 +2243,10 @@ export const de_DescribeInputDeviceThumbnailCommand = async (output, context) =>
2712
2243
  }
2713
2244
  const contents = map({
2714
2245
  $metadata: deserializeMetadata(output),
2715
- ContentType: [, output.headers["content-type"]],
2716
- ContentLength: [
2717
- () => void 0 !== output.headers["content-length"],
2718
- () => __strictParseLong(output.headers["content-length"]),
2719
- ],
2720
- ETag: [, output.headers["etag"]],
2721
- LastModified: [
2722
- () => void 0 !== output.headers["last-modified"],
2723
- () => __expectNonNull(__parseRfc7231DateTime(output.headers["last-modified"])),
2724
- ],
2246
+ [_CT]: [, output.headers[_ct]],
2247
+ [_CL]: [() => void 0 !== output.headers[_cl], () => __strictParseLong(output.headers[_cl])],
2248
+ [_ET]: [, output.headers[_e]],
2249
+ [_LM]: [() => void 0 !== output.headers[_lm], () => __expectNonNull(__parseRfc7231DateTime(output.headers[_lm]))],
2725
2250
  });
2726
2251
  const data = output.body;
2727
2252
  context.sdkStreamMixin(data);
@@ -9043,6 +8568,48 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
9043
8568
  value !== "" &&
9044
8569
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
9045
8570
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
8571
+ const _A = "Accept";
8572
+ const _C = "Codec";
8573
+ const _CC = "ChannelClass";
8574
+ const _CCh = "ChannelConfiguration";
8575
+ const _CL = "ContentLength";
8576
+ const _CT = "ContentType";
8577
+ const _D = "Duration";
8578
+ const _ET = "ETag";
8579
+ const _LM = "LastModified";
8580
+ const _MB = "MaximumBitrate";
8581
+ const _MF = "MaximumFramerate";
8582
+ const _MR = "MaxResults";
8583
+ const _NT = "NextToken";
8584
+ const _PI = "PipelineId";
8585
+ const _R = "Resolution";
8586
+ const _RT = "ResourceType";
8587
+ const _SF = "SpecialFeature";
8588
+ const _TK = "TagKeys";
8589
+ const _TT = "ThumbnailType";
8590
+ const _TTr = "TransferType";
8591
+ const _VQ = "VideoQuality";
8592
+ const _a = "accept";
8593
+ const _c = "codec";
8594
+ const _cC = "channelClass";
8595
+ const _cCh = "channelConfiguration";
8596
+ const _cl = "content-length";
8597
+ const _ct = "content-type";
8598
+ const _d = "duration";
8599
+ const _e = "etag";
8600
+ const _lm = "last-modified";
8601
+ const _mB = "maximumBitrate";
8602
+ const _mF = "maximumFramerate";
8603
+ const _mR = "maxResults";
8604
+ const _nT = "nextToken";
8605
+ const _pI = "pipelineId";
8606
+ const _r = "resolution";
8607
+ const _rT = "resourceType";
8608
+ const _sF = "specialFeature";
8609
+ const _tK = "tagKeys";
8610
+ const _tT = "thumbnailType";
8611
+ const _tTr = "transferType";
8612
+ const _vQ = "videoQuality";
9046
8613
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
9047
8614
  if (encoded.length) {
9048
8615
  return JSON.parse(encoded);