@aws-sdk/client-medialive 3.1068.0 → 3.1070.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 +641 -661
- package/dist-cjs/models/MediaLiveServiceException.js +4 -8
- package/dist-cjs/models/errors.js +19 -31
- 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 +21 -25
- package/dist-cjs/schemas/schemas_0.js +1627 -1041
- 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, defaultMediaLiveHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
|
|
13
|
+
const { getRuntimeConfig } = require("./runtimeConfig");
|
|
14
|
+
const { AcceptInputDeviceTransfer$, BatchDelete$, BatchStart$, BatchStop$, BatchUpdateSchedule$, CancelInputDeviceTransfer$, ClaimDevice$, CreateChannel$, CreateChannelPlacementGroup$, CreateCloudWatchAlarmTemplate$, CreateCloudWatchAlarmTemplateGroup$, CreateCluster$, CreateEventBridgeRuleTemplate$, CreateEventBridgeRuleTemplateGroup$, CreateInput$, CreateInputSecurityGroup$, CreateMultiplex$, CreateMultiplexProgram$, CreateNetwork$, CreateNode$, CreateNodeRegistrationScript$, CreatePartnerInput$, CreateSdiSource$, CreateSignalMap$, CreateTags$, DeleteChannel$, DeleteChannelPlacementGroup$, DeleteCloudWatchAlarmTemplate$, DeleteCloudWatchAlarmTemplateGroup$, DeleteCluster$, DeleteEventBridgeRuleTemplate$, DeleteEventBridgeRuleTemplateGroup$, DeleteInput$, DeleteInputSecurityGroup$, DeleteMultiplex$, DeleteMultiplexProgram$, DeleteNetwork$, DeleteNode$, DeleteReservation$, DeleteSchedule$, DeleteSdiSource$, DeleteSignalMap$, DeleteTags$, DescribeAccountConfiguration$, DescribeChannel$, DescribeChannelPlacementGroup$, DescribeCluster$, DescribeInput$, DescribeInputDevice$, DescribeInputDeviceThumbnail$, DescribeInputSecurityGroup$, DescribeMultiplex$, DescribeMultiplexProgram$, DescribeNetwork$, DescribeNode$, DescribeOffering$, DescribeReservation$, DescribeSchedule$, DescribeSdiSource$, DescribeThumbnails$, GetCloudWatchAlarmTemplate$, GetCloudWatchAlarmTemplateGroup$, GetEventBridgeRuleTemplate$, GetEventBridgeRuleTemplateGroup$, GetSignalMap$, ListAlerts$, ListChannelPlacementGroups$, ListChannels$, ListCloudWatchAlarmTemplateGroups$, ListCloudWatchAlarmTemplates$, ListClusterAlerts$, ListClusters$, ListEventBridgeRuleTemplateGroups$, ListEventBridgeRuleTemplates$, ListInputDevices$, ListInputDeviceTransfers$, ListInputs$, ListInputSecurityGroups$, ListMultiplexAlerts$, ListMultiplexes$, ListMultiplexPrograms$, ListNetworks$, ListNodes$, ListOfferings$, ListReservations$, ListSdiSources$, ListSignalMaps$, ListTagsForResource$, ListVersions$, PurchaseOffering$, RebootInputDevice$, RejectInputDeviceTransfer$, RestartChannelPipelines$, StartChannel$, StartDeleteMonitorDeployment$, StartInputDevice$, StartInputDeviceMaintenanceWindow$, StartMonitorDeployment$, StartMultiplex$, StartUpdateSignalMap$, StopChannel$, StopInputDevice$, StopMultiplex$, TransferInputDevice$, UpdateAccountConfiguration$, UpdateChannelClass$, UpdateChannel$, UpdateChannelPlacementGroup$, UpdateCloudWatchAlarmTemplate$, UpdateCloudWatchAlarmTemplateGroup$, UpdateCluster$, UpdateEventBridgeRuleTemplate$, UpdateEventBridgeRuleTemplateGroup$, UpdateInput$, UpdateInputDevice$, UpdateInputSecurityGroup$, UpdateMultiplex$, UpdateMultiplexProgram$, UpdateNetwork$, UpdateNode$, UpdateNodeState$, UpdateReservation$, UpdateSdiSource$ } = require("./schemas/schemas_0");
|
|
15
|
+
__exportStar(require("./schemas/schemas_0"), exports);
|
|
16
|
+
__exportStar(require("./models/errors"), exports);
|
|
17
|
+
const { MediaLiveServiceException } = require("./models/MediaLiveServiceException");
|
|
18
|
+
exports.MediaLiveServiceException = MediaLiveServiceException;
|
|
16
19
|
|
|
17
20
|
const resolveClientEndpointParameters = (options) => {
|
|
18
21
|
return Object.assign(options, {
|
|
@@ -68,1579 +71,1579 @@ 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 MediaLiveClient extends
|
|
79
|
+
class MediaLiveClient 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: defaultMediaLiveHttpAuthSchemeParametersProvider,
|
|
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 AcceptInputDeviceTransferCommand extends
|
|
114
|
+
class AcceptInputDeviceTransferCommand 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("MediaLive", "AcceptInputDeviceTransfer", {})
|
|
118
121
|
.n("MediaLiveClient", "AcceptInputDeviceTransferCommand")
|
|
119
|
-
.sc(
|
|
122
|
+
.sc(AcceptInputDeviceTransfer$)
|
|
120
123
|
.build() {
|
|
121
124
|
}
|
|
122
125
|
|
|
123
|
-
class BatchDeleteCommand extends
|
|
126
|
+
class BatchDeleteCommand 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("MediaLive", "BatchDelete", {})
|
|
130
133
|
.n("MediaLiveClient", "BatchDeleteCommand")
|
|
131
|
-
.sc(
|
|
134
|
+
.sc(BatchDelete$)
|
|
132
135
|
.build() {
|
|
133
136
|
}
|
|
134
137
|
|
|
135
|
-
class BatchStartCommand extends
|
|
138
|
+
class BatchStartCommand 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("MediaLive", "BatchStart", {})
|
|
142
145
|
.n("MediaLiveClient", "BatchStartCommand")
|
|
143
|
-
.sc(
|
|
146
|
+
.sc(BatchStart$)
|
|
144
147
|
.build() {
|
|
145
148
|
}
|
|
146
149
|
|
|
147
|
-
class BatchStopCommand extends
|
|
150
|
+
class BatchStopCommand 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("MediaLive", "BatchStop", {})
|
|
154
157
|
.n("MediaLiveClient", "BatchStopCommand")
|
|
155
|
-
.sc(
|
|
158
|
+
.sc(BatchStop$)
|
|
156
159
|
.build() {
|
|
157
160
|
}
|
|
158
161
|
|
|
159
|
-
class BatchUpdateScheduleCommand extends
|
|
162
|
+
class BatchUpdateScheduleCommand 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("MediaLive", "BatchUpdateSchedule", {})
|
|
166
169
|
.n("MediaLiveClient", "BatchUpdateScheduleCommand")
|
|
167
|
-
.sc(
|
|
170
|
+
.sc(BatchUpdateSchedule$)
|
|
168
171
|
.build() {
|
|
169
172
|
}
|
|
170
173
|
|
|
171
|
-
class CancelInputDeviceTransferCommand extends
|
|
174
|
+
class CancelInputDeviceTransferCommand 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("MediaLive", "CancelInputDeviceTransfer", {})
|
|
178
181
|
.n("MediaLiveClient", "CancelInputDeviceTransferCommand")
|
|
179
|
-
.sc(
|
|
182
|
+
.sc(CancelInputDeviceTransfer$)
|
|
180
183
|
.build() {
|
|
181
184
|
}
|
|
182
185
|
|
|
183
|
-
class ClaimDeviceCommand extends
|
|
186
|
+
class ClaimDeviceCommand 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("MediaLive", "ClaimDevice", {})
|
|
190
193
|
.n("MediaLiveClient", "ClaimDeviceCommand")
|
|
191
|
-
.sc(
|
|
194
|
+
.sc(ClaimDevice$)
|
|
192
195
|
.build() {
|
|
193
196
|
}
|
|
194
197
|
|
|
195
|
-
class CreateChannelCommand extends
|
|
198
|
+
class CreateChannelCommand 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("MediaLive", "CreateChannel", {})
|
|
202
205
|
.n("MediaLiveClient", "CreateChannelCommand")
|
|
203
|
-
.sc(
|
|
206
|
+
.sc(CreateChannel$)
|
|
204
207
|
.build() {
|
|
205
208
|
}
|
|
206
209
|
|
|
207
|
-
class CreateChannelPlacementGroupCommand extends
|
|
210
|
+
class CreateChannelPlacementGroupCommand 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("MediaLive", "CreateChannelPlacementGroup", {})
|
|
214
217
|
.n("MediaLiveClient", "CreateChannelPlacementGroupCommand")
|
|
215
|
-
.sc(
|
|
218
|
+
.sc(CreateChannelPlacementGroup$)
|
|
216
219
|
.build() {
|
|
217
220
|
}
|
|
218
221
|
|
|
219
|
-
class CreateCloudWatchAlarmTemplateCommand extends
|
|
222
|
+
class CreateCloudWatchAlarmTemplateCommand 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("MediaLive", "CreateCloudWatchAlarmTemplate", {})
|
|
226
229
|
.n("MediaLiveClient", "CreateCloudWatchAlarmTemplateCommand")
|
|
227
|
-
.sc(
|
|
230
|
+
.sc(CreateCloudWatchAlarmTemplate$)
|
|
228
231
|
.build() {
|
|
229
232
|
}
|
|
230
233
|
|
|
231
|
-
class CreateCloudWatchAlarmTemplateGroupCommand extends
|
|
234
|
+
class CreateCloudWatchAlarmTemplateGroupCommand 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("MediaLive", "CreateCloudWatchAlarmTemplateGroup", {})
|
|
238
241
|
.n("MediaLiveClient", "CreateCloudWatchAlarmTemplateGroupCommand")
|
|
239
|
-
.sc(
|
|
242
|
+
.sc(CreateCloudWatchAlarmTemplateGroup$)
|
|
240
243
|
.build() {
|
|
241
244
|
}
|
|
242
245
|
|
|
243
|
-
class CreateClusterCommand extends
|
|
246
|
+
class CreateClusterCommand 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("MediaLive", "CreateCluster", {})
|
|
250
253
|
.n("MediaLiveClient", "CreateClusterCommand")
|
|
251
|
-
.sc(
|
|
254
|
+
.sc(CreateCluster$)
|
|
252
255
|
.build() {
|
|
253
256
|
}
|
|
254
257
|
|
|
255
|
-
class CreateEventBridgeRuleTemplateCommand extends
|
|
258
|
+
class CreateEventBridgeRuleTemplateCommand 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("MediaLive", "CreateEventBridgeRuleTemplate", {})
|
|
262
265
|
.n("MediaLiveClient", "CreateEventBridgeRuleTemplateCommand")
|
|
263
|
-
.sc(
|
|
266
|
+
.sc(CreateEventBridgeRuleTemplate$)
|
|
264
267
|
.build() {
|
|
265
268
|
}
|
|
266
269
|
|
|
267
|
-
class CreateEventBridgeRuleTemplateGroupCommand extends
|
|
270
|
+
class CreateEventBridgeRuleTemplateGroupCommand 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("MediaLive", "CreateEventBridgeRuleTemplateGroup", {})
|
|
274
277
|
.n("MediaLiveClient", "CreateEventBridgeRuleTemplateGroupCommand")
|
|
275
|
-
.sc(
|
|
278
|
+
.sc(CreateEventBridgeRuleTemplateGroup$)
|
|
276
279
|
.build() {
|
|
277
280
|
}
|
|
278
281
|
|
|
279
|
-
class CreateInputCommand extends
|
|
282
|
+
class CreateInputCommand 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("MediaLive", "CreateInput", {})
|
|
286
289
|
.n("MediaLiveClient", "CreateInputCommand")
|
|
287
|
-
.sc(
|
|
290
|
+
.sc(CreateInput$)
|
|
288
291
|
.build() {
|
|
289
292
|
}
|
|
290
293
|
|
|
291
|
-
class CreateInputSecurityGroupCommand extends
|
|
294
|
+
class CreateInputSecurityGroupCommand 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("MediaLive", "CreateInputSecurityGroup", {})
|
|
298
301
|
.n("MediaLiveClient", "CreateInputSecurityGroupCommand")
|
|
299
|
-
.sc(
|
|
302
|
+
.sc(CreateInputSecurityGroup$)
|
|
300
303
|
.build() {
|
|
301
304
|
}
|
|
302
305
|
|
|
303
|
-
class CreateMultiplexCommand extends
|
|
306
|
+
class CreateMultiplexCommand 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("MediaLive", "CreateMultiplex", {})
|
|
310
313
|
.n("MediaLiveClient", "CreateMultiplexCommand")
|
|
311
|
-
.sc(
|
|
314
|
+
.sc(CreateMultiplex$)
|
|
312
315
|
.build() {
|
|
313
316
|
}
|
|
314
317
|
|
|
315
|
-
class CreateMultiplexProgramCommand extends
|
|
318
|
+
class CreateMultiplexProgramCommand 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("MediaLive", "CreateMultiplexProgram", {})
|
|
322
325
|
.n("MediaLiveClient", "CreateMultiplexProgramCommand")
|
|
323
|
-
.sc(
|
|
326
|
+
.sc(CreateMultiplexProgram$)
|
|
324
327
|
.build() {
|
|
325
328
|
}
|
|
326
329
|
|
|
327
|
-
class CreateNetworkCommand extends
|
|
330
|
+
class CreateNetworkCommand 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("MediaLive", "CreateNetwork", {})
|
|
334
337
|
.n("MediaLiveClient", "CreateNetworkCommand")
|
|
335
|
-
.sc(
|
|
338
|
+
.sc(CreateNetwork$)
|
|
336
339
|
.build() {
|
|
337
340
|
}
|
|
338
341
|
|
|
339
|
-
class CreateNodeCommand extends
|
|
342
|
+
class CreateNodeCommand 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("MediaLive", "CreateNode", {})
|
|
346
349
|
.n("MediaLiveClient", "CreateNodeCommand")
|
|
347
|
-
.sc(
|
|
350
|
+
.sc(CreateNode$)
|
|
348
351
|
.build() {
|
|
349
352
|
}
|
|
350
353
|
|
|
351
|
-
class CreateNodeRegistrationScriptCommand extends
|
|
354
|
+
class CreateNodeRegistrationScriptCommand 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("MediaLive", "CreateNodeRegistrationScript", {})
|
|
358
361
|
.n("MediaLiveClient", "CreateNodeRegistrationScriptCommand")
|
|
359
|
-
.sc(
|
|
362
|
+
.sc(CreateNodeRegistrationScript$)
|
|
360
363
|
.build() {
|
|
361
364
|
}
|
|
362
365
|
|
|
363
|
-
class CreatePartnerInputCommand extends
|
|
366
|
+
class CreatePartnerInputCommand 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("MediaLive", "CreatePartnerInput", {})
|
|
370
373
|
.n("MediaLiveClient", "CreatePartnerInputCommand")
|
|
371
|
-
.sc(
|
|
374
|
+
.sc(CreatePartnerInput$)
|
|
372
375
|
.build() {
|
|
373
376
|
}
|
|
374
377
|
|
|
375
|
-
class CreateSdiSourceCommand extends
|
|
378
|
+
class CreateSdiSourceCommand 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("MediaLive", "CreateSdiSource", {})
|
|
382
385
|
.n("MediaLiveClient", "CreateSdiSourceCommand")
|
|
383
|
-
.sc(
|
|
386
|
+
.sc(CreateSdiSource$)
|
|
384
387
|
.build() {
|
|
385
388
|
}
|
|
386
389
|
|
|
387
|
-
class CreateSignalMapCommand extends
|
|
390
|
+
class CreateSignalMapCommand 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("MediaLive", "CreateSignalMap", {})
|
|
394
397
|
.n("MediaLiveClient", "CreateSignalMapCommand")
|
|
395
|
-
.sc(
|
|
398
|
+
.sc(CreateSignalMap$)
|
|
396
399
|
.build() {
|
|
397
400
|
}
|
|
398
401
|
|
|
399
|
-
class CreateTagsCommand extends
|
|
402
|
+
class CreateTagsCommand 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("MediaLive", "CreateTags", {})
|
|
406
409
|
.n("MediaLiveClient", "CreateTagsCommand")
|
|
407
|
-
.sc(
|
|
410
|
+
.sc(CreateTags$)
|
|
408
411
|
.build() {
|
|
409
412
|
}
|
|
410
413
|
|
|
411
|
-
class DeleteChannelCommand extends
|
|
414
|
+
class DeleteChannelCommand 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("MediaLive", "DeleteChannel", {})
|
|
418
421
|
.n("MediaLiveClient", "DeleteChannelCommand")
|
|
419
|
-
.sc(
|
|
422
|
+
.sc(DeleteChannel$)
|
|
420
423
|
.build() {
|
|
421
424
|
}
|
|
422
425
|
|
|
423
|
-
class DeleteChannelPlacementGroupCommand extends
|
|
426
|
+
class DeleteChannelPlacementGroupCommand 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("MediaLive", "DeleteChannelPlacementGroup", {})
|
|
430
433
|
.n("MediaLiveClient", "DeleteChannelPlacementGroupCommand")
|
|
431
|
-
.sc(
|
|
434
|
+
.sc(DeleteChannelPlacementGroup$)
|
|
432
435
|
.build() {
|
|
433
436
|
}
|
|
434
437
|
|
|
435
|
-
class DeleteCloudWatchAlarmTemplateCommand extends
|
|
438
|
+
class DeleteCloudWatchAlarmTemplateCommand 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("MediaLive", "DeleteCloudWatchAlarmTemplate", {})
|
|
442
445
|
.n("MediaLiveClient", "DeleteCloudWatchAlarmTemplateCommand")
|
|
443
|
-
.sc(
|
|
446
|
+
.sc(DeleteCloudWatchAlarmTemplate$)
|
|
444
447
|
.build() {
|
|
445
448
|
}
|
|
446
449
|
|
|
447
|
-
class DeleteCloudWatchAlarmTemplateGroupCommand extends
|
|
450
|
+
class DeleteCloudWatchAlarmTemplateGroupCommand 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("MediaLive", "DeleteCloudWatchAlarmTemplateGroup", {})
|
|
454
457
|
.n("MediaLiveClient", "DeleteCloudWatchAlarmTemplateGroupCommand")
|
|
455
|
-
.sc(
|
|
458
|
+
.sc(DeleteCloudWatchAlarmTemplateGroup$)
|
|
456
459
|
.build() {
|
|
457
460
|
}
|
|
458
461
|
|
|
459
|
-
class DeleteClusterCommand extends
|
|
462
|
+
class DeleteClusterCommand 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("MediaLive", "DeleteCluster", {})
|
|
466
469
|
.n("MediaLiveClient", "DeleteClusterCommand")
|
|
467
|
-
.sc(
|
|
470
|
+
.sc(DeleteCluster$)
|
|
468
471
|
.build() {
|
|
469
472
|
}
|
|
470
473
|
|
|
471
|
-
class DeleteEventBridgeRuleTemplateCommand extends
|
|
474
|
+
class DeleteEventBridgeRuleTemplateCommand 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("MediaLive", "DeleteEventBridgeRuleTemplate", {})
|
|
478
481
|
.n("MediaLiveClient", "DeleteEventBridgeRuleTemplateCommand")
|
|
479
|
-
.sc(
|
|
482
|
+
.sc(DeleteEventBridgeRuleTemplate$)
|
|
480
483
|
.build() {
|
|
481
484
|
}
|
|
482
485
|
|
|
483
|
-
class DeleteEventBridgeRuleTemplateGroupCommand extends
|
|
486
|
+
class DeleteEventBridgeRuleTemplateGroupCommand 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("MediaLive", "DeleteEventBridgeRuleTemplateGroup", {})
|
|
490
493
|
.n("MediaLiveClient", "DeleteEventBridgeRuleTemplateGroupCommand")
|
|
491
|
-
.sc(
|
|
494
|
+
.sc(DeleteEventBridgeRuleTemplateGroup$)
|
|
492
495
|
.build() {
|
|
493
496
|
}
|
|
494
497
|
|
|
495
|
-
class DeleteInputCommand extends
|
|
498
|
+
class DeleteInputCommand 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("MediaLive", "DeleteInput", {})
|
|
502
505
|
.n("MediaLiveClient", "DeleteInputCommand")
|
|
503
|
-
.sc(
|
|
506
|
+
.sc(DeleteInput$)
|
|
504
507
|
.build() {
|
|
505
508
|
}
|
|
506
509
|
|
|
507
|
-
class DeleteInputSecurityGroupCommand extends
|
|
510
|
+
class DeleteInputSecurityGroupCommand 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("MediaLive", "DeleteInputSecurityGroup", {})
|
|
514
517
|
.n("MediaLiveClient", "DeleteInputSecurityGroupCommand")
|
|
515
|
-
.sc(
|
|
518
|
+
.sc(DeleteInputSecurityGroup$)
|
|
516
519
|
.build() {
|
|
517
520
|
}
|
|
518
521
|
|
|
519
|
-
class DeleteMultiplexCommand extends
|
|
522
|
+
class DeleteMultiplexCommand 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("MediaLive", "DeleteMultiplex", {})
|
|
526
529
|
.n("MediaLiveClient", "DeleteMultiplexCommand")
|
|
527
|
-
.sc(
|
|
530
|
+
.sc(DeleteMultiplex$)
|
|
528
531
|
.build() {
|
|
529
532
|
}
|
|
530
533
|
|
|
531
|
-
class DeleteMultiplexProgramCommand extends
|
|
534
|
+
class DeleteMultiplexProgramCommand 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("MediaLive", "DeleteMultiplexProgram", {})
|
|
538
541
|
.n("MediaLiveClient", "DeleteMultiplexProgramCommand")
|
|
539
|
-
.sc(
|
|
542
|
+
.sc(DeleteMultiplexProgram$)
|
|
540
543
|
.build() {
|
|
541
544
|
}
|
|
542
545
|
|
|
543
|
-
class DeleteNetworkCommand extends
|
|
546
|
+
class DeleteNetworkCommand 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("MediaLive", "DeleteNetwork", {})
|
|
550
553
|
.n("MediaLiveClient", "DeleteNetworkCommand")
|
|
551
|
-
.sc(
|
|
554
|
+
.sc(DeleteNetwork$)
|
|
552
555
|
.build() {
|
|
553
556
|
}
|
|
554
557
|
|
|
555
|
-
class DeleteNodeCommand extends
|
|
558
|
+
class DeleteNodeCommand 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("MediaLive", "DeleteNode", {})
|
|
562
565
|
.n("MediaLiveClient", "DeleteNodeCommand")
|
|
563
|
-
.sc(
|
|
566
|
+
.sc(DeleteNode$)
|
|
564
567
|
.build() {
|
|
565
568
|
}
|
|
566
569
|
|
|
567
|
-
class DeleteReservationCommand extends
|
|
570
|
+
class DeleteReservationCommand 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("MediaLive", "DeleteReservation", {})
|
|
574
577
|
.n("MediaLiveClient", "DeleteReservationCommand")
|
|
575
|
-
.sc(
|
|
578
|
+
.sc(DeleteReservation$)
|
|
576
579
|
.build() {
|
|
577
580
|
}
|
|
578
581
|
|
|
579
|
-
class DeleteScheduleCommand extends
|
|
582
|
+
class DeleteScheduleCommand 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("MediaLive", "DeleteSchedule", {})
|
|
586
589
|
.n("MediaLiveClient", "DeleteScheduleCommand")
|
|
587
|
-
.sc(
|
|
590
|
+
.sc(DeleteSchedule$)
|
|
588
591
|
.build() {
|
|
589
592
|
}
|
|
590
593
|
|
|
591
|
-
class DeleteSdiSourceCommand extends
|
|
594
|
+
class DeleteSdiSourceCommand 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("MediaLive", "DeleteSdiSource", {})
|
|
598
601
|
.n("MediaLiveClient", "DeleteSdiSourceCommand")
|
|
599
|
-
.sc(
|
|
602
|
+
.sc(DeleteSdiSource$)
|
|
600
603
|
.build() {
|
|
601
604
|
}
|
|
602
605
|
|
|
603
|
-
class DeleteSignalMapCommand extends
|
|
606
|
+
class DeleteSignalMapCommand 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("MediaLive", "DeleteSignalMap", {})
|
|
610
613
|
.n("MediaLiveClient", "DeleteSignalMapCommand")
|
|
611
|
-
.sc(
|
|
614
|
+
.sc(DeleteSignalMap$)
|
|
612
615
|
.build() {
|
|
613
616
|
}
|
|
614
617
|
|
|
615
|
-
class DeleteTagsCommand extends
|
|
618
|
+
class DeleteTagsCommand 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("MediaLive", "DeleteTags", {})
|
|
622
625
|
.n("MediaLiveClient", "DeleteTagsCommand")
|
|
623
|
-
.sc(
|
|
626
|
+
.sc(DeleteTags$)
|
|
624
627
|
.build() {
|
|
625
628
|
}
|
|
626
629
|
|
|
627
|
-
class DescribeAccountConfigurationCommand extends
|
|
630
|
+
class DescribeAccountConfigurationCommand 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("MediaLive", "DescribeAccountConfiguration", {})
|
|
634
637
|
.n("MediaLiveClient", "DescribeAccountConfigurationCommand")
|
|
635
|
-
.sc(
|
|
638
|
+
.sc(DescribeAccountConfiguration$)
|
|
636
639
|
.build() {
|
|
637
640
|
}
|
|
638
641
|
|
|
639
|
-
class DescribeChannelCommand extends
|
|
642
|
+
class DescribeChannelCommand 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("MediaLive", "DescribeChannel", {})
|
|
646
649
|
.n("MediaLiveClient", "DescribeChannelCommand")
|
|
647
|
-
.sc(
|
|
650
|
+
.sc(DescribeChannel$)
|
|
648
651
|
.build() {
|
|
649
652
|
}
|
|
650
653
|
|
|
651
|
-
class DescribeChannelPlacementGroupCommand extends
|
|
654
|
+
class DescribeChannelPlacementGroupCommand 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("MediaLive", "DescribeChannelPlacementGroup", {})
|
|
658
661
|
.n("MediaLiveClient", "DescribeChannelPlacementGroupCommand")
|
|
659
|
-
.sc(
|
|
662
|
+
.sc(DescribeChannelPlacementGroup$)
|
|
660
663
|
.build() {
|
|
661
664
|
}
|
|
662
665
|
|
|
663
|
-
class DescribeClusterCommand extends
|
|
666
|
+
class DescribeClusterCommand 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("MediaLive", "DescribeCluster", {})
|
|
670
673
|
.n("MediaLiveClient", "DescribeClusterCommand")
|
|
671
|
-
.sc(
|
|
674
|
+
.sc(DescribeCluster$)
|
|
672
675
|
.build() {
|
|
673
676
|
}
|
|
674
677
|
|
|
675
|
-
class DescribeInputCommand extends
|
|
678
|
+
class DescribeInputCommand 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("MediaLive", "DescribeInput", {})
|
|
682
685
|
.n("MediaLiveClient", "DescribeInputCommand")
|
|
683
|
-
.sc(
|
|
686
|
+
.sc(DescribeInput$)
|
|
684
687
|
.build() {
|
|
685
688
|
}
|
|
686
689
|
|
|
687
|
-
class DescribeInputDeviceCommand extends
|
|
690
|
+
class DescribeInputDeviceCommand 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("MediaLive", "DescribeInputDevice", {})
|
|
694
697
|
.n("MediaLiveClient", "DescribeInputDeviceCommand")
|
|
695
|
-
.sc(
|
|
698
|
+
.sc(DescribeInputDevice$)
|
|
696
699
|
.build() {
|
|
697
700
|
}
|
|
698
701
|
|
|
699
|
-
class DescribeInputDeviceThumbnailCommand extends
|
|
702
|
+
class DescribeInputDeviceThumbnailCommand 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("MediaLive", "DescribeInputDeviceThumbnail", {})
|
|
706
709
|
.n("MediaLiveClient", "DescribeInputDeviceThumbnailCommand")
|
|
707
|
-
.sc(
|
|
710
|
+
.sc(DescribeInputDeviceThumbnail$)
|
|
708
711
|
.build() {
|
|
709
712
|
}
|
|
710
713
|
|
|
711
|
-
class DescribeInputSecurityGroupCommand extends
|
|
714
|
+
class DescribeInputSecurityGroupCommand 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("MediaLive", "DescribeInputSecurityGroup", {})
|
|
718
721
|
.n("MediaLiveClient", "DescribeInputSecurityGroupCommand")
|
|
719
|
-
.sc(
|
|
722
|
+
.sc(DescribeInputSecurityGroup$)
|
|
720
723
|
.build() {
|
|
721
724
|
}
|
|
722
725
|
|
|
723
|
-
class DescribeMultiplexCommand extends
|
|
726
|
+
class DescribeMultiplexCommand 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("MediaLive", "DescribeMultiplex", {})
|
|
730
733
|
.n("MediaLiveClient", "DescribeMultiplexCommand")
|
|
731
|
-
.sc(
|
|
734
|
+
.sc(DescribeMultiplex$)
|
|
732
735
|
.build() {
|
|
733
736
|
}
|
|
734
737
|
|
|
735
|
-
class DescribeMultiplexProgramCommand extends
|
|
738
|
+
class DescribeMultiplexProgramCommand 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("MediaLive", "DescribeMultiplexProgram", {})
|
|
742
745
|
.n("MediaLiveClient", "DescribeMultiplexProgramCommand")
|
|
743
|
-
.sc(
|
|
746
|
+
.sc(DescribeMultiplexProgram$)
|
|
744
747
|
.build() {
|
|
745
748
|
}
|
|
746
749
|
|
|
747
|
-
class DescribeNetworkCommand extends
|
|
750
|
+
class DescribeNetworkCommand 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("MediaLive", "DescribeNetwork", {})
|
|
754
757
|
.n("MediaLiveClient", "DescribeNetworkCommand")
|
|
755
|
-
.sc(
|
|
758
|
+
.sc(DescribeNetwork$)
|
|
756
759
|
.build() {
|
|
757
760
|
}
|
|
758
761
|
|
|
759
|
-
class DescribeNodeCommand extends
|
|
762
|
+
class DescribeNodeCommand 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("MediaLive", "DescribeNode", {})
|
|
766
769
|
.n("MediaLiveClient", "DescribeNodeCommand")
|
|
767
|
-
.sc(
|
|
770
|
+
.sc(DescribeNode$)
|
|
768
771
|
.build() {
|
|
769
772
|
}
|
|
770
773
|
|
|
771
|
-
class DescribeOfferingCommand extends
|
|
774
|
+
class DescribeOfferingCommand 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("MediaLive", "DescribeOffering", {})
|
|
778
781
|
.n("MediaLiveClient", "DescribeOfferingCommand")
|
|
779
|
-
.sc(
|
|
782
|
+
.sc(DescribeOffering$)
|
|
780
783
|
.build() {
|
|
781
784
|
}
|
|
782
785
|
|
|
783
|
-
class DescribeReservationCommand extends
|
|
786
|
+
class DescribeReservationCommand 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("MediaLive", "DescribeReservation", {})
|
|
790
793
|
.n("MediaLiveClient", "DescribeReservationCommand")
|
|
791
|
-
.sc(
|
|
794
|
+
.sc(DescribeReservation$)
|
|
792
795
|
.build() {
|
|
793
796
|
}
|
|
794
797
|
|
|
795
|
-
class DescribeScheduleCommand extends
|
|
798
|
+
class DescribeScheduleCommand 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("MediaLive", "DescribeSchedule", {})
|
|
802
805
|
.n("MediaLiveClient", "DescribeScheduleCommand")
|
|
803
|
-
.sc(
|
|
806
|
+
.sc(DescribeSchedule$)
|
|
804
807
|
.build() {
|
|
805
808
|
}
|
|
806
809
|
|
|
807
|
-
class DescribeSdiSourceCommand extends
|
|
810
|
+
class DescribeSdiSourceCommand 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("MediaLive", "DescribeSdiSource", {})
|
|
814
817
|
.n("MediaLiveClient", "DescribeSdiSourceCommand")
|
|
815
|
-
.sc(
|
|
818
|
+
.sc(DescribeSdiSource$)
|
|
816
819
|
.build() {
|
|
817
820
|
}
|
|
818
821
|
|
|
819
|
-
class DescribeThumbnailsCommand extends
|
|
822
|
+
class DescribeThumbnailsCommand 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("MediaLive", "DescribeThumbnails", {})
|
|
826
829
|
.n("MediaLiveClient", "DescribeThumbnailsCommand")
|
|
827
|
-
.sc(
|
|
830
|
+
.sc(DescribeThumbnails$)
|
|
828
831
|
.build() {
|
|
829
832
|
}
|
|
830
833
|
|
|
831
|
-
class GetCloudWatchAlarmTemplateCommand extends
|
|
834
|
+
class GetCloudWatchAlarmTemplateCommand 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("MediaLive", "GetCloudWatchAlarmTemplate", {})
|
|
838
841
|
.n("MediaLiveClient", "GetCloudWatchAlarmTemplateCommand")
|
|
839
|
-
.sc(
|
|
842
|
+
.sc(GetCloudWatchAlarmTemplate$)
|
|
840
843
|
.build() {
|
|
841
844
|
}
|
|
842
845
|
|
|
843
|
-
class GetCloudWatchAlarmTemplateGroupCommand extends
|
|
846
|
+
class GetCloudWatchAlarmTemplateGroupCommand 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("MediaLive", "GetCloudWatchAlarmTemplateGroup", {})
|
|
850
853
|
.n("MediaLiveClient", "GetCloudWatchAlarmTemplateGroupCommand")
|
|
851
|
-
.sc(
|
|
854
|
+
.sc(GetCloudWatchAlarmTemplateGroup$)
|
|
852
855
|
.build() {
|
|
853
856
|
}
|
|
854
857
|
|
|
855
|
-
class GetEventBridgeRuleTemplateCommand extends
|
|
858
|
+
class GetEventBridgeRuleTemplateCommand 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("MediaLive", "GetEventBridgeRuleTemplate", {})
|
|
862
865
|
.n("MediaLiveClient", "GetEventBridgeRuleTemplateCommand")
|
|
863
|
-
.sc(
|
|
866
|
+
.sc(GetEventBridgeRuleTemplate$)
|
|
864
867
|
.build() {
|
|
865
868
|
}
|
|
866
869
|
|
|
867
|
-
class GetEventBridgeRuleTemplateGroupCommand extends
|
|
870
|
+
class GetEventBridgeRuleTemplateGroupCommand 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("MediaLive", "GetEventBridgeRuleTemplateGroup", {})
|
|
874
877
|
.n("MediaLiveClient", "GetEventBridgeRuleTemplateGroupCommand")
|
|
875
|
-
.sc(
|
|
878
|
+
.sc(GetEventBridgeRuleTemplateGroup$)
|
|
876
879
|
.build() {
|
|
877
880
|
}
|
|
878
881
|
|
|
879
|
-
class GetSignalMapCommand extends
|
|
882
|
+
class GetSignalMapCommand 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("MediaLive", "GetSignalMap", {})
|
|
886
889
|
.n("MediaLiveClient", "GetSignalMapCommand")
|
|
887
|
-
.sc(
|
|
890
|
+
.sc(GetSignalMap$)
|
|
888
891
|
.build() {
|
|
889
892
|
}
|
|
890
893
|
|
|
891
|
-
class ListAlertsCommand extends
|
|
894
|
+
class ListAlertsCommand 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("MediaLive", "ListAlerts", {})
|
|
898
901
|
.n("MediaLiveClient", "ListAlertsCommand")
|
|
899
|
-
.sc(
|
|
902
|
+
.sc(ListAlerts$)
|
|
900
903
|
.build() {
|
|
901
904
|
}
|
|
902
905
|
|
|
903
|
-
class ListChannelPlacementGroupsCommand extends
|
|
906
|
+
class ListChannelPlacementGroupsCommand 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("MediaLive", "ListChannelPlacementGroups", {})
|
|
910
913
|
.n("MediaLiveClient", "ListChannelPlacementGroupsCommand")
|
|
911
|
-
.sc(
|
|
914
|
+
.sc(ListChannelPlacementGroups$)
|
|
912
915
|
.build() {
|
|
913
916
|
}
|
|
914
917
|
|
|
915
|
-
class ListChannelsCommand extends
|
|
918
|
+
class ListChannelsCommand 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("MediaLive", "ListChannels", {})
|
|
922
925
|
.n("MediaLiveClient", "ListChannelsCommand")
|
|
923
|
-
.sc(
|
|
926
|
+
.sc(ListChannels$)
|
|
924
927
|
.build() {
|
|
925
928
|
}
|
|
926
929
|
|
|
927
|
-
class ListCloudWatchAlarmTemplateGroupsCommand extends
|
|
930
|
+
class ListCloudWatchAlarmTemplateGroupsCommand 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("MediaLive", "ListCloudWatchAlarmTemplateGroups", {})
|
|
934
937
|
.n("MediaLiveClient", "ListCloudWatchAlarmTemplateGroupsCommand")
|
|
935
|
-
.sc(
|
|
938
|
+
.sc(ListCloudWatchAlarmTemplateGroups$)
|
|
936
939
|
.build() {
|
|
937
940
|
}
|
|
938
941
|
|
|
939
|
-
class ListCloudWatchAlarmTemplatesCommand extends
|
|
942
|
+
class ListCloudWatchAlarmTemplatesCommand 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("MediaLive", "ListCloudWatchAlarmTemplates", {})
|
|
946
949
|
.n("MediaLiveClient", "ListCloudWatchAlarmTemplatesCommand")
|
|
947
|
-
.sc(
|
|
950
|
+
.sc(ListCloudWatchAlarmTemplates$)
|
|
948
951
|
.build() {
|
|
949
952
|
}
|
|
950
953
|
|
|
951
|
-
class ListClusterAlertsCommand extends
|
|
954
|
+
class ListClusterAlertsCommand 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("MediaLive", "ListClusterAlerts", {})
|
|
958
961
|
.n("MediaLiveClient", "ListClusterAlertsCommand")
|
|
959
|
-
.sc(
|
|
962
|
+
.sc(ListClusterAlerts$)
|
|
960
963
|
.build() {
|
|
961
964
|
}
|
|
962
965
|
|
|
963
|
-
class ListClustersCommand extends
|
|
966
|
+
class ListClustersCommand 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("MediaLive", "ListClusters", {})
|
|
970
973
|
.n("MediaLiveClient", "ListClustersCommand")
|
|
971
|
-
.sc(
|
|
974
|
+
.sc(ListClusters$)
|
|
972
975
|
.build() {
|
|
973
976
|
}
|
|
974
977
|
|
|
975
|
-
class ListEventBridgeRuleTemplateGroupsCommand extends
|
|
978
|
+
class ListEventBridgeRuleTemplateGroupsCommand 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("MediaLive", "ListEventBridgeRuleTemplateGroups", {})
|
|
982
985
|
.n("MediaLiveClient", "ListEventBridgeRuleTemplateGroupsCommand")
|
|
983
|
-
.sc(
|
|
986
|
+
.sc(ListEventBridgeRuleTemplateGroups$)
|
|
984
987
|
.build() {
|
|
985
988
|
}
|
|
986
989
|
|
|
987
|
-
class ListEventBridgeRuleTemplatesCommand extends
|
|
990
|
+
class ListEventBridgeRuleTemplatesCommand 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("MediaLive", "ListEventBridgeRuleTemplates", {})
|
|
994
997
|
.n("MediaLiveClient", "ListEventBridgeRuleTemplatesCommand")
|
|
995
|
-
.sc(
|
|
998
|
+
.sc(ListEventBridgeRuleTemplates$)
|
|
996
999
|
.build() {
|
|
997
1000
|
}
|
|
998
1001
|
|
|
999
|
-
class ListInputDevicesCommand extends
|
|
1002
|
+
class ListInputDevicesCommand 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("MediaLive", "ListInputDevices", {})
|
|
1006
1009
|
.n("MediaLiveClient", "ListInputDevicesCommand")
|
|
1007
|
-
.sc(
|
|
1010
|
+
.sc(ListInputDevices$)
|
|
1008
1011
|
.build() {
|
|
1009
1012
|
}
|
|
1010
1013
|
|
|
1011
|
-
class ListInputDeviceTransfersCommand extends
|
|
1014
|
+
class ListInputDeviceTransfersCommand 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("MediaLive", "ListInputDeviceTransfers", {})
|
|
1018
1021
|
.n("MediaLiveClient", "ListInputDeviceTransfersCommand")
|
|
1019
|
-
.sc(
|
|
1022
|
+
.sc(ListInputDeviceTransfers$)
|
|
1020
1023
|
.build() {
|
|
1021
1024
|
}
|
|
1022
1025
|
|
|
1023
|
-
class ListInputsCommand extends
|
|
1026
|
+
class ListInputsCommand 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("MediaLive", "ListInputs", {})
|
|
1030
1033
|
.n("MediaLiveClient", "ListInputsCommand")
|
|
1031
|
-
.sc(
|
|
1034
|
+
.sc(ListInputs$)
|
|
1032
1035
|
.build() {
|
|
1033
1036
|
}
|
|
1034
1037
|
|
|
1035
|
-
class ListInputSecurityGroupsCommand extends
|
|
1038
|
+
class ListInputSecurityGroupsCommand 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("MediaLive", "ListInputSecurityGroups", {})
|
|
1042
1045
|
.n("MediaLiveClient", "ListInputSecurityGroupsCommand")
|
|
1043
|
-
.sc(
|
|
1046
|
+
.sc(ListInputSecurityGroups$)
|
|
1044
1047
|
.build() {
|
|
1045
1048
|
}
|
|
1046
1049
|
|
|
1047
|
-
class ListMultiplexAlertsCommand extends
|
|
1050
|
+
class ListMultiplexAlertsCommand 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("MediaLive", "ListMultiplexAlerts", {})
|
|
1054
1057
|
.n("MediaLiveClient", "ListMultiplexAlertsCommand")
|
|
1055
|
-
.sc(
|
|
1058
|
+
.sc(ListMultiplexAlerts$)
|
|
1056
1059
|
.build() {
|
|
1057
1060
|
}
|
|
1058
1061
|
|
|
1059
|
-
class ListMultiplexesCommand extends
|
|
1062
|
+
class ListMultiplexesCommand 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("MediaLive", "ListMultiplexes", {})
|
|
1066
1069
|
.n("MediaLiveClient", "ListMultiplexesCommand")
|
|
1067
|
-
.sc(
|
|
1070
|
+
.sc(ListMultiplexes$)
|
|
1068
1071
|
.build() {
|
|
1069
1072
|
}
|
|
1070
1073
|
|
|
1071
|
-
class ListMultiplexProgramsCommand extends
|
|
1074
|
+
class ListMultiplexProgramsCommand 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("MediaLive", "ListMultiplexPrograms", {})
|
|
1078
1081
|
.n("MediaLiveClient", "ListMultiplexProgramsCommand")
|
|
1079
|
-
.sc(
|
|
1082
|
+
.sc(ListMultiplexPrograms$)
|
|
1080
1083
|
.build() {
|
|
1081
1084
|
}
|
|
1082
1085
|
|
|
1083
|
-
class ListNetworksCommand extends
|
|
1086
|
+
class ListNetworksCommand 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("MediaLive", "ListNetworks", {})
|
|
1090
1093
|
.n("MediaLiveClient", "ListNetworksCommand")
|
|
1091
|
-
.sc(
|
|
1094
|
+
.sc(ListNetworks$)
|
|
1092
1095
|
.build() {
|
|
1093
1096
|
}
|
|
1094
1097
|
|
|
1095
|
-
class ListNodesCommand extends
|
|
1098
|
+
class ListNodesCommand extends Command
|
|
1096
1099
|
.classBuilder()
|
|
1097
1100
|
.ep(commonParams)
|
|
1098
1101
|
.m(function (Command, cs, config, o) {
|
|
1099
|
-
return [
|
|
1102
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1100
1103
|
})
|
|
1101
1104
|
.s("MediaLive", "ListNodes", {})
|
|
1102
1105
|
.n("MediaLiveClient", "ListNodesCommand")
|
|
1103
|
-
.sc(
|
|
1106
|
+
.sc(ListNodes$)
|
|
1104
1107
|
.build() {
|
|
1105
1108
|
}
|
|
1106
1109
|
|
|
1107
|
-
class ListOfferingsCommand extends
|
|
1110
|
+
class ListOfferingsCommand extends Command
|
|
1108
1111
|
.classBuilder()
|
|
1109
1112
|
.ep(commonParams)
|
|
1110
1113
|
.m(function (Command, cs, config, o) {
|
|
1111
|
-
return [
|
|
1114
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1112
1115
|
})
|
|
1113
1116
|
.s("MediaLive", "ListOfferings", {})
|
|
1114
1117
|
.n("MediaLiveClient", "ListOfferingsCommand")
|
|
1115
|
-
.sc(
|
|
1118
|
+
.sc(ListOfferings$)
|
|
1116
1119
|
.build() {
|
|
1117
1120
|
}
|
|
1118
1121
|
|
|
1119
|
-
class ListReservationsCommand extends
|
|
1122
|
+
class ListReservationsCommand extends Command
|
|
1120
1123
|
.classBuilder()
|
|
1121
1124
|
.ep(commonParams)
|
|
1122
1125
|
.m(function (Command, cs, config, o) {
|
|
1123
|
-
return [
|
|
1126
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1124
1127
|
})
|
|
1125
1128
|
.s("MediaLive", "ListReservations", {})
|
|
1126
1129
|
.n("MediaLiveClient", "ListReservationsCommand")
|
|
1127
|
-
.sc(
|
|
1130
|
+
.sc(ListReservations$)
|
|
1128
1131
|
.build() {
|
|
1129
1132
|
}
|
|
1130
1133
|
|
|
1131
|
-
class ListSdiSourcesCommand extends
|
|
1134
|
+
class ListSdiSourcesCommand extends Command
|
|
1132
1135
|
.classBuilder()
|
|
1133
1136
|
.ep(commonParams)
|
|
1134
1137
|
.m(function (Command, cs, config, o) {
|
|
1135
|
-
return [
|
|
1138
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1136
1139
|
})
|
|
1137
1140
|
.s("MediaLive", "ListSdiSources", {})
|
|
1138
1141
|
.n("MediaLiveClient", "ListSdiSourcesCommand")
|
|
1139
|
-
.sc(
|
|
1142
|
+
.sc(ListSdiSources$)
|
|
1140
1143
|
.build() {
|
|
1141
1144
|
}
|
|
1142
1145
|
|
|
1143
|
-
class ListSignalMapsCommand extends
|
|
1146
|
+
class ListSignalMapsCommand extends Command
|
|
1144
1147
|
.classBuilder()
|
|
1145
1148
|
.ep(commonParams)
|
|
1146
1149
|
.m(function (Command, cs, config, o) {
|
|
1147
|
-
return [
|
|
1150
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1148
1151
|
})
|
|
1149
1152
|
.s("MediaLive", "ListSignalMaps", {})
|
|
1150
1153
|
.n("MediaLiveClient", "ListSignalMapsCommand")
|
|
1151
|
-
.sc(
|
|
1154
|
+
.sc(ListSignalMaps$)
|
|
1152
1155
|
.build() {
|
|
1153
1156
|
}
|
|
1154
1157
|
|
|
1155
|
-
class ListTagsForResourceCommand extends
|
|
1158
|
+
class ListTagsForResourceCommand extends Command
|
|
1156
1159
|
.classBuilder()
|
|
1157
1160
|
.ep(commonParams)
|
|
1158
1161
|
.m(function (Command, cs, config, o) {
|
|
1159
|
-
return [
|
|
1162
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1160
1163
|
})
|
|
1161
1164
|
.s("MediaLive", "ListTagsForResource", {})
|
|
1162
1165
|
.n("MediaLiveClient", "ListTagsForResourceCommand")
|
|
1163
|
-
.sc(
|
|
1166
|
+
.sc(ListTagsForResource$)
|
|
1164
1167
|
.build() {
|
|
1165
1168
|
}
|
|
1166
1169
|
|
|
1167
|
-
class ListVersionsCommand extends
|
|
1170
|
+
class ListVersionsCommand extends Command
|
|
1168
1171
|
.classBuilder()
|
|
1169
1172
|
.ep(commonParams)
|
|
1170
1173
|
.m(function (Command, cs, config, o) {
|
|
1171
|
-
return [
|
|
1174
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1172
1175
|
})
|
|
1173
1176
|
.s("MediaLive", "ListVersions", {})
|
|
1174
1177
|
.n("MediaLiveClient", "ListVersionsCommand")
|
|
1175
|
-
.sc(
|
|
1178
|
+
.sc(ListVersions$)
|
|
1176
1179
|
.build() {
|
|
1177
1180
|
}
|
|
1178
1181
|
|
|
1179
|
-
class PurchaseOfferingCommand extends
|
|
1182
|
+
class PurchaseOfferingCommand extends Command
|
|
1180
1183
|
.classBuilder()
|
|
1181
1184
|
.ep(commonParams)
|
|
1182
1185
|
.m(function (Command, cs, config, o) {
|
|
1183
|
-
return [
|
|
1186
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1184
1187
|
})
|
|
1185
1188
|
.s("MediaLive", "PurchaseOffering", {})
|
|
1186
1189
|
.n("MediaLiveClient", "PurchaseOfferingCommand")
|
|
1187
|
-
.sc(
|
|
1190
|
+
.sc(PurchaseOffering$)
|
|
1188
1191
|
.build() {
|
|
1189
1192
|
}
|
|
1190
1193
|
|
|
1191
|
-
class RebootInputDeviceCommand extends
|
|
1194
|
+
class RebootInputDeviceCommand extends Command
|
|
1192
1195
|
.classBuilder()
|
|
1193
1196
|
.ep(commonParams)
|
|
1194
1197
|
.m(function (Command, cs, config, o) {
|
|
1195
|
-
return [
|
|
1198
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1196
1199
|
})
|
|
1197
1200
|
.s("MediaLive", "RebootInputDevice", {})
|
|
1198
1201
|
.n("MediaLiveClient", "RebootInputDeviceCommand")
|
|
1199
|
-
.sc(
|
|
1202
|
+
.sc(RebootInputDevice$)
|
|
1200
1203
|
.build() {
|
|
1201
1204
|
}
|
|
1202
1205
|
|
|
1203
|
-
class RejectInputDeviceTransferCommand extends
|
|
1206
|
+
class RejectInputDeviceTransferCommand extends Command
|
|
1204
1207
|
.classBuilder()
|
|
1205
1208
|
.ep(commonParams)
|
|
1206
1209
|
.m(function (Command, cs, config, o) {
|
|
1207
|
-
return [
|
|
1210
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1208
1211
|
})
|
|
1209
1212
|
.s("MediaLive", "RejectInputDeviceTransfer", {})
|
|
1210
1213
|
.n("MediaLiveClient", "RejectInputDeviceTransferCommand")
|
|
1211
|
-
.sc(
|
|
1214
|
+
.sc(RejectInputDeviceTransfer$)
|
|
1212
1215
|
.build() {
|
|
1213
1216
|
}
|
|
1214
1217
|
|
|
1215
|
-
class RestartChannelPipelinesCommand extends
|
|
1218
|
+
class RestartChannelPipelinesCommand extends Command
|
|
1216
1219
|
.classBuilder()
|
|
1217
1220
|
.ep(commonParams)
|
|
1218
1221
|
.m(function (Command, cs, config, o) {
|
|
1219
|
-
return [
|
|
1222
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1220
1223
|
})
|
|
1221
1224
|
.s("MediaLive", "RestartChannelPipelines", {})
|
|
1222
1225
|
.n("MediaLiveClient", "RestartChannelPipelinesCommand")
|
|
1223
|
-
.sc(
|
|
1226
|
+
.sc(RestartChannelPipelines$)
|
|
1224
1227
|
.build() {
|
|
1225
1228
|
}
|
|
1226
1229
|
|
|
1227
|
-
class StartChannelCommand extends
|
|
1230
|
+
class StartChannelCommand extends Command
|
|
1228
1231
|
.classBuilder()
|
|
1229
1232
|
.ep(commonParams)
|
|
1230
1233
|
.m(function (Command, cs, config, o) {
|
|
1231
|
-
return [
|
|
1234
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1232
1235
|
})
|
|
1233
1236
|
.s("MediaLive", "StartChannel", {})
|
|
1234
1237
|
.n("MediaLiveClient", "StartChannelCommand")
|
|
1235
|
-
.sc(
|
|
1238
|
+
.sc(StartChannel$)
|
|
1236
1239
|
.build() {
|
|
1237
1240
|
}
|
|
1238
1241
|
|
|
1239
|
-
class StartDeleteMonitorDeploymentCommand extends
|
|
1242
|
+
class StartDeleteMonitorDeploymentCommand extends Command
|
|
1240
1243
|
.classBuilder()
|
|
1241
1244
|
.ep(commonParams)
|
|
1242
1245
|
.m(function (Command, cs, config, o) {
|
|
1243
|
-
return [
|
|
1246
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1244
1247
|
})
|
|
1245
1248
|
.s("MediaLive", "StartDeleteMonitorDeployment", {})
|
|
1246
1249
|
.n("MediaLiveClient", "StartDeleteMonitorDeploymentCommand")
|
|
1247
|
-
.sc(
|
|
1250
|
+
.sc(StartDeleteMonitorDeployment$)
|
|
1248
1251
|
.build() {
|
|
1249
1252
|
}
|
|
1250
1253
|
|
|
1251
|
-
class StartInputDeviceCommand extends
|
|
1254
|
+
class StartInputDeviceCommand extends Command
|
|
1252
1255
|
.classBuilder()
|
|
1253
1256
|
.ep(commonParams)
|
|
1254
1257
|
.m(function (Command, cs, config, o) {
|
|
1255
|
-
return [
|
|
1258
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1256
1259
|
})
|
|
1257
1260
|
.s("MediaLive", "StartInputDevice", {})
|
|
1258
1261
|
.n("MediaLiveClient", "StartInputDeviceCommand")
|
|
1259
|
-
.sc(
|
|
1262
|
+
.sc(StartInputDevice$)
|
|
1260
1263
|
.build() {
|
|
1261
1264
|
}
|
|
1262
1265
|
|
|
1263
|
-
class StartInputDeviceMaintenanceWindowCommand extends
|
|
1266
|
+
class StartInputDeviceMaintenanceWindowCommand extends Command
|
|
1264
1267
|
.classBuilder()
|
|
1265
1268
|
.ep(commonParams)
|
|
1266
1269
|
.m(function (Command, cs, config, o) {
|
|
1267
|
-
return [
|
|
1270
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1268
1271
|
})
|
|
1269
1272
|
.s("MediaLive", "StartInputDeviceMaintenanceWindow", {})
|
|
1270
1273
|
.n("MediaLiveClient", "StartInputDeviceMaintenanceWindowCommand")
|
|
1271
|
-
.sc(
|
|
1274
|
+
.sc(StartInputDeviceMaintenanceWindow$)
|
|
1272
1275
|
.build() {
|
|
1273
1276
|
}
|
|
1274
1277
|
|
|
1275
|
-
class StartMonitorDeploymentCommand extends
|
|
1278
|
+
class StartMonitorDeploymentCommand extends Command
|
|
1276
1279
|
.classBuilder()
|
|
1277
1280
|
.ep(commonParams)
|
|
1278
1281
|
.m(function (Command, cs, config, o) {
|
|
1279
|
-
return [
|
|
1282
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1280
1283
|
})
|
|
1281
1284
|
.s("MediaLive", "StartMonitorDeployment", {})
|
|
1282
1285
|
.n("MediaLiveClient", "StartMonitorDeploymentCommand")
|
|
1283
|
-
.sc(
|
|
1286
|
+
.sc(StartMonitorDeployment$)
|
|
1284
1287
|
.build() {
|
|
1285
1288
|
}
|
|
1286
1289
|
|
|
1287
|
-
class StartMultiplexCommand extends
|
|
1290
|
+
class StartMultiplexCommand extends Command
|
|
1288
1291
|
.classBuilder()
|
|
1289
1292
|
.ep(commonParams)
|
|
1290
1293
|
.m(function (Command, cs, config, o) {
|
|
1291
|
-
return [
|
|
1294
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1292
1295
|
})
|
|
1293
1296
|
.s("MediaLive", "StartMultiplex", {})
|
|
1294
1297
|
.n("MediaLiveClient", "StartMultiplexCommand")
|
|
1295
|
-
.sc(
|
|
1298
|
+
.sc(StartMultiplex$)
|
|
1296
1299
|
.build() {
|
|
1297
1300
|
}
|
|
1298
1301
|
|
|
1299
|
-
class StartUpdateSignalMapCommand extends
|
|
1302
|
+
class StartUpdateSignalMapCommand extends Command
|
|
1300
1303
|
.classBuilder()
|
|
1301
1304
|
.ep(commonParams)
|
|
1302
1305
|
.m(function (Command, cs, config, o) {
|
|
1303
|
-
return [
|
|
1306
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1304
1307
|
})
|
|
1305
1308
|
.s("MediaLive", "StartUpdateSignalMap", {})
|
|
1306
1309
|
.n("MediaLiveClient", "StartUpdateSignalMapCommand")
|
|
1307
|
-
.sc(
|
|
1310
|
+
.sc(StartUpdateSignalMap$)
|
|
1308
1311
|
.build() {
|
|
1309
1312
|
}
|
|
1310
1313
|
|
|
1311
|
-
class StopChannelCommand extends
|
|
1314
|
+
class StopChannelCommand extends Command
|
|
1312
1315
|
.classBuilder()
|
|
1313
1316
|
.ep(commonParams)
|
|
1314
1317
|
.m(function (Command, cs, config, o) {
|
|
1315
|
-
return [
|
|
1318
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1316
1319
|
})
|
|
1317
1320
|
.s("MediaLive", "StopChannel", {})
|
|
1318
1321
|
.n("MediaLiveClient", "StopChannelCommand")
|
|
1319
|
-
.sc(
|
|
1322
|
+
.sc(StopChannel$)
|
|
1320
1323
|
.build() {
|
|
1321
1324
|
}
|
|
1322
1325
|
|
|
1323
|
-
class StopInputDeviceCommand extends
|
|
1326
|
+
class StopInputDeviceCommand extends Command
|
|
1324
1327
|
.classBuilder()
|
|
1325
1328
|
.ep(commonParams)
|
|
1326
1329
|
.m(function (Command, cs, config, o) {
|
|
1327
|
-
return [
|
|
1330
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1328
1331
|
})
|
|
1329
1332
|
.s("MediaLive", "StopInputDevice", {})
|
|
1330
1333
|
.n("MediaLiveClient", "StopInputDeviceCommand")
|
|
1331
|
-
.sc(
|
|
1334
|
+
.sc(StopInputDevice$)
|
|
1332
1335
|
.build() {
|
|
1333
1336
|
}
|
|
1334
1337
|
|
|
1335
|
-
class StopMultiplexCommand extends
|
|
1338
|
+
class StopMultiplexCommand extends Command
|
|
1336
1339
|
.classBuilder()
|
|
1337
1340
|
.ep(commonParams)
|
|
1338
1341
|
.m(function (Command, cs, config, o) {
|
|
1339
|
-
return [
|
|
1342
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1340
1343
|
})
|
|
1341
1344
|
.s("MediaLive", "StopMultiplex", {})
|
|
1342
1345
|
.n("MediaLiveClient", "StopMultiplexCommand")
|
|
1343
|
-
.sc(
|
|
1346
|
+
.sc(StopMultiplex$)
|
|
1344
1347
|
.build() {
|
|
1345
1348
|
}
|
|
1346
1349
|
|
|
1347
|
-
class TransferInputDeviceCommand extends
|
|
1350
|
+
class TransferInputDeviceCommand extends Command
|
|
1348
1351
|
.classBuilder()
|
|
1349
1352
|
.ep(commonParams)
|
|
1350
1353
|
.m(function (Command, cs, config, o) {
|
|
1351
|
-
return [
|
|
1354
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1352
1355
|
})
|
|
1353
1356
|
.s("MediaLive", "TransferInputDevice", {})
|
|
1354
1357
|
.n("MediaLiveClient", "TransferInputDeviceCommand")
|
|
1355
|
-
.sc(
|
|
1358
|
+
.sc(TransferInputDevice$)
|
|
1356
1359
|
.build() {
|
|
1357
1360
|
}
|
|
1358
1361
|
|
|
1359
|
-
class UpdateAccountConfigurationCommand extends
|
|
1362
|
+
class UpdateAccountConfigurationCommand extends Command
|
|
1360
1363
|
.classBuilder()
|
|
1361
1364
|
.ep(commonParams)
|
|
1362
1365
|
.m(function (Command, cs, config, o) {
|
|
1363
|
-
return [
|
|
1366
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1364
1367
|
})
|
|
1365
1368
|
.s("MediaLive", "UpdateAccountConfiguration", {})
|
|
1366
1369
|
.n("MediaLiveClient", "UpdateAccountConfigurationCommand")
|
|
1367
|
-
.sc(
|
|
1370
|
+
.sc(UpdateAccountConfiguration$)
|
|
1368
1371
|
.build() {
|
|
1369
1372
|
}
|
|
1370
1373
|
|
|
1371
|
-
class UpdateChannelClassCommand extends
|
|
1374
|
+
class UpdateChannelClassCommand extends Command
|
|
1372
1375
|
.classBuilder()
|
|
1373
1376
|
.ep(commonParams)
|
|
1374
1377
|
.m(function (Command, cs, config, o) {
|
|
1375
|
-
return [
|
|
1378
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1376
1379
|
})
|
|
1377
1380
|
.s("MediaLive", "UpdateChannelClass", {})
|
|
1378
1381
|
.n("MediaLiveClient", "UpdateChannelClassCommand")
|
|
1379
|
-
.sc(
|
|
1382
|
+
.sc(UpdateChannelClass$)
|
|
1380
1383
|
.build() {
|
|
1381
1384
|
}
|
|
1382
1385
|
|
|
1383
|
-
class UpdateChannelCommand extends
|
|
1386
|
+
class UpdateChannelCommand extends Command
|
|
1384
1387
|
.classBuilder()
|
|
1385
1388
|
.ep(commonParams)
|
|
1386
1389
|
.m(function (Command, cs, config, o) {
|
|
1387
|
-
return [
|
|
1390
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1388
1391
|
})
|
|
1389
1392
|
.s("MediaLive", "UpdateChannel", {})
|
|
1390
1393
|
.n("MediaLiveClient", "UpdateChannelCommand")
|
|
1391
|
-
.sc(
|
|
1394
|
+
.sc(UpdateChannel$)
|
|
1392
1395
|
.build() {
|
|
1393
1396
|
}
|
|
1394
1397
|
|
|
1395
|
-
class UpdateChannelPlacementGroupCommand extends
|
|
1398
|
+
class UpdateChannelPlacementGroupCommand extends Command
|
|
1396
1399
|
.classBuilder()
|
|
1397
1400
|
.ep(commonParams)
|
|
1398
1401
|
.m(function (Command, cs, config, o) {
|
|
1399
|
-
return [
|
|
1402
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1400
1403
|
})
|
|
1401
1404
|
.s("MediaLive", "UpdateChannelPlacementGroup", {})
|
|
1402
1405
|
.n("MediaLiveClient", "UpdateChannelPlacementGroupCommand")
|
|
1403
|
-
.sc(
|
|
1406
|
+
.sc(UpdateChannelPlacementGroup$)
|
|
1404
1407
|
.build() {
|
|
1405
1408
|
}
|
|
1406
1409
|
|
|
1407
|
-
class UpdateCloudWatchAlarmTemplateCommand extends
|
|
1410
|
+
class UpdateCloudWatchAlarmTemplateCommand extends Command
|
|
1408
1411
|
.classBuilder()
|
|
1409
1412
|
.ep(commonParams)
|
|
1410
1413
|
.m(function (Command, cs, config, o) {
|
|
1411
|
-
return [
|
|
1414
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1412
1415
|
})
|
|
1413
1416
|
.s("MediaLive", "UpdateCloudWatchAlarmTemplate", {})
|
|
1414
1417
|
.n("MediaLiveClient", "UpdateCloudWatchAlarmTemplateCommand")
|
|
1415
|
-
.sc(
|
|
1418
|
+
.sc(UpdateCloudWatchAlarmTemplate$)
|
|
1416
1419
|
.build() {
|
|
1417
1420
|
}
|
|
1418
1421
|
|
|
1419
|
-
class UpdateCloudWatchAlarmTemplateGroupCommand extends
|
|
1422
|
+
class UpdateCloudWatchAlarmTemplateGroupCommand extends Command
|
|
1420
1423
|
.classBuilder()
|
|
1421
1424
|
.ep(commonParams)
|
|
1422
1425
|
.m(function (Command, cs, config, o) {
|
|
1423
|
-
return [
|
|
1426
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1424
1427
|
})
|
|
1425
1428
|
.s("MediaLive", "UpdateCloudWatchAlarmTemplateGroup", {})
|
|
1426
1429
|
.n("MediaLiveClient", "UpdateCloudWatchAlarmTemplateGroupCommand")
|
|
1427
|
-
.sc(
|
|
1430
|
+
.sc(UpdateCloudWatchAlarmTemplateGroup$)
|
|
1428
1431
|
.build() {
|
|
1429
1432
|
}
|
|
1430
1433
|
|
|
1431
|
-
class UpdateClusterCommand extends
|
|
1434
|
+
class UpdateClusterCommand extends Command
|
|
1432
1435
|
.classBuilder()
|
|
1433
1436
|
.ep(commonParams)
|
|
1434
1437
|
.m(function (Command, cs, config, o) {
|
|
1435
|
-
return [
|
|
1438
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1436
1439
|
})
|
|
1437
1440
|
.s("MediaLive", "UpdateCluster", {})
|
|
1438
1441
|
.n("MediaLiveClient", "UpdateClusterCommand")
|
|
1439
|
-
.sc(
|
|
1442
|
+
.sc(UpdateCluster$)
|
|
1440
1443
|
.build() {
|
|
1441
1444
|
}
|
|
1442
1445
|
|
|
1443
|
-
class UpdateEventBridgeRuleTemplateCommand extends
|
|
1446
|
+
class UpdateEventBridgeRuleTemplateCommand extends Command
|
|
1444
1447
|
.classBuilder()
|
|
1445
1448
|
.ep(commonParams)
|
|
1446
1449
|
.m(function (Command, cs, config, o) {
|
|
1447
|
-
return [
|
|
1450
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1448
1451
|
})
|
|
1449
1452
|
.s("MediaLive", "UpdateEventBridgeRuleTemplate", {})
|
|
1450
1453
|
.n("MediaLiveClient", "UpdateEventBridgeRuleTemplateCommand")
|
|
1451
|
-
.sc(
|
|
1454
|
+
.sc(UpdateEventBridgeRuleTemplate$)
|
|
1452
1455
|
.build() {
|
|
1453
1456
|
}
|
|
1454
1457
|
|
|
1455
|
-
class UpdateEventBridgeRuleTemplateGroupCommand extends
|
|
1458
|
+
class UpdateEventBridgeRuleTemplateGroupCommand extends Command
|
|
1456
1459
|
.classBuilder()
|
|
1457
1460
|
.ep(commonParams)
|
|
1458
1461
|
.m(function (Command, cs, config, o) {
|
|
1459
|
-
return [
|
|
1462
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1460
1463
|
})
|
|
1461
1464
|
.s("MediaLive", "UpdateEventBridgeRuleTemplateGroup", {})
|
|
1462
1465
|
.n("MediaLiveClient", "UpdateEventBridgeRuleTemplateGroupCommand")
|
|
1463
|
-
.sc(
|
|
1466
|
+
.sc(UpdateEventBridgeRuleTemplateGroup$)
|
|
1464
1467
|
.build() {
|
|
1465
1468
|
}
|
|
1466
1469
|
|
|
1467
|
-
class UpdateInputCommand extends
|
|
1470
|
+
class UpdateInputCommand extends Command
|
|
1468
1471
|
.classBuilder()
|
|
1469
1472
|
.ep(commonParams)
|
|
1470
1473
|
.m(function (Command, cs, config, o) {
|
|
1471
|
-
return [
|
|
1474
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1472
1475
|
})
|
|
1473
1476
|
.s("MediaLive", "UpdateInput", {})
|
|
1474
1477
|
.n("MediaLiveClient", "UpdateInputCommand")
|
|
1475
|
-
.sc(
|
|
1478
|
+
.sc(UpdateInput$)
|
|
1476
1479
|
.build() {
|
|
1477
1480
|
}
|
|
1478
1481
|
|
|
1479
|
-
class UpdateInputDeviceCommand extends
|
|
1482
|
+
class UpdateInputDeviceCommand extends Command
|
|
1480
1483
|
.classBuilder()
|
|
1481
1484
|
.ep(commonParams)
|
|
1482
1485
|
.m(function (Command, cs, config, o) {
|
|
1483
|
-
return [
|
|
1486
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1484
1487
|
})
|
|
1485
1488
|
.s("MediaLive", "UpdateInputDevice", {})
|
|
1486
1489
|
.n("MediaLiveClient", "UpdateInputDeviceCommand")
|
|
1487
|
-
.sc(
|
|
1490
|
+
.sc(UpdateInputDevice$)
|
|
1488
1491
|
.build() {
|
|
1489
1492
|
}
|
|
1490
1493
|
|
|
1491
|
-
class UpdateInputSecurityGroupCommand extends
|
|
1494
|
+
class UpdateInputSecurityGroupCommand extends Command
|
|
1492
1495
|
.classBuilder()
|
|
1493
1496
|
.ep(commonParams)
|
|
1494
1497
|
.m(function (Command, cs, config, o) {
|
|
1495
|
-
return [
|
|
1498
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1496
1499
|
})
|
|
1497
1500
|
.s("MediaLive", "UpdateInputSecurityGroup", {})
|
|
1498
1501
|
.n("MediaLiveClient", "UpdateInputSecurityGroupCommand")
|
|
1499
|
-
.sc(
|
|
1502
|
+
.sc(UpdateInputSecurityGroup$)
|
|
1500
1503
|
.build() {
|
|
1501
1504
|
}
|
|
1502
1505
|
|
|
1503
|
-
class UpdateMultiplexCommand extends
|
|
1506
|
+
class UpdateMultiplexCommand extends Command
|
|
1504
1507
|
.classBuilder()
|
|
1505
1508
|
.ep(commonParams)
|
|
1506
1509
|
.m(function (Command, cs, config, o) {
|
|
1507
|
-
return [
|
|
1510
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1508
1511
|
})
|
|
1509
1512
|
.s("MediaLive", "UpdateMultiplex", {})
|
|
1510
1513
|
.n("MediaLiveClient", "UpdateMultiplexCommand")
|
|
1511
|
-
.sc(
|
|
1514
|
+
.sc(UpdateMultiplex$)
|
|
1512
1515
|
.build() {
|
|
1513
1516
|
}
|
|
1514
1517
|
|
|
1515
|
-
class UpdateMultiplexProgramCommand extends
|
|
1518
|
+
class UpdateMultiplexProgramCommand extends Command
|
|
1516
1519
|
.classBuilder()
|
|
1517
1520
|
.ep(commonParams)
|
|
1518
1521
|
.m(function (Command, cs, config, o) {
|
|
1519
|
-
return [
|
|
1522
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1520
1523
|
})
|
|
1521
1524
|
.s("MediaLive", "UpdateMultiplexProgram", {})
|
|
1522
1525
|
.n("MediaLiveClient", "UpdateMultiplexProgramCommand")
|
|
1523
|
-
.sc(
|
|
1526
|
+
.sc(UpdateMultiplexProgram$)
|
|
1524
1527
|
.build() {
|
|
1525
1528
|
}
|
|
1526
1529
|
|
|
1527
|
-
class UpdateNetworkCommand extends
|
|
1530
|
+
class UpdateNetworkCommand extends Command
|
|
1528
1531
|
.classBuilder()
|
|
1529
1532
|
.ep(commonParams)
|
|
1530
1533
|
.m(function (Command, cs, config, o) {
|
|
1531
|
-
return [
|
|
1534
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1532
1535
|
})
|
|
1533
1536
|
.s("MediaLive", "UpdateNetwork", {})
|
|
1534
1537
|
.n("MediaLiveClient", "UpdateNetworkCommand")
|
|
1535
|
-
.sc(
|
|
1538
|
+
.sc(UpdateNetwork$)
|
|
1536
1539
|
.build() {
|
|
1537
1540
|
}
|
|
1538
1541
|
|
|
1539
|
-
class UpdateNodeCommand extends
|
|
1542
|
+
class UpdateNodeCommand extends Command
|
|
1540
1543
|
.classBuilder()
|
|
1541
1544
|
.ep(commonParams)
|
|
1542
1545
|
.m(function (Command, cs, config, o) {
|
|
1543
|
-
return [
|
|
1546
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1544
1547
|
})
|
|
1545
1548
|
.s("MediaLive", "UpdateNode", {})
|
|
1546
1549
|
.n("MediaLiveClient", "UpdateNodeCommand")
|
|
1547
|
-
.sc(
|
|
1550
|
+
.sc(UpdateNode$)
|
|
1548
1551
|
.build() {
|
|
1549
1552
|
}
|
|
1550
1553
|
|
|
1551
|
-
class UpdateNodeStateCommand extends
|
|
1554
|
+
class UpdateNodeStateCommand extends Command
|
|
1552
1555
|
.classBuilder()
|
|
1553
1556
|
.ep(commonParams)
|
|
1554
1557
|
.m(function (Command, cs, config, o) {
|
|
1555
|
-
return [
|
|
1558
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1556
1559
|
})
|
|
1557
1560
|
.s("MediaLive", "UpdateNodeState", {})
|
|
1558
1561
|
.n("MediaLiveClient", "UpdateNodeStateCommand")
|
|
1559
|
-
.sc(
|
|
1562
|
+
.sc(UpdateNodeState$)
|
|
1560
1563
|
.build() {
|
|
1561
1564
|
}
|
|
1562
1565
|
|
|
1563
|
-
class UpdateReservationCommand extends
|
|
1566
|
+
class UpdateReservationCommand extends Command
|
|
1564
1567
|
.classBuilder()
|
|
1565
1568
|
.ep(commonParams)
|
|
1566
1569
|
.m(function (Command, cs, config, o) {
|
|
1567
|
-
return [
|
|
1570
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1568
1571
|
})
|
|
1569
1572
|
.s("MediaLive", "UpdateReservation", {})
|
|
1570
1573
|
.n("MediaLiveClient", "UpdateReservationCommand")
|
|
1571
|
-
.sc(
|
|
1574
|
+
.sc(UpdateReservation$)
|
|
1572
1575
|
.build() {
|
|
1573
1576
|
}
|
|
1574
1577
|
|
|
1575
|
-
class UpdateSdiSourceCommand extends
|
|
1578
|
+
class UpdateSdiSourceCommand extends Command
|
|
1576
1579
|
.classBuilder()
|
|
1577
1580
|
.ep(commonParams)
|
|
1578
1581
|
.m(function (Command, cs, config, o) {
|
|
1579
|
-
return [
|
|
1582
|
+
return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
|
|
1580
1583
|
})
|
|
1581
1584
|
.s("MediaLive", "UpdateSdiSource", {})
|
|
1582
1585
|
.n("MediaLiveClient", "UpdateSdiSourceCommand")
|
|
1583
|
-
.sc(
|
|
1586
|
+
.sc(UpdateSdiSource$)
|
|
1584
1587
|
.build() {
|
|
1585
1588
|
}
|
|
1586
1589
|
|
|
1587
|
-
const paginateDescribeSchedule =
|
|
1590
|
+
const paginateDescribeSchedule = createPaginator(MediaLiveClient, DescribeScheduleCommand, "NextToken", "NextToken", "MaxResults");
|
|
1588
1591
|
|
|
1589
|
-
const paginateListAlerts =
|
|
1592
|
+
const paginateListAlerts = createPaginator(MediaLiveClient, ListAlertsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1590
1593
|
|
|
1591
|
-
const paginateListChannelPlacementGroups =
|
|
1594
|
+
const paginateListChannelPlacementGroups = createPaginator(MediaLiveClient, ListChannelPlacementGroupsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1592
1595
|
|
|
1593
|
-
const paginateListChannels =
|
|
1596
|
+
const paginateListChannels = createPaginator(MediaLiveClient, ListChannelsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1594
1597
|
|
|
1595
|
-
const paginateListCloudWatchAlarmTemplateGroups =
|
|
1598
|
+
const paginateListCloudWatchAlarmTemplateGroups = createPaginator(MediaLiveClient, ListCloudWatchAlarmTemplateGroupsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1596
1599
|
|
|
1597
|
-
const paginateListCloudWatchAlarmTemplates =
|
|
1600
|
+
const paginateListCloudWatchAlarmTemplates = createPaginator(MediaLiveClient, ListCloudWatchAlarmTemplatesCommand, "NextToken", "NextToken", "MaxResults");
|
|
1598
1601
|
|
|
1599
|
-
const paginateListClusterAlerts =
|
|
1602
|
+
const paginateListClusterAlerts = createPaginator(MediaLiveClient, ListClusterAlertsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1600
1603
|
|
|
1601
|
-
const paginateListClusters =
|
|
1604
|
+
const paginateListClusters = createPaginator(MediaLiveClient, ListClustersCommand, "NextToken", "NextToken", "MaxResults");
|
|
1602
1605
|
|
|
1603
|
-
const paginateListEventBridgeRuleTemplateGroups =
|
|
1606
|
+
const paginateListEventBridgeRuleTemplateGroups = createPaginator(MediaLiveClient, ListEventBridgeRuleTemplateGroupsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1604
1607
|
|
|
1605
|
-
const paginateListEventBridgeRuleTemplates =
|
|
1608
|
+
const paginateListEventBridgeRuleTemplates = createPaginator(MediaLiveClient, ListEventBridgeRuleTemplatesCommand, "NextToken", "NextToken", "MaxResults");
|
|
1606
1609
|
|
|
1607
|
-
const paginateListInputDevices =
|
|
1610
|
+
const paginateListInputDevices = createPaginator(MediaLiveClient, ListInputDevicesCommand, "NextToken", "NextToken", "MaxResults");
|
|
1608
1611
|
|
|
1609
|
-
const paginateListInputDeviceTransfers =
|
|
1612
|
+
const paginateListInputDeviceTransfers = createPaginator(MediaLiveClient, ListInputDeviceTransfersCommand, "NextToken", "NextToken", "MaxResults");
|
|
1610
1613
|
|
|
1611
|
-
const paginateListInputSecurityGroups =
|
|
1614
|
+
const paginateListInputSecurityGroups = createPaginator(MediaLiveClient, ListInputSecurityGroupsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1612
1615
|
|
|
1613
|
-
const paginateListInputs =
|
|
1616
|
+
const paginateListInputs = createPaginator(MediaLiveClient, ListInputsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1614
1617
|
|
|
1615
|
-
const paginateListMultiplexAlerts =
|
|
1618
|
+
const paginateListMultiplexAlerts = createPaginator(MediaLiveClient, ListMultiplexAlertsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1616
1619
|
|
|
1617
|
-
const paginateListMultiplexes =
|
|
1620
|
+
const paginateListMultiplexes = createPaginator(MediaLiveClient, ListMultiplexesCommand, "NextToken", "NextToken", "MaxResults");
|
|
1618
1621
|
|
|
1619
|
-
const paginateListMultiplexPrograms =
|
|
1622
|
+
const paginateListMultiplexPrograms = createPaginator(MediaLiveClient, ListMultiplexProgramsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1620
1623
|
|
|
1621
|
-
const paginateListNetworks =
|
|
1624
|
+
const paginateListNetworks = createPaginator(MediaLiveClient, ListNetworksCommand, "NextToken", "NextToken", "MaxResults");
|
|
1622
1625
|
|
|
1623
|
-
const paginateListNodes =
|
|
1626
|
+
const paginateListNodes = createPaginator(MediaLiveClient, ListNodesCommand, "NextToken", "NextToken", "MaxResults");
|
|
1624
1627
|
|
|
1625
|
-
const paginateListOfferings =
|
|
1628
|
+
const paginateListOfferings = createPaginator(MediaLiveClient, ListOfferingsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1626
1629
|
|
|
1627
|
-
const paginateListReservations =
|
|
1630
|
+
const paginateListReservations = createPaginator(MediaLiveClient, ListReservationsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1628
1631
|
|
|
1629
|
-
const paginateListSdiSources =
|
|
1632
|
+
const paginateListSdiSources = createPaginator(MediaLiveClient, ListSdiSourcesCommand, "NextToken", "NextToken", "MaxResults");
|
|
1630
1633
|
|
|
1631
|
-
const paginateListSignalMaps =
|
|
1634
|
+
const paginateListSignalMaps = createPaginator(MediaLiveClient, ListSignalMapsCommand, "NextToken", "NextToken", "MaxResults");
|
|
1632
1635
|
|
|
1633
|
-
const checkState$l = async (client
|
|
1636
|
+
const checkState$l = async (client, input) => {
|
|
1634
1637
|
let reason;
|
|
1635
1638
|
try {
|
|
1636
|
-
let result = await client
|
|
1639
|
+
let result = await client.send(new DescribeChannelCommand(input));
|
|
1637
1640
|
reason = result;
|
|
1638
1641
|
try {
|
|
1639
1642
|
const returnComparator = () => {
|
|
1640
1643
|
return result.State;
|
|
1641
1644
|
};
|
|
1642
1645
|
if (returnComparator() === "IDLE") {
|
|
1643
|
-
return { state:
|
|
1646
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1644
1647
|
}
|
|
1645
1648
|
}
|
|
1646
1649
|
catch (e) { }
|
|
@@ -1649,7 +1652,7 @@ const checkState$l = async (client$1, input) => {
|
|
|
1649
1652
|
return result.State;
|
|
1650
1653
|
};
|
|
1651
1654
|
if (returnComparator() === "CREATING") {
|
|
1652
|
-
return { state:
|
|
1655
|
+
return { state: WaiterState.RETRY, reason };
|
|
1653
1656
|
}
|
|
1654
1657
|
}
|
|
1655
1658
|
catch (e) { }
|
|
@@ -1658,7 +1661,7 @@ const checkState$l = async (client$1, input) => {
|
|
|
1658
1661
|
return result.State;
|
|
1659
1662
|
};
|
|
1660
1663
|
if (returnComparator() === "CREATE_FAILED") {
|
|
1661
|
-
return { state:
|
|
1664
|
+
return { state: WaiterState.FAILURE, reason };
|
|
1662
1665
|
}
|
|
1663
1666
|
}
|
|
1664
1667
|
catch (e) { }
|
|
@@ -1666,32 +1669,32 @@ const checkState$l = async (client$1, input) => {
|
|
|
1666
1669
|
catch (exception) {
|
|
1667
1670
|
reason = exception;
|
|
1668
1671
|
if (exception.name === "InternalServerErrorException") {
|
|
1669
|
-
return { state:
|
|
1672
|
+
return { state: WaiterState.RETRY, reason };
|
|
1670
1673
|
}
|
|
1671
1674
|
}
|
|
1672
|
-
return { state:
|
|
1675
|
+
return { state: WaiterState.RETRY, reason };
|
|
1673
1676
|
};
|
|
1674
1677
|
const waitForChannelCreated = async (params, input) => {
|
|
1675
1678
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1676
|
-
return
|
|
1679
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$l);
|
|
1677
1680
|
};
|
|
1678
1681
|
const waitUntilChannelCreated = async (params, input) => {
|
|
1679
1682
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1680
|
-
const result = await
|
|
1681
|
-
return
|
|
1683
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$l);
|
|
1684
|
+
return checkExceptions(result);
|
|
1682
1685
|
};
|
|
1683
1686
|
|
|
1684
|
-
const checkState$k = async (client
|
|
1687
|
+
const checkState$k = async (client, input) => {
|
|
1685
1688
|
let reason;
|
|
1686
1689
|
try {
|
|
1687
|
-
let result = await client
|
|
1690
|
+
let result = await client.send(new DescribeChannelCommand(input));
|
|
1688
1691
|
reason = result;
|
|
1689
1692
|
try {
|
|
1690
1693
|
const returnComparator = () => {
|
|
1691
1694
|
return result.State;
|
|
1692
1695
|
};
|
|
1693
1696
|
if (returnComparator() === "DELETED") {
|
|
1694
|
-
return { state:
|
|
1697
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1695
1698
|
}
|
|
1696
1699
|
}
|
|
1697
1700
|
catch (e) { }
|
|
@@ -1700,7 +1703,7 @@ const checkState$k = async (client$1, input) => {
|
|
|
1700
1703
|
return result.State;
|
|
1701
1704
|
};
|
|
1702
1705
|
if (returnComparator() === "DELETING") {
|
|
1703
|
-
return { state:
|
|
1706
|
+
return { state: WaiterState.RETRY, reason };
|
|
1704
1707
|
}
|
|
1705
1708
|
}
|
|
1706
1709
|
catch (e) { }
|
|
@@ -1708,32 +1711,32 @@ const checkState$k = async (client$1, input) => {
|
|
|
1708
1711
|
catch (exception) {
|
|
1709
1712
|
reason = exception;
|
|
1710
1713
|
if (exception.name === "InternalServerErrorException") {
|
|
1711
|
-
return { state:
|
|
1714
|
+
return { state: WaiterState.RETRY, reason };
|
|
1712
1715
|
}
|
|
1713
1716
|
}
|
|
1714
|
-
return { state:
|
|
1717
|
+
return { state: WaiterState.RETRY, reason };
|
|
1715
1718
|
};
|
|
1716
1719
|
const waitForChannelDeleted = async (params, input) => {
|
|
1717
1720
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
1718
|
-
return
|
|
1721
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$k);
|
|
1719
1722
|
};
|
|
1720
1723
|
const waitUntilChannelDeleted = async (params, input) => {
|
|
1721
1724
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
1722
|
-
const result = await
|
|
1723
|
-
return
|
|
1725
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$k);
|
|
1726
|
+
return checkExceptions(result);
|
|
1724
1727
|
};
|
|
1725
1728
|
|
|
1726
|
-
const checkState$j = async (client
|
|
1729
|
+
const checkState$j = async (client, input) => {
|
|
1727
1730
|
let reason;
|
|
1728
1731
|
try {
|
|
1729
|
-
let result = await client
|
|
1732
|
+
let result = await client.send(new DescribeChannelPlacementGroupCommand(input));
|
|
1730
1733
|
reason = result;
|
|
1731
1734
|
try {
|
|
1732
1735
|
const returnComparator = () => {
|
|
1733
1736
|
return result.State;
|
|
1734
1737
|
};
|
|
1735
1738
|
if (returnComparator() === "ASSIGNED") {
|
|
1736
|
-
return { state:
|
|
1739
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1737
1740
|
}
|
|
1738
1741
|
}
|
|
1739
1742
|
catch (e) { }
|
|
@@ -1742,7 +1745,7 @@ const checkState$j = async (client$1, input) => {
|
|
|
1742
1745
|
return result.State;
|
|
1743
1746
|
};
|
|
1744
1747
|
if (returnComparator() === "ASSIGNING") {
|
|
1745
|
-
return { state:
|
|
1748
|
+
return { state: WaiterState.RETRY, reason };
|
|
1746
1749
|
}
|
|
1747
1750
|
}
|
|
1748
1751
|
catch (e) { }
|
|
@@ -1750,32 +1753,32 @@ const checkState$j = async (client$1, input) => {
|
|
|
1750
1753
|
catch (exception) {
|
|
1751
1754
|
reason = exception;
|
|
1752
1755
|
if (exception.name === "InternalServerErrorException") {
|
|
1753
|
-
return { state:
|
|
1756
|
+
return { state: WaiterState.RETRY, reason };
|
|
1754
1757
|
}
|
|
1755
1758
|
}
|
|
1756
|
-
return { state:
|
|
1759
|
+
return { state: WaiterState.RETRY, reason };
|
|
1757
1760
|
};
|
|
1758
1761
|
const waitForChannelPlacementGroupAssigned = async (params, input) => {
|
|
1759
1762
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1760
|
-
return
|
|
1763
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$j);
|
|
1761
1764
|
};
|
|
1762
1765
|
const waitUntilChannelPlacementGroupAssigned = async (params, input) => {
|
|
1763
1766
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1764
|
-
const result = await
|
|
1765
|
-
return
|
|
1767
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$j);
|
|
1768
|
+
return checkExceptions(result);
|
|
1766
1769
|
};
|
|
1767
1770
|
|
|
1768
|
-
const checkState$i = async (client
|
|
1771
|
+
const checkState$i = async (client, input) => {
|
|
1769
1772
|
let reason;
|
|
1770
1773
|
try {
|
|
1771
|
-
let result = await client
|
|
1774
|
+
let result = await client.send(new DescribeChannelPlacementGroupCommand(input));
|
|
1772
1775
|
reason = result;
|
|
1773
1776
|
try {
|
|
1774
1777
|
const returnComparator = () => {
|
|
1775
1778
|
return result.State;
|
|
1776
1779
|
};
|
|
1777
1780
|
if (returnComparator() === "DELETED") {
|
|
1778
|
-
return { state:
|
|
1781
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1779
1782
|
}
|
|
1780
1783
|
}
|
|
1781
1784
|
catch (e) { }
|
|
@@ -1784,7 +1787,7 @@ const checkState$i = async (client$1, input) => {
|
|
|
1784
1787
|
return result.State;
|
|
1785
1788
|
};
|
|
1786
1789
|
if (returnComparator() === "DELETING") {
|
|
1787
|
-
return { state:
|
|
1790
|
+
return { state: WaiterState.RETRY, reason };
|
|
1788
1791
|
}
|
|
1789
1792
|
}
|
|
1790
1793
|
catch (e) { }
|
|
@@ -1792,32 +1795,32 @@ const checkState$i = async (client$1, input) => {
|
|
|
1792
1795
|
catch (exception) {
|
|
1793
1796
|
reason = exception;
|
|
1794
1797
|
if (exception.name === "InternalServerErrorException") {
|
|
1795
|
-
return { state:
|
|
1798
|
+
return { state: WaiterState.RETRY, reason };
|
|
1796
1799
|
}
|
|
1797
1800
|
}
|
|
1798
|
-
return { state:
|
|
1801
|
+
return { state: WaiterState.RETRY, reason };
|
|
1799
1802
|
};
|
|
1800
1803
|
const waitForChannelPlacementGroupDeleted = async (params, input) => {
|
|
1801
1804
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
1802
|
-
return
|
|
1805
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$i);
|
|
1803
1806
|
};
|
|
1804
1807
|
const waitUntilChannelPlacementGroupDeleted = async (params, input) => {
|
|
1805
1808
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
1806
|
-
const result = await
|
|
1807
|
-
return
|
|
1809
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$i);
|
|
1810
|
+
return checkExceptions(result);
|
|
1808
1811
|
};
|
|
1809
1812
|
|
|
1810
|
-
const checkState$h = async (client
|
|
1813
|
+
const checkState$h = async (client, input) => {
|
|
1811
1814
|
let reason;
|
|
1812
1815
|
try {
|
|
1813
|
-
let result = await client
|
|
1816
|
+
let result = await client.send(new DescribeChannelPlacementGroupCommand(input));
|
|
1814
1817
|
reason = result;
|
|
1815
1818
|
try {
|
|
1816
1819
|
const returnComparator = () => {
|
|
1817
1820
|
return result.State;
|
|
1818
1821
|
};
|
|
1819
1822
|
if (returnComparator() === "UNASSIGNED") {
|
|
1820
|
-
return { state:
|
|
1823
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1821
1824
|
}
|
|
1822
1825
|
}
|
|
1823
1826
|
catch (e) { }
|
|
@@ -1826,7 +1829,7 @@ const checkState$h = async (client$1, input) => {
|
|
|
1826
1829
|
return result.State;
|
|
1827
1830
|
};
|
|
1828
1831
|
if (returnComparator() === "UNASSIGNING") {
|
|
1829
|
-
return { state:
|
|
1832
|
+
return { state: WaiterState.RETRY, reason };
|
|
1830
1833
|
}
|
|
1831
1834
|
}
|
|
1832
1835
|
catch (e) { }
|
|
@@ -1834,32 +1837,32 @@ const checkState$h = async (client$1, input) => {
|
|
|
1834
1837
|
catch (exception) {
|
|
1835
1838
|
reason = exception;
|
|
1836
1839
|
if (exception.name === "InternalServerErrorException") {
|
|
1837
|
-
return { state:
|
|
1840
|
+
return { state: WaiterState.RETRY, reason };
|
|
1838
1841
|
}
|
|
1839
1842
|
}
|
|
1840
|
-
return { state:
|
|
1843
|
+
return { state: WaiterState.RETRY, reason };
|
|
1841
1844
|
};
|
|
1842
1845
|
const waitForChannelPlacementGroupUnassigned = async (params, input) => {
|
|
1843
1846
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
1844
|
-
return
|
|
1847
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$h);
|
|
1845
1848
|
};
|
|
1846
1849
|
const waitUntilChannelPlacementGroupUnassigned = async (params, input) => {
|
|
1847
1850
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
1848
|
-
const result = await
|
|
1849
|
-
return
|
|
1851
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$h);
|
|
1852
|
+
return checkExceptions(result);
|
|
1850
1853
|
};
|
|
1851
1854
|
|
|
1852
|
-
const checkState$g = async (client
|
|
1855
|
+
const checkState$g = async (client, input) => {
|
|
1853
1856
|
let reason;
|
|
1854
1857
|
try {
|
|
1855
|
-
let result = await client
|
|
1858
|
+
let result = await client.send(new DescribeChannelCommand(input));
|
|
1856
1859
|
reason = result;
|
|
1857
1860
|
try {
|
|
1858
1861
|
const returnComparator = () => {
|
|
1859
1862
|
return result.State;
|
|
1860
1863
|
};
|
|
1861
1864
|
if (returnComparator() === "RUNNING") {
|
|
1862
|
-
return { state:
|
|
1865
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1863
1866
|
}
|
|
1864
1867
|
}
|
|
1865
1868
|
catch (e) { }
|
|
@@ -1868,7 +1871,7 @@ const checkState$g = async (client$1, input) => {
|
|
|
1868
1871
|
return result.State;
|
|
1869
1872
|
};
|
|
1870
1873
|
if (returnComparator() === "STARTING") {
|
|
1871
|
-
return { state:
|
|
1874
|
+
return { state: WaiterState.RETRY, reason };
|
|
1872
1875
|
}
|
|
1873
1876
|
}
|
|
1874
1877
|
catch (e) { }
|
|
@@ -1876,32 +1879,32 @@ const checkState$g = async (client$1, input) => {
|
|
|
1876
1879
|
catch (exception) {
|
|
1877
1880
|
reason = exception;
|
|
1878
1881
|
if (exception.name === "InternalServerErrorException") {
|
|
1879
|
-
return { state:
|
|
1882
|
+
return { state: WaiterState.RETRY, reason };
|
|
1880
1883
|
}
|
|
1881
1884
|
}
|
|
1882
|
-
return { state:
|
|
1885
|
+
return { state: WaiterState.RETRY, reason };
|
|
1883
1886
|
};
|
|
1884
1887
|
const waitForChannelRunning = async (params, input) => {
|
|
1885
1888
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
1886
|
-
return
|
|
1889
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$g);
|
|
1887
1890
|
};
|
|
1888
1891
|
const waitUntilChannelRunning = async (params, input) => {
|
|
1889
1892
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
1890
|
-
const result = await
|
|
1891
|
-
return
|
|
1893
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$g);
|
|
1894
|
+
return checkExceptions(result);
|
|
1892
1895
|
};
|
|
1893
1896
|
|
|
1894
|
-
const checkState$f = async (client
|
|
1897
|
+
const checkState$f = async (client, input) => {
|
|
1895
1898
|
let reason;
|
|
1896
1899
|
try {
|
|
1897
|
-
let result = await client
|
|
1900
|
+
let result = await client.send(new DescribeChannelCommand(input));
|
|
1898
1901
|
reason = result;
|
|
1899
1902
|
try {
|
|
1900
1903
|
const returnComparator = () => {
|
|
1901
1904
|
return result.State;
|
|
1902
1905
|
};
|
|
1903
1906
|
if (returnComparator() === "IDLE") {
|
|
1904
|
-
return { state:
|
|
1907
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1905
1908
|
}
|
|
1906
1909
|
}
|
|
1907
1910
|
catch (e) { }
|
|
@@ -1910,7 +1913,7 @@ const checkState$f = async (client$1, input) => {
|
|
|
1910
1913
|
return result.State;
|
|
1911
1914
|
};
|
|
1912
1915
|
if (returnComparator() === "STOPPING") {
|
|
1913
|
-
return { state:
|
|
1916
|
+
return { state: WaiterState.RETRY, reason };
|
|
1914
1917
|
}
|
|
1915
1918
|
}
|
|
1916
1919
|
catch (e) { }
|
|
@@ -1918,32 +1921,32 @@ const checkState$f = async (client$1, input) => {
|
|
|
1918
1921
|
catch (exception) {
|
|
1919
1922
|
reason = exception;
|
|
1920
1923
|
if (exception.name === "InternalServerErrorException") {
|
|
1921
|
-
return { state:
|
|
1924
|
+
return { state: WaiterState.RETRY, reason };
|
|
1922
1925
|
}
|
|
1923
1926
|
}
|
|
1924
|
-
return { state:
|
|
1927
|
+
return { state: WaiterState.RETRY, reason };
|
|
1925
1928
|
};
|
|
1926
1929
|
const waitForChannelStopped = async (params, input) => {
|
|
1927
1930
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
1928
|
-
return
|
|
1931
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$f);
|
|
1929
1932
|
};
|
|
1930
1933
|
const waitUntilChannelStopped = async (params, input) => {
|
|
1931
1934
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
1932
|
-
const result = await
|
|
1933
|
-
return
|
|
1935
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$f);
|
|
1936
|
+
return checkExceptions(result);
|
|
1934
1937
|
};
|
|
1935
1938
|
|
|
1936
|
-
const checkState$e = async (client
|
|
1939
|
+
const checkState$e = async (client, input) => {
|
|
1937
1940
|
let reason;
|
|
1938
1941
|
try {
|
|
1939
|
-
let result = await client
|
|
1942
|
+
let result = await client.send(new DescribeClusterCommand(input));
|
|
1940
1943
|
reason = result;
|
|
1941
1944
|
try {
|
|
1942
1945
|
const returnComparator = () => {
|
|
1943
1946
|
return result.State;
|
|
1944
1947
|
};
|
|
1945
1948
|
if (returnComparator() === "ACTIVE") {
|
|
1946
|
-
return { state:
|
|
1949
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1947
1950
|
}
|
|
1948
1951
|
}
|
|
1949
1952
|
catch (e) { }
|
|
@@ -1952,7 +1955,7 @@ const checkState$e = async (client$1, input) => {
|
|
|
1952
1955
|
return result.State;
|
|
1953
1956
|
};
|
|
1954
1957
|
if (returnComparator() === "CREATING") {
|
|
1955
|
-
return { state:
|
|
1958
|
+
return { state: WaiterState.RETRY, reason };
|
|
1956
1959
|
}
|
|
1957
1960
|
}
|
|
1958
1961
|
catch (e) { }
|
|
@@ -1961,7 +1964,7 @@ const checkState$e = async (client$1, input) => {
|
|
|
1961
1964
|
return result.State;
|
|
1962
1965
|
};
|
|
1963
1966
|
if (returnComparator() === "CREATE_FAILED") {
|
|
1964
|
-
return { state:
|
|
1967
|
+
return { state: WaiterState.FAILURE, reason };
|
|
1965
1968
|
}
|
|
1966
1969
|
}
|
|
1967
1970
|
catch (e) { }
|
|
@@ -1969,32 +1972,32 @@ const checkState$e = async (client$1, input) => {
|
|
|
1969
1972
|
catch (exception) {
|
|
1970
1973
|
reason = exception;
|
|
1971
1974
|
if (exception.name === "InternalServerErrorException") {
|
|
1972
|
-
return { state:
|
|
1975
|
+
return { state: WaiterState.RETRY, reason };
|
|
1973
1976
|
}
|
|
1974
1977
|
}
|
|
1975
|
-
return { state:
|
|
1978
|
+
return { state: WaiterState.RETRY, reason };
|
|
1976
1979
|
};
|
|
1977
1980
|
const waitForClusterCreated = async (params, input) => {
|
|
1978
1981
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1979
|
-
return
|
|
1982
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
|
|
1980
1983
|
};
|
|
1981
1984
|
const waitUntilClusterCreated = async (params, input) => {
|
|
1982
1985
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
1983
|
-
const result = await
|
|
1984
|
-
return
|
|
1986
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
|
|
1987
|
+
return checkExceptions(result);
|
|
1985
1988
|
};
|
|
1986
1989
|
|
|
1987
|
-
const checkState$d = async (client
|
|
1990
|
+
const checkState$d = async (client, input) => {
|
|
1988
1991
|
let reason;
|
|
1989
1992
|
try {
|
|
1990
|
-
let result = await client
|
|
1993
|
+
let result = await client.send(new DescribeClusterCommand(input));
|
|
1991
1994
|
reason = result;
|
|
1992
1995
|
try {
|
|
1993
1996
|
const returnComparator = () => {
|
|
1994
1997
|
return result.State;
|
|
1995
1998
|
};
|
|
1996
1999
|
if (returnComparator() === "DELETED") {
|
|
1997
|
-
return { state:
|
|
2000
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
1998
2001
|
}
|
|
1999
2002
|
}
|
|
2000
2003
|
catch (e) { }
|
|
@@ -2003,7 +2006,7 @@ const checkState$d = async (client$1, input) => {
|
|
|
2003
2006
|
return result.State;
|
|
2004
2007
|
};
|
|
2005
2008
|
if (returnComparator() === "DELETING") {
|
|
2006
|
-
return { state:
|
|
2009
|
+
return { state: WaiterState.RETRY, reason };
|
|
2007
2010
|
}
|
|
2008
2011
|
}
|
|
2009
2012
|
catch (e) { }
|
|
@@ -2011,32 +2014,32 @@ const checkState$d = async (client$1, input) => {
|
|
|
2011
2014
|
catch (exception) {
|
|
2012
2015
|
reason = exception;
|
|
2013
2016
|
if (exception.name === "InternalServerErrorException") {
|
|
2014
|
-
return { state:
|
|
2017
|
+
return { state: WaiterState.RETRY, reason };
|
|
2015
2018
|
}
|
|
2016
2019
|
}
|
|
2017
|
-
return { state:
|
|
2020
|
+
return { state: WaiterState.RETRY, reason };
|
|
2018
2021
|
};
|
|
2019
2022
|
const waitForClusterDeleted = async (params, input) => {
|
|
2020
2023
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2021
|
-
return
|
|
2024
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
|
|
2022
2025
|
};
|
|
2023
2026
|
const waitUntilClusterDeleted = async (params, input) => {
|
|
2024
2027
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2025
|
-
const result = await
|
|
2026
|
-
return
|
|
2028
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
|
|
2029
|
+
return checkExceptions(result);
|
|
2027
2030
|
};
|
|
2028
2031
|
|
|
2029
|
-
const checkState$c = async (client
|
|
2032
|
+
const checkState$c = async (client, input) => {
|
|
2030
2033
|
let reason;
|
|
2031
2034
|
try {
|
|
2032
|
-
let result = await client
|
|
2035
|
+
let result = await client.send(new DescribeInputCommand(input));
|
|
2033
2036
|
reason = result;
|
|
2034
2037
|
try {
|
|
2035
2038
|
const returnComparator = () => {
|
|
2036
2039
|
return result.State;
|
|
2037
2040
|
};
|
|
2038
2041
|
if (returnComparator() === "ATTACHED") {
|
|
2039
|
-
return { state:
|
|
2042
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
2040
2043
|
}
|
|
2041
2044
|
}
|
|
2042
2045
|
catch (e) { }
|
|
@@ -2045,7 +2048,7 @@ const checkState$c = async (client$1, input) => {
|
|
|
2045
2048
|
return result.State;
|
|
2046
2049
|
};
|
|
2047
2050
|
if (returnComparator() === "DETACHED") {
|
|
2048
|
-
return { state:
|
|
2051
|
+
return { state: WaiterState.RETRY, reason };
|
|
2049
2052
|
}
|
|
2050
2053
|
}
|
|
2051
2054
|
catch (e) { }
|
|
@@ -2053,32 +2056,32 @@ const checkState$c = async (client$1, input) => {
|
|
|
2053
2056
|
catch (exception) {
|
|
2054
2057
|
reason = exception;
|
|
2055
2058
|
if (exception.name === "InternalServerErrorException") {
|
|
2056
|
-
return { state:
|
|
2059
|
+
return { state: WaiterState.RETRY, reason };
|
|
2057
2060
|
}
|
|
2058
2061
|
}
|
|
2059
|
-
return { state:
|
|
2062
|
+
return { state: WaiterState.RETRY, reason };
|
|
2060
2063
|
};
|
|
2061
2064
|
const waitForInputAttached = async (params, input) => {
|
|
2062
2065
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2063
|
-
return
|
|
2066
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
|
|
2064
2067
|
};
|
|
2065
2068
|
const waitUntilInputAttached = async (params, input) => {
|
|
2066
2069
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2067
|
-
const result = await
|
|
2068
|
-
return
|
|
2070
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
|
|
2071
|
+
return checkExceptions(result);
|
|
2069
2072
|
};
|
|
2070
2073
|
|
|
2071
|
-
const checkState$b = async (client
|
|
2074
|
+
const checkState$b = async (client, input) => {
|
|
2072
2075
|
let reason;
|
|
2073
2076
|
try {
|
|
2074
|
-
let result = await client
|
|
2077
|
+
let result = await client.send(new DescribeInputCommand(input));
|
|
2075
2078
|
reason = result;
|
|
2076
2079
|
try {
|
|
2077
2080
|
const returnComparator = () => {
|
|
2078
2081
|
return result.State;
|
|
2079
2082
|
};
|
|
2080
2083
|
if (returnComparator() === "DELETED") {
|
|
2081
|
-
return { state:
|
|
2084
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
2082
2085
|
}
|
|
2083
2086
|
}
|
|
2084
2087
|
catch (e) { }
|
|
@@ -2087,7 +2090,7 @@ const checkState$b = async (client$1, input) => {
|
|
|
2087
2090
|
return result.State;
|
|
2088
2091
|
};
|
|
2089
2092
|
if (returnComparator() === "DELETING") {
|
|
2090
|
-
return { state:
|
|
2093
|
+
return { state: WaiterState.RETRY, reason };
|
|
2091
2094
|
}
|
|
2092
2095
|
}
|
|
2093
2096
|
catch (e) { }
|
|
@@ -2095,32 +2098,32 @@ const checkState$b = async (client$1, input) => {
|
|
|
2095
2098
|
catch (exception) {
|
|
2096
2099
|
reason = exception;
|
|
2097
2100
|
if (exception.name === "InternalServerErrorException") {
|
|
2098
|
-
return { state:
|
|
2101
|
+
return { state: WaiterState.RETRY, reason };
|
|
2099
2102
|
}
|
|
2100
2103
|
}
|
|
2101
|
-
return { state:
|
|
2104
|
+
return { state: WaiterState.RETRY, reason };
|
|
2102
2105
|
};
|
|
2103
2106
|
const waitForInputDeleted = async (params, input) => {
|
|
2104
2107
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2105
|
-
return
|
|
2108
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
|
|
2106
2109
|
};
|
|
2107
2110
|
const waitUntilInputDeleted = async (params, input) => {
|
|
2108
2111
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2109
|
-
const result = await
|
|
2110
|
-
return
|
|
2112
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
|
|
2113
|
+
return checkExceptions(result);
|
|
2111
2114
|
};
|
|
2112
2115
|
|
|
2113
|
-
const checkState$a = async (client
|
|
2116
|
+
const checkState$a = async (client, input) => {
|
|
2114
2117
|
let reason;
|
|
2115
2118
|
try {
|
|
2116
|
-
let result = await client
|
|
2119
|
+
let result = await client.send(new DescribeInputCommand(input));
|
|
2117
2120
|
reason = result;
|
|
2118
2121
|
try {
|
|
2119
2122
|
const returnComparator = () => {
|
|
2120
2123
|
return result.State;
|
|
2121
2124
|
};
|
|
2122
2125
|
if (returnComparator() === "DETACHED") {
|
|
2123
|
-
return { state:
|
|
2126
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
2124
2127
|
}
|
|
2125
2128
|
}
|
|
2126
2129
|
catch (e) { }
|
|
@@ -2129,7 +2132,7 @@ const checkState$a = async (client$1, input) => {
|
|
|
2129
2132
|
return result.State;
|
|
2130
2133
|
};
|
|
2131
2134
|
if (returnComparator() === "CREATING") {
|
|
2132
|
-
return { state:
|
|
2135
|
+
return { state: WaiterState.RETRY, reason };
|
|
2133
2136
|
}
|
|
2134
2137
|
}
|
|
2135
2138
|
catch (e) { }
|
|
@@ -2138,7 +2141,7 @@ const checkState$a = async (client$1, input) => {
|
|
|
2138
2141
|
return result.State;
|
|
2139
2142
|
};
|
|
2140
2143
|
if (returnComparator() === "ATTACHED") {
|
|
2141
|
-
return { state:
|
|
2144
|
+
return { state: WaiterState.RETRY, reason };
|
|
2142
2145
|
}
|
|
2143
2146
|
}
|
|
2144
2147
|
catch (e) { }
|
|
@@ -2146,32 +2149,32 @@ const checkState$a = async (client$1, input) => {
|
|
|
2146
2149
|
catch (exception) {
|
|
2147
2150
|
reason = exception;
|
|
2148
2151
|
if (exception.name === "InternalServerErrorException") {
|
|
2149
|
-
return { state:
|
|
2152
|
+
return { state: WaiterState.RETRY, reason };
|
|
2150
2153
|
}
|
|
2151
2154
|
}
|
|
2152
|
-
return { state:
|
|
2155
|
+
return { state: WaiterState.RETRY, reason };
|
|
2153
2156
|
};
|
|
2154
2157
|
const waitForInputDetached = async (params, input) => {
|
|
2155
2158
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2156
|
-
return
|
|
2159
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
|
|
2157
2160
|
};
|
|
2158
2161
|
const waitUntilInputDetached = async (params, input) => {
|
|
2159
2162
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2160
|
-
const result = await
|
|
2161
|
-
return
|
|
2163
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
|
|
2164
|
+
return checkExceptions(result);
|
|
2162
2165
|
};
|
|
2163
2166
|
|
|
2164
|
-
const checkState$9 = async (client
|
|
2167
|
+
const checkState$9 = async (client, input) => {
|
|
2165
2168
|
let reason;
|
|
2166
2169
|
try {
|
|
2167
|
-
let result = await client
|
|
2170
|
+
let result = await client.send(new DescribeMultiplexCommand(input));
|
|
2168
2171
|
reason = result;
|
|
2169
2172
|
try {
|
|
2170
2173
|
const returnComparator = () => {
|
|
2171
2174
|
return result.State;
|
|
2172
2175
|
};
|
|
2173
2176
|
if (returnComparator() === "IDLE") {
|
|
2174
|
-
return { state:
|
|
2177
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
2175
2178
|
}
|
|
2176
2179
|
}
|
|
2177
2180
|
catch (e) { }
|
|
@@ -2180,7 +2183,7 @@ const checkState$9 = async (client$1, input) => {
|
|
|
2180
2183
|
return result.State;
|
|
2181
2184
|
};
|
|
2182
2185
|
if (returnComparator() === "CREATING") {
|
|
2183
|
-
return { state:
|
|
2186
|
+
return { state: WaiterState.RETRY, reason };
|
|
2184
2187
|
}
|
|
2185
2188
|
}
|
|
2186
2189
|
catch (e) { }
|
|
@@ -2189,7 +2192,7 @@ const checkState$9 = async (client$1, input) => {
|
|
|
2189
2192
|
return result.State;
|
|
2190
2193
|
};
|
|
2191
2194
|
if (returnComparator() === "CREATE_FAILED") {
|
|
2192
|
-
return { state:
|
|
2195
|
+
return { state: WaiterState.FAILURE, reason };
|
|
2193
2196
|
}
|
|
2194
2197
|
}
|
|
2195
2198
|
catch (e) { }
|
|
@@ -2197,32 +2200,32 @@ const checkState$9 = async (client$1, input) => {
|
|
|
2197
2200
|
catch (exception) {
|
|
2198
2201
|
reason = exception;
|
|
2199
2202
|
if (exception.name === "InternalServerErrorException") {
|
|
2200
|
-
return { state:
|
|
2203
|
+
return { state: WaiterState.RETRY, reason };
|
|
2201
2204
|
}
|
|
2202
2205
|
}
|
|
2203
|
-
return { state:
|
|
2206
|
+
return { state: WaiterState.RETRY, reason };
|
|
2204
2207
|
};
|
|
2205
2208
|
const waitForMultiplexCreated = async (params, input) => {
|
|
2206
2209
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
2207
|
-
return
|
|
2210
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
|
|
2208
2211
|
};
|
|
2209
2212
|
const waitUntilMultiplexCreated = async (params, input) => {
|
|
2210
2213
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
2211
|
-
const result = await
|
|
2212
|
-
return
|
|
2214
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
|
|
2215
|
+
return checkExceptions(result);
|
|
2213
2216
|
};
|
|
2214
2217
|
|
|
2215
|
-
const checkState$8 = async (client
|
|
2218
|
+
const checkState$8 = async (client, input) => {
|
|
2216
2219
|
let reason;
|
|
2217
2220
|
try {
|
|
2218
|
-
let result = await client
|
|
2221
|
+
let result = await client.send(new DescribeMultiplexCommand(input));
|
|
2219
2222
|
reason = result;
|
|
2220
2223
|
try {
|
|
2221
2224
|
const returnComparator = () => {
|
|
2222
2225
|
return result.State;
|
|
2223
2226
|
};
|
|
2224
2227
|
if (returnComparator() === "DELETED") {
|
|
2225
|
-
return { state:
|
|
2228
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
2226
2229
|
}
|
|
2227
2230
|
}
|
|
2228
2231
|
catch (e) { }
|
|
@@ -2231,7 +2234,7 @@ const checkState$8 = async (client$1, input) => {
|
|
|
2231
2234
|
return result.State;
|
|
2232
2235
|
};
|
|
2233
2236
|
if (returnComparator() === "DELETING") {
|
|
2234
|
-
return { state:
|
|
2237
|
+
return { state: WaiterState.RETRY, reason };
|
|
2235
2238
|
}
|
|
2236
2239
|
}
|
|
2237
2240
|
catch (e) { }
|
|
@@ -2239,32 +2242,32 @@ const checkState$8 = async (client$1, input) => {
|
|
|
2239
2242
|
catch (exception) {
|
|
2240
2243
|
reason = exception;
|
|
2241
2244
|
if (exception.name === "InternalServerErrorException") {
|
|
2242
|
-
return { state:
|
|
2245
|
+
return { state: WaiterState.RETRY, reason };
|
|
2243
2246
|
}
|
|
2244
2247
|
}
|
|
2245
|
-
return { state:
|
|
2248
|
+
return { state: WaiterState.RETRY, reason };
|
|
2246
2249
|
};
|
|
2247
2250
|
const waitForMultiplexDeleted = async (params, input) => {
|
|
2248
2251
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2249
|
-
return
|
|
2252
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
|
|
2250
2253
|
};
|
|
2251
2254
|
const waitUntilMultiplexDeleted = async (params, input) => {
|
|
2252
2255
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2253
|
-
const result = await
|
|
2254
|
-
return
|
|
2256
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
|
|
2257
|
+
return checkExceptions(result);
|
|
2255
2258
|
};
|
|
2256
2259
|
|
|
2257
|
-
const checkState$7 = async (client
|
|
2260
|
+
const checkState$7 = async (client, input) => {
|
|
2258
2261
|
let reason;
|
|
2259
2262
|
try {
|
|
2260
|
-
let result = await client
|
|
2263
|
+
let result = await client.send(new DescribeMultiplexCommand(input));
|
|
2261
2264
|
reason = result;
|
|
2262
2265
|
try {
|
|
2263
2266
|
const returnComparator = () => {
|
|
2264
2267
|
return result.State;
|
|
2265
2268
|
};
|
|
2266
2269
|
if (returnComparator() === "RUNNING") {
|
|
2267
|
-
return { state:
|
|
2270
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
2268
2271
|
}
|
|
2269
2272
|
}
|
|
2270
2273
|
catch (e) { }
|
|
@@ -2273,7 +2276,7 @@ const checkState$7 = async (client$1, input) => {
|
|
|
2273
2276
|
return result.State;
|
|
2274
2277
|
};
|
|
2275
2278
|
if (returnComparator() === "STARTING") {
|
|
2276
|
-
return { state:
|
|
2279
|
+
return { state: WaiterState.RETRY, reason };
|
|
2277
2280
|
}
|
|
2278
2281
|
}
|
|
2279
2282
|
catch (e) { }
|
|
@@ -2281,32 +2284,32 @@ const checkState$7 = async (client$1, input) => {
|
|
|
2281
2284
|
catch (exception) {
|
|
2282
2285
|
reason = exception;
|
|
2283
2286
|
if (exception.name === "InternalServerErrorException") {
|
|
2284
|
-
return { state:
|
|
2287
|
+
return { state: WaiterState.RETRY, reason };
|
|
2285
2288
|
}
|
|
2286
2289
|
}
|
|
2287
|
-
return { state:
|
|
2290
|
+
return { state: WaiterState.RETRY, reason };
|
|
2288
2291
|
};
|
|
2289
2292
|
const waitForMultiplexRunning = async (params, input) => {
|
|
2290
2293
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2291
|
-
return
|
|
2294
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
|
|
2292
2295
|
};
|
|
2293
2296
|
const waitUntilMultiplexRunning = async (params, input) => {
|
|
2294
2297
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2295
|
-
const result = await
|
|
2296
|
-
return
|
|
2298
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
|
|
2299
|
+
return checkExceptions(result);
|
|
2297
2300
|
};
|
|
2298
2301
|
|
|
2299
|
-
const checkState$6 = async (client
|
|
2302
|
+
const checkState$6 = async (client, input) => {
|
|
2300
2303
|
let reason;
|
|
2301
2304
|
try {
|
|
2302
|
-
let result = await client
|
|
2305
|
+
let result = await client.send(new DescribeMultiplexCommand(input));
|
|
2303
2306
|
reason = result;
|
|
2304
2307
|
try {
|
|
2305
2308
|
const returnComparator = () => {
|
|
2306
2309
|
return result.State;
|
|
2307
2310
|
};
|
|
2308
2311
|
if (returnComparator() === "IDLE") {
|
|
2309
|
-
return { state:
|
|
2312
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
2310
2313
|
}
|
|
2311
2314
|
}
|
|
2312
2315
|
catch (e) { }
|
|
@@ -2315,7 +2318,7 @@ const checkState$6 = async (client$1, input) => {
|
|
|
2315
2318
|
return result.State;
|
|
2316
2319
|
};
|
|
2317
2320
|
if (returnComparator() === "STOPPING") {
|
|
2318
|
-
return { state:
|
|
2321
|
+
return { state: WaiterState.RETRY, reason };
|
|
2319
2322
|
}
|
|
2320
2323
|
}
|
|
2321
2324
|
catch (e) { }
|
|
@@ -2323,32 +2326,32 @@ const checkState$6 = async (client$1, input) => {
|
|
|
2323
2326
|
catch (exception) {
|
|
2324
2327
|
reason = exception;
|
|
2325
2328
|
if (exception.name === "InternalServerErrorException") {
|
|
2326
|
-
return { state:
|
|
2329
|
+
return { state: WaiterState.RETRY, reason };
|
|
2327
2330
|
}
|
|
2328
2331
|
}
|
|
2329
|
-
return { state:
|
|
2332
|
+
return { state: WaiterState.RETRY, reason };
|
|
2330
2333
|
};
|
|
2331
2334
|
const waitForMultiplexStopped = async (params, input) => {
|
|
2332
2335
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2333
|
-
return
|
|
2336
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
|
|
2334
2337
|
};
|
|
2335
2338
|
const waitUntilMultiplexStopped = async (params, input) => {
|
|
2336
2339
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2337
|
-
const result = await
|
|
2338
|
-
return
|
|
2340
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
|
|
2341
|
+
return checkExceptions(result);
|
|
2339
2342
|
};
|
|
2340
2343
|
|
|
2341
|
-
const checkState$5 = async (client
|
|
2344
|
+
const checkState$5 = async (client, input) => {
|
|
2342
2345
|
let reason;
|
|
2343
2346
|
try {
|
|
2344
|
-
let result = await client
|
|
2347
|
+
let result = await client.send(new DescribeNodeCommand(input));
|
|
2345
2348
|
reason = result;
|
|
2346
2349
|
try {
|
|
2347
2350
|
const returnComparator = () => {
|
|
2348
2351
|
return result.State;
|
|
2349
2352
|
};
|
|
2350
2353
|
if (returnComparator() === "DEREGISTERED") {
|
|
2351
|
-
return { state:
|
|
2354
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
2352
2355
|
}
|
|
2353
2356
|
}
|
|
2354
2357
|
catch (e) { }
|
|
@@ -2357,7 +2360,7 @@ const checkState$5 = async (client$1, input) => {
|
|
|
2357
2360
|
return result.State;
|
|
2358
2361
|
};
|
|
2359
2362
|
if (returnComparator() === "DEREGISTERING") {
|
|
2360
|
-
return { state:
|
|
2363
|
+
return { state: WaiterState.RETRY, reason };
|
|
2361
2364
|
}
|
|
2362
2365
|
}
|
|
2363
2366
|
catch (e) { }
|
|
@@ -2366,7 +2369,7 @@ const checkState$5 = async (client$1, input) => {
|
|
|
2366
2369
|
return result.State;
|
|
2367
2370
|
};
|
|
2368
2371
|
if (returnComparator() === "DRAINING") {
|
|
2369
|
-
return { state:
|
|
2372
|
+
return { state: WaiterState.RETRY, reason };
|
|
2370
2373
|
}
|
|
2371
2374
|
}
|
|
2372
2375
|
catch (e) { }
|
|
@@ -2374,32 +2377,32 @@ const checkState$5 = async (client$1, input) => {
|
|
|
2374
2377
|
catch (exception) {
|
|
2375
2378
|
reason = exception;
|
|
2376
2379
|
if (exception.name === "InternalServerErrorException") {
|
|
2377
|
-
return { state:
|
|
2380
|
+
return { state: WaiterState.RETRY, reason };
|
|
2378
2381
|
}
|
|
2379
2382
|
}
|
|
2380
|
-
return { state:
|
|
2383
|
+
return { state: WaiterState.RETRY, reason };
|
|
2381
2384
|
};
|
|
2382
2385
|
const waitForNodeDeregistered = async (params, input) => {
|
|
2383
2386
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2384
|
-
return
|
|
2387
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
|
|
2385
2388
|
};
|
|
2386
2389
|
const waitUntilNodeDeregistered = async (params, input) => {
|
|
2387
2390
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2388
|
-
const result = await
|
|
2389
|
-
return
|
|
2391
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
|
|
2392
|
+
return checkExceptions(result);
|
|
2390
2393
|
};
|
|
2391
2394
|
|
|
2392
|
-
const checkState$4 = async (client
|
|
2395
|
+
const checkState$4 = async (client, input) => {
|
|
2393
2396
|
let reason;
|
|
2394
2397
|
try {
|
|
2395
|
-
let result = await client
|
|
2398
|
+
let result = await client.send(new DescribeNodeCommand(input));
|
|
2396
2399
|
reason = result;
|
|
2397
2400
|
try {
|
|
2398
2401
|
const returnComparator = () => {
|
|
2399
2402
|
return result.State;
|
|
2400
2403
|
};
|
|
2401
2404
|
if (returnComparator() === "ACTIVE") {
|
|
2402
|
-
return { state:
|
|
2405
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
2403
2406
|
}
|
|
2404
2407
|
}
|
|
2405
2408
|
catch (e) { }
|
|
@@ -2408,7 +2411,7 @@ const checkState$4 = async (client$1, input) => {
|
|
|
2408
2411
|
return result.State;
|
|
2409
2412
|
};
|
|
2410
2413
|
if (returnComparator() === "REGISTERING") {
|
|
2411
|
-
return { state:
|
|
2414
|
+
return { state: WaiterState.RETRY, reason };
|
|
2412
2415
|
}
|
|
2413
2416
|
}
|
|
2414
2417
|
catch (e) { }
|
|
@@ -2417,7 +2420,7 @@ const checkState$4 = async (client$1, input) => {
|
|
|
2417
2420
|
return result.State;
|
|
2418
2421
|
};
|
|
2419
2422
|
if (returnComparator() === "REGISTRATION_FAILED") {
|
|
2420
|
-
return { state:
|
|
2423
|
+
return { state: WaiterState.FAILURE, reason };
|
|
2421
2424
|
}
|
|
2422
2425
|
}
|
|
2423
2426
|
catch (e) { }
|
|
@@ -2425,35 +2428,35 @@ const checkState$4 = async (client$1, input) => {
|
|
|
2425
2428
|
catch (exception) {
|
|
2426
2429
|
reason = exception;
|
|
2427
2430
|
if (exception.name === "NotFoundException") {
|
|
2428
|
-
return { state:
|
|
2431
|
+
return { state: WaiterState.RETRY, reason };
|
|
2429
2432
|
}
|
|
2430
2433
|
if (exception.name === "InternalServerErrorException") {
|
|
2431
|
-
return { state:
|
|
2434
|
+
return { state: WaiterState.RETRY, reason };
|
|
2432
2435
|
}
|
|
2433
2436
|
}
|
|
2434
|
-
return { state:
|
|
2437
|
+
return { state: WaiterState.RETRY, reason };
|
|
2435
2438
|
};
|
|
2436
2439
|
const waitForNodeRegistered = async (params, input) => {
|
|
2437
2440
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
2438
|
-
return
|
|
2441
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
|
|
2439
2442
|
};
|
|
2440
2443
|
const waitUntilNodeRegistered = async (params, input) => {
|
|
2441
2444
|
const serviceDefaults = { minDelay: 3, maxDelay: 120 };
|
|
2442
|
-
const result = await
|
|
2443
|
-
return
|
|
2445
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
|
|
2446
|
+
return checkExceptions(result);
|
|
2444
2447
|
};
|
|
2445
2448
|
|
|
2446
|
-
const checkState$3 = async (client
|
|
2449
|
+
const checkState$3 = async (client, input) => {
|
|
2447
2450
|
let reason;
|
|
2448
2451
|
try {
|
|
2449
|
-
let result = await client
|
|
2452
|
+
let result = await client.send(new GetSignalMapCommand(input));
|
|
2450
2453
|
reason = result;
|
|
2451
2454
|
try {
|
|
2452
2455
|
const returnComparator = () => {
|
|
2453
2456
|
return result.Status;
|
|
2454
2457
|
};
|
|
2455
2458
|
if (returnComparator() === "CREATE_COMPLETE") {
|
|
2456
|
-
return { state:
|
|
2459
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
2457
2460
|
}
|
|
2458
2461
|
}
|
|
2459
2462
|
catch (e) { }
|
|
@@ -2462,7 +2465,7 @@ const checkState$3 = async (client$1, input) => {
|
|
|
2462
2465
|
return result.Status;
|
|
2463
2466
|
};
|
|
2464
2467
|
if (returnComparator() === "CREATE_IN_PROGRESS") {
|
|
2465
|
-
return { state:
|
|
2468
|
+
return { state: WaiterState.RETRY, reason };
|
|
2466
2469
|
}
|
|
2467
2470
|
}
|
|
2468
2471
|
catch (e) { }
|
|
@@ -2471,7 +2474,7 @@ const checkState$3 = async (client$1, input) => {
|
|
|
2471
2474
|
return result.Status;
|
|
2472
2475
|
};
|
|
2473
2476
|
if (returnComparator() === "CREATE_FAILED") {
|
|
2474
|
-
return { state:
|
|
2477
|
+
return { state: WaiterState.FAILURE, reason };
|
|
2475
2478
|
}
|
|
2476
2479
|
}
|
|
2477
2480
|
catch (e) { }
|
|
@@ -2479,29 +2482,29 @@ const checkState$3 = async (client$1, input) => {
|
|
|
2479
2482
|
catch (exception) {
|
|
2480
2483
|
reason = exception;
|
|
2481
2484
|
}
|
|
2482
|
-
return { state:
|
|
2485
|
+
return { state: WaiterState.RETRY, reason };
|
|
2483
2486
|
};
|
|
2484
2487
|
const waitForSignalMapCreated = async (params, input) => {
|
|
2485
2488
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2486
|
-
return
|
|
2489
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
|
|
2487
2490
|
};
|
|
2488
2491
|
const waitUntilSignalMapCreated = async (params, input) => {
|
|
2489
2492
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2490
|
-
const result = await
|
|
2491
|
-
return
|
|
2493
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
|
|
2494
|
+
return checkExceptions(result);
|
|
2492
2495
|
};
|
|
2493
2496
|
|
|
2494
|
-
const checkState$2 = async (client
|
|
2497
|
+
const checkState$2 = async (client, input) => {
|
|
2495
2498
|
let reason;
|
|
2496
2499
|
try {
|
|
2497
|
-
let result = await client
|
|
2500
|
+
let result = await client.send(new GetSignalMapCommand(input));
|
|
2498
2501
|
reason = result;
|
|
2499
2502
|
try {
|
|
2500
2503
|
const returnComparator = () => {
|
|
2501
2504
|
return result.MonitorDeployment.Status;
|
|
2502
2505
|
};
|
|
2503
2506
|
if (returnComparator() === "DELETE_COMPLETE") {
|
|
2504
|
-
return { state:
|
|
2507
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
2505
2508
|
}
|
|
2506
2509
|
}
|
|
2507
2510
|
catch (e) { }
|
|
@@ -2510,7 +2513,7 @@ const checkState$2 = async (client$1, input) => {
|
|
|
2510
2513
|
return result.MonitorDeployment.Status;
|
|
2511
2514
|
};
|
|
2512
2515
|
if (returnComparator() === "DELETE_IN_PROGRESS") {
|
|
2513
|
-
return { state:
|
|
2516
|
+
return { state: WaiterState.RETRY, reason };
|
|
2514
2517
|
}
|
|
2515
2518
|
}
|
|
2516
2519
|
catch (e) { }
|
|
@@ -2519,7 +2522,7 @@ const checkState$2 = async (client$1, input) => {
|
|
|
2519
2522
|
return result.MonitorDeployment.Status;
|
|
2520
2523
|
};
|
|
2521
2524
|
if (returnComparator() === "DELETE_FAILED") {
|
|
2522
|
-
return { state:
|
|
2525
|
+
return { state: WaiterState.FAILURE, reason };
|
|
2523
2526
|
}
|
|
2524
2527
|
}
|
|
2525
2528
|
catch (e) { }
|
|
@@ -2527,29 +2530,29 @@ const checkState$2 = async (client$1, input) => {
|
|
|
2527
2530
|
catch (exception) {
|
|
2528
2531
|
reason = exception;
|
|
2529
2532
|
}
|
|
2530
|
-
return { state:
|
|
2533
|
+
return { state: WaiterState.RETRY, reason };
|
|
2531
2534
|
};
|
|
2532
2535
|
const waitForSignalMapMonitorDeleted = async (params, input) => {
|
|
2533
2536
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2534
|
-
return
|
|
2537
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
|
|
2535
2538
|
};
|
|
2536
2539
|
const waitUntilSignalMapMonitorDeleted = async (params, input) => {
|
|
2537
2540
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2538
|
-
const result = await
|
|
2539
|
-
return
|
|
2541
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
|
|
2542
|
+
return checkExceptions(result);
|
|
2540
2543
|
};
|
|
2541
2544
|
|
|
2542
|
-
const checkState$1 = async (client
|
|
2545
|
+
const checkState$1 = async (client, input) => {
|
|
2543
2546
|
let reason;
|
|
2544
2547
|
try {
|
|
2545
|
-
let result = await client
|
|
2548
|
+
let result = await client.send(new GetSignalMapCommand(input));
|
|
2546
2549
|
reason = result;
|
|
2547
2550
|
try {
|
|
2548
2551
|
const returnComparator = () => {
|
|
2549
2552
|
return result.MonitorDeployment.Status;
|
|
2550
2553
|
};
|
|
2551
2554
|
if (returnComparator() === "DRY_RUN_DEPLOYMENT_COMPLETE") {
|
|
2552
|
-
return { state:
|
|
2555
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
2553
2556
|
}
|
|
2554
2557
|
}
|
|
2555
2558
|
catch (e) { }
|
|
@@ -2558,7 +2561,7 @@ const checkState$1 = async (client$1, input) => {
|
|
|
2558
2561
|
return result.MonitorDeployment.Status;
|
|
2559
2562
|
};
|
|
2560
2563
|
if (returnComparator() === "DEPLOYMENT_COMPLETE") {
|
|
2561
|
-
return { state:
|
|
2564
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
2562
2565
|
}
|
|
2563
2566
|
}
|
|
2564
2567
|
catch (e) { }
|
|
@@ -2567,7 +2570,7 @@ const checkState$1 = async (client$1, input) => {
|
|
|
2567
2570
|
return result.MonitorDeployment.Status;
|
|
2568
2571
|
};
|
|
2569
2572
|
if (returnComparator() === "DRY_RUN_DEPLOYMENT_IN_PROGRESS") {
|
|
2570
|
-
return { state:
|
|
2573
|
+
return { state: WaiterState.RETRY, reason };
|
|
2571
2574
|
}
|
|
2572
2575
|
}
|
|
2573
2576
|
catch (e) { }
|
|
@@ -2576,7 +2579,7 @@ const checkState$1 = async (client$1, input) => {
|
|
|
2576
2579
|
return result.MonitorDeployment.Status;
|
|
2577
2580
|
};
|
|
2578
2581
|
if (returnComparator() === "DEPLOYMENT_IN_PROGRESS") {
|
|
2579
|
-
return { state:
|
|
2582
|
+
return { state: WaiterState.RETRY, reason };
|
|
2580
2583
|
}
|
|
2581
2584
|
}
|
|
2582
2585
|
catch (e) { }
|
|
@@ -2585,7 +2588,7 @@ const checkState$1 = async (client$1, input) => {
|
|
|
2585
2588
|
return result.MonitorDeployment.Status;
|
|
2586
2589
|
};
|
|
2587
2590
|
if (returnComparator() === "DRY_RUN_DEPLOYMENT_FAILED") {
|
|
2588
|
-
return { state:
|
|
2591
|
+
return { state: WaiterState.FAILURE, reason };
|
|
2589
2592
|
}
|
|
2590
2593
|
}
|
|
2591
2594
|
catch (e) { }
|
|
@@ -2594,7 +2597,7 @@ const checkState$1 = async (client$1, input) => {
|
|
|
2594
2597
|
return result.MonitorDeployment.Status;
|
|
2595
2598
|
};
|
|
2596
2599
|
if (returnComparator() === "DEPLOYMENT_FAILED") {
|
|
2597
|
-
return { state:
|
|
2600
|
+
return { state: WaiterState.FAILURE, reason };
|
|
2598
2601
|
}
|
|
2599
2602
|
}
|
|
2600
2603
|
catch (e) { }
|
|
@@ -2602,29 +2605,29 @@ const checkState$1 = async (client$1, input) => {
|
|
|
2602
2605
|
catch (exception) {
|
|
2603
2606
|
reason = exception;
|
|
2604
2607
|
}
|
|
2605
|
-
return { state:
|
|
2608
|
+
return { state: WaiterState.RETRY, reason };
|
|
2606
2609
|
};
|
|
2607
2610
|
const waitForSignalMapMonitorDeployed = async (params, input) => {
|
|
2608
2611
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2609
|
-
return
|
|
2612
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
|
|
2610
2613
|
};
|
|
2611
2614
|
const waitUntilSignalMapMonitorDeployed = async (params, input) => {
|
|
2612
2615
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2613
|
-
const result = await
|
|
2614
|
-
return
|
|
2616
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
|
|
2617
|
+
return checkExceptions(result);
|
|
2615
2618
|
};
|
|
2616
2619
|
|
|
2617
|
-
const checkState = async (client
|
|
2620
|
+
const checkState = async (client, input) => {
|
|
2618
2621
|
let reason;
|
|
2619
2622
|
try {
|
|
2620
|
-
let result = await client
|
|
2623
|
+
let result = await client.send(new GetSignalMapCommand(input));
|
|
2621
2624
|
reason = result;
|
|
2622
2625
|
try {
|
|
2623
2626
|
const returnComparator = () => {
|
|
2624
2627
|
return result.Status;
|
|
2625
2628
|
};
|
|
2626
2629
|
if (returnComparator() === "UPDATE_COMPLETE") {
|
|
2627
|
-
return { state:
|
|
2630
|
+
return { state: WaiterState.SUCCESS, reason };
|
|
2628
2631
|
}
|
|
2629
2632
|
}
|
|
2630
2633
|
catch (e) { }
|
|
@@ -2633,7 +2636,7 @@ const checkState = async (client$1, input) => {
|
|
|
2633
2636
|
return result.Status;
|
|
2634
2637
|
};
|
|
2635
2638
|
if (returnComparator() === "UPDATE_IN_PROGRESS") {
|
|
2636
|
-
return { state:
|
|
2639
|
+
return { state: WaiterState.RETRY, reason };
|
|
2637
2640
|
}
|
|
2638
2641
|
}
|
|
2639
2642
|
catch (e) { }
|
|
@@ -2642,7 +2645,7 @@ const checkState = async (client$1, input) => {
|
|
|
2642
2645
|
return result.Status;
|
|
2643
2646
|
};
|
|
2644
2647
|
if (returnComparator() === "UPDATE_FAILED") {
|
|
2645
|
-
return { state:
|
|
2648
|
+
return { state: WaiterState.FAILURE, reason };
|
|
2646
2649
|
}
|
|
2647
2650
|
}
|
|
2648
2651
|
catch (e) { }
|
|
@@ -2651,7 +2654,7 @@ const checkState = async (client$1, input) => {
|
|
|
2651
2654
|
return result.Status;
|
|
2652
2655
|
};
|
|
2653
2656
|
if (returnComparator() === "UPDATE_REVERTED") {
|
|
2654
|
-
return { state:
|
|
2657
|
+
return { state: WaiterState.FAILURE, reason };
|
|
2655
2658
|
}
|
|
2656
2659
|
}
|
|
2657
2660
|
catch (e) { }
|
|
@@ -2659,16 +2662,16 @@ const checkState = async (client$1, input) => {
|
|
|
2659
2662
|
catch (exception) {
|
|
2660
2663
|
reason = exception;
|
|
2661
2664
|
}
|
|
2662
|
-
return { state:
|
|
2665
|
+
return { state: WaiterState.RETRY, reason };
|
|
2663
2666
|
};
|
|
2664
2667
|
const waitForSignalMapUpdated = async (params, input) => {
|
|
2665
2668
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2666
|
-
return
|
|
2669
|
+
return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
|
|
2667
2670
|
};
|
|
2668
2671
|
const waitUntilSignalMapUpdated = async (params, input) => {
|
|
2669
2672
|
const serviceDefaults = { minDelay: 5, maxDelay: 120 };
|
|
2670
|
-
const result = await
|
|
2671
|
-
return
|
|
2673
|
+
const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
|
|
2674
|
+
return checkExceptions(result);
|
|
2672
2675
|
};
|
|
2673
2676
|
|
|
2674
2677
|
const commands = {
|
|
@@ -2847,7 +2850,7 @@ const waiters = {
|
|
|
2847
2850
|
};
|
|
2848
2851
|
class MediaLive extends MediaLiveClient {
|
|
2849
2852
|
}
|
|
2850
|
-
|
|
2853
|
+
createAggregatedClient(commands, MediaLive, { paginators, waiters });
|
|
2851
2854
|
|
|
2852
2855
|
const DashRoleAudio = {
|
|
2853
2856
|
ALTERNATE: "ALTERNATE",
|
|
@@ -4611,9 +4614,6 @@ const UpdateNodeStateShape = {
|
|
|
4611
4614
|
DRAINING: "DRAINING",
|
|
4612
4615
|
};
|
|
4613
4616
|
|
|
4614
|
-
exports.$Command = client.Command;
|
|
4615
|
-
exports.__Client = client.Client;
|
|
4616
|
-
exports.MediaLiveServiceException = MediaLiveServiceException.MediaLiveServiceException;
|
|
4617
4617
|
exports.AacCodingMode = AacCodingMode;
|
|
4618
4618
|
exports.AacInputType = AacInputType;
|
|
4619
4619
|
exports.AacProfile = AacProfile;
|
|
@@ -5148,23 +5148,3 @@ exports.waitUntilSignalMapCreated = waitUntilSignalMapCreated;
|
|
|
5148
5148
|
exports.waitUntilSignalMapMonitorDeleted = waitUntilSignalMapMonitorDeleted;
|
|
5149
5149
|
exports.waitUntilSignalMapMonitorDeployed = waitUntilSignalMapMonitorDeployed;
|
|
5150
5150
|
exports.waitUntilSignalMapUpdated = waitUntilSignalMapUpdated;
|
|
5151
|
-
Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
|
|
5152
|
-
!Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
|
|
5153
|
-
Object.defineProperty(exports, '__proto__', {
|
|
5154
|
-
enumerable: true,
|
|
5155
|
-
value: schemas_0['__proto__']
|
|
5156
|
-
});
|
|
5157
|
-
|
|
5158
|
-
Object.keys(schemas_0).forEach(function (k) {
|
|
5159
|
-
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
|
|
5160
|
-
});
|
|
5161
|
-
Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
|
|
5162
|
-
!Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
|
|
5163
|
-
Object.defineProperty(exports, '__proto__', {
|
|
5164
|
-
enumerable: true,
|
|
5165
|
-
value: errors['__proto__']
|
|
5166
|
-
});
|
|
5167
|
-
|
|
5168
|
-
Object.keys(errors).forEach(function (k) {
|
|
5169
|
-
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
|
|
5170
|
-
});
|