Route53RecoveryReadinessClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/route53-recovery-readiness/Route53RecoveryReadinessPaginationBase.h>
#include <aws/route53-recovery-readiness/Route53RecoveryReadinessServiceClientModel.h>
#include <aws/route53-recovery-readiness/Route53RecoveryReadinessWaiter.h>
#include <aws/route53-recovery-readiness/Route53RecoveryReadiness_EXPORTS.h>
 
namespace Aws {
namespace Route53RecoveryReadiness {
class AWS_ROUTE53RECOVERYREADINESS_API Route53RecoveryReadinessClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<Route53RecoveryReadinessClient>,
      public Route53RecoveryReadinessPaginationBase<Route53RecoveryReadinessClient>,
      public Route53RecoveryReadinessWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<Route53RecoveryReadinessEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<Route53RecoveryReadinessClient>;
  void init(const Route53RecoveryReadinessClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, Route53RecoveryReadinessError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  Route53RecoveryReadinessClientConfiguration m_clientConfiguration;
  std::shared_ptr<Route53RecoveryReadinessEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Route53RecoveryReadiness
}  // namespace Aws