ResilienceHubClient.h

 
#pragma once
#include <aws/resiliencehub/ResilienceHub_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/resiliencehub/ResilienceHubServiceClientModel.h>
 
namespace Aws
{
namespace ResilienceHub
{
  class AWS_RESILIENCEHUB_API ResilienceHubClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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