Route53RecoveryControlConfigClient.h

 
#pragma once
#include <aws/route53-recovery-control-config/Route53RecoveryControlConfig_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-control-config/Route53RecoveryControlConfigServiceClientModel.h>
 
namespace Aws
{
namespace Route53RecoveryControlConfig
{
  class AWS_ROUTE53RECOVERYCONTROLCONFIG_API Route53RecoveryControlConfigClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<Route53RecoveryControlConfigClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef Route53RecoveryControlConfigClientConfiguration ClientConfigurationType;
      typedef Route53RecoveryControlConfigEndpointProvider EndpointProviderType;
 
        Route53RecoveryControlConfigClient(const Aws::Route53RecoveryControlConfig::Route53RecoveryControlConfigClientConfiguration& clientConfiguration = Aws::Route53RecoveryControlConfig::Route53RecoveryControlConfigClientConfiguration(),
                                           std::shared_ptr<Route53RecoveryControlConfigEndpointProviderBase> endpointProvider = nullptr);
 
        Route53RecoveryControlConfigClient(const Aws::Auth::AWSCredentials& credentials,
                                           std::shared_ptr<Route53RecoveryControlConfigEndpointProviderBase> endpointProvider = nullptr,
                                           const Aws::Route53RecoveryControlConfig::Route53RecoveryControlConfigClientConfiguration& clientConfiguration = Aws::Route53RecoveryControlConfig::Route53RecoveryControlConfigClientConfiguration());
 
        Route53RecoveryControlConfigClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                           std::shared_ptr<Route53RecoveryControlConfigEndpointProviderBase> endpointProvider = nullptr,
                                           const Aws::Route53RecoveryControlConfig::Route53RecoveryControlConfigClientConfiguration& clientConfiguration = Aws::Route53RecoveryControlConfig::Route53RecoveryControlConfigClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        Route53RecoveryControlConfigClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        Route53RecoveryControlConfigClient(const Aws::Auth::AWSCredentials& credentials,
                                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        Route53RecoveryControlConfigClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~Route53RecoveryControlConfigClient();
 
        virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request) const;
 
        template<typename CreateClusterRequestT = Model::CreateClusterRequest>
        Model::CreateClusterOutcomeCallable CreateClusterCallable(const CreateClusterRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::CreateCluster, request);
        }
 
        template<typename CreateClusterRequestT = Model::CreateClusterRequest>
        void CreateClusterAsync(const CreateClusterRequestT& request, const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::CreateCluster, request, handler, context);
        }
 
        virtual Model::CreateControlPanelOutcome CreateControlPanel(const Model::CreateControlPanelRequest& request) const;
 
        template<typename CreateControlPanelRequestT = Model::CreateControlPanelRequest>
        Model::CreateControlPanelOutcomeCallable CreateControlPanelCallable(const CreateControlPanelRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::CreateControlPanel, request);
        }
 
        template<typename CreateControlPanelRequestT = Model::CreateControlPanelRequest>
        void CreateControlPanelAsync(const CreateControlPanelRequestT& request, const CreateControlPanelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::CreateControlPanel, request, handler, context);
        }
 
        virtual Model::CreateRoutingControlOutcome CreateRoutingControl(const Model::CreateRoutingControlRequest& request) const;
 
        template<typename CreateRoutingControlRequestT = Model::CreateRoutingControlRequest>
        Model::CreateRoutingControlOutcomeCallable CreateRoutingControlCallable(const CreateRoutingControlRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::CreateRoutingControl, request);
        }
 
        template<typename CreateRoutingControlRequestT = Model::CreateRoutingControlRequest>
        void CreateRoutingControlAsync(const CreateRoutingControlRequestT& request, const CreateRoutingControlResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::CreateRoutingControl, request, handler, context);
        }
 
        virtual Model::CreateSafetyRuleOutcome CreateSafetyRule(const Model::CreateSafetyRuleRequest& request = {}) const;
 
        template<typename CreateSafetyRuleRequestT = Model::CreateSafetyRuleRequest>
        Model::CreateSafetyRuleOutcomeCallable CreateSafetyRuleCallable(const CreateSafetyRuleRequestT& request = {}) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::CreateSafetyRule, request);
        }
 
        template<typename CreateSafetyRuleRequestT = Model::CreateSafetyRuleRequest>
        void CreateSafetyRuleAsync(const CreateSafetyRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateSafetyRuleRequestT& request = {}) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::CreateSafetyRule, request, handler, context);
        }
 
        virtual Model::DeleteClusterOutcome DeleteCluster(const Model::DeleteClusterRequest& request) const;
 
        template<typename DeleteClusterRequestT = Model::DeleteClusterRequest>
        Model::DeleteClusterOutcomeCallable DeleteClusterCallable(const DeleteClusterRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::DeleteCluster, request);
        }
 
        template<typename DeleteClusterRequestT = Model::DeleteClusterRequest>
        void DeleteClusterAsync(const DeleteClusterRequestT& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::DeleteCluster, request, handler, context);
        }
 
        virtual Model::DeleteControlPanelOutcome DeleteControlPanel(const Model::DeleteControlPanelRequest& request) const;
 
        template<typename DeleteControlPanelRequestT = Model::DeleteControlPanelRequest>
        Model::DeleteControlPanelOutcomeCallable DeleteControlPanelCallable(const DeleteControlPanelRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::DeleteControlPanel, request);
        }
 
        template<typename DeleteControlPanelRequestT = Model::DeleteControlPanelRequest>
        void DeleteControlPanelAsync(const DeleteControlPanelRequestT& request, const DeleteControlPanelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::DeleteControlPanel, request, handler, context);
        }
 
        virtual Model::DeleteRoutingControlOutcome DeleteRoutingControl(const Model::DeleteRoutingControlRequest& request) const;
 
        template<typename DeleteRoutingControlRequestT = Model::DeleteRoutingControlRequest>
        Model::DeleteRoutingControlOutcomeCallable DeleteRoutingControlCallable(const DeleteRoutingControlRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::DeleteRoutingControl, request);
        }
 
        template<typename DeleteRoutingControlRequestT = Model::DeleteRoutingControlRequest>
        void DeleteRoutingControlAsync(const DeleteRoutingControlRequestT& request, const DeleteRoutingControlResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::DeleteRoutingControl, request, handler, context);
        }
 
        virtual Model::DeleteSafetyRuleOutcome DeleteSafetyRule(const Model::DeleteSafetyRuleRequest& request) const;
 
        template<typename DeleteSafetyRuleRequestT = Model::DeleteSafetyRuleRequest>
        Model::DeleteSafetyRuleOutcomeCallable DeleteSafetyRuleCallable(const DeleteSafetyRuleRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::DeleteSafetyRule, request);
        }
 
        template<typename DeleteSafetyRuleRequestT = Model::DeleteSafetyRuleRequest>
        void DeleteSafetyRuleAsync(const DeleteSafetyRuleRequestT& request, const DeleteSafetyRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::DeleteSafetyRule, request, handler, context);
        }
 
        virtual Model::DescribeClusterOutcome DescribeCluster(const Model::DescribeClusterRequest& request) const;
 
        template<typename DescribeClusterRequestT = Model::DescribeClusterRequest>
        Model::DescribeClusterOutcomeCallable DescribeClusterCallable(const DescribeClusterRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::DescribeCluster, request);
        }
 
        template<typename DescribeClusterRequestT = Model::DescribeClusterRequest>
        void DescribeClusterAsync(const DescribeClusterRequestT& request, const DescribeClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::DescribeCluster, request, handler, context);
        }
 
        virtual Model::DescribeControlPanelOutcome DescribeControlPanel(const Model::DescribeControlPanelRequest& request) const;
 
        template<typename DescribeControlPanelRequestT = Model::DescribeControlPanelRequest>
        Model::DescribeControlPanelOutcomeCallable DescribeControlPanelCallable(const DescribeControlPanelRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::DescribeControlPanel, request);
        }
 
        template<typename DescribeControlPanelRequestT = Model::DescribeControlPanelRequest>
        void DescribeControlPanelAsync(const DescribeControlPanelRequestT& request, const DescribeControlPanelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::DescribeControlPanel, request, handler, context);
        }
 
        virtual Model::DescribeRoutingControlOutcome DescribeRoutingControl(const Model::DescribeRoutingControlRequest& request) const;
 
        template<typename DescribeRoutingControlRequestT = Model::DescribeRoutingControlRequest>
        Model::DescribeRoutingControlOutcomeCallable DescribeRoutingControlCallable(const DescribeRoutingControlRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::DescribeRoutingControl, request);
        }
 
        template<typename DescribeRoutingControlRequestT = Model::DescribeRoutingControlRequest>
        void DescribeRoutingControlAsync(const DescribeRoutingControlRequestT& request, const DescribeRoutingControlResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::DescribeRoutingControl, request, handler, context);
        }
 
        virtual Model::DescribeSafetyRuleOutcome DescribeSafetyRule(const Model::DescribeSafetyRuleRequest& request) const;
 
        template<typename DescribeSafetyRuleRequestT = Model::DescribeSafetyRuleRequest>
        Model::DescribeSafetyRuleOutcomeCallable DescribeSafetyRuleCallable(const DescribeSafetyRuleRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::DescribeSafetyRule, request);
        }
 
        template<typename DescribeSafetyRuleRequestT = Model::DescribeSafetyRuleRequest>
        void DescribeSafetyRuleAsync(const DescribeSafetyRuleRequestT& request, const DescribeSafetyRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::DescribeSafetyRule, request, handler, context);
        }
 
        virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request) const;
 
        template<typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
        Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::GetResourcePolicy, request);
        }
 
        template<typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
        void GetResourcePolicyAsync(const GetResourcePolicyRequestT& request, const GetResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::GetResourcePolicy, request, handler, context);
        }
 
        virtual Model::ListAssociatedRoute53HealthChecksOutcome ListAssociatedRoute53HealthChecks(const Model::ListAssociatedRoute53HealthChecksRequest& request) const;
 
        template<typename ListAssociatedRoute53HealthChecksRequestT = Model::ListAssociatedRoute53HealthChecksRequest>
        Model::ListAssociatedRoute53HealthChecksOutcomeCallable ListAssociatedRoute53HealthChecksCallable(const ListAssociatedRoute53HealthChecksRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::ListAssociatedRoute53HealthChecks, request);
        }
 
        template<typename ListAssociatedRoute53HealthChecksRequestT = Model::ListAssociatedRoute53HealthChecksRequest>
        void ListAssociatedRoute53HealthChecksAsync(const ListAssociatedRoute53HealthChecksRequestT& request, const ListAssociatedRoute53HealthChecksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::ListAssociatedRoute53HealthChecks, request, handler, context);
        }
 
        virtual Model::ListClustersOutcome ListClusters(const Model::ListClustersRequest& request = {}) const;
 
        template<typename ListClustersRequestT = Model::ListClustersRequest>
        Model::ListClustersOutcomeCallable ListClustersCallable(const ListClustersRequestT& request = {}) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::ListClusters, request);
        }
 
        template<typename ListClustersRequestT = Model::ListClustersRequest>
        void ListClustersAsync(const ListClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListClustersRequestT& request = {}) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::ListClusters, request, handler, context);
        }
 
        virtual Model::ListControlPanelsOutcome ListControlPanels(const Model::ListControlPanelsRequest& request = {}) const;
 
        template<typename ListControlPanelsRequestT = Model::ListControlPanelsRequest>
        Model::ListControlPanelsOutcomeCallable ListControlPanelsCallable(const ListControlPanelsRequestT& request = {}) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::ListControlPanels, request);
        }
 
        template<typename ListControlPanelsRequestT = Model::ListControlPanelsRequest>
        void ListControlPanelsAsync(const ListControlPanelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListControlPanelsRequestT& request = {}) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::ListControlPanels, request, handler, context);
        }
 
        virtual Model::ListRoutingControlsOutcome ListRoutingControls(const Model::ListRoutingControlsRequest& request) const;
 
        template<typename ListRoutingControlsRequestT = Model::ListRoutingControlsRequest>
        Model::ListRoutingControlsOutcomeCallable ListRoutingControlsCallable(const ListRoutingControlsRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::ListRoutingControls, request);
        }
 
        template<typename ListRoutingControlsRequestT = Model::ListRoutingControlsRequest>
        void ListRoutingControlsAsync(const ListRoutingControlsRequestT& request, const ListRoutingControlsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::ListRoutingControls, request, handler, context);
        }
 
        virtual Model::ListSafetyRulesOutcome ListSafetyRules(const Model::ListSafetyRulesRequest& request) const;
 
        template<typename ListSafetyRulesRequestT = Model::ListSafetyRulesRequest>
        Model::ListSafetyRulesOutcomeCallable ListSafetyRulesCallable(const ListSafetyRulesRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::ListSafetyRules, request);
        }
 
        template<typename ListSafetyRulesRequestT = Model::ListSafetyRulesRequest>
        void ListSafetyRulesAsync(const ListSafetyRulesRequestT& request, const ListSafetyRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::ListSafetyRules, request, handler, context);
        }
 
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::ListTagsForResource, 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(&Route53RecoveryControlConfigClient::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(&Route53RecoveryControlConfigClient::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(&Route53RecoveryControlConfigClient::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(&Route53RecoveryControlConfigClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateControlPanelOutcome UpdateControlPanel(const Model::UpdateControlPanelRequest& request) const;
 
        template<typename UpdateControlPanelRequestT = Model::UpdateControlPanelRequest>
        Model::UpdateControlPanelOutcomeCallable UpdateControlPanelCallable(const UpdateControlPanelRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::UpdateControlPanel, request);
        }
 
        template<typename UpdateControlPanelRequestT = Model::UpdateControlPanelRequest>
        void UpdateControlPanelAsync(const UpdateControlPanelRequestT& request, const UpdateControlPanelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::UpdateControlPanel, request, handler, context);
        }
 
        virtual Model::UpdateRoutingControlOutcome UpdateRoutingControl(const Model::UpdateRoutingControlRequest& request) const;
 
        template<typename UpdateRoutingControlRequestT = Model::UpdateRoutingControlRequest>
        Model::UpdateRoutingControlOutcomeCallable UpdateRoutingControlCallable(const UpdateRoutingControlRequestT& request) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::UpdateRoutingControl, request);
        }
 
        template<typename UpdateRoutingControlRequestT = Model::UpdateRoutingControlRequest>
        void UpdateRoutingControlAsync(const UpdateRoutingControlRequestT& request, const UpdateRoutingControlResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::UpdateRoutingControl, request, handler, context);
        }
 
        virtual Model::UpdateSafetyRuleOutcome UpdateSafetyRule(const Model::UpdateSafetyRuleRequest& request = {}) const;
 
        template<typename UpdateSafetyRuleRequestT = Model::UpdateSafetyRuleRequest>
        Model::UpdateSafetyRuleOutcomeCallable UpdateSafetyRuleCallable(const UpdateSafetyRuleRequestT& request = {}) const
        {
            return SubmitCallable(&Route53RecoveryControlConfigClient::UpdateSafetyRule, request);
        }
 
        template<typename UpdateSafetyRuleRequestT = Model::UpdateSafetyRuleRequest>
        void UpdateSafetyRuleAsync(const UpdateSafetyRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateSafetyRuleRequestT& request = {}) const
        {
            return SubmitAsync(&Route53RecoveryControlConfigClient::UpdateSafetyRule, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<Route53RecoveryControlConfigEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<Route53RecoveryControlConfigClient>;
      void init(const Route53RecoveryControlConfigClientConfiguration& clientConfiguration);
 
      Route53RecoveryControlConfigClientConfiguration m_clientConfiguration;
      std::shared_ptr<Route53RecoveryControlConfigEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Route53RecoveryControlConfig
} // namespace Aws