@aws-sdk/client-route53-recovery-cluster 3.58.0 → 3.72.0

package/CHANGELOG.md

@@ -3,6 +3,33 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.72.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.71.0...v3.72.0) (2022-04-15)
+
+**Note:** Version bump only for package @aws-sdk/client-route53-recovery-cluster
+
+
+
+
+
+# [3.67.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.66.0...v3.67.0) (2022-04-08)
+
+**Note:** Version bump only for package @aws-sdk/client-route53-recovery-cluster
+
+
+
+
+
+# [3.61.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.60.0...v3.61.0) (2022-03-31)
+
+
+### Features
+
+* **client-route53-recovery-cluster:** This release adds a new API "ListRoutingControls" to list routing control states using the highly reliable Route 53 ARC data plane endpoints. ([ac15087](https://github.com/aws/aws-sdk-js-v3/commit/ac1508711cd99e732b3e5cf8fa120fe46ea2ad8b))
+
+
+
+
+
 # [3.58.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.57.0...v3.58.0) (2022-03-28)
 
 **Note:** Version bump only for package @aws-sdk/client-route53-recovery-cluster

package/README.md

@@ -8,42 +8,43 @@
 AWS SDK for JavaScript Route53RecoveryCluster Client for Node.js, Browser and React Native.
 
 <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>
 
@@ -156,7 +157,7 @@ but they are supported by the send operation.
 ```js
 // callbacks.
 client.send(command, (err, data) => {
-  // proccess err and data.
+  // process err and data.
 });
 ```
 
@@ -190,7 +191,7 @@ client
 
 // callbacks.
 client.getRoutingControlState(params, (err, data) => {
-  // proccess err and data.
+  // process err and data.
 });
 ```
 

package/dist-cjs/Route53RecoveryCluster.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Route53RecoveryCluster = void 0;
 const GetRoutingControlStateCommand_1 = require("./commands/GetRoutingControlStateCommand");
+const ListRoutingControlsCommand_1 = require("./commands/ListRoutingControlsCommand");
 const UpdateRoutingControlStateCommand_1 = require("./commands/UpdateRoutingControlStateCommand");
 const UpdateRoutingControlStatesCommand_1 = require("./commands/UpdateRoutingControlStatesCommand");
 const Route53RecoveryClusterClient_1 = require("./Route53RecoveryClusterClient");
@@ -20,6 +21,20 @@ class Route53RecoveryCluster extends Route53RecoveryClusterClient_1.Route53Recov
             return this.send(command, optionsOrCb);
         }
     }
+    listRoutingControls(args, optionsOrCb, cb) {
+        const command = new ListRoutingControlsCommand_1.ListRoutingControlsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     updateRoutingControlState(args, optionsOrCb, cb) {
         const command = new UpdateRoutingControlStateCommand_1.UpdateRoutingControlStateCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-cjs/commands/ListRoutingControlsCommand.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListRoutingControlsCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_0_1 = require("../protocols/Aws_json1_0");
+class ListRoutingControlsCommand extends smithy_client_1.Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "Route53RecoveryClusterClient";
+        const commandName = "ListRoutingControlsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.ListRoutingControlsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.ListRoutingControlsResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_json1_0_1.serializeAws_json1_0ListRoutingControlsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_json1_0_1.deserializeAws_json1_0ListRoutingControlsCommand)(output, context);
+    }
+}
+exports.ListRoutingControlsCommand = ListRoutingControlsCommand;

package/dist-cjs/commands/index.js

@@ -2,5 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./GetRoutingControlStateCommand"), exports);
+tslib_1.__exportStar(require("./ListRoutingControlsCommand"), exports);
 tslib_1.__exportStar(require("./UpdateRoutingControlStateCommand"), exports);
 tslib_1.__exportStar(require("./UpdateRoutingControlStatesCommand"), exports);

package/dist-cjs/index.js

@@ -6,5 +6,6 @@ tslib_1.__exportStar(require("./Route53RecoveryCluster"), exports);
 tslib_1.__exportStar(require("./Route53RecoveryClusterClient"), exports);
 tslib_1.__exportStar(require("./commands"), exports);
 tslib_1.__exportStar(require("./models"), exports);
+tslib_1.__exportStar(require("./pagination"), exports);
 var Route53RecoveryClusterServiceException_1 = require("./models/Route53RecoveryClusterServiceException");
 Object.defineProperty(exports, "Route53RecoveryClusterServiceException", { enumerable: true, get: function () { return Route53RecoveryClusterServiceException_1.Route53RecoveryClusterServiceException; } });

package/dist-cjs/models/models_0.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UpdateRoutingControlStatesResponse = exports.UpdateRoutingControlStatesRequest = exports.UpdateRoutingControlStateEntry = exports.UpdateRoutingControlStateResponse = exports.UpdateRoutingControlStateRequest = exports.ValidationException = exports.ValidationExceptionReason = exports.ValidationExceptionField = exports.ThrottlingException = exports.ResourceNotFoundException = exports.InternalServerException = exports.GetRoutingControlStateResponse = exports.RoutingControlState = exports.GetRoutingControlStateRequest = exports.EndpointTemporarilyUnavailableException = exports.ConflictException = exports.AccessDeniedException = void 0;
+exports.UpdateRoutingControlStatesResponse = exports.UpdateRoutingControlStatesRequest = exports.UpdateRoutingControlStateEntry = exports.UpdateRoutingControlStateResponse = exports.UpdateRoutingControlStateRequest = exports.ServiceLimitExceededException = exports.ListRoutingControlsResponse = exports.RoutingControl = exports.ListRoutingControlsRequest = exports.ValidationException = exports.ValidationExceptionReason = exports.ValidationExceptionField = exports.ThrottlingException = exports.ResourceNotFoundException = exports.InternalServerException = exports.GetRoutingControlStateResponse = exports.RoutingControlState = exports.GetRoutingControlStateRequest = exports.EndpointTemporarilyUnavailableException = exports.ConflictException = exports.AccessDeniedException = void 0;
 const Route53RecoveryClusterServiceException_1 = require("./Route53RecoveryClusterServiceException");
 class AccessDeniedException extends Route53RecoveryClusterServiceException_1.Route53RecoveryClusterServiceException {
     constructor(opts) {
@@ -131,6 +131,41 @@ class ValidationException extends Route53RecoveryClusterServiceException_1.Route
     }
 }
 exports.ValidationException = ValidationException;
+var ListRoutingControlsRequest;
+(function (ListRoutingControlsRequest) {
+    ListRoutingControlsRequest.filterSensitiveLog = (obj) => ({
+        ...obj,
+    });
+})(ListRoutingControlsRequest = exports.ListRoutingControlsRequest || (exports.ListRoutingControlsRequest = {}));
+var RoutingControl;
+(function (RoutingControl) {
+    RoutingControl.filterSensitiveLog = (obj) => ({
+        ...obj,
+    });
+})(RoutingControl = exports.RoutingControl || (exports.RoutingControl = {}));
+var ListRoutingControlsResponse;
+(function (ListRoutingControlsResponse) {
+    ListRoutingControlsResponse.filterSensitiveLog = (obj) => ({
+        ...obj,
+    });
+})(ListRoutingControlsResponse = exports.ListRoutingControlsResponse || (exports.ListRoutingControlsResponse = {}));
+class ServiceLimitExceededException extends Route53RecoveryClusterServiceException_1.Route53RecoveryClusterServiceException {
+    constructor(opts) {
+        super({
+            name: "ServiceLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ServiceLimitExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ServiceLimitExceededException.prototype);
+        this.resourceId = opts.resourceId;
+        this.resourceType = opts.resourceType;
+        this.limitCode = opts.limitCode;
+        this.serviceCode = opts.serviceCode;
+    }
+}
+exports.ServiceLimitExceededException = ServiceLimitExceededException;
 var UpdateRoutingControlStateRequest;
 (function (UpdateRoutingControlStateRequest) {
     UpdateRoutingControlStateRequest.filterSensitiveLog = (obj) => ({

package/dist-cjs/pagination/Interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/pagination/ListRoutingControlsPaginator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateListRoutingControls = void 0;
+const ListRoutingControlsCommand_1 = require("../commands/ListRoutingControlsCommand");
+const Route53RecoveryCluster_1 = require("../Route53RecoveryCluster");
+const Route53RecoveryClusterClient_1 = require("../Route53RecoveryClusterClient");
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListRoutingControlsCommand_1.ListRoutingControlsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listRoutingControls(input, ...args);
+};
+async function* paginateListRoutingControls(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof Route53RecoveryCluster_1.Route53RecoveryCluster) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof Route53RecoveryClusterClient_1.Route53RecoveryClusterClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Route53RecoveryCluster | Route53RecoveryClusterClient");
+        }
+        yield page;
+        token = page.NextToken;
+        hasNext = !!token;
+    }
+    return undefined;
+}
+exports.paginateListRoutingControls = paginateListRoutingControls;

package/dist-cjs/pagination/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./Interfaces"), exports);
+tslib_1.__exportStar(require("./ListRoutingControlsPaginator"), exports);

package/dist-cjs/protocols/Aws_json1_0.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeAws_json1_0UpdateRoutingControlStatesCommand = exports.deserializeAws_json1_0UpdateRoutingControlStateCommand = exports.deserializeAws_json1_0GetRoutingControlStateCommand = exports.serializeAws_json1_0UpdateRoutingControlStatesCommand = exports.serializeAws_json1_0UpdateRoutingControlStateCommand = exports.serializeAws_json1_0GetRoutingControlStateCommand = void 0;
+exports.deserializeAws_json1_0UpdateRoutingControlStatesCommand = exports.deserializeAws_json1_0UpdateRoutingControlStateCommand = exports.deserializeAws_json1_0ListRoutingControlsCommand = exports.deserializeAws_json1_0GetRoutingControlStateCommand = exports.serializeAws_json1_0UpdateRoutingControlStatesCommand = exports.serializeAws_json1_0UpdateRoutingControlStateCommand = exports.serializeAws_json1_0ListRoutingControlsCommand = exports.serializeAws_json1_0GetRoutingControlStateCommand = void 0;
 const protocol_http_1 = require("@aws-sdk/protocol-http");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
@@ -15,6 +15,16 @@ const serializeAws_json1_0GetRoutingControlStateCommand = async (input, context)
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.serializeAws_json1_0GetRoutingControlStateCommand = serializeAws_json1_0GetRoutingControlStateCommand;
+const serializeAws_json1_0ListRoutingControlsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.0",
+        "x-amz-target": "ToggleCustomerAPI.ListRoutingControls",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_0ListRoutingControlsRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+exports.serializeAws_json1_0ListRoutingControlsCommand = serializeAws_json1_0ListRoutingControlsCommand;
 const serializeAws_json1_0UpdateRoutingControlStateCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.0",
@@ -86,6 +96,57 @@ const deserializeAws_json1_0GetRoutingControlStateCommandError = async (output,
             throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
+const deserializeAws_json1_0ListRoutingControlsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_0ListRoutingControlsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_0ListRoutingControlsResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+exports.deserializeAws_json1_0ListRoutingControlsCommand = deserializeAws_json1_0ListRoutingControlsCommand;
+const deserializeAws_json1_0ListRoutingControlsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.route53recoverycluster#AccessDeniedException":
+            throw await deserializeAws_json1_0AccessDeniedExceptionResponse(parsedOutput, context);
+        case "EndpointTemporarilyUnavailableException":
+        case "com.amazonaws.route53recoverycluster#EndpointTemporarilyUnavailableException":
+            throw await deserializeAws_json1_0EndpointTemporarilyUnavailableExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.route53recoverycluster#InternalServerException":
+            throw await deserializeAws_json1_0InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.route53recoverycluster#ResourceNotFoundException":
+            throw await deserializeAws_json1_0ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.route53recoverycluster#ThrottlingException":
+            throw await deserializeAws_json1_0ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.route53recoverycluster#ValidationException":
+            throw await deserializeAws_json1_0ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            response = new Route53RecoveryClusterServiceException_1.Route53RecoveryClusterServiceException({
+                name: parsedBody.code || parsedBody.Code || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            });
+            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
+    }
+};
 const deserializeAws_json1_0UpdateRoutingControlStateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_json1_0UpdateRoutingControlStateCommandError(output, context);
@@ -178,6 +239,9 @@ const deserializeAws_json1_0UpdateRoutingControlStatesCommandError = async (outp
         case "ResourceNotFoundException":
         case "com.amazonaws.route53recoverycluster#ResourceNotFoundException":
             throw await deserializeAws_json1_0ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceLimitExceededException":
+        case "com.amazonaws.route53recoverycluster#ServiceLimitExceededException":
+            throw await deserializeAws_json1_0ServiceLimitExceededExceptionResponse(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.route53recoverycluster#ThrottlingException":
             throw await deserializeAws_json1_0ThrottlingExceptionResponse(parsedOutput, context);
@@ -239,6 +303,15 @@ const deserializeAws_json1_0ResourceNotFoundExceptionResponse = async (parsedOut
     });
     return (0, smithy_client_1.decorateServiceException)(exception, body);
 };
+const deserializeAws_json1_0ServiceLimitExceededExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_0ServiceLimitExceededException(body, context);
+    const exception = new models_0_1.ServiceLimitExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, body);
+};
 const deserializeAws_json1_0ThrottlingExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_json1_0ThrottlingException(body, context);
@@ -273,6 +346,14 @@ const serializeAws_json1_0GetRoutingControlStateRequest = (input, context) => {
             input.RoutingControlArn !== null && { RoutingControlArn: input.RoutingControlArn }),
     };
 };
+const serializeAws_json1_0ListRoutingControlsRequest = (input, context) => {
+    return {
+        ...(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 }),
+    };
+};
 const serializeAws_json1_0UpdateRoutingControlStateEntries = (input, context) => {
     return input
         .filter((e) => e != null)
@@ -335,6 +416,7 @@ const deserializeAws_json1_0EndpointTemporarilyUnavailableException = (output, c
 const deserializeAws_json1_0GetRoutingControlStateResponse = (output, context) => {
     return {
         RoutingControlArn: (0, smithy_client_1.expectString)(output.RoutingControlArn),
+        RoutingControlName: (0, smithy_client_1.expectString)(output.RoutingControlName),
         RoutingControlState: (0, smithy_client_1.expectString)(output.RoutingControlState),
     };
 };
@@ -344,6 +426,14 @@ const deserializeAws_json1_0InternalServerException = (output, context) => {
         retryAfterSeconds: (0, smithy_client_1.expectInt32)(output.retryAfterSeconds),
     };
 };
+const deserializeAws_json1_0ListRoutingControlsResponse = (output, context) => {
+    return {
+        NextToken: (0, smithy_client_1.expectString)(output.NextToken),
+        RoutingControls: output.RoutingControls !== undefined && output.RoutingControls !== null
+            ? deserializeAws_json1_0RoutingControls(output.RoutingControls, context)
+            : undefined,
+    };
+};
 const deserializeAws_json1_0ResourceNotFoundException = (output, context) => {
     return {
         message: (0, smithy_client_1.expectString)(output.message),
@@ -351,6 +441,35 @@ const deserializeAws_json1_0ResourceNotFoundException = (output, context) => {
         resourceType: (0, smithy_client_1.expectString)(output.resourceType),
     };
 };
+const deserializeAws_json1_0RoutingControl = (output, context) => {
+    return {
+        ControlPanelArn: (0, smithy_client_1.expectString)(output.ControlPanelArn),
+        ControlPanelName: (0, smithy_client_1.expectString)(output.ControlPanelName),
+        RoutingControlArn: (0, smithy_client_1.expectString)(output.RoutingControlArn),
+        RoutingControlName: (0, smithy_client_1.expectString)(output.RoutingControlName),
+        RoutingControlState: (0, smithy_client_1.expectString)(output.RoutingControlState),
+    };
+};
+const deserializeAws_json1_0RoutingControls = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_0RoutingControl(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_0ServiceLimitExceededException = (output, context) => {
+    return {
+        limitCode: (0, smithy_client_1.expectString)(output.limitCode),
+        message: (0, smithy_client_1.expectString)(output.message),
+        resourceId: (0, smithy_client_1.expectString)(output.resourceId),
+        resourceType: (0, smithy_client_1.expectString)(output.resourceType),
+        serviceCode: (0, smithy_client_1.expectString)(output.serviceCode),
+    };
+};
 const deserializeAws_json1_0ThrottlingException = (output, context) => {
     return {
         message: (0, smithy_client_1.expectString)(output.message),

package/dist-es/Route53RecoveryCluster.js

@@ -1,5 +1,6 @@
 import { __extends } from "tslib";
 import { GetRoutingControlStateCommand, } from "./commands/GetRoutingControlStateCommand";
+import { ListRoutingControlsCommand, } from "./commands/ListRoutingControlsCommand";
 import { UpdateRoutingControlStateCommand, } from "./commands/UpdateRoutingControlStateCommand";
 import { UpdateRoutingControlStatesCommand, } from "./commands/UpdateRoutingControlStatesCommand";
 import { Route53RecoveryClusterClient } from "./Route53RecoveryClusterClient";
@@ -22,6 +23,20 @@ var Route53RecoveryCluster = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Route53RecoveryCluster.prototype.listRoutingControls = function (args, optionsOrCb, cb) {
+        var command = new ListRoutingControlsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Route53RecoveryCluster.prototype.updateRoutingControlState = function (args, optionsOrCb, cb) {
         var command = new UpdateRoutingControlStateCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/ListRoutingControlsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListRoutingControlsRequest, ListRoutingControlsResponse } from "../models/models_0";
+import { deserializeAws_json1_0ListRoutingControlsCommand, serializeAws_json1_0ListRoutingControlsCommand, } from "../protocols/Aws_json1_0";
+var ListRoutingControlsCommand = (function (_super) {
+    __extends(ListRoutingControlsCommand, _super);
+    function ListRoutingControlsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListRoutingControlsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "Route53RecoveryClusterClient";
+        var commandName = "ListRoutingControlsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListRoutingControlsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListRoutingControlsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListRoutingControlsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0ListRoutingControlsCommand(input, context);
+    };
+    ListRoutingControlsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListRoutingControlsCommand(output, context);
+    };
+    return ListRoutingControlsCommand;
+}($Command));
+export { ListRoutingControlsCommand };

package/dist-es/commands/index.js

@@ -1,3 +1,4 @@
 export * from "./GetRoutingControlStateCommand";
+export * from "./ListRoutingControlsCommand";
 export * from "./UpdateRoutingControlStateCommand";
 export * from "./UpdateRoutingControlStatesCommand";

package/dist-es/index.js

@@ -2,4 +2,5 @@ export * from "./Route53RecoveryCluster";
 export * from "./Route53RecoveryClusterClient";
 export * from "./commands";
 export * from "./models";
+export * from "./pagination";
 export { Route53RecoveryClusterServiceException } from "./models/Route53RecoveryClusterServiceException";

package/dist-es/models/models_0.js

@@ -116,6 +116,34 @@ var ValidationException = (function (_super) {
     return ValidationException;
 }(__BaseException));
 export { ValidationException };
+export var ListRoutingControlsRequest;
+(function (ListRoutingControlsRequest) {
+    ListRoutingControlsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListRoutingControlsRequest || (ListRoutingControlsRequest = {}));
+export var RoutingControl;
+(function (RoutingControl) {
+    RoutingControl.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RoutingControl || (RoutingControl = {}));
+export var ListRoutingControlsResponse;
+(function (ListRoutingControlsResponse) {
+    ListRoutingControlsResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListRoutingControlsResponse || (ListRoutingControlsResponse = {}));
+var ServiceLimitExceededException = (function (_super) {
+    __extends(ServiceLimitExceededException, _super);
+    function ServiceLimitExceededException(opts) {
+        var _this = _super.call(this, __assign({ name: "ServiceLimitExceededException", $fault: "client" }, opts)) || this;
+        _this.name = "ServiceLimitExceededException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ServiceLimitExceededException.prototype);
+        _this.resourceId = opts.resourceId;
+        _this.resourceType = opts.resourceType;
+        _this.limitCode = opts.limitCode;
+        _this.serviceCode = opts.serviceCode;
+        return _this;
+    }
+    return ServiceLimitExceededException;
+}(__BaseException));
+export { ServiceLimitExceededException };
 export var UpdateRoutingControlStateRequest;
 (function (UpdateRoutingControlStateRequest) {
     UpdateRoutingControlStateRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };

package/dist-es/pagination/Interfaces.js

@@ -0,0 +1 @@
+export {};