WellArchitectedClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/wellarchitected/WellArchitectedServiceClientModel.h>
#include <aws/wellarchitected/WellArchitected_EXPORTS.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