WellArchitectedClient.h

 
#pragma once
#include <aws/wellarchitected/WellArchitected_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/wellarchitected/WellArchitectedServiceClientModel.h>
 
namespace Aws
{
namespace WellArchitected
{
  class AWS_WELLARCHITECTED_API WellArchitectedClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<WellArchitectedClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef WellArchitectedClientConfiguration ClientConfigurationType;
      typedef WellArchitectedEndpointProvider EndpointProviderType;
 
        WellArchitectedClient(const Aws::WellArchitected::WellArchitectedClientConfiguration& clientConfiguration = Aws::WellArchitected::WellArchitectedClientConfiguration(),
                              std::shared_ptr<WellArchitectedEndpointProviderBase> endpointProvider = nullptr);
 
        WellArchitectedClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<WellArchitectedEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::WellArchitected::WellArchitectedClientConfiguration& clientConfiguration = Aws::WellArchitected::WellArchitectedClientConfiguration());
 
        WellArchitectedClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<WellArchitectedEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::WellArchitected::WellArchitectedClientConfiguration& clientConfiguration = Aws::WellArchitected::WellArchitectedClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        WellArchitectedClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        WellArchitectedClient(const Aws::Auth::AWSCredentials& credentials,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        WellArchitectedClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~WellArchitectedClient();
 
        virtual Model::AssociateLensesOutcome AssociateLenses(const Model::AssociateLensesRequest& request) const;
 
        template<typename AssociateLensesRequestT = Model::AssociateLensesRequest>
        Model::AssociateLensesOutcomeCallable AssociateLensesCallable(const AssociateLensesRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::AssociateLenses, request);
        }
 
        template<typename AssociateLensesRequestT = Model::AssociateLensesRequest>
        void AssociateLensesAsync(const AssociateLensesRequestT& request, const AssociateLensesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::AssociateLenses, request, handler, context);
        }
 
        virtual Model::AssociateProfilesOutcome AssociateProfiles(const Model::AssociateProfilesRequest& request) const;
 
        template<typename AssociateProfilesRequestT = Model::AssociateProfilesRequest>
        Model::AssociateProfilesOutcomeCallable AssociateProfilesCallable(const AssociateProfilesRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::AssociateProfiles, request);
        }
 
        template<typename AssociateProfilesRequestT = Model::AssociateProfilesRequest>
        void AssociateProfilesAsync(const AssociateProfilesRequestT& request, const AssociateProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::AssociateProfiles, request, handler, context);
        }
 
        virtual Model::CreateLensShareOutcome CreateLensShare(const Model::CreateLensShareRequest& request) const;
 
        template<typename CreateLensShareRequestT = Model::CreateLensShareRequest>
        Model::CreateLensShareOutcomeCallable CreateLensShareCallable(const CreateLensShareRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::CreateLensShare, request);
        }
 
        template<typename CreateLensShareRequestT = Model::CreateLensShareRequest>
        void CreateLensShareAsync(const CreateLensShareRequestT& request, const CreateLensShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::CreateLensShare, request, handler, context);
        }
 
        virtual Model::CreateLensVersionOutcome CreateLensVersion(const Model::CreateLensVersionRequest& request) const;
 
        template<typename CreateLensVersionRequestT = Model::CreateLensVersionRequest>
        Model::CreateLensVersionOutcomeCallable CreateLensVersionCallable(const CreateLensVersionRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::CreateLensVersion, request);
        }
 
        template<typename CreateLensVersionRequestT = Model::CreateLensVersionRequest>
        void CreateLensVersionAsync(const CreateLensVersionRequestT& request, const CreateLensVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::CreateLensVersion, request, handler, context);
        }
 
        virtual Model::CreateMilestoneOutcome CreateMilestone(const Model::CreateMilestoneRequest& request) const;
 
        template<typename CreateMilestoneRequestT = Model::CreateMilestoneRequest>
        Model::CreateMilestoneOutcomeCallable CreateMilestoneCallable(const CreateMilestoneRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::CreateMilestone, request);
        }
 
        template<typename CreateMilestoneRequestT = Model::CreateMilestoneRequest>
        void CreateMilestoneAsync(const CreateMilestoneRequestT& request, const CreateMilestoneResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::CreateMilestone, request, handler, context);
        }
 
        virtual Model::CreateProfileOutcome CreateProfile(const Model::CreateProfileRequest& request) const;
 
        template<typename CreateProfileRequestT = Model::CreateProfileRequest>
        Model::CreateProfileOutcomeCallable CreateProfileCallable(const CreateProfileRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::CreateProfile, request);
        }
 
        template<typename CreateProfileRequestT = Model::CreateProfileRequest>
        void CreateProfileAsync(const CreateProfileRequestT& request, const CreateProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::CreateProfile, request, handler, context);
        }
 
        virtual Model::CreateProfileShareOutcome CreateProfileShare(const Model::CreateProfileShareRequest& request) const;
 
        template<typename CreateProfileShareRequestT = Model::CreateProfileShareRequest>
        Model::CreateProfileShareOutcomeCallable CreateProfileShareCallable(const CreateProfileShareRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::CreateProfileShare, request);
        }
 
        template<typename CreateProfileShareRequestT = Model::CreateProfileShareRequest>
        void CreateProfileShareAsync(const CreateProfileShareRequestT& request, const CreateProfileShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::CreateProfileShare, request, handler, context);
        }
 
        virtual Model::CreateReviewTemplateOutcome CreateReviewTemplate(const Model::CreateReviewTemplateRequest& request) const;
 
        template<typename CreateReviewTemplateRequestT = Model::CreateReviewTemplateRequest>
        Model::CreateReviewTemplateOutcomeCallable CreateReviewTemplateCallable(const CreateReviewTemplateRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::CreateReviewTemplate, request);
        }
 
        template<typename CreateReviewTemplateRequestT = Model::CreateReviewTemplateRequest>
        void CreateReviewTemplateAsync(const CreateReviewTemplateRequestT& request, const CreateReviewTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::CreateReviewTemplate, request, handler, context);
        }
 
        virtual Model::CreateTemplateShareOutcome CreateTemplateShare(const Model::CreateTemplateShareRequest& request) const;
 
        template<typename CreateTemplateShareRequestT = Model::CreateTemplateShareRequest>
        Model::CreateTemplateShareOutcomeCallable CreateTemplateShareCallable(const CreateTemplateShareRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::CreateTemplateShare, request);
        }
 
        template<typename CreateTemplateShareRequestT = Model::CreateTemplateShareRequest>
        void CreateTemplateShareAsync(const CreateTemplateShareRequestT& request, const CreateTemplateShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::CreateTemplateShare, request, handler, context);
        }
 
        virtual Model::CreateWorkloadOutcome CreateWorkload(const Model::CreateWorkloadRequest& request) const;
 
        template<typename CreateWorkloadRequestT = Model::CreateWorkloadRequest>
        Model::CreateWorkloadOutcomeCallable CreateWorkloadCallable(const CreateWorkloadRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::CreateWorkload, request);
        }
 
        template<typename CreateWorkloadRequestT = Model::CreateWorkloadRequest>
        void CreateWorkloadAsync(const CreateWorkloadRequestT& request, const CreateWorkloadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::CreateWorkload, request, handler, context);
        }
 
        virtual Model::CreateWorkloadShareOutcome CreateWorkloadShare(const Model::CreateWorkloadShareRequest& request) const;
 
        template<typename CreateWorkloadShareRequestT = Model::CreateWorkloadShareRequest>
        Model::CreateWorkloadShareOutcomeCallable CreateWorkloadShareCallable(const CreateWorkloadShareRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::CreateWorkloadShare, request);
        }
 
        template<typename CreateWorkloadShareRequestT = Model::CreateWorkloadShareRequest>
        void CreateWorkloadShareAsync(const CreateWorkloadShareRequestT& request, const CreateWorkloadShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::CreateWorkloadShare, request, handler, context);
        }
 
        virtual Model::DeleteLensOutcome DeleteLens(const Model::DeleteLensRequest& request) const;
 
        template<typename DeleteLensRequestT = Model::DeleteLensRequest>
        Model::DeleteLensOutcomeCallable DeleteLensCallable(const DeleteLensRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::DeleteLens, request);
        }
 
        template<typename DeleteLensRequestT = Model::DeleteLensRequest>
        void DeleteLensAsync(const DeleteLensRequestT& request, const DeleteLensResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::DeleteLens, request, handler, context);
        }
 
        virtual Model::DeleteLensShareOutcome DeleteLensShare(const Model::DeleteLensShareRequest& request) const;
 
        template<typename DeleteLensShareRequestT = Model::DeleteLensShareRequest>
        Model::DeleteLensShareOutcomeCallable DeleteLensShareCallable(const DeleteLensShareRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::DeleteLensShare, request);
        }
 
        template<typename DeleteLensShareRequestT = Model::DeleteLensShareRequest>
        void DeleteLensShareAsync(const DeleteLensShareRequestT& request, const DeleteLensShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::DeleteLensShare, request, handler, context);
        }
 
        virtual Model::DeleteProfileOutcome DeleteProfile(const Model::DeleteProfileRequest& request) const;
 
        template<typename DeleteProfileRequestT = Model::DeleteProfileRequest>
        Model::DeleteProfileOutcomeCallable DeleteProfileCallable(const DeleteProfileRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::DeleteProfile, request);
        }
 
        template<typename DeleteProfileRequestT = Model::DeleteProfileRequest>
        void DeleteProfileAsync(const DeleteProfileRequestT& request, const DeleteProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::DeleteProfile, request, handler, context);
        }
 
        virtual Model::DeleteProfileShareOutcome DeleteProfileShare(const Model::DeleteProfileShareRequest& request) const;
 
        template<typename DeleteProfileShareRequestT = Model::DeleteProfileShareRequest>
        Model::DeleteProfileShareOutcomeCallable DeleteProfileShareCallable(const DeleteProfileShareRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::DeleteProfileShare, request);
        }
 
        template<typename DeleteProfileShareRequestT = Model::DeleteProfileShareRequest>
        void DeleteProfileShareAsync(const DeleteProfileShareRequestT& request, const DeleteProfileShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::DeleteProfileShare, request, handler, context);
        }
 
        virtual Model::DeleteReviewTemplateOutcome DeleteReviewTemplate(const Model::DeleteReviewTemplateRequest& request) const;
 
        template<typename DeleteReviewTemplateRequestT = Model::DeleteReviewTemplateRequest>
        Model::DeleteReviewTemplateOutcomeCallable DeleteReviewTemplateCallable(const DeleteReviewTemplateRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::DeleteReviewTemplate, request);
        }
 
        template<typename DeleteReviewTemplateRequestT = Model::DeleteReviewTemplateRequest>
        void DeleteReviewTemplateAsync(const DeleteReviewTemplateRequestT& request, const DeleteReviewTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::DeleteReviewTemplate, request, handler, context);
        }
 
        virtual Model::DeleteTemplateShareOutcome DeleteTemplateShare(const Model::DeleteTemplateShareRequest& request) const;
 
        template<typename DeleteTemplateShareRequestT = Model::DeleteTemplateShareRequest>
        Model::DeleteTemplateShareOutcomeCallable DeleteTemplateShareCallable(const DeleteTemplateShareRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::DeleteTemplateShare, request);
        }
 
        template<typename DeleteTemplateShareRequestT = Model::DeleteTemplateShareRequest>
        void DeleteTemplateShareAsync(const DeleteTemplateShareRequestT& request, const DeleteTemplateShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::DeleteTemplateShare, request, handler, context);
        }
 
        virtual Model::DeleteWorkloadOutcome DeleteWorkload(const Model::DeleteWorkloadRequest& request) const;
 
        template<typename DeleteWorkloadRequestT = Model::DeleteWorkloadRequest>
        Model::DeleteWorkloadOutcomeCallable DeleteWorkloadCallable(const DeleteWorkloadRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::DeleteWorkload, request);
        }
 
        template<typename DeleteWorkloadRequestT = Model::DeleteWorkloadRequest>
        void DeleteWorkloadAsync(const DeleteWorkloadRequestT& request, const DeleteWorkloadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::DeleteWorkload, request, handler, context);
        }
 
        virtual Model::DeleteWorkloadShareOutcome DeleteWorkloadShare(const Model::DeleteWorkloadShareRequest& request) const;
 
        template<typename DeleteWorkloadShareRequestT = Model::DeleteWorkloadShareRequest>
        Model::DeleteWorkloadShareOutcomeCallable DeleteWorkloadShareCallable(const DeleteWorkloadShareRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::DeleteWorkloadShare, request);
        }
 
        template<typename DeleteWorkloadShareRequestT = Model::DeleteWorkloadShareRequest>
        void DeleteWorkloadShareAsync(const DeleteWorkloadShareRequestT& request, const DeleteWorkloadShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::DeleteWorkloadShare, request, handler, context);
        }
 
        virtual Model::DisassociateLensesOutcome DisassociateLenses(const Model::DisassociateLensesRequest& request) const;
 
        template<typename DisassociateLensesRequestT = Model::DisassociateLensesRequest>
        Model::DisassociateLensesOutcomeCallable DisassociateLensesCallable(const DisassociateLensesRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::DisassociateLenses, request);
        }
 
        template<typename DisassociateLensesRequestT = Model::DisassociateLensesRequest>
        void DisassociateLensesAsync(const DisassociateLensesRequestT& request, const DisassociateLensesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::DisassociateLenses, request, handler, context);
        }
 
        virtual Model::DisassociateProfilesOutcome DisassociateProfiles(const Model::DisassociateProfilesRequest& request) const;
 
        template<typename DisassociateProfilesRequestT = Model::DisassociateProfilesRequest>
        Model::DisassociateProfilesOutcomeCallable DisassociateProfilesCallable(const DisassociateProfilesRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::DisassociateProfiles, request);
        }
 
        template<typename DisassociateProfilesRequestT = Model::DisassociateProfilesRequest>
        void DisassociateProfilesAsync(const DisassociateProfilesRequestT& request, const DisassociateProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::DisassociateProfiles, request, handler, context);
        }
 
        virtual Model::ExportLensOutcome ExportLens(const Model::ExportLensRequest& request) const;
 
        template<typename ExportLensRequestT = Model::ExportLensRequest>
        Model::ExportLensOutcomeCallable ExportLensCallable(const ExportLensRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::ExportLens, request);
        }
 
        template<typename ExportLensRequestT = Model::ExportLensRequest>
        void ExportLensAsync(const ExportLensRequestT& request, const ExportLensResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::ExportLens, request, handler, context);
        }
 
        virtual Model::GetAnswerOutcome GetAnswer(const Model::GetAnswerRequest& request) const;
 
        template<typename GetAnswerRequestT = Model::GetAnswerRequest>
        Model::GetAnswerOutcomeCallable GetAnswerCallable(const GetAnswerRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::GetAnswer, request);
        }
 
        template<typename GetAnswerRequestT = Model::GetAnswerRequest>
        void GetAnswerAsync(const GetAnswerRequestT& request, const GetAnswerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::GetAnswer, request, handler, context);
        }
 
        virtual Model::GetConsolidatedReportOutcome GetConsolidatedReport(const Model::GetConsolidatedReportRequest& request) const;
 
        template<typename GetConsolidatedReportRequestT = Model::GetConsolidatedReportRequest>
        Model::GetConsolidatedReportOutcomeCallable GetConsolidatedReportCallable(const GetConsolidatedReportRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::GetConsolidatedReport, request);
        }
 
        template<typename GetConsolidatedReportRequestT = Model::GetConsolidatedReportRequest>
        void GetConsolidatedReportAsync(const GetConsolidatedReportRequestT& request, const GetConsolidatedReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::GetConsolidatedReport, request, handler, context);
        }
 
        virtual Model::GetGlobalSettingsOutcome GetGlobalSettings(const Model::GetGlobalSettingsRequest& request = {}) const;
 
        template<typename GetGlobalSettingsRequestT = Model::GetGlobalSettingsRequest>
        Model::GetGlobalSettingsOutcomeCallable GetGlobalSettingsCallable(const GetGlobalSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&WellArchitectedClient::GetGlobalSettings, request);
        }
 
        template<typename GetGlobalSettingsRequestT = Model::GetGlobalSettingsRequest>
        void GetGlobalSettingsAsync(const GetGlobalSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetGlobalSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&WellArchitectedClient::GetGlobalSettings, request, handler, context);
        }
 
        virtual Model::GetLensOutcome GetLens(const Model::GetLensRequest& request) const;
 
        template<typename GetLensRequestT = Model::GetLensRequest>
        Model::GetLensOutcomeCallable GetLensCallable(const GetLensRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::GetLens, request);
        }
 
        template<typename GetLensRequestT = Model::GetLensRequest>
        void GetLensAsync(const GetLensRequestT& request, const GetLensResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::GetLens, request, handler, context);
        }
 
        virtual Model::GetLensReviewOutcome GetLensReview(const Model::GetLensReviewRequest& request) const;
 
        template<typename GetLensReviewRequestT = Model::GetLensReviewRequest>
        Model::GetLensReviewOutcomeCallable GetLensReviewCallable(const GetLensReviewRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::GetLensReview, request);
        }
 
        template<typename GetLensReviewRequestT = Model::GetLensReviewRequest>
        void GetLensReviewAsync(const GetLensReviewRequestT& request, const GetLensReviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::GetLensReview, request, handler, context);
        }
 
        virtual Model::GetLensReviewReportOutcome GetLensReviewReport(const Model::GetLensReviewReportRequest& request) const;
 
        template<typename GetLensReviewReportRequestT = Model::GetLensReviewReportRequest>
        Model::GetLensReviewReportOutcomeCallable GetLensReviewReportCallable(const GetLensReviewReportRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::GetLensReviewReport, request);
        }
 
        template<typename GetLensReviewReportRequestT = Model::GetLensReviewReportRequest>
        void GetLensReviewReportAsync(const GetLensReviewReportRequestT& request, const GetLensReviewReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::GetLensReviewReport, request, handler, context);
        }
 
        virtual Model::GetLensVersionDifferenceOutcome GetLensVersionDifference(const Model::GetLensVersionDifferenceRequest& request) const;
 
        template<typename GetLensVersionDifferenceRequestT = Model::GetLensVersionDifferenceRequest>
        Model::GetLensVersionDifferenceOutcomeCallable GetLensVersionDifferenceCallable(const GetLensVersionDifferenceRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::GetLensVersionDifference, request);
        }
 
        template<typename GetLensVersionDifferenceRequestT = Model::GetLensVersionDifferenceRequest>
        void GetLensVersionDifferenceAsync(const GetLensVersionDifferenceRequestT& request, const GetLensVersionDifferenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::GetLensVersionDifference, request, handler, context);
        }
 
        virtual Model::GetMilestoneOutcome GetMilestone(const Model::GetMilestoneRequest& request) const;
 
        template<typename GetMilestoneRequestT = Model::GetMilestoneRequest>
        Model::GetMilestoneOutcomeCallable GetMilestoneCallable(const GetMilestoneRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::GetMilestone, request);
        }
 
        template<typename GetMilestoneRequestT = Model::GetMilestoneRequest>
        void GetMilestoneAsync(const GetMilestoneRequestT& request, const GetMilestoneResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::GetMilestone, request, handler, context);
        }
 
        virtual Model::GetProfileOutcome GetProfile(const Model::GetProfileRequest& request) const;
 
        template<typename GetProfileRequestT = Model::GetProfileRequest>
        Model::GetProfileOutcomeCallable GetProfileCallable(const GetProfileRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::GetProfile, request);
        }
 
        template<typename GetProfileRequestT = Model::GetProfileRequest>
        void GetProfileAsync(const GetProfileRequestT& request, const GetProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::GetProfile, request, handler, context);
        }
 
        virtual Model::GetProfileTemplateOutcome GetProfileTemplate(const Model::GetProfileTemplateRequest& request = {}) const;
 
        template<typename GetProfileTemplateRequestT = Model::GetProfileTemplateRequest>
        Model::GetProfileTemplateOutcomeCallable GetProfileTemplateCallable(const GetProfileTemplateRequestT& request = {}) const
        {
            return SubmitCallable(&WellArchitectedClient::GetProfileTemplate, request);
        }
 
        template<typename GetProfileTemplateRequestT = Model::GetProfileTemplateRequest>
        void GetProfileTemplateAsync(const GetProfileTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetProfileTemplateRequestT& request = {}) const
        {
            return SubmitAsync(&WellArchitectedClient::GetProfileTemplate, request, handler, context);
        }
 
        virtual Model::GetReviewTemplateOutcome GetReviewTemplate(const Model::GetReviewTemplateRequest& request) const;
 
        template<typename GetReviewTemplateRequestT = Model::GetReviewTemplateRequest>
        Model::GetReviewTemplateOutcomeCallable GetReviewTemplateCallable(const GetReviewTemplateRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::GetReviewTemplate, request);
        }
 
        template<typename GetReviewTemplateRequestT = Model::GetReviewTemplateRequest>
        void GetReviewTemplateAsync(const GetReviewTemplateRequestT& request, const GetReviewTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::GetReviewTemplate, request, handler, context);
        }
 
        virtual Model::GetReviewTemplateAnswerOutcome GetReviewTemplateAnswer(const Model::GetReviewTemplateAnswerRequest& request) const;
 
        template<typename GetReviewTemplateAnswerRequestT = Model::GetReviewTemplateAnswerRequest>
        Model::GetReviewTemplateAnswerOutcomeCallable GetReviewTemplateAnswerCallable(const GetReviewTemplateAnswerRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::GetReviewTemplateAnswer, request);
        }
 
        template<typename GetReviewTemplateAnswerRequestT = Model::GetReviewTemplateAnswerRequest>
        void GetReviewTemplateAnswerAsync(const GetReviewTemplateAnswerRequestT& request, const GetReviewTemplateAnswerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::GetReviewTemplateAnswer, request, handler, context);
        }
 
        virtual Model::GetReviewTemplateLensReviewOutcome GetReviewTemplateLensReview(const Model::GetReviewTemplateLensReviewRequest& request) const;
 
        template<typename GetReviewTemplateLensReviewRequestT = Model::GetReviewTemplateLensReviewRequest>
        Model::GetReviewTemplateLensReviewOutcomeCallable GetReviewTemplateLensReviewCallable(const GetReviewTemplateLensReviewRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::GetReviewTemplateLensReview, request);
        }
 
        template<typename GetReviewTemplateLensReviewRequestT = Model::GetReviewTemplateLensReviewRequest>
        void GetReviewTemplateLensReviewAsync(const GetReviewTemplateLensReviewRequestT& request, const GetReviewTemplateLensReviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::GetReviewTemplateLensReview, request, handler, context);
        }
 
        virtual Model::GetWorkloadOutcome GetWorkload(const Model::GetWorkloadRequest& request) const;
 
        template<typename GetWorkloadRequestT = Model::GetWorkloadRequest>
        Model::GetWorkloadOutcomeCallable GetWorkloadCallable(const GetWorkloadRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::GetWorkload, request);
        }
 
        template<typename GetWorkloadRequestT = Model::GetWorkloadRequest>
        void GetWorkloadAsync(const GetWorkloadRequestT& request, const GetWorkloadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::GetWorkload, request, handler, context);
        }
 
        virtual Model::ImportLensOutcome ImportLens(const Model::ImportLensRequest& request) const;
 
        template<typename ImportLensRequestT = Model::ImportLensRequest>
        Model::ImportLensOutcomeCallable ImportLensCallable(const ImportLensRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::ImportLens, request);
        }
 
        template<typename ImportLensRequestT = Model::ImportLensRequest>
        void ImportLensAsync(const ImportLensRequestT& request, const ImportLensResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::ImportLens, request, handler, context);
        }
 
        virtual Model::ListAnswersOutcome ListAnswers(const Model::ListAnswersRequest& request) const;
 
        template<typename ListAnswersRequestT = Model::ListAnswersRequest>
        Model::ListAnswersOutcomeCallable ListAnswersCallable(const ListAnswersRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::ListAnswers, request);
        }
 
        template<typename ListAnswersRequestT = Model::ListAnswersRequest>
        void ListAnswersAsync(const ListAnswersRequestT& request, const ListAnswersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::ListAnswers, request, handler, context);
        }
 
        virtual Model::ListCheckDetailsOutcome ListCheckDetails(const Model::ListCheckDetailsRequest& request) const;
 
        template<typename ListCheckDetailsRequestT = Model::ListCheckDetailsRequest>
        Model::ListCheckDetailsOutcomeCallable ListCheckDetailsCallable(const ListCheckDetailsRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::ListCheckDetails, request);
        }
 
        template<typename ListCheckDetailsRequestT = Model::ListCheckDetailsRequest>
        void ListCheckDetailsAsync(const ListCheckDetailsRequestT& request, const ListCheckDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::ListCheckDetails, request, handler, context);
        }
 
        virtual Model::ListCheckSummariesOutcome ListCheckSummaries(const Model::ListCheckSummariesRequest& request) const;
 
        template<typename ListCheckSummariesRequestT = Model::ListCheckSummariesRequest>
        Model::ListCheckSummariesOutcomeCallable ListCheckSummariesCallable(const ListCheckSummariesRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::ListCheckSummaries, request);
        }
 
        template<typename ListCheckSummariesRequestT = Model::ListCheckSummariesRequest>
        void ListCheckSummariesAsync(const ListCheckSummariesRequestT& request, const ListCheckSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::ListCheckSummaries, request, handler, context);
        }
 
        virtual Model::ListLensReviewImprovementsOutcome ListLensReviewImprovements(const Model::ListLensReviewImprovementsRequest& request) const;
 
        template<typename ListLensReviewImprovementsRequestT = Model::ListLensReviewImprovementsRequest>
        Model::ListLensReviewImprovementsOutcomeCallable ListLensReviewImprovementsCallable(const ListLensReviewImprovementsRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::ListLensReviewImprovements, request);
        }
 
        template<typename ListLensReviewImprovementsRequestT = Model::ListLensReviewImprovementsRequest>
        void ListLensReviewImprovementsAsync(const ListLensReviewImprovementsRequestT& request, const ListLensReviewImprovementsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::ListLensReviewImprovements, request, handler, context);
        }
 
        virtual Model::ListLensReviewsOutcome ListLensReviews(const Model::ListLensReviewsRequest& request) const;
 
        template<typename ListLensReviewsRequestT = Model::ListLensReviewsRequest>
        Model::ListLensReviewsOutcomeCallable ListLensReviewsCallable(const ListLensReviewsRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::ListLensReviews, request);
        }
 
        template<typename ListLensReviewsRequestT = Model::ListLensReviewsRequest>
        void ListLensReviewsAsync(const ListLensReviewsRequestT& request, const ListLensReviewsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::ListLensReviews, request, handler, context);
        }
 
        virtual Model::ListLensSharesOutcome ListLensShares(const Model::ListLensSharesRequest& request) const;
 
        template<typename ListLensSharesRequestT = Model::ListLensSharesRequest>
        Model::ListLensSharesOutcomeCallable ListLensSharesCallable(const ListLensSharesRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::ListLensShares, request);
        }
 
        template<typename ListLensSharesRequestT = Model::ListLensSharesRequest>
        void ListLensSharesAsync(const ListLensSharesRequestT& request, const ListLensSharesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::ListLensShares, request, handler, context);
        }
 
        virtual Model::ListLensesOutcome ListLenses(const Model::ListLensesRequest& request = {}) const;
 
        template<typename ListLensesRequestT = Model::ListLensesRequest>
        Model::ListLensesOutcomeCallable ListLensesCallable(const ListLensesRequestT& request = {}) const
        {
            return SubmitCallable(&WellArchitectedClient::ListLenses, request);
        }
 
        template<typename ListLensesRequestT = Model::ListLensesRequest>
        void ListLensesAsync(const ListLensesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLensesRequestT& request = {}) const
        {
            return SubmitAsync(&WellArchitectedClient::ListLenses, request, handler, context);
        }
 
        virtual Model::ListMilestonesOutcome ListMilestones(const Model::ListMilestonesRequest& request) const;
 
        template<typename ListMilestonesRequestT = Model::ListMilestonesRequest>
        Model::ListMilestonesOutcomeCallable ListMilestonesCallable(const ListMilestonesRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::ListMilestones, request);
        }
 
        template<typename ListMilestonesRequestT = Model::ListMilestonesRequest>
        void ListMilestonesAsync(const ListMilestonesRequestT& request, const ListMilestonesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::ListMilestones, request, handler, context);
        }
 
        virtual Model::ListNotificationsOutcome ListNotifications(const Model::ListNotificationsRequest& request = {}) const;
 
        template<typename ListNotificationsRequestT = Model::ListNotificationsRequest>
        Model::ListNotificationsOutcomeCallable ListNotificationsCallable(const ListNotificationsRequestT& request = {}) const
        {
            return SubmitCallable(&WellArchitectedClient::ListNotifications, request);
        }
 
        template<typename ListNotificationsRequestT = Model::ListNotificationsRequest>
        void ListNotificationsAsync(const ListNotificationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListNotificationsRequestT& request = {}) const
        {
            return SubmitAsync(&WellArchitectedClient::ListNotifications, request, handler, context);
        }
 
        virtual Model::ListProfileNotificationsOutcome ListProfileNotifications(const Model::ListProfileNotificationsRequest& request = {}) const;
 
        template<typename ListProfileNotificationsRequestT = Model::ListProfileNotificationsRequest>
        Model::ListProfileNotificationsOutcomeCallable ListProfileNotificationsCallable(const ListProfileNotificationsRequestT& request = {}) const
        {
            return SubmitCallable(&WellArchitectedClient::ListProfileNotifications, request);
        }
 
        template<typename ListProfileNotificationsRequestT = Model::ListProfileNotificationsRequest>
        void ListProfileNotificationsAsync(const ListProfileNotificationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProfileNotificationsRequestT& request = {}) const
        {
            return SubmitAsync(&WellArchitectedClient::ListProfileNotifications, request, handler, context);
        }
 
        virtual Model::ListProfileSharesOutcome ListProfileShares(const Model::ListProfileSharesRequest& request) const;
 
        template<typename ListProfileSharesRequestT = Model::ListProfileSharesRequest>
        Model::ListProfileSharesOutcomeCallable ListProfileSharesCallable(const ListProfileSharesRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::ListProfileShares, request);
        }
 
        template<typename ListProfileSharesRequestT = Model::ListProfileSharesRequest>
        void ListProfileSharesAsync(const ListProfileSharesRequestT& request, const ListProfileSharesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::ListProfileShares, request, handler, context);
        }
 
        virtual Model::ListProfilesOutcome ListProfiles(const Model::ListProfilesRequest& request = {}) const;
 
        template<typename ListProfilesRequestT = Model::ListProfilesRequest>
        Model::ListProfilesOutcomeCallable ListProfilesCallable(const ListProfilesRequestT& request = {}) const
        {
            return SubmitCallable(&WellArchitectedClient::ListProfiles, request);
        }
 
        template<typename ListProfilesRequestT = Model::ListProfilesRequest>
        void ListProfilesAsync(const ListProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProfilesRequestT& request = {}) const
        {
            return SubmitAsync(&WellArchitectedClient::ListProfiles, request, handler, context);
        }
 
        virtual Model::ListReviewTemplateAnswersOutcome ListReviewTemplateAnswers(const Model::ListReviewTemplateAnswersRequest& request) const;
 
        template<typename ListReviewTemplateAnswersRequestT = Model::ListReviewTemplateAnswersRequest>
        Model::ListReviewTemplateAnswersOutcomeCallable ListReviewTemplateAnswersCallable(const ListReviewTemplateAnswersRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::ListReviewTemplateAnswers, request);
        }
 
        template<typename ListReviewTemplateAnswersRequestT = Model::ListReviewTemplateAnswersRequest>
        void ListReviewTemplateAnswersAsync(const ListReviewTemplateAnswersRequestT& request, const ListReviewTemplateAnswersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::ListReviewTemplateAnswers, request, handler, context);
        }
 
        virtual Model::ListReviewTemplatesOutcome ListReviewTemplates(const Model::ListReviewTemplatesRequest& request = {}) const;
 
        template<typename ListReviewTemplatesRequestT = Model::ListReviewTemplatesRequest>
        Model::ListReviewTemplatesOutcomeCallable ListReviewTemplatesCallable(const ListReviewTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&WellArchitectedClient::ListReviewTemplates, request);
        }
 
        template<typename ListReviewTemplatesRequestT = Model::ListReviewTemplatesRequest>
        void ListReviewTemplatesAsync(const ListReviewTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListReviewTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&WellArchitectedClient::ListReviewTemplates, request, handler, context);
        }
 
        virtual Model::ListShareInvitationsOutcome ListShareInvitations(const Model::ListShareInvitationsRequest& request = {}) const;
 
        template<typename ListShareInvitationsRequestT = Model::ListShareInvitationsRequest>
        Model::ListShareInvitationsOutcomeCallable ListShareInvitationsCallable(const ListShareInvitationsRequestT& request = {}) const
        {
            return SubmitCallable(&WellArchitectedClient::ListShareInvitations, request);
        }
 
        template<typename ListShareInvitationsRequestT = Model::ListShareInvitationsRequest>
        void ListShareInvitationsAsync(const ListShareInvitationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListShareInvitationsRequestT& request = {}) const
        {
            return SubmitAsync(&WellArchitectedClient::ListShareInvitations, 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(&WellArchitectedClient::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(&WellArchitectedClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTemplateSharesOutcome ListTemplateShares(const Model::ListTemplateSharesRequest& request) const;
 
        template<typename ListTemplateSharesRequestT = Model::ListTemplateSharesRequest>
        Model::ListTemplateSharesOutcomeCallable ListTemplateSharesCallable(const ListTemplateSharesRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::ListTemplateShares, request);
        }
 
        template<typename ListTemplateSharesRequestT = Model::ListTemplateSharesRequest>
        void ListTemplateSharesAsync(const ListTemplateSharesRequestT& request, const ListTemplateSharesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::ListTemplateShares, request, handler, context);
        }
 
        virtual Model::ListWorkloadSharesOutcome ListWorkloadShares(const Model::ListWorkloadSharesRequest& request) const;
 
        template<typename ListWorkloadSharesRequestT = Model::ListWorkloadSharesRequest>
        Model::ListWorkloadSharesOutcomeCallable ListWorkloadSharesCallable(const ListWorkloadSharesRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::ListWorkloadShares, request);
        }
 
        template<typename ListWorkloadSharesRequestT = Model::ListWorkloadSharesRequest>
        void ListWorkloadSharesAsync(const ListWorkloadSharesRequestT& request, const ListWorkloadSharesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::ListWorkloadShares, request, handler, context);
        }
 
        virtual Model::ListWorkloadsOutcome ListWorkloads(const Model::ListWorkloadsRequest& request = {}) const;
 
        template<typename ListWorkloadsRequestT = Model::ListWorkloadsRequest>
        Model::ListWorkloadsOutcomeCallable ListWorkloadsCallable(const ListWorkloadsRequestT& request = {}) const
        {
            return SubmitCallable(&WellArchitectedClient::ListWorkloads, request);
        }
 
        template<typename ListWorkloadsRequestT = Model::ListWorkloadsRequest>
        void ListWorkloadsAsync(const ListWorkloadsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWorkloadsRequestT& request = {}) const
        {
            return SubmitAsync(&WellArchitectedClient::ListWorkloads, 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(&WellArchitectedClient::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(&WellArchitectedClient::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(&WellArchitectedClient::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(&WellArchitectedClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAnswerOutcome UpdateAnswer(const Model::UpdateAnswerRequest& request) const;
 
        template<typename UpdateAnswerRequestT = Model::UpdateAnswerRequest>
        Model::UpdateAnswerOutcomeCallable UpdateAnswerCallable(const UpdateAnswerRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::UpdateAnswer, request);
        }
 
        template<typename UpdateAnswerRequestT = Model::UpdateAnswerRequest>
        void UpdateAnswerAsync(const UpdateAnswerRequestT& request, const UpdateAnswerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::UpdateAnswer, request, handler, context);
        }
 
        virtual Model::UpdateGlobalSettingsOutcome UpdateGlobalSettings(const Model::UpdateGlobalSettingsRequest& request = {}) const;
 
        template<typename UpdateGlobalSettingsRequestT = Model::UpdateGlobalSettingsRequest>
        Model::UpdateGlobalSettingsOutcomeCallable UpdateGlobalSettingsCallable(const UpdateGlobalSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&WellArchitectedClient::UpdateGlobalSettings, request);
        }
 
        template<typename UpdateGlobalSettingsRequestT = Model::UpdateGlobalSettingsRequest>
        void UpdateGlobalSettingsAsync(const UpdateGlobalSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateGlobalSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&WellArchitectedClient::UpdateGlobalSettings, request, handler, context);
        }
 
        virtual Model::UpdateIntegrationOutcome UpdateIntegration(const Model::UpdateIntegrationRequest& request) const;
 
        template<typename UpdateIntegrationRequestT = Model::UpdateIntegrationRequest>
        Model::UpdateIntegrationOutcomeCallable UpdateIntegrationCallable(const UpdateIntegrationRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::UpdateIntegration, request);
        }
 
        template<typename UpdateIntegrationRequestT = Model::UpdateIntegrationRequest>
        void UpdateIntegrationAsync(const UpdateIntegrationRequestT& request, const UpdateIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::UpdateIntegration, request, handler, context);
        }
 
        virtual Model::UpdateLensReviewOutcome UpdateLensReview(const Model::UpdateLensReviewRequest& request) const;
 
        template<typename UpdateLensReviewRequestT = Model::UpdateLensReviewRequest>
        Model::UpdateLensReviewOutcomeCallable UpdateLensReviewCallable(const UpdateLensReviewRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::UpdateLensReview, request);
        }
 
        template<typename UpdateLensReviewRequestT = Model::UpdateLensReviewRequest>
        void UpdateLensReviewAsync(const UpdateLensReviewRequestT& request, const UpdateLensReviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::UpdateLensReview, request, handler, context);
        }
 
        virtual Model::UpdateProfileOutcome UpdateProfile(const Model::UpdateProfileRequest& request) const;
 
        template<typename UpdateProfileRequestT = Model::UpdateProfileRequest>
        Model::UpdateProfileOutcomeCallable UpdateProfileCallable(const UpdateProfileRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::UpdateProfile, request);
        }
 
        template<typename UpdateProfileRequestT = Model::UpdateProfileRequest>
        void UpdateProfileAsync(const UpdateProfileRequestT& request, const UpdateProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::UpdateProfile, request, handler, context);
        }
 
        virtual Model::UpdateReviewTemplateOutcome UpdateReviewTemplate(const Model::UpdateReviewTemplateRequest& request) const;
 
        template<typename UpdateReviewTemplateRequestT = Model::UpdateReviewTemplateRequest>
        Model::UpdateReviewTemplateOutcomeCallable UpdateReviewTemplateCallable(const UpdateReviewTemplateRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::UpdateReviewTemplate, request);
        }
 
        template<typename UpdateReviewTemplateRequestT = Model::UpdateReviewTemplateRequest>
        void UpdateReviewTemplateAsync(const UpdateReviewTemplateRequestT& request, const UpdateReviewTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::UpdateReviewTemplate, request, handler, context);
        }
 
        virtual Model::UpdateReviewTemplateAnswerOutcome UpdateReviewTemplateAnswer(const Model::UpdateReviewTemplateAnswerRequest& request) const;
 
        template<typename UpdateReviewTemplateAnswerRequestT = Model::UpdateReviewTemplateAnswerRequest>
        Model::UpdateReviewTemplateAnswerOutcomeCallable UpdateReviewTemplateAnswerCallable(const UpdateReviewTemplateAnswerRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::UpdateReviewTemplateAnswer, request);
        }
 
        template<typename UpdateReviewTemplateAnswerRequestT = Model::UpdateReviewTemplateAnswerRequest>
        void UpdateReviewTemplateAnswerAsync(const UpdateReviewTemplateAnswerRequestT& request, const UpdateReviewTemplateAnswerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::UpdateReviewTemplateAnswer, request, handler, context);
        }
 
        virtual Model::UpdateReviewTemplateLensReviewOutcome UpdateReviewTemplateLensReview(const Model::UpdateReviewTemplateLensReviewRequest& request) const;
 
        template<typename UpdateReviewTemplateLensReviewRequestT = Model::UpdateReviewTemplateLensReviewRequest>
        Model::UpdateReviewTemplateLensReviewOutcomeCallable UpdateReviewTemplateLensReviewCallable(const UpdateReviewTemplateLensReviewRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::UpdateReviewTemplateLensReview, request);
        }
 
        template<typename UpdateReviewTemplateLensReviewRequestT = Model::UpdateReviewTemplateLensReviewRequest>
        void UpdateReviewTemplateLensReviewAsync(const UpdateReviewTemplateLensReviewRequestT& request, const UpdateReviewTemplateLensReviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::UpdateReviewTemplateLensReview, request, handler, context);
        }
 
        virtual Model::UpdateShareInvitationOutcome UpdateShareInvitation(const Model::UpdateShareInvitationRequest& request) const;
 
        template<typename UpdateShareInvitationRequestT = Model::UpdateShareInvitationRequest>
        Model::UpdateShareInvitationOutcomeCallable UpdateShareInvitationCallable(const UpdateShareInvitationRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::UpdateShareInvitation, request);
        }
 
        template<typename UpdateShareInvitationRequestT = Model::UpdateShareInvitationRequest>
        void UpdateShareInvitationAsync(const UpdateShareInvitationRequestT& request, const UpdateShareInvitationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::UpdateShareInvitation, request, handler, context);
        }
 
        virtual Model::UpdateWorkloadOutcome UpdateWorkload(const Model::UpdateWorkloadRequest& request) const;
 
        template<typename UpdateWorkloadRequestT = Model::UpdateWorkloadRequest>
        Model::UpdateWorkloadOutcomeCallable UpdateWorkloadCallable(const UpdateWorkloadRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::UpdateWorkload, request);
        }
 
        template<typename UpdateWorkloadRequestT = Model::UpdateWorkloadRequest>
        void UpdateWorkloadAsync(const UpdateWorkloadRequestT& request, const UpdateWorkloadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::UpdateWorkload, request, handler, context);
        }
 
        virtual Model::UpdateWorkloadShareOutcome UpdateWorkloadShare(const Model::UpdateWorkloadShareRequest& request) const;
 
        template<typename UpdateWorkloadShareRequestT = Model::UpdateWorkloadShareRequest>
        Model::UpdateWorkloadShareOutcomeCallable UpdateWorkloadShareCallable(const UpdateWorkloadShareRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::UpdateWorkloadShare, request);
        }
 
        template<typename UpdateWorkloadShareRequestT = Model::UpdateWorkloadShareRequest>
        void UpdateWorkloadShareAsync(const UpdateWorkloadShareRequestT& request, const UpdateWorkloadShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::UpdateWorkloadShare, request, handler, context);
        }
 
        virtual Model::UpgradeLensReviewOutcome UpgradeLensReview(const Model::UpgradeLensReviewRequest& request) const;
 
        template<typename UpgradeLensReviewRequestT = Model::UpgradeLensReviewRequest>
        Model::UpgradeLensReviewOutcomeCallable UpgradeLensReviewCallable(const UpgradeLensReviewRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::UpgradeLensReview, request);
        }
 
        template<typename UpgradeLensReviewRequestT = Model::UpgradeLensReviewRequest>
        void UpgradeLensReviewAsync(const UpgradeLensReviewRequestT& request, const UpgradeLensReviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::UpgradeLensReview, request, handler, context);
        }
 
        virtual Model::UpgradeProfileVersionOutcome UpgradeProfileVersion(const Model::UpgradeProfileVersionRequest& request) const;
 
        template<typename UpgradeProfileVersionRequestT = Model::UpgradeProfileVersionRequest>
        Model::UpgradeProfileVersionOutcomeCallable UpgradeProfileVersionCallable(const UpgradeProfileVersionRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::UpgradeProfileVersion, request);
        }
 
        template<typename UpgradeProfileVersionRequestT = Model::UpgradeProfileVersionRequest>
        void UpgradeProfileVersionAsync(const UpgradeProfileVersionRequestT& request, const UpgradeProfileVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::UpgradeProfileVersion, request, handler, context);
        }
 
        virtual Model::UpgradeReviewTemplateLensReviewOutcome UpgradeReviewTemplateLensReview(const Model::UpgradeReviewTemplateLensReviewRequest& request) const;
 
        template<typename UpgradeReviewTemplateLensReviewRequestT = Model::UpgradeReviewTemplateLensReviewRequest>
        Model::UpgradeReviewTemplateLensReviewOutcomeCallable UpgradeReviewTemplateLensReviewCallable(const UpgradeReviewTemplateLensReviewRequestT& request) const
        {
            return SubmitCallable(&WellArchitectedClient::UpgradeReviewTemplateLensReview, request);
        }
 
        template<typename UpgradeReviewTemplateLensReviewRequestT = Model::UpgradeReviewTemplateLensReviewRequest>
        void UpgradeReviewTemplateLensReviewAsync(const UpgradeReviewTemplateLensReviewRequestT& request, const UpgradeReviewTemplateLensReviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WellArchitectedClient::UpgradeReviewTemplateLensReview, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<WellArchitectedEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<WellArchitectedClient>;
      void init(const WellArchitectedClientConfiguration& clientConfiguration);
 
      WellArchitectedClientConfiguration m_clientConfiguration;
      std::shared_ptr<WellArchitectedEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace WellArchitected
} // namespace Aws