ResilienceHubClient.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/resiliencehub/ResilienceHubPaginationBase.h>
#include <aws/resiliencehub/ResilienceHubServiceClientModel.h>
#include <aws/resiliencehub/ResilienceHub_EXPORTS.h>
 
namespace Aws {
namespace ResilienceHub {
class AWS_RESILIENCEHUB_API ResilienceHubClient : public Aws::Client::AWSJsonClient,
                                                  public Aws::Client::ClientWithAsyncTemplateMethods<ResilienceHubClient>,
                                                  public ResilienceHubPaginationBase<ResilienceHubClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ResilienceHubClientConfiguration ClientConfigurationType;
  typedef ResilienceHubEndpointProvider EndpointProviderType;
 
  ResilienceHubClient(const Aws::ResilienceHub::ResilienceHubClientConfiguration& clientConfiguration =
                          Aws::ResilienceHub::ResilienceHubClientConfiguration(),
                      std::shared_ptr<ResilienceHubEndpointProviderBase> endpointProvider = nullptr);
 
  ResilienceHubClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<ResilienceHubEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::ResilienceHub::ResilienceHubClientConfiguration& clientConfiguration =
                          Aws::ResilienceHub::ResilienceHubClientConfiguration());
 
  ResilienceHubClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<ResilienceHubEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::ResilienceHub::ResilienceHubClientConfiguration& clientConfiguration =
                          Aws::ResilienceHub::ResilienceHubClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ResilienceHubClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ResilienceHubClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ResilienceHubClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ResilienceHubClient();
 
  virtual Model::AcceptResourceGroupingRecommendationsOutcome AcceptResourceGroupingRecommendations(
      const Model::AcceptResourceGroupingRecommendationsRequest& request) const;
 
  template <typename AcceptResourceGroupingRecommendationsRequestT = Model::AcceptResourceGroupingRecommendationsRequest>
  Model::AcceptResourceGroupingRecommendationsOutcomeCallable AcceptResourceGroupingRecommendationsCallable(
      const AcceptResourceGroupingRecommendationsRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::AcceptResourceGroupingRecommendations, request);
  }
 
  template <typename AcceptResourceGroupingRecommendationsRequestT = Model::AcceptResourceGroupingRecommendationsRequest>
  void AcceptResourceGroupingRecommendationsAsync(const AcceptResourceGroupingRecommendationsRequestT& request,
                                                  const AcceptResourceGroupingRecommendationsResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::AcceptResourceGroupingRecommendations, request, handler, context);
  }
 
  virtual Model::AddDraftAppVersionResourceMappingsOutcome AddDraftAppVersionResourceMappings(
      const Model::AddDraftAppVersionResourceMappingsRequest& request) const;
 
  template <typename AddDraftAppVersionResourceMappingsRequestT = Model::AddDraftAppVersionResourceMappingsRequest>
  Model::AddDraftAppVersionResourceMappingsOutcomeCallable AddDraftAppVersionResourceMappingsCallable(
      const AddDraftAppVersionResourceMappingsRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::AddDraftAppVersionResourceMappings, request);
  }
 
  template <typename AddDraftAppVersionResourceMappingsRequestT = Model::AddDraftAppVersionResourceMappingsRequest>
  void AddDraftAppVersionResourceMappingsAsync(const AddDraftAppVersionResourceMappingsRequestT& request,
                                               const AddDraftAppVersionResourceMappingsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::AddDraftAppVersionResourceMappings, request, handler, context);
  }
 
  virtual Model::BatchUpdateRecommendationStatusOutcome BatchUpdateRecommendationStatus(
      const Model::BatchUpdateRecommendationStatusRequest& request) const;
 
  template <typename BatchUpdateRecommendationStatusRequestT = Model::BatchUpdateRecommendationStatusRequest>
  Model::BatchUpdateRecommendationStatusOutcomeCallable BatchUpdateRecommendationStatusCallable(
      const BatchUpdateRecommendationStatusRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::BatchUpdateRecommendationStatus, request);
  }
 
  template <typename BatchUpdateRecommendationStatusRequestT = Model::BatchUpdateRecommendationStatusRequest>
  void BatchUpdateRecommendationStatusAsync(const BatchUpdateRecommendationStatusRequestT& request,
                                            const BatchUpdateRecommendationStatusResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::BatchUpdateRecommendationStatus, request, handler, context);
  }
 
  virtual Model::CreateAppOutcome CreateApp(const Model::CreateAppRequest& request) const;
 
  template <typename CreateAppRequestT = Model::CreateAppRequest>
  Model::CreateAppOutcomeCallable CreateAppCallable(const CreateAppRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::CreateApp, request);
  }
 
  template <typename CreateAppRequestT = Model::CreateAppRequest>
  void CreateAppAsync(const CreateAppRequestT& request, const CreateAppResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::CreateApp, request, handler, context);
  }
 
  virtual Model::CreateAppVersionAppComponentOutcome CreateAppVersionAppComponent(
      const Model::CreateAppVersionAppComponentRequest& request) const;
 
  template <typename CreateAppVersionAppComponentRequestT = Model::CreateAppVersionAppComponentRequest>
  Model::CreateAppVersionAppComponentOutcomeCallable CreateAppVersionAppComponentCallable(
      const CreateAppVersionAppComponentRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::CreateAppVersionAppComponent, request);
  }
 
  template <typename CreateAppVersionAppComponentRequestT = Model::CreateAppVersionAppComponentRequest>
  void CreateAppVersionAppComponentAsync(const CreateAppVersionAppComponentRequestT& request,
                                         const CreateAppVersionAppComponentResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::CreateAppVersionAppComponent, request, handler, context);
  }
 
  virtual Model::CreateAppVersionResourceOutcome CreateAppVersionResource(const Model::CreateAppVersionResourceRequest& request) const;
 
  template <typename CreateAppVersionResourceRequestT = Model::CreateAppVersionResourceRequest>
  Model::CreateAppVersionResourceOutcomeCallable CreateAppVersionResourceCallable(const CreateAppVersionResourceRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::CreateAppVersionResource, request);
  }
 
  template <typename CreateAppVersionResourceRequestT = Model::CreateAppVersionResourceRequest>
  void CreateAppVersionResourceAsync(const CreateAppVersionResourceRequestT& request,
                                     const CreateAppVersionResourceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::CreateAppVersionResource, request, handler, context);
  }
 
  virtual Model::CreateRecommendationTemplateOutcome CreateRecommendationTemplate(
      const Model::CreateRecommendationTemplateRequest& request) const;
 
  template <typename CreateRecommendationTemplateRequestT = Model::CreateRecommendationTemplateRequest>
  Model::CreateRecommendationTemplateOutcomeCallable CreateRecommendationTemplateCallable(
      const CreateRecommendationTemplateRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::CreateRecommendationTemplate, request);
  }
 
  template <typename CreateRecommendationTemplateRequestT = Model::CreateRecommendationTemplateRequest>
  void CreateRecommendationTemplateAsync(const CreateRecommendationTemplateRequestT& request,
                                         const CreateRecommendationTemplateResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::CreateRecommendationTemplate, request, handler, context);
  }
 
  virtual Model::CreateResiliencyPolicyOutcome CreateResiliencyPolicy(const Model::CreateResiliencyPolicyRequest& request) const;
 
  template <typename CreateResiliencyPolicyRequestT = Model::CreateResiliencyPolicyRequest>
  Model::CreateResiliencyPolicyOutcomeCallable CreateResiliencyPolicyCallable(const CreateResiliencyPolicyRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::CreateResiliencyPolicy, request);
  }
 
  template <typename CreateResiliencyPolicyRequestT = Model::CreateResiliencyPolicyRequest>
  void CreateResiliencyPolicyAsync(const CreateResiliencyPolicyRequestT& request,
                                   const CreateResiliencyPolicyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::CreateResiliencyPolicy, request, handler, context);
  }
 
  virtual Model::DeleteAppOutcome DeleteApp(const Model::DeleteAppRequest& request) const;
 
  template <typename DeleteAppRequestT = Model::DeleteAppRequest>
  Model::DeleteAppOutcomeCallable DeleteAppCallable(const DeleteAppRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DeleteApp, request);
  }
 
  template <typename DeleteAppRequestT = Model::DeleteAppRequest>
  void DeleteAppAsync(const DeleteAppRequestT& request, const DeleteAppResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DeleteApp, request, handler, context);
  }
 
  virtual Model::DeleteAppAssessmentOutcome DeleteAppAssessment(const Model::DeleteAppAssessmentRequest& request) const;
 
  template <typename DeleteAppAssessmentRequestT = Model::DeleteAppAssessmentRequest>
  Model::DeleteAppAssessmentOutcomeCallable DeleteAppAssessmentCallable(const DeleteAppAssessmentRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DeleteAppAssessment, request);
  }
 
  template <typename DeleteAppAssessmentRequestT = Model::DeleteAppAssessmentRequest>
  void DeleteAppAssessmentAsync(const DeleteAppAssessmentRequestT& request, const DeleteAppAssessmentResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DeleteAppAssessment, request, handler, context);
  }
 
  virtual Model::DeleteAppInputSourceOutcome DeleteAppInputSource(const Model::DeleteAppInputSourceRequest& request) const;
 
  template <typename DeleteAppInputSourceRequestT = Model::DeleteAppInputSourceRequest>
  Model::DeleteAppInputSourceOutcomeCallable DeleteAppInputSourceCallable(const DeleteAppInputSourceRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DeleteAppInputSource, request);
  }
 
  template <typename DeleteAppInputSourceRequestT = Model::DeleteAppInputSourceRequest>
  void DeleteAppInputSourceAsync(const DeleteAppInputSourceRequestT& request, const DeleteAppInputSourceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DeleteAppInputSource, request, handler, context);
  }
 
  virtual Model::DeleteAppVersionAppComponentOutcome DeleteAppVersionAppComponent(
      const Model::DeleteAppVersionAppComponentRequest& request) const;
 
  template <typename DeleteAppVersionAppComponentRequestT = Model::DeleteAppVersionAppComponentRequest>
  Model::DeleteAppVersionAppComponentOutcomeCallable DeleteAppVersionAppComponentCallable(
      const DeleteAppVersionAppComponentRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DeleteAppVersionAppComponent, request);
  }
 
  template <typename DeleteAppVersionAppComponentRequestT = Model::DeleteAppVersionAppComponentRequest>
  void DeleteAppVersionAppComponentAsync(const DeleteAppVersionAppComponentRequestT& request,
                                         const DeleteAppVersionAppComponentResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DeleteAppVersionAppComponent, request, handler, context);
  }
 
  virtual Model::DeleteAppVersionResourceOutcome DeleteAppVersionResource(const Model::DeleteAppVersionResourceRequest& request) const;
 
  template <typename DeleteAppVersionResourceRequestT = Model::DeleteAppVersionResourceRequest>
  Model::DeleteAppVersionResourceOutcomeCallable DeleteAppVersionResourceCallable(const DeleteAppVersionResourceRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DeleteAppVersionResource, request);
  }
 
  template <typename DeleteAppVersionResourceRequestT = Model::DeleteAppVersionResourceRequest>
  void DeleteAppVersionResourceAsync(const DeleteAppVersionResourceRequestT& request,
                                     const DeleteAppVersionResourceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DeleteAppVersionResource, request, handler, context);
  }
 
  virtual Model::DeleteRecommendationTemplateOutcome DeleteRecommendationTemplate(
      const Model::DeleteRecommendationTemplateRequest& request) const;
 
  template <typename DeleteRecommendationTemplateRequestT = Model::DeleteRecommendationTemplateRequest>
  Model::DeleteRecommendationTemplateOutcomeCallable DeleteRecommendationTemplateCallable(
      const DeleteRecommendationTemplateRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DeleteRecommendationTemplate, request);
  }
 
  template <typename DeleteRecommendationTemplateRequestT = Model::DeleteRecommendationTemplateRequest>
  void DeleteRecommendationTemplateAsync(const DeleteRecommendationTemplateRequestT& request,
                                         const DeleteRecommendationTemplateResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DeleteRecommendationTemplate, request, handler, context);
  }
 
  virtual Model::DeleteResiliencyPolicyOutcome DeleteResiliencyPolicy(const Model::DeleteResiliencyPolicyRequest& request) const;
 
  template <typename DeleteResiliencyPolicyRequestT = Model::DeleteResiliencyPolicyRequest>
  Model::DeleteResiliencyPolicyOutcomeCallable DeleteResiliencyPolicyCallable(const DeleteResiliencyPolicyRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DeleteResiliencyPolicy, request);
  }
 
  template <typename DeleteResiliencyPolicyRequestT = Model::DeleteResiliencyPolicyRequest>
  void DeleteResiliencyPolicyAsync(const DeleteResiliencyPolicyRequestT& request,
                                   const DeleteResiliencyPolicyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DeleteResiliencyPolicy, request, handler, context);
  }
 
  virtual Model::DescribeAppOutcome DescribeApp(const Model::DescribeAppRequest& request) const;
 
  template <typename DescribeAppRequestT = Model::DescribeAppRequest>
  Model::DescribeAppOutcomeCallable DescribeAppCallable(const DescribeAppRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DescribeApp, request);
  }
 
  template <typename DescribeAppRequestT = Model::DescribeAppRequest>
  void DescribeAppAsync(const DescribeAppRequestT& request, const DescribeAppResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DescribeApp, request, handler, context);
  }
 
  virtual Model::DescribeAppAssessmentOutcome DescribeAppAssessment(const Model::DescribeAppAssessmentRequest& request) const;
 
  template <typename DescribeAppAssessmentRequestT = Model::DescribeAppAssessmentRequest>
  Model::DescribeAppAssessmentOutcomeCallable DescribeAppAssessmentCallable(const DescribeAppAssessmentRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DescribeAppAssessment, request);
  }
 
  template <typename DescribeAppAssessmentRequestT = Model::DescribeAppAssessmentRequest>
  void DescribeAppAssessmentAsync(const DescribeAppAssessmentRequestT& request, const DescribeAppAssessmentResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DescribeAppAssessment, request, handler, context);
  }
 
  virtual Model::DescribeAppVersionOutcome DescribeAppVersion(const Model::DescribeAppVersionRequest& request) const;
 
  template <typename DescribeAppVersionRequestT = Model::DescribeAppVersionRequest>
  Model::DescribeAppVersionOutcomeCallable DescribeAppVersionCallable(const DescribeAppVersionRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DescribeAppVersion, request);
  }
 
  template <typename DescribeAppVersionRequestT = Model::DescribeAppVersionRequest>
  void DescribeAppVersionAsync(const DescribeAppVersionRequestT& request, const DescribeAppVersionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DescribeAppVersion, request, handler, context);
  }
 
  virtual Model::DescribeAppVersionAppComponentOutcome DescribeAppVersionAppComponent(
      const Model::DescribeAppVersionAppComponentRequest& request) const;
 
  template <typename DescribeAppVersionAppComponentRequestT = Model::DescribeAppVersionAppComponentRequest>
  Model::DescribeAppVersionAppComponentOutcomeCallable DescribeAppVersionAppComponentCallable(
      const DescribeAppVersionAppComponentRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DescribeAppVersionAppComponent, request);
  }
 
  template <typename DescribeAppVersionAppComponentRequestT = Model::DescribeAppVersionAppComponentRequest>
  void DescribeAppVersionAppComponentAsync(const DescribeAppVersionAppComponentRequestT& request,
                                           const DescribeAppVersionAppComponentResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DescribeAppVersionAppComponent, request, handler, context);
  }
 
  virtual Model::DescribeAppVersionResourceOutcome DescribeAppVersionResource(
      const Model::DescribeAppVersionResourceRequest& request) const;
 
  template <typename DescribeAppVersionResourceRequestT = Model::DescribeAppVersionResourceRequest>
  Model::DescribeAppVersionResourceOutcomeCallable DescribeAppVersionResourceCallable(
      const DescribeAppVersionResourceRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DescribeAppVersionResource, request);
  }
 
  template <typename DescribeAppVersionResourceRequestT = Model::DescribeAppVersionResourceRequest>
  void DescribeAppVersionResourceAsync(const DescribeAppVersionResourceRequestT& request,
                                       const DescribeAppVersionResourceResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DescribeAppVersionResource, request, handler, context);
  }
 
  virtual Model::DescribeAppVersionResourcesResolutionStatusOutcome DescribeAppVersionResourcesResolutionStatus(
      const Model::DescribeAppVersionResourcesResolutionStatusRequest& request) const;
 
  template <typename DescribeAppVersionResourcesResolutionStatusRequestT = Model::DescribeAppVersionResourcesResolutionStatusRequest>
  Model::DescribeAppVersionResourcesResolutionStatusOutcomeCallable DescribeAppVersionResourcesResolutionStatusCallable(
      const DescribeAppVersionResourcesResolutionStatusRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DescribeAppVersionResourcesResolutionStatus, request);
  }
 
  template <typename DescribeAppVersionResourcesResolutionStatusRequestT = Model::DescribeAppVersionResourcesResolutionStatusRequest>
  void DescribeAppVersionResourcesResolutionStatusAsync(
      const DescribeAppVersionResourcesResolutionStatusRequestT& request,
      const DescribeAppVersionResourcesResolutionStatusResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DescribeAppVersionResourcesResolutionStatus, request, handler, context);
  }
 
  virtual Model::DescribeAppVersionTemplateOutcome DescribeAppVersionTemplate(
      const Model::DescribeAppVersionTemplateRequest& request) const;
 
  template <typename DescribeAppVersionTemplateRequestT = Model::DescribeAppVersionTemplateRequest>
  Model::DescribeAppVersionTemplateOutcomeCallable DescribeAppVersionTemplateCallable(
      const DescribeAppVersionTemplateRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DescribeAppVersionTemplate, request);
  }
 
  template <typename DescribeAppVersionTemplateRequestT = Model::DescribeAppVersionTemplateRequest>
  void DescribeAppVersionTemplateAsync(const DescribeAppVersionTemplateRequestT& request,
                                       const DescribeAppVersionTemplateResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DescribeAppVersionTemplate, request, handler, context);
  }
 
  virtual Model::DescribeDraftAppVersionResourcesImportStatusOutcome DescribeDraftAppVersionResourcesImportStatus(
      const Model::DescribeDraftAppVersionResourcesImportStatusRequest& request) const;
 
  template <typename DescribeDraftAppVersionResourcesImportStatusRequestT = Model::DescribeDraftAppVersionResourcesImportStatusRequest>
  Model::DescribeDraftAppVersionResourcesImportStatusOutcomeCallable DescribeDraftAppVersionResourcesImportStatusCallable(
      const DescribeDraftAppVersionResourcesImportStatusRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DescribeDraftAppVersionResourcesImportStatus, request);
  }
 
  template <typename DescribeDraftAppVersionResourcesImportStatusRequestT = Model::DescribeDraftAppVersionResourcesImportStatusRequest>
  void DescribeDraftAppVersionResourcesImportStatusAsync(
      const DescribeDraftAppVersionResourcesImportStatusRequestT& request,
      const DescribeDraftAppVersionResourcesImportStatusResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DescribeDraftAppVersionResourcesImportStatus, request, handler, context);
  }
 
  virtual Model::DescribeMetricsExportOutcome DescribeMetricsExport(const Model::DescribeMetricsExportRequest& request) const;
 
  template <typename DescribeMetricsExportRequestT = Model::DescribeMetricsExportRequest>
  Model::DescribeMetricsExportOutcomeCallable DescribeMetricsExportCallable(const DescribeMetricsExportRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DescribeMetricsExport, request);
  }
 
  template <typename DescribeMetricsExportRequestT = Model::DescribeMetricsExportRequest>
  void DescribeMetricsExportAsync(const DescribeMetricsExportRequestT& request, const DescribeMetricsExportResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DescribeMetricsExport, request, handler, context);
  }
 
  virtual Model::DescribeResiliencyPolicyOutcome DescribeResiliencyPolicy(const Model::DescribeResiliencyPolicyRequest& request) const;
 
  template <typename DescribeResiliencyPolicyRequestT = Model::DescribeResiliencyPolicyRequest>
  Model::DescribeResiliencyPolicyOutcomeCallable DescribeResiliencyPolicyCallable(const DescribeResiliencyPolicyRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DescribeResiliencyPolicy, request);
  }
 
  template <typename DescribeResiliencyPolicyRequestT = Model::DescribeResiliencyPolicyRequest>
  void DescribeResiliencyPolicyAsync(const DescribeResiliencyPolicyRequestT& request,
                                     const DescribeResiliencyPolicyResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DescribeResiliencyPolicy, request, handler, context);
  }
 
  virtual Model::DescribeResourceGroupingRecommendationTaskOutcome DescribeResourceGroupingRecommendationTask(
      const Model::DescribeResourceGroupingRecommendationTaskRequest& request) const;
 
  template <typename DescribeResourceGroupingRecommendationTaskRequestT = Model::DescribeResourceGroupingRecommendationTaskRequest>
  Model::DescribeResourceGroupingRecommendationTaskOutcomeCallable DescribeResourceGroupingRecommendationTaskCallable(
      const DescribeResourceGroupingRecommendationTaskRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::DescribeResourceGroupingRecommendationTask, request);
  }
 
  template <typename DescribeResourceGroupingRecommendationTaskRequestT = Model::DescribeResourceGroupingRecommendationTaskRequest>
  void DescribeResourceGroupingRecommendationTaskAsync(
      const DescribeResourceGroupingRecommendationTaskRequestT& request,
      const DescribeResourceGroupingRecommendationTaskResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::DescribeResourceGroupingRecommendationTask, request, handler, context);
  }
 
  virtual Model::ImportResourcesToDraftAppVersionOutcome ImportResourcesToDraftAppVersion(
      const Model::ImportResourcesToDraftAppVersionRequest& request) const;
 
  template <typename ImportResourcesToDraftAppVersionRequestT = Model::ImportResourcesToDraftAppVersionRequest>
  Model::ImportResourcesToDraftAppVersionOutcomeCallable ImportResourcesToDraftAppVersionCallable(
      const ImportResourcesToDraftAppVersionRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ImportResourcesToDraftAppVersion, request);
  }
 
  template <typename ImportResourcesToDraftAppVersionRequestT = Model::ImportResourcesToDraftAppVersionRequest>
  void ImportResourcesToDraftAppVersionAsync(const ImportResourcesToDraftAppVersionRequestT& request,
                                             const ImportResourcesToDraftAppVersionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ImportResourcesToDraftAppVersion, request, handler, context);
  }
 
  virtual Model::ListAlarmRecommendationsOutcome ListAlarmRecommendations(const Model::ListAlarmRecommendationsRequest& request) const;
 
  template <typename ListAlarmRecommendationsRequestT = Model::ListAlarmRecommendationsRequest>
  Model::ListAlarmRecommendationsOutcomeCallable ListAlarmRecommendationsCallable(const ListAlarmRecommendationsRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ListAlarmRecommendations, request);
  }
 
  template <typename ListAlarmRecommendationsRequestT = Model::ListAlarmRecommendationsRequest>
  void ListAlarmRecommendationsAsync(const ListAlarmRecommendationsRequestT& request,
                                     const ListAlarmRecommendationsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ListAlarmRecommendations, request, handler, context);
  }
 
  virtual Model::ListAppAssessmentComplianceDriftsOutcome ListAppAssessmentComplianceDrifts(
      const Model::ListAppAssessmentComplianceDriftsRequest& request) const;
 
  template <typename ListAppAssessmentComplianceDriftsRequestT = Model::ListAppAssessmentComplianceDriftsRequest>
  Model::ListAppAssessmentComplianceDriftsOutcomeCallable ListAppAssessmentComplianceDriftsCallable(
      const ListAppAssessmentComplianceDriftsRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ListAppAssessmentComplianceDrifts, request);
  }
 
  template <typename ListAppAssessmentComplianceDriftsRequestT = Model::ListAppAssessmentComplianceDriftsRequest>
  void ListAppAssessmentComplianceDriftsAsync(const ListAppAssessmentComplianceDriftsRequestT& request,
                                              const ListAppAssessmentComplianceDriftsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ListAppAssessmentComplianceDrifts, request, handler, context);
  }
 
  virtual Model::ListAppAssessmentResourceDriftsOutcome ListAppAssessmentResourceDrifts(
      const Model::ListAppAssessmentResourceDriftsRequest& request) const;
 
  template <typename ListAppAssessmentResourceDriftsRequestT = Model::ListAppAssessmentResourceDriftsRequest>
  Model::ListAppAssessmentResourceDriftsOutcomeCallable ListAppAssessmentResourceDriftsCallable(
      const ListAppAssessmentResourceDriftsRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ListAppAssessmentResourceDrifts, request);
  }
 
  template <typename ListAppAssessmentResourceDriftsRequestT = Model::ListAppAssessmentResourceDriftsRequest>
  void ListAppAssessmentResourceDriftsAsync(const ListAppAssessmentResourceDriftsRequestT& request,
                                            const ListAppAssessmentResourceDriftsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ListAppAssessmentResourceDrifts, request, handler, context);
  }
 
  virtual Model::ListAppAssessmentsOutcome ListAppAssessments(const Model::ListAppAssessmentsRequest& request = {}) const;
 
  template <typename ListAppAssessmentsRequestT = Model::ListAppAssessmentsRequest>
  Model::ListAppAssessmentsOutcomeCallable ListAppAssessmentsCallable(const ListAppAssessmentsRequestT& request = {}) const {
    return SubmitCallable(&ResilienceHubClient::ListAppAssessments, request);
  }
 
  template <typename ListAppAssessmentsRequestT = Model::ListAppAssessmentsRequest>
  void ListAppAssessmentsAsync(const ListAppAssessmentsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListAppAssessmentsRequestT& request = {}) const {
    return SubmitAsync(&ResilienceHubClient::ListAppAssessments, request, handler, context);
  }
 
  virtual Model::ListAppComponentCompliancesOutcome ListAppComponentCompliances(
      const Model::ListAppComponentCompliancesRequest& request) const;
 
  template <typename ListAppComponentCompliancesRequestT = Model::ListAppComponentCompliancesRequest>
  Model::ListAppComponentCompliancesOutcomeCallable ListAppComponentCompliancesCallable(
      const ListAppComponentCompliancesRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ListAppComponentCompliances, request);
  }
 
  template <typename ListAppComponentCompliancesRequestT = Model::ListAppComponentCompliancesRequest>
  void ListAppComponentCompliancesAsync(const ListAppComponentCompliancesRequestT& request,
                                        const ListAppComponentCompliancesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ListAppComponentCompliances, request, handler, context);
  }
 
  virtual Model::ListAppComponentRecommendationsOutcome ListAppComponentRecommendations(
      const Model::ListAppComponentRecommendationsRequest& request) const;
 
  template <typename ListAppComponentRecommendationsRequestT = Model::ListAppComponentRecommendationsRequest>
  Model::ListAppComponentRecommendationsOutcomeCallable ListAppComponentRecommendationsCallable(
      const ListAppComponentRecommendationsRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ListAppComponentRecommendations, request);
  }
 
  template <typename ListAppComponentRecommendationsRequestT = Model::ListAppComponentRecommendationsRequest>
  void ListAppComponentRecommendationsAsync(const ListAppComponentRecommendationsRequestT& request,
                                            const ListAppComponentRecommendationsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ListAppComponentRecommendations, request, handler, context);
  }
 
  virtual Model::ListAppInputSourcesOutcome ListAppInputSources(const Model::ListAppInputSourcesRequest& request) const;
 
  template <typename ListAppInputSourcesRequestT = Model::ListAppInputSourcesRequest>
  Model::ListAppInputSourcesOutcomeCallable ListAppInputSourcesCallable(const ListAppInputSourcesRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ListAppInputSources, request);
  }
 
  template <typename ListAppInputSourcesRequestT = Model::ListAppInputSourcesRequest>
  void ListAppInputSourcesAsync(const ListAppInputSourcesRequestT& request, const ListAppInputSourcesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ListAppInputSources, request, handler, context);
  }
 
  virtual Model::ListAppVersionAppComponentsOutcome ListAppVersionAppComponents(
      const Model::ListAppVersionAppComponentsRequest& request) const;
 
  template <typename ListAppVersionAppComponentsRequestT = Model::ListAppVersionAppComponentsRequest>
  Model::ListAppVersionAppComponentsOutcomeCallable ListAppVersionAppComponentsCallable(
      const ListAppVersionAppComponentsRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ListAppVersionAppComponents, request);
  }
 
  template <typename ListAppVersionAppComponentsRequestT = Model::ListAppVersionAppComponentsRequest>
  void ListAppVersionAppComponentsAsync(const ListAppVersionAppComponentsRequestT& request,
                                        const ListAppVersionAppComponentsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ListAppVersionAppComponents, request, handler, context);
  }
 
  virtual Model::ListAppVersionResourceMappingsOutcome ListAppVersionResourceMappings(
      const Model::ListAppVersionResourceMappingsRequest& request) const;
 
  template <typename ListAppVersionResourceMappingsRequestT = Model::ListAppVersionResourceMappingsRequest>
  Model::ListAppVersionResourceMappingsOutcomeCallable ListAppVersionResourceMappingsCallable(
      const ListAppVersionResourceMappingsRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ListAppVersionResourceMappings, request);
  }
 
  template <typename ListAppVersionResourceMappingsRequestT = Model::ListAppVersionResourceMappingsRequest>
  void ListAppVersionResourceMappingsAsync(const ListAppVersionResourceMappingsRequestT& request,
                                           const ListAppVersionResourceMappingsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ListAppVersionResourceMappings, request, handler, context);
  }
 
  virtual Model::ListAppVersionResourcesOutcome ListAppVersionResources(const Model::ListAppVersionResourcesRequest& request) const;
 
  template <typename ListAppVersionResourcesRequestT = Model::ListAppVersionResourcesRequest>
  Model::ListAppVersionResourcesOutcomeCallable ListAppVersionResourcesCallable(const ListAppVersionResourcesRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ListAppVersionResources, request);
  }
 
  template <typename ListAppVersionResourcesRequestT = Model::ListAppVersionResourcesRequest>
  void ListAppVersionResourcesAsync(const ListAppVersionResourcesRequestT& request,
                                    const ListAppVersionResourcesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ListAppVersionResources, request, handler, context);
  }
 
  virtual Model::ListAppVersionsOutcome ListAppVersions(const Model::ListAppVersionsRequest& request) const;
 
  template <typename ListAppVersionsRequestT = Model::ListAppVersionsRequest>
  Model::ListAppVersionsOutcomeCallable ListAppVersionsCallable(const ListAppVersionsRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ListAppVersions, request);
  }
 
  template <typename ListAppVersionsRequestT = Model::ListAppVersionsRequest>
  void ListAppVersionsAsync(const ListAppVersionsRequestT& request, const ListAppVersionsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ListAppVersions, request, handler, context);
  }
 
  virtual Model::ListAppsOutcome ListApps(const Model::ListAppsRequest& request = {}) const;
 
  template <typename ListAppsRequestT = Model::ListAppsRequest>
  Model::ListAppsOutcomeCallable ListAppsCallable(const ListAppsRequestT& request = {}) const {
    return SubmitCallable(&ResilienceHubClient::ListApps, request);
  }
 
  template <typename ListAppsRequestT = Model::ListAppsRequest>
  void ListAppsAsync(const ListAppsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const ListAppsRequestT& request = {}) const {
    return SubmitAsync(&ResilienceHubClient::ListApps, request, handler, context);
  }
 
  virtual Model::ListMetricsOutcome ListMetrics(const Model::ListMetricsRequest& request = {}) const;
 
  template <typename ListMetricsRequestT = Model::ListMetricsRequest>
  Model::ListMetricsOutcomeCallable ListMetricsCallable(const ListMetricsRequestT& request = {}) const {
    return SubmitCallable(&ResilienceHubClient::ListMetrics, request);
  }
 
  template <typename ListMetricsRequestT = Model::ListMetricsRequest>
  void ListMetricsAsync(const ListMetricsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListMetricsRequestT& request = {}) const {
    return SubmitAsync(&ResilienceHubClient::ListMetrics, request, handler, context);
  }
 
  virtual Model::ListRecommendationTemplatesOutcome ListRecommendationTemplates(
      const Model::ListRecommendationTemplatesRequest& request = {}) const;
 
  template <typename ListRecommendationTemplatesRequestT = Model::ListRecommendationTemplatesRequest>
  Model::ListRecommendationTemplatesOutcomeCallable ListRecommendationTemplatesCallable(
      const ListRecommendationTemplatesRequestT& request = {}) const {
    return SubmitCallable(&ResilienceHubClient::ListRecommendationTemplates, request);
  }
 
  template <typename ListRecommendationTemplatesRequestT = Model::ListRecommendationTemplatesRequest>
  void ListRecommendationTemplatesAsync(const ListRecommendationTemplatesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListRecommendationTemplatesRequestT& request = {}) const {
    return SubmitAsync(&ResilienceHubClient::ListRecommendationTemplates, request, handler, context);
  }
 
  virtual Model::ListResiliencyPoliciesOutcome ListResiliencyPolicies(const Model::ListResiliencyPoliciesRequest& request = {}) const;
 
  template <typename ListResiliencyPoliciesRequestT = Model::ListResiliencyPoliciesRequest>
  Model::ListResiliencyPoliciesOutcomeCallable ListResiliencyPoliciesCallable(const ListResiliencyPoliciesRequestT& request = {}) const {
    return SubmitCallable(&ResilienceHubClient::ListResiliencyPolicies, request);
  }
 
  template <typename ListResiliencyPoliciesRequestT = Model::ListResiliencyPoliciesRequest>
  void ListResiliencyPoliciesAsync(const ListResiliencyPoliciesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListResiliencyPoliciesRequestT& request = {}) const {
    return SubmitAsync(&ResilienceHubClient::ListResiliencyPolicies, request, handler, context);
  }
 
  virtual Model::ListResourceGroupingRecommendationsOutcome ListResourceGroupingRecommendations(
      const Model::ListResourceGroupingRecommendationsRequest& request = {}) const;
 
  template <typename ListResourceGroupingRecommendationsRequestT = Model::ListResourceGroupingRecommendationsRequest>
  Model::ListResourceGroupingRecommendationsOutcomeCallable ListResourceGroupingRecommendationsCallable(
      const ListResourceGroupingRecommendationsRequestT& request = {}) const {
    return SubmitCallable(&ResilienceHubClient::ListResourceGroupingRecommendations, request);
  }
 
  template <typename ListResourceGroupingRecommendationsRequestT = Model::ListResourceGroupingRecommendationsRequest>
  void ListResourceGroupingRecommendationsAsync(const ListResourceGroupingRecommendationsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const ListResourceGroupingRecommendationsRequestT& request = {}) const {
    return SubmitAsync(&ResilienceHubClient::ListResourceGroupingRecommendations, request, handler, context);
  }
 
  virtual Model::ListSopRecommendationsOutcome ListSopRecommendations(const Model::ListSopRecommendationsRequest& request) const;
 
  template <typename ListSopRecommendationsRequestT = Model::ListSopRecommendationsRequest>
  Model::ListSopRecommendationsOutcomeCallable ListSopRecommendationsCallable(const ListSopRecommendationsRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ListSopRecommendations, request);
  }
 
  template <typename ListSopRecommendationsRequestT = Model::ListSopRecommendationsRequest>
  void ListSopRecommendationsAsync(const ListSopRecommendationsRequestT& request,
                                   const ListSopRecommendationsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ListSopRecommendations, request, handler, context);
  }
 
  virtual Model::ListSuggestedResiliencyPoliciesOutcome ListSuggestedResiliencyPolicies(
      const Model::ListSuggestedResiliencyPoliciesRequest& request = {}) const;
 
  template <typename ListSuggestedResiliencyPoliciesRequestT = Model::ListSuggestedResiliencyPoliciesRequest>
  Model::ListSuggestedResiliencyPoliciesOutcomeCallable ListSuggestedResiliencyPoliciesCallable(
      const ListSuggestedResiliencyPoliciesRequestT& request = {}) const {
    return SubmitCallable(&ResilienceHubClient::ListSuggestedResiliencyPolicies, request);
  }
 
  template <typename ListSuggestedResiliencyPoliciesRequestT = Model::ListSuggestedResiliencyPoliciesRequest>
  void ListSuggestedResiliencyPoliciesAsync(const ListSuggestedResiliencyPoliciesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const ListSuggestedResiliencyPoliciesRequestT& request = {}) const {
    return SubmitAsync(&ResilienceHubClient::ListSuggestedResiliencyPolicies, 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(&ResilienceHubClient::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(&ResilienceHubClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTestRecommendationsOutcome ListTestRecommendations(const Model::ListTestRecommendationsRequest& request) const;
 
  template <typename ListTestRecommendationsRequestT = Model::ListTestRecommendationsRequest>
  Model::ListTestRecommendationsOutcomeCallable ListTestRecommendationsCallable(const ListTestRecommendationsRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ListTestRecommendations, request);
  }
 
  template <typename ListTestRecommendationsRequestT = Model::ListTestRecommendationsRequest>
  void ListTestRecommendationsAsync(const ListTestRecommendationsRequestT& request,
                                    const ListTestRecommendationsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ListTestRecommendations, request, handler, context);
  }
 
  virtual Model::ListUnsupportedAppVersionResourcesOutcome ListUnsupportedAppVersionResources(
      const Model::ListUnsupportedAppVersionResourcesRequest& request) const;
 
  template <typename ListUnsupportedAppVersionResourcesRequestT = Model::ListUnsupportedAppVersionResourcesRequest>
  Model::ListUnsupportedAppVersionResourcesOutcomeCallable ListUnsupportedAppVersionResourcesCallable(
      const ListUnsupportedAppVersionResourcesRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ListUnsupportedAppVersionResources, request);
  }
 
  template <typename ListUnsupportedAppVersionResourcesRequestT = Model::ListUnsupportedAppVersionResourcesRequest>
  void ListUnsupportedAppVersionResourcesAsync(const ListUnsupportedAppVersionResourcesRequestT& request,
                                               const ListUnsupportedAppVersionResourcesResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ListUnsupportedAppVersionResources, request, handler, context);
  }
 
  virtual Model::PublishAppVersionOutcome PublishAppVersion(const Model::PublishAppVersionRequest& request) const;
 
  template <typename PublishAppVersionRequestT = Model::PublishAppVersionRequest>
  Model::PublishAppVersionOutcomeCallable PublishAppVersionCallable(const PublishAppVersionRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::PublishAppVersion, request);
  }
 
  template <typename PublishAppVersionRequestT = Model::PublishAppVersionRequest>
  void PublishAppVersionAsync(const PublishAppVersionRequestT& request, const PublishAppVersionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::PublishAppVersion, request, handler, context);
  }
 
  virtual Model::PutDraftAppVersionTemplateOutcome PutDraftAppVersionTemplate(
      const Model::PutDraftAppVersionTemplateRequest& request) const;
 
  template <typename PutDraftAppVersionTemplateRequestT = Model::PutDraftAppVersionTemplateRequest>
  Model::PutDraftAppVersionTemplateOutcomeCallable PutDraftAppVersionTemplateCallable(
      const PutDraftAppVersionTemplateRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::PutDraftAppVersionTemplate, request);
  }
 
  template <typename PutDraftAppVersionTemplateRequestT = Model::PutDraftAppVersionTemplateRequest>
  void PutDraftAppVersionTemplateAsync(const PutDraftAppVersionTemplateRequestT& request,
                                       const PutDraftAppVersionTemplateResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::PutDraftAppVersionTemplate, request, handler, context);
  }
 
  virtual Model::RejectResourceGroupingRecommendationsOutcome RejectResourceGroupingRecommendations(
      const Model::RejectResourceGroupingRecommendationsRequest& request) const;
 
  template <typename RejectResourceGroupingRecommendationsRequestT = Model::RejectResourceGroupingRecommendationsRequest>
  Model::RejectResourceGroupingRecommendationsOutcomeCallable RejectResourceGroupingRecommendationsCallable(
      const RejectResourceGroupingRecommendationsRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::RejectResourceGroupingRecommendations, request);
  }
 
  template <typename RejectResourceGroupingRecommendationsRequestT = Model::RejectResourceGroupingRecommendationsRequest>
  void RejectResourceGroupingRecommendationsAsync(const RejectResourceGroupingRecommendationsRequestT& request,
                                                  const RejectResourceGroupingRecommendationsResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::RejectResourceGroupingRecommendations, request, handler, context);
  }
 
  virtual Model::RemoveDraftAppVersionResourceMappingsOutcome RemoveDraftAppVersionResourceMappings(
      const Model::RemoveDraftAppVersionResourceMappingsRequest& request) const;
 
  template <typename RemoveDraftAppVersionResourceMappingsRequestT = Model::RemoveDraftAppVersionResourceMappingsRequest>
  Model::RemoveDraftAppVersionResourceMappingsOutcomeCallable RemoveDraftAppVersionResourceMappingsCallable(
      const RemoveDraftAppVersionResourceMappingsRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::RemoveDraftAppVersionResourceMappings, request);
  }
 
  template <typename RemoveDraftAppVersionResourceMappingsRequestT = Model::RemoveDraftAppVersionResourceMappingsRequest>
  void RemoveDraftAppVersionResourceMappingsAsync(const RemoveDraftAppVersionResourceMappingsRequestT& request,
                                                  const RemoveDraftAppVersionResourceMappingsResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::RemoveDraftAppVersionResourceMappings, request, handler, context);
  }
 
  virtual Model::ResolveAppVersionResourcesOutcome ResolveAppVersionResources(
      const Model::ResolveAppVersionResourcesRequest& request) const;
 
  template <typename ResolveAppVersionResourcesRequestT = Model::ResolveAppVersionResourcesRequest>
  Model::ResolveAppVersionResourcesOutcomeCallable ResolveAppVersionResourcesCallable(
      const ResolveAppVersionResourcesRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::ResolveAppVersionResources, request);
  }
 
  template <typename ResolveAppVersionResourcesRequestT = Model::ResolveAppVersionResourcesRequest>
  void ResolveAppVersionResourcesAsync(const ResolveAppVersionResourcesRequestT& request,
                                       const ResolveAppVersionResourcesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::ResolveAppVersionResources, request, handler, context);
  }
 
  virtual Model::StartAppAssessmentOutcome StartAppAssessment(const Model::StartAppAssessmentRequest& request) const;
 
  template <typename StartAppAssessmentRequestT = Model::StartAppAssessmentRequest>
  Model::StartAppAssessmentOutcomeCallable StartAppAssessmentCallable(const StartAppAssessmentRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::StartAppAssessment, request);
  }
 
  template <typename StartAppAssessmentRequestT = Model::StartAppAssessmentRequest>
  void StartAppAssessmentAsync(const StartAppAssessmentRequestT& request, const StartAppAssessmentResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::StartAppAssessment, request, handler, context);
  }
 
  virtual Model::StartMetricsExportOutcome StartMetricsExport(const Model::StartMetricsExportRequest& request = {}) const;
 
  template <typename StartMetricsExportRequestT = Model::StartMetricsExportRequest>
  Model::StartMetricsExportOutcomeCallable StartMetricsExportCallable(const StartMetricsExportRequestT& request = {}) const {
    return SubmitCallable(&ResilienceHubClient::StartMetricsExport, request);
  }
 
  template <typename StartMetricsExportRequestT = Model::StartMetricsExportRequest>
  void StartMetricsExportAsync(const StartMetricsExportResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const StartMetricsExportRequestT& request = {}) const {
    return SubmitAsync(&ResilienceHubClient::StartMetricsExport, request, handler, context);
  }
 
  virtual Model::StartResourceGroupingRecommendationTaskOutcome StartResourceGroupingRecommendationTask(
      const Model::StartResourceGroupingRecommendationTaskRequest& request) const;
 
  template <typename StartResourceGroupingRecommendationTaskRequestT = Model::StartResourceGroupingRecommendationTaskRequest>
  Model::StartResourceGroupingRecommendationTaskOutcomeCallable StartResourceGroupingRecommendationTaskCallable(
      const StartResourceGroupingRecommendationTaskRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::StartResourceGroupingRecommendationTask, request);
  }
 
  template <typename StartResourceGroupingRecommendationTaskRequestT = Model::StartResourceGroupingRecommendationTaskRequest>
  void StartResourceGroupingRecommendationTaskAsync(const StartResourceGroupingRecommendationTaskRequestT& request,
                                                    const StartResourceGroupingRecommendationTaskResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::StartResourceGroupingRecommendationTask, 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(&ResilienceHubClient::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(&ResilienceHubClient::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(&ResilienceHubClient::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(&ResilienceHubClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAppOutcome UpdateApp(const Model::UpdateAppRequest& request) const;
 
  template <typename UpdateAppRequestT = Model::UpdateAppRequest>
  Model::UpdateAppOutcomeCallable UpdateAppCallable(const UpdateAppRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::UpdateApp, request);
  }
 
  template <typename UpdateAppRequestT = Model::UpdateAppRequest>
  void UpdateAppAsync(const UpdateAppRequestT& request, const UpdateAppResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::UpdateApp, request, handler, context);
  }
 
  virtual Model::UpdateAppVersionOutcome UpdateAppVersion(const Model::UpdateAppVersionRequest& request) const;
 
  template <typename UpdateAppVersionRequestT = Model::UpdateAppVersionRequest>
  Model::UpdateAppVersionOutcomeCallable UpdateAppVersionCallable(const UpdateAppVersionRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::UpdateAppVersion, request);
  }
 
  template <typename UpdateAppVersionRequestT = Model::UpdateAppVersionRequest>
  void UpdateAppVersionAsync(const UpdateAppVersionRequestT& request, const UpdateAppVersionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::UpdateAppVersion, request, handler, context);
  }
 
  virtual Model::UpdateAppVersionAppComponentOutcome UpdateAppVersionAppComponent(
      const Model::UpdateAppVersionAppComponentRequest& request) const;
 
  template <typename UpdateAppVersionAppComponentRequestT = Model::UpdateAppVersionAppComponentRequest>
  Model::UpdateAppVersionAppComponentOutcomeCallable UpdateAppVersionAppComponentCallable(
      const UpdateAppVersionAppComponentRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::UpdateAppVersionAppComponent, request);
  }
 
  template <typename UpdateAppVersionAppComponentRequestT = Model::UpdateAppVersionAppComponentRequest>
  void UpdateAppVersionAppComponentAsync(const UpdateAppVersionAppComponentRequestT& request,
                                         const UpdateAppVersionAppComponentResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::UpdateAppVersionAppComponent, request, handler, context);
  }
 
  virtual Model::UpdateAppVersionResourceOutcome UpdateAppVersionResource(const Model::UpdateAppVersionResourceRequest& request) const;
 
  template <typename UpdateAppVersionResourceRequestT = Model::UpdateAppVersionResourceRequest>
  Model::UpdateAppVersionResourceOutcomeCallable UpdateAppVersionResourceCallable(const UpdateAppVersionResourceRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::UpdateAppVersionResource, request);
  }
 
  template <typename UpdateAppVersionResourceRequestT = Model::UpdateAppVersionResourceRequest>
  void UpdateAppVersionResourceAsync(const UpdateAppVersionResourceRequestT& request,
                                     const UpdateAppVersionResourceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::UpdateAppVersionResource, request, handler, context);
  }
 
  virtual Model::UpdateResiliencyPolicyOutcome UpdateResiliencyPolicy(const Model::UpdateResiliencyPolicyRequest& request) const;
 
  template <typename UpdateResiliencyPolicyRequestT = Model::UpdateResiliencyPolicyRequest>
  Model::UpdateResiliencyPolicyOutcomeCallable UpdateResiliencyPolicyCallable(const UpdateResiliencyPolicyRequestT& request) const {
    return SubmitCallable(&ResilienceHubClient::UpdateResiliencyPolicy, request);
  }
 
  template <typename UpdateResiliencyPolicyRequestT = Model::UpdateResiliencyPolicyRequest>
  void UpdateResiliencyPolicyAsync(const UpdateResiliencyPolicyRequestT& request,
                                   const UpdateResiliencyPolicyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ResilienceHubClient::UpdateResiliencyPolicy, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ResilienceHubEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ResilienceHubClient>;
  void init(const ResilienceHubClientConfiguration& clientConfiguration);
 
  ResilienceHubClientConfiguration m_clientConfiguration;
  std::shared_ptr<ResilienceHubEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ResilienceHub
}  // namespace Aws