@aws-sdk/client-route53-recovery-control-config 3.901.0 → 3.906.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/dist-cjs/index.js +1705 -1863
  2. package/package.json +5 -5
package/dist-cjs/index.js CHANGED
@@ -1,1929 +1,1771 @@
1
- "use strict";
2
- var __defProp = Object.defineProperty;
3
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
- var __getOwnPropNames = Object.getOwnPropertyNames;
5
- var __hasOwnProp = Object.prototype.hasOwnProperty;
6
- var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
7
- var __export = (target, all) => {
8
- for (var name in all)
9
- __defProp(target, name, { get: all[name], enumerable: true });
10
- };
11
- var __copyProps = (to, from, except, desc) => {
12
- if (from && typeof from === "object" || typeof from === "function") {
13
- for (let key of __getOwnPropNames(from))
14
- if (!__hasOwnProp.call(to, key) && key !== except)
15
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
16
- }
17
- return to;
18
- };
19
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
20
-
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- AccessDeniedException: () => AccessDeniedException,
25
- ConflictException: () => ConflictException,
26
- CreateClusterCommand: () => CreateClusterCommand,
27
- CreateControlPanelCommand: () => CreateControlPanelCommand,
28
- CreateRoutingControlCommand: () => CreateRoutingControlCommand,
29
- CreateSafetyRuleCommand: () => CreateSafetyRuleCommand,
30
- DeleteClusterCommand: () => DeleteClusterCommand,
31
- DeleteControlPanelCommand: () => DeleteControlPanelCommand,
32
- DeleteRoutingControlCommand: () => DeleteRoutingControlCommand,
33
- DeleteSafetyRuleCommand: () => DeleteSafetyRuleCommand,
34
- DescribeClusterCommand: () => DescribeClusterCommand,
35
- DescribeControlPanelCommand: () => DescribeControlPanelCommand,
36
- DescribeRoutingControlCommand: () => DescribeRoutingControlCommand,
37
- DescribeSafetyRuleCommand: () => DescribeSafetyRuleCommand,
38
- GetResourcePolicyCommand: () => GetResourcePolicyCommand,
39
- InternalServerException: () => InternalServerException,
40
- ListAssociatedRoute53HealthChecksCommand: () => ListAssociatedRoute53HealthChecksCommand,
41
- ListClustersCommand: () => ListClustersCommand,
42
- ListControlPanelsCommand: () => ListControlPanelsCommand,
43
- ListRoutingControlsCommand: () => ListRoutingControlsCommand,
44
- ListSafetyRulesCommand: () => ListSafetyRulesCommand,
45
- ListTagsForResourceCommand: () => ListTagsForResourceCommand,
46
- NetworkType: () => NetworkType,
47
- ResourceNotFoundException: () => ResourceNotFoundException,
48
- Route53RecoveryControlConfig: () => Route53RecoveryControlConfig,
49
- Route53RecoveryControlConfigClient: () => Route53RecoveryControlConfigClient,
50
- Route53RecoveryControlConfigServiceException: () => Route53RecoveryControlConfigServiceException,
51
- RuleType: () => RuleType,
52
- ServiceQuotaExceededException: () => ServiceQuotaExceededException,
53
- Status: () => Status,
54
- TagResourceCommand: () => TagResourceCommand,
55
- ThrottlingException: () => ThrottlingException,
56
- UntagResourceCommand: () => UntagResourceCommand,
57
- UpdateClusterCommand: () => UpdateClusterCommand,
58
- UpdateControlPanelCommand: () => UpdateControlPanelCommand,
59
- UpdateRoutingControlCommand: () => UpdateRoutingControlCommand,
60
- UpdateSafetyRuleCommand: () => UpdateSafetyRuleCommand,
61
- ValidationException: () => ValidationException,
62
- __Client: () => import_smithy_client.Client,
63
- paginateListAssociatedRoute53HealthChecks: () => paginateListAssociatedRoute53HealthChecks,
64
- paginateListClusters: () => paginateListClusters,
65
- paginateListControlPanels: () => paginateListControlPanels,
66
- paginateListRoutingControls: () => paginateListRoutingControls,
67
- paginateListSafetyRules: () => paginateListSafetyRules,
68
- waitForClusterCreated: () => waitForClusterCreated,
69
- waitForClusterDeleted: () => waitForClusterDeleted,
70
- waitForControlPanelCreated: () => waitForControlPanelCreated,
71
- waitForControlPanelDeleted: () => waitForControlPanelDeleted,
72
- waitForRoutingControlCreated: () => waitForRoutingControlCreated,
73
- waitForRoutingControlDeleted: () => waitForRoutingControlDeleted,
74
- waitUntilClusterCreated: () => waitUntilClusterCreated,
75
- waitUntilClusterDeleted: () => waitUntilClusterDeleted,
76
- waitUntilControlPanelCreated: () => waitUntilControlPanelCreated,
77
- waitUntilControlPanelDeleted: () => waitUntilControlPanelDeleted,
78
- waitUntilRoutingControlCreated: () => waitUntilRoutingControlCreated,
79
- waitUntilRoutingControlDeleted: () => waitUntilRoutingControlDeleted
80
- });
81
- module.exports = __toCommonJS(index_exports);
82
-
83
- // src/Route53RecoveryControlConfigClient.ts
84
- var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
85
- var import_middleware_logger = require("@aws-sdk/middleware-logger");
86
- var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
87
- var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
88
- var import_config_resolver = require("@smithy/config-resolver");
89
- var import_core = require("@smithy/core");
90
- var import_middleware_content_length = require("@smithy/middleware-content-length");
91
- var import_middleware_endpoint = require("@smithy/middleware-endpoint");
92
- var import_middleware_retry = require("@smithy/middleware-retry");
93
-
94
- var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
95
-
96
- // src/endpoint/EndpointParameters.ts
97
- var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
98
- return Object.assign(options, {
99
- useDualstackEndpoint: options.useDualstackEndpoint ?? false,
100
- useFipsEndpoint: options.useFipsEndpoint ?? false,
101
- defaultSigningName: "route53-recovery-control-config"
102
- });
103
- }, "resolveClientEndpointParameters");
104
- var commonParams = {
105
- UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
106
- Endpoint: { type: "builtInParams", name: "endpoint" },
107
- Region: { type: "builtInParams", name: "region" },
108
- UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
1
+ 'use strict';
2
+
3
+ var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
4
+ var middlewareLogger = require('@aws-sdk/middleware-logger');
5
+ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
6
+ var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
7
+ var configResolver = require('@smithy/config-resolver');
8
+ var core = require('@smithy/core');
9
+ var middlewareContentLength = require('@smithy/middleware-content-length');
10
+ var middlewareEndpoint = require('@smithy/middleware-endpoint');
11
+ var middlewareRetry = require('@smithy/middleware-retry');
12
+ var smithyClient = require('@smithy/smithy-client');
13
+ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
14
+ var runtimeConfig = require('./runtimeConfig');
15
+ var regionConfigResolver = require('@aws-sdk/region-config-resolver');
16
+ var protocolHttp = require('@smithy/protocol-http');
17
+ var middlewareSerde = require('@smithy/middleware-serde');
18
+ var core$1 = require('@aws-sdk/core');
19
+ var uuid = require('@smithy/uuid');
20
+ var utilWaiter = require('@smithy/util-waiter');
21
+
22
+ const resolveClientEndpointParameters = (options) => {
23
+ return Object.assign(options, {
24
+ useDualstackEndpoint: options.useDualstackEndpoint ?? false,
25
+ useFipsEndpoint: options.useFipsEndpoint ?? false,
26
+ defaultSigningName: "route53-recovery-control-config",
27
+ });
28
+ };
29
+ const commonParams = {
30
+ UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
31
+ Endpoint: { type: "builtInParams", name: "endpoint" },
32
+ Region: { type: "builtInParams", name: "region" },
33
+ UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
109
34
  };
110
35
 
111
- // src/Route53RecoveryControlConfigClient.ts
112
- var import_runtimeConfig = require("././runtimeConfig");
36
+ const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
37
+ const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
38
+ let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
39
+ let _credentials = runtimeConfig.credentials;
40
+ return {
41
+ setHttpAuthScheme(httpAuthScheme) {
42
+ const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
43
+ if (index === -1) {
44
+ _httpAuthSchemes.push(httpAuthScheme);
45
+ }
46
+ else {
47
+ _httpAuthSchemes.splice(index, 1, httpAuthScheme);
48
+ }
49
+ },
50
+ httpAuthSchemes() {
51
+ return _httpAuthSchemes;
52
+ },
53
+ setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
54
+ _httpAuthSchemeProvider = httpAuthSchemeProvider;
55
+ },
56
+ httpAuthSchemeProvider() {
57
+ return _httpAuthSchemeProvider;
58
+ },
59
+ setCredentials(credentials) {
60
+ _credentials = credentials;
61
+ },
62
+ credentials() {
63
+ return _credentials;
64
+ },
65
+ };
66
+ };
67
+ const resolveHttpAuthRuntimeConfig = (config) => {
68
+ return {
69
+ httpAuthSchemes: config.httpAuthSchemes(),
70
+ httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
71
+ credentials: config.credentials(),
72
+ };
73
+ };
113
74
 
114
- // src/runtimeExtensions.ts
115
- var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
116
- var import_protocol_http = require("@smithy/protocol-http");
117
- var import_smithy_client = require("@smithy/smithy-client");
75
+ const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
76
+ const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
77
+ extensions.forEach((extension) => extension.configure(extensionConfiguration));
78
+ return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
79
+ };
118
80
 
119
- // src/auth/httpAuthExtensionConfiguration.ts
120
- var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
121
- const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
122
- let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
123
- let _credentials = runtimeConfig.credentials;
124
- return {
125
- setHttpAuthScheme(httpAuthScheme) {
126
- const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
127
- if (index === -1) {
128
- _httpAuthSchemes.push(httpAuthScheme);
129
- } else {
130
- _httpAuthSchemes.splice(index, 1, httpAuthScheme);
131
- }
132
- },
133
- httpAuthSchemes() {
134
- return _httpAuthSchemes;
135
- },
136
- setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
137
- _httpAuthSchemeProvider = httpAuthSchemeProvider;
138
- },
139
- httpAuthSchemeProvider() {
140
- return _httpAuthSchemeProvider;
141
- },
142
- setCredentials(credentials) {
143
- _credentials = credentials;
144
- },
145
- credentials() {
146
- return _credentials;
81
+ class Route53RecoveryControlConfigClient extends smithyClient.Client {
82
+ config;
83
+ constructor(...[configuration]) {
84
+ const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
85
+ super(_config_0);
86
+ this.initConfig = _config_0;
87
+ const _config_1 = resolveClientEndpointParameters(_config_0);
88
+ const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
89
+ const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
90
+ const _config_4 = configResolver.resolveRegionConfig(_config_3);
91
+ const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
92
+ const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
93
+ const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
94
+ const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
95
+ this.config = _config_8;
96
+ this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
97
+ this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
98
+ this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
99
+ this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
100
+ this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
101
+ this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
102
+ this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
103
+ httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultRoute53RecoveryControlConfigHttpAuthSchemeParametersProvider,
104
+ identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
105
+ "aws.auth#sigv4": config.credentials,
106
+ }),
107
+ }));
108
+ this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
147
109
  }
148
- };
149
- }, "getHttpAuthExtensionConfiguration");
150
- var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
151
- return {
152
- httpAuthSchemes: config.httpAuthSchemes(),
153
- httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
154
- credentials: config.credentials()
155
- };
156
- }, "resolveHttpAuthRuntimeConfig");
110
+ destroy() {
111
+ super.destroy();
112
+ }
113
+ }
157
114
 
158
- // src/runtimeExtensions.ts
159
- var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
160
- const extensionConfiguration = Object.assign(
161
- (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
162
- (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
163
- (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
164
- getHttpAuthExtensionConfiguration(runtimeConfig)
165
- );
166
- extensions.forEach((extension) => extension.configure(extensionConfiguration));
167
- return Object.assign(
168
- runtimeConfig,
169
- (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
170
- (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
171
- (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
172
- resolveHttpAuthRuntimeConfig(extensionConfiguration)
173
- );
174
- }, "resolveRuntimeExtensions");
115
+ class Route53RecoveryControlConfigServiceException extends smithyClient.ServiceException {
116
+ constructor(options) {
117
+ super(options);
118
+ Object.setPrototypeOf(this, Route53RecoveryControlConfigServiceException.prototype);
119
+ }
120
+ }
175
121
 
176
- // src/Route53RecoveryControlConfigClient.ts
177
- var Route53RecoveryControlConfigClient = class extends import_smithy_client.Client {
178
- static {
179
- __name(this, "Route53RecoveryControlConfigClient");
180
- }
181
- /**
182
- * The resolved configuration of Route53RecoveryControlConfigClient class. This is resolved and normalized from the {@link Route53RecoveryControlConfigClientConfig | constructor configuration interface}.
183
- */
184
- config;
185
- constructor(...[configuration]) {
186
- const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
187
- super(_config_0);
188
- this.initConfig = _config_0;
189
- const _config_1 = resolveClientEndpointParameters(_config_0);
190
- const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
191
- const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
192
- const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
193
- const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
194
- const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
195
- const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
196
- const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
197
- this.config = _config_8;
198
- this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
199
- this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
200
- this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
201
- this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
202
- this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
203
- this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
204
- this.middlewareStack.use(
205
- (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
206
- httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultRoute53RecoveryControlConfigHttpAuthSchemeParametersProvider,
207
- identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
208
- "aws.auth#sigv4": config.credentials
209
- }), "identityProviderConfigProvider")
210
- })
211
- );
212
- this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
213
- }
214
- /**
215
- * Destroy underlying resources, like sockets. It's usually not necessary to do this.
216
- * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
217
- * Otherwise, sockets might stay open for quite a long time before the server terminates them.
218
- */
219
- destroy() {
220
- super.destroy();
221
- }
122
+ const NetworkType = {
123
+ DUALSTACK: "DUALSTACK",
124
+ IPV4: "IPV4",
222
125
  };
223
-
224
- // src/Route53RecoveryControlConfig.ts
225
-
226
-
227
- // src/commands/CreateClusterCommand.ts
228
-
229
- var import_middleware_serde = require("@smithy/middleware-serde");
230
-
231
-
232
- // src/protocols/Aws_restJson1.ts
233
- var import_core2 = require("@aws-sdk/core");
234
-
235
-
236
- var import_uuid = require("@smithy/uuid");
237
-
238
- // src/models/Route53RecoveryControlConfigServiceException.ts
239
-
240
- var Route53RecoveryControlConfigServiceException = class _Route53RecoveryControlConfigServiceException extends import_smithy_client.ServiceException {
241
- static {
242
- __name(this, "Route53RecoveryControlConfigServiceException");
243
- }
244
- /**
245
- * @internal
246
- */
247
- constructor(options) {
248
- super(options);
249
- Object.setPrototypeOf(this, _Route53RecoveryControlConfigServiceException.prototype);
250
- }
126
+ const Status = {
127
+ DEPLOYED: "DEPLOYED",
128
+ PENDING: "PENDING",
129
+ PENDING_DELETION: "PENDING_DELETION",
251
130
  };
252
-
253
- // src/models/models_0.ts
254
- var NetworkType = {
255
- DUALSTACK: "DUALSTACK",
256
- IPV4: "IPV4"
257
- };
258
- var Status = {
259
- DEPLOYED: "DEPLOYED",
260
- PENDING: "PENDING",
261
- PENDING_DELETION: "PENDING_DELETION"
262
- };
263
- var RuleType = {
264
- AND: "AND",
265
- ATLEAST: "ATLEAST",
266
- OR: "OR"
267
- };
268
- var AccessDeniedException = class _AccessDeniedException extends Route53RecoveryControlConfigServiceException {
269
- static {
270
- __name(this, "AccessDeniedException");
271
- }
272
- name = "AccessDeniedException";
273
- $fault = "client";
274
- Message;
275
- /**
276
- * @internal
277
- */
278
- constructor(opts) {
279
- super({
280
- name: "AccessDeniedException",
281
- $fault: "client",
282
- ...opts
283
- });
284
- Object.setPrototypeOf(this, _AccessDeniedException.prototype);
285
- this.Message = opts.Message;
286
- }
287
- };
288
- var ConflictException = class _ConflictException extends Route53RecoveryControlConfigServiceException {
289
- static {
290
- __name(this, "ConflictException");
291
- }
292
- name = "ConflictException";
293
- $fault = "client";
294
- Message;
295
- /**
296
- * @internal
297
- */
298
- constructor(opts) {
299
- super({
300
- name: "ConflictException",
301
- $fault: "client",
302
- ...opts
303
- });
304
- Object.setPrototypeOf(this, _ConflictException.prototype);
305
- this.Message = opts.Message;
306
- }
307
- };
308
- var InternalServerException = class _InternalServerException extends Route53RecoveryControlConfigServiceException {
309
- static {
310
- __name(this, "InternalServerException");
311
- }
312
- name = "InternalServerException";
313
- $fault = "server";
314
- Message;
315
- /**
316
- * @internal
317
- */
318
- constructor(opts) {
319
- super({
320
- name: "InternalServerException",
321
- $fault: "server",
322
- ...opts
323
- });
324
- Object.setPrototypeOf(this, _InternalServerException.prototype);
325
- this.Message = opts.Message;
326
- }
327
- };
328
- var ResourceNotFoundException = class _ResourceNotFoundException extends Route53RecoveryControlConfigServiceException {
329
- static {
330
- __name(this, "ResourceNotFoundException");
331
- }
332
- name = "ResourceNotFoundException";
333
- $fault = "client";
334
- Message;
335
- /**
336
- * @internal
337
- */
338
- constructor(opts) {
339
- super({
340
- name: "ResourceNotFoundException",
341
- $fault: "client",
342
- ...opts
343
- });
344
- Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
345
- this.Message = opts.Message;
346
- }
347
- };
348
- var ServiceQuotaExceededException = class _ServiceQuotaExceededException extends Route53RecoveryControlConfigServiceException {
349
- static {
350
- __name(this, "ServiceQuotaExceededException");
351
- }
352
- name = "ServiceQuotaExceededException";
353
- $fault = "client";
354
- Message;
355
- /**
356
- * @internal
357
- */
358
- constructor(opts) {
359
- super({
360
- name: "ServiceQuotaExceededException",
361
- $fault: "client",
362
- ...opts
363
- });
364
- Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
365
- this.Message = opts.Message;
366
- }
367
- };
368
- var ThrottlingException = class _ThrottlingException extends Route53RecoveryControlConfigServiceException {
369
- static {
370
- __name(this, "ThrottlingException");
371
- }
372
- name = "ThrottlingException";
373
- $fault = "client";
374
- Message;
375
- /**
376
- * @internal
377
- */
378
- constructor(opts) {
379
- super({
380
- name: "ThrottlingException",
381
- $fault: "client",
382
- ...opts
383
- });
384
- Object.setPrototypeOf(this, _ThrottlingException.prototype);
385
- this.Message = opts.Message;
386
- }
387
- };
388
- var ValidationException = class _ValidationException extends Route53RecoveryControlConfigServiceException {
389
- static {
390
- __name(this, "ValidationException");
391
- }
392
- name = "ValidationException";
393
- $fault = "client";
394
- Message;
395
- /**
396
- * @internal
397
- */
398
- constructor(opts) {
399
- super({
400
- name: "ValidationException",
401
- $fault: "client",
402
- ...opts
403
- });
404
- Object.setPrototypeOf(this, _ValidationException.prototype);
405
- this.Message = opts.Message;
406
- }
131
+ const RuleType = {
132
+ AND: "AND",
133
+ ATLEAST: "ATLEAST",
134
+ OR: "OR",
407
135
  };
408
-
409
- // src/protocols/Aws_restJson1.ts
410
- var se_CreateClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
411
- const b = (0, import_core.requestBuilder)(input, context);
412
- const headers = {
413
- "content-type": "application/json"
414
- };
415
- b.bp("/cluster");
416
- let body;
417
- body = JSON.stringify(
418
- (0, import_smithy_client.take)(input, {
419
- ClientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
420
- ClusterName: [],
421
- NetworkType: [],
422
- Tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Tags")
423
- })
424
- );
425
- b.m("POST").h(headers).b(body);
426
- return b.build();
427
- }, "se_CreateClusterCommand");
428
- var se_CreateControlPanelCommand = /* @__PURE__ */ __name(async (input, context) => {
429
- const b = (0, import_core.requestBuilder)(input, context);
430
- const headers = {
431
- "content-type": "application/json"
432
- };
433
- b.bp("/controlpanel");
434
- let body;
435
- body = JSON.stringify(
436
- (0, import_smithy_client.take)(input, {
437
- ClientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
438
- ClusterArn: [],
439
- ControlPanelName: [],
440
- Tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Tags")
441
- })
442
- );
443
- b.m("POST").h(headers).b(body);
444
- return b.build();
445
- }, "se_CreateControlPanelCommand");
446
- var se_CreateRoutingControlCommand = /* @__PURE__ */ __name(async (input, context) => {
447
- const b = (0, import_core.requestBuilder)(input, context);
448
- const headers = {
449
- "content-type": "application/json"
450
- };
451
- b.bp("/routingcontrol");
452
- let body;
453
- body = JSON.stringify(
454
- (0, import_smithy_client.take)(input, {
455
- ClientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
456
- ClusterArn: [],
457
- ControlPanelArn: [],
458
- RoutingControlName: []
459
- })
460
- );
461
- b.m("POST").h(headers).b(body);
462
- return b.build();
463
- }, "se_CreateRoutingControlCommand");
464
- var se_CreateSafetyRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
465
- const b = (0, import_core.requestBuilder)(input, context);
466
- const headers = {
467
- "content-type": "application/json"
468
- };
469
- b.bp("/safetyrule");
470
- let body;
471
- body = JSON.stringify(
472
- (0, import_smithy_client.take)(input, {
473
- AssertionRule: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "AssertionRule"),
474
- ClientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
475
- GatingRule: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "GatingRule"),
476
- Tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Tags")
477
- })
478
- );
479
- b.m("POST").h(headers).b(body);
480
- return b.build();
481
- }, "se_CreateSafetyRuleCommand");
482
- var se_DeleteClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
483
- const b = (0, import_core.requestBuilder)(input, context);
484
- const headers = {};
485
- b.bp("/cluster/{ClusterArn}");
486
- b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
487
- let body;
488
- b.m("DELETE").h(headers).b(body);
489
- return b.build();
490
- }, "se_DeleteClusterCommand");
491
- var se_DeleteControlPanelCommand = /* @__PURE__ */ __name(async (input, context) => {
492
- const b = (0, import_core.requestBuilder)(input, context);
493
- const headers = {};
494
- b.bp("/controlpanel/{ControlPanelArn}");
495
- b.p("ControlPanelArn", () => input.ControlPanelArn, "{ControlPanelArn}", false);
496
- let body;
497
- b.m("DELETE").h(headers).b(body);
498
- return b.build();
499
- }, "se_DeleteControlPanelCommand");
500
- var se_DeleteRoutingControlCommand = /* @__PURE__ */ __name(async (input, context) => {
501
- const b = (0, import_core.requestBuilder)(input, context);
502
- const headers = {};
503
- b.bp("/routingcontrol/{RoutingControlArn}");
504
- b.p("RoutingControlArn", () => input.RoutingControlArn, "{RoutingControlArn}", false);
505
- let body;
506
- b.m("DELETE").h(headers).b(body);
507
- return b.build();
508
- }, "se_DeleteRoutingControlCommand");
509
- var se_DeleteSafetyRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
510
- const b = (0, import_core.requestBuilder)(input, context);
511
- const headers = {};
512
- b.bp("/safetyrule/{SafetyRuleArn}");
513
- b.p("SafetyRuleArn", () => input.SafetyRuleArn, "{SafetyRuleArn}", false);
514
- let body;
515
- b.m("DELETE").h(headers).b(body);
516
- return b.build();
517
- }, "se_DeleteSafetyRuleCommand");
518
- var se_DescribeClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
519
- const b = (0, import_core.requestBuilder)(input, context);
520
- const headers = {};
521
- b.bp("/cluster/{ClusterArn}");
522
- b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
523
- let body;
524
- b.m("GET").h(headers).b(body);
525
- return b.build();
526
- }, "se_DescribeClusterCommand");
527
- var se_DescribeControlPanelCommand = /* @__PURE__ */ __name(async (input, context) => {
528
- const b = (0, import_core.requestBuilder)(input, context);
529
- const headers = {};
530
- b.bp("/controlpanel/{ControlPanelArn}");
531
- b.p("ControlPanelArn", () => input.ControlPanelArn, "{ControlPanelArn}", false);
532
- let body;
533
- b.m("GET").h(headers).b(body);
534
- return b.build();
535
- }, "se_DescribeControlPanelCommand");
536
- var se_DescribeRoutingControlCommand = /* @__PURE__ */ __name(async (input, context) => {
537
- const b = (0, import_core.requestBuilder)(input, context);
538
- const headers = {};
539
- b.bp("/routingcontrol/{RoutingControlArn}");
540
- b.p("RoutingControlArn", () => input.RoutingControlArn, "{RoutingControlArn}", false);
541
- let body;
542
- b.m("GET").h(headers).b(body);
543
- return b.build();
544
- }, "se_DescribeRoutingControlCommand");
545
- var se_DescribeSafetyRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
546
- const b = (0, import_core.requestBuilder)(input, context);
547
- const headers = {};
548
- b.bp("/safetyrule/{SafetyRuleArn}");
549
- b.p("SafetyRuleArn", () => input.SafetyRuleArn, "{SafetyRuleArn}", false);
550
- let body;
551
- b.m("GET").h(headers).b(body);
552
- return b.build();
553
- }, "se_DescribeSafetyRuleCommand");
554
- var se_GetResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
555
- const b = (0, import_core.requestBuilder)(input, context);
556
- const headers = {};
557
- b.bp("/resourcePolicy/{ResourceArn}");
558
- b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
559
- let body;
560
- b.m("GET").h(headers).b(body);
561
- return b.build();
562
- }, "se_GetResourcePolicyCommand");
563
- var se_ListAssociatedRoute53HealthChecksCommand = /* @__PURE__ */ __name(async (input, context) => {
564
- const b = (0, import_core.requestBuilder)(input, context);
565
- const headers = {};
566
- b.bp("/routingcontrol/{RoutingControlArn}/associatedRoute53HealthChecks");
567
- b.p("RoutingControlArn", () => input.RoutingControlArn, "{RoutingControlArn}", false);
568
- const query = (0, import_smithy_client.map)({
569
- [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
570
- [_NT]: [, input[_NT]]
571
- });
572
- let body;
573
- b.m("GET").h(headers).q(query).b(body);
574
- return b.build();
575
- }, "se_ListAssociatedRoute53HealthChecksCommand");
576
- var se_ListClustersCommand = /* @__PURE__ */ __name(async (input, context) => {
577
- const b = (0, import_core.requestBuilder)(input, context);
578
- const headers = {};
579
- b.bp("/cluster");
580
- const query = (0, import_smithy_client.map)({
581
- [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
582
- [_NT]: [, input[_NT]]
583
- });
584
- let body;
585
- b.m("GET").h(headers).q(query).b(body);
586
- return b.build();
587
- }, "se_ListClustersCommand");
588
- var se_ListControlPanelsCommand = /* @__PURE__ */ __name(async (input, context) => {
589
- const b = (0, import_core.requestBuilder)(input, context);
590
- const headers = {};
591
- b.bp("/controlpanels");
592
- const query = (0, import_smithy_client.map)({
593
- [_CA]: [, input[_CA]],
594
- [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
595
- [_NT]: [, input[_NT]]
596
- });
597
- let body;
598
- b.m("GET").h(headers).q(query).b(body);
599
- return b.build();
600
- }, "se_ListControlPanelsCommand");
601
- var se_ListRoutingControlsCommand = /* @__PURE__ */ __name(async (input, context) => {
602
- const b = (0, import_core.requestBuilder)(input, context);
603
- const headers = {};
604
- b.bp("/controlpanel/{ControlPanelArn}/routingcontrols");
605
- b.p("ControlPanelArn", () => input.ControlPanelArn, "{ControlPanelArn}", false);
606
- const query = (0, import_smithy_client.map)({
607
- [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
608
- [_NT]: [, input[_NT]]
609
- });
610
- let body;
611
- b.m("GET").h(headers).q(query).b(body);
612
- return b.build();
613
- }, "se_ListRoutingControlsCommand");
614
- var se_ListSafetyRulesCommand = /* @__PURE__ */ __name(async (input, context) => {
615
- const b = (0, import_core.requestBuilder)(input, context);
616
- const headers = {};
617
- b.bp("/controlpanel/{ControlPanelArn}/safetyrules");
618
- b.p("ControlPanelArn", () => input.ControlPanelArn, "{ControlPanelArn}", false);
619
- const query = (0, import_smithy_client.map)({
620
- [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
621
- [_NT]: [, input[_NT]]
622
- });
623
- let body;
624
- b.m("GET").h(headers).q(query).b(body);
625
- return b.build();
626
- }, "se_ListSafetyRulesCommand");
627
- var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
628
- const b = (0, import_core.requestBuilder)(input, context);
629
- const headers = {};
630
- b.bp("/tags/{ResourceArn}");
631
- b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
632
- let body;
633
- b.m("GET").h(headers).b(body);
634
- return b.build();
635
- }, "se_ListTagsForResourceCommand");
636
- var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
637
- const b = (0, import_core.requestBuilder)(input, context);
638
- const headers = {
639
- "content-type": "application/json"
640
- };
641
- b.bp("/tags/{ResourceArn}");
642
- b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
643
- let body;
644
- body = JSON.stringify(
645
- (0, import_smithy_client.take)(input, {
646
- Tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Tags")
647
- })
648
- );
649
- b.m("POST").h(headers).b(body);
650
- return b.build();
651
- }, "se_TagResourceCommand");
652
- var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
653
- const b = (0, import_core.requestBuilder)(input, context);
654
- const headers = {};
655
- b.bp("/tags/{ResourceArn}");
656
- b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
657
- const query = (0, import_smithy_client.map)({
658
- [_TK]: [(0, import_smithy_client.expectNonNull)(input.TagKeys, `TagKeys`) != null, () => input[_TK] || []]
659
- });
660
- let body;
661
- b.m("DELETE").h(headers).q(query).b(body);
662
- return b.build();
663
- }, "se_UntagResourceCommand");
664
- var se_UpdateClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
665
- const b = (0, import_core.requestBuilder)(input, context);
666
- const headers = {
667
- "content-type": "application/json"
668
- };
669
- b.bp("/cluster");
670
- let body;
671
- body = JSON.stringify(
672
- (0, import_smithy_client.take)(input, {
673
- ClusterArn: [],
674
- NetworkType: []
675
- })
676
- );
677
- b.m("PUT").h(headers).b(body);
678
- return b.build();
679
- }, "se_UpdateClusterCommand");
680
- var se_UpdateControlPanelCommand = /* @__PURE__ */ __name(async (input, context) => {
681
- const b = (0, import_core.requestBuilder)(input, context);
682
- const headers = {
683
- "content-type": "application/json"
684
- };
685
- b.bp("/controlpanel");
686
- let body;
687
- body = JSON.stringify(
688
- (0, import_smithy_client.take)(input, {
689
- ControlPanelArn: [],
690
- ControlPanelName: []
691
- })
692
- );
693
- b.m("PUT").h(headers).b(body);
694
- return b.build();
695
- }, "se_UpdateControlPanelCommand");
696
- var se_UpdateRoutingControlCommand = /* @__PURE__ */ __name(async (input, context) => {
697
- const b = (0, import_core.requestBuilder)(input, context);
698
- const headers = {
699
- "content-type": "application/json"
700
- };
701
- b.bp("/routingcontrol");
702
- let body;
703
- body = JSON.stringify(
704
- (0, import_smithy_client.take)(input, {
705
- RoutingControlArn: [],
706
- RoutingControlName: []
707
- })
708
- );
709
- b.m("PUT").h(headers).b(body);
710
- return b.build();
711
- }, "se_UpdateRoutingControlCommand");
712
- var se_UpdateSafetyRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
713
- const b = (0, import_core.requestBuilder)(input, context);
714
- const headers = {
715
- "content-type": "application/json"
716
- };
717
- b.bp("/safetyrule");
718
- let body;
719
- body = JSON.stringify(
720
- (0, import_smithy_client.take)(input, {
721
- AssertionRuleUpdate: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "AssertionRuleUpdate"),
722
- GatingRuleUpdate: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "GatingRuleUpdate")
723
- })
724
- );
725
- b.m("PUT").h(headers).b(body);
726
- return b.build();
727
- }, "se_UpdateSafetyRuleCommand");
728
- var de_CreateClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
729
- if (output.statusCode !== 200 && output.statusCode >= 300) {
730
- return de_CommandError(output, context);
731
- }
732
- const contents = (0, import_smithy_client.map)({
733
- $metadata: deserializeMetadata(output)
734
- });
735
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
736
- const doc = (0, import_smithy_client.take)(data, {
737
- Cluster: import_smithy_client._json
738
- });
739
- Object.assign(contents, doc);
740
- return contents;
741
- }, "de_CreateClusterCommand");
742
- var de_CreateControlPanelCommand = /* @__PURE__ */ __name(async (output, context) => {
743
- if (output.statusCode !== 200 && output.statusCode >= 300) {
744
- return de_CommandError(output, context);
745
- }
746
- const contents = (0, import_smithy_client.map)({
747
- $metadata: deserializeMetadata(output)
748
- });
749
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
750
- const doc = (0, import_smithy_client.take)(data, {
751
- ControlPanel: import_smithy_client._json
752
- });
753
- Object.assign(contents, doc);
754
- return contents;
755
- }, "de_CreateControlPanelCommand");
756
- var de_CreateRoutingControlCommand = /* @__PURE__ */ __name(async (output, context) => {
757
- if (output.statusCode !== 200 && output.statusCode >= 300) {
758
- return de_CommandError(output, context);
759
- }
760
- const contents = (0, import_smithy_client.map)({
761
- $metadata: deserializeMetadata(output)
762
- });
763
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
764
- const doc = (0, import_smithy_client.take)(data, {
765
- RoutingControl: import_smithy_client._json
766
- });
767
- Object.assign(contents, doc);
768
- return contents;
769
- }, "de_CreateRoutingControlCommand");
770
- var de_CreateSafetyRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
771
- if (output.statusCode !== 200 && output.statusCode >= 300) {
772
- return de_CommandError(output, context);
773
- }
774
- const contents = (0, import_smithy_client.map)({
775
- $metadata: deserializeMetadata(output)
776
- });
777
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
778
- const doc = (0, import_smithy_client.take)(data, {
779
- AssertionRule: import_smithy_client._json,
780
- GatingRule: import_smithy_client._json
781
- });
782
- Object.assign(contents, doc);
783
- return contents;
784
- }, "de_CreateSafetyRuleCommand");
785
- var de_DeleteClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
786
- if (output.statusCode !== 200 && output.statusCode >= 300) {
787
- return de_CommandError(output, context);
788
- }
789
- const contents = (0, import_smithy_client.map)({
790
- $metadata: deserializeMetadata(output)
791
- });
792
- await (0, import_smithy_client.collectBody)(output.body, context);
793
- return contents;
794
- }, "de_DeleteClusterCommand");
795
- var de_DeleteControlPanelCommand = /* @__PURE__ */ __name(async (output, context) => {
796
- if (output.statusCode !== 200 && output.statusCode >= 300) {
797
- return de_CommandError(output, context);
798
- }
799
- const contents = (0, import_smithy_client.map)({
800
- $metadata: deserializeMetadata(output)
801
- });
802
- await (0, import_smithy_client.collectBody)(output.body, context);
803
- return contents;
804
- }, "de_DeleteControlPanelCommand");
805
- var de_DeleteRoutingControlCommand = /* @__PURE__ */ __name(async (output, context) => {
806
- if (output.statusCode !== 200 && output.statusCode >= 300) {
807
- return de_CommandError(output, context);
808
- }
809
- const contents = (0, import_smithy_client.map)({
810
- $metadata: deserializeMetadata(output)
811
- });
812
- await (0, import_smithy_client.collectBody)(output.body, context);
813
- return contents;
814
- }, "de_DeleteRoutingControlCommand");
815
- var de_DeleteSafetyRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
816
- if (output.statusCode !== 200 && output.statusCode >= 300) {
817
- return de_CommandError(output, context);
818
- }
819
- const contents = (0, import_smithy_client.map)({
820
- $metadata: deserializeMetadata(output)
821
- });
822
- await (0, import_smithy_client.collectBody)(output.body, context);
823
- return contents;
824
- }, "de_DeleteSafetyRuleCommand");
825
- var de_DescribeClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
826
- if (output.statusCode !== 200 && output.statusCode >= 300) {
827
- return de_CommandError(output, context);
828
- }
829
- const contents = (0, import_smithy_client.map)({
830
- $metadata: deserializeMetadata(output)
831
- });
832
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
833
- const doc = (0, import_smithy_client.take)(data, {
834
- Cluster: import_smithy_client._json
835
- });
836
- Object.assign(contents, doc);
837
- return contents;
838
- }, "de_DescribeClusterCommand");
839
- var de_DescribeControlPanelCommand = /* @__PURE__ */ __name(async (output, context) => {
840
- if (output.statusCode !== 200 && output.statusCode >= 300) {
841
- return de_CommandError(output, context);
842
- }
843
- const contents = (0, import_smithy_client.map)({
844
- $metadata: deserializeMetadata(output)
845
- });
846
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
847
- const doc = (0, import_smithy_client.take)(data, {
848
- ControlPanel: import_smithy_client._json
849
- });
850
- Object.assign(contents, doc);
851
- return contents;
852
- }, "de_DescribeControlPanelCommand");
853
- var de_DescribeRoutingControlCommand = /* @__PURE__ */ __name(async (output, context) => {
854
- if (output.statusCode !== 200 && output.statusCode >= 300) {
855
- return de_CommandError(output, context);
856
- }
857
- const contents = (0, import_smithy_client.map)({
858
- $metadata: deserializeMetadata(output)
859
- });
860
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
861
- const doc = (0, import_smithy_client.take)(data, {
862
- RoutingControl: import_smithy_client._json
863
- });
864
- Object.assign(contents, doc);
865
- return contents;
866
- }, "de_DescribeRoutingControlCommand");
867
- var de_DescribeSafetyRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
868
- if (output.statusCode !== 200 && output.statusCode >= 300) {
869
- return de_CommandError(output, context);
870
- }
871
- const contents = (0, import_smithy_client.map)({
872
- $metadata: deserializeMetadata(output)
873
- });
874
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
875
- const doc = (0, import_smithy_client.take)(data, {
876
- AssertionRule: import_smithy_client._json,
877
- GatingRule: import_smithy_client._json
878
- });
879
- Object.assign(contents, doc);
880
- return contents;
881
- }, "de_DescribeSafetyRuleCommand");
882
- var de_GetResourcePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
883
- if (output.statusCode !== 200 && output.statusCode >= 300) {
884
- return de_CommandError(output, context);
885
- }
886
- const contents = (0, import_smithy_client.map)({
887
- $metadata: deserializeMetadata(output)
888
- });
889
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
890
- const doc = (0, import_smithy_client.take)(data, {
891
- Policy: import_smithy_client.expectString
892
- });
893
- Object.assign(contents, doc);
894
- return contents;
895
- }, "de_GetResourcePolicyCommand");
896
- var de_ListAssociatedRoute53HealthChecksCommand = /* @__PURE__ */ __name(async (output, context) => {
897
- if (output.statusCode !== 200 && output.statusCode >= 300) {
898
- return de_CommandError(output, context);
899
- }
900
- const contents = (0, import_smithy_client.map)({
901
- $metadata: deserializeMetadata(output)
902
- });
903
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
904
- const doc = (0, import_smithy_client.take)(data, {
905
- HealthCheckIds: import_smithy_client._json,
906
- NextToken: import_smithy_client.expectString
907
- });
908
- Object.assign(contents, doc);
909
- return contents;
910
- }, "de_ListAssociatedRoute53HealthChecksCommand");
911
- var de_ListClustersCommand = /* @__PURE__ */ __name(async (output, context) => {
912
- if (output.statusCode !== 200 && output.statusCode >= 300) {
913
- return de_CommandError(output, context);
914
- }
915
- const contents = (0, import_smithy_client.map)({
916
- $metadata: deserializeMetadata(output)
917
- });
918
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
919
- const doc = (0, import_smithy_client.take)(data, {
920
- Clusters: import_smithy_client._json,
921
- NextToken: import_smithy_client.expectString
922
- });
923
- Object.assign(contents, doc);
924
- return contents;
925
- }, "de_ListClustersCommand");
926
- var de_ListControlPanelsCommand = /* @__PURE__ */ __name(async (output, context) => {
927
- if (output.statusCode !== 200 && output.statusCode >= 300) {
928
- return de_CommandError(output, context);
929
- }
930
- const contents = (0, import_smithy_client.map)({
931
- $metadata: deserializeMetadata(output)
932
- });
933
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
934
- const doc = (0, import_smithy_client.take)(data, {
935
- ControlPanels: import_smithy_client._json,
936
- NextToken: import_smithy_client.expectString
937
- });
938
- Object.assign(contents, doc);
939
- return contents;
940
- }, "de_ListControlPanelsCommand");
941
- var de_ListRoutingControlsCommand = /* @__PURE__ */ __name(async (output, context) => {
942
- if (output.statusCode !== 200 && output.statusCode >= 300) {
943
- return de_CommandError(output, context);
944
- }
945
- const contents = (0, import_smithy_client.map)({
946
- $metadata: deserializeMetadata(output)
947
- });
948
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
949
- const doc = (0, import_smithy_client.take)(data, {
950
- NextToken: import_smithy_client.expectString,
951
- RoutingControls: import_smithy_client._json
952
- });
953
- Object.assign(contents, doc);
954
- return contents;
955
- }, "de_ListRoutingControlsCommand");
956
- var de_ListSafetyRulesCommand = /* @__PURE__ */ __name(async (output, context) => {
957
- if (output.statusCode !== 200 && output.statusCode >= 300) {
958
- return de_CommandError(output, context);
959
- }
960
- const contents = (0, import_smithy_client.map)({
961
- $metadata: deserializeMetadata(output)
962
- });
963
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
964
- const doc = (0, import_smithy_client.take)(data, {
965
- NextToken: import_smithy_client.expectString,
966
- SafetyRules: import_smithy_client._json
967
- });
968
- Object.assign(contents, doc);
969
- return contents;
970
- }, "de_ListSafetyRulesCommand");
971
- var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
972
- if (output.statusCode !== 200 && output.statusCode >= 300) {
973
- return de_CommandError(output, context);
974
- }
975
- const contents = (0, import_smithy_client.map)({
976
- $metadata: deserializeMetadata(output)
977
- });
978
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
979
- const doc = (0, import_smithy_client.take)(data, {
980
- Tags: import_smithy_client._json
981
- });
982
- Object.assign(contents, doc);
983
- return contents;
984
- }, "de_ListTagsForResourceCommand");
985
- var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
986
- if (output.statusCode !== 200 && output.statusCode >= 300) {
987
- return de_CommandError(output, context);
988
- }
989
- const contents = (0, import_smithy_client.map)({
990
- $metadata: deserializeMetadata(output)
991
- });
992
- await (0, import_smithy_client.collectBody)(output.body, context);
993
- return contents;
994
- }, "de_TagResourceCommand");
995
- var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
996
- if (output.statusCode !== 200 && output.statusCode >= 300) {
997
- return de_CommandError(output, context);
998
- }
999
- const contents = (0, import_smithy_client.map)({
1000
- $metadata: deserializeMetadata(output)
1001
- });
1002
- await (0, import_smithy_client.collectBody)(output.body, context);
1003
- return contents;
1004
- }, "de_UntagResourceCommand");
1005
- var de_UpdateClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
1006
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1007
- return de_CommandError(output, context);
1008
- }
1009
- const contents = (0, import_smithy_client.map)({
1010
- $metadata: deserializeMetadata(output)
1011
- });
1012
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1013
- const doc = (0, import_smithy_client.take)(data, {
1014
- Cluster: import_smithy_client._json
1015
- });
1016
- Object.assign(contents, doc);
1017
- return contents;
1018
- }, "de_UpdateClusterCommand");
1019
- var de_UpdateControlPanelCommand = /* @__PURE__ */ __name(async (output, context) => {
1020
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1021
- return de_CommandError(output, context);
1022
- }
1023
- const contents = (0, import_smithy_client.map)({
1024
- $metadata: deserializeMetadata(output)
1025
- });
1026
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1027
- const doc = (0, import_smithy_client.take)(data, {
1028
- ControlPanel: import_smithy_client._json
1029
- });
1030
- Object.assign(contents, doc);
1031
- return contents;
1032
- }, "de_UpdateControlPanelCommand");
1033
- var de_UpdateRoutingControlCommand = /* @__PURE__ */ __name(async (output, context) => {
1034
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1035
- return de_CommandError(output, context);
1036
- }
1037
- const contents = (0, import_smithy_client.map)({
1038
- $metadata: deserializeMetadata(output)
1039
- });
1040
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1041
- const doc = (0, import_smithy_client.take)(data, {
1042
- RoutingControl: import_smithy_client._json
1043
- });
1044
- Object.assign(contents, doc);
1045
- return contents;
1046
- }, "de_UpdateRoutingControlCommand");
1047
- var de_UpdateSafetyRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
1048
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1049
- return de_CommandError(output, context);
1050
- }
1051
- const contents = (0, import_smithy_client.map)({
1052
- $metadata: deserializeMetadata(output)
1053
- });
1054
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1055
- const doc = (0, import_smithy_client.take)(data, {
1056
- AssertionRule: import_smithy_client._json,
1057
- GatingRule: import_smithy_client._json
1058
- });
1059
- Object.assign(contents, doc);
1060
- return contents;
1061
- }, "de_UpdateSafetyRuleCommand");
1062
- var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
1063
- const parsedOutput = {
1064
- ...output,
1065
- body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
1066
- };
1067
- const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
1068
- switch (errorCode) {
1069
- case "AccessDeniedException":
1070
- case "com.amazonaws.route53recoverycontrolconfig#AccessDeniedException":
1071
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1072
- case "ConflictException":
1073
- case "com.amazonaws.route53recoverycontrolconfig#ConflictException":
1074
- throw await de_ConflictExceptionRes(parsedOutput, context);
1075
- case "InternalServerException":
1076
- case "com.amazonaws.route53recoverycontrolconfig#InternalServerException":
1077
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1078
- case "ResourceNotFoundException":
1079
- case "com.amazonaws.route53recoverycontrolconfig#ResourceNotFoundException":
1080
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1081
- case "ServiceQuotaExceededException":
1082
- case "com.amazonaws.route53recoverycontrolconfig#ServiceQuotaExceededException":
1083
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1084
- case "ThrottlingException":
1085
- case "com.amazonaws.route53recoverycontrolconfig#ThrottlingException":
1086
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1087
- case "ValidationException":
1088
- case "com.amazonaws.route53recoverycontrolconfig#ValidationException":
1089
- throw await de_ValidationExceptionRes(parsedOutput, context);
1090
- default:
1091
- const parsedBody = parsedOutput.body;
1092
- return throwDefaultError({
1093
- output,
1094
- parsedBody,
1095
- errorCode
1096
- });
1097
- }
1098
- }, "de_CommandError");
1099
- var throwDefaultError = (0, import_smithy_client.withBaseException)(Route53RecoveryControlConfigServiceException);
1100
- var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1101
- const contents = (0, import_smithy_client.map)({});
1102
- const data = parsedOutput.body;
1103
- const doc = (0, import_smithy_client.take)(data, {
1104
- Message: [, import_smithy_client.expectString, `message`]
1105
- });
1106
- Object.assign(contents, doc);
1107
- const exception = new AccessDeniedException({
1108
- $metadata: deserializeMetadata(parsedOutput),
1109
- ...contents
1110
- });
1111
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1112
- }, "de_AccessDeniedExceptionRes");
1113
- var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1114
- const contents = (0, import_smithy_client.map)({});
1115
- const data = parsedOutput.body;
1116
- const doc = (0, import_smithy_client.take)(data, {
1117
- Message: [, import_smithy_client.expectString, `message`]
1118
- });
1119
- Object.assign(contents, doc);
1120
- const exception = new ConflictException({
1121
- $metadata: deserializeMetadata(parsedOutput),
1122
- ...contents
1123
- });
1124
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1125
- }, "de_ConflictExceptionRes");
1126
- var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1127
- const contents = (0, import_smithy_client.map)({});
1128
- const data = parsedOutput.body;
1129
- const doc = (0, import_smithy_client.take)(data, {
1130
- Message: [, import_smithy_client.expectString, `message`]
1131
- });
1132
- Object.assign(contents, doc);
1133
- const exception = new InternalServerException({
1134
- $metadata: deserializeMetadata(parsedOutput),
1135
- ...contents
1136
- });
1137
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1138
- }, "de_InternalServerExceptionRes");
1139
- var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1140
- const contents = (0, import_smithy_client.map)({});
1141
- const data = parsedOutput.body;
1142
- const doc = (0, import_smithy_client.take)(data, {
1143
- Message: [, import_smithy_client.expectString, `message`]
1144
- });
1145
- Object.assign(contents, doc);
1146
- const exception = new ResourceNotFoundException({
1147
- $metadata: deserializeMetadata(parsedOutput),
1148
- ...contents
1149
- });
1150
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1151
- }, "de_ResourceNotFoundExceptionRes");
1152
- var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1153
- const contents = (0, import_smithy_client.map)({});
1154
- const data = parsedOutput.body;
1155
- const doc = (0, import_smithy_client.take)(data, {
1156
- Message: [, import_smithy_client.expectString, `message`]
1157
- });
1158
- Object.assign(contents, doc);
1159
- const exception = new ServiceQuotaExceededException({
1160
- $metadata: deserializeMetadata(parsedOutput),
1161
- ...contents
1162
- });
1163
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1164
- }, "de_ServiceQuotaExceededExceptionRes");
1165
- var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1166
- const contents = (0, import_smithy_client.map)({});
1167
- const data = parsedOutput.body;
1168
- const doc = (0, import_smithy_client.take)(data, {
1169
- Message: [, import_smithy_client.expectString, `message`]
1170
- });
1171
- Object.assign(contents, doc);
1172
- const exception = new ThrottlingException({
1173
- $metadata: deserializeMetadata(parsedOutput),
1174
- ...contents
1175
- });
1176
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1177
- }, "de_ThrottlingExceptionRes");
1178
- var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1179
- const contents = (0, import_smithy_client.map)({});
1180
- const data = parsedOutput.body;
1181
- const doc = (0, import_smithy_client.take)(data, {
1182
- Message: [, import_smithy_client.expectString, `message`]
1183
- });
1184
- Object.assign(contents, doc);
1185
- const exception = new ValidationException({
1186
- $metadata: deserializeMetadata(parsedOutput),
1187
- ...contents
1188
- });
1189
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1190
- }, "de_ValidationExceptionRes");
1191
- var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
1192
- httpStatusCode: output.statusCode,
1193
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1194
- extendedRequestId: output.headers["x-amz-id-2"],
1195
- cfId: output.headers["x-amz-cf-id"]
1196
- }), "deserializeMetadata");
1197
- var _CA = "ClusterArn";
1198
- var _MR = "MaxResults";
1199
- var _NT = "NextToken";
1200
- var _TK = "TagKeys";
1201
-
1202
- // src/commands/CreateClusterCommand.ts
1203
- var CreateClusterCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1204
- return [
1205
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1206
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1207
- ];
1208
- }).s("Route53RecoveryControlConfig", "CreateCluster", {}).n("Route53RecoveryControlConfigClient", "CreateClusterCommand").f(void 0, void 0).ser(se_CreateClusterCommand).de(de_CreateClusterCommand).build() {
1209
- static {
1210
- __name(this, "CreateClusterCommand");
1211
- }
136
+ class AccessDeniedException extends Route53RecoveryControlConfigServiceException {
137
+ name = "AccessDeniedException";
138
+ $fault = "client";
139
+ Message;
140
+ constructor(opts) {
141
+ super({
142
+ name: "AccessDeniedException",
143
+ $fault: "client",
144
+ ...opts,
145
+ });
146
+ Object.setPrototypeOf(this, AccessDeniedException.prototype);
147
+ this.Message = opts.Message;
148
+ }
149
+ }
150
+ class ConflictException extends Route53RecoveryControlConfigServiceException {
151
+ name = "ConflictException";
152
+ $fault = "client";
153
+ Message;
154
+ constructor(opts) {
155
+ super({
156
+ name: "ConflictException",
157
+ $fault: "client",
158
+ ...opts,
159
+ });
160
+ Object.setPrototypeOf(this, ConflictException.prototype);
161
+ this.Message = opts.Message;
162
+ }
163
+ }
164
+ class InternalServerException extends Route53RecoveryControlConfigServiceException {
165
+ name = "InternalServerException";
166
+ $fault = "server";
167
+ Message;
168
+ constructor(opts) {
169
+ super({
170
+ name: "InternalServerException",
171
+ $fault: "server",
172
+ ...opts,
173
+ });
174
+ Object.setPrototypeOf(this, InternalServerException.prototype);
175
+ this.Message = opts.Message;
176
+ }
177
+ }
178
+ class ResourceNotFoundException extends Route53RecoveryControlConfigServiceException {
179
+ name = "ResourceNotFoundException";
180
+ $fault = "client";
181
+ Message;
182
+ constructor(opts) {
183
+ super({
184
+ name: "ResourceNotFoundException",
185
+ $fault: "client",
186
+ ...opts,
187
+ });
188
+ Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
189
+ this.Message = opts.Message;
190
+ }
191
+ }
192
+ class ServiceQuotaExceededException extends Route53RecoveryControlConfigServiceException {
193
+ name = "ServiceQuotaExceededException";
194
+ $fault = "client";
195
+ Message;
196
+ constructor(opts) {
197
+ super({
198
+ name: "ServiceQuotaExceededException",
199
+ $fault: "client",
200
+ ...opts,
201
+ });
202
+ Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
203
+ this.Message = opts.Message;
204
+ }
205
+ }
206
+ class ThrottlingException extends Route53RecoveryControlConfigServiceException {
207
+ name = "ThrottlingException";
208
+ $fault = "client";
209
+ Message;
210
+ constructor(opts) {
211
+ super({
212
+ name: "ThrottlingException",
213
+ $fault: "client",
214
+ ...opts,
215
+ });
216
+ Object.setPrototypeOf(this, ThrottlingException.prototype);
217
+ this.Message = opts.Message;
218
+ }
219
+ }
220
+ class ValidationException extends Route53RecoveryControlConfigServiceException {
221
+ name = "ValidationException";
222
+ $fault = "client";
223
+ Message;
224
+ constructor(opts) {
225
+ super({
226
+ name: "ValidationException",
227
+ $fault: "client",
228
+ ...opts,
229
+ });
230
+ Object.setPrototypeOf(this, ValidationException.prototype);
231
+ this.Message = opts.Message;
232
+ }
233
+ }
234
+
235
+ const se_CreateClusterCommand = async (input, context) => {
236
+ const b = core.requestBuilder(input, context);
237
+ const headers = {
238
+ "content-type": "application/json",
239
+ };
240
+ b.bp("/cluster");
241
+ let body;
242
+ body = JSON.stringify(smithyClient.take(input, {
243
+ ClientToken: [true, (_) => _ ?? uuid.v4()],
244
+ ClusterName: [],
245
+ NetworkType: [],
246
+ Tags: (_) => smithyClient._json(_),
247
+ }));
248
+ b.m("POST").h(headers).b(body);
249
+ return b.build();
1212
250
  };
1213
-
1214
- // src/commands/CreateControlPanelCommand.ts
1215
-
1216
-
1217
-
1218
- var CreateControlPanelCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1219
- return [
1220
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1221
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1222
- ];
1223
- }).s("Route53RecoveryControlConfig", "CreateControlPanel", {}).n("Route53RecoveryControlConfigClient", "CreateControlPanelCommand").f(void 0, void 0).ser(se_CreateControlPanelCommand).de(de_CreateControlPanelCommand).build() {
1224
- static {
1225
- __name(this, "CreateControlPanelCommand");
1226
- }
251
+ const se_CreateControlPanelCommand = async (input, context) => {
252
+ const b = core.requestBuilder(input, context);
253
+ const headers = {
254
+ "content-type": "application/json",
255
+ };
256
+ b.bp("/controlpanel");
257
+ let body;
258
+ body = JSON.stringify(smithyClient.take(input, {
259
+ ClientToken: [true, (_) => _ ?? uuid.v4()],
260
+ ClusterArn: [],
261
+ ControlPanelName: [],
262
+ Tags: (_) => smithyClient._json(_),
263
+ }));
264
+ b.m("POST").h(headers).b(body);
265
+ return b.build();
1227
266
  };
1228
-
1229
- // src/commands/CreateRoutingControlCommand.ts
1230
-
1231
-
1232
-
1233
- var CreateRoutingControlCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1234
- return [
1235
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1236
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1237
- ];
1238
- }).s("Route53RecoveryControlConfig", "CreateRoutingControl", {}).n("Route53RecoveryControlConfigClient", "CreateRoutingControlCommand").f(void 0, void 0).ser(se_CreateRoutingControlCommand).de(de_CreateRoutingControlCommand).build() {
1239
- static {
1240
- __name(this, "CreateRoutingControlCommand");
1241
- }
267
+ const se_CreateRoutingControlCommand = async (input, context) => {
268
+ const b = core.requestBuilder(input, context);
269
+ const headers = {
270
+ "content-type": "application/json",
271
+ };
272
+ b.bp("/routingcontrol");
273
+ let body;
274
+ body = JSON.stringify(smithyClient.take(input, {
275
+ ClientToken: [true, (_) => _ ?? uuid.v4()],
276
+ ClusterArn: [],
277
+ ControlPanelArn: [],
278
+ RoutingControlName: [],
279
+ }));
280
+ b.m("POST").h(headers).b(body);
281
+ return b.build();
1242
282
  };
1243
-
1244
- // src/commands/CreateSafetyRuleCommand.ts
1245
-
1246
-
1247
-
1248
- var CreateSafetyRuleCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1249
- return [
1250
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1251
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1252
- ];
1253
- }).s("Route53RecoveryControlConfig", "CreateSafetyRule", {}).n("Route53RecoveryControlConfigClient", "CreateSafetyRuleCommand").f(void 0, void 0).ser(se_CreateSafetyRuleCommand).de(de_CreateSafetyRuleCommand).build() {
1254
- static {
1255
- __name(this, "CreateSafetyRuleCommand");
1256
- }
283
+ const se_CreateSafetyRuleCommand = async (input, context) => {
284
+ const b = core.requestBuilder(input, context);
285
+ const headers = {
286
+ "content-type": "application/json",
287
+ };
288
+ b.bp("/safetyrule");
289
+ let body;
290
+ body = JSON.stringify(smithyClient.take(input, {
291
+ AssertionRule: (_) => smithyClient._json(_),
292
+ ClientToken: [true, (_) => _ ?? uuid.v4()],
293
+ GatingRule: (_) => smithyClient._json(_),
294
+ Tags: (_) => smithyClient._json(_),
295
+ }));
296
+ b.m("POST").h(headers).b(body);
297
+ return b.build();
1257
298
  };
1258
-
1259
- // src/commands/DeleteClusterCommand.ts
1260
-
1261
-
1262
-
1263
- var DeleteClusterCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1264
- return [
1265
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1266
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1267
- ];
1268
- }).s("Route53RecoveryControlConfig", "DeleteCluster", {}).n("Route53RecoveryControlConfigClient", "DeleteClusterCommand").f(void 0, void 0).ser(se_DeleteClusterCommand).de(de_DeleteClusterCommand).build() {
1269
- static {
1270
- __name(this, "DeleteClusterCommand");
1271
- }
299
+ const se_DeleteClusterCommand = async (input, context) => {
300
+ const b = core.requestBuilder(input, context);
301
+ const headers = {};
302
+ b.bp("/cluster/{ClusterArn}");
303
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
304
+ let body;
305
+ b.m("DELETE").h(headers).b(body);
306
+ return b.build();
1272
307
  };
1273
-
1274
- // src/commands/DeleteControlPanelCommand.ts
1275
-
1276
-
1277
-
1278
- var DeleteControlPanelCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1279
- return [
1280
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1281
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1282
- ];
1283
- }).s("Route53RecoveryControlConfig", "DeleteControlPanel", {}).n("Route53RecoveryControlConfigClient", "DeleteControlPanelCommand").f(void 0, void 0).ser(se_DeleteControlPanelCommand).de(de_DeleteControlPanelCommand).build() {
1284
- static {
1285
- __name(this, "DeleteControlPanelCommand");
1286
- }
308
+ const se_DeleteControlPanelCommand = async (input, context) => {
309
+ const b = core.requestBuilder(input, context);
310
+ const headers = {};
311
+ b.bp("/controlpanel/{ControlPanelArn}");
312
+ b.p("ControlPanelArn", () => input.ControlPanelArn, "{ControlPanelArn}", false);
313
+ let body;
314
+ b.m("DELETE").h(headers).b(body);
315
+ return b.build();
1287
316
  };
1288
-
1289
- // src/commands/DeleteRoutingControlCommand.ts
1290
-
1291
-
1292
-
1293
- var DeleteRoutingControlCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1294
- return [
1295
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1296
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1297
- ];
1298
- }).s("Route53RecoveryControlConfig", "DeleteRoutingControl", {}).n("Route53RecoveryControlConfigClient", "DeleteRoutingControlCommand").f(void 0, void 0).ser(se_DeleteRoutingControlCommand).de(de_DeleteRoutingControlCommand).build() {
1299
- static {
1300
- __name(this, "DeleteRoutingControlCommand");
1301
- }
317
+ const se_DeleteRoutingControlCommand = async (input, context) => {
318
+ const b = core.requestBuilder(input, context);
319
+ const headers = {};
320
+ b.bp("/routingcontrol/{RoutingControlArn}");
321
+ b.p("RoutingControlArn", () => input.RoutingControlArn, "{RoutingControlArn}", false);
322
+ let body;
323
+ b.m("DELETE").h(headers).b(body);
324
+ return b.build();
1302
325
  };
1303
-
1304
- // src/commands/DeleteSafetyRuleCommand.ts
1305
-
1306
-
1307
-
1308
- var DeleteSafetyRuleCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1309
- return [
1310
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1311
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1312
- ];
1313
- }).s("Route53RecoveryControlConfig", "DeleteSafetyRule", {}).n("Route53RecoveryControlConfigClient", "DeleteSafetyRuleCommand").f(void 0, void 0).ser(se_DeleteSafetyRuleCommand).de(de_DeleteSafetyRuleCommand).build() {
1314
- static {
1315
- __name(this, "DeleteSafetyRuleCommand");
1316
- }
326
+ const se_DeleteSafetyRuleCommand = async (input, context) => {
327
+ const b = core.requestBuilder(input, context);
328
+ const headers = {};
329
+ b.bp("/safetyrule/{SafetyRuleArn}");
330
+ b.p("SafetyRuleArn", () => input.SafetyRuleArn, "{SafetyRuleArn}", false);
331
+ let body;
332
+ b.m("DELETE").h(headers).b(body);
333
+ return b.build();
1317
334
  };
1318
-
1319
- // src/commands/DescribeClusterCommand.ts
1320
-
1321
-
1322
-
1323
- var DescribeClusterCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1324
- return [
1325
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1326
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1327
- ];
1328
- }).s("Route53RecoveryControlConfig", "DescribeCluster", {}).n("Route53RecoveryControlConfigClient", "DescribeClusterCommand").f(void 0, void 0).ser(se_DescribeClusterCommand).de(de_DescribeClusterCommand).build() {
1329
- static {
1330
- __name(this, "DescribeClusterCommand");
1331
- }
335
+ const se_DescribeClusterCommand = async (input, context) => {
336
+ const b = core.requestBuilder(input, context);
337
+ const headers = {};
338
+ b.bp("/cluster/{ClusterArn}");
339
+ b.p("ClusterArn", () => input.ClusterArn, "{ClusterArn}", false);
340
+ let body;
341
+ b.m("GET").h(headers).b(body);
342
+ return b.build();
1332
343
  };
1333
-
1334
- // src/commands/DescribeControlPanelCommand.ts
1335
-
1336
-
1337
-
1338
- var DescribeControlPanelCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1339
- return [
1340
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1341
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1342
- ];
1343
- }).s("Route53RecoveryControlConfig", "DescribeControlPanel", {}).n("Route53RecoveryControlConfigClient", "DescribeControlPanelCommand").f(void 0, void 0).ser(se_DescribeControlPanelCommand).de(de_DescribeControlPanelCommand).build() {
1344
- static {
1345
- __name(this, "DescribeControlPanelCommand");
1346
- }
344
+ const se_DescribeControlPanelCommand = async (input, context) => {
345
+ const b = core.requestBuilder(input, context);
346
+ const headers = {};
347
+ b.bp("/controlpanel/{ControlPanelArn}");
348
+ b.p("ControlPanelArn", () => input.ControlPanelArn, "{ControlPanelArn}", false);
349
+ let body;
350
+ b.m("GET").h(headers).b(body);
351
+ return b.build();
1347
352
  };
1348
-
1349
- // src/commands/DescribeRoutingControlCommand.ts
1350
-
1351
-
1352
-
1353
- var DescribeRoutingControlCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1354
- return [
1355
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1356
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1357
- ];
1358
- }).s("Route53RecoveryControlConfig", "DescribeRoutingControl", {}).n("Route53RecoveryControlConfigClient", "DescribeRoutingControlCommand").f(void 0, void 0).ser(se_DescribeRoutingControlCommand).de(de_DescribeRoutingControlCommand).build() {
1359
- static {
1360
- __name(this, "DescribeRoutingControlCommand");
1361
- }
353
+ const se_DescribeRoutingControlCommand = async (input, context) => {
354
+ const b = core.requestBuilder(input, context);
355
+ const headers = {};
356
+ b.bp("/routingcontrol/{RoutingControlArn}");
357
+ b.p("RoutingControlArn", () => input.RoutingControlArn, "{RoutingControlArn}", false);
358
+ let body;
359
+ b.m("GET").h(headers).b(body);
360
+ return b.build();
1362
361
  };
1363
-
1364
- // src/commands/DescribeSafetyRuleCommand.ts
1365
-
1366
-
1367
-
1368
- var DescribeSafetyRuleCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1369
- return [
1370
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1371
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1372
- ];
1373
- }).s("Route53RecoveryControlConfig", "DescribeSafetyRule", {}).n("Route53RecoveryControlConfigClient", "DescribeSafetyRuleCommand").f(void 0, void 0).ser(se_DescribeSafetyRuleCommand).de(de_DescribeSafetyRuleCommand).build() {
1374
- static {
1375
- __name(this, "DescribeSafetyRuleCommand");
1376
- }
362
+ const se_DescribeSafetyRuleCommand = async (input, context) => {
363
+ const b = core.requestBuilder(input, context);
364
+ const headers = {};
365
+ b.bp("/safetyrule/{SafetyRuleArn}");
366
+ b.p("SafetyRuleArn", () => input.SafetyRuleArn, "{SafetyRuleArn}", false);
367
+ let body;
368
+ b.m("GET").h(headers).b(body);
369
+ return b.build();
1377
370
  };
1378
-
1379
- // src/commands/GetResourcePolicyCommand.ts
1380
-
1381
-
1382
-
1383
- var GetResourcePolicyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1384
- return [
1385
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1386
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1387
- ];
1388
- }).s("Route53RecoveryControlConfig", "GetResourcePolicy", {}).n("Route53RecoveryControlConfigClient", "GetResourcePolicyCommand").f(void 0, void 0).ser(se_GetResourcePolicyCommand).de(de_GetResourcePolicyCommand).build() {
1389
- static {
1390
- __name(this, "GetResourcePolicyCommand");
1391
- }
371
+ const se_GetResourcePolicyCommand = async (input, context) => {
372
+ const b = core.requestBuilder(input, context);
373
+ const headers = {};
374
+ b.bp("/resourcePolicy/{ResourceArn}");
375
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
376
+ let body;
377
+ b.m("GET").h(headers).b(body);
378
+ return b.build();
1392
379
  };
1393
-
1394
- // src/commands/ListAssociatedRoute53HealthChecksCommand.ts
1395
-
1396
-
1397
-
1398
- var ListAssociatedRoute53HealthChecksCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1399
- return [
1400
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1401
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1402
- ];
1403
- }).s("Route53RecoveryControlConfig", "ListAssociatedRoute53HealthChecks", {}).n("Route53RecoveryControlConfigClient", "ListAssociatedRoute53HealthChecksCommand").f(void 0, void 0).ser(se_ListAssociatedRoute53HealthChecksCommand).de(de_ListAssociatedRoute53HealthChecksCommand).build() {
1404
- static {
1405
- __name(this, "ListAssociatedRoute53HealthChecksCommand");
1406
- }
380
+ const se_ListAssociatedRoute53HealthChecksCommand = async (input, context) => {
381
+ const b = core.requestBuilder(input, context);
382
+ const headers = {};
383
+ b.bp("/routingcontrol/{RoutingControlArn}/associatedRoute53HealthChecks");
384
+ b.p("RoutingControlArn", () => input.RoutingControlArn, "{RoutingControlArn}", false);
385
+ const query = smithyClient.map({
386
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
387
+ [_NT]: [, input[_NT]],
388
+ });
389
+ let body;
390
+ b.m("GET").h(headers).q(query).b(body);
391
+ return b.build();
1407
392
  };
1408
-
1409
- // src/commands/ListClustersCommand.ts
1410
-
1411
-
1412
-
1413
- var ListClustersCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1414
- return [
1415
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1416
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1417
- ];
1418
- }).s("Route53RecoveryControlConfig", "ListClusters", {}).n("Route53RecoveryControlConfigClient", "ListClustersCommand").f(void 0, void 0).ser(se_ListClustersCommand).de(de_ListClustersCommand).build() {
1419
- static {
1420
- __name(this, "ListClustersCommand");
1421
- }
393
+ const se_ListClustersCommand = async (input, context) => {
394
+ const b = core.requestBuilder(input, context);
395
+ const headers = {};
396
+ b.bp("/cluster");
397
+ const query = smithyClient.map({
398
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
399
+ [_NT]: [, input[_NT]],
400
+ });
401
+ let body;
402
+ b.m("GET").h(headers).q(query).b(body);
403
+ return b.build();
1422
404
  };
1423
-
1424
- // src/commands/ListControlPanelsCommand.ts
1425
-
1426
-
1427
-
1428
- var ListControlPanelsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1429
- return [
1430
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1431
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1432
- ];
1433
- }).s("Route53RecoveryControlConfig", "ListControlPanels", {}).n("Route53RecoveryControlConfigClient", "ListControlPanelsCommand").f(void 0, void 0).ser(se_ListControlPanelsCommand).de(de_ListControlPanelsCommand).build() {
1434
- static {
1435
- __name(this, "ListControlPanelsCommand");
1436
- }
405
+ const se_ListControlPanelsCommand = async (input, context) => {
406
+ const b = core.requestBuilder(input, context);
407
+ const headers = {};
408
+ b.bp("/controlpanels");
409
+ const query = smithyClient.map({
410
+ [_CA]: [, input[_CA]],
411
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
412
+ [_NT]: [, input[_NT]],
413
+ });
414
+ let body;
415
+ b.m("GET").h(headers).q(query).b(body);
416
+ return b.build();
1437
417
  };
1438
-
1439
- // src/commands/ListRoutingControlsCommand.ts
1440
-
1441
-
1442
-
1443
- var ListRoutingControlsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1444
- return [
1445
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1446
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1447
- ];
1448
- }).s("Route53RecoveryControlConfig", "ListRoutingControls", {}).n("Route53RecoveryControlConfigClient", "ListRoutingControlsCommand").f(void 0, void 0).ser(se_ListRoutingControlsCommand).de(de_ListRoutingControlsCommand).build() {
1449
- static {
1450
- __name(this, "ListRoutingControlsCommand");
1451
- }
418
+ const se_ListRoutingControlsCommand = async (input, context) => {
419
+ const b = core.requestBuilder(input, context);
420
+ const headers = {};
421
+ b.bp("/controlpanel/{ControlPanelArn}/routingcontrols");
422
+ b.p("ControlPanelArn", () => input.ControlPanelArn, "{ControlPanelArn}", false);
423
+ const query = smithyClient.map({
424
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
425
+ [_NT]: [, input[_NT]],
426
+ });
427
+ let body;
428
+ b.m("GET").h(headers).q(query).b(body);
429
+ return b.build();
1452
430
  };
1453
-
1454
- // src/commands/ListSafetyRulesCommand.ts
1455
-
1456
-
1457
-
1458
- var ListSafetyRulesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1459
- return [
1460
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1461
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1462
- ];
1463
- }).s("Route53RecoveryControlConfig", "ListSafetyRules", {}).n("Route53RecoveryControlConfigClient", "ListSafetyRulesCommand").f(void 0, void 0).ser(se_ListSafetyRulesCommand).de(de_ListSafetyRulesCommand).build() {
1464
- static {
1465
- __name(this, "ListSafetyRulesCommand");
1466
- }
431
+ const se_ListSafetyRulesCommand = async (input, context) => {
432
+ const b = core.requestBuilder(input, context);
433
+ const headers = {};
434
+ b.bp("/controlpanel/{ControlPanelArn}/safetyrules");
435
+ b.p("ControlPanelArn", () => input.ControlPanelArn, "{ControlPanelArn}", false);
436
+ const query = smithyClient.map({
437
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
438
+ [_NT]: [, input[_NT]],
439
+ });
440
+ let body;
441
+ b.m("GET").h(headers).q(query).b(body);
442
+ return b.build();
1467
443
  };
1468
-
1469
- // src/commands/ListTagsForResourceCommand.ts
1470
-
1471
-
1472
-
1473
- var ListTagsForResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1474
- return [
1475
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1476
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1477
- ];
1478
- }).s("Route53RecoveryControlConfig", "ListTagsForResource", {}).n("Route53RecoveryControlConfigClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
1479
- static {
1480
- __name(this, "ListTagsForResourceCommand");
1481
- }
444
+ const se_ListTagsForResourceCommand = async (input, context) => {
445
+ const b = core.requestBuilder(input, context);
446
+ const headers = {};
447
+ b.bp("/tags/{ResourceArn}");
448
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
449
+ let body;
450
+ b.m("GET").h(headers).b(body);
451
+ return b.build();
1482
452
  };
1483
-
1484
- // src/commands/TagResourceCommand.ts
1485
-
1486
-
1487
-
1488
- var TagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1489
- return [
1490
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1491
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1492
- ];
1493
- }).s("Route53RecoveryControlConfig", "TagResource", {}).n("Route53RecoveryControlConfigClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
1494
- static {
1495
- __name(this, "TagResourceCommand");
1496
- }
453
+ const se_TagResourceCommand = async (input, context) => {
454
+ const b = core.requestBuilder(input, context);
455
+ const headers = {
456
+ "content-type": "application/json",
457
+ };
458
+ b.bp("/tags/{ResourceArn}");
459
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
460
+ let body;
461
+ body = JSON.stringify(smithyClient.take(input, {
462
+ Tags: (_) => smithyClient._json(_),
463
+ }));
464
+ b.m("POST").h(headers).b(body);
465
+ return b.build();
1497
466
  };
1498
-
1499
- // src/commands/UntagResourceCommand.ts
1500
-
1501
-
1502
-
1503
- var UntagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1504
- return [
1505
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1506
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1507
- ];
1508
- }).s("Route53RecoveryControlConfig", "UntagResource", {}).n("Route53RecoveryControlConfigClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
1509
- static {
1510
- __name(this, "UntagResourceCommand");
1511
- }
467
+ const se_UntagResourceCommand = async (input, context) => {
468
+ const b = core.requestBuilder(input, context);
469
+ const headers = {};
470
+ b.bp("/tags/{ResourceArn}");
471
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
472
+ const query = smithyClient.map({
473
+ [_TK]: [smithyClient.expectNonNull(input.TagKeys, `TagKeys`) != null, () => input[_TK] || []],
474
+ });
475
+ let body;
476
+ b.m("DELETE").h(headers).q(query).b(body);
477
+ return b.build();
1512
478
  };
1513
-
1514
- // src/commands/UpdateClusterCommand.ts
1515
-
1516
-
1517
-
1518
- var UpdateClusterCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1519
- return [
1520
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1521
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1522
- ];
1523
- }).s("Route53RecoveryControlConfig", "UpdateCluster", {}).n("Route53RecoveryControlConfigClient", "UpdateClusterCommand").f(void 0, void 0).ser(se_UpdateClusterCommand).de(de_UpdateClusterCommand).build() {
1524
- static {
1525
- __name(this, "UpdateClusterCommand");
1526
- }
479
+ const se_UpdateClusterCommand = async (input, context) => {
480
+ const b = core.requestBuilder(input, context);
481
+ const headers = {
482
+ "content-type": "application/json",
483
+ };
484
+ b.bp("/cluster");
485
+ let body;
486
+ body = JSON.stringify(smithyClient.take(input, {
487
+ ClusterArn: [],
488
+ NetworkType: [],
489
+ }));
490
+ b.m("PUT").h(headers).b(body);
491
+ return b.build();
1527
492
  };
1528
-
1529
- // src/commands/UpdateControlPanelCommand.ts
1530
-
1531
-
1532
-
1533
- var UpdateControlPanelCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1534
- return [
1535
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1536
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1537
- ];
1538
- }).s("Route53RecoveryControlConfig", "UpdateControlPanel", {}).n("Route53RecoveryControlConfigClient", "UpdateControlPanelCommand").f(void 0, void 0).ser(se_UpdateControlPanelCommand).de(de_UpdateControlPanelCommand).build() {
1539
- static {
1540
- __name(this, "UpdateControlPanelCommand");
1541
- }
493
+ const se_UpdateControlPanelCommand = async (input, context) => {
494
+ const b = core.requestBuilder(input, context);
495
+ const headers = {
496
+ "content-type": "application/json",
497
+ };
498
+ b.bp("/controlpanel");
499
+ let body;
500
+ body = JSON.stringify(smithyClient.take(input, {
501
+ ControlPanelArn: [],
502
+ ControlPanelName: [],
503
+ }));
504
+ b.m("PUT").h(headers).b(body);
505
+ return b.build();
1542
506
  };
1543
-
1544
- // src/commands/UpdateRoutingControlCommand.ts
1545
-
1546
-
1547
-
1548
- var UpdateRoutingControlCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1549
- return [
1550
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1551
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1552
- ];
1553
- }).s("Route53RecoveryControlConfig", "UpdateRoutingControl", {}).n("Route53RecoveryControlConfigClient", "UpdateRoutingControlCommand").f(void 0, void 0).ser(se_UpdateRoutingControlCommand).de(de_UpdateRoutingControlCommand).build() {
1554
- static {
1555
- __name(this, "UpdateRoutingControlCommand");
1556
- }
507
+ const se_UpdateRoutingControlCommand = async (input, context) => {
508
+ const b = core.requestBuilder(input, context);
509
+ const headers = {
510
+ "content-type": "application/json",
511
+ };
512
+ b.bp("/routingcontrol");
513
+ let body;
514
+ body = JSON.stringify(smithyClient.take(input, {
515
+ RoutingControlArn: [],
516
+ RoutingControlName: [],
517
+ }));
518
+ b.m("PUT").h(headers).b(body);
519
+ return b.build();
1557
520
  };
1558
-
1559
- // src/commands/UpdateSafetyRuleCommand.ts
1560
-
1561
-
1562
-
1563
- var UpdateSafetyRuleCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1564
- return [
1565
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1566
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1567
- ];
1568
- }).s("Route53RecoveryControlConfig", "UpdateSafetyRule", {}).n("Route53RecoveryControlConfigClient", "UpdateSafetyRuleCommand").f(void 0, void 0).ser(se_UpdateSafetyRuleCommand).de(de_UpdateSafetyRuleCommand).build() {
1569
- static {
1570
- __name(this, "UpdateSafetyRuleCommand");
1571
- }
521
+ const se_UpdateSafetyRuleCommand = async (input, context) => {
522
+ const b = core.requestBuilder(input, context);
523
+ const headers = {
524
+ "content-type": "application/json",
525
+ };
526
+ b.bp("/safetyrule");
527
+ let body;
528
+ body = JSON.stringify(smithyClient.take(input, {
529
+ AssertionRuleUpdate: (_) => smithyClient._json(_),
530
+ GatingRuleUpdate: (_) => smithyClient._json(_),
531
+ }));
532
+ b.m("PUT").h(headers).b(body);
533
+ return b.build();
1572
534
  };
535
+ const de_CreateClusterCommand = async (output, context) => {
536
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
537
+ return de_CommandError(output, context);
538
+ }
539
+ const contents = smithyClient.map({
540
+ $metadata: deserializeMetadata(output),
541
+ });
542
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
543
+ const doc = smithyClient.take(data, {
544
+ Cluster: smithyClient._json,
545
+ });
546
+ Object.assign(contents, doc);
547
+ return contents;
548
+ };
549
+ const de_CreateControlPanelCommand = async (output, context) => {
550
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
551
+ return de_CommandError(output, context);
552
+ }
553
+ const contents = smithyClient.map({
554
+ $metadata: deserializeMetadata(output),
555
+ });
556
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
557
+ const doc = smithyClient.take(data, {
558
+ ControlPanel: smithyClient._json,
559
+ });
560
+ Object.assign(contents, doc);
561
+ return contents;
562
+ };
563
+ const de_CreateRoutingControlCommand = async (output, context) => {
564
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
565
+ return de_CommandError(output, context);
566
+ }
567
+ const contents = smithyClient.map({
568
+ $metadata: deserializeMetadata(output),
569
+ });
570
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
571
+ const doc = smithyClient.take(data, {
572
+ RoutingControl: smithyClient._json,
573
+ });
574
+ Object.assign(contents, doc);
575
+ return contents;
576
+ };
577
+ const de_CreateSafetyRuleCommand = async (output, context) => {
578
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
579
+ return de_CommandError(output, context);
580
+ }
581
+ const contents = smithyClient.map({
582
+ $metadata: deserializeMetadata(output),
583
+ });
584
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
585
+ const doc = smithyClient.take(data, {
586
+ AssertionRule: smithyClient._json,
587
+ GatingRule: smithyClient._json,
588
+ });
589
+ Object.assign(contents, doc);
590
+ return contents;
591
+ };
592
+ const de_DeleteClusterCommand = async (output, context) => {
593
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
594
+ return de_CommandError(output, context);
595
+ }
596
+ const contents = smithyClient.map({
597
+ $metadata: deserializeMetadata(output),
598
+ });
599
+ await smithyClient.collectBody(output.body, context);
600
+ return contents;
601
+ };
602
+ const de_DeleteControlPanelCommand = async (output, context) => {
603
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
604
+ return de_CommandError(output, context);
605
+ }
606
+ const contents = smithyClient.map({
607
+ $metadata: deserializeMetadata(output),
608
+ });
609
+ await smithyClient.collectBody(output.body, context);
610
+ return contents;
611
+ };
612
+ const de_DeleteRoutingControlCommand = async (output, context) => {
613
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
614
+ return de_CommandError(output, context);
615
+ }
616
+ const contents = smithyClient.map({
617
+ $metadata: deserializeMetadata(output),
618
+ });
619
+ await smithyClient.collectBody(output.body, context);
620
+ return contents;
621
+ };
622
+ const de_DeleteSafetyRuleCommand = async (output, context) => {
623
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
624
+ return de_CommandError(output, context);
625
+ }
626
+ const contents = smithyClient.map({
627
+ $metadata: deserializeMetadata(output),
628
+ });
629
+ await smithyClient.collectBody(output.body, context);
630
+ return contents;
631
+ };
632
+ const de_DescribeClusterCommand = async (output, context) => {
633
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
634
+ return de_CommandError(output, context);
635
+ }
636
+ const contents = smithyClient.map({
637
+ $metadata: deserializeMetadata(output),
638
+ });
639
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
640
+ const doc = smithyClient.take(data, {
641
+ Cluster: smithyClient._json,
642
+ });
643
+ Object.assign(contents, doc);
644
+ return contents;
645
+ };
646
+ const de_DescribeControlPanelCommand = async (output, context) => {
647
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
648
+ return de_CommandError(output, context);
649
+ }
650
+ const contents = smithyClient.map({
651
+ $metadata: deserializeMetadata(output),
652
+ });
653
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
654
+ const doc = smithyClient.take(data, {
655
+ ControlPanel: smithyClient._json,
656
+ });
657
+ Object.assign(contents, doc);
658
+ return contents;
659
+ };
660
+ const de_DescribeRoutingControlCommand = async (output, context) => {
661
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
662
+ return de_CommandError(output, context);
663
+ }
664
+ const contents = smithyClient.map({
665
+ $metadata: deserializeMetadata(output),
666
+ });
667
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
668
+ const doc = smithyClient.take(data, {
669
+ RoutingControl: smithyClient._json,
670
+ });
671
+ Object.assign(contents, doc);
672
+ return contents;
673
+ };
674
+ const de_DescribeSafetyRuleCommand = async (output, context) => {
675
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
676
+ return de_CommandError(output, context);
677
+ }
678
+ const contents = smithyClient.map({
679
+ $metadata: deserializeMetadata(output),
680
+ });
681
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
682
+ const doc = smithyClient.take(data, {
683
+ AssertionRule: smithyClient._json,
684
+ GatingRule: smithyClient._json,
685
+ });
686
+ Object.assign(contents, doc);
687
+ return contents;
688
+ };
689
+ const de_GetResourcePolicyCommand = async (output, context) => {
690
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
691
+ return de_CommandError(output, context);
692
+ }
693
+ const contents = smithyClient.map({
694
+ $metadata: deserializeMetadata(output),
695
+ });
696
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
697
+ const doc = smithyClient.take(data, {
698
+ Policy: smithyClient.expectString,
699
+ });
700
+ Object.assign(contents, doc);
701
+ return contents;
702
+ };
703
+ const de_ListAssociatedRoute53HealthChecksCommand = async (output, context) => {
704
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
705
+ return de_CommandError(output, context);
706
+ }
707
+ const contents = smithyClient.map({
708
+ $metadata: deserializeMetadata(output),
709
+ });
710
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
711
+ const doc = smithyClient.take(data, {
712
+ HealthCheckIds: smithyClient._json,
713
+ NextToken: smithyClient.expectString,
714
+ });
715
+ Object.assign(contents, doc);
716
+ return contents;
717
+ };
718
+ const de_ListClustersCommand = async (output, context) => {
719
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
720
+ return de_CommandError(output, context);
721
+ }
722
+ const contents = smithyClient.map({
723
+ $metadata: deserializeMetadata(output),
724
+ });
725
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
726
+ const doc = smithyClient.take(data, {
727
+ Clusters: smithyClient._json,
728
+ NextToken: smithyClient.expectString,
729
+ });
730
+ Object.assign(contents, doc);
731
+ return contents;
732
+ };
733
+ const de_ListControlPanelsCommand = async (output, context) => {
734
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
735
+ return de_CommandError(output, context);
736
+ }
737
+ const contents = smithyClient.map({
738
+ $metadata: deserializeMetadata(output),
739
+ });
740
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
741
+ const doc = smithyClient.take(data, {
742
+ ControlPanels: smithyClient._json,
743
+ NextToken: smithyClient.expectString,
744
+ });
745
+ Object.assign(contents, doc);
746
+ return contents;
747
+ };
748
+ const de_ListRoutingControlsCommand = async (output, context) => {
749
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
750
+ return de_CommandError(output, context);
751
+ }
752
+ const contents = smithyClient.map({
753
+ $metadata: deserializeMetadata(output),
754
+ });
755
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
756
+ const doc = smithyClient.take(data, {
757
+ NextToken: smithyClient.expectString,
758
+ RoutingControls: smithyClient._json,
759
+ });
760
+ Object.assign(contents, doc);
761
+ return contents;
762
+ };
763
+ const de_ListSafetyRulesCommand = async (output, context) => {
764
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
765
+ return de_CommandError(output, context);
766
+ }
767
+ const contents = smithyClient.map({
768
+ $metadata: deserializeMetadata(output),
769
+ });
770
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
771
+ const doc = smithyClient.take(data, {
772
+ NextToken: smithyClient.expectString,
773
+ SafetyRules: smithyClient._json,
774
+ });
775
+ Object.assign(contents, doc);
776
+ return contents;
777
+ };
778
+ const de_ListTagsForResourceCommand = async (output, context) => {
779
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
780
+ return de_CommandError(output, context);
781
+ }
782
+ const contents = smithyClient.map({
783
+ $metadata: deserializeMetadata(output),
784
+ });
785
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
786
+ const doc = smithyClient.take(data, {
787
+ Tags: smithyClient._json,
788
+ });
789
+ Object.assign(contents, doc);
790
+ return contents;
791
+ };
792
+ const de_TagResourceCommand = async (output, context) => {
793
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
794
+ return de_CommandError(output, context);
795
+ }
796
+ const contents = smithyClient.map({
797
+ $metadata: deserializeMetadata(output),
798
+ });
799
+ await smithyClient.collectBody(output.body, context);
800
+ return contents;
801
+ };
802
+ const de_UntagResourceCommand = async (output, context) => {
803
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
804
+ return de_CommandError(output, context);
805
+ }
806
+ const contents = smithyClient.map({
807
+ $metadata: deserializeMetadata(output),
808
+ });
809
+ await smithyClient.collectBody(output.body, context);
810
+ return contents;
811
+ };
812
+ const de_UpdateClusterCommand = async (output, context) => {
813
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
814
+ return de_CommandError(output, context);
815
+ }
816
+ const contents = smithyClient.map({
817
+ $metadata: deserializeMetadata(output),
818
+ });
819
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
820
+ const doc = smithyClient.take(data, {
821
+ Cluster: smithyClient._json,
822
+ });
823
+ Object.assign(contents, doc);
824
+ return contents;
825
+ };
826
+ const de_UpdateControlPanelCommand = async (output, context) => {
827
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
828
+ return de_CommandError(output, context);
829
+ }
830
+ const contents = smithyClient.map({
831
+ $metadata: deserializeMetadata(output),
832
+ });
833
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
834
+ const doc = smithyClient.take(data, {
835
+ ControlPanel: smithyClient._json,
836
+ });
837
+ Object.assign(contents, doc);
838
+ return contents;
839
+ };
840
+ const de_UpdateRoutingControlCommand = async (output, context) => {
841
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
842
+ return de_CommandError(output, context);
843
+ }
844
+ const contents = smithyClient.map({
845
+ $metadata: deserializeMetadata(output),
846
+ });
847
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
848
+ const doc = smithyClient.take(data, {
849
+ RoutingControl: smithyClient._json,
850
+ });
851
+ Object.assign(contents, doc);
852
+ return contents;
853
+ };
854
+ const de_UpdateSafetyRuleCommand = async (output, context) => {
855
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
856
+ return de_CommandError(output, context);
857
+ }
858
+ const contents = smithyClient.map({
859
+ $metadata: deserializeMetadata(output),
860
+ });
861
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
862
+ const doc = smithyClient.take(data, {
863
+ AssertionRule: smithyClient._json,
864
+ GatingRule: smithyClient._json,
865
+ });
866
+ Object.assign(contents, doc);
867
+ return contents;
868
+ };
869
+ const de_CommandError = async (output, context) => {
870
+ const parsedOutput = {
871
+ ...output,
872
+ body: await core$1.parseJsonErrorBody(output.body, context),
873
+ };
874
+ const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
875
+ switch (errorCode) {
876
+ case "AccessDeniedException":
877
+ case "com.amazonaws.route53recoverycontrolconfig#AccessDeniedException":
878
+ throw await de_AccessDeniedExceptionRes(parsedOutput);
879
+ case "ConflictException":
880
+ case "com.amazonaws.route53recoverycontrolconfig#ConflictException":
881
+ throw await de_ConflictExceptionRes(parsedOutput);
882
+ case "InternalServerException":
883
+ case "com.amazonaws.route53recoverycontrolconfig#InternalServerException":
884
+ throw await de_InternalServerExceptionRes(parsedOutput);
885
+ case "ResourceNotFoundException":
886
+ case "com.amazonaws.route53recoverycontrolconfig#ResourceNotFoundException":
887
+ throw await de_ResourceNotFoundExceptionRes(parsedOutput);
888
+ case "ServiceQuotaExceededException":
889
+ case "com.amazonaws.route53recoverycontrolconfig#ServiceQuotaExceededException":
890
+ throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
891
+ case "ThrottlingException":
892
+ case "com.amazonaws.route53recoverycontrolconfig#ThrottlingException":
893
+ throw await de_ThrottlingExceptionRes(parsedOutput);
894
+ case "ValidationException":
895
+ case "com.amazonaws.route53recoverycontrolconfig#ValidationException":
896
+ throw await de_ValidationExceptionRes(parsedOutput);
897
+ default:
898
+ const parsedBody = parsedOutput.body;
899
+ return throwDefaultError({
900
+ output,
901
+ parsedBody,
902
+ errorCode,
903
+ });
904
+ }
905
+ };
906
+ const throwDefaultError = smithyClient.withBaseException(Route53RecoveryControlConfigServiceException);
907
+ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
908
+ const contents = smithyClient.map({});
909
+ const data = parsedOutput.body;
910
+ const doc = smithyClient.take(data, {
911
+ Message: [, smithyClient.expectString, `message`],
912
+ });
913
+ Object.assign(contents, doc);
914
+ const exception = new AccessDeniedException({
915
+ $metadata: deserializeMetadata(parsedOutput),
916
+ ...contents,
917
+ });
918
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
919
+ };
920
+ const de_ConflictExceptionRes = async (parsedOutput, context) => {
921
+ const contents = smithyClient.map({});
922
+ const data = parsedOutput.body;
923
+ const doc = smithyClient.take(data, {
924
+ Message: [, smithyClient.expectString, `message`],
925
+ });
926
+ Object.assign(contents, doc);
927
+ const exception = new ConflictException({
928
+ $metadata: deserializeMetadata(parsedOutput),
929
+ ...contents,
930
+ });
931
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
932
+ };
933
+ const de_InternalServerExceptionRes = async (parsedOutput, context) => {
934
+ const contents = smithyClient.map({});
935
+ const data = parsedOutput.body;
936
+ const doc = smithyClient.take(data, {
937
+ Message: [, smithyClient.expectString, `message`],
938
+ });
939
+ Object.assign(contents, doc);
940
+ const exception = new InternalServerException({
941
+ $metadata: deserializeMetadata(parsedOutput),
942
+ ...contents,
943
+ });
944
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
945
+ };
946
+ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
947
+ const contents = smithyClient.map({});
948
+ const data = parsedOutput.body;
949
+ const doc = smithyClient.take(data, {
950
+ Message: [, smithyClient.expectString, `message`],
951
+ });
952
+ Object.assign(contents, doc);
953
+ const exception = new ResourceNotFoundException({
954
+ $metadata: deserializeMetadata(parsedOutput),
955
+ ...contents,
956
+ });
957
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
958
+ };
959
+ const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
960
+ const contents = smithyClient.map({});
961
+ const data = parsedOutput.body;
962
+ const doc = smithyClient.take(data, {
963
+ Message: [, smithyClient.expectString, `message`],
964
+ });
965
+ Object.assign(contents, doc);
966
+ const exception = new ServiceQuotaExceededException({
967
+ $metadata: deserializeMetadata(parsedOutput),
968
+ ...contents,
969
+ });
970
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
971
+ };
972
+ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
973
+ const contents = smithyClient.map({});
974
+ const data = parsedOutput.body;
975
+ const doc = smithyClient.take(data, {
976
+ Message: [, smithyClient.expectString, `message`],
977
+ });
978
+ Object.assign(contents, doc);
979
+ const exception = new ThrottlingException({
980
+ $metadata: deserializeMetadata(parsedOutput),
981
+ ...contents,
982
+ });
983
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
984
+ };
985
+ const de_ValidationExceptionRes = async (parsedOutput, context) => {
986
+ const contents = smithyClient.map({});
987
+ const data = parsedOutput.body;
988
+ const doc = smithyClient.take(data, {
989
+ Message: [, smithyClient.expectString, `message`],
990
+ });
991
+ Object.assign(contents, doc);
992
+ const exception = new ValidationException({
993
+ $metadata: deserializeMetadata(parsedOutput),
994
+ ...contents,
995
+ });
996
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
997
+ };
998
+ const deserializeMetadata = (output) => ({
999
+ httpStatusCode: output.statusCode,
1000
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1001
+ extendedRequestId: output.headers["x-amz-id-2"],
1002
+ cfId: output.headers["x-amz-cf-id"],
1003
+ });
1004
+ const _CA = "ClusterArn";
1005
+ const _MR = "MaxResults";
1006
+ const _NT = "NextToken";
1007
+ const _TK = "TagKeys";
1008
+
1009
+ class CreateClusterCommand extends smithyClient.Command
1010
+ .classBuilder()
1011
+ .ep(commonParams)
1012
+ .m(function (Command, cs, config, o) {
1013
+ return [
1014
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1015
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1016
+ ];
1017
+ })
1018
+ .s("Route53RecoveryControlConfig", "CreateCluster", {})
1019
+ .n("Route53RecoveryControlConfigClient", "CreateClusterCommand")
1020
+ .f(void 0, void 0)
1021
+ .ser(se_CreateClusterCommand)
1022
+ .de(de_CreateClusterCommand)
1023
+ .build() {
1024
+ }
1025
+
1026
+ class CreateControlPanelCommand extends smithyClient.Command
1027
+ .classBuilder()
1028
+ .ep(commonParams)
1029
+ .m(function (Command, cs, config, o) {
1030
+ return [
1031
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1032
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1033
+ ];
1034
+ })
1035
+ .s("Route53RecoveryControlConfig", "CreateControlPanel", {})
1036
+ .n("Route53RecoveryControlConfigClient", "CreateControlPanelCommand")
1037
+ .f(void 0, void 0)
1038
+ .ser(se_CreateControlPanelCommand)
1039
+ .de(de_CreateControlPanelCommand)
1040
+ .build() {
1041
+ }
1042
+
1043
+ class CreateRoutingControlCommand extends smithyClient.Command
1044
+ .classBuilder()
1045
+ .ep(commonParams)
1046
+ .m(function (Command, cs, config, o) {
1047
+ return [
1048
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1049
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1050
+ ];
1051
+ })
1052
+ .s("Route53RecoveryControlConfig", "CreateRoutingControl", {})
1053
+ .n("Route53RecoveryControlConfigClient", "CreateRoutingControlCommand")
1054
+ .f(void 0, void 0)
1055
+ .ser(se_CreateRoutingControlCommand)
1056
+ .de(de_CreateRoutingControlCommand)
1057
+ .build() {
1058
+ }
1059
+
1060
+ class CreateSafetyRuleCommand extends smithyClient.Command
1061
+ .classBuilder()
1062
+ .ep(commonParams)
1063
+ .m(function (Command, cs, config, o) {
1064
+ return [
1065
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1066
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1067
+ ];
1068
+ })
1069
+ .s("Route53RecoveryControlConfig", "CreateSafetyRule", {})
1070
+ .n("Route53RecoveryControlConfigClient", "CreateSafetyRuleCommand")
1071
+ .f(void 0, void 0)
1072
+ .ser(se_CreateSafetyRuleCommand)
1073
+ .de(de_CreateSafetyRuleCommand)
1074
+ .build() {
1075
+ }
1076
+
1077
+ class DeleteClusterCommand extends smithyClient.Command
1078
+ .classBuilder()
1079
+ .ep(commonParams)
1080
+ .m(function (Command, cs, config, o) {
1081
+ return [
1082
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1083
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1084
+ ];
1085
+ })
1086
+ .s("Route53RecoveryControlConfig", "DeleteCluster", {})
1087
+ .n("Route53RecoveryControlConfigClient", "DeleteClusterCommand")
1088
+ .f(void 0, void 0)
1089
+ .ser(se_DeleteClusterCommand)
1090
+ .de(de_DeleteClusterCommand)
1091
+ .build() {
1092
+ }
1093
+
1094
+ class DeleteControlPanelCommand extends smithyClient.Command
1095
+ .classBuilder()
1096
+ .ep(commonParams)
1097
+ .m(function (Command, cs, config, o) {
1098
+ return [
1099
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1100
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1101
+ ];
1102
+ })
1103
+ .s("Route53RecoveryControlConfig", "DeleteControlPanel", {})
1104
+ .n("Route53RecoveryControlConfigClient", "DeleteControlPanelCommand")
1105
+ .f(void 0, void 0)
1106
+ .ser(se_DeleteControlPanelCommand)
1107
+ .de(de_DeleteControlPanelCommand)
1108
+ .build() {
1109
+ }
1110
+
1111
+ class DeleteRoutingControlCommand extends smithyClient.Command
1112
+ .classBuilder()
1113
+ .ep(commonParams)
1114
+ .m(function (Command, cs, config, o) {
1115
+ return [
1116
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1117
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1118
+ ];
1119
+ })
1120
+ .s("Route53RecoveryControlConfig", "DeleteRoutingControl", {})
1121
+ .n("Route53RecoveryControlConfigClient", "DeleteRoutingControlCommand")
1122
+ .f(void 0, void 0)
1123
+ .ser(se_DeleteRoutingControlCommand)
1124
+ .de(de_DeleteRoutingControlCommand)
1125
+ .build() {
1126
+ }
1127
+
1128
+ class DeleteSafetyRuleCommand extends smithyClient.Command
1129
+ .classBuilder()
1130
+ .ep(commonParams)
1131
+ .m(function (Command, cs, config, o) {
1132
+ return [
1133
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1134
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1135
+ ];
1136
+ })
1137
+ .s("Route53RecoveryControlConfig", "DeleteSafetyRule", {})
1138
+ .n("Route53RecoveryControlConfigClient", "DeleteSafetyRuleCommand")
1139
+ .f(void 0, void 0)
1140
+ .ser(se_DeleteSafetyRuleCommand)
1141
+ .de(de_DeleteSafetyRuleCommand)
1142
+ .build() {
1143
+ }
1144
+
1145
+ class DescribeClusterCommand extends smithyClient.Command
1146
+ .classBuilder()
1147
+ .ep(commonParams)
1148
+ .m(function (Command, cs, config, o) {
1149
+ return [
1150
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1151
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1152
+ ];
1153
+ })
1154
+ .s("Route53RecoveryControlConfig", "DescribeCluster", {})
1155
+ .n("Route53RecoveryControlConfigClient", "DescribeClusterCommand")
1156
+ .f(void 0, void 0)
1157
+ .ser(se_DescribeClusterCommand)
1158
+ .de(de_DescribeClusterCommand)
1159
+ .build() {
1160
+ }
1161
+
1162
+ class DescribeControlPanelCommand extends smithyClient.Command
1163
+ .classBuilder()
1164
+ .ep(commonParams)
1165
+ .m(function (Command, cs, config, o) {
1166
+ return [
1167
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1168
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1169
+ ];
1170
+ })
1171
+ .s("Route53RecoveryControlConfig", "DescribeControlPanel", {})
1172
+ .n("Route53RecoveryControlConfigClient", "DescribeControlPanelCommand")
1173
+ .f(void 0, void 0)
1174
+ .ser(se_DescribeControlPanelCommand)
1175
+ .de(de_DescribeControlPanelCommand)
1176
+ .build() {
1177
+ }
1178
+
1179
+ class DescribeRoutingControlCommand extends smithyClient.Command
1180
+ .classBuilder()
1181
+ .ep(commonParams)
1182
+ .m(function (Command, cs, config, o) {
1183
+ return [
1184
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1185
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1186
+ ];
1187
+ })
1188
+ .s("Route53RecoveryControlConfig", "DescribeRoutingControl", {})
1189
+ .n("Route53RecoveryControlConfigClient", "DescribeRoutingControlCommand")
1190
+ .f(void 0, void 0)
1191
+ .ser(se_DescribeRoutingControlCommand)
1192
+ .de(de_DescribeRoutingControlCommand)
1193
+ .build() {
1194
+ }
1195
+
1196
+ class DescribeSafetyRuleCommand extends smithyClient.Command
1197
+ .classBuilder()
1198
+ .ep(commonParams)
1199
+ .m(function (Command, cs, config, o) {
1200
+ return [
1201
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1202
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1203
+ ];
1204
+ })
1205
+ .s("Route53RecoveryControlConfig", "DescribeSafetyRule", {})
1206
+ .n("Route53RecoveryControlConfigClient", "DescribeSafetyRuleCommand")
1207
+ .f(void 0, void 0)
1208
+ .ser(se_DescribeSafetyRuleCommand)
1209
+ .de(de_DescribeSafetyRuleCommand)
1210
+ .build() {
1211
+ }
1212
+
1213
+ class GetResourcePolicyCommand extends smithyClient.Command
1214
+ .classBuilder()
1215
+ .ep(commonParams)
1216
+ .m(function (Command, cs, config, o) {
1217
+ return [
1218
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1219
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1220
+ ];
1221
+ })
1222
+ .s("Route53RecoveryControlConfig", "GetResourcePolicy", {})
1223
+ .n("Route53RecoveryControlConfigClient", "GetResourcePolicyCommand")
1224
+ .f(void 0, void 0)
1225
+ .ser(se_GetResourcePolicyCommand)
1226
+ .de(de_GetResourcePolicyCommand)
1227
+ .build() {
1228
+ }
1229
+
1230
+ class ListAssociatedRoute53HealthChecksCommand extends smithyClient.Command
1231
+ .classBuilder()
1232
+ .ep(commonParams)
1233
+ .m(function (Command, cs, config, o) {
1234
+ return [
1235
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1236
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1237
+ ];
1238
+ })
1239
+ .s("Route53RecoveryControlConfig", "ListAssociatedRoute53HealthChecks", {})
1240
+ .n("Route53RecoveryControlConfigClient", "ListAssociatedRoute53HealthChecksCommand")
1241
+ .f(void 0, void 0)
1242
+ .ser(se_ListAssociatedRoute53HealthChecksCommand)
1243
+ .de(de_ListAssociatedRoute53HealthChecksCommand)
1244
+ .build() {
1245
+ }
1246
+
1247
+ class ListClustersCommand extends smithyClient.Command
1248
+ .classBuilder()
1249
+ .ep(commonParams)
1250
+ .m(function (Command, cs, config, o) {
1251
+ return [
1252
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1253
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1254
+ ];
1255
+ })
1256
+ .s("Route53RecoveryControlConfig", "ListClusters", {})
1257
+ .n("Route53RecoveryControlConfigClient", "ListClustersCommand")
1258
+ .f(void 0, void 0)
1259
+ .ser(se_ListClustersCommand)
1260
+ .de(de_ListClustersCommand)
1261
+ .build() {
1262
+ }
1263
+
1264
+ class ListControlPanelsCommand extends smithyClient.Command
1265
+ .classBuilder()
1266
+ .ep(commonParams)
1267
+ .m(function (Command, cs, config, o) {
1268
+ return [
1269
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1270
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1271
+ ];
1272
+ })
1273
+ .s("Route53RecoveryControlConfig", "ListControlPanels", {})
1274
+ .n("Route53RecoveryControlConfigClient", "ListControlPanelsCommand")
1275
+ .f(void 0, void 0)
1276
+ .ser(se_ListControlPanelsCommand)
1277
+ .de(de_ListControlPanelsCommand)
1278
+ .build() {
1279
+ }
1280
+
1281
+ class ListRoutingControlsCommand extends smithyClient.Command
1282
+ .classBuilder()
1283
+ .ep(commonParams)
1284
+ .m(function (Command, cs, config, o) {
1285
+ return [
1286
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1287
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1288
+ ];
1289
+ })
1290
+ .s("Route53RecoveryControlConfig", "ListRoutingControls", {})
1291
+ .n("Route53RecoveryControlConfigClient", "ListRoutingControlsCommand")
1292
+ .f(void 0, void 0)
1293
+ .ser(se_ListRoutingControlsCommand)
1294
+ .de(de_ListRoutingControlsCommand)
1295
+ .build() {
1296
+ }
1297
+
1298
+ class ListSafetyRulesCommand extends smithyClient.Command
1299
+ .classBuilder()
1300
+ .ep(commonParams)
1301
+ .m(function (Command, cs, config, o) {
1302
+ return [
1303
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1304
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1305
+ ];
1306
+ })
1307
+ .s("Route53RecoveryControlConfig", "ListSafetyRules", {})
1308
+ .n("Route53RecoveryControlConfigClient", "ListSafetyRulesCommand")
1309
+ .f(void 0, void 0)
1310
+ .ser(se_ListSafetyRulesCommand)
1311
+ .de(de_ListSafetyRulesCommand)
1312
+ .build() {
1313
+ }
1314
+
1315
+ class ListTagsForResourceCommand extends smithyClient.Command
1316
+ .classBuilder()
1317
+ .ep(commonParams)
1318
+ .m(function (Command, cs, config, o) {
1319
+ return [
1320
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1321
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1322
+ ];
1323
+ })
1324
+ .s("Route53RecoveryControlConfig", "ListTagsForResource", {})
1325
+ .n("Route53RecoveryControlConfigClient", "ListTagsForResourceCommand")
1326
+ .f(void 0, void 0)
1327
+ .ser(se_ListTagsForResourceCommand)
1328
+ .de(de_ListTagsForResourceCommand)
1329
+ .build() {
1330
+ }
1331
+
1332
+ class TagResourceCommand extends smithyClient.Command
1333
+ .classBuilder()
1334
+ .ep(commonParams)
1335
+ .m(function (Command, cs, config, o) {
1336
+ return [
1337
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1338
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1339
+ ];
1340
+ })
1341
+ .s("Route53RecoveryControlConfig", "TagResource", {})
1342
+ .n("Route53RecoveryControlConfigClient", "TagResourceCommand")
1343
+ .f(void 0, void 0)
1344
+ .ser(se_TagResourceCommand)
1345
+ .de(de_TagResourceCommand)
1346
+ .build() {
1347
+ }
1348
+
1349
+ class UntagResourceCommand extends smithyClient.Command
1350
+ .classBuilder()
1351
+ .ep(commonParams)
1352
+ .m(function (Command, cs, config, o) {
1353
+ return [
1354
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1355
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1356
+ ];
1357
+ })
1358
+ .s("Route53RecoveryControlConfig", "UntagResource", {})
1359
+ .n("Route53RecoveryControlConfigClient", "UntagResourceCommand")
1360
+ .f(void 0, void 0)
1361
+ .ser(se_UntagResourceCommand)
1362
+ .de(de_UntagResourceCommand)
1363
+ .build() {
1364
+ }
1365
+
1366
+ class UpdateClusterCommand extends smithyClient.Command
1367
+ .classBuilder()
1368
+ .ep(commonParams)
1369
+ .m(function (Command, cs, config, o) {
1370
+ return [
1371
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1372
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1373
+ ];
1374
+ })
1375
+ .s("Route53RecoveryControlConfig", "UpdateCluster", {})
1376
+ .n("Route53RecoveryControlConfigClient", "UpdateClusterCommand")
1377
+ .f(void 0, void 0)
1378
+ .ser(se_UpdateClusterCommand)
1379
+ .de(de_UpdateClusterCommand)
1380
+ .build() {
1381
+ }
1382
+
1383
+ class UpdateControlPanelCommand extends smithyClient.Command
1384
+ .classBuilder()
1385
+ .ep(commonParams)
1386
+ .m(function (Command, cs, config, o) {
1387
+ return [
1388
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1389
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1390
+ ];
1391
+ })
1392
+ .s("Route53RecoveryControlConfig", "UpdateControlPanel", {})
1393
+ .n("Route53RecoveryControlConfigClient", "UpdateControlPanelCommand")
1394
+ .f(void 0, void 0)
1395
+ .ser(se_UpdateControlPanelCommand)
1396
+ .de(de_UpdateControlPanelCommand)
1397
+ .build() {
1398
+ }
1399
+
1400
+ class UpdateRoutingControlCommand extends smithyClient.Command
1401
+ .classBuilder()
1402
+ .ep(commonParams)
1403
+ .m(function (Command, cs, config, o) {
1404
+ return [
1405
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1406
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1407
+ ];
1408
+ })
1409
+ .s("Route53RecoveryControlConfig", "UpdateRoutingControl", {})
1410
+ .n("Route53RecoveryControlConfigClient", "UpdateRoutingControlCommand")
1411
+ .f(void 0, void 0)
1412
+ .ser(se_UpdateRoutingControlCommand)
1413
+ .de(de_UpdateRoutingControlCommand)
1414
+ .build() {
1415
+ }
1416
+
1417
+ class UpdateSafetyRuleCommand extends smithyClient.Command
1418
+ .classBuilder()
1419
+ .ep(commonParams)
1420
+ .m(function (Command, cs, config, o) {
1421
+ return [
1422
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1423
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1424
+ ];
1425
+ })
1426
+ .s("Route53RecoveryControlConfig", "UpdateSafetyRule", {})
1427
+ .n("Route53RecoveryControlConfigClient", "UpdateSafetyRuleCommand")
1428
+ .f(void 0, void 0)
1429
+ .ser(se_UpdateSafetyRuleCommand)
1430
+ .de(de_UpdateSafetyRuleCommand)
1431
+ .build() {
1432
+ }
1433
+
1434
+ const commands = {
1435
+ CreateClusterCommand,
1436
+ CreateControlPanelCommand,
1437
+ CreateRoutingControlCommand,
1438
+ CreateSafetyRuleCommand,
1439
+ DeleteClusterCommand,
1440
+ DeleteControlPanelCommand,
1441
+ DeleteRoutingControlCommand,
1442
+ DeleteSafetyRuleCommand,
1443
+ DescribeClusterCommand,
1444
+ DescribeControlPanelCommand,
1445
+ DescribeRoutingControlCommand,
1446
+ DescribeSafetyRuleCommand,
1447
+ GetResourcePolicyCommand,
1448
+ ListAssociatedRoute53HealthChecksCommand,
1449
+ ListClustersCommand,
1450
+ ListControlPanelsCommand,
1451
+ ListRoutingControlsCommand,
1452
+ ListSafetyRulesCommand,
1453
+ ListTagsForResourceCommand,
1454
+ TagResourceCommand,
1455
+ UntagResourceCommand,
1456
+ UpdateClusterCommand,
1457
+ UpdateControlPanelCommand,
1458
+ UpdateRoutingControlCommand,
1459
+ UpdateSafetyRuleCommand,
1460
+ };
1461
+ class Route53RecoveryControlConfig extends Route53RecoveryControlConfigClient {
1462
+ }
1463
+ smithyClient.createAggregatedClient(commands, Route53RecoveryControlConfig);
1573
1464
 
1574
- // src/Route53RecoveryControlConfig.ts
1575
- var commands = {
1576
- CreateClusterCommand,
1577
- CreateControlPanelCommand,
1578
- CreateRoutingControlCommand,
1579
- CreateSafetyRuleCommand,
1580
- DeleteClusterCommand,
1581
- DeleteControlPanelCommand,
1582
- DeleteRoutingControlCommand,
1583
- DeleteSafetyRuleCommand,
1584
- DescribeClusterCommand,
1585
- DescribeControlPanelCommand,
1586
- DescribeRoutingControlCommand,
1587
- DescribeSafetyRuleCommand,
1588
- GetResourcePolicyCommand,
1589
- ListAssociatedRoute53HealthChecksCommand,
1590
- ListClustersCommand,
1591
- ListControlPanelsCommand,
1592
- ListRoutingControlsCommand,
1593
- ListSafetyRulesCommand,
1594
- ListTagsForResourceCommand,
1595
- TagResourceCommand,
1596
- UntagResourceCommand,
1597
- UpdateClusterCommand,
1598
- UpdateControlPanelCommand,
1599
- UpdateRoutingControlCommand,
1600
- UpdateSafetyRuleCommand
1601
- };
1602
- var Route53RecoveryControlConfig = class extends Route53RecoveryControlConfigClient {
1603
- static {
1604
- __name(this, "Route53RecoveryControlConfig");
1605
- }
1606
- };
1607
- (0, import_smithy_client.createAggregatedClient)(commands, Route53RecoveryControlConfig);
1608
-
1609
- // src/pagination/ListAssociatedRoute53HealthChecksPaginator.ts
1610
-
1611
- var paginateListAssociatedRoute53HealthChecks = (0, import_core.createPaginator)(Route53RecoveryControlConfigClient, ListAssociatedRoute53HealthChecksCommand, "NextToken", "NextToken", "MaxResults");
1612
-
1613
- // src/pagination/ListClustersPaginator.ts
1614
-
1615
- var paginateListClusters = (0, import_core.createPaginator)(Route53RecoveryControlConfigClient, ListClustersCommand, "NextToken", "NextToken", "MaxResults");
1616
-
1617
- // src/pagination/ListControlPanelsPaginator.ts
1618
-
1619
- var paginateListControlPanels = (0, import_core.createPaginator)(Route53RecoveryControlConfigClient, ListControlPanelsCommand, "NextToken", "NextToken", "MaxResults");
1465
+ const paginateListAssociatedRoute53HealthChecks = core.createPaginator(Route53RecoveryControlConfigClient, ListAssociatedRoute53HealthChecksCommand, "NextToken", "NextToken", "MaxResults");
1620
1466
 
1621
- // src/pagination/ListRoutingControlsPaginator.ts
1467
+ const paginateListClusters = core.createPaginator(Route53RecoveryControlConfigClient, ListClustersCommand, "NextToken", "NextToken", "MaxResults");
1622
1468
 
1623
- var paginateListRoutingControls = (0, import_core.createPaginator)(Route53RecoveryControlConfigClient, ListRoutingControlsCommand, "NextToken", "NextToken", "MaxResults");
1469
+ const paginateListControlPanels = core.createPaginator(Route53RecoveryControlConfigClient, ListControlPanelsCommand, "NextToken", "NextToken", "MaxResults");
1624
1470
 
1625
- // src/pagination/ListSafetyRulesPaginator.ts
1471
+ const paginateListRoutingControls = core.createPaginator(Route53RecoveryControlConfigClient, ListRoutingControlsCommand, "NextToken", "NextToken", "MaxResults");
1626
1472
 
1627
- var paginateListSafetyRules = (0, import_core.createPaginator)(Route53RecoveryControlConfigClient, ListSafetyRulesCommand, "NextToken", "NextToken", "MaxResults");
1473
+ const paginateListSafetyRules = core.createPaginator(Route53RecoveryControlConfigClient, ListSafetyRulesCommand, "NextToken", "NextToken", "MaxResults");
1628
1474
 
1629
- // src/waiters/waitForClusterCreated.ts
1630
- var import_util_waiter = require("@smithy/util-waiter");
1631
- var checkState = /* @__PURE__ */ __name(async (client, input) => {
1632
- let reason;
1633
- try {
1634
- const result = await client.send(new DescribeClusterCommand(input));
1635
- reason = result;
1475
+ const checkState$5 = async (client, input) => {
1476
+ let reason;
1636
1477
  try {
1637
- const returnComparator = /* @__PURE__ */ __name(() => {
1638
- return result.Cluster.Status;
1639
- }, "returnComparator");
1640
- if (returnComparator() === "DEPLOYED") {
1641
- return { state: import_util_waiter.WaiterState.SUCCESS, reason };
1642
- }
1643
- } catch (e) {
1478
+ const result = await client.send(new DescribeClusterCommand(input));
1479
+ reason = result;
1480
+ try {
1481
+ const returnComparator = () => {
1482
+ return result.Cluster.Status;
1483
+ };
1484
+ if (returnComparator() === "DEPLOYED") {
1485
+ return { state: utilWaiter.WaiterState.SUCCESS, reason };
1486
+ }
1487
+ }
1488
+ catch (e) { }
1489
+ try {
1490
+ const returnComparator = () => {
1491
+ return result.Cluster.Status;
1492
+ };
1493
+ if (returnComparator() === "PENDING") {
1494
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1495
+ }
1496
+ }
1497
+ catch (e) { }
1644
1498
  }
1645
- try {
1646
- const returnComparator = /* @__PURE__ */ __name(() => {
1647
- return result.Cluster.Status;
1648
- }, "returnComparator");
1649
- if (returnComparator() === "PENDING") {
1650
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1651
- }
1652
- } catch (e) {
1499
+ catch (exception) {
1500
+ reason = exception;
1501
+ if (exception.name && exception.name == "InternalServerException") {
1502
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1503
+ }
1653
1504
  }
1654
- } catch (exception) {
1655
- reason = exception;
1656
- if (exception.name && exception.name == "InternalServerException") {
1657
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1658
- }
1659
- }
1660
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1661
- }, "checkState");
1662
- var waitForClusterCreated = /* @__PURE__ */ __name(async (params, input) => {
1663
- const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1664
- return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
1665
- }, "waitForClusterCreated");
1666
- var waitUntilClusterCreated = /* @__PURE__ */ __name(async (params, input) => {
1667
- const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1668
- const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
1669
- return (0, import_util_waiter.checkExceptions)(result);
1670
- }, "waitUntilClusterCreated");
1671
-
1672
- // src/waiters/waitForClusterDeleted.ts
1505
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1506
+ };
1507
+ const waitForClusterCreated = async (params, input) => {
1508
+ const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1509
+ return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
1510
+ };
1511
+ const waitUntilClusterCreated = async (params, input) => {
1512
+ const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1513
+ const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
1514
+ return utilWaiter.checkExceptions(result);
1515
+ };
1673
1516
 
1674
- var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
1675
- let reason;
1676
- try {
1677
- const result = await client.send(new DescribeClusterCommand(input));
1678
- reason = result;
1517
+ const checkState$4 = async (client, input) => {
1518
+ let reason;
1679
1519
  try {
1680
- const returnComparator = /* @__PURE__ */ __name(() => {
1681
- return result.Cluster.Status;
1682
- }, "returnComparator");
1683
- if (returnComparator() === "PENDING_DELETION") {
1684
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1685
- }
1686
- } catch (e) {
1687
- }
1688
- } catch (exception) {
1689
- reason = exception;
1690
- if (exception.name && exception.name == "ResourceNotFoundException") {
1691
- return { state: import_util_waiter.WaiterState.SUCCESS, reason };
1520
+ const result = await client.send(new DescribeClusterCommand(input));
1521
+ reason = result;
1522
+ try {
1523
+ const returnComparator = () => {
1524
+ return result.Cluster.Status;
1525
+ };
1526
+ if (returnComparator() === "PENDING_DELETION") {
1527
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1528
+ }
1529
+ }
1530
+ catch (e) { }
1692
1531
  }
1693
- if (exception.name && exception.name == "InternalServerException") {
1694
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1532
+ catch (exception) {
1533
+ reason = exception;
1534
+ if (exception.name && exception.name == "ResourceNotFoundException") {
1535
+ return { state: utilWaiter.WaiterState.SUCCESS, reason };
1536
+ }
1537
+ if (exception.name && exception.name == "InternalServerException") {
1538
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1539
+ }
1695
1540
  }
1696
- }
1697
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1698
- }, "checkState");
1699
- var waitForClusterDeleted = /* @__PURE__ */ __name(async (params, input) => {
1700
- const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1701
- return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
1702
- }, "waitForClusterDeleted");
1703
- var waitUntilClusterDeleted = /* @__PURE__ */ __name(async (params, input) => {
1704
- const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1705
- const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
1706
- return (0, import_util_waiter.checkExceptions)(result);
1707
- }, "waitUntilClusterDeleted");
1708
-
1709
- // src/waiters/waitForControlPanelCreated.ts
1541
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1542
+ };
1543
+ const waitForClusterDeleted = async (params, input) => {
1544
+ const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1545
+ return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
1546
+ };
1547
+ const waitUntilClusterDeleted = async (params, input) => {
1548
+ const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1549
+ const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
1550
+ return utilWaiter.checkExceptions(result);
1551
+ };
1710
1552
 
1711
- var checkState3 = /* @__PURE__ */ __name(async (client, input) => {
1712
- let reason;
1713
- try {
1714
- const result = await client.send(new DescribeControlPanelCommand(input));
1715
- reason = result;
1553
+ const checkState$3 = async (client, input) => {
1554
+ let reason;
1716
1555
  try {
1717
- const returnComparator = /* @__PURE__ */ __name(() => {
1718
- return result.ControlPanel.Status;
1719
- }, "returnComparator");
1720
- if (returnComparator() === "DEPLOYED") {
1721
- return { state: import_util_waiter.WaiterState.SUCCESS, reason };
1722
- }
1723
- } catch (e) {
1556
+ const result = await client.send(new DescribeControlPanelCommand(input));
1557
+ reason = result;
1558
+ try {
1559
+ const returnComparator = () => {
1560
+ return result.ControlPanel.Status;
1561
+ };
1562
+ if (returnComparator() === "DEPLOYED") {
1563
+ return { state: utilWaiter.WaiterState.SUCCESS, reason };
1564
+ }
1565
+ }
1566
+ catch (e) { }
1567
+ try {
1568
+ const returnComparator = () => {
1569
+ return result.ControlPanel.Status;
1570
+ };
1571
+ if (returnComparator() === "PENDING") {
1572
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1573
+ }
1574
+ }
1575
+ catch (e) { }
1724
1576
  }
1725
- try {
1726
- const returnComparator = /* @__PURE__ */ __name(() => {
1727
- return result.ControlPanel.Status;
1728
- }, "returnComparator");
1729
- if (returnComparator() === "PENDING") {
1730
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1731
- }
1732
- } catch (e) {
1577
+ catch (exception) {
1578
+ reason = exception;
1579
+ if (exception.name && exception.name == "InternalServerException") {
1580
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1581
+ }
1733
1582
  }
1734
- } catch (exception) {
1735
- reason = exception;
1736
- if (exception.name && exception.name == "InternalServerException") {
1737
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1738
- }
1739
- }
1740
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1741
- }, "checkState");
1742
- var waitForControlPanelCreated = /* @__PURE__ */ __name(async (params, input) => {
1743
- const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1744
- return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
1745
- }, "waitForControlPanelCreated");
1746
- var waitUntilControlPanelCreated = /* @__PURE__ */ __name(async (params, input) => {
1747
- const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1748
- const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
1749
- return (0, import_util_waiter.checkExceptions)(result);
1750
- }, "waitUntilControlPanelCreated");
1751
-
1752
- // src/waiters/waitForControlPanelDeleted.ts
1583
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1584
+ };
1585
+ const waitForControlPanelCreated = async (params, input) => {
1586
+ const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1587
+ return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
1588
+ };
1589
+ const waitUntilControlPanelCreated = async (params, input) => {
1590
+ const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1591
+ const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
1592
+ return utilWaiter.checkExceptions(result);
1593
+ };
1753
1594
 
1754
- var checkState4 = /* @__PURE__ */ __name(async (client, input) => {
1755
- let reason;
1756
- try {
1757
- const result = await client.send(new DescribeControlPanelCommand(input));
1758
- reason = result;
1595
+ const checkState$2 = async (client, input) => {
1596
+ let reason;
1759
1597
  try {
1760
- const returnComparator = /* @__PURE__ */ __name(() => {
1761
- return result.ControlPanel.Status;
1762
- }, "returnComparator");
1763
- if (returnComparator() === "PENDING_DELETION") {
1764
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1765
- }
1766
- } catch (e) {
1767
- }
1768
- } catch (exception) {
1769
- reason = exception;
1770
- if (exception.name && exception.name == "ResourceNotFoundException") {
1771
- return { state: import_util_waiter.WaiterState.SUCCESS, reason };
1598
+ const result = await client.send(new DescribeControlPanelCommand(input));
1599
+ reason = result;
1600
+ try {
1601
+ const returnComparator = () => {
1602
+ return result.ControlPanel.Status;
1603
+ };
1604
+ if (returnComparator() === "PENDING_DELETION") {
1605
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1606
+ }
1607
+ }
1608
+ catch (e) { }
1772
1609
  }
1773
- if (exception.name && exception.name == "InternalServerException") {
1774
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1610
+ catch (exception) {
1611
+ reason = exception;
1612
+ if (exception.name && exception.name == "ResourceNotFoundException") {
1613
+ return { state: utilWaiter.WaiterState.SUCCESS, reason };
1614
+ }
1615
+ if (exception.name && exception.name == "InternalServerException") {
1616
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1617
+ }
1775
1618
  }
1776
- }
1777
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1778
- }, "checkState");
1779
- var waitForControlPanelDeleted = /* @__PURE__ */ __name(async (params, input) => {
1780
- const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1781
- return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
1782
- }, "waitForControlPanelDeleted");
1783
- var waitUntilControlPanelDeleted = /* @__PURE__ */ __name(async (params, input) => {
1784
- const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1785
- const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
1786
- return (0, import_util_waiter.checkExceptions)(result);
1787
- }, "waitUntilControlPanelDeleted");
1788
-
1789
- // src/waiters/waitForRoutingControlCreated.ts
1619
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1620
+ };
1621
+ const waitForControlPanelDeleted = async (params, input) => {
1622
+ const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1623
+ return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
1624
+ };
1625
+ const waitUntilControlPanelDeleted = async (params, input) => {
1626
+ const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1627
+ const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
1628
+ return utilWaiter.checkExceptions(result);
1629
+ };
1790
1630
 
1791
- var checkState5 = /* @__PURE__ */ __name(async (client, input) => {
1792
- let reason;
1793
- try {
1794
- const result = await client.send(new DescribeRoutingControlCommand(input));
1795
- reason = result;
1796
- try {
1797
- const returnComparator = /* @__PURE__ */ __name(() => {
1798
- return result.RoutingControl.Status;
1799
- }, "returnComparator");
1800
- if (returnComparator() === "DEPLOYED") {
1801
- return { state: import_util_waiter.WaiterState.SUCCESS, reason };
1802
- }
1803
- } catch (e) {
1804
- }
1631
+ const checkState$1 = async (client, input) => {
1632
+ let reason;
1805
1633
  try {
1806
- const returnComparator = /* @__PURE__ */ __name(() => {
1807
- return result.RoutingControl.Status;
1808
- }, "returnComparator");
1809
- if (returnComparator() === "PENDING") {
1810
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1811
- }
1812
- } catch (e) {
1634
+ const result = await client.send(new DescribeRoutingControlCommand(input));
1635
+ reason = result;
1636
+ try {
1637
+ const returnComparator = () => {
1638
+ return result.RoutingControl.Status;
1639
+ };
1640
+ if (returnComparator() === "DEPLOYED") {
1641
+ return { state: utilWaiter.WaiterState.SUCCESS, reason };
1642
+ }
1643
+ }
1644
+ catch (e) { }
1645
+ try {
1646
+ const returnComparator = () => {
1647
+ return result.RoutingControl.Status;
1648
+ };
1649
+ if (returnComparator() === "PENDING") {
1650
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1651
+ }
1652
+ }
1653
+ catch (e) { }
1813
1654
  }
1814
- } catch (exception) {
1815
- reason = exception;
1816
- if (exception.name && exception.name == "InternalServerException") {
1817
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1655
+ catch (exception) {
1656
+ reason = exception;
1657
+ if (exception.name && exception.name == "InternalServerException") {
1658
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1659
+ }
1818
1660
  }
1819
- }
1820
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1821
- }, "checkState");
1822
- var waitForRoutingControlCreated = /* @__PURE__ */ __name(async (params, input) => {
1823
- const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1824
- return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState5);
1825
- }, "waitForRoutingControlCreated");
1826
- var waitUntilRoutingControlCreated = /* @__PURE__ */ __name(async (params, input) => {
1827
- const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1828
- const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState5);
1829
- return (0, import_util_waiter.checkExceptions)(result);
1830
- }, "waitUntilRoutingControlCreated");
1831
-
1832
- // src/waiters/waitForRoutingControlDeleted.ts
1661
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1662
+ };
1663
+ const waitForRoutingControlCreated = async (params, input) => {
1664
+ const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1665
+ return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
1666
+ };
1667
+ const waitUntilRoutingControlCreated = async (params, input) => {
1668
+ const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1669
+ const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
1670
+ return utilWaiter.checkExceptions(result);
1671
+ };
1833
1672
 
1834
- var checkState6 = /* @__PURE__ */ __name(async (client, input) => {
1835
- let reason;
1836
- try {
1837
- const result = await client.send(new DescribeRoutingControlCommand(input));
1838
- reason = result;
1673
+ const checkState = async (client, input) => {
1674
+ let reason;
1839
1675
  try {
1840
- const returnComparator = /* @__PURE__ */ __name(() => {
1841
- return result.RoutingControl.Status;
1842
- }, "returnComparator");
1843
- if (returnComparator() === "PENDING_DELETION") {
1844
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1845
- }
1846
- } catch (e) {
1676
+ const result = await client.send(new DescribeRoutingControlCommand(input));
1677
+ reason = result;
1678
+ try {
1679
+ const returnComparator = () => {
1680
+ return result.RoutingControl.Status;
1681
+ };
1682
+ if (returnComparator() === "PENDING_DELETION") {
1683
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1684
+ }
1685
+ }
1686
+ catch (e) { }
1847
1687
  }
1848
- } catch (exception) {
1849
- reason = exception;
1850
- if (exception.name && exception.name == "ResourceNotFoundException") {
1851
- return { state: import_util_waiter.WaiterState.SUCCESS, reason };
1688
+ catch (exception) {
1689
+ reason = exception;
1690
+ if (exception.name && exception.name == "ResourceNotFoundException") {
1691
+ return { state: utilWaiter.WaiterState.SUCCESS, reason };
1692
+ }
1693
+ if (exception.name && exception.name == "InternalServerException") {
1694
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1695
+ }
1852
1696
  }
1853
- if (exception.name && exception.name == "InternalServerException") {
1854
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1855
- }
1856
- }
1857
- return { state: import_util_waiter.WaiterState.RETRY, reason };
1858
- }, "checkState");
1859
- var waitForRoutingControlDeleted = /* @__PURE__ */ __name(async (params, input) => {
1860
- const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1861
- return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState6);
1862
- }, "waitForRoutingControlDeleted");
1863
- var waitUntilRoutingControlDeleted = /* @__PURE__ */ __name(async (params, input) => {
1864
- const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1865
- const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState6);
1866
- return (0, import_util_waiter.checkExceptions)(result);
1867
- }, "waitUntilRoutingControlDeleted");
1868
- // Annotate the CommonJS export names for ESM import in node:
1697
+ return { state: utilWaiter.WaiterState.RETRY, reason };
1698
+ };
1699
+ const waitForRoutingControlDeleted = async (params, input) => {
1700
+ const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1701
+ return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
1702
+ };
1703
+ const waitUntilRoutingControlDeleted = async (params, input) => {
1704
+ const serviceDefaults = { minDelay: 5, maxDelay: 120 };
1705
+ const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
1706
+ return utilWaiter.checkExceptions(result);
1707
+ };
1869
1708
 
1870
- 0 && (module.exports = {
1871
- Route53RecoveryControlConfigServiceException,
1872
- __Client,
1873
- Route53RecoveryControlConfigClient,
1874
- Route53RecoveryControlConfig,
1875
- $Command,
1876
- CreateClusterCommand,
1877
- CreateControlPanelCommand,
1878
- CreateRoutingControlCommand,
1879
- CreateSafetyRuleCommand,
1880
- DeleteClusterCommand,
1881
- DeleteControlPanelCommand,
1882
- DeleteRoutingControlCommand,
1883
- DeleteSafetyRuleCommand,
1884
- DescribeClusterCommand,
1885
- DescribeControlPanelCommand,
1886
- DescribeRoutingControlCommand,
1887
- DescribeSafetyRuleCommand,
1888
- GetResourcePolicyCommand,
1889
- ListAssociatedRoute53HealthChecksCommand,
1890
- ListClustersCommand,
1891
- ListControlPanelsCommand,
1892
- ListRoutingControlsCommand,
1893
- ListSafetyRulesCommand,
1894
- ListTagsForResourceCommand,
1895
- TagResourceCommand,
1896
- UntagResourceCommand,
1897
- UpdateClusterCommand,
1898
- UpdateControlPanelCommand,
1899
- UpdateRoutingControlCommand,
1900
- UpdateSafetyRuleCommand,
1901
- paginateListAssociatedRoute53HealthChecks,
1902
- paginateListClusters,
1903
- paginateListControlPanels,
1904
- paginateListRoutingControls,
1905
- paginateListSafetyRules,
1906
- waitForClusterCreated,
1907
- waitUntilClusterCreated,
1908
- waitForClusterDeleted,
1909
- waitUntilClusterDeleted,
1910
- waitForControlPanelCreated,
1911
- waitUntilControlPanelCreated,
1912
- waitForControlPanelDeleted,
1913
- waitUntilControlPanelDeleted,
1914
- waitForRoutingControlCreated,
1915
- waitUntilRoutingControlCreated,
1916
- waitForRoutingControlDeleted,
1917
- waitUntilRoutingControlDeleted,
1918
- NetworkType,
1919
- Status,
1920
- RuleType,
1921
- AccessDeniedException,
1922
- ConflictException,
1923
- InternalServerException,
1924
- ResourceNotFoundException,
1925
- ServiceQuotaExceededException,
1926
- ThrottlingException,
1927
- ValidationException
1709
+ Object.defineProperty(exports, "$Command", {
1710
+ enumerable: true,
1711
+ get: function () { return smithyClient.Command; }
1928
1712
  });
1929
-
1713
+ Object.defineProperty(exports, "__Client", {
1714
+ enumerable: true,
1715
+ get: function () { return smithyClient.Client; }
1716
+ });
1717
+ exports.AccessDeniedException = AccessDeniedException;
1718
+ exports.ConflictException = ConflictException;
1719
+ exports.CreateClusterCommand = CreateClusterCommand;
1720
+ exports.CreateControlPanelCommand = CreateControlPanelCommand;
1721
+ exports.CreateRoutingControlCommand = CreateRoutingControlCommand;
1722
+ exports.CreateSafetyRuleCommand = CreateSafetyRuleCommand;
1723
+ exports.DeleteClusterCommand = DeleteClusterCommand;
1724
+ exports.DeleteControlPanelCommand = DeleteControlPanelCommand;
1725
+ exports.DeleteRoutingControlCommand = DeleteRoutingControlCommand;
1726
+ exports.DeleteSafetyRuleCommand = DeleteSafetyRuleCommand;
1727
+ exports.DescribeClusterCommand = DescribeClusterCommand;
1728
+ exports.DescribeControlPanelCommand = DescribeControlPanelCommand;
1729
+ exports.DescribeRoutingControlCommand = DescribeRoutingControlCommand;
1730
+ exports.DescribeSafetyRuleCommand = DescribeSafetyRuleCommand;
1731
+ exports.GetResourcePolicyCommand = GetResourcePolicyCommand;
1732
+ exports.InternalServerException = InternalServerException;
1733
+ exports.ListAssociatedRoute53HealthChecksCommand = ListAssociatedRoute53HealthChecksCommand;
1734
+ exports.ListClustersCommand = ListClustersCommand;
1735
+ exports.ListControlPanelsCommand = ListControlPanelsCommand;
1736
+ exports.ListRoutingControlsCommand = ListRoutingControlsCommand;
1737
+ exports.ListSafetyRulesCommand = ListSafetyRulesCommand;
1738
+ exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
1739
+ exports.NetworkType = NetworkType;
1740
+ exports.ResourceNotFoundException = ResourceNotFoundException;
1741
+ exports.Route53RecoveryControlConfig = Route53RecoveryControlConfig;
1742
+ exports.Route53RecoveryControlConfigClient = Route53RecoveryControlConfigClient;
1743
+ exports.Route53RecoveryControlConfigServiceException = Route53RecoveryControlConfigServiceException;
1744
+ exports.RuleType = RuleType;
1745
+ exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
1746
+ exports.Status = Status;
1747
+ exports.TagResourceCommand = TagResourceCommand;
1748
+ exports.ThrottlingException = ThrottlingException;
1749
+ exports.UntagResourceCommand = UntagResourceCommand;
1750
+ exports.UpdateClusterCommand = UpdateClusterCommand;
1751
+ exports.UpdateControlPanelCommand = UpdateControlPanelCommand;
1752
+ exports.UpdateRoutingControlCommand = UpdateRoutingControlCommand;
1753
+ exports.UpdateSafetyRuleCommand = UpdateSafetyRuleCommand;
1754
+ exports.ValidationException = ValidationException;
1755
+ exports.paginateListAssociatedRoute53HealthChecks = paginateListAssociatedRoute53HealthChecks;
1756
+ exports.paginateListClusters = paginateListClusters;
1757
+ exports.paginateListControlPanels = paginateListControlPanels;
1758
+ exports.paginateListRoutingControls = paginateListRoutingControls;
1759
+ exports.paginateListSafetyRules = paginateListSafetyRules;
1760
+ exports.waitForClusterCreated = waitForClusterCreated;
1761
+ exports.waitForClusterDeleted = waitForClusterDeleted;
1762
+ exports.waitForControlPanelCreated = waitForControlPanelCreated;
1763
+ exports.waitForControlPanelDeleted = waitForControlPanelDeleted;
1764
+ exports.waitForRoutingControlCreated = waitForRoutingControlCreated;
1765
+ exports.waitForRoutingControlDeleted = waitForRoutingControlDeleted;
1766
+ exports.waitUntilClusterCreated = waitUntilClusterCreated;
1767
+ exports.waitUntilClusterDeleted = waitUntilClusterDeleted;
1768
+ exports.waitUntilControlPanelCreated = waitUntilControlPanelCreated;
1769
+ exports.waitUntilControlPanelDeleted = waitUntilControlPanelDeleted;
1770
+ exports.waitUntilRoutingControlCreated = waitUntilRoutingControlCreated;
1771
+ exports.waitUntilRoutingControlDeleted = waitUntilRoutingControlDeleted;