Route53RecoveryReadinessClient.h

 
#pragma once
#include <aws/route53-recovery-readiness/Route53RecoveryReadiness_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/route53-recovery-readiness/Route53RecoveryReadinessServiceClientModel.h>
 
namespace Aws
{
namespace Route53RecoveryReadiness
{
  class AWS_ROUTE53RECOVERYREADINESS_API Route53RecoveryReadinessClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<Route53RecoveryReadinessClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef Route53RecoveryReadinessClientConfiguration ClientConfigurationType;
      typedef Route53RecoveryReadinessEndpointProvider EndpointProviderType;
 
        Route53RecoveryReadinessClient(const Aws::Route53RecoveryReadiness::Route53RecoveryReadinessClientConfiguration& clientConfiguration = Aws::Route53RecoveryReadiness::Route53RecoveryReadinessClientConfiguration(),
                                       std::shared_ptr<Route53RecoveryReadinessEndpointProviderBase> endpointProvider = nullptr);
 
        Route53RecoveryReadinessClient(const Aws::Auth::AWSCredentials& credentials,
                                       std::shared_ptr<Route53RecoveryReadinessEndpointProviderBase> endpointProvider = nullptr,
                                       const Aws::Route53RecoveryReadiness::Route53RecoveryReadinessClientConfiguration& clientConfiguration = Aws::Route53RecoveryReadiness::Route53RecoveryReadinessClientConfiguration());
 
        Route53RecoveryReadinessClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                       std::shared_ptr<Route53RecoveryReadinessEndpointProviderBase> endpointProvider = nullptr,
                                       const Aws::Route53RecoveryReadiness::Route53RecoveryReadinessClientConfiguration& clientConfiguration = Aws::Route53RecoveryReadiness::Route53RecoveryReadinessClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        Route53RecoveryReadinessClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        Route53RecoveryReadinessClient(const Aws::Auth::AWSCredentials& credentials,
                                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        Route53RecoveryReadinessClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~Route53RecoveryReadinessClient();
 
        virtual Model::CreateCellOutcome CreateCell(const Model::CreateCellRequest& request) const;
 
        template<typename CreateCellRequestT = Model::CreateCellRequest>
        Model::CreateCellOutcomeCallable CreateCellCallable(const CreateCellRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::CreateCell, request);
        }
 
        template<typename CreateCellRequestT = Model::CreateCellRequest>
        void CreateCellAsync(const CreateCellRequestT& request, const CreateCellResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::CreateCell, request, handler, context);
        }
 
        virtual Model::CreateCrossAccountAuthorizationOutcome CreateCrossAccountAuthorization(const Model::CreateCrossAccountAuthorizationRequest& request) const;
 
        template<typename CreateCrossAccountAuthorizationRequestT = Model::CreateCrossAccountAuthorizationRequest>
        Model::CreateCrossAccountAuthorizationOutcomeCallable CreateCrossAccountAuthorizationCallable(const CreateCrossAccountAuthorizationRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::CreateCrossAccountAuthorization, request);
        }
 
        template<typename CreateCrossAccountAuthorizationRequestT = Model::CreateCrossAccountAuthorizationRequest>
        void CreateCrossAccountAuthorizationAsync(const CreateCrossAccountAuthorizationRequestT& request, const CreateCrossAccountAuthorizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::CreateCrossAccountAuthorization, request, handler, context);
        }
 
        virtual Model::CreateReadinessCheckOutcome CreateReadinessCheck(const Model::CreateReadinessCheckRequest& request) const;
 
        template<typename CreateReadinessCheckRequestT = Model::CreateReadinessCheckRequest>
        Model::CreateReadinessCheckOutcomeCallable CreateReadinessCheckCallable(const CreateReadinessCheckRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::CreateReadinessCheck, request);
        }
 
        template<typename CreateReadinessCheckRequestT = Model::CreateReadinessCheckRequest>
        void CreateReadinessCheckAsync(const CreateReadinessCheckRequestT& request, const CreateReadinessCheckResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::CreateReadinessCheck, request, handler, context);
        }
 
        virtual Model::CreateRecoveryGroupOutcome CreateRecoveryGroup(const Model::CreateRecoveryGroupRequest& request) const;
 
        template<typename CreateRecoveryGroupRequestT = Model::CreateRecoveryGroupRequest>
        Model::CreateRecoveryGroupOutcomeCallable CreateRecoveryGroupCallable(const CreateRecoveryGroupRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::CreateRecoveryGroup, request);
        }
 
        template<typename CreateRecoveryGroupRequestT = Model::CreateRecoveryGroupRequest>
        void CreateRecoveryGroupAsync(const CreateRecoveryGroupRequestT& request, const CreateRecoveryGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::CreateRecoveryGroup, request, handler, context);
        }
 
        virtual Model::CreateResourceSetOutcome CreateResourceSet(const Model::CreateResourceSetRequest& request) const;
 
        template<typename CreateResourceSetRequestT = Model::CreateResourceSetRequest>
        Model::CreateResourceSetOutcomeCallable CreateResourceSetCallable(const CreateResourceSetRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::CreateResourceSet, request);
        }
 
        template<typename CreateResourceSetRequestT = Model::CreateResourceSetRequest>
        void CreateResourceSetAsync(const CreateResourceSetRequestT& request, const CreateResourceSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::CreateResourceSet, request, handler, context);
        }
 
        virtual Model::DeleteCellOutcome DeleteCell(const Model::DeleteCellRequest& request) const;
 
        template<typename DeleteCellRequestT = Model::DeleteCellRequest>
        Model::DeleteCellOutcomeCallable DeleteCellCallable(const DeleteCellRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::DeleteCell, request);
        }
 
        template<typename DeleteCellRequestT = Model::DeleteCellRequest>
        void DeleteCellAsync(const DeleteCellRequestT& request, const DeleteCellResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::DeleteCell, request, handler, context);
        }
 
        virtual Model::DeleteCrossAccountAuthorizationOutcome DeleteCrossAccountAuthorization(const Model::DeleteCrossAccountAuthorizationRequest& request) const;
 
        template<typename DeleteCrossAccountAuthorizationRequestT = Model::DeleteCrossAccountAuthorizationRequest>
        Model::DeleteCrossAccountAuthorizationOutcomeCallable DeleteCrossAccountAuthorizationCallable(const DeleteCrossAccountAuthorizationRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::DeleteCrossAccountAuthorization, request);
        }
 
        template<typename DeleteCrossAccountAuthorizationRequestT = Model::DeleteCrossAccountAuthorizationRequest>
        void DeleteCrossAccountAuthorizationAsync(const DeleteCrossAccountAuthorizationRequestT& request, const DeleteCrossAccountAuthorizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::DeleteCrossAccountAuthorization, request, handler, context);
        }
 
        virtual Model::DeleteReadinessCheckOutcome DeleteReadinessCheck(const Model::DeleteReadinessCheckRequest& request) const;
 
        template<typename DeleteReadinessCheckRequestT = Model::DeleteReadinessCheckRequest>
        Model::DeleteReadinessCheckOutcomeCallable DeleteReadinessCheckCallable(const DeleteReadinessCheckRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::DeleteReadinessCheck, request);
        }
 
        template<typename DeleteReadinessCheckRequestT = Model::DeleteReadinessCheckRequest>
        void DeleteReadinessCheckAsync(const DeleteReadinessCheckRequestT& request, const DeleteReadinessCheckResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::DeleteReadinessCheck, request, handler, context);
        }
 
        virtual Model::DeleteRecoveryGroupOutcome DeleteRecoveryGroup(const Model::DeleteRecoveryGroupRequest& request) const;
 
        template<typename DeleteRecoveryGroupRequestT = Model::DeleteRecoveryGroupRequest>
        Model::DeleteRecoveryGroupOutcomeCallable DeleteRecoveryGroupCallable(const DeleteRecoveryGroupRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::DeleteRecoveryGroup, request);
        }
 
        template<typename DeleteRecoveryGroupRequestT = Model::DeleteRecoveryGroupRequest>
        void DeleteRecoveryGroupAsync(const DeleteRecoveryGroupRequestT& request, const DeleteRecoveryGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::DeleteRecoveryGroup, request, handler, context);
        }
 
        virtual Model::DeleteResourceSetOutcome DeleteResourceSet(const Model::DeleteResourceSetRequest& request) const;
 
        template<typename DeleteResourceSetRequestT = Model::DeleteResourceSetRequest>
        Model::DeleteResourceSetOutcomeCallable DeleteResourceSetCallable(const DeleteResourceSetRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::DeleteResourceSet, request);
        }
 
        template<typename DeleteResourceSetRequestT = Model::DeleteResourceSetRequest>
        void DeleteResourceSetAsync(const DeleteResourceSetRequestT& request, const DeleteResourceSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::DeleteResourceSet, request, handler, context);
        }
 
        virtual Model::GetArchitectureRecommendationsOutcome GetArchitectureRecommendations(const Model::GetArchitectureRecommendationsRequest& request) const;
 
        template<typename GetArchitectureRecommendationsRequestT = Model::GetArchitectureRecommendationsRequest>
        Model::GetArchitectureRecommendationsOutcomeCallable GetArchitectureRecommendationsCallable(const GetArchitectureRecommendationsRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::GetArchitectureRecommendations, request);
        }
 
        template<typename GetArchitectureRecommendationsRequestT = Model::GetArchitectureRecommendationsRequest>
        void GetArchitectureRecommendationsAsync(const GetArchitectureRecommendationsRequestT& request, const GetArchitectureRecommendationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::GetArchitectureRecommendations, request, handler, context);
        }
 
        virtual Model::GetCellOutcome GetCell(const Model::GetCellRequest& request) const;
 
        template<typename GetCellRequestT = Model::GetCellRequest>
        Model::GetCellOutcomeCallable GetCellCallable(const GetCellRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::GetCell, request);
        }
 
        template<typename GetCellRequestT = Model::GetCellRequest>
        void GetCellAsync(const GetCellRequestT& request, const GetCellResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::GetCell, request, handler, context);
        }
 
        virtual Model::GetCellReadinessSummaryOutcome GetCellReadinessSummary(const Model::GetCellReadinessSummaryRequest& request) const;
 
        template<typename GetCellReadinessSummaryRequestT = Model::GetCellReadinessSummaryRequest>
        Model::GetCellReadinessSummaryOutcomeCallable GetCellReadinessSummaryCallable(const GetCellReadinessSummaryRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::GetCellReadinessSummary, request);
        }
 
        template<typename GetCellReadinessSummaryRequestT = Model::GetCellReadinessSummaryRequest>
        void GetCellReadinessSummaryAsync(const GetCellReadinessSummaryRequestT& request, const GetCellReadinessSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::GetCellReadinessSummary, request, handler, context);
        }
 
        virtual Model::GetReadinessCheckOutcome GetReadinessCheck(const Model::GetReadinessCheckRequest& request) const;
 
        template<typename GetReadinessCheckRequestT = Model::GetReadinessCheckRequest>
        Model::GetReadinessCheckOutcomeCallable GetReadinessCheckCallable(const GetReadinessCheckRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::GetReadinessCheck, request);
        }
 
        template<typename GetReadinessCheckRequestT = Model::GetReadinessCheckRequest>
        void GetReadinessCheckAsync(const GetReadinessCheckRequestT& request, const GetReadinessCheckResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::GetReadinessCheck, request, handler, context);
        }
 
        virtual Model::GetReadinessCheckResourceStatusOutcome GetReadinessCheckResourceStatus(const Model::GetReadinessCheckResourceStatusRequest& request) const;
 
        template<typename GetReadinessCheckResourceStatusRequestT = Model::GetReadinessCheckResourceStatusRequest>
        Model::GetReadinessCheckResourceStatusOutcomeCallable GetReadinessCheckResourceStatusCallable(const GetReadinessCheckResourceStatusRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::GetReadinessCheckResourceStatus, request);
        }
 
        template<typename GetReadinessCheckResourceStatusRequestT = Model::GetReadinessCheckResourceStatusRequest>
        void GetReadinessCheckResourceStatusAsync(const GetReadinessCheckResourceStatusRequestT& request, const GetReadinessCheckResourceStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::GetReadinessCheckResourceStatus, request, handler, context);
        }
 
        virtual Model::GetReadinessCheckStatusOutcome GetReadinessCheckStatus(const Model::GetReadinessCheckStatusRequest& request) const;
 
        template<typename GetReadinessCheckStatusRequestT = Model::GetReadinessCheckStatusRequest>
        Model::GetReadinessCheckStatusOutcomeCallable GetReadinessCheckStatusCallable(const GetReadinessCheckStatusRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::GetReadinessCheckStatus, request);
        }
 
        template<typename GetReadinessCheckStatusRequestT = Model::GetReadinessCheckStatusRequest>
        void GetReadinessCheckStatusAsync(const GetReadinessCheckStatusRequestT& request, const GetReadinessCheckStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::GetReadinessCheckStatus, request, handler, context);
        }
 
        virtual Model::GetRecoveryGroupOutcome GetRecoveryGroup(const Model::GetRecoveryGroupRequest& request) const;
 
        template<typename GetRecoveryGroupRequestT = Model::GetRecoveryGroupRequest>
        Model::GetRecoveryGroupOutcomeCallable GetRecoveryGroupCallable(const GetRecoveryGroupRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::GetRecoveryGroup, request);
        }
 
        template<typename GetRecoveryGroupRequestT = Model::GetRecoveryGroupRequest>
        void GetRecoveryGroupAsync(const GetRecoveryGroupRequestT& request, const GetRecoveryGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::GetRecoveryGroup, request, handler, context);
        }
 
        virtual Model::GetRecoveryGroupReadinessSummaryOutcome GetRecoveryGroupReadinessSummary(const Model::GetRecoveryGroupReadinessSummaryRequest& request) const;
 
        template<typename GetRecoveryGroupReadinessSummaryRequestT = Model::GetRecoveryGroupReadinessSummaryRequest>
        Model::GetRecoveryGroupReadinessSummaryOutcomeCallable GetRecoveryGroupReadinessSummaryCallable(const GetRecoveryGroupReadinessSummaryRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::GetRecoveryGroupReadinessSummary, request);
        }
 
        template<typename GetRecoveryGroupReadinessSummaryRequestT = Model::GetRecoveryGroupReadinessSummaryRequest>
        void GetRecoveryGroupReadinessSummaryAsync(const GetRecoveryGroupReadinessSummaryRequestT& request, const GetRecoveryGroupReadinessSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::GetRecoveryGroupReadinessSummary, request, handler, context);
        }
 
        virtual Model::GetResourceSetOutcome GetResourceSet(const Model::GetResourceSetRequest& request) const;
 
        template<typename GetResourceSetRequestT = Model::GetResourceSetRequest>
        Model::GetResourceSetOutcomeCallable GetResourceSetCallable(const GetResourceSetRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::GetResourceSet, request);
        }
 
        template<typename GetResourceSetRequestT = Model::GetResourceSetRequest>
        void GetResourceSetAsync(const GetResourceSetRequestT& request, const GetResourceSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::GetResourceSet, request, handler, context);
        }
 
        virtual Model::ListCellsOutcome ListCells(const Model::ListCellsRequest& request = {}) const;
 
        template<typename ListCellsRequestT = Model::ListCellsRequest>
        Model::ListCellsOutcomeCallable ListCellsCallable(const ListCellsRequestT& request = {}) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::ListCells, request);
        }
 
        template<typename ListCellsRequestT = Model::ListCellsRequest>
        void ListCellsAsync(const ListCellsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCellsRequestT& request = {}) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::ListCells, request, handler, context);
        }
 
        virtual Model::ListCrossAccountAuthorizationsOutcome ListCrossAccountAuthorizations(const Model::ListCrossAccountAuthorizationsRequest& request = {}) const;
 
        template<typename ListCrossAccountAuthorizationsRequestT = Model::ListCrossAccountAuthorizationsRequest>
        Model::ListCrossAccountAuthorizationsOutcomeCallable ListCrossAccountAuthorizationsCallable(const ListCrossAccountAuthorizationsRequestT& request = {}) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::ListCrossAccountAuthorizations, request);
        }
 
        template<typename ListCrossAccountAuthorizationsRequestT = Model::ListCrossAccountAuthorizationsRequest>
        void ListCrossAccountAuthorizationsAsync(const ListCrossAccountAuthorizationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCrossAccountAuthorizationsRequestT& request = {}) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::ListCrossAccountAuthorizations, request, handler, context);
        }
 
        virtual Model::ListReadinessChecksOutcome ListReadinessChecks(const Model::ListReadinessChecksRequest& request = {}) const;
 
        template<typename ListReadinessChecksRequestT = Model::ListReadinessChecksRequest>
        Model::ListReadinessChecksOutcomeCallable ListReadinessChecksCallable(const ListReadinessChecksRequestT& request = {}) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::ListReadinessChecks, request);
        }
 
        template<typename ListReadinessChecksRequestT = Model::ListReadinessChecksRequest>
        void ListReadinessChecksAsync(const ListReadinessChecksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListReadinessChecksRequestT& request = {}) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::ListReadinessChecks, request, handler, context);
        }
 
        virtual Model::ListRecoveryGroupsOutcome ListRecoveryGroups(const Model::ListRecoveryGroupsRequest& request = {}) const;
 
        template<typename ListRecoveryGroupsRequestT = Model::ListRecoveryGroupsRequest>
        Model::ListRecoveryGroupsOutcomeCallable ListRecoveryGroupsCallable(const ListRecoveryGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::ListRecoveryGroups, request);
        }
 
        template<typename ListRecoveryGroupsRequestT = Model::ListRecoveryGroupsRequest>
        void ListRecoveryGroupsAsync(const ListRecoveryGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRecoveryGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::ListRecoveryGroups, request, handler, context);
        }
 
        virtual Model::ListResourceSetsOutcome ListResourceSets(const Model::ListResourceSetsRequest& request = {}) const;
 
        template<typename ListResourceSetsRequestT = Model::ListResourceSetsRequest>
        Model::ListResourceSetsOutcomeCallable ListResourceSetsCallable(const ListResourceSetsRequestT& request = {}) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::ListResourceSets, request);
        }
 
        template<typename ListResourceSetsRequestT = Model::ListResourceSetsRequest>
        void ListResourceSetsAsync(const ListResourceSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListResourceSetsRequestT& request = {}) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::ListResourceSets, request, handler, context);
        }
 
        virtual Model::ListRulesOutcome ListRules(const Model::ListRulesRequest& request = {}) const;
 
        template<typename ListRulesRequestT = Model::ListRulesRequest>
        Model::ListRulesOutcomeCallable ListRulesCallable(const ListRulesRequestT& request = {}) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::ListRules, request);
        }
 
        template<typename ListRulesRequestT = Model::ListRulesRequest>
        void ListRulesAsync(const ListRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRulesRequestT& request = {}) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::ListRules, request, handler, context);
        }
 
        virtual Model::ListTagsForResourcesOutcome ListTagsForResources(const Model::ListTagsForResourcesRequest& request) const;
 
        template<typename ListTagsForResourcesRequestT = Model::ListTagsForResourcesRequest>
        Model::ListTagsForResourcesOutcomeCallable ListTagsForResourcesCallable(const ListTagsForResourcesRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::ListTagsForResources, request);
        }
 
        template<typename ListTagsForResourcesRequestT = Model::ListTagsForResourcesRequest>
        void ListTagsForResourcesAsync(const ListTagsForResourcesRequestT& request, const ListTagsForResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::ListTagsForResources, request, handler, context);
        }
 
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::TagResource, request);
        }
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::TagResource, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::UntagResource, request);
        }
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateCellOutcome UpdateCell(const Model::UpdateCellRequest& request) const;
 
        template<typename UpdateCellRequestT = Model::UpdateCellRequest>
        Model::UpdateCellOutcomeCallable UpdateCellCallable(const UpdateCellRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::UpdateCell, request);
        }
 
        template<typename UpdateCellRequestT = Model::UpdateCellRequest>
        void UpdateCellAsync(const UpdateCellRequestT& request, const UpdateCellResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::UpdateCell, request, handler, context);
        }
 
        virtual Model::UpdateReadinessCheckOutcome UpdateReadinessCheck(const Model::UpdateReadinessCheckRequest& request) const;
 
        template<typename UpdateReadinessCheckRequestT = Model::UpdateReadinessCheckRequest>
        Model::UpdateReadinessCheckOutcomeCallable UpdateReadinessCheckCallable(const UpdateReadinessCheckRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::UpdateReadinessCheck, request);
        }
 
        template<typename UpdateReadinessCheckRequestT = Model::UpdateReadinessCheckRequest>
        void UpdateReadinessCheckAsync(const UpdateReadinessCheckRequestT& request, const UpdateReadinessCheckResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::UpdateReadinessCheck, request, handler, context);
        }
 
        virtual Model::UpdateRecoveryGroupOutcome UpdateRecoveryGroup(const Model::UpdateRecoveryGroupRequest& request) const;
 
        template<typename UpdateRecoveryGroupRequestT = Model::UpdateRecoveryGroupRequest>
        Model::UpdateRecoveryGroupOutcomeCallable UpdateRecoveryGroupCallable(const UpdateRecoveryGroupRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::UpdateRecoveryGroup, request);
        }
 
        template<typename UpdateRecoveryGroupRequestT = Model::UpdateRecoveryGroupRequest>
        void UpdateRecoveryGroupAsync(const UpdateRecoveryGroupRequestT& request, const UpdateRecoveryGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::UpdateRecoveryGroup, request, handler, context);
        }
 
        virtual Model::UpdateResourceSetOutcome UpdateResourceSet(const Model::UpdateResourceSetRequest& request) const;
 
        template<typename UpdateResourceSetRequestT = Model::UpdateResourceSetRequest>
        Model::UpdateResourceSetOutcomeCallable UpdateResourceSetCallable(const UpdateResourceSetRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryReadinessClient::UpdateResourceSet, request);
        }
 
        template<typename UpdateResourceSetRequestT = Model::UpdateResourceSetRequest>
        void UpdateResourceSetAsync(const UpdateResourceSetRequestT& request, const UpdateResourceSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryReadinessClient::UpdateResourceSet, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<Route53RecoveryReadinessEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<Route53RecoveryReadinessClient>;
      void init(const Route53RecoveryReadinessClientConfiguration& clientConfiguration);
 
      Route53RecoveryReadinessClientConfiguration m_clientConfiguration;
      std::shared_ptr<Route53RecoveryReadinessEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Route53RecoveryReadiness
} // namespace Aws