@aws-sdk/client-route53-recovery-cluster 3.55.0 → 3.61.0

package/dist-es/pagination/ListRoutingControlsPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ListRoutingControlsCommand, } from "../commands/ListRoutingControlsCommand";
+import { Route53RecoveryCluster } from "../Route53RecoveryCluster";
+import { Route53RecoveryClusterClient } from "../Route53RecoveryClusterClient";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new ListRoutingControlsCommand(input)], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.listRoutingControls.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListRoutingControls(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListRoutingControls_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.NextToken = token;
+                    input["MaxResults"] = config.pageSize;
+                    if (!(config.client instanceof Route53RecoveryCluster)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof Route53RecoveryClusterClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected Route53RecoveryCluster | Route53RecoveryClusterClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.NextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/index.js

@@ -0,0 +1,2 @@
+export * from "./Interfaces";
+export * from "./ListRoutingControlsPaginator";

package/dist-es/protocols/Aws_json1_0.js

@@ -1,7 +1,7 @@
 import { __assign, __awaiter, __generator } from "tslib";
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectString as __expectString, } from "@aws-sdk/smithy-client";
-import { AccessDeniedException, ConflictException, EndpointTemporarilyUnavailableException, InternalServerException, ResourceNotFoundException, ThrottlingException, ValidationException, } from "../models/models_0";
+import { AccessDeniedException, ConflictException, EndpointTemporarilyUnavailableException, InternalServerException, ResourceNotFoundException, ServiceLimitExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
 import { Route53RecoveryClusterServiceException as __BaseException } from "../models/Route53RecoveryClusterServiceException";
 export var serializeAws_json1_0GetRoutingControlStateCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
@@ -14,6 +14,17 @@ export var serializeAws_json1_0GetRoutingControlStateCommand = function (input,
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_json1_0ListRoutingControlsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "ToggleCustomerAPI.ListRoutingControls",
+        };
+        body = JSON.stringify(serializeAws_json1_0ListRoutingControlsRequest(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_json1_0UpdateRoutingControlStateCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -106,6 +117,76 @@ var deserializeAws_json1_0GetRoutingControlStateCommandError = function (output,
         }
     });
 }); };
+export var deserializeAws_json1_0ListRoutingControlsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0ListRoutingControlsCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0ListRoutingControlsResponse(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0ListRoutingControlsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = "UnknownError";
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AccessDeniedException": return [3, 2];
+                    case "com.amazonaws.route53recoverycluster#AccessDeniedException": return [3, 2];
+                    case "EndpointTemporarilyUnavailableException": return [3, 4];
+                    case "com.amazonaws.route53recoverycluster#EndpointTemporarilyUnavailableException": return [3, 4];
+                    case "InternalServerException": return [3, 6];
+                    case "com.amazonaws.route53recoverycluster#InternalServerException": return [3, 6];
+                    case "ResourceNotFoundException": return [3, 8];
+                    case "com.amazonaws.route53recoverycluster#ResourceNotFoundException": return [3, 8];
+                    case "ThrottlingException": return [3, 10];
+                    case "com.amazonaws.route53recoverycluster#ThrottlingException": return [3, 10];
+                    case "ValidationException": return [3, 12];
+                    case "com.amazonaws.route53recoverycluster#ValidationException": return [3, 12];
+                }
+                return [3, 14];
+            case 2: return [4, deserializeAws_json1_0AccessDeniedExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0EndpointTemporarilyUnavailableExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_0InternalServerExceptionResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_json1_0ResourceNotFoundExceptionResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10: return [4, deserializeAws_json1_0ThrottlingExceptionResponse(parsedOutput, context)];
+            case 11: throw _d.sent();
+            case 12: return [4, deserializeAws_json1_0ValidationExceptionResponse(parsedOutput, context)];
+            case 13: throw _d.sent();
+            case 14:
+                parsedBody = parsedOutput.body;
+                response = new __BaseException({
+                    name: parsedBody.code || parsedBody.Code || errorCode,
+                    $fault: "client",
+                    $metadata: deserializeMetadata(output),
+                });
+                throw __decorateServiceException(response, parsedBody);
+        }
+    });
+}); };
 export var deserializeAws_json1_0UpdateRoutingControlStateCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -223,12 +304,14 @@ var deserializeAws_json1_0UpdateRoutingControlStatesCommandError = function (out
                     case "com.amazonaws.route53recoverycluster#InternalServerException": return [3, 8];
                     case "ResourceNotFoundException": return [3, 10];
                     case "com.amazonaws.route53recoverycluster#ResourceNotFoundException": return [3, 10];
-                    case "ThrottlingException": return [3, 12];
-                    case "com.amazonaws.route53recoverycluster#ThrottlingException": return [3, 12];
-                    case "ValidationException": return [3, 14];
-                    case "com.amazonaws.route53recoverycluster#ValidationException": return [3, 14];
+                    case "ServiceLimitExceededException": return [3, 12];
+                    case "com.amazonaws.route53recoverycluster#ServiceLimitExceededException": return [3, 12];
+                    case "ThrottlingException": return [3, 14];
+                    case "com.amazonaws.route53recoverycluster#ThrottlingException": return [3, 14];
+                    case "ValidationException": return [3, 16];
+                    case "com.amazonaws.route53recoverycluster#ValidationException": return [3, 16];
                 }
-                return [3, 16];
+                return [3, 18];
             case 2: return [4, deserializeAws_json1_0AccessDeniedExceptionResponse(parsedOutput, context)];
             case 3: throw _d.sent();
             case 4: return [4, deserializeAws_json1_0ConflictExceptionResponse(parsedOutput, context)];
@@ -239,11 +322,13 @@ var deserializeAws_json1_0UpdateRoutingControlStatesCommandError = function (out
             case 9: throw _d.sent();
             case 10: return [4, deserializeAws_json1_0ResourceNotFoundExceptionResponse(parsedOutput, context)];
             case 11: throw _d.sent();
-            case 12: return [4, deserializeAws_json1_0ThrottlingExceptionResponse(parsedOutput, context)];
+            case 12: return [4, deserializeAws_json1_0ServiceLimitExceededExceptionResponse(parsedOutput, context)];
             case 13: throw _d.sent();
-            case 14: return [4, deserializeAws_json1_0ValidationExceptionResponse(parsedOutput, context)];
+            case 14: return [4, deserializeAws_json1_0ThrottlingExceptionResponse(parsedOutput, context)];
             case 15: throw _d.sent();
-            case 16:
+            case 16: return [4, deserializeAws_json1_0ValidationExceptionResponse(parsedOutput, context)];
+            case 17: throw _d.sent();
+            case 18:
                 parsedBody = parsedOutput.body;
                 response = new __BaseException({
                     name: parsedBody.code || parsedBody.Code || errorCode,
@@ -299,6 +384,15 @@ var deserializeAws_json1_0ResourceNotFoundExceptionResponse = function (parsedOu
         return [2, __decorateServiceException(exception, body)];
     });
 }); };
+var deserializeAws_json1_0ServiceLimitExceededExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0ServiceLimitExceededException(body, context);
+        exception = new ServiceLimitExceededException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
 var deserializeAws_json1_0ThrottlingExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
     var body, deserialized, exception;
     return __generator(this, function (_a) {
@@ -331,6 +425,10 @@ var serializeAws_json1_0GetRoutingControlStateRequest = function (input, context
     return __assign({}, (input.RoutingControlArn !== undefined &&
         input.RoutingControlArn !== null && { RoutingControlArn: input.RoutingControlArn }));
 };
+var serializeAws_json1_0ListRoutingControlsRequest = function (input, context) {
+    return __assign(__assign(__assign({}, (input.ControlPanelArn !== undefined &&
+        input.ControlPanelArn !== null && { ControlPanelArn: input.ControlPanelArn })), (input.MaxResults !== undefined && input.MaxResults !== null && { MaxResults: input.MaxResults })), (input.NextToken !== undefined && input.NextToken !== null && { NextToken: input.NextToken }));
+};
 var serializeAws_json1_0UpdateRoutingControlStateEntries = function (input, context) {
     return input
         .filter(function (e) { return e != null; })
@@ -383,6 +481,7 @@ var deserializeAws_json1_0EndpointTemporarilyUnavailableException = function (ou
 var deserializeAws_json1_0GetRoutingControlStateResponse = function (output, context) {
     return {
         RoutingControlArn: __expectString(output.RoutingControlArn),
+        RoutingControlName: __expectString(output.RoutingControlName),
         RoutingControlState: __expectString(output.RoutingControlState),
     };
 };
@@ -392,6 +491,14 @@ var deserializeAws_json1_0InternalServerException = function (output, context) {
         retryAfterSeconds: __expectInt32(output.retryAfterSeconds),
     };
 };
+var deserializeAws_json1_0ListRoutingControlsResponse = function (output, context) {
+    return {
+        NextToken: __expectString(output.NextToken),
+        RoutingControls: output.RoutingControls !== undefined && output.RoutingControls !== null
+            ? deserializeAws_json1_0RoutingControls(output.RoutingControls, context)
+            : undefined,
+    };
+};
 var deserializeAws_json1_0ResourceNotFoundException = function (output, context) {
     return {
         message: __expectString(output.message),
@@ -399,6 +506,35 @@ var deserializeAws_json1_0ResourceNotFoundException = function (output, context)
         resourceType: __expectString(output.resourceType),
     };
 };
+var deserializeAws_json1_0RoutingControl = function (output, context) {
+    return {
+        ControlPanelArn: __expectString(output.ControlPanelArn),
+        ControlPanelName: __expectString(output.ControlPanelName),
+        RoutingControlArn: __expectString(output.RoutingControlArn),
+        RoutingControlName: __expectString(output.RoutingControlName),
+        RoutingControlState: __expectString(output.RoutingControlState),
+    };
+};
+var deserializeAws_json1_0RoutingControls = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_0RoutingControl(entry, context);
+    });
+    return retVal;
+};
+var deserializeAws_json1_0ServiceLimitExceededException = function (output, context) {
+    return {
+        limitCode: __expectString(output.limitCode),
+        message: __expectString(output.message),
+        resourceId: __expectString(output.resourceId),
+        resourceType: __expectString(output.resourceType),
+        serviceCode: __expectString(output.serviceCode),
+    };
+};
 var deserializeAws_json1_0ThrottlingException = function (output, context) {
     return {
         message: __expectString(output.message),

package/dist-types/Route53RecoveryCluster.d.ts

@@ -1,62 +1,64 @@
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
 import { GetRoutingControlStateCommandInput, GetRoutingControlStateCommandOutput } from "./commands/GetRoutingControlStateCommand";
+import { ListRoutingControlsCommandInput, ListRoutingControlsCommandOutput } from "./commands/ListRoutingControlsCommand";
 import { UpdateRoutingControlStateCommandInput, UpdateRoutingControlStateCommandOutput } from "./commands/UpdateRoutingControlStateCommand";
 import { UpdateRoutingControlStatesCommandInput, UpdateRoutingControlStatesCommandOutput } from "./commands/UpdateRoutingControlStatesCommand";
 import { Route53RecoveryClusterClient } from "./Route53RecoveryClusterClient";
 /**
  * <p>Welcome to the Routing Control (Recovery Cluster) API Reference Guide for Amazon Route 53 Application Recovery Controller.</p>
- * 			      <p>With Amazon Route 53 Application Recovery Controller, you can use routing control with extreme reliability to
+ * 			      <p>With Route 53 ARC, you can use routing control with extreme reliability to
  * 			recover applications by rerouting traffic across
- * 			Availability Zones or AWS Regions. Routing controls are simple on/off switches hosted
- * 			on a highly available cluster in Application Recovery Controller. A cluster provides a set of five redundant Regional endpoints against which you
+ * 			Availability Zones or Amazon Web Services Regions. Routing controls are simple on/off switches hosted
+ * 			on a highly available cluster in Route 53 ARC. A cluster provides a set of five redundant Regional endpoints against which you
  * 			can run API calls to get or update the state of routing controls. To implement failover, you set
- * 			one routing control on and another one off, to reroute traffic from one Availability Zone or Amazon Web Services Region
+ * 			one routing control On and another one Off, to reroute traffic from one Availability Zone or Amazon Web Services Region
  * 			to another. </p>
  * 			      <p>
- *             <i>Be aware that you must specify the Regional endpoints for a cluster when you work with API cluster operations
- * 				to get or update routing control states in Application Recovery Controller.</i> In addition, you must specify the US West (Oregon) Region
- * 				for Application Recovery Controller API calls. For example, use the parameter <code>region us-west-2</code> with AWS CLI commands.
+ *             <i>Be aware that you must specify a Regional endpoint for a cluster when you work with API cluster operations
+ * 				to get or update routing control states in Route 53 ARC.</i> In addition, you must specify the US West (Oregon) Region
+ * 				for Route 53 ARC API calls. For example, use the parameter <code>--region us-west-2</code> with AWS CLI commands.
  * 				For more information, see
  * 				<a href="https://docs.aws.amazon.com/r53recovery/latest/dg/routing-control.update.api.html">
  * 					Get and update routing control states using the API</a> in the Amazon Route 53 Application Recovery Controller Developer Guide.</p>
  * 		       <p>This API guide includes information about the API operations for how to get and update routing control states
- * 			in Application Recovery Controller. You also must set up the structures to support routing controls: clusters and control panels.</p>
- * 			      <p>For more information about working with routing control in Application Recovery Controller, see the following:</p>
+ * 			in Route 53 ARC. To work with routing control in Route 53 ARC, you must first create the required components (clusters, control
+ * 			panels, and routing controls) using the recovery cluster configuration API.</p>
+ * 			      <p>For more information about working with routing control in Route 53 ARC, see the following:</p>
  * 		       <ul>
  *             <li>
- * 				           <p>To create clusters, routing controls, and control panels by using the control plane API
- * 					for routing control, see the <a href="https://docs.aws.amazon.com/recovery-cluster/latest/api/">Recovery Control Configuration API Reference Guide for Amazon Route 53 Application Recovery Controller</a>.</p>
+ * 				           <p>Create clusters, control panels, and routing controls by using API operations. For more information,
+ * 					see the <a href="https://docs.aws.amazon.com/recovery-cluster/latest/api/">Recovery Control Configuration API Reference Guide for Amazon Route 53 Application Recovery Controller</a>.</p>
  * 			         </li>
  *             <li>
- *                <p>Learn about the components in recovery control configuration, including clusters,
- * 				routing controls, and control panels. For more information, see
- * 				<a href="https://docs.aws.amazon.com/r53recovery/latest/dg/introduction-components.html#introduction-components-routing">
+ *                <p>Learn about the components in recovery control, including clusters,
+ * 				routing controls, and control panels, and how to work with Route 53 ARC in the Amazon Web Services console. For more
+ * 				information, see <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/introduction-components.html#introduction-components-routing">
  * 					Recovery control components</a> in the Amazon Route 53 Application Recovery Controller Developer Guide.</p>
  *             </li>
  *             <li>
- * 				           <p>Application Recovery Controller also provides readiness checks that run continually to help make sure that your
+ * 				           <p>Route 53 ARC also provides readiness checks that continually audit resources to help make sure that your
  * 					applications are scaled and ready to handle failover traffic. For more information about
- * 					the related API actions, see the <a href="https://docs.aws.amazon.com/recovery-readiness/latest/api/">Recovery Readiness API Reference Guide for Amazon Route 53 Application Recovery Controller</a>.</p>
+ * 					the related API operations, see the <a href="https://docs.aws.amazon.com/recovery-readiness/latest/api/">Recovery Readiness API Reference Guide for Amazon Route 53 Application Recovery Controller</a>.</p>
  * 			         </li>
  *             <li>
  * 				           <p>For more information about creating resilient applications and preparing for
- * 					recovery readiness with Application Recovery Controller, see the <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/">Amazon Route 53 Application Recovery Controller Developer Guide</a>.</p>
+ * 					recovery readiness with Route 53 ARC, see the <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/">Amazon Route 53 Application Recovery Controller Developer Guide</a>.</p>
  * 			         </li>
  *          </ul>
  */
 export declare class Route53RecoveryCluster extends Route53RecoveryClusterClient {
     /**
      * <p>Get the state for a routing control. A routing control is a simple on/off switch that you
-     * 			can use to route traffic to cells. When the state is On, traffic flows to a cell. When
-     * 			it's Off, traffic does not flow. </p>
-     * 			      <p>Before you can create a routing control, you must first create a cluster to host the control
-     * 				in a control panel. For more information, see <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/routing-control.create.html">
+     * 				can use to route traffic to cells. When a routing control state is On, traffic flows to a cell. When
+     * 				the state is Off, traffic does not flow. </p>
+     * 			      <p>Before you can create a routing control, you must first create a cluster, and then host the control
+     * 				in a control panel on the cluster. For more information, see <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/routing-control.create.html">
      * 					Create routing control structures</a> in the Amazon Route 53 Application Recovery Controller Developer Guide.
-     * 				Then you access one of the endpoints for the cluster to get or update the routing control state to
-     * 				redirect traffic. </p>
+     * 				You access one of the endpoints for the cluster to get or update the routing control state to
+     * 				redirect traffic for your application. </p>
      * 			      <p>
      *             <i>You must specify Regional endpoints when you work with API cluster operations
-     * 				to get or update routing control states in Application Recovery Controller.</i>
+     * 				to get or update routing control states in Route 53 ARC.</i>
      *          </p>
      * 			      <p>To see a code example for getting a routing control state, including accessing Regional cluster endpoints
      * 				in sequence, see <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/service_code_examples_actions.html">API examples</a>
@@ -72,7 +74,8 @@ export declare class Route53RecoveryCluster extends Route53RecoveryClusterClient
      *             </li>
      *             <li>
      *                <p>
-     *                   <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/routing-control.html">Working with routing controls overall</a>
+     *                   <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/routing-control.html">Working with
+     * 					routing controls in Route 53 ARC</a>
      *                </p>
      *             </li>
      *          </ul>
@@ -80,11 +83,48 @@ export declare class Route53RecoveryCluster extends Route53RecoveryClusterClient
     getRoutingControlState(args: GetRoutingControlStateCommandInput, options?: __HttpHandlerOptions): Promise<GetRoutingControlStateCommandOutput>;
     getRoutingControlState(args: GetRoutingControlStateCommandInput, cb: (err: any, data?: GetRoutingControlStateCommandOutput) => void): void;
     getRoutingControlState(args: GetRoutingControlStateCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetRoutingControlStateCommandOutput) => void): void;
+    /**
+     * <p>List routing control names and Amazon Resource Names (ARNs), as well as the routing control
+     * 			state for each routing control, along with the control panel name and control panel ARN for the routing controls.
+     * 			If you specify a control panel ARN, this call lists the routing controls in the control panel. Otherwise, it lists
+     * 			all the routing controls in the cluster.</p>
+     * 		       <p>A routing control is a simple on/off switch in Route 53 ARC that you
+     * 			can use to route traffic to cells. When a routing control state is On, traffic flows to a cell. When
+     * 			the state is Off, traffic does not flow.</p>
+     * 		       <p>Before you can create a routing control, you must first create a cluster, and then host the control
+     * 			in a control panel on the cluster. For more information, see <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/routing-control.create.html">
+     * 				Create routing control structures</a> in the Amazon Route 53 Application Recovery Controller Developer Guide.
+     * 			You access one of the endpoints for the cluster to get or update the routing control state to
+     * 			redirect traffic for your application. </p>
+     * 		       <p>
+     *             <i>You must specify Regional endpoints when you work with API cluster operations
+     * 			to use this API operation to list routing controls in Route 53 ARC.</i>
+     *          </p>
+     * 		       <p>Learn more about working with routing controls in the following topics in the
+     * 			Amazon Route 53 Application Recovery Controller Developer Guide:</p>
+     * 		       <ul>
+     *             <li>
+     *                <p>
+     *                   <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/routing-control.update.html">
+     * 				Viewing and updating routing control states</a>
+     *                </p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/routing-control.html">Working with
+     * 				routing controls in Route 53 ARC</a>
+     *                </p>
+     *             </li>
+     *          </ul>
+     */
+    listRoutingControls(args: ListRoutingControlsCommandInput, options?: __HttpHandlerOptions): Promise<ListRoutingControlsCommandOutput>;
+    listRoutingControls(args: ListRoutingControlsCommandInput, cb: (err: any, data?: ListRoutingControlsCommandOutput) => void): void;
+    listRoutingControls(args: ListRoutingControlsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListRoutingControlsCommandOutput) => void): void;
     /**
      * <p>Set the state of the routing control to reroute traffic. You can set the value to be On or
-     * 			Off. When the state is On, traffic flows to a cell. When it's Off, traffic does not
+     * 			Off. When the state is On, traffic flows to a cell. When the state is Off, traffic does not
      * 			flow.</p>
-     * 			      <p>With Application Recovery Controller, you can add safety rules for routing controls, which are safeguards for routing
+     * 			      <p>With Route 53 ARC, you can add safety rules for routing controls, which are safeguards for routing
      * 				control state updates that help prevent unexpected outcomes, like fail open traffic routing. However,
      * 				there are scenarios when you might want to bypass the routing control safeguards that are enforced with
      * 				safety rules that you've configured. For example, you might want to fail over quickly for disaster recovery,
@@ -97,7 +137,7 @@ export declare class Route53RecoveryCluster extends Route53RecoveryClusterClient
      * 					Override safety rules to reroute traffic</a> in the Amazon Route 53 Application Recovery Controller Developer Guide.</p>
      * 			      <p>
      *             <i>You must specify Regional endpoints when you work with API cluster operations
-     * 				to get or update routing control states in Application Recovery Controller.</i>
+     * 				to get or update routing control states in Route 53 ARC.</i>
      *          </p>
      * 			      <p>To see a code example for getting a routing control state, including accessing Regional cluster endpoints
      * 				in sequence, see <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/service_code_examples_actions.html">API examples</a>
@@ -123,7 +163,7 @@ export declare class Route53RecoveryCluster extends Route53RecoveryClusterClient
      * <p>Set multiple routing control states. You can set the value for each state to be On or Off.
      * 			When the state is On, traffic flows to a cell. When it's Off, traffic does not
      * 			flow.</p>
-     * 			      <p>With Application Recovery Controller, you can add safety rules for routing controls, which are safeguards for routing
+     * 			      <p>With Route 53 ARC, you can add safety rules for routing controls, which are safeguards for routing
      * 				control state updates that help prevent unexpected outcomes, like fail open traffic routing. However,
      * 				there are scenarios when you might want to bypass the routing control safeguards that are enforced with
      * 				safety rules that you've configured. For example, you might want to fail over quickly for disaster recovery,
@@ -136,7 +176,7 @@ export declare class Route53RecoveryCluster extends Route53RecoveryClusterClient
      * 					Override safety rules to reroute traffic</a> in the Amazon Route 53 Application Recovery Controller Developer Guide.</p>
      *          <p>
      *             <i>You must specify Regional endpoints when you work with API cluster operations
-     * 				to get or update routing control states in Application Recovery Controller.</i>
+     * 				to get or update routing control states in Route 53 ARC.</i>
      *          </p>
      * 			      <p>To see a code example for getting a routing control state, including accessing Regional cluster endpoints
      * 				in sequence, see <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/service_code_examples_actions.html">API examples</a>

package/dist-types/Route53RecoveryClusterClient.d.ts

@@ -7,10 +7,11 @@ import { HttpHandler as __HttpHandler } from "@aws-sdk/protocol-http";
 import { Client as __Client, DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@aws-sdk/smithy-client";
 import { BodyLengthCalculator as __BodyLengthCalculator, Credentials as __Credentials, Decoder as __Decoder, Encoder as __Encoder, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, RegionInfoProvider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@aws-sdk/types";
 import { GetRoutingControlStateCommandInput, GetRoutingControlStateCommandOutput } from "./commands/GetRoutingControlStateCommand";
+import { ListRoutingControlsCommandInput, ListRoutingControlsCommandOutput } from "./commands/ListRoutingControlsCommand";
 import { UpdateRoutingControlStateCommandInput, UpdateRoutingControlStateCommandOutput } from "./commands/UpdateRoutingControlStateCommand";
 import { UpdateRoutingControlStatesCommandInput, UpdateRoutingControlStatesCommandOutput } from "./commands/UpdateRoutingControlStatesCommand";
-export declare type ServiceInputTypes = GetRoutingControlStateCommandInput | UpdateRoutingControlStateCommandInput | UpdateRoutingControlStatesCommandInput;
-export declare type ServiceOutputTypes = GetRoutingControlStateCommandOutput | UpdateRoutingControlStateCommandOutput | UpdateRoutingControlStatesCommandOutput;
+export declare type ServiceInputTypes = GetRoutingControlStateCommandInput | ListRoutingControlsCommandInput | UpdateRoutingControlStateCommandInput | UpdateRoutingControlStatesCommandInput;
+export declare type ServiceOutputTypes = GetRoutingControlStateCommandOutput | ListRoutingControlsCommandOutput | UpdateRoutingControlStateCommandOutput | UpdateRoutingControlStatesCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
     /**
      * The HTTP handler to use. Fetch in browser and Https in Nodejs.
@@ -130,42 +131,43 @@ export interface Route53RecoveryClusterClientResolvedConfig extends Route53Recov
 }
 /**
  * <p>Welcome to the Routing Control (Recovery Cluster) API Reference Guide for Amazon Route 53 Application Recovery Controller.</p>
- * 			      <p>With Amazon Route 53 Application Recovery Controller, you can use routing control with extreme reliability to
+ * 			      <p>With Route 53 ARC, you can use routing control with extreme reliability to
  * 			recover applications by rerouting traffic across
- * 			Availability Zones or AWS Regions. Routing controls are simple on/off switches hosted
- * 			on a highly available cluster in Application Recovery Controller. A cluster provides a set of five redundant Regional endpoints against which you
+ * 			Availability Zones or Amazon Web Services Regions. Routing controls are simple on/off switches hosted
+ * 			on a highly available cluster in Route 53 ARC. A cluster provides a set of five redundant Regional endpoints against which you
  * 			can run API calls to get or update the state of routing controls. To implement failover, you set
- * 			one routing control on and another one off, to reroute traffic from one Availability Zone or Amazon Web Services Region
+ * 			one routing control On and another one Off, to reroute traffic from one Availability Zone or Amazon Web Services Region
  * 			to another. </p>
  * 			      <p>
- *             <i>Be aware that you must specify the Regional endpoints for a cluster when you work with API cluster operations
- * 				to get or update routing control states in Application Recovery Controller.</i> In addition, you must specify the US West (Oregon) Region
- * 				for Application Recovery Controller API calls. For example, use the parameter <code>region us-west-2</code> with AWS CLI commands.
+ *             <i>Be aware that you must specify a Regional endpoint for a cluster when you work with API cluster operations
+ * 				to get or update routing control states in Route 53 ARC.</i> In addition, you must specify the US West (Oregon) Region
+ * 				for Route 53 ARC API calls. For example, use the parameter <code>--region us-west-2</code> with AWS CLI commands.
  * 				For more information, see
  * 				<a href="https://docs.aws.amazon.com/r53recovery/latest/dg/routing-control.update.api.html">
  * 					Get and update routing control states using the API</a> in the Amazon Route 53 Application Recovery Controller Developer Guide.</p>
  * 		       <p>This API guide includes information about the API operations for how to get and update routing control states
- * 			in Application Recovery Controller. You also must set up the structures to support routing controls: clusters and control panels.</p>
- * 			      <p>For more information about working with routing control in Application Recovery Controller, see the following:</p>
+ * 			in Route 53 ARC. To work with routing control in Route 53 ARC, you must first create the required components (clusters, control
+ * 			panels, and routing controls) using the recovery cluster configuration API.</p>
+ * 			      <p>For more information about working with routing control in Route 53 ARC, see the following:</p>
  * 		       <ul>
  *             <li>
- * 				           <p>To create clusters, routing controls, and control panels by using the control plane API
- * 					for routing control, see the <a href="https://docs.aws.amazon.com/recovery-cluster/latest/api/">Recovery Control Configuration API Reference Guide for Amazon Route 53 Application Recovery Controller</a>.</p>
+ * 				           <p>Create clusters, control panels, and routing controls by using API operations. For more information,
+ * 					see the <a href="https://docs.aws.amazon.com/recovery-cluster/latest/api/">Recovery Control Configuration API Reference Guide for Amazon Route 53 Application Recovery Controller</a>.</p>
  * 			         </li>
  *             <li>
- *                <p>Learn about the components in recovery control configuration, including clusters,
- * 				routing controls, and control panels. For more information, see
- * 				<a href="https://docs.aws.amazon.com/r53recovery/latest/dg/introduction-components.html#introduction-components-routing">
+ *                <p>Learn about the components in recovery control, including clusters,
+ * 				routing controls, and control panels, and how to work with Route 53 ARC in the Amazon Web Services console. For more
+ * 				information, see <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/introduction-components.html#introduction-components-routing">
  * 					Recovery control components</a> in the Amazon Route 53 Application Recovery Controller Developer Guide.</p>
  *             </li>
  *             <li>
- * 				           <p>Application Recovery Controller also provides readiness checks that run continually to help make sure that your
+ * 				           <p>Route 53 ARC also provides readiness checks that continually audit resources to help make sure that your
  * 					applications are scaled and ready to handle failover traffic. For more information about
- * 					the related API actions, see the <a href="https://docs.aws.amazon.com/recovery-readiness/latest/api/">Recovery Readiness API Reference Guide for Amazon Route 53 Application Recovery Controller</a>.</p>
+ * 					the related API operations, see the <a href="https://docs.aws.amazon.com/recovery-readiness/latest/api/">Recovery Readiness API Reference Guide for Amazon Route 53 Application Recovery Controller</a>.</p>
  * 			         </li>
  *             <li>
  * 				           <p>For more information about creating resilient applications and preparing for
- * 					recovery readiness with Application Recovery Controller, see the <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/">Amazon Route 53 Application Recovery Controller Developer Guide</a>.</p>
+ * 					recovery readiness with Route 53 ARC, see the <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/">Amazon Route 53 Application Recovery Controller Developer Guide</a>.</p>
  * 			         </li>
  *          </ul>
  */

package/dist-types/commands/GetRoutingControlStateCommand.d.ts

@@ -8,16 +8,16 @@ export interface GetRoutingControlStateCommandOutput extends GetRoutingControlSt
 }
 /**
  * <p>Get the state for a routing control. A routing control is a simple on/off switch that you
- * 			can use to route traffic to cells. When the state is On, traffic flows to a cell. When
- * 			it's Off, traffic does not flow. </p>
- * 			      <p>Before you can create a routing control, you must first create a cluster to host the control
- * 				in a control panel. For more information, see <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/routing-control.create.html">
+ * 				can use to route traffic to cells. When a routing control state is On, traffic flows to a cell. When
+ * 				the state is Off, traffic does not flow. </p>
+ * 			      <p>Before you can create a routing control, you must first create a cluster, and then host the control
+ * 				in a control panel on the cluster. For more information, see <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/routing-control.create.html">
  * 					Create routing control structures</a> in the Amazon Route 53 Application Recovery Controller Developer Guide.
- * 				Then you access one of the endpoints for the cluster to get or update the routing control state to
- * 				redirect traffic. </p>
+ * 				You access one of the endpoints for the cluster to get or update the routing control state to
+ * 				redirect traffic for your application. </p>
  * 			      <p>
  *             <i>You must specify Regional endpoints when you work with API cluster operations
- * 				to get or update routing control states in Application Recovery Controller.</i>
+ * 				to get or update routing control states in Route 53 ARC.</i>
  *          </p>
  * 			      <p>To see a code example for getting a routing control state, including accessing Regional cluster endpoints
  * 				in sequence, see <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/service_code_examples_actions.html">API examples</a>
@@ -33,7 +33,8 @@ export interface GetRoutingControlStateCommandOutput extends GetRoutingControlSt
  *             </li>
  *             <li>
  *                <p>
- *                   <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/routing-control.html">Working with routing controls overall</a>
+ *                   <a href="https://docs.aws.amazon.com/r53recovery/latest/dg/routing-control.html">Working with
+ * 					routing controls in Route 53 ARC</a>
  *                </p>
  *             </li>
  *          </ul>