@aws-sdk/client-mediaconnect 3.1068.0 → 3.1069.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.
- package/dist-cjs/auth/httpAuthSchemeProvider.js +9 -15
- package/dist-cjs/endpoint/bdd.js +2 -5
- package/dist-cjs/endpoint/endpointResolver.js +7 -11
- package/dist-cjs/index.js +421 -441
- package/dist-cjs/models/MediaConnectServiceException.js +4 -8
- package/dist-cjs/models/errors.js +31 -49
- package/dist-cjs/runtimeConfig.browser.js +22 -26
- package/dist-cjs/runtimeConfig.js +30 -34
- package/dist-cjs/runtimeConfig.native.js +4 -7
- package/dist-cjs/runtimeConfig.shared.js +20 -24
- package/dist-cjs/schemas/schemas_0.js +967 -638
- package/package.json +8 -8
package/dist-cjs/index.js
CHANGED
|
@@ -1,18 +1,21 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
1
|
+
var __exportStar = (m, e) => { Object.assign(e, m); };
|
|
2
|
+
const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
|
|
3
|
+
const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
|
|
4
|
+
const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createWaiter, checkExceptions, WaiterState, createAggregatedClient } = require("@smithy/core/client");
|
|
5
|
+
exports.$Command = Command;
|
|
6
|
+
exports.__Client = Client;
|
|
7
|
+
const { resolveRegionConfig } = require("@smithy/core/config");
|
|
8
|
+
const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
|
|
9
|
+
const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
|
|
10
|
+
const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
|
|
11
|
+
const { getSchemaSerdePlugin } = require("@smithy/core/schema");
|
|
12
|
+
const { resolveHttpAuthSchemeConfig, defaultMediaConnectHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
|
|
13
|
+
const { getRuntimeConfig } = require("./runtimeConfig");
|
|
14
|
+
const { AddBridgeOutputs$, AddBridgeSources$, AddFlowMediaStreams$, AddFlowOutputs$, AddFlowSources$, AddFlowVpcInterfaces$, BatchGetRouterInput$, BatchGetRouterNetworkInterface$, BatchGetRouterOutput$, CreateBridge$, CreateFlow$, CreateGateway$, CreateRouterInput$, CreateRouterNetworkInterface$, CreateRouterOutput$, DeleteBridge$, DeleteFlow$, DeleteGateway$, DeleteRouterInput$, DeleteRouterNetworkInterface$, DeleteRouterOutput$, DeregisterGatewayInstance$, DescribeBridge$, DescribeFlow$, DescribeFlowSourceMetadata$, DescribeFlowSourceThumbnail$, DescribeGateway$, DescribeGatewayInstance$, DescribeOffering$, DescribeReservation$, GetRouterInput$, GetRouterInputSourceMetadata$, GetRouterInputThumbnail$, GetRouterNetworkInterface$, GetRouterOutput$, GrantFlowEntitlements$, ListBridges$, ListEntitlements$, ListFlows$, ListGatewayInstances$, ListGateways$, ListOfferings$, ListReservations$, ListRouterInputs$, ListRouterNetworkInterfaces$, ListRouterOutputs$, ListTagsForGlobalResource$, ListTagsForResource$, PurchaseOffering$, RemoveBridgeOutput$, RemoveBridgeSource$, RemoveFlowMediaStream$, RemoveFlowOutput$, RemoveFlowSource$, RemoveFlowVpcInterface$, RestartRouterInput$, RestartRouterOutput$, RevokeFlowEntitlement$, StartFlow$, StartRouterInput$, StartRouterOutput$, StopFlow$, StopRouterInput$, StopRouterOutput$, TagGlobalResource$, TagResource$, TakeRouterInput$, UntagGlobalResource$, UntagResource$, UpdateBridge$, UpdateBridgeOutput$, UpdateBridgeSource$, UpdateBridgeState$, UpdateFlow$, UpdateFlowEntitlement$, UpdateFlowMediaStream$, UpdateFlowOutput$, UpdateFlowSource$, UpdateGatewayInstance$, UpdateRouterInput$, UpdateRouterNetworkInterface$, UpdateRouterOutput$ } = require("./schemas/schemas_0");
|
|
15
|
+
__exportStar(require("./schemas/schemas_0"), exports);
|
|
16
|
+
__exportStar(require("./models/errors"), exports);
|
|
17
|
+
const { MediaConnectServiceException } = require("./models/MediaConnectServiceException");
|
|
18
|
+
exports.MediaConnectServiceException = MediaConnectServiceException;
|
|
16
19
|
|
|
17
20
|
const resolveClientEndpointParameters = (options) => {
|
|
18
21
|
return Object.assign(options, {
|
|
@@ -68,1061 +71,1061 @@ const resolveHttpAuthRuntimeConfig = (config) => {
|
|
|
68
71
|
};
|
|
69
72
|
|
|
70
73
|
const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
|
|
71
|
-
const extensionConfiguration = Object.assign(
|
|
74
|
+
const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
|
|
72
75
|
extensions.forEach((extension) => extension.configure(extensionConfiguration));
|
|
73
|
-
return Object.assign(runtimeConfig,
|
|
76
|
+
return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
|
|
74
77
|
};
|
|
75
78
|
|
|
76
|
-
class MediaConnectClient extends
|
|
79
|
+
class MediaConnectClient extends Client {
|
|
77
80
|
config;
|
|
78
81
|
constructor(...[configuration]) {
|
|
79
|
-
const _config_0 =
|
|
82
|
+
const _config_0 = getRuntimeConfig(configuration || {});
|
|
80
83
|
super(_config_0);
|
|
81
84
|
this.initConfig = _config_0;
|
|
82
85
|
const _config_1 = resolveClientEndpointParameters(_config_0);
|
|
83
|
-
const _config_2 =
|
|
84
|
-
const _config_3 =
|
|
85
|
-
const _config_4 =
|
|
86
|
-
const _config_5 =
|
|
87
|
-
const _config_6 =
|
|
88
|
-
const _config_7 =
|
|
86
|
+
const _config_2 = resolveUserAgentConfig(_config_1);
|
|
87
|
+
const _config_3 = resolveRetryConfig(_config_2);
|
|
88
|
+
const _config_4 = resolveRegionConfig(_config_3);
|
|
89
|
+
const _config_5 = resolveHostHeaderConfig(_config_4);
|
|
90
|
+
const _config_6 = resolveEndpointConfig(_config_5);
|
|
91
|
+
const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
|
|
89
92
|
const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
|
|
90
93
|
this.config = _config_8;
|
|
91
|
-
this.middlewareStack.use(
|
|
92
|
-
this.middlewareStack.use(
|
|
93
|
-
this.middlewareStack.use(
|
|
94
|
-
this.middlewareStack.use(
|
|
95
|
-
this.middlewareStack.use(
|
|
96
|
-
this.middlewareStack.use(
|
|
97
|
-
this.middlewareStack.use(
|
|
98
|
-
this.middlewareStack.use(
|
|
99
|
-
httpAuthSchemeParametersProvider:
|
|
100
|
-
identityProviderConfigProvider: async (config) => new
|
|
94
|
+
this.middlewareStack.use(getSchemaSerdePlugin(this.config));
|
|
95
|
+
this.middlewareStack.use(getUserAgentPlugin(this.config));
|
|
96
|
+
this.middlewareStack.use(getRetryPlugin(this.config));
|
|
97
|
+
this.middlewareStack.use(getContentLengthPlugin(this.config));
|
|
98
|
+
this.middlewareStack.use(getHostHeaderPlugin(this.config));
|
|
99
|
+
this.middlewareStack.use(getLoggerPlugin(this.config));
|
|
100
|
+
this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
|
|
101
|
+
this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
|
|
102
|
+
httpAuthSchemeParametersProvider: defaultMediaConnectHttpAuthSchemeParametersProvider,
|
|
103
|
+
identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
|
|
101
104
|
"aws.auth#sigv4": config.credentials,
|
|
102
105
|
}),
|
|
103
106
|
}));
|
|
104
|
-
this.middlewareStack.use(
|
|
107
|
+
this.middlewareStack.use(getHttpSigningPlugin(this.config));
|
|
105
108
|
}
|
|
106
109
|
destroy() {
|
|
107
110
|
super.destroy();
|
|
108
111
|
}
|
|
109
112
|
}
|
|
110
113
|
|
|
111
|
-
class AddBridgeOutputsCommand extends
|
|
114
|
+
class AddBridgeOutputsCommand extends Command
|
|
112
115
|
.classBuilder()
|
|
113
116
|
.ep(commonParams)
|
|
114
117
|
.m(function (Command, cs, config, o) {
|
|
115
|
-
return [
|
|
118
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
116
119
|
})
|
|
117
120
|
.s("MediaConnect", "AddBridgeOutputs", {})
|
|
118
121
|
.n("MediaConnectClient", "AddBridgeOutputsCommand")
|
|
119
|
-
.sc(
|
|
122
|
+
.sc(AddBridgeOutputs$)
|
|
120
123
|
.build() {
|
|
121
124
|
}
|
|
122
125
|
|
|
123
|
-
class AddBridgeSourcesCommand extends
|
|
126
|
+
class AddBridgeSourcesCommand extends Command
|
|
124
127
|
.classBuilder()
|
|
125
128
|
.ep(commonParams)
|
|
126
129
|
.m(function (Command, cs, config, o) {
|
|
127
|
-
return [
|
|
130
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
128
131
|
})
|
|
129
132
|
.s("MediaConnect", "AddBridgeSources", {})
|
|
130
133
|
.n("MediaConnectClient", "AddBridgeSourcesCommand")
|
|
131
|
-
.sc(
|
|
134
|
+
.sc(AddBridgeSources$)
|
|
132
135
|
.build() {
|
|
133
136
|
}
|
|
134
137
|
|
|
135
|
-
class AddFlowMediaStreamsCommand extends
|
|
138
|
+
class AddFlowMediaStreamsCommand extends Command
|
|
136
139
|
.classBuilder()
|
|
137
140
|
.ep(commonParams)
|
|
138
141
|
.m(function (Command, cs, config, o) {
|
|
139
|
-
return [
|
|
142
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
140
143
|
})
|
|
141
144
|
.s("MediaConnect", "AddFlowMediaStreams", {})
|
|
142
145
|
.n("MediaConnectClient", "AddFlowMediaStreamsCommand")
|
|
143
|
-
.sc(
|
|
146
|
+
.sc(AddFlowMediaStreams$)
|
|
144
147
|
.build() {
|
|
145
148
|
}
|
|
146
149
|
|
|
147
|
-
class AddFlowOutputsCommand extends
|
|
150
|
+
class AddFlowOutputsCommand extends Command
|
|
148
151
|
.classBuilder()
|
|
149
152
|
.ep(commonParams)
|
|
150
153
|
.m(function (Command, cs, config, o) {
|
|
151
|
-
return [
|
|
154
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
152
155
|
})
|
|
153
156
|
.s("MediaConnect", "AddFlowOutputs", {})
|
|
154
157
|
.n("MediaConnectClient", "AddFlowOutputsCommand")
|
|
155
|
-
.sc(
|
|
158
|
+
.sc(AddFlowOutputs$)
|
|
156
159
|
.build() {
|
|
157
160
|
}
|
|
158
161
|
|
|
159
|
-
class AddFlowSourcesCommand extends
|
|
162
|
+
class AddFlowSourcesCommand extends Command
|
|
160
163
|
.classBuilder()
|
|
161
164
|
.ep(commonParams)
|
|
162
165
|
.m(function (Command, cs, config, o) {
|
|
163
|
-
return [
|
|
166
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
164
167
|
})
|
|
165
168
|
.s("MediaConnect", "AddFlowSources", {})
|
|
166
169
|
.n("MediaConnectClient", "AddFlowSourcesCommand")
|
|
167
|
-
.sc(
|
|
170
|
+
.sc(AddFlowSources$)
|
|
168
171
|
.build() {
|
|
169
172
|
}
|
|
170
173
|
|
|
171
|
-
class AddFlowVpcInterfacesCommand extends
|
|
174
|
+
class AddFlowVpcInterfacesCommand extends Command
|
|
172
175
|
.classBuilder()
|
|
173
176
|
.ep(commonParams)
|
|
174
177
|
.m(function (Command, cs, config, o) {
|
|
175
|
-
return [
|
|
178
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
176
179
|
})
|
|
177
180
|
.s("MediaConnect", "AddFlowVpcInterfaces", {})
|
|
178
181
|
.n("MediaConnectClient", "AddFlowVpcInterfacesCommand")
|
|
179
|
-
.sc(
|
|
182
|
+
.sc(AddFlowVpcInterfaces$)
|
|
180
183
|
.build() {
|
|
181
184
|
}
|
|
182
185
|
|
|
183
|
-
class BatchGetRouterInputCommand extends
|
|
186
|
+
class BatchGetRouterInputCommand extends Command
|
|
184
187
|
.classBuilder()
|
|
185
188
|
.ep(commonParams)
|
|
186
189
|
.m(function (Command, cs, config, o) {
|
|
187
|
-
return [
|
|
190
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
188
191
|
})
|
|
189
192
|
.s("MediaConnect", "BatchGetRouterInput", {})
|
|
190
193
|
.n("MediaConnectClient", "BatchGetRouterInputCommand")
|
|
191
|
-
.sc(
|
|
194
|
+
.sc(BatchGetRouterInput$)
|
|
192
195
|
.build() {
|
|
193
196
|
}
|
|
194
197
|
|
|
195
|
-
class BatchGetRouterNetworkInterfaceCommand extends
|
|
198
|
+
class BatchGetRouterNetworkInterfaceCommand extends Command
|
|
196
199
|
.classBuilder()
|
|
197
200
|
.ep(commonParams)
|
|
198
201
|
.m(function (Command, cs, config, o) {
|
|
199
|
-
return [
|
|
202
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
200
203
|
})
|
|
201
204
|
.s("MediaConnect", "BatchGetRouterNetworkInterface", {})
|
|
202
205
|
.n("MediaConnectClient", "BatchGetRouterNetworkInterfaceCommand")
|
|
203
|
-
.sc(
|
|
206
|
+
.sc(BatchGetRouterNetworkInterface$)
|
|
204
207
|
.build() {
|
|
205
208
|
}
|
|
206
209
|
|
|
207
|
-
class BatchGetRouterOutputCommand extends
|
|
210
|
+
class BatchGetRouterOutputCommand extends Command
|
|
208
211
|
.classBuilder()
|
|
209
212
|
.ep(commonParams)
|
|
210
213
|
.m(function (Command, cs, config, o) {
|
|
211
|
-
return [
|
|
214
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
212
215
|
})
|
|
213
216
|
.s("MediaConnect", "BatchGetRouterOutput", {})
|
|
214
217
|
.n("MediaConnectClient", "BatchGetRouterOutputCommand")
|
|
215
|
-
.sc(
|
|
218
|
+
.sc(BatchGetRouterOutput$)
|
|
216
219
|
.build() {
|
|
217
220
|
}
|
|
218
221
|
|
|
219
|
-
class CreateBridgeCommand extends
|
|
222
|
+
class CreateBridgeCommand extends Command
|
|
220
223
|
.classBuilder()
|
|
221
224
|
.ep(commonParams)
|
|
222
225
|
.m(function (Command, cs, config, o) {
|
|
223
|
-
return [
|
|
226
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
224
227
|
})
|
|
225
228
|
.s("MediaConnect", "CreateBridge", {})
|
|
226
229
|
.n("MediaConnectClient", "CreateBridgeCommand")
|
|
227
|
-
.sc(
|
|
230
|
+
.sc(CreateBridge$)
|
|
228
231
|
.build() {
|
|
229
232
|
}
|
|
230
233
|
|
|
231
|
-
class CreateFlowCommand extends
|
|
234
|
+
class CreateFlowCommand extends Command
|
|
232
235
|
.classBuilder()
|
|
233
236
|
.ep(commonParams)
|
|
234
237
|
.m(function (Command, cs, config, o) {
|
|
235
|
-
return [
|
|
238
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
236
239
|
})
|
|
237
240
|
.s("MediaConnect", "CreateFlow", {})
|
|
238
241
|
.n("MediaConnectClient", "CreateFlowCommand")
|
|
239
|
-
.sc(
|
|
242
|
+
.sc(CreateFlow$)
|
|
240
243
|
.build() {
|
|
241
244
|
}
|
|
242
245
|
|
|
243
|
-
class CreateGatewayCommand extends
|
|
246
|
+
class CreateGatewayCommand extends Command
|
|
244
247
|
.classBuilder()
|
|
245
248
|
.ep(commonParams)
|
|
246
249
|
.m(function (Command, cs, config, o) {
|
|
247
|
-
return [
|
|
250
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
248
251
|
})
|
|
249
252
|
.s("MediaConnect", "CreateGateway", {})
|
|
250
253
|
.n("MediaConnectClient", "CreateGatewayCommand")
|
|
251
|
-
.sc(
|
|
254
|
+
.sc(CreateGateway$)
|
|
252
255
|
.build() {
|
|
253
256
|
}
|
|
254
257
|
|
|
255
|
-
class CreateRouterInputCommand extends
|
|
258
|
+
class CreateRouterInputCommand extends Command
|
|
256
259
|
.classBuilder()
|
|
257
260
|
.ep(commonParams)
|
|
258
261
|
.m(function (Command, cs, config, o) {
|
|
259
|
-
return [
|
|
262
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
260
263
|
})
|
|
261
264
|
.s("MediaConnect", "CreateRouterInput", {})
|
|
262
265
|
.n("MediaConnectClient", "CreateRouterInputCommand")
|
|
263
|
-
.sc(
|
|
266
|
+
.sc(CreateRouterInput$)
|
|
264
267
|
.build() {
|
|
265
268
|
}
|
|
266
269
|
|
|
267
|
-
class CreateRouterNetworkInterfaceCommand extends
|
|
270
|
+
class CreateRouterNetworkInterfaceCommand extends Command
|
|
268
271
|
.classBuilder()
|
|
269
272
|
.ep(commonParams)
|
|
270
273
|
.m(function (Command, cs, config, o) {
|
|
271
|
-
return [
|
|
274
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
272
275
|
})
|
|
273
276
|
.s("MediaConnect", "CreateRouterNetworkInterface", {})
|
|
274
277
|
.n("MediaConnectClient", "CreateRouterNetworkInterfaceCommand")
|
|
275
|
-
.sc(
|
|
278
|
+
.sc(CreateRouterNetworkInterface$)
|
|
276
279
|
.build() {
|
|
277
280
|
}
|
|
278
281
|
|
|
279
|
-
class CreateRouterOutputCommand extends
|
|
282
|
+
class CreateRouterOutputCommand extends Command
|
|
280
283
|
.classBuilder()
|
|
281
284
|
.ep(commonParams)
|
|
282
285
|
.m(function (Command, cs, config, o) {
|
|
283
|
-
return [
|
|
286
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
284
287
|
})
|
|
285
288
|
.s("MediaConnect", "CreateRouterOutput", {})
|
|
286
289
|
.n("MediaConnectClient", "CreateRouterOutputCommand")
|
|
287
|
-
.sc(
|
|
290
|
+
.sc(CreateRouterOutput$)
|
|
288
291
|
.build() {
|
|
289
292
|
}
|
|
290
293
|
|
|
291
|
-
class DeleteBridgeCommand extends
|
|
294
|
+
class DeleteBridgeCommand extends Command
|
|
292
295
|
.classBuilder()
|
|
293
296
|
.ep(commonParams)
|
|
294
297
|
.m(function (Command, cs, config, o) {
|
|
295
|
-
return [
|
|
298
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
296
299
|
})
|
|
297
300
|
.s("MediaConnect", "DeleteBridge", {})
|
|
298
301
|
.n("MediaConnectClient", "DeleteBridgeCommand")
|
|
299
|
-
.sc(
|
|
302
|
+
.sc(DeleteBridge$)
|
|
300
303
|
.build() {
|
|
301
304
|
}
|
|
302
305
|
|
|
303
|
-
class DeleteFlowCommand extends
|
|
306
|
+
class DeleteFlowCommand extends Command
|
|
304
307
|
.classBuilder()
|
|
305
308
|
.ep(commonParams)
|
|
306
309
|
.m(function (Command, cs, config, o) {
|
|
307
|
-
return [
|
|
310
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
308
311
|
})
|
|
309
312
|
.s("MediaConnect", "DeleteFlow", {})
|
|
310
313
|
.n("MediaConnectClient", "DeleteFlowCommand")
|
|
311
|
-
.sc(
|
|
314
|
+
.sc(DeleteFlow$)
|
|
312
315
|
.build() {
|
|
313
316
|
}
|
|
314
317
|
|
|
315
|
-
class DeleteGatewayCommand extends
|
|
318
|
+
class DeleteGatewayCommand extends Command
|
|
316
319
|
.classBuilder()
|
|
317
320
|
.ep(commonParams)
|
|
318
321
|
.m(function (Command, cs, config, o) {
|
|
319
|
-
return [
|
|
322
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
320
323
|
})
|
|
321
324
|
.s("MediaConnect", "DeleteGateway", {})
|
|
322
325
|
.n("MediaConnectClient", "DeleteGatewayCommand")
|
|
323
|
-
.sc(
|
|
326
|
+
.sc(DeleteGateway$)
|
|
324
327
|
.build() {
|
|
325
328
|
}
|
|
326
329
|
|
|
327
|
-
class DeleteRouterInputCommand extends
|
|
330
|
+
class DeleteRouterInputCommand extends Command
|
|
328
331
|
.classBuilder()
|
|
329
332
|
.ep(commonParams)
|
|
330
333
|
.m(function (Command, cs, config, o) {
|
|
331
|
-
return [
|
|
334
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
332
335
|
})
|
|
333
336
|
.s("MediaConnect", "DeleteRouterInput", {})
|
|
334
337
|
.n("MediaConnectClient", "DeleteRouterInputCommand")
|
|
335
|
-
.sc(
|
|
338
|
+
.sc(DeleteRouterInput$)
|
|
336
339
|
.build() {
|
|
337
340
|
}
|
|
338
341
|
|
|
339
|
-
class DeleteRouterNetworkInterfaceCommand extends
|
|
342
|
+
class DeleteRouterNetworkInterfaceCommand extends Command
|
|
340
343
|
.classBuilder()
|
|
341
344
|
.ep(commonParams)
|
|
342
345
|
.m(function (Command, cs, config, o) {
|
|
343
|
-
return [
|
|
346
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
344
347
|
})
|
|
345
348
|
.s("MediaConnect", "DeleteRouterNetworkInterface", {})
|
|
346
349
|
.n("MediaConnectClient", "DeleteRouterNetworkInterfaceCommand")
|
|
347
|
-
.sc(
|
|
350
|
+
.sc(DeleteRouterNetworkInterface$)
|
|
348
351
|
.build() {
|
|
349
352
|
}
|
|
350
353
|
|
|
351
|
-
class DeleteRouterOutputCommand extends
|
|
354
|
+
class DeleteRouterOutputCommand extends Command
|
|
352
355
|
.classBuilder()
|
|
353
356
|
.ep(commonParams)
|
|
354
357
|
.m(function (Command, cs, config, o) {
|
|
355
|
-
return [
|
|
358
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
356
359
|
})
|
|
357
360
|
.s("MediaConnect", "DeleteRouterOutput", {})
|
|
358
361
|
.n("MediaConnectClient", "DeleteRouterOutputCommand")
|
|
359
|
-
.sc(
|
|
362
|
+
.sc(DeleteRouterOutput$)
|
|
360
363
|
.build() {
|
|
361
364
|
}
|
|
362
365
|
|
|
363
|
-
class DeregisterGatewayInstanceCommand extends
|
|
366
|
+
class DeregisterGatewayInstanceCommand extends Command
|
|
364
367
|
.classBuilder()
|
|
365
368
|
.ep(commonParams)
|
|
366
369
|
.m(function (Command, cs, config, o) {
|
|
367
|
-
return [
|
|
370
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
368
371
|
})
|
|
369
372
|
.s("MediaConnect", "DeregisterGatewayInstance", {})
|
|
370
373
|
.n("MediaConnectClient", "DeregisterGatewayInstanceCommand")
|
|
371
|
-
.sc(
|
|
374
|
+
.sc(DeregisterGatewayInstance$)
|
|
372
375
|
.build() {
|
|
373
376
|
}
|
|
374
377
|
|
|
375
|
-
class DescribeBridgeCommand extends
|
|
378
|
+
class DescribeBridgeCommand extends Command
|
|
376
379
|
.classBuilder()
|
|
377
380
|
.ep(commonParams)
|
|
378
381
|
.m(function (Command, cs, config, o) {
|
|
379
|
-
return [
|
|
382
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
380
383
|
})
|
|
381
384
|
.s("MediaConnect", "DescribeBridge", {})
|
|
382
385
|
.n("MediaConnectClient", "DescribeBridgeCommand")
|
|
383
|
-
.sc(
|
|
386
|
+
.sc(DescribeBridge$)
|
|
384
387
|
.build() {
|
|
385
388
|
}
|
|
386
389
|
|
|
387
|
-
class DescribeFlowCommand extends
|
|
390
|
+
class DescribeFlowCommand extends Command
|
|
388
391
|
.classBuilder()
|
|
389
392
|
.ep(commonParams)
|
|
390
393
|
.m(function (Command, cs, config, o) {
|
|
391
|
-
return [
|
|
394
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
392
395
|
})
|
|
393
396
|
.s("MediaConnect", "DescribeFlow", {})
|
|
394
397
|
.n("MediaConnectClient", "DescribeFlowCommand")
|
|
395
|
-
.sc(
|
|
398
|
+
.sc(DescribeFlow$)
|
|
396
399
|
.build() {
|
|
397
400
|
}
|
|
398
401
|
|
|
399
|
-
class DescribeFlowSourceMetadataCommand extends
|
|
402
|
+
class DescribeFlowSourceMetadataCommand extends Command
|
|
400
403
|
.classBuilder()
|
|
401
404
|
.ep(commonParams)
|
|
402
405
|
.m(function (Command, cs, config, o) {
|
|
403
|
-
return [
|
|
406
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
404
407
|
})
|
|
405
408
|
.s("MediaConnect", "DescribeFlowSourceMetadata", {})
|
|
406
409
|
.n("MediaConnectClient", "DescribeFlowSourceMetadataCommand")
|
|
407
|
-
.sc(
|
|
410
|
+
.sc(DescribeFlowSourceMetadata$)
|
|
408
411
|
.build() {
|
|
409
412
|
}
|
|
410
413
|
|
|
411
|
-
class DescribeFlowSourceThumbnailCommand extends
|
|
414
|
+
class DescribeFlowSourceThumbnailCommand extends Command
|
|
412
415
|
.classBuilder()
|
|
413
416
|
.ep(commonParams)
|
|
414
417
|
.m(function (Command, cs, config, o) {
|
|
415
|
-
return [
|
|
418
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
416
419
|
})
|
|
417
420
|
.s("MediaConnect", "DescribeFlowSourceThumbnail", {})
|
|
418
421
|
.n("MediaConnectClient", "DescribeFlowSourceThumbnailCommand")
|
|
419
|
-
.sc(
|
|
422
|
+
.sc(DescribeFlowSourceThumbnail$)
|
|
420
423
|
.build() {
|
|
421
424
|
}
|
|
422
425
|
|
|
423
|
-
class DescribeGatewayCommand extends
|
|
426
|
+
class DescribeGatewayCommand extends Command
|
|
424
427
|
.classBuilder()
|
|
425
428
|
.ep(commonParams)
|
|
426
429
|
.m(function (Command, cs, config, o) {
|
|
427
|
-
return [
|
|
430
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
428
431
|
})
|
|
429
432
|
.s("MediaConnect", "DescribeGateway", {})
|
|
430
433
|
.n("MediaConnectClient", "DescribeGatewayCommand")
|
|
431
|
-
.sc(
|
|
434
|
+
.sc(DescribeGateway$)
|
|
432
435
|
.build() {
|
|
433
436
|
}
|
|
434
437
|
|
|
435
|
-
class DescribeGatewayInstanceCommand extends
|
|
438
|
+
class DescribeGatewayInstanceCommand extends Command
|
|
436
439
|
.classBuilder()
|
|
437
440
|
.ep(commonParams)
|
|
438
441
|
.m(function (Command, cs, config, o) {
|
|
439
|
-
return [
|
|
442
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
440
443
|
})
|
|
441
444
|
.s("MediaConnect", "DescribeGatewayInstance", {})
|
|
442
445
|
.n("MediaConnectClient", "DescribeGatewayInstanceCommand")
|
|
443
|
-
.sc(
|
|
446
|
+
.sc(DescribeGatewayInstance$)
|
|
444
447
|
.build() {
|
|
445
448
|
}
|
|
446
449
|
|
|
447
|
-
class DescribeOfferingCommand extends
|
|
450
|
+
class DescribeOfferingCommand extends Command
|
|
448
451
|
.classBuilder()
|
|
449
452
|
.ep(commonParams)
|
|
450
453
|
.m(function (Command, cs, config, o) {
|
|
451
|
-
return [
|
|
454
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
452
455
|
})
|
|
453
456
|
.s("MediaConnect", "DescribeOffering", {})
|
|
454
457
|
.n("MediaConnectClient", "DescribeOfferingCommand")
|
|
455
|
-
.sc(
|
|
458
|
+
.sc(DescribeOffering$)
|
|
456
459
|
.build() {
|
|
457
460
|
}
|
|
458
461
|
|
|
459
|
-
class DescribeReservationCommand extends
|
|
462
|
+
class DescribeReservationCommand extends Command
|
|
460
463
|
.classBuilder()
|
|
461
464
|
.ep(commonParams)
|
|
462
465
|
.m(function (Command, cs, config, o) {
|
|
463
|
-
return [
|
|
466
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
464
467
|
})
|
|
465
468
|
.s("MediaConnect", "DescribeReservation", {})
|
|
466
469
|
.n("MediaConnectClient", "DescribeReservationCommand")
|
|
467
|
-
.sc(
|
|
470
|
+
.sc(DescribeReservation$)
|
|
468
471
|
.build() {
|
|
469
472
|
}
|
|
470
473
|
|
|
471
|
-
class GetRouterInputCommand extends
|
|
474
|
+
class GetRouterInputCommand extends Command
|
|
472
475
|
.classBuilder()
|
|
473
476
|
.ep(commonParams)
|
|
474
477
|
.m(function (Command, cs, config, o) {
|
|
475
|
-
return [
|
|
478
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
476
479
|
})
|
|
477
480
|
.s("MediaConnect", "GetRouterInput", {})
|
|
478
481
|
.n("MediaConnectClient", "GetRouterInputCommand")
|
|
479
|
-
.sc(
|
|
482
|
+
.sc(GetRouterInput$)
|
|
480
483
|
.build() {
|
|
481
484
|
}
|
|
482
485
|
|
|
483
|
-
class GetRouterInputSourceMetadataCommand extends
|
|
486
|
+
class GetRouterInputSourceMetadataCommand extends Command
|
|
484
487
|
.classBuilder()
|
|
485
488
|
.ep(commonParams)
|
|
486
489
|
.m(function (Command, cs, config, o) {
|
|
487
|
-
return [
|
|
490
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
488
491
|
})
|
|
489
492
|
.s("MediaConnect", "GetRouterInputSourceMetadata", {})
|
|
490
493
|
.n("MediaConnectClient", "GetRouterInputSourceMetadataCommand")
|
|
491
|
-
.sc(
|
|
494
|
+
.sc(GetRouterInputSourceMetadata$)
|
|
492
495
|
.build() {
|
|
493
496
|
}
|
|
494
497
|
|
|
495
|
-
class GetRouterInputThumbnailCommand extends
|
|
498
|
+
class GetRouterInputThumbnailCommand extends Command
|
|
496
499
|
.classBuilder()
|
|
497
500
|
.ep(commonParams)
|
|
498
501
|
.m(function (Command, cs, config, o) {
|
|
499
|
-
return [
|
|
502
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
500
503
|
})
|
|
501
504
|
.s("MediaConnect", "GetRouterInputThumbnail", {})
|
|
502
505
|
.n("MediaConnectClient", "GetRouterInputThumbnailCommand")
|
|
503
|
-
.sc(
|
|
506
|
+
.sc(GetRouterInputThumbnail$)
|
|
504
507
|
.build() {
|
|
505
508
|
}
|
|
506
509
|
|
|
507
|
-
class GetRouterNetworkInterfaceCommand extends
|
|
510
|
+
class GetRouterNetworkInterfaceCommand extends Command
|
|
508
511
|
.classBuilder()
|
|
509
512
|
.ep(commonParams)
|
|
510
513
|
.m(function (Command, cs, config, o) {
|
|
511
|
-
return [
|
|
514
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
512
515
|
})
|
|
513
516
|
.s("MediaConnect", "GetRouterNetworkInterface", {})
|
|
514
517
|
.n("MediaConnectClient", "GetRouterNetworkInterfaceCommand")
|
|
515
|
-
.sc(
|
|
518
|
+
.sc(GetRouterNetworkInterface$)
|
|
516
519
|
.build() {
|
|
517
520
|
}
|
|
518
521
|
|
|
519
|
-
class GetRouterOutputCommand extends
|
|
522
|
+
class GetRouterOutputCommand extends Command
|
|
520
523
|
.classBuilder()
|
|
521
524
|
.ep(commonParams)
|
|
522
525
|
.m(function (Command, cs, config, o) {
|
|
523
|
-
return [
|
|
526
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
524
527
|
})
|
|
525
528
|
.s("MediaConnect", "GetRouterOutput", {})
|
|
526
529
|
.n("MediaConnectClient", "GetRouterOutputCommand")
|
|
527
|
-
.sc(
|
|
530
|
+
.sc(GetRouterOutput$)
|
|
528
531
|
.build() {
|
|
529
532
|
}
|
|
530
533
|
|
|
531
|
-
class GrantFlowEntitlementsCommand extends
|
|
534
|
+
class GrantFlowEntitlementsCommand extends Command
|
|
532
535
|
.classBuilder()
|
|
533
536
|
.ep(commonParams)
|
|
534
537
|
.m(function (Command, cs, config, o) {
|
|
535
|
-
return [
|
|
538
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
536
539
|
})
|
|
537
540
|
.s("MediaConnect", "GrantFlowEntitlements", {})
|
|
538
541
|
.n("MediaConnectClient", "GrantFlowEntitlementsCommand")
|
|
539
|
-
.sc(
|
|
542
|
+
.sc(GrantFlowEntitlements$)
|
|
540
543
|
.build() {
|
|
541
544
|
}
|
|
542
545
|
|
|
543
|
-
class ListBridgesCommand extends
|
|
546
|
+
class ListBridgesCommand extends Command
|
|
544
547
|
.classBuilder()
|
|
545
548
|
.ep(commonParams)
|
|
546
549
|
.m(function (Command, cs, config, o) {
|
|
547
|
-
return [
|
|
550
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
548
551
|
})
|
|
549
552
|
.s("MediaConnect", "ListBridges", {})
|
|
550
553
|
.n("MediaConnectClient", "ListBridgesCommand")
|
|
551
|
-
.sc(
|
|
554
|
+
.sc(ListBridges$)
|
|
552
555
|
.build() {
|
|
553
556
|
}
|
|
554
557
|
|
|
555
|
-
class ListEntitlementsCommand extends
|
|
558
|
+
class ListEntitlementsCommand extends Command
|
|
556
559
|
.classBuilder()
|
|
557
560
|
.ep(commonParams)
|
|
558
561
|
.m(function (Command, cs, config, o) {
|
|
559
|
-
return [
|
|
562
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
560
563
|
})
|
|
561
564
|
.s("MediaConnect", "ListEntitlements", {})
|
|
562
565
|
.n("MediaConnectClient", "ListEntitlementsCommand")
|
|
563
|
-
.sc(
|
|
566
|
+
.sc(ListEntitlements$)
|
|
564
567
|
.build() {
|
|
565
568
|
}
|
|
566
569
|
|
|
567
|
-
class ListFlowsCommand extends
|
|
570
|
+
class ListFlowsCommand extends Command
|
|
568
571
|
.classBuilder()
|
|
569
572
|
.ep(commonParams)
|
|
570
573
|
.m(function (Command, cs, config, o) {
|
|
571
|
-
return [
|
|
574
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
572
575
|
})
|
|
573
576
|
.s("MediaConnect", "ListFlows", {})
|
|
574
577
|
.n("MediaConnectClient", "ListFlowsCommand")
|
|
575
|
-
.sc(
|
|
578
|
+
.sc(ListFlows$)
|
|
576
579
|
.build() {
|
|
577
580
|
}
|
|
578
581
|
|
|
579
|
-
class ListGatewayInstancesCommand extends
|
|
582
|
+
class ListGatewayInstancesCommand extends Command
|
|
580
583
|
.classBuilder()
|
|
581
584
|
.ep(commonParams)
|
|
582
585
|
.m(function (Command, cs, config, o) {
|
|
583
|
-
return [
|
|
586
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
584
587
|
})
|
|
585
588
|
.s("MediaConnect", "ListGatewayInstances", {})
|
|
586
589
|
.n("MediaConnectClient", "ListGatewayInstancesCommand")
|
|
587
|
-
.sc(
|
|
590
|
+
.sc(ListGatewayInstances$)
|
|
588
591
|
.build() {
|
|
589
592
|
}
|
|
590
593
|
|
|
591
|
-
class ListGatewaysCommand extends
|
|
594
|
+
class ListGatewaysCommand extends Command
|
|
592
595
|
.classBuilder()
|
|
593
596
|
.ep(commonParams)
|
|
594
597
|
.m(function (Command, cs, config, o) {
|
|
595
|
-
return [
|
|
598
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
596
599
|
})
|
|
597
600
|
.s("MediaConnect", "ListGateways", {})
|
|
598
601
|
.n("MediaConnectClient", "ListGatewaysCommand")
|
|
599
|
-
.sc(
|
|
602
|
+
.sc(ListGateways$)
|
|
600
603
|
.build() {
|
|
601
604
|
}
|
|
602
605
|
|
|
603
|
-
class ListOfferingsCommand extends
|
|
606
|
+
class ListOfferingsCommand extends Command
|
|
604
607
|
.classBuilder()
|
|
605
608
|
.ep(commonParams)
|
|
606
609
|
.m(function (Command, cs, config, o) {
|
|
607
|
-
return [
|
|
610
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
608
611
|
})
|
|
609
612
|
.s("MediaConnect", "ListOfferings", {})
|
|
610
613
|
.n("MediaConnectClient", "ListOfferingsCommand")
|
|
611
|
-
.sc(
|
|
614
|
+
.sc(ListOfferings$)
|
|
612
615
|
.build() {
|
|
613
616
|
}
|
|
614
617
|
|
|
615
|
-
class ListReservationsCommand extends
|
|
618
|
+
class ListReservationsCommand extends Command
|
|
616
619
|
.classBuilder()
|
|
617
620
|
.ep(commonParams)
|
|
618
621
|
.m(function (Command, cs, config, o) {
|
|
619
|
-
return [
|
|
622
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
620
623
|
})
|
|
621
624
|
.s("MediaConnect", "ListReservations", {})
|
|
622
625
|
.n("MediaConnectClient", "ListReservationsCommand")
|
|
623
|
-
.sc(
|
|
626
|
+
.sc(ListReservations$)
|
|
624
627
|
.build() {
|
|
625
628
|
}
|
|
626
629
|
|
|
627
|
-
class ListRouterInputsCommand extends
|
|
630
|
+
class ListRouterInputsCommand extends Command
|
|
628
631
|
.classBuilder()
|
|
629
632
|
.ep(commonParams)
|
|
630
633
|
.m(function (Command, cs, config, o) {
|
|
631
|
-
return [
|
|
634
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
632
635
|
})
|
|
633
636
|
.s("MediaConnect", "ListRouterInputs", {})
|
|
634
637
|
.n("MediaConnectClient", "ListRouterInputsCommand")
|
|
635
|
-
.sc(
|
|
638
|
+
.sc(ListRouterInputs$)
|
|
636
639
|
.build() {
|
|
637
640
|
}
|
|
638
641
|
|
|
639
|
-
class ListRouterNetworkInterfacesCommand extends
|
|
642
|
+
class ListRouterNetworkInterfacesCommand extends Command
|
|
640
643
|
.classBuilder()
|
|
641
644
|
.ep(commonParams)
|
|
642
645
|
.m(function (Command, cs, config, o) {
|
|
643
|
-
return [
|
|
646
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
644
647
|
})
|
|
645
648
|
.s("MediaConnect", "ListRouterNetworkInterfaces", {})
|
|
646
649
|
.n("MediaConnectClient", "ListRouterNetworkInterfacesCommand")
|
|
647
|
-
.sc(
|
|
650
|
+
.sc(ListRouterNetworkInterfaces$)
|
|
648
651
|
.build() {
|
|
649
652
|
}
|
|
650
653
|
|
|
651
|
-
class ListRouterOutputsCommand extends
|
|
654
|
+
class ListRouterOutputsCommand extends Command
|
|
652
655
|
.classBuilder()
|
|
653
656
|
.ep(commonParams)
|
|
654
657
|
.m(function (Command, cs, config, o) {
|
|
655
|
-
return [
|
|
658
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
656
659
|
})
|
|
657
660
|
.s("MediaConnect", "ListRouterOutputs", {})
|
|
658
661
|
.n("MediaConnectClient", "ListRouterOutputsCommand")
|
|
659
|
-
.sc(
|
|
662
|
+
.sc(ListRouterOutputs$)
|
|
660
663
|
.build() {
|
|
661
664
|
}
|
|
662
665
|
|
|
663
|
-
class ListTagsForGlobalResourceCommand extends
|
|
666
|
+
class ListTagsForGlobalResourceCommand extends Command
|
|
664
667
|
.classBuilder()
|
|
665
668
|
.ep(commonParams)
|
|
666
669
|
.m(function (Command, cs, config, o) {
|
|
667
|
-
return [
|
|
670
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
668
671
|
})
|
|
669
672
|
.s("MediaConnect", "ListTagsForGlobalResource", {})
|
|
670
673
|
.n("MediaConnectClient", "ListTagsForGlobalResourceCommand")
|
|
671
|
-
.sc(
|
|
674
|
+
.sc(ListTagsForGlobalResource$)
|
|
672
675
|
.build() {
|
|
673
676
|
}
|
|
674
677
|
|
|
675
|
-
class ListTagsForResourceCommand extends
|
|
678
|
+
class ListTagsForResourceCommand extends Command
|
|
676
679
|
.classBuilder()
|
|
677
680
|
.ep(commonParams)
|
|
678
681
|
.m(function (Command, cs, config, o) {
|
|
679
|
-
return [
|
|
682
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
680
683
|
})
|
|
681
684
|
.s("MediaConnect", "ListTagsForResource", {})
|
|
682
685
|
.n("MediaConnectClient", "ListTagsForResourceCommand")
|
|
683
|
-
.sc(
|
|
686
|
+
.sc(ListTagsForResource$)
|
|
684
687
|
.build() {
|
|
685
688
|
}
|
|
686
689
|
|
|
687
|
-
class PurchaseOfferingCommand extends
|
|
690
|
+
class PurchaseOfferingCommand extends Command
|
|
688
691
|
.classBuilder()
|
|
689
692
|
.ep(commonParams)
|
|
690
693
|
.m(function (Command, cs, config, o) {
|
|
691
|
-
return [
|
|
694
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
692
695
|
})
|
|
693
696
|
.s("MediaConnect", "PurchaseOffering", {})
|
|
694
697
|
.n("MediaConnectClient", "PurchaseOfferingCommand")
|
|
695
|
-
.sc(
|
|
698
|
+
.sc(PurchaseOffering$)
|
|
696
699
|
.build() {
|
|
697
700
|
}
|
|
698
701
|
|
|
699
|
-
class RemoveBridgeOutputCommand extends
|
|
702
|
+
class RemoveBridgeOutputCommand extends Command
|
|
700
703
|
.classBuilder()
|
|
701
704
|
.ep(commonParams)
|
|
702
705
|
.m(function (Command, cs, config, o) {
|
|
703
|
-
return [
|
|
706
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
704
707
|
})
|
|
705
708
|
.s("MediaConnect", "RemoveBridgeOutput", {})
|
|
706
709
|
.n("MediaConnectClient", "RemoveBridgeOutputCommand")
|
|
707
|
-
.sc(
|
|
710
|
+
.sc(RemoveBridgeOutput$)
|
|
708
711
|
.build() {
|
|
709
712
|
}
|
|
710
713
|
|
|
711
|
-
class RemoveBridgeSourceCommand extends
|
|
714
|
+
class RemoveBridgeSourceCommand extends Command
|
|
712
715
|
.classBuilder()
|
|
713
716
|
.ep(commonParams)
|
|
714
717
|
.m(function (Command, cs, config, o) {
|
|
715
|
-
return [
|
|
718
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
716
719
|
})
|
|
717
720
|
.s("MediaConnect", "RemoveBridgeSource", {})
|
|
718
721
|
.n("MediaConnectClient", "RemoveBridgeSourceCommand")
|
|
719
|
-
.sc(
|
|
722
|
+
.sc(RemoveBridgeSource$)
|
|
720
723
|
.build() {
|
|
721
724
|
}
|
|
722
725
|
|
|
723
|
-
class RemoveFlowMediaStreamCommand extends
|
|
726
|
+
class RemoveFlowMediaStreamCommand extends Command
|
|
724
727
|
.classBuilder()
|
|
725
728
|
.ep(commonParams)
|
|
726
729
|
.m(function (Command, cs, config, o) {
|
|
727
|
-
return [
|
|
730
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
728
731
|
})
|
|
729
732
|
.s("MediaConnect", "RemoveFlowMediaStream", {})
|
|
730
733
|
.n("MediaConnectClient", "RemoveFlowMediaStreamCommand")
|
|
731
|
-
.sc(
|
|
734
|
+
.sc(RemoveFlowMediaStream$)
|
|
732
735
|
.build() {
|
|
733
736
|
}
|
|
734
737
|
|
|
735
|
-
class RemoveFlowOutputCommand extends
|
|
738
|
+
class RemoveFlowOutputCommand extends Command
|
|
736
739
|
.classBuilder()
|
|
737
740
|
.ep(commonParams)
|
|
738
741
|
.m(function (Command, cs, config, o) {
|
|
739
|
-
return [
|
|
742
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
740
743
|
})
|
|
741
744
|
.s("MediaConnect", "RemoveFlowOutput", {})
|
|
742
745
|
.n("MediaConnectClient", "RemoveFlowOutputCommand")
|
|
743
|
-
.sc(
|
|
746
|
+
.sc(RemoveFlowOutput$)
|
|
744
747
|
.build() {
|
|
745
748
|
}
|
|
746
749
|
|
|
747
|
-
class RemoveFlowSourceCommand extends
|
|
750
|
+
class RemoveFlowSourceCommand extends Command
|
|
748
751
|
.classBuilder()
|
|
749
752
|
.ep(commonParams)
|
|
750
753
|
.m(function (Command, cs, config, o) {
|
|
751
|
-
return [
|
|
754
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
752
755
|
})
|
|
753
756
|
.s("MediaConnect", "RemoveFlowSource", {})
|
|
754
757
|
.n("MediaConnectClient", "RemoveFlowSourceCommand")
|
|
755
|
-
.sc(
|
|
758
|
+
.sc(RemoveFlowSource$)
|
|
756
759
|
.build() {
|
|
757
760
|
}
|
|
758
761
|
|
|
759
|
-
class RemoveFlowVpcInterfaceCommand extends
|
|
762
|
+
class RemoveFlowVpcInterfaceCommand extends Command
|
|
760
763
|
.classBuilder()
|
|
761
764
|
.ep(commonParams)
|
|
762
765
|
.m(function (Command, cs, config, o) {
|
|
763
|
-
return [
|
|
766
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
764
767
|
})
|
|
765
768
|
.s("MediaConnect", "RemoveFlowVpcInterface", {})
|
|
766
769
|
.n("MediaConnectClient", "RemoveFlowVpcInterfaceCommand")
|
|
767
|
-
.sc(
|
|
770
|
+
.sc(RemoveFlowVpcInterface$)
|
|
768
771
|
.build() {
|
|
769
772
|
}
|
|
770
773
|
|
|
771
|
-
class RestartRouterInputCommand extends
|
|
774
|
+
class RestartRouterInputCommand extends Command
|
|
772
775
|
.classBuilder()
|
|
773
776
|
.ep(commonParams)
|
|
774
777
|
.m(function (Command, cs, config, o) {
|
|
775
|
-
return [
|
|
778
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
776
779
|
})
|
|
777
780
|
.s("MediaConnect", "RestartRouterInput", {})
|
|
778
781
|
.n("MediaConnectClient", "RestartRouterInputCommand")
|
|
779
|
-
.sc(
|
|
782
|
+
.sc(RestartRouterInput$)
|
|
780
783
|
.build() {
|
|
781
784
|
}
|
|
782
785
|
|
|
783
|
-
class RestartRouterOutputCommand extends
|
|
786
|
+
class RestartRouterOutputCommand extends Command
|
|
784
787
|
.classBuilder()
|
|
785
788
|
.ep(commonParams)
|
|
786
789
|
.m(function (Command, cs, config, o) {
|
|
787
|
-
return [
|
|
790
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
788
791
|
})
|
|
789
792
|
.s("MediaConnect", "RestartRouterOutput", {})
|
|
790
793
|
.n("MediaConnectClient", "RestartRouterOutputCommand")
|
|
791
|
-
.sc(
|
|
794
|
+
.sc(RestartRouterOutput$)
|
|
792
795
|
.build() {
|
|
793
796
|
}
|
|
794
797
|
|
|
795
|
-
class RevokeFlowEntitlementCommand extends
|
|
798
|
+
class RevokeFlowEntitlementCommand extends Command
|
|
796
799
|
.classBuilder()
|
|
797
800
|
.ep(commonParams)
|
|
798
801
|
.m(function (Command, cs, config, o) {
|
|
799
|
-
return [
|
|
802
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
800
803
|
})
|
|
801
804
|
.s("MediaConnect", "RevokeFlowEntitlement", {})
|
|
802
805
|
.n("MediaConnectClient", "RevokeFlowEntitlementCommand")
|
|
803
|
-
.sc(
|
|
806
|
+
.sc(RevokeFlowEntitlement$)
|
|
804
807
|
.build() {
|
|
805
808
|
}
|
|
806
809
|
|
|
807
|
-
class StartFlowCommand extends
|
|
810
|
+
class StartFlowCommand extends Command
|
|
808
811
|
.classBuilder()
|
|
809
812
|
.ep(commonParams)
|
|
810
813
|
.m(function (Command, cs, config, o) {
|
|
811
|
-
return [
|
|
814
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
812
815
|
})
|
|
813
816
|
.s("MediaConnect", "StartFlow", {})
|
|
814
817
|
.n("MediaConnectClient", "StartFlowCommand")
|
|
815
|
-
.sc(
|
|
818
|
+
.sc(StartFlow$)
|
|
816
819
|
.build() {
|
|
817
820
|
}
|
|
818
821
|
|
|
819
|
-
class StartRouterInputCommand extends
|
|
822
|
+
class StartRouterInputCommand extends Command
|
|
820
823
|
.classBuilder()
|
|
821
824
|
.ep(commonParams)
|
|
822
825
|
.m(function (Command, cs, config, o) {
|
|
823
|
-
return [
|
|
826
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
824
827
|
})
|
|
825
828
|
.s("MediaConnect", "StartRouterInput", {})
|
|
826
829
|
.n("MediaConnectClient", "StartRouterInputCommand")
|
|
827
|
-
.sc(
|
|
830
|
+
.sc(StartRouterInput$)
|
|
828
831
|
.build() {
|
|
829
832
|
}
|
|
830
833
|
|
|
831
|
-
class StartRouterOutputCommand extends
|
|
834
|
+
class StartRouterOutputCommand extends Command
|
|
832
835
|
.classBuilder()
|
|
833
836
|
.ep(commonParams)
|
|
834
837
|
.m(function (Command, cs, config, o) {
|
|
835
|
-
return [
|
|
838
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
836
839
|
})
|
|
837
840
|
.s("MediaConnect", "StartRouterOutput", {})
|
|
838
841
|
.n("MediaConnectClient", "StartRouterOutputCommand")
|
|
839
|
-
.sc(
|
|
842
|
+
.sc(StartRouterOutput$)
|
|
840
843
|
.build() {
|
|
841
844
|
}
|
|
842
845
|
|
|
843
|
-
class StopFlowCommand extends
|
|
846
|
+
class StopFlowCommand extends Command
|
|
844
847
|
.classBuilder()
|
|
845
848
|
.ep(commonParams)
|
|
846
849
|
.m(function (Command, cs, config, o) {
|
|
847
|
-
return [
|
|
850
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
848
851
|
})
|
|
849
852
|
.s("MediaConnect", "StopFlow", {})
|
|
850
853
|
.n("MediaConnectClient", "StopFlowCommand")
|
|
851
|
-
.sc(
|
|
854
|
+
.sc(StopFlow$)
|
|
852
855
|
.build() {
|
|
853
856
|
}
|
|
854
857
|
|
|
855
|
-
class StopRouterInputCommand extends
|
|
858
|
+
class StopRouterInputCommand extends Command
|
|
856
859
|
.classBuilder()
|
|
857
860
|
.ep(commonParams)
|
|
858
861
|
.m(function (Command, cs, config, o) {
|
|
859
|
-
return [
|
|
862
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
860
863
|
})
|
|
861
864
|
.s("MediaConnect", "StopRouterInput", {})
|
|
862
865
|
.n("MediaConnectClient", "StopRouterInputCommand")
|
|
863
|
-
.sc(
|
|
866
|
+
.sc(StopRouterInput$)
|
|
864
867
|
.build() {
|
|
865
868
|
}
|
|
866
869
|
|
|
867
|
-
class StopRouterOutputCommand extends
|
|
870
|
+
class StopRouterOutputCommand extends Command
|
|
868
871
|
.classBuilder()
|
|
869
872
|
.ep(commonParams)
|
|
870
873
|
.m(function (Command, cs, config, o) {
|
|
871
|
-
return [
|
|
874
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
872
875
|
})
|
|
873
876
|
.s("MediaConnect", "StopRouterOutput", {})
|
|
874
877
|
.n("MediaConnectClient", "StopRouterOutputCommand")
|
|
875
|
-
.sc(
|
|
878
|
+
.sc(StopRouterOutput$)
|
|
876
879
|
.build() {
|
|
877
880
|
}
|
|
878
881
|
|
|
879
|
-
class TagGlobalResourceCommand extends
|
|
882
|
+
class TagGlobalResourceCommand extends Command
|
|
880
883
|
.classBuilder()
|
|
881
884
|
.ep(commonParams)
|
|
882
885
|
.m(function (Command, cs, config, o) {
|
|
883
|
-
return [
|
|
886
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
884
887
|
})
|
|
885
888
|
.s("MediaConnect", "TagGlobalResource", {})
|
|
886
889
|
.n("MediaConnectClient", "TagGlobalResourceCommand")
|
|
887
|
-
.sc(
|
|
890
|
+
.sc(TagGlobalResource$)
|
|
888
891
|
.build() {
|
|
889
892
|
}
|
|
890
893
|
|
|
891
|
-
class TagResourceCommand extends
|
|
894
|
+
class TagResourceCommand extends Command
|
|
892
895
|
.classBuilder()
|
|
893
896
|
.ep(commonParams)
|
|
894
897
|
.m(function (Command, cs, config, o) {
|
|
895
|
-
return [
|
|
898
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
896
899
|
})
|
|
897
900
|
.s("MediaConnect", "TagResource", {})
|
|
898
901
|
.n("MediaConnectClient", "TagResourceCommand")
|
|
899
|
-
.sc(
|
|
902
|
+
.sc(TagResource$)
|
|
900
903
|
.build() {
|
|
901
904
|
}
|
|
902
905
|
|
|
903
|
-
class TakeRouterInputCommand extends
|
|
906
|
+
class TakeRouterInputCommand extends Command
|
|
904
907
|
.classBuilder()
|
|
905
908
|
.ep(commonParams)
|
|
906
909
|
.m(function (Command, cs, config, o) {
|
|
907
|
-
return [
|
|
910
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
908
911
|
})
|
|
909
912
|
.s("MediaConnect", "TakeRouterInput", {})
|
|
910
913
|
.n("MediaConnectClient", "TakeRouterInputCommand")
|
|
911
|
-
.sc(
|
|
914
|
+
.sc(TakeRouterInput$)
|
|
912
915
|
.build() {
|
|
913
916
|
}
|
|
914
917
|
|
|
915
|
-
class UntagGlobalResourceCommand extends
|
|
918
|
+
class UntagGlobalResourceCommand extends Command
|
|
916
919
|
.classBuilder()
|
|
917
920
|
.ep(commonParams)
|
|
918
921
|
.m(function (Command, cs, config, o) {
|
|
919
|
-
return [
|
|
922
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
920
923
|
})
|
|
921
924
|
.s("MediaConnect", "UntagGlobalResource", {})
|
|
922
925
|
.n("MediaConnectClient", "UntagGlobalResourceCommand")
|
|
923
|
-
.sc(
|
|
926
|
+
.sc(UntagGlobalResource$)
|
|
924
927
|
.build() {
|
|
925
928
|
}
|
|
926
929
|
|
|
927
|
-
class UntagResourceCommand extends
|
|
930
|
+
class UntagResourceCommand extends Command
|
|
928
931
|
.classBuilder()
|
|
929
932
|
.ep(commonParams)
|
|
930
933
|
.m(function (Command, cs, config, o) {
|
|
931
|
-
return [
|
|
934
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
932
935
|
})
|
|
933
936
|
.s("MediaConnect", "UntagResource", {})
|
|
934
937
|
.n("MediaConnectClient", "UntagResourceCommand")
|
|
935
|
-
.sc(
|
|
938
|
+
.sc(UntagResource$)
|
|
936
939
|
.build() {
|
|
937
940
|
}
|
|
938
941
|
|
|
939
|
-
class UpdateBridgeCommand extends
|
|
942
|
+
class UpdateBridgeCommand extends Command
|
|
940
943
|
.classBuilder()
|
|
941
944
|
.ep(commonParams)
|
|
942
945
|
.m(function (Command, cs, config, o) {
|
|
943
|
-
return [
|
|
946
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
944
947
|
})
|
|
945
948
|
.s("MediaConnect", "UpdateBridge", {})
|
|
946
949
|
.n("MediaConnectClient", "UpdateBridgeCommand")
|
|
947
|
-
.sc(
|
|
950
|
+
.sc(UpdateBridge$)
|
|
948
951
|
.build() {
|
|
949
952
|
}
|
|
950
953
|
|
|
951
|
-
class UpdateBridgeOutputCommand extends
|
|
954
|
+
class UpdateBridgeOutputCommand extends Command
|
|
952
955
|
.classBuilder()
|
|
953
956
|
.ep(commonParams)
|
|
954
957
|
.m(function (Command, cs, config, o) {
|
|
955
|
-
return [
|
|
958
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
956
959
|
})
|
|
957
960
|
.s("MediaConnect", "UpdateBridgeOutput", {})
|
|
958
961
|
.n("MediaConnectClient", "UpdateBridgeOutputCommand")
|
|
959
|
-
.sc(
|
|
962
|
+
.sc(UpdateBridgeOutput$)
|
|
960
963
|
.build() {
|
|
961
964
|
}
|
|
962
965
|
|
|
963
|
-
class UpdateBridgeSourceCommand extends
|
|
966
|
+
class UpdateBridgeSourceCommand extends Command
|
|
964
967
|
.classBuilder()
|
|
965
968
|
.ep(commonParams)
|
|
966
969
|
.m(function (Command, cs, config, o) {
|
|
967
|
-
return [
|
|
970
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
968
971
|
})
|
|
969
972
|
.s("MediaConnect", "UpdateBridgeSource", {})
|
|
970
973
|
.n("MediaConnectClient", "UpdateBridgeSourceCommand")
|
|
971
|
-
.sc(
|
|
974
|
+
.sc(UpdateBridgeSource$)
|
|
972
975
|
.build() {
|
|
973
976
|
}
|
|
974
977
|
|
|
975
|
-
class UpdateBridgeStateCommand extends
|
|
978
|
+
class UpdateBridgeStateCommand extends Command
|
|
976
979
|
.classBuilder()
|
|
977
980
|
.ep(commonParams)
|
|
978
981
|
.m(function (Command, cs, config, o) {
|
|
979
|
-
return [
|
|
982
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
980
983
|
})
|
|
981
984
|
.s("MediaConnect", "UpdateBridgeState", {})
|
|
982
985
|
.n("MediaConnectClient", "UpdateBridgeStateCommand")
|
|
983
|
-
.sc(
|
|
986
|
+
.sc(UpdateBridgeState$)
|
|
984
987
|
.build() {
|
|
985
988
|
}
|
|
986
989
|
|
|
987
|
-
class UpdateFlowCommand extends
|
|
990
|
+
class UpdateFlowCommand extends Command
|
|
988
991
|
.classBuilder()
|
|
989
992
|
.ep(commonParams)
|
|
990
993
|
.m(function (Command, cs, config, o) {
|
|
991
|
-
return [
|
|
994
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
992
995
|
})
|
|
993
996
|
.s("MediaConnect", "UpdateFlow", {})
|
|
994
997
|
.n("MediaConnectClient", "UpdateFlowCommand")
|
|
995
|
-
.sc(
|
|
998
|
+
.sc(UpdateFlow$)
|
|
996
999
|
.build() {
|
|
997
1000
|
}
|
|
998
1001
|
|
|
999
|
-
class UpdateFlowEntitlementCommand extends
|
|
1002
|
+
class UpdateFlowEntitlementCommand extends Command
|
|
1000
1003
|
.classBuilder()
|
|
1001
1004
|
.ep(commonParams)
|
|
1002
1005
|
.m(function (Command, cs, config, o) {
|
|
1003
|
-
return [
|
|
1006
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1004
1007
|
})
|
|
1005
1008
|
.s("MediaConnect", "UpdateFlowEntitlement", {})
|
|
1006
1009
|
.n("MediaConnectClient", "UpdateFlowEntitlementCommand")
|
|
1007
|
-
.sc(
|
|
1010
|
+
.sc(UpdateFlowEntitlement$)
|
|
1008
1011
|
.build() {
|
|
1009
1012
|
}
|
|
1010
1013
|
|
|
1011
|
-
class UpdateFlowMediaStreamCommand extends
|
|
1014
|
+
class UpdateFlowMediaStreamCommand extends Command
|
|
1012
1015
|
.classBuilder()
|
|
1013
1016
|
.ep(commonParams)
|
|
1014
1017
|
.m(function (Command, cs, config, o) {
|
|
1015
|
-
return [
|
|
1018
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1016
1019
|
})
|
|
1017
1020
|
.s("MediaConnect", "UpdateFlowMediaStream", {})
|
|
1018
1021
|
.n("MediaConnectClient", "UpdateFlowMediaStreamCommand")
|
|
1019
|
-
.sc(
|
|
1022
|
+
.sc(UpdateFlowMediaStream$)
|
|
1020
1023
|
.build() {
|
|
1021
1024
|
}
|
|
1022
1025
|
|
|
1023
|
-
class UpdateFlowOutputCommand extends
|
|
1026
|
+
class UpdateFlowOutputCommand extends Command
|
|
1024
1027
|
.classBuilder()
|
|
1025
1028
|
.ep(commonParams)
|
|
1026
1029
|
.m(function (Command, cs, config, o) {
|
|
1027
|
-
return [
|
|
1030
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1028
1031
|
})
|
|
1029
1032
|
.s("MediaConnect", "UpdateFlowOutput", {})
|
|
1030
1033
|
.n("MediaConnectClient", "UpdateFlowOutputCommand")
|
|
1031
|
-
.sc(
|
|
1034
|
+
.sc(UpdateFlowOutput$)
|
|
1032
1035
|
.build() {
|
|
1033
1036
|
}
|
|
1034
1037
|
|
|
1035
|
-
class UpdateFlowSourceCommand extends
|
|
1038
|
+
class UpdateFlowSourceCommand extends Command
|
|
1036
1039
|
.classBuilder()
|
|
1037
1040
|
.ep(commonParams)
|
|
1038
1041
|
.m(function (Command, cs, config, o) {
|
|
1039
|
-
return [
|
|
1042
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1040
1043
|
})
|
|
1041
1044
|
.s("MediaConnect", "UpdateFlowSource", {})
|
|
1042
1045
|
.n("MediaConnectClient", "UpdateFlowSourceCommand")
|
|
1043
|
-
.sc(
|
|
1046
|
+
.sc(UpdateFlowSource$)
|
|
1044
1047
|
.build() {
|
|
1045
1048
|
}
|
|
1046
1049
|
|
|
1047
|
-
class UpdateGatewayInstanceCommand extends
|
|
1050
|
+
class UpdateGatewayInstanceCommand extends Command
|
|
1048
1051
|
.classBuilder()
|
|
1049
1052
|
.ep(commonParams)
|
|
1050
1053
|
.m(function (Command, cs, config, o) {
|
|
1051
|
-
return [
|
|
1054
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1052
1055
|
})
|
|
1053
1056
|
.s("MediaConnect", "UpdateGatewayInstance", {})
|
|
1054
1057
|
.n("MediaConnectClient", "UpdateGatewayInstanceCommand")
|
|
1055
|
-
.sc(
|
|
1058
|
+
.sc(UpdateGatewayInstance$)
|
|
1056
1059
|
.build() {
|
|
1057
1060
|
}
|
|
1058
1061
|
|
|
1059
|
-
class UpdateRouterInputCommand extends
|
|
1062
|
+
class UpdateRouterInputCommand extends Command
|
|
1060
1063
|
.classBuilder()
|
|
1061
1064
|
.ep(commonParams)
|
|
1062
1065
|
.m(function (Command, cs, config, o) {
|
|
1063
|
-
return [
|
|
1066
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1064
1067
|
})
|
|
1065
1068
|
.s("MediaConnect", "UpdateRouterInput", {})
|
|
1066
1069
|
.n("MediaConnectClient", "UpdateRouterInputCommand")
|
|
1067
|
-
.sc(
|
|
1070
|
+
.sc(UpdateRouterInput$)
|
|
1068
1071
|
.build() {
|
|
1069
1072
|
}
|
|
1070
1073
|
|
|
1071
|
-
class UpdateRouterNetworkInterfaceCommand extends
|
|
1074
|
+
class UpdateRouterNetworkInterfaceCommand extends Command
|
|
1072
1075
|
.classBuilder()
|
|
1073
1076
|
.ep(commonParams)
|
|
1074
1077
|
.m(function (Command, cs, config, o) {
|
|
1075
|
-
return [
|
|
1078
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1076
1079
|
})
|
|
1077
1080
|
.s("MediaConnect", "UpdateRouterNetworkInterface", {})
|
|
1078
1081
|
.n("MediaConnectClient", "UpdateRouterNetworkInterfaceCommand")
|
|
1079
|
-
.sc(
|
|
1082
|
+
.sc(UpdateRouterNetworkInterface$)
|
|
1080
1083
|
.build() {
|
|
1081
1084
|
}
|
|
1082
1085
|
|
|
1083
|
-
class UpdateRouterOutputCommand extends
|
|
1086
|
+
class UpdateRouterOutputCommand extends Command
|
|
1084
1087
|
.classBuilder()
|
|
1085
1088
|
.ep(commonParams)
|
|
1086
1089
|
.m(function (Command, cs, config, o) {
|
|
1087
|
-
return [
|
|
1090
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1088
1091
|
})
|
|
1089
1092
|
.s("MediaConnect", "UpdateRouterOutput", {})
|
|
1090
1093
|
.n("MediaConnectClient", "UpdateRouterOutputCommand")
|
|
1091
|
-
.sc(
|
|
1094
|
+
.sc(UpdateRouterOutput$)
|
|
1092
1095
|
.build() {
|
|
1093
1096
|
}
|
|
1094
1097
|
|
|
1095
|
-
const paginateListBridges =
|
|
1098
|
+
const paginateListBridges = createPaginator(MediaConnectClient, ListBridgesCommand, "NextToken", "NextToken", "MaxResults");
|
|
1096
1099
|
|
|
1097
|
-
const paginateListEntitlements =
|
|
1100
|
+
const paginateListEntitlements = createPaginator(MediaConnectClient, ListEntitlementsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1098
1101
|
|
|
1099
|
-
const paginateListFlows =
|
|
1102
|
+
const paginateListFlows = createPaginator(MediaConnectClient, ListFlowsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1100
1103
|
|
|
1101
|
-
const paginateListGatewayInstances =
|
|
1104
|
+
const paginateListGatewayInstances = createPaginator(MediaConnectClient, ListGatewayInstancesCommand, "NextToken", "NextToken", "MaxResults");
|
|
1102
1105
|
|
|
1103
|
-
const paginateListGateways =
|
|
1106
|
+
const paginateListGateways = createPaginator(MediaConnectClient, ListGatewaysCommand, "NextToken", "NextToken", "MaxResults");
|
|
1104
1107
|
|
|
1105
|
-
const paginateListOfferings =
|
|
1108
|
+
const paginateListOfferings = createPaginator(MediaConnectClient, ListOfferingsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1106
1109
|
|
|
1107
|
-
const paginateListReservations =
|
|
1110
|
+
const paginateListReservations = createPaginator(MediaConnectClient, ListReservationsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1108
1111
|
|
|
1109
|
-
const paginateListRouterInputs =
|
|
1112
|
+
const paginateListRouterInputs = createPaginator(MediaConnectClient, ListRouterInputsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1110
1113
|
|
|
1111
|
-
const paginateListRouterNetworkInterfaces =
|
|
1114
|
+
const paginateListRouterNetworkInterfaces = createPaginator(MediaConnectClient, ListRouterNetworkInterfacesCommand, "NextToken", "NextToken", "MaxResults");
|
|
1112
1115
|
|
|
1113
|
-
const paginateListRouterOutputs =
|
|
1116
|
+
const paginateListRouterOutputs = createPaginator(MediaConnectClient, ListRouterOutputsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1114
1117
|
|
|
1115
|
-
const checkState$a = async (client
|
|
1118
|
+
const checkState$a = async (client, input) => {
|
|
1116
1119
|
let reason;
|
|
1117
1120
|
try {
|
|
1118
|
-
let result = await client
|
|
1121
|
+
let result = await client.send(new DescribeFlowCommand(input));
|
|
1119
1122
|
reason = result;
|
|
1120
1123
|
try {
|
|
1121
1124
|
const returnComparator = () => {
|
|
1122
1125
|
return result.Flow.Status;
|
|
1123
1126
|
};
|
|
1124
1127
|
if (returnComparator() === "ACTIVE") {
|
|
1125
|
-
return { state:
|
|
1128
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1126
1129
|
}
|
|
1127
1130
|
}
|
|
1128
1131
|
catch (e) { }
|
|
@@ -1131,7 +1134,7 @@ const checkState$a = async (client$1, input) => {
|
|
|
1131
1134
|
return result.Flow.Status;
|
|
1132
1135
|
};
|
|
1133
1136
|
if (returnComparator() === "STARTING") {
|
|
1134
|
-
return { state:
|
|
1137
|
+
return { state: WaiterState.RETRY, reason };
|
|
1135
1138
|
}
|
|
1136
1139
|
}
|
|
1137
1140
|
catch (e) { }
|
|
@@ -1140,7 +1143,7 @@ const checkState$a = async (client$1, input) => {
|
|
|
1140
1143
|
return result.Flow.Status;
|
|
1141
1144
|
};
|
|
1142
1145
|
if (returnComparator() === "UPDATING") {
|
|
1143
|
-
return { state:
|
|
1146
|
+
return { state: WaiterState.RETRY, reason };
|
|
1144
1147
|
}
|
|
1145
1148
|
}
|
|
1146
1149
|
catch (e) { }
|
|
@@ -1149,7 +1152,7 @@ const checkState$a = async (client$1, input) => {
|
|
|
1149
1152
|
return result.Flow.Status;
|
|
1150
1153
|
};
|
|
1151
1154
|
if (returnComparator() === "STANDBY") {
|
|
1152
|
-
return { state:
|
|
1155
|
+
return { state: WaiterState.FAILURE, reason };
|
|
1153
1156
|
}
|
|
1154
1157
|
}
|
|
1155
1158
|
catch (e) { }
|
|
@@ -1158,7 +1161,7 @@ const checkState$a = async (client$1, input) => {
|
|
|
1158
1161
|
return result.Flow.Status;
|
|
1159
1162
|
};
|
|
1160
1163
|
if (returnComparator() === "ERROR") {
|
|
1161
|
-
return { state:
|
|
1164
|
+
return { state: WaiterState.FAILURE, reason };
|
|
1162
1165
|
}
|
|
1163
1166
|
}
|
|
1164
1167
|
catch (e) { }
|
|
@@ -1166,35 +1169,35 @@ const checkState$a = async (client$1, input) => {
|
|
|
1166
1169
|
catch (exception) {
|
|
1167
1170
|
reason = exception;
|
|
1168
1171
|
if (exception.name === "InternalServerErrorException") {
|
|
1169
|
-
return { state:
|
|
1172
|
+
return { state: WaiterState.RETRY, reason };
|
|
1170
1173
|
}
|
|
1171
1174
|
if (exception.name === "ServiceUnavailableException") {
|
|
1172
|
-
return { state:
|
|
1175
|
+
return { state: WaiterState.RETRY, reason };
|
|
1173
1176
|
}
|
|
1174
1177
|
}
|
|
1175
|
-
return { state:
|
|
1178
|
+
return { state: WaiterState.RETRY, reason };
|
|
1176
1179
|
};
|
|
1177
1180
|
const waitForFlowActive = async (params, input) => {
|
|
1178
1181
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1179
|
-
return
|
|
1182
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
|
|
1180
1183
|
};
|
|
1181
1184
|
const waitUntilFlowActive = async (params, input) => {
|
|
1182
1185
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1183
|
-
const result = await
|
|
1184
|
-
return
|
|
1186
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
|
|
1187
|
+
return checkExceptions(result);
|
|
1185
1188
|
};
|
|
1186
1189
|
|
|
1187
|
-
const checkState$9 = async (client
|
|
1190
|
+
const checkState$9 = async (client, input) => {
|
|
1188
1191
|
let reason;
|
|
1189
1192
|
try {
|
|
1190
|
-
let result = await client
|
|
1193
|
+
let result = await client.send(new DescribeFlowCommand(input));
|
|
1191
1194
|
reason = result;
|
|
1192
1195
|
try {
|
|
1193
1196
|
const returnComparator = () => {
|
|
1194
1197
|
return result.Flow.Status;
|
|
1195
1198
|
};
|
|
1196
1199
|
if (returnComparator() === "DELETING") {
|
|
1197
|
-
return { state:
|
|
1200
|
+
return { state: WaiterState.RETRY, reason };
|
|
1198
1201
|
}
|
|
1199
1202
|
}
|
|
1200
1203
|
catch (e) { }
|
|
@@ -1203,7 +1206,7 @@ const checkState$9 = async (client$1, input) => {
|
|
|
1203
1206
|
return result.Flow.Status;
|
|
1204
1207
|
};
|
|
1205
1208
|
if (returnComparator() === "ERROR") {
|
|
1206
|
-
return { state:
|
|
1209
|
+
return { state: WaiterState.FAILURE, reason };
|
|
1207
1210
|
}
|
|
1208
1211
|
}
|
|
1209
1212
|
catch (e) { }
|
|
@@ -1211,38 +1214,38 @@ const checkState$9 = async (client$1, input) => {
|
|
|
1211
1214
|
catch (exception) {
|
|
1212
1215
|
reason = exception;
|
|
1213
1216
|
if (exception.name === "NotFoundException") {
|
|
1214
|
-
return { state:
|
|
1217
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1215
1218
|
}
|
|
1216
1219
|
if (exception.name === "InternalServerErrorException") {
|
|
1217
|
-
return { state:
|
|
1220
|
+
return { state: WaiterState.RETRY, reason };
|
|
1218
1221
|
}
|
|
1219
1222
|
if (exception.name === "ServiceUnavailableException") {
|
|
1220
|
-
return { state:
|
|
1223
|
+
return { state: WaiterState.RETRY, reason };
|
|
1221
1224
|
}
|
|
1222
1225
|
}
|
|
1223
|
-
return { state:
|
|
1226
|
+
return { state: WaiterState.RETRY, reason };
|
|
1224
1227
|
};
|
|
1225
1228
|
const waitForFlowDeleted = async (params, input) => {
|
|
1226
1229
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1227
|
-
return
|
|
1230
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
|
|
1228
1231
|
};
|
|
1229
1232
|
const waitUntilFlowDeleted = async (params, input) => {
|
|
1230
1233
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1231
|
-
const result = await
|
|
1232
|
-
return
|
|
1234
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
|
|
1235
|
+
return checkExceptions(result);
|
|
1233
1236
|
};
|
|
1234
1237
|
|
|
1235
|
-
const checkState$8 = async (client
|
|
1238
|
+
const checkState$8 = async (client, input) => {
|
|
1236
1239
|
let reason;
|
|
1237
1240
|
try {
|
|
1238
|
-
let result = await client
|
|
1241
|
+
let result = await client.send(new DescribeFlowCommand(input));
|
|
1239
1242
|
reason = result;
|
|
1240
1243
|
try {
|
|
1241
1244
|
const returnComparator = () => {
|
|
1242
1245
|
return result.Flow.Status;
|
|
1243
1246
|
};
|
|
1244
1247
|
if (returnComparator() === "STANDBY") {
|
|
1245
|
-
return { state:
|
|
1248
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1246
1249
|
}
|
|
1247
1250
|
}
|
|
1248
1251
|
catch (e) { }
|
|
@@ -1251,7 +1254,7 @@ const checkState$8 = async (client$1, input) => {
|
|
|
1251
1254
|
return result.Flow.Status;
|
|
1252
1255
|
};
|
|
1253
1256
|
if (returnComparator() === "STOPPING") {
|
|
1254
|
-
return { state:
|
|
1257
|
+
return { state: WaiterState.RETRY, reason };
|
|
1255
1258
|
}
|
|
1256
1259
|
}
|
|
1257
1260
|
catch (e) { }
|
|
@@ -1260,7 +1263,7 @@ const checkState$8 = async (client$1, input) => {
|
|
|
1260
1263
|
return result.Flow.Status;
|
|
1261
1264
|
};
|
|
1262
1265
|
if (returnComparator() === "ERROR") {
|
|
1263
|
-
return { state:
|
|
1266
|
+
return { state: WaiterState.FAILURE, reason };
|
|
1264
1267
|
}
|
|
1265
1268
|
}
|
|
1266
1269
|
catch (e) { }
|
|
@@ -1268,35 +1271,35 @@ const checkState$8 = async (client$1, input) => {
|
|
|
1268
1271
|
catch (exception) {
|
|
1269
1272
|
reason = exception;
|
|
1270
1273
|
if (exception.name === "InternalServerErrorException") {
|
|
1271
|
-
return { state:
|
|
1274
|
+
return { state: WaiterState.RETRY, reason };
|
|
1272
1275
|
}
|
|
1273
1276
|
if (exception.name === "ServiceUnavailableException") {
|
|
1274
|
-
return { state:
|
|
1277
|
+
return { state: WaiterState.RETRY, reason };
|
|
1275
1278
|
}
|
|
1276
1279
|
}
|
|
1277
|
-
return { state:
|
|
1280
|
+
return { state: WaiterState.RETRY, reason };
|
|
1278
1281
|
};
|
|
1279
1282
|
const waitForFlowStandby = async (params, input) => {
|
|
1280
1283
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1281
|
-
return
|
|
1284
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
|
|
1282
1285
|
};
|
|
1283
1286
|
const waitUntilFlowStandby = async (params, input) => {
|
|
1284
1287
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1285
|
-
const result = await
|
|
1286
|
-
return
|
|
1288
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
|
|
1289
|
+
return checkExceptions(result);
|
|
1287
1290
|
};
|
|
1288
1291
|
|
|
1289
|
-
const checkState$7 = async (client
|
|
1292
|
+
const checkState$7 = async (client, input) => {
|
|
1290
1293
|
let reason;
|
|
1291
1294
|
try {
|
|
1292
|
-
let result = await client
|
|
1295
|
+
let result = await client.send(new GetRouterInputCommand(input));
|
|
1293
1296
|
reason = result;
|
|
1294
1297
|
try {
|
|
1295
1298
|
const returnComparator = () => {
|
|
1296
1299
|
return result.RouterInput.State;
|
|
1297
1300
|
};
|
|
1298
1301
|
if (returnComparator() === "ACTIVE") {
|
|
1299
|
-
return { state:
|
|
1302
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1300
1303
|
}
|
|
1301
1304
|
}
|
|
1302
1305
|
catch (e) { }
|
|
@@ -1305,7 +1308,7 @@ const checkState$7 = async (client$1, input) => {
|
|
|
1305
1308
|
return result.RouterInput.State;
|
|
1306
1309
|
};
|
|
1307
1310
|
if (returnComparator() === "STARTING") {
|
|
1308
|
-
return { state:
|
|
1311
|
+
return { state: WaiterState.RETRY, reason };
|
|
1309
1312
|
}
|
|
1310
1313
|
}
|
|
1311
1314
|
catch (e) { }
|
|
@@ -1314,7 +1317,7 @@ const checkState$7 = async (client$1, input) => {
|
|
|
1314
1317
|
return result.RouterInput.State;
|
|
1315
1318
|
};
|
|
1316
1319
|
if (returnComparator() === "UPDATING") {
|
|
1317
|
-
return { state:
|
|
1320
|
+
return { state: WaiterState.RETRY, reason };
|
|
1318
1321
|
}
|
|
1319
1322
|
}
|
|
1320
1323
|
catch (e) { }
|
|
@@ -1323,7 +1326,7 @@ const checkState$7 = async (client$1, input) => {
|
|
|
1323
1326
|
return result.RouterInput.State;
|
|
1324
1327
|
};
|
|
1325
1328
|
if (returnComparator() === "MIGRATING") {
|
|
1326
|
-
return { state:
|
|
1329
|
+
return { state: WaiterState.RETRY, reason };
|
|
1327
1330
|
}
|
|
1328
1331
|
}
|
|
1329
1332
|
catch (e) { }
|
|
@@ -1332,7 +1335,7 @@ const checkState$7 = async (client$1, input) => {
|
|
|
1332
1335
|
return result.RouterInput.State;
|
|
1333
1336
|
};
|
|
1334
1337
|
if (returnComparator() === "ERROR") {
|
|
1335
|
-
return { state:
|
|
1338
|
+
return { state: WaiterState.FAILURE, reason };
|
|
1336
1339
|
}
|
|
1337
1340
|
}
|
|
1338
1341
|
catch (e) { }
|
|
@@ -1340,35 +1343,35 @@ const checkState$7 = async (client$1, input) => {
|
|
|
1340
1343
|
catch (exception) {
|
|
1341
1344
|
reason = exception;
|
|
1342
1345
|
if (exception.name === "InternalServerErrorException") {
|
|
1343
|
-
return { state:
|
|
1346
|
+
return { state: WaiterState.RETRY, reason };
|
|
1344
1347
|
}
|
|
1345
1348
|
if (exception.name === "ServiceUnavailableException") {
|
|
1346
|
-
return { state:
|
|
1349
|
+
return { state: WaiterState.RETRY, reason };
|
|
1347
1350
|
}
|
|
1348
1351
|
}
|
|
1349
|
-
return { state:
|
|
1352
|
+
return { state: WaiterState.RETRY, reason };
|
|
1350
1353
|
};
|
|
1351
1354
|
const waitForInputActive = async (params, input) => {
|
|
1352
1355
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1353
|
-
return
|
|
1356
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
|
|
1354
1357
|
};
|
|
1355
1358
|
const waitUntilInputActive = async (params, input) => {
|
|
1356
1359
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1357
|
-
const result = await
|
|
1358
|
-
return
|
|
1360
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
|
|
1361
|
+
return checkExceptions(result);
|
|
1359
1362
|
};
|
|
1360
1363
|
|
|
1361
|
-
const checkState$6 = async (client
|
|
1364
|
+
const checkState$6 = async (client, input) => {
|
|
1362
1365
|
let reason;
|
|
1363
1366
|
try {
|
|
1364
|
-
let result = await client
|
|
1367
|
+
let result = await client.send(new GetRouterInputCommand(input));
|
|
1365
1368
|
reason = result;
|
|
1366
1369
|
try {
|
|
1367
1370
|
const returnComparator = () => {
|
|
1368
1371
|
return result.RouterInput.State;
|
|
1369
1372
|
};
|
|
1370
1373
|
if (returnComparator() === "DELETING") {
|
|
1371
|
-
return { state:
|
|
1374
|
+
return { state: WaiterState.RETRY, reason };
|
|
1372
1375
|
}
|
|
1373
1376
|
}
|
|
1374
1377
|
catch (e) { }
|
|
@@ -1377,7 +1380,7 @@ const checkState$6 = async (client$1, input) => {
|
|
|
1377
1380
|
return result.RouterInput.State;
|
|
1378
1381
|
};
|
|
1379
1382
|
if (returnComparator() === "ERROR") {
|
|
1380
|
-
return { state:
|
|
1383
|
+
return { state: WaiterState.FAILURE, reason };
|
|
1381
1384
|
}
|
|
1382
1385
|
}
|
|
1383
1386
|
catch (e) { }
|
|
@@ -1385,38 +1388,38 @@ const checkState$6 = async (client$1, input) => {
|
|
|
1385
1388
|
catch (exception) {
|
|
1386
1389
|
reason = exception;
|
|
1387
1390
|
if (exception.name === "InternalServerErrorException") {
|
|
1388
|
-
return { state:
|
|
1391
|
+
return { state: WaiterState.RETRY, reason };
|
|
1389
1392
|
}
|
|
1390
1393
|
if (exception.name === "ServiceUnavailableException") {
|
|
1391
|
-
return { state:
|
|
1394
|
+
return { state: WaiterState.RETRY, reason };
|
|
1392
1395
|
}
|
|
1393
1396
|
if (exception.name === "NotFoundException") {
|
|
1394
|
-
return { state:
|
|
1397
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1395
1398
|
}
|
|
1396
1399
|
}
|
|
1397
|
-
return { state:
|
|
1400
|
+
return { state: WaiterState.RETRY, reason };
|
|
1398
1401
|
};
|
|
1399
1402
|
const waitForInputDeleted = async (params, input) => {
|
|
1400
1403
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1401
|
-
return
|
|
1404
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
|
|
1402
1405
|
};
|
|
1403
1406
|
const waitUntilInputDeleted = async (params, input) => {
|
|
1404
1407
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1405
|
-
const result = await
|
|
1406
|
-
return
|
|
1408
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
|
|
1409
|
+
return checkExceptions(result);
|
|
1407
1410
|
};
|
|
1408
1411
|
|
|
1409
|
-
const checkState$5 = async (client
|
|
1412
|
+
const checkState$5 = async (client, input) => {
|
|
1410
1413
|
let reason;
|
|
1411
1414
|
try {
|
|
1412
|
-
let result = await client
|
|
1415
|
+
let result = await client.send(new GetRouterInputCommand(input));
|
|
1413
1416
|
reason = result;
|
|
1414
1417
|
try {
|
|
1415
1418
|
const returnComparator = () => {
|
|
1416
1419
|
return result.RouterInput.State;
|
|
1417
1420
|
};
|
|
1418
1421
|
if (returnComparator() === "STANDBY") {
|
|
1419
|
-
return { state:
|
|
1422
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1420
1423
|
}
|
|
1421
1424
|
}
|
|
1422
1425
|
catch (e) { }
|
|
@@ -1425,7 +1428,7 @@ const checkState$5 = async (client$1, input) => {
|
|
|
1425
1428
|
return result.RouterInput.State;
|
|
1426
1429
|
};
|
|
1427
1430
|
if (returnComparator() === "STOPPING") {
|
|
1428
|
-
return { state:
|
|
1431
|
+
return { state: WaiterState.RETRY, reason };
|
|
1429
1432
|
}
|
|
1430
1433
|
}
|
|
1431
1434
|
catch (e) { }
|
|
@@ -1434,7 +1437,7 @@ const checkState$5 = async (client$1, input) => {
|
|
|
1434
1437
|
return result.RouterInput.State;
|
|
1435
1438
|
};
|
|
1436
1439
|
if (returnComparator() === "ERROR") {
|
|
1437
|
-
return { state:
|
|
1440
|
+
return { state: WaiterState.FAILURE, reason };
|
|
1438
1441
|
}
|
|
1439
1442
|
}
|
|
1440
1443
|
catch (e) { }
|
|
@@ -1442,35 +1445,35 @@ const checkState$5 = async (client$1, input) => {
|
|
|
1442
1445
|
catch (exception) {
|
|
1443
1446
|
reason = exception;
|
|
1444
1447
|
if (exception.name === "InternalServerErrorException") {
|
|
1445
|
-
return { state:
|
|
1448
|
+
return { state: WaiterState.RETRY, reason };
|
|
1446
1449
|
}
|
|
1447
1450
|
if (exception.name === "ServiceUnavailableException") {
|
|
1448
|
-
return { state:
|
|
1451
|
+
return { state: WaiterState.RETRY, reason };
|
|
1449
1452
|
}
|
|
1450
1453
|
}
|
|
1451
|
-
return { state:
|
|
1454
|
+
return { state: WaiterState.RETRY, reason };
|
|
1452
1455
|
};
|
|
1453
1456
|
const waitForInputStandby = async (params, input) => {
|
|
1454
1457
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1455
|
-
return
|
|
1458
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
|
|
1456
1459
|
};
|
|
1457
1460
|
const waitUntilInputStandby = async (params, input) => {
|
|
1458
1461
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1459
|
-
const result = await
|
|
1460
|
-
return
|
|
1462
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
|
|
1463
|
+
return checkExceptions(result);
|
|
1461
1464
|
};
|
|
1462
1465
|
|
|
1463
|
-
const checkState$4 = async (client
|
|
1466
|
+
const checkState$4 = async (client, input) => {
|
|
1464
1467
|
let reason;
|
|
1465
1468
|
try {
|
|
1466
|
-
let result = await client
|
|
1469
|
+
let result = await client.send(new GetRouterOutputCommand(input));
|
|
1467
1470
|
reason = result;
|
|
1468
1471
|
try {
|
|
1469
1472
|
const returnComparator = () => {
|
|
1470
1473
|
return result.RouterOutput.State;
|
|
1471
1474
|
};
|
|
1472
1475
|
if (returnComparator() === "ACTIVE") {
|
|
1473
|
-
return { state:
|
|
1476
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1474
1477
|
}
|
|
1475
1478
|
}
|
|
1476
1479
|
catch (e) { }
|
|
@@ -1479,7 +1482,7 @@ const checkState$4 = async (client$1, input) => {
|
|
|
1479
1482
|
return result.RouterOutput.State;
|
|
1480
1483
|
};
|
|
1481
1484
|
if (returnComparator() === "STARTING") {
|
|
1482
|
-
return { state:
|
|
1485
|
+
return { state: WaiterState.RETRY, reason };
|
|
1483
1486
|
}
|
|
1484
1487
|
}
|
|
1485
1488
|
catch (e) { }
|
|
@@ -1488,7 +1491,7 @@ const checkState$4 = async (client$1, input) => {
|
|
|
1488
1491
|
return result.RouterOutput.State;
|
|
1489
1492
|
};
|
|
1490
1493
|
if (returnComparator() === "UPDATING") {
|
|
1491
|
-
return { state:
|
|
1494
|
+
return { state: WaiterState.RETRY, reason };
|
|
1492
1495
|
}
|
|
1493
1496
|
}
|
|
1494
1497
|
catch (e) { }
|
|
@@ -1497,7 +1500,7 @@ const checkState$4 = async (client$1, input) => {
|
|
|
1497
1500
|
return result.RouterOutput.State;
|
|
1498
1501
|
};
|
|
1499
1502
|
if (returnComparator() === "MIGRATING") {
|
|
1500
|
-
return { state:
|
|
1503
|
+
return { state: WaiterState.RETRY, reason };
|
|
1501
1504
|
}
|
|
1502
1505
|
}
|
|
1503
1506
|
catch (e) { }
|
|
@@ -1506,7 +1509,7 @@ const checkState$4 = async (client$1, input) => {
|
|
|
1506
1509
|
return result.RouterOutput.State;
|
|
1507
1510
|
};
|
|
1508
1511
|
if (returnComparator() === "ERROR") {
|
|
1509
|
-
return { state:
|
|
1512
|
+
return { state: WaiterState.FAILURE, reason };
|
|
1510
1513
|
}
|
|
1511
1514
|
}
|
|
1512
1515
|
catch (e) { }
|
|
@@ -1514,35 +1517,35 @@ const checkState$4 = async (client$1, input) => {
|
|
|
1514
1517
|
catch (exception) {
|
|
1515
1518
|
reason = exception;
|
|
1516
1519
|
if (exception.name === "InternalServerErrorException") {
|
|
1517
|
-
return { state:
|
|
1520
|
+
return { state: WaiterState.RETRY, reason };
|
|
1518
1521
|
}
|
|
1519
1522
|
if (exception.name === "ServiceUnavailableException") {
|
|
1520
|
-
return { state:
|
|
1523
|
+
return { state: WaiterState.RETRY, reason };
|
|
1521
1524
|
}
|
|
1522
1525
|
}
|
|
1523
|
-
return { state:
|
|
1526
|
+
return { state: WaiterState.RETRY, reason };
|
|
1524
1527
|
};
|
|
1525
1528
|
const waitForOutputActive = async (params, input) => {
|
|
1526
1529
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1527
|
-
return
|
|
1530
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
|
|
1528
1531
|
};
|
|
1529
1532
|
const waitUntilOutputActive = async (params, input) => {
|
|
1530
1533
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1531
|
-
const result = await
|
|
1532
|
-
return
|
|
1534
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
|
|
1535
|
+
return checkExceptions(result);
|
|
1533
1536
|
};
|
|
1534
1537
|
|
|
1535
|
-
const checkState$3 = async (client
|
|
1538
|
+
const checkState$3 = async (client, input) => {
|
|
1536
1539
|
let reason;
|
|
1537
1540
|
try {
|
|
1538
|
-
let result = await client
|
|
1541
|
+
let result = await client.send(new GetRouterOutputCommand(input));
|
|
1539
1542
|
reason = result;
|
|
1540
1543
|
try {
|
|
1541
1544
|
const returnComparator = () => {
|
|
1542
1545
|
return result.RouterOutput.State;
|
|
1543
1546
|
};
|
|
1544
1547
|
if (returnComparator() === "DELETING") {
|
|
1545
|
-
return { state:
|
|
1548
|
+
return { state: WaiterState.RETRY, reason };
|
|
1546
1549
|
}
|
|
1547
1550
|
}
|
|
1548
1551
|
catch (e) { }
|
|
@@ -1551,7 +1554,7 @@ const checkState$3 = async (client$1, input) => {
|
|
|
1551
1554
|
return result.RouterOutput.State;
|
|
1552
1555
|
};
|
|
1553
1556
|
if (returnComparator() === "ERROR") {
|
|
1554
|
-
return { state:
|
|
1557
|
+
return { state: WaiterState.FAILURE, reason };
|
|
1555
1558
|
}
|
|
1556
1559
|
}
|
|
1557
1560
|
catch (e) { }
|
|
@@ -1559,38 +1562,38 @@ const checkState$3 = async (client$1, input) => {
|
|
|
1559
1562
|
catch (exception) {
|
|
1560
1563
|
reason = exception;
|
|
1561
1564
|
if (exception.name === "InternalServerErrorException") {
|
|
1562
|
-
return { state:
|
|
1565
|
+
return { state: WaiterState.RETRY, reason };
|
|
1563
1566
|
}
|
|
1564
1567
|
if (exception.name === "ServiceUnavailableException") {
|
|
1565
|
-
return { state:
|
|
1568
|
+
return { state: WaiterState.RETRY, reason };
|
|
1566
1569
|
}
|
|
1567
1570
|
if (exception.name === "NotFoundException") {
|
|
1568
|
-
return { state:
|
|
1571
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1569
1572
|
}
|
|
1570
1573
|
}
|
|
1571
|
-
return { state:
|
|
1574
|
+
return { state: WaiterState.RETRY, reason };
|
|
1572
1575
|
};
|
|
1573
1576
|
const waitForOutputDeleted = async (params, input) => {
|
|
1574
1577
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1575
|
-
return
|
|
1578
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
|
|
1576
1579
|
};
|
|
1577
1580
|
const waitUntilOutputDeleted = async (params, input) => {
|
|
1578
1581
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1579
|
-
const result = await
|
|
1580
|
-
return
|
|
1582
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
|
|
1583
|
+
return checkExceptions(result);
|
|
1581
1584
|
};
|
|
1582
1585
|
|
|
1583
|
-
const checkState$2 = async (client
|
|
1586
|
+
const checkState$2 = async (client, input) => {
|
|
1584
1587
|
let reason;
|
|
1585
1588
|
try {
|
|
1586
|
-
let result = await client
|
|
1589
|
+
let result = await client.send(new GetRouterOutputCommand(input));
|
|
1587
1590
|
reason = result;
|
|
1588
1591
|
try {
|
|
1589
1592
|
const returnComparator = () => {
|
|
1590
1593
|
return result.RouterOutput.RoutedState;
|
|
1591
1594
|
};
|
|
1592
1595
|
if (returnComparator() === "ROUTED") {
|
|
1593
|
-
return { state:
|
|
1596
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1594
1597
|
}
|
|
1595
1598
|
}
|
|
1596
1599
|
catch (e) { }
|
|
@@ -1599,7 +1602,7 @@ const checkState$2 = async (client$1, input) => {
|
|
|
1599
1602
|
return result.RouterOutput.RoutedState;
|
|
1600
1603
|
};
|
|
1601
1604
|
if (returnComparator() === "ROUTING") {
|
|
1602
|
-
return { state:
|
|
1605
|
+
return { state: WaiterState.RETRY, reason };
|
|
1603
1606
|
}
|
|
1604
1607
|
}
|
|
1605
1608
|
catch (e) { }
|
|
@@ -1607,35 +1610,35 @@ const checkState$2 = async (client$1, input) => {
|
|
|
1607
1610
|
catch (exception) {
|
|
1608
1611
|
reason = exception;
|
|
1609
1612
|
if (exception.name === "InternalServerErrorException") {
|
|
1610
|
-
return { state:
|
|
1613
|
+
return { state: WaiterState.RETRY, reason };
|
|
1611
1614
|
}
|
|
1612
1615
|
if (exception.name === "ServiceUnavailableException") {
|
|
1613
|
-
return { state:
|
|
1616
|
+
return { state: WaiterState.RETRY, reason };
|
|
1614
1617
|
}
|
|
1615
1618
|
}
|
|
1616
|
-
return { state:
|
|
1619
|
+
return { state: WaiterState.RETRY, reason };
|
|
1617
1620
|
};
|
|
1618
1621
|
const waitForOutputRouted = async (params, input) => {
|
|
1619
1622
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1620
|
-
return
|
|
1623
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
|
|
1621
1624
|
};
|
|
1622
1625
|
const waitUntilOutputRouted = async (params, input) => {
|
|
1623
1626
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1624
|
-
const result = await
|
|
1625
|
-
return
|
|
1627
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
|
|
1628
|
+
return checkExceptions(result);
|
|
1626
1629
|
};
|
|
1627
1630
|
|
|
1628
|
-
const checkState$1 = async (client
|
|
1631
|
+
const checkState$1 = async (client, input) => {
|
|
1629
1632
|
let reason;
|
|
1630
1633
|
try {
|
|
1631
|
-
let result = await client
|
|
1634
|
+
let result = await client.send(new GetRouterOutputCommand(input));
|
|
1632
1635
|
reason = result;
|
|
1633
1636
|
try {
|
|
1634
1637
|
const returnComparator = () => {
|
|
1635
1638
|
return result.RouterOutput.State;
|
|
1636
1639
|
};
|
|
1637
1640
|
if (returnComparator() === "STANDBY") {
|
|
1638
|
-
return { state:
|
|
1641
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1639
1642
|
}
|
|
1640
1643
|
}
|
|
1641
1644
|
catch (e) { }
|
|
@@ -1644,7 +1647,7 @@ const checkState$1 = async (client$1, input) => {
|
|
|
1644
1647
|
return result.RouterOutput.State;
|
|
1645
1648
|
};
|
|
1646
1649
|
if (returnComparator() === "STOPPING") {
|
|
1647
|
-
return { state:
|
|
1650
|
+
return { state: WaiterState.RETRY, reason };
|
|
1648
1651
|
}
|
|
1649
1652
|
}
|
|
1650
1653
|
catch (e) { }
|
|
@@ -1653,7 +1656,7 @@ const checkState$1 = async (client$1, input) => {
|
|
|
1653
1656
|
return result.RouterOutput.State;
|
|
1654
1657
|
};
|
|
1655
1658
|
if (returnComparator() === "ERROR") {
|
|
1656
|
-
return { state:
|
|
1659
|
+
return { state: WaiterState.FAILURE, reason };
|
|
1657
1660
|
}
|
|
1658
1661
|
}
|
|
1659
1662
|
catch (e) { }
|
|
@@ -1661,35 +1664,35 @@ const checkState$1 = async (client$1, input) => {
|
|
|
1661
1664
|
catch (exception) {
|
|
1662
1665
|
reason = exception;
|
|
1663
1666
|
if (exception.name === "InternalServerErrorException") {
|
|
1664
|
-
return { state:
|
|
1667
|
+
return { state: WaiterState.RETRY, reason };
|
|
1665
1668
|
}
|
|
1666
1669
|
if (exception.name === "ServiceUnavailableException") {
|
|
1667
|
-
return { state:
|
|
1670
|
+
return { state: WaiterState.RETRY, reason };
|
|
1668
1671
|
}
|
|
1669
1672
|
}
|
|
1670
|
-
return { state:
|
|
1673
|
+
return { state: WaiterState.RETRY, reason };
|
|
1671
1674
|
};
|
|
1672
1675
|
const waitForOutputStandby = async (params, input) => {
|
|
1673
1676
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1674
|
-
return
|
|
1677
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
|
|
1675
1678
|
};
|
|
1676
1679
|
const waitUntilOutputStandby = async (params, input) => {
|
|
1677
1680
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1678
|
-
const result = await
|
|
1679
|
-
return
|
|
1681
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
|
|
1682
|
+
return checkExceptions(result);
|
|
1680
1683
|
};
|
|
1681
1684
|
|
|
1682
|
-
const checkState = async (client
|
|
1685
|
+
const checkState = async (client, input) => {
|
|
1683
1686
|
let reason;
|
|
1684
1687
|
try {
|
|
1685
|
-
let result = await client
|
|
1688
|
+
let result = await client.send(new GetRouterOutputCommand(input));
|
|
1686
1689
|
reason = result;
|
|
1687
1690
|
try {
|
|
1688
1691
|
const returnComparator = () => {
|
|
1689
1692
|
return result.RouterOutput.RoutedState;
|
|
1690
1693
|
};
|
|
1691
1694
|
if (returnComparator() === "UNROUTED") {
|
|
1692
|
-
return { state:
|
|
1695
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1693
1696
|
}
|
|
1694
1697
|
}
|
|
1695
1698
|
catch (e) { }
|
|
@@ -1698,7 +1701,7 @@ const checkState = async (client$1, input) => {
|
|
|
1698
1701
|
return result.RouterOutput.RoutedState;
|
|
1699
1702
|
};
|
|
1700
1703
|
if (returnComparator() === "ROUTING") {
|
|
1701
|
-
return { state:
|
|
1704
|
+
return { state: WaiterState.RETRY, reason };
|
|
1702
1705
|
}
|
|
1703
1706
|
}
|
|
1704
1707
|
catch (e) { }
|
|
@@ -1706,22 +1709,22 @@ const checkState = async (client$1, input) => {
|
|
|
1706
1709
|
catch (exception) {
|
|
1707
1710
|
reason = exception;
|
|
1708
1711
|
if (exception.name === "InternalServerErrorException") {
|
|
1709
|
-
return { state:
|
|
1712
|
+
return { state: WaiterState.RETRY, reason };
|
|
1710
1713
|
}
|
|
1711
1714
|
if (exception.name === "ServiceUnavailableException") {
|
|
1712
|
-
return { state:
|
|
1715
|
+
return { state: WaiterState.RETRY, reason };
|
|
1713
1716
|
}
|
|
1714
1717
|
}
|
|
1715
|
-
return { state:
|
|
1718
|
+
return { state: WaiterState.RETRY, reason };
|
|
1716
1719
|
};
|
|
1717
1720
|
const waitForOutputUnrouted = async (params, input) => {
|
|
1718
1721
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1719
|
-
return
|
|
1722
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
|
|
1720
1723
|
};
|
|
1721
1724
|
const waitUntilOutputUnrouted = async (params, input) => {
|
|
1722
1725
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1723
|
-
const result = await
|
|
1724
|
-
return
|
|
1726
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
|
|
1727
|
+
return checkExceptions(result);
|
|
1725
1728
|
};
|
|
1726
1729
|
|
|
1727
1730
|
const commands = {
|
|
@@ -1835,7 +1838,7 @@ const waiters = {
|
|
|
1835
1838
|
};
|
|
1836
1839
|
class MediaConnect extends MediaConnectClient {
|
|
1837
1840
|
}
|
|
1838
|
-
|
|
1841
|
+
createAggregatedClient(commands, MediaConnect, { paginators, waiters });
|
|
1839
1842
|
|
|
1840
1843
|
const Protocol = {
|
|
1841
1844
|
cdi: "cdi",
|
|
@@ -2155,9 +2158,6 @@ const ThumbnailState = {
|
|
|
2155
2158
|
ENABLED: "ENABLED",
|
|
2156
2159
|
};
|
|
2157
2160
|
|
|
2158
|
-
exports.$Command = client.Command;
|
|
2159
|
-
exports.__Client = client.Client;
|
|
2160
|
-
exports.MediaConnectServiceException = MediaConnectServiceException.MediaConnectServiceException;
|
|
2161
2161
|
exports.AddBridgeOutputsCommand = AddBridgeOutputsCommand;
|
|
2162
2162
|
exports.AddBridgeSourcesCommand = AddBridgeSourcesCommand;
|
|
2163
2163
|
exports.AddFlowMediaStreamsCommand = AddFlowMediaStreamsCommand;
|
|
@@ -2330,23 +2330,3 @@ exports.waitUntilOutputDeleted = waitUntilOutputDeleted;
|
|
|
2330
2330
|
exports.waitUntilOutputRouted = waitUntilOutputRouted;
|
|
2331
2331
|
exports.waitUntilOutputStandby = waitUntilOutputStandby;
|
|
2332
2332
|
exports.waitUntilOutputUnrouted = waitUntilOutputUnrouted;
|
|
2333
|
-
Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
|
|
2334
|
-
!Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
|
|
2335
|
-
Object.defineProperty(exports, '__proto__', {
|
|
2336
|
-
enumerable: true,
|
|
2337
|
-
value: schemas_0['__proto__']
|
|
2338
|
-
});
|
|
2339
|
-
|
|
2340
|
-
Object.keys(schemas_0).forEach(function (k) {
|
|
2341
|
-
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
|
|
2342
|
-
});
|
|
2343
|
-
Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
|
|
2344
|
-
!Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
|
|
2345
|
-
Object.defineProperty(exports, '__proto__', {
|
|
2346
|
-
enumerable: true,
|
|
2347
|
-
value: errors['__proto__']
|
|
2348
|
-
});
|
|
2349
|
-
|
|
2350
|
-
Object.keys(errors).forEach(function (k) {
|
|
2351
|
-
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
|
|
2352
|
-
});
|