@aws-sdk/client-mediaconnect 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 +283 -644
  2. package/dist-es/protocols/Aws_restJson1.js +284 -645
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,139 +1,97 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { MediaConnectServiceException as __BaseException } from "../models/MediaConnectServiceException";
4
4
  import { AddFlowOutputs420Exception, BadRequestException, ConflictException, CreateBridge420Exception, CreateFlow420Exception, CreateGateway420Exception, ForbiddenException, GrantFlowEntitlements420Exception, InternalServerErrorException, NotFoundException, ServiceUnavailableException, TooManyRequestsException, } from "../models/models_0";
5
5
  export const se_AddBridgeOutputsCommand = async (input, context) => {
6
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
6
+ const b = rb(input, context);
7
7
  const headers = {
8
8
  "content-type": "application/json",
9
9
  };
10
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}/outputs";
11
- resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
10
+ b.bp("/v1/bridges/{BridgeArn}/outputs");
11
+ b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
12
12
  let body;
13
13
  body = JSON.stringify(take(input, {
14
14
  outputs: [, (_) => se___listOfAddBridgeOutputRequest(_, context), `Outputs`],
15
15
  }));
16
- return new __HttpRequest({
17
- protocol,
18
- hostname,
19
- port,
20
- method: "POST",
21
- headers,
22
- path: resolvedPath,
23
- body,
24
- });
16
+ b.m("POST").h(headers).b(body);
17
+ return b.build();
25
18
  };
26
19
  export const se_AddBridgeSourcesCommand = async (input, context) => {
27
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
20
+ const b = rb(input, context);
28
21
  const headers = {
29
22
  "content-type": "application/json",
30
23
  };
31
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}/sources";
32
- resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
24
+ b.bp("/v1/bridges/{BridgeArn}/sources");
25
+ b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
33
26
  let body;
34
27
  body = JSON.stringify(take(input, {
35
28
  sources: [, (_) => se___listOfAddBridgeSourceRequest(_, context), `Sources`],
36
29
  }));
37
- return new __HttpRequest({
38
- protocol,
39
- hostname,
40
- port,
41
- method: "POST",
42
- headers,
43
- path: resolvedPath,
44
- body,
45
- });
30
+ b.m("POST").h(headers).b(body);
31
+ return b.build();
46
32
  };
47
33
  export const se_AddFlowMediaStreamsCommand = async (input, context) => {
48
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
34
+ const b = rb(input, context);
49
35
  const headers = {
50
36
  "content-type": "application/json",
51
37
  };
52
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/mediaStreams";
53
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
38
+ b.bp("/v1/flows/{FlowArn}/mediaStreams");
39
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
54
40
  let body;
55
41
  body = JSON.stringify(take(input, {
56
42
  mediaStreams: [, (_) => se___listOfAddMediaStreamRequest(_, context), `MediaStreams`],
57
43
  }));
58
- return new __HttpRequest({
59
- protocol,
60
- hostname,
61
- port,
62
- method: "POST",
63
- headers,
64
- path: resolvedPath,
65
- body,
66
- });
44
+ b.m("POST").h(headers).b(body);
45
+ return b.build();
67
46
  };
68
47
  export const se_AddFlowOutputsCommand = async (input, context) => {
69
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
48
+ const b = rb(input, context);
70
49
  const headers = {
71
50
  "content-type": "application/json",
72
51
  };
73
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/outputs";
74
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
52
+ b.bp("/v1/flows/{FlowArn}/outputs");
53
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
75
54
  let body;
76
55
  body = JSON.stringify(take(input, {
77
56
  outputs: [, (_) => se___listOfAddOutputRequest(_, context), `Outputs`],
78
57
  }));
79
- return new __HttpRequest({
80
- protocol,
81
- hostname,
82
- port,
83
- method: "POST",
84
- headers,
85
- path: resolvedPath,
86
- body,
87
- });
58
+ b.m("POST").h(headers).b(body);
59
+ return b.build();
88
60
  };
89
61
  export const se_AddFlowSourcesCommand = async (input, context) => {
90
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
62
+ const b = rb(input, context);
91
63
  const headers = {
92
64
  "content-type": "application/json",
93
65
  };
94
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/source";
95
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
66
+ b.bp("/v1/flows/{FlowArn}/source");
67
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
96
68
  let body;
97
69
  body = JSON.stringify(take(input, {
98
70
  sources: [, (_) => se___listOfSetSourceRequest(_, context), `Sources`],
99
71
  }));
100
- return new __HttpRequest({
101
- protocol,
102
- hostname,
103
- port,
104
- method: "POST",
105
- headers,
106
- path: resolvedPath,
107
- body,
108
- });
72
+ b.m("POST").h(headers).b(body);
73
+ return b.build();
109
74
  };
110
75
  export const se_AddFlowVpcInterfacesCommand = async (input, context) => {
111
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
76
+ const b = rb(input, context);
112
77
  const headers = {
113
78
  "content-type": "application/json",
114
79
  };
115
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/vpcInterfaces";
116
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
80
+ b.bp("/v1/flows/{FlowArn}/vpcInterfaces");
81
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
117
82
  let body;
118
83
  body = JSON.stringify(take(input, {
119
84
  vpcInterfaces: [, (_) => se___listOfVpcInterfaceRequest(_, context), `VpcInterfaces`],
120
85
  }));
121
- return new __HttpRequest({
122
- protocol,
123
- hostname,
124
- port,
125
- method: "POST",
126
- headers,
127
- path: resolvedPath,
128
- body,
129
- });
86
+ b.m("POST").h(headers).b(body);
87
+ return b.build();
130
88
  };
131
89
  export const se_CreateBridgeCommand = async (input, context) => {
132
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
90
+ const b = rb(input, context);
133
91
  const headers = {
134
92
  "content-type": "application/json",
135
93
  };
136
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges";
94
+ b.bp("/v1/bridges");
137
95
  let body;
138
96
  body = JSON.stringify(take(input, {
139
97
  egressGatewayBridge: [, (_) => se_AddEgressGatewayBridgeRequest(_, context), `EgressGatewayBridge`],
@@ -144,22 +102,15 @@ export const se_CreateBridgeCommand = async (input, context) => {
144
102
  sourceFailoverConfig: [, (_) => se_FailoverConfig(_, context), `SourceFailoverConfig`],
145
103
  sources: [, (_) => se___listOfAddBridgeSourceRequest(_, context), `Sources`],
146
104
  }));
147
- return new __HttpRequest({
148
- protocol,
149
- hostname,
150
- port,
151
- method: "POST",
152
- headers,
153
- path: resolvedPath,
154
- body,
155
- });
105
+ b.m("POST").h(headers).b(body);
106
+ return b.build();
156
107
  };
157
108
  export const se_CreateFlowCommand = async (input, context) => {
158
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
109
+ const b = rb(input, context);
159
110
  const headers = {
160
111
  "content-type": "application/json",
161
112
  };
162
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows";
113
+ b.bp("/v1/flows");
163
114
  let body;
164
115
  body = JSON.stringify(take(input, {
165
116
  availabilityZone: [, , `AvailabilityZone`],
@@ -173,727 +124,442 @@ export const se_CreateFlowCommand = async (input, context) => {
173
124
  sources: [, (_) => se___listOfSetSourceRequest(_, context), `Sources`],
174
125
  vpcInterfaces: [, (_) => se___listOfVpcInterfaceRequest(_, context), `VpcInterfaces`],
175
126
  }));
176
- return new __HttpRequest({
177
- protocol,
178
- hostname,
179
- port,
180
- method: "POST",
181
- headers,
182
- path: resolvedPath,
183
- body,
184
- });
127
+ b.m("POST").h(headers).b(body);
128
+ return b.build();
185
129
  };
186
130
  export const se_CreateGatewayCommand = async (input, context) => {
187
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
131
+ const b = rb(input, context);
188
132
  const headers = {
189
133
  "content-type": "application/json",
190
134
  };
191
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateways";
135
+ b.bp("/v1/gateways");
192
136
  let body;
193
137
  body = JSON.stringify(take(input, {
194
138
  egressCidrBlocks: [, (_) => _json(_), `EgressCidrBlocks`],
195
139
  name: [, , `Name`],
196
140
  networks: [, (_) => se___listOfGatewayNetwork(_, context), `Networks`],
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_DeleteBridgeCommand = 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
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}";
212
- resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
148
+ b.bp("/v1/bridges/{BridgeArn}");
149
+ b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
213
150
  let body;
214
- return new __HttpRequest({
215
- protocol,
216
- hostname,
217
- port,
218
- method: "DELETE",
219
- headers,
220
- path: resolvedPath,
221
- body,
222
- });
151
+ b.m("DELETE").h(headers).b(body);
152
+ return b.build();
223
153
  };
224
154
  export const se_DeleteFlowCommand = async (input, context) => {
225
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
155
+ const b = rb(input, context);
226
156
  const headers = {};
227
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}";
228
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
157
+ b.bp("/v1/flows/{FlowArn}");
158
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
229
159
  let body;
230
- return new __HttpRequest({
231
- protocol,
232
- hostname,
233
- port,
234
- method: "DELETE",
235
- headers,
236
- path: resolvedPath,
237
- body,
238
- });
160
+ b.m("DELETE").h(headers).b(body);
161
+ return b.build();
239
162
  };
240
163
  export const se_DeleteGatewayCommand = async (input, context) => {
241
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
164
+ const b = rb(input, context);
242
165
  const headers = {};
243
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateways/{GatewayArn}";
244
- resolvedPath = __resolvedPath(resolvedPath, input, "GatewayArn", () => input.GatewayArn, "{GatewayArn}", false);
166
+ b.bp("/v1/gateways/{GatewayArn}");
167
+ b.p("GatewayArn", () => input.GatewayArn, "{GatewayArn}", false);
245
168
  let body;
246
- return new __HttpRequest({
247
- protocol,
248
- hostname,
249
- port,
250
- method: "DELETE",
251
- headers,
252
- path: resolvedPath,
253
- body,
254
- });
169
+ b.m("DELETE").h(headers).b(body);
170
+ return b.build();
255
171
  };
256
172
  export const se_DeregisterGatewayInstanceCommand = async (input, context) => {
257
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
173
+ const b = rb(input, context);
258
174
  const headers = {};
259
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
260
- "/v1/gateway-instances/{GatewayInstanceArn}";
261
- resolvedPath = __resolvedPath(resolvedPath, input, "GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
175
+ b.bp("/v1/gateway-instances/{GatewayInstanceArn}");
176
+ b.p("GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
262
177
  const query = map({
263
- force: [() => input.Force !== void 0, () => input.Force.toString()],
178
+ [_f]: [() => input.Force !== void 0, () => input[_F].toString()],
264
179
  });
265
180
  let body;
266
- return new __HttpRequest({
267
- protocol,
268
- hostname,
269
- port,
270
- method: "DELETE",
271
- headers,
272
- path: resolvedPath,
273
- query,
274
- body,
275
- });
181
+ b.m("DELETE").h(headers).q(query).b(body);
182
+ return b.build();
276
183
  };
277
184
  export const se_DescribeBridgeCommand = async (input, context) => {
278
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
185
+ const b = rb(input, context);
279
186
  const headers = {};
280
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}";
281
- resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
187
+ b.bp("/v1/bridges/{BridgeArn}");
188
+ b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
282
189
  let body;
283
- return new __HttpRequest({
284
- protocol,
285
- hostname,
286
- port,
287
- method: "GET",
288
- headers,
289
- path: resolvedPath,
290
- body,
291
- });
190
+ b.m("GET").h(headers).b(body);
191
+ return b.build();
292
192
  };
293
193
  export const se_DescribeFlowCommand = async (input, context) => {
294
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
194
+ const b = rb(input, context);
295
195
  const headers = {};
296
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}";
297
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
196
+ b.bp("/v1/flows/{FlowArn}");
197
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
298
198
  let body;
299
- return new __HttpRequest({
300
- protocol,
301
- hostname,
302
- port,
303
- method: "GET",
304
- headers,
305
- path: resolvedPath,
306
- body,
307
- });
199
+ b.m("GET").h(headers).b(body);
200
+ return b.build();
308
201
  };
309
202
  export const se_DescribeGatewayCommand = async (input, context) => {
310
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
203
+ const b = rb(input, context);
311
204
  const headers = {};
312
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateways/{GatewayArn}";
313
- resolvedPath = __resolvedPath(resolvedPath, input, "GatewayArn", () => input.GatewayArn, "{GatewayArn}", false);
205
+ b.bp("/v1/gateways/{GatewayArn}");
206
+ b.p("GatewayArn", () => input.GatewayArn, "{GatewayArn}", false);
314
207
  let body;
315
- return new __HttpRequest({
316
- protocol,
317
- hostname,
318
- port,
319
- method: "GET",
320
- headers,
321
- path: resolvedPath,
322
- body,
323
- });
208
+ b.m("GET").h(headers).b(body);
209
+ return b.build();
324
210
  };
325
211
  export const se_DescribeGatewayInstanceCommand = async (input, context) => {
326
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
212
+ const b = rb(input, context);
327
213
  const headers = {};
328
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
329
- "/v1/gateway-instances/{GatewayInstanceArn}";
330
- resolvedPath = __resolvedPath(resolvedPath, input, "GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
214
+ b.bp("/v1/gateway-instances/{GatewayInstanceArn}");
215
+ b.p("GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
331
216
  let body;
332
- return new __HttpRequest({
333
- protocol,
334
- hostname,
335
- port,
336
- method: "GET",
337
- headers,
338
- path: resolvedPath,
339
- body,
340
- });
217
+ b.m("GET").h(headers).b(body);
218
+ return b.build();
341
219
  };
342
220
  export const se_DescribeOfferingCommand = async (input, context) => {
343
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
221
+ const b = rb(input, context);
344
222
  const headers = {};
345
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/offerings/{OfferingArn}";
346
- resolvedPath = __resolvedPath(resolvedPath, input, "OfferingArn", () => input.OfferingArn, "{OfferingArn}", false);
223
+ b.bp("/v1/offerings/{OfferingArn}");
224
+ b.p("OfferingArn", () => input.OfferingArn, "{OfferingArn}", false);
347
225
  let body;
348
- return new __HttpRequest({
349
- protocol,
350
- hostname,
351
- port,
352
- method: "GET",
353
- headers,
354
- path: resolvedPath,
355
- body,
356
- });
226
+ b.m("GET").h(headers).b(body);
227
+ return b.build();
357
228
  };
358
229
  export const se_DescribeReservationCommand = async (input, context) => {
359
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
230
+ const b = rb(input, context);
360
231
  const headers = {};
361
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/reservations/{ReservationArn}";
362
- resolvedPath = __resolvedPath(resolvedPath, input, "ReservationArn", () => input.ReservationArn, "{ReservationArn}", false);
232
+ b.bp("/v1/reservations/{ReservationArn}");
233
+ b.p("ReservationArn", () => input.ReservationArn, "{ReservationArn}", false);
363
234
  let body;
364
- return new __HttpRequest({
365
- protocol,
366
- hostname,
367
- port,
368
- method: "GET",
369
- headers,
370
- path: resolvedPath,
371
- body,
372
- });
235
+ b.m("GET").h(headers).b(body);
236
+ return b.build();
373
237
  };
374
238
  export const se_GrantFlowEntitlementsCommand = async (input, context) => {
375
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
239
+ const b = rb(input, context);
376
240
  const headers = {
377
241
  "content-type": "application/json",
378
242
  };
379
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/entitlements";
380
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
243
+ b.bp("/v1/flows/{FlowArn}/entitlements");
244
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
381
245
  let body;
382
246
  body = JSON.stringify(take(input, {
383
247
  entitlements: [, (_) => se___listOfGrantEntitlementRequest(_, context), `Entitlements`],
384
248
  }));
385
- return new __HttpRequest({
386
- protocol,
387
- hostname,
388
- port,
389
- method: "POST",
390
- headers,
391
- path: resolvedPath,
392
- body,
393
- });
249
+ b.m("POST").h(headers).b(body);
250
+ return b.build();
394
251
  };
395
252
  export const se_ListBridgesCommand = async (input, context) => {
396
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
253
+ const b = rb(input, context);
397
254
  const headers = {};
398
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges";
255
+ b.bp("/v1/bridges");
399
256
  const query = map({
400
- filterArn: [, input.FilterArn],
401
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
402
- nextToken: [, input.NextToken],
257
+ [_fA]: [, input[_FA]],
258
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
259
+ [_nT]: [, input[_NT]],
403
260
  });
404
261
  let body;
405
- return new __HttpRequest({
406
- protocol,
407
- hostname,
408
- port,
409
- method: "GET",
410
- headers,
411
- path: resolvedPath,
412
- query,
413
- body,
414
- });
262
+ b.m("GET").h(headers).q(query).b(body);
263
+ return b.build();
415
264
  };
416
265
  export const se_ListEntitlementsCommand = async (input, context) => {
417
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
266
+ const b = rb(input, context);
418
267
  const headers = {};
419
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/entitlements";
268
+ b.bp("/v1/entitlements");
420
269
  const query = map({
421
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
422
- nextToken: [, input.NextToken],
270
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
271
+ [_nT]: [, input[_NT]],
423
272
  });
424
273
  let body;
425
- return new __HttpRequest({
426
- protocol,
427
- hostname,
428
- port,
429
- method: "GET",
430
- headers,
431
- path: resolvedPath,
432
- query,
433
- body,
434
- });
274
+ b.m("GET").h(headers).q(query).b(body);
275
+ return b.build();
435
276
  };
436
277
  export const se_ListFlowsCommand = async (input, context) => {
437
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
278
+ const b = rb(input, context);
438
279
  const headers = {};
439
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows";
280
+ b.bp("/v1/flows");
440
281
  const query = map({
441
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
442
- nextToken: [, input.NextToken],
282
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
283
+ [_nT]: [, input[_NT]],
443
284
  });
444
285
  let body;
445
- return new __HttpRequest({
446
- protocol,
447
- hostname,
448
- port,
449
- method: "GET",
450
- headers,
451
- path: resolvedPath,
452
- query,
453
- body,
454
- });
286
+ b.m("GET").h(headers).q(query).b(body);
287
+ return b.build();
455
288
  };
456
289
  export const se_ListGatewayInstancesCommand = async (input, context) => {
457
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
290
+ const b = rb(input, context);
458
291
  const headers = {};
459
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateway-instances";
292
+ b.bp("/v1/gateway-instances");
460
293
  const query = map({
461
- filterArn: [, input.FilterArn],
462
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
463
- nextToken: [, input.NextToken],
294
+ [_fA]: [, input[_FA]],
295
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
296
+ [_nT]: [, input[_NT]],
464
297
  });
465
298
  let body;
466
- return new __HttpRequest({
467
- protocol,
468
- hostname,
469
- port,
470
- method: "GET",
471
- headers,
472
- path: resolvedPath,
473
- query,
474
- body,
475
- });
299
+ b.m("GET").h(headers).q(query).b(body);
300
+ return b.build();
476
301
  };
477
302
  export const se_ListGatewaysCommand = async (input, context) => {
478
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
303
+ const b = rb(input, context);
479
304
  const headers = {};
480
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateways";
305
+ b.bp("/v1/gateways");
481
306
  const query = map({
482
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
483
- nextToken: [, input.NextToken],
307
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
308
+ [_nT]: [, input[_NT]],
484
309
  });
485
310
  let body;
486
- return new __HttpRequest({
487
- protocol,
488
- hostname,
489
- port,
490
- method: "GET",
491
- headers,
492
- path: resolvedPath,
493
- query,
494
- body,
495
- });
311
+ b.m("GET").h(headers).q(query).b(body);
312
+ return b.build();
496
313
  };
497
314
  export const se_ListOfferingsCommand = async (input, context) => {
498
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
315
+ const b = rb(input, context);
499
316
  const headers = {};
500
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/offerings";
317
+ b.bp("/v1/offerings");
501
318
  const query = map({
502
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
503
- nextToken: [, input.NextToken],
319
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
320
+ [_nT]: [, input[_NT]],
504
321
  });
505
322
  let body;
506
- return new __HttpRequest({
507
- protocol,
508
- hostname,
509
- port,
510
- method: "GET",
511
- headers,
512
- path: resolvedPath,
513
- query,
514
- body,
515
- });
323
+ b.m("GET").h(headers).q(query).b(body);
324
+ return b.build();
516
325
  };
517
326
  export const se_ListReservationsCommand = async (input, context) => {
518
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
327
+ const b = rb(input, context);
519
328
  const headers = {};
520
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/reservations";
329
+ b.bp("/v1/reservations");
521
330
  const query = map({
522
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
523
- nextToken: [, input.NextToken],
331
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
332
+ [_nT]: [, input[_NT]],
524
333
  });
525
334
  let body;
526
- return new __HttpRequest({
527
- protocol,
528
- hostname,
529
- port,
530
- method: "GET",
531
- headers,
532
- path: resolvedPath,
533
- query,
534
- body,
535
- });
335
+ b.m("GET").h(headers).q(query).b(body);
336
+ return b.build();
536
337
  };
537
338
  export const se_ListTagsForResourceCommand = async (input, context) => {
538
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
339
+ const b = rb(input, context);
539
340
  const headers = {};
540
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
541
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
341
+ b.bp("/tags/{ResourceArn}");
342
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
542
343
  let body;
543
- return new __HttpRequest({
544
- protocol,
545
- hostname,
546
- port,
547
- method: "GET",
548
- headers,
549
- path: resolvedPath,
550
- body,
551
- });
344
+ b.m("GET").h(headers).b(body);
345
+ return b.build();
552
346
  };
553
347
  export const se_PurchaseOfferingCommand = async (input, context) => {
554
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
348
+ const b = rb(input, context);
555
349
  const headers = {
556
350
  "content-type": "application/json",
557
351
  };
558
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/offerings/{OfferingArn}";
559
- resolvedPath = __resolvedPath(resolvedPath, input, "OfferingArn", () => input.OfferingArn, "{OfferingArn}", false);
352
+ b.bp("/v1/offerings/{OfferingArn}");
353
+ b.p("OfferingArn", () => input.OfferingArn, "{OfferingArn}", false);
560
354
  let body;
561
355
  body = JSON.stringify(take(input, {
562
356
  reservationName: [, , `ReservationName`],
563
357
  start: [, , `Start`],
564
358
  }));
565
- return new __HttpRequest({
566
- protocol,
567
- hostname,
568
- port,
569
- method: "POST",
570
- headers,
571
- path: resolvedPath,
572
- body,
573
- });
359
+ b.m("POST").h(headers).b(body);
360
+ return b.build();
574
361
  };
575
362
  export const se_RemoveBridgeOutputCommand = async (input, context) => {
576
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
363
+ const b = rb(input, context);
577
364
  const headers = {};
578
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
579
- "/v1/bridges/{BridgeArn}/outputs/{OutputName}";
580
- resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
581
- resolvedPath = __resolvedPath(resolvedPath, input, "OutputName", () => input.OutputName, "{OutputName}", false);
365
+ b.bp("/v1/bridges/{BridgeArn}/outputs/{OutputName}");
366
+ b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
367
+ b.p("OutputName", () => input.OutputName, "{OutputName}", false);
582
368
  let body;
583
- return new __HttpRequest({
584
- protocol,
585
- hostname,
586
- port,
587
- method: "DELETE",
588
- headers,
589
- path: resolvedPath,
590
- body,
591
- });
369
+ b.m("DELETE").h(headers).b(body);
370
+ return b.build();
592
371
  };
593
372
  export const se_RemoveBridgeSourceCommand = async (input, context) => {
594
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
373
+ const b = rb(input, context);
595
374
  const headers = {};
596
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
597
- "/v1/bridges/{BridgeArn}/sources/{SourceName}";
598
- resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
599
- resolvedPath = __resolvedPath(resolvedPath, input, "SourceName", () => input.SourceName, "{SourceName}", false);
375
+ b.bp("/v1/bridges/{BridgeArn}/sources/{SourceName}");
376
+ b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
377
+ b.p("SourceName", () => input.SourceName, "{SourceName}", false);
600
378
  let body;
601
- return new __HttpRequest({
602
- protocol,
603
- hostname,
604
- port,
605
- method: "DELETE",
606
- headers,
607
- path: resolvedPath,
608
- body,
609
- });
379
+ b.m("DELETE").h(headers).b(body);
380
+ return b.build();
610
381
  };
611
382
  export const se_RemoveFlowMediaStreamCommand = async (input, context) => {
612
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
383
+ const b = rb(input, context);
613
384
  const headers = {};
614
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
615
- "/v1/flows/{FlowArn}/mediaStreams/{MediaStreamName}";
616
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
617
- resolvedPath = __resolvedPath(resolvedPath, input, "MediaStreamName", () => input.MediaStreamName, "{MediaStreamName}", false);
385
+ b.bp("/v1/flows/{FlowArn}/mediaStreams/{MediaStreamName}");
386
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
387
+ b.p("MediaStreamName", () => input.MediaStreamName, "{MediaStreamName}", false);
618
388
  let body;
619
- return new __HttpRequest({
620
- protocol,
621
- hostname,
622
- port,
623
- method: "DELETE",
624
- headers,
625
- path: resolvedPath,
626
- body,
627
- });
389
+ b.m("DELETE").h(headers).b(body);
390
+ return b.build();
628
391
  };
629
392
  export const se_RemoveFlowOutputCommand = async (input, context) => {
630
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
393
+ const b = rb(input, context);
631
394
  const headers = {};
632
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/outputs/{OutputArn}";
633
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
634
- resolvedPath = __resolvedPath(resolvedPath, input, "OutputArn", () => input.OutputArn, "{OutputArn}", false);
395
+ b.bp("/v1/flows/{FlowArn}/outputs/{OutputArn}");
396
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
397
+ b.p("OutputArn", () => input.OutputArn, "{OutputArn}", false);
635
398
  let body;
636
- return new __HttpRequest({
637
- protocol,
638
- hostname,
639
- port,
640
- method: "DELETE",
641
- headers,
642
- path: resolvedPath,
643
- body,
644
- });
399
+ b.m("DELETE").h(headers).b(body);
400
+ return b.build();
645
401
  };
646
402
  export const se_RemoveFlowSourceCommand = async (input, context) => {
647
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
403
+ const b = rb(input, context);
648
404
  const headers = {};
649
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/source/{SourceArn}";
650
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
651
- resolvedPath = __resolvedPath(resolvedPath, input, "SourceArn", () => input.SourceArn, "{SourceArn}", false);
405
+ b.bp("/v1/flows/{FlowArn}/source/{SourceArn}");
406
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
407
+ b.p("SourceArn", () => input.SourceArn, "{SourceArn}", false);
652
408
  let body;
653
- return new __HttpRequest({
654
- protocol,
655
- hostname,
656
- port,
657
- method: "DELETE",
658
- headers,
659
- path: resolvedPath,
660
- body,
661
- });
409
+ b.m("DELETE").h(headers).b(body);
410
+ return b.build();
662
411
  };
663
412
  export const se_RemoveFlowVpcInterfaceCommand = async (input, context) => {
664
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
413
+ const b = rb(input, context);
665
414
  const headers = {};
666
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
667
- "/v1/flows/{FlowArn}/vpcInterfaces/{VpcInterfaceName}";
668
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
669
- resolvedPath = __resolvedPath(resolvedPath, input, "VpcInterfaceName", () => input.VpcInterfaceName, "{VpcInterfaceName}", false);
415
+ b.bp("/v1/flows/{FlowArn}/vpcInterfaces/{VpcInterfaceName}");
416
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
417
+ b.p("VpcInterfaceName", () => input.VpcInterfaceName, "{VpcInterfaceName}", false);
670
418
  let body;
671
- return new __HttpRequest({
672
- protocol,
673
- hostname,
674
- port,
675
- method: "DELETE",
676
- headers,
677
- path: resolvedPath,
678
- body,
679
- });
419
+ b.m("DELETE").h(headers).b(body);
420
+ return b.build();
680
421
  };
681
422
  export const se_RevokeFlowEntitlementCommand = async (input, context) => {
682
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
423
+ const b = rb(input, context);
683
424
  const headers = {};
684
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
685
- "/v1/flows/{FlowArn}/entitlements/{EntitlementArn}";
686
- resolvedPath = __resolvedPath(resolvedPath, input, "EntitlementArn", () => input.EntitlementArn, "{EntitlementArn}", false);
687
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
425
+ b.bp("/v1/flows/{FlowArn}/entitlements/{EntitlementArn}");
426
+ b.p("EntitlementArn", () => input.EntitlementArn, "{EntitlementArn}", false);
427
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
688
428
  let body;
689
- return new __HttpRequest({
690
- protocol,
691
- hostname,
692
- port,
693
- method: "DELETE",
694
- headers,
695
- path: resolvedPath,
696
- body,
697
- });
429
+ b.m("DELETE").h(headers).b(body);
430
+ return b.build();
698
431
  };
699
432
  export const se_StartFlowCommand = async (input, context) => {
700
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
433
+ const b = rb(input, context);
701
434
  const headers = {};
702
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/start/{FlowArn}";
703
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
435
+ b.bp("/v1/flows/start/{FlowArn}");
436
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
704
437
  let body;
705
- return new __HttpRequest({
706
- protocol,
707
- hostname,
708
- port,
709
- method: "POST",
710
- headers,
711
- path: resolvedPath,
712
- body,
713
- });
438
+ b.m("POST").h(headers).b(body);
439
+ return b.build();
714
440
  };
715
441
  export const se_StopFlowCommand = async (input, context) => {
716
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
442
+ const b = rb(input, context);
717
443
  const headers = {};
718
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/stop/{FlowArn}";
719
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
444
+ b.bp("/v1/flows/stop/{FlowArn}");
445
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
720
446
  let body;
721
- return new __HttpRequest({
722
- protocol,
723
- hostname,
724
- port,
725
- method: "POST",
726
- headers,
727
- path: resolvedPath,
728
- body,
729
- });
447
+ b.m("POST").h(headers).b(body);
448
+ return b.build();
730
449
  };
731
450
  export const se_TagResourceCommand = async (input, context) => {
732
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
451
+ const b = rb(input, context);
733
452
  const headers = {
734
453
  "content-type": "application/json",
735
454
  };
736
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
737
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
455
+ b.bp("/tags/{ResourceArn}");
456
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
738
457
  let body;
739
458
  body = JSON.stringify(take(input, {
740
459
  tags: [, (_) => _json(_), `Tags`],
741
460
  }));
742
- return new __HttpRequest({
743
- protocol,
744
- hostname,
745
- port,
746
- method: "POST",
747
- headers,
748
- path: resolvedPath,
749
- body,
750
- });
461
+ b.m("POST").h(headers).b(body);
462
+ return b.build();
751
463
  };
752
464
  export const se_UntagResourceCommand = async (input, context) => {
753
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
465
+ const b = rb(input, context);
754
466
  const headers = {};
755
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
756
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
467
+ b.bp("/tags/{ResourceArn}");
468
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
757
469
  const query = map({
758
- tagKeys: [
470
+ [_tK]: [
759
471
  __expectNonNull(input.TagKeys, `TagKeys`) != null,
760
- () => (input.TagKeys || []).map((_entry) => _entry),
472
+ () => (input[_TK] || []).map((_entry) => _entry),
761
473
  ],
762
474
  });
763
475
  let body;
764
- return new __HttpRequest({
765
- protocol,
766
- hostname,
767
- port,
768
- method: "DELETE",
769
- headers,
770
- path: resolvedPath,
771
- query,
772
- body,
773
- });
476
+ b.m("DELETE").h(headers).q(query).b(body);
477
+ return b.build();
774
478
  };
775
479
  export const se_UpdateBridgeCommand = async (input, context) => {
776
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
480
+ const b = rb(input, context);
777
481
  const headers = {
778
482
  "content-type": "application/json",
779
483
  };
780
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}";
781
- resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
484
+ b.bp("/v1/bridges/{BridgeArn}");
485
+ b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
782
486
  let body;
783
487
  body = JSON.stringify(take(input, {
784
488
  egressGatewayBridge: [, (_) => se_UpdateEgressGatewayBridgeRequest(_, context), `EgressGatewayBridge`],
785
489
  ingressGatewayBridge: [, (_) => se_UpdateIngressGatewayBridgeRequest(_, context), `IngressGatewayBridge`],
786
490
  sourceFailoverConfig: [, (_) => se_UpdateFailoverConfig(_, context), `SourceFailoverConfig`],
787
491
  }));
788
- return new __HttpRequest({
789
- protocol,
790
- hostname,
791
- port,
792
- method: "PUT",
793
- headers,
794
- path: resolvedPath,
795
- body,
796
- });
492
+ b.m("PUT").h(headers).b(body);
493
+ return b.build();
797
494
  };
798
495
  export const se_UpdateBridgeOutputCommand = async (input, context) => {
799
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
496
+ const b = rb(input, context);
800
497
  const headers = {
801
498
  "content-type": "application/json",
802
499
  };
803
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
804
- "/v1/bridges/{BridgeArn}/outputs/{OutputName}";
805
- resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
806
- resolvedPath = __resolvedPath(resolvedPath, input, "OutputName", () => input.OutputName, "{OutputName}", false);
500
+ b.bp("/v1/bridges/{BridgeArn}/outputs/{OutputName}");
501
+ b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
502
+ b.p("OutputName", () => input.OutputName, "{OutputName}", false);
807
503
  let body;
808
504
  body = JSON.stringify(take(input, {
809
505
  networkOutput: [, (_) => se_UpdateBridgeNetworkOutputRequest(_, context), `NetworkOutput`],
810
506
  }));
811
- return new __HttpRequest({
812
- protocol,
813
- hostname,
814
- port,
815
- method: "PUT",
816
- headers,
817
- path: resolvedPath,
818
- body,
819
- });
507
+ b.m("PUT").h(headers).b(body);
508
+ return b.build();
820
509
  };
821
510
  export const se_UpdateBridgeSourceCommand = async (input, context) => {
822
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
511
+ const b = rb(input, context);
823
512
  const headers = {
824
513
  "content-type": "application/json",
825
514
  };
826
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
827
- "/v1/bridges/{BridgeArn}/sources/{SourceName}";
828
- resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
829
- resolvedPath = __resolvedPath(resolvedPath, input, "SourceName", () => input.SourceName, "{SourceName}", false);
515
+ b.bp("/v1/bridges/{BridgeArn}/sources/{SourceName}");
516
+ b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
517
+ b.p("SourceName", () => input.SourceName, "{SourceName}", false);
830
518
  let body;
831
519
  body = JSON.stringify(take(input, {
832
520
  flowSource: [, (_) => se_UpdateBridgeFlowSourceRequest(_, context), `FlowSource`],
833
521
  networkSource: [, (_) => se_UpdateBridgeNetworkSourceRequest(_, context), `NetworkSource`],
834
522
  }));
835
- return new __HttpRequest({
836
- protocol,
837
- hostname,
838
- port,
839
- method: "PUT",
840
- headers,
841
- path: resolvedPath,
842
- body,
843
- });
523
+ b.m("PUT").h(headers).b(body);
524
+ return b.build();
844
525
  };
845
526
  export const se_UpdateBridgeStateCommand = async (input, context) => {
846
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
527
+ const b = rb(input, context);
847
528
  const headers = {
848
529
  "content-type": "application/json",
849
530
  };
850
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/bridges/{BridgeArn}/state";
851
- resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
531
+ b.bp("/v1/bridges/{BridgeArn}/state");
532
+ b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
852
533
  let body;
853
534
  body = JSON.stringify(take(input, {
854
535
  desiredState: [, , `DesiredState`],
855
536
  }));
856
- return new __HttpRequest({
857
- protocol,
858
- hostname,
859
- port,
860
- method: "PUT",
861
- headers,
862
- path: resolvedPath,
863
- body,
864
- });
537
+ b.m("PUT").h(headers).b(body);
538
+ return b.build();
865
539
  };
866
540
  export const se_UpdateFlowCommand = async (input, context) => {
867
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
541
+ const b = rb(input, context);
868
542
  const headers = {
869
543
  "content-type": "application/json",
870
544
  };
871
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}";
872
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
545
+ b.bp("/v1/flows/{FlowArn}");
546
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
873
547
  let body;
874
548
  body = JSON.stringify(take(input, {
875
549
  maintenance: [, (_) => se_UpdateMaintenance(_, context), `Maintenance`],
876
550
  sourceFailoverConfig: [, (_) => se_UpdateFailoverConfig(_, context), `SourceFailoverConfig`],
877
551
  }));
878
- return new __HttpRequest({
879
- protocol,
880
- hostname,
881
- port,
882
- method: "PUT",
883
- headers,
884
- path: resolvedPath,
885
- body,
886
- });
552
+ b.m("PUT").h(headers).b(body);
553
+ return b.build();
887
554
  };
888
555
  export const se_UpdateFlowEntitlementCommand = async (input, context) => {
889
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
556
+ const b = rb(input, context);
890
557
  const headers = {
891
558
  "content-type": "application/json",
892
559
  };
893
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
894
- "/v1/flows/{FlowArn}/entitlements/{EntitlementArn}";
895
- resolvedPath = __resolvedPath(resolvedPath, input, "EntitlementArn", () => input.EntitlementArn, "{EntitlementArn}", false);
896
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
560
+ b.bp("/v1/flows/{FlowArn}/entitlements/{EntitlementArn}");
561
+ b.p("EntitlementArn", () => input.EntitlementArn, "{EntitlementArn}", false);
562
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
897
563
  let body;
898
564
  body = JSON.stringify(take(input, {
899
565
  description: [, , `Description`],
@@ -901,25 +567,17 @@ export const se_UpdateFlowEntitlementCommand = async (input, context) => {
901
567
  entitlementStatus: [, , `EntitlementStatus`],
902
568
  subscribers: [, (_) => _json(_), `Subscribers`],
903
569
  }));
904
- return new __HttpRequest({
905
- protocol,
906
- hostname,
907
- port,
908
- method: "PUT",
909
- headers,
910
- path: resolvedPath,
911
- body,
912
- });
570
+ b.m("PUT").h(headers).b(body);
571
+ return b.build();
913
572
  };
914
573
  export const se_UpdateFlowMediaStreamCommand = async (input, context) => {
915
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
574
+ const b = rb(input, context);
916
575
  const headers = {
917
576
  "content-type": "application/json",
918
577
  };
919
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
920
- "/v1/flows/{FlowArn}/mediaStreams/{MediaStreamName}";
921
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
922
- resolvedPath = __resolvedPath(resolvedPath, input, "MediaStreamName", () => input.MediaStreamName, "{MediaStreamName}", false);
578
+ b.bp("/v1/flows/{FlowArn}/mediaStreams/{MediaStreamName}");
579
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
580
+ b.p("MediaStreamName", () => input.MediaStreamName, "{MediaStreamName}", false);
923
581
  let body;
924
582
  body = JSON.stringify(take(input, {
925
583
  attributes: [, (_) => se_MediaStreamAttributesRequest(_, context), `Attributes`],
@@ -928,24 +586,17 @@ export const se_UpdateFlowMediaStreamCommand = async (input, context) => {
928
586
  mediaStreamType: [, , `MediaStreamType`],
929
587
  videoFormat: [, , `VideoFormat`],
930
588
  }));
931
- return new __HttpRequest({
932
- protocol,
933
- hostname,
934
- port,
935
- method: "PUT",
936
- headers,
937
- path: resolvedPath,
938
- body,
939
- });
589
+ b.m("PUT").h(headers).b(body);
590
+ return b.build();
940
591
  };
941
592
  export const se_UpdateFlowOutputCommand = async (input, context) => {
942
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
593
+ const b = rb(input, context);
943
594
  const headers = {
944
595
  "content-type": "application/json",
945
596
  };
946
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/outputs/{OutputArn}";
947
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
948
- resolvedPath = __resolvedPath(resolvedPath, input, "OutputArn", () => input.OutputArn, "{OutputArn}", false);
597
+ b.bp("/v1/flows/{FlowArn}/outputs/{OutputArn}");
598
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
599
+ b.p("OutputArn", () => input.OutputArn, "{OutputArn}", false);
949
600
  let body;
950
601
  body = JSON.stringify(take(input, {
951
602
  cidrAllowList: [, (_) => _json(_), `CidrAllowList`],
@@ -968,24 +619,17 @@ export const se_UpdateFlowOutputCommand = async (input, context) => {
968
619
  streamId: [, , `StreamId`],
969
620
  vpcInterfaceAttachment: [, (_) => se_VpcInterfaceAttachment(_, context), `VpcInterfaceAttachment`],
970
621
  }));
971
- return new __HttpRequest({
972
- protocol,
973
- hostname,
974
- port,
975
- method: "PUT",
976
- headers,
977
- path: resolvedPath,
978
- body,
979
- });
622
+ b.m("PUT").h(headers).b(body);
623
+ return b.build();
980
624
  };
981
625
  export const se_UpdateFlowSourceCommand = async (input, context) => {
982
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
626
+ const b = rb(input, context);
983
627
  const headers = {
984
628
  "content-type": "application/json",
985
629
  };
986
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/flows/{FlowArn}/source/{SourceArn}";
987
- resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
988
- resolvedPath = __resolvedPath(resolvedPath, input, "SourceArn", () => input.SourceArn, "{SourceArn}", false);
630
+ b.bp("/v1/flows/{FlowArn}/source/{SourceArn}");
631
+ b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
632
+ b.p("SourceArn", () => input.SourceArn, "{SourceArn}", false);
989
633
  let body;
990
634
  body = JSON.stringify(take(input, {
991
635
  decryption: [, (_) => se_UpdateEncryption(_, context), `Decryption`],
@@ -1011,37 +655,22 @@ export const se_UpdateFlowSourceCommand = async (input, context) => {
1011
655
  vpcInterfaceName: [, , `VpcInterfaceName`],
1012
656
  whitelistCidr: [, , `WhitelistCidr`],
1013
657
  }));
1014
- return new __HttpRequest({
1015
- protocol,
1016
- hostname,
1017
- port,
1018
- method: "PUT",
1019
- headers,
1020
- path: resolvedPath,
1021
- body,
1022
- });
658
+ b.m("PUT").h(headers).b(body);
659
+ return b.build();
1023
660
  };
1024
661
  export const se_UpdateGatewayInstanceCommand = async (input, context) => {
1025
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
662
+ const b = rb(input, context);
1026
663
  const headers = {
1027
664
  "content-type": "application/json",
1028
665
  };
1029
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1030
- "/v1/gateway-instances/{GatewayInstanceArn}";
1031
- resolvedPath = __resolvedPath(resolvedPath, input, "GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
666
+ b.bp("/v1/gateway-instances/{GatewayInstanceArn}");
667
+ b.p("GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
1032
668
  let body;
1033
669
  body = JSON.stringify(take(input, {
1034
670
  bridgePlacement: [, , `BridgePlacement`],
1035
671
  }));
1036
- return new __HttpRequest({
1037
- protocol,
1038
- hostname,
1039
- port,
1040
- method: "PUT",
1041
- headers,
1042
- path: resolvedPath,
1043
- body,
1044
- });
672
+ b.m("PUT").h(headers).b(body);
673
+ return b.build();
1045
674
  };
1046
675
  export const de_AddBridgeOutputsCommand = async (output, context) => {
1047
676
  if (output.statusCode !== 202 && output.statusCode >= 300) {
@@ -4590,6 +4219,16 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
4590
4219
  value !== "" &&
4591
4220
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
4592
4221
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
4222
+ const _F = "Force";
4223
+ const _FA = "FilterArn";
4224
+ const _MR = "MaxResults";
4225
+ const _NT = "NextToken";
4226
+ const _TK = "TagKeys";
4227
+ const _f = "force";
4228
+ const _fA = "filterArn";
4229
+ const _mR = "maxResults";
4230
+ const _nT = "nextToken";
4231
+ const _tK = "tagKeys";
4593
4232
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
4594
4233
  if (encoded.length) {
4595
4234
  return JSON.parse(encoded);