QuickSightClient.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/quicksight/QuickSightPaginationBase.h>
#include <aws/quicksight/QuickSightServiceClientModel.h>
#include <aws/quicksight/QuickSightWaiter.h>
#include <aws/quicksight/QuickSight_EXPORTS.h>
 
namespace Aws {
namespace QuickSight {
class AWS_QUICKSIGHT_API QuickSightClient : public Aws::Client::AWSJsonClient,
                                            public Aws::Client::ClientWithAsyncTemplateMethods<QuickSightClient>,
                                            public QuickSightPaginationBase<QuickSightClient>,
                                            public QuickSightWaiter<QuickSightClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef QuickSightClientConfiguration ClientConfigurationType;
  typedef QuickSightEndpointProvider EndpointProviderType;
 
  QuickSightClient(
      const Aws::QuickSight::QuickSightClientConfiguration& clientConfiguration = Aws::QuickSight::QuickSightClientConfiguration(),
      std::shared_ptr<QuickSightEndpointProviderBase> endpointProvider = nullptr);
 
  QuickSightClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<QuickSightEndpointProviderBase> endpointProvider = nullptr,
      const Aws::QuickSight::QuickSightClientConfiguration& clientConfiguration = Aws::QuickSight::QuickSightClientConfiguration());
 
  QuickSightClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<QuickSightEndpointProviderBase> endpointProvider = nullptr,
      const Aws::QuickSight::QuickSightClientConfiguration& clientConfiguration = Aws::QuickSight::QuickSightClientConfiguration());
 
  /* Legacy constructors due deprecation */
  QuickSightClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  QuickSightClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  QuickSightClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~QuickSightClient();
 
  virtual Model::BatchCreateTopicReviewedAnswerOutcome BatchCreateTopicReviewedAnswer(
      const Model::BatchCreateTopicReviewedAnswerRequest& request) const;
 
  template <typename BatchCreateTopicReviewedAnswerRequestT = Model::BatchCreateTopicReviewedAnswerRequest>
  Model::BatchCreateTopicReviewedAnswerOutcomeCallable BatchCreateTopicReviewedAnswerCallable(
      const BatchCreateTopicReviewedAnswerRequestT& request) const {
    return SubmitCallable(&QuickSightClient::BatchCreateTopicReviewedAnswer, request);
  }
 
  template <typename BatchCreateTopicReviewedAnswerRequestT = Model::BatchCreateTopicReviewedAnswerRequest>
  void BatchCreateTopicReviewedAnswerAsync(const BatchCreateTopicReviewedAnswerRequestT& request,
                                           const BatchCreateTopicReviewedAnswerResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::BatchCreateTopicReviewedAnswer, request, handler, context);
  }
 
  virtual Model::BatchDeleteKnowledgeBaseOutcome BatchDeleteKnowledgeBase(const Model::BatchDeleteKnowledgeBaseRequest& request) const;
 
  template <typename BatchDeleteKnowledgeBaseRequestT = Model::BatchDeleteKnowledgeBaseRequest>
  Model::BatchDeleteKnowledgeBaseOutcomeCallable BatchDeleteKnowledgeBaseCallable(const BatchDeleteKnowledgeBaseRequestT& request) const {
    return SubmitCallable(&QuickSightClient::BatchDeleteKnowledgeBase, request);
  }
 
  template <typename BatchDeleteKnowledgeBaseRequestT = Model::BatchDeleteKnowledgeBaseRequest>
  void BatchDeleteKnowledgeBaseAsync(const BatchDeleteKnowledgeBaseRequestT& request,
                                     const BatchDeleteKnowledgeBaseResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::BatchDeleteKnowledgeBase, request, handler, context);
  }
 
  virtual Model::BatchDeleteTopicReviewedAnswerOutcome BatchDeleteTopicReviewedAnswer(
      const Model::BatchDeleteTopicReviewedAnswerRequest& request) const;
 
  template <typename BatchDeleteTopicReviewedAnswerRequestT = Model::BatchDeleteTopicReviewedAnswerRequest>
  Model::BatchDeleteTopicReviewedAnswerOutcomeCallable BatchDeleteTopicReviewedAnswerCallable(
      const BatchDeleteTopicReviewedAnswerRequestT& request) const {
    return SubmitCallable(&QuickSightClient::BatchDeleteTopicReviewedAnswer, request);
  }
 
  template <typename BatchDeleteTopicReviewedAnswerRequestT = Model::BatchDeleteTopicReviewedAnswerRequest>
  void BatchDeleteTopicReviewedAnswerAsync(const BatchDeleteTopicReviewedAnswerRequestT& request,
                                           const BatchDeleteTopicReviewedAnswerResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::BatchDeleteTopicReviewedAnswer, request, handler, context);
  }
 
  virtual Model::CancelIngestionOutcome CancelIngestion(const Model::CancelIngestionRequest& request) const;
 
  template <typename CancelIngestionRequestT = Model::CancelIngestionRequest>
  Model::CancelIngestionOutcomeCallable CancelIngestionCallable(const CancelIngestionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CancelIngestion, request);
  }
 
  template <typename CancelIngestionRequestT = Model::CancelIngestionRequest>
  void CancelIngestionAsync(const CancelIngestionRequestT& request, const CancelIngestionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CancelIngestion, request, handler, context);
  }
 
  virtual Model::CreateAccountCustomizationOutcome CreateAccountCustomization(
      const Model::CreateAccountCustomizationRequest& request) const;
 
  template <typename CreateAccountCustomizationRequestT = Model::CreateAccountCustomizationRequest>
  Model::CreateAccountCustomizationOutcomeCallable CreateAccountCustomizationCallable(
      const CreateAccountCustomizationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateAccountCustomization, request);
  }
 
  template <typename CreateAccountCustomizationRequestT = Model::CreateAccountCustomizationRequest>
  void CreateAccountCustomizationAsync(const CreateAccountCustomizationRequestT& request,
                                       const CreateAccountCustomizationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateAccountCustomization, request, handler, context);
  }
 
  virtual Model::CreateAccountSubscriptionOutcome CreateAccountSubscription(const Model::CreateAccountSubscriptionRequest& request) const;
 
  template <typename CreateAccountSubscriptionRequestT = Model::CreateAccountSubscriptionRequest>
  Model::CreateAccountSubscriptionOutcomeCallable CreateAccountSubscriptionCallable(
      const CreateAccountSubscriptionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateAccountSubscription, request);
  }
 
  template <typename CreateAccountSubscriptionRequestT = Model::CreateAccountSubscriptionRequest>
  void CreateAccountSubscriptionAsync(const CreateAccountSubscriptionRequestT& request,
                                      const CreateAccountSubscriptionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateAccountSubscription, request, handler, context);
  }
 
  virtual Model::CreateActionConnectorOutcome CreateActionConnector(const Model::CreateActionConnectorRequest& request) const;
 
  template <typename CreateActionConnectorRequestT = Model::CreateActionConnectorRequest>
  Model::CreateActionConnectorOutcomeCallable CreateActionConnectorCallable(const CreateActionConnectorRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateActionConnector, request);
  }
 
  template <typename CreateActionConnectorRequestT = Model::CreateActionConnectorRequest>
  void CreateActionConnectorAsync(const CreateActionConnectorRequestT& request, const CreateActionConnectorResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateActionConnector, request, handler, context);
  }
 
  virtual Model::CreateAgentOutcome CreateAgent(const Model::CreateAgentRequest& request) const;
 
  template <typename CreateAgentRequestT = Model::CreateAgentRequest>
  Model::CreateAgentOutcomeCallable CreateAgentCallable(const CreateAgentRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateAgent, request);
  }
 
  template <typename CreateAgentRequestT = Model::CreateAgentRequest>
  void CreateAgentAsync(const CreateAgentRequestT& request, const CreateAgentResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateAgent, request, handler, context);
  }
 
  virtual Model::CreateAnalysisOutcome CreateAnalysis(const Model::CreateAnalysisRequest& request) const;
 
  template <typename CreateAnalysisRequestT = Model::CreateAnalysisRequest>
  Model::CreateAnalysisOutcomeCallable CreateAnalysisCallable(const CreateAnalysisRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateAnalysis, request);
  }
 
  template <typename CreateAnalysisRequestT = Model::CreateAnalysisRequest>
  void CreateAnalysisAsync(const CreateAnalysisRequestT& request, const CreateAnalysisResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateAnalysis, request, handler, context);
  }
 
  virtual Model::CreateBrandOutcome CreateBrand(const Model::CreateBrandRequest& request) const;
 
  template <typename CreateBrandRequestT = Model::CreateBrandRequest>
  Model::CreateBrandOutcomeCallable CreateBrandCallable(const CreateBrandRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateBrand, request);
  }
 
  template <typename CreateBrandRequestT = Model::CreateBrandRequest>
  void CreateBrandAsync(const CreateBrandRequestT& request, const CreateBrandResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateBrand, request, handler, context);
  }
 
  virtual Model::CreateCustomPermissionsOutcome CreateCustomPermissions(const Model::CreateCustomPermissionsRequest& request) const;
 
  template <typename CreateCustomPermissionsRequestT = Model::CreateCustomPermissionsRequest>
  Model::CreateCustomPermissionsOutcomeCallable CreateCustomPermissionsCallable(const CreateCustomPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateCustomPermissions, request);
  }
 
  template <typename CreateCustomPermissionsRequestT = Model::CreateCustomPermissionsRequest>
  void CreateCustomPermissionsAsync(const CreateCustomPermissionsRequestT& request,
                                    const CreateCustomPermissionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateCustomPermissions, request, handler, context);
  }
 
  virtual Model::CreateDashboardOutcome CreateDashboard(const Model::CreateDashboardRequest& request) const;
 
  template <typename CreateDashboardRequestT = Model::CreateDashboardRequest>
  Model::CreateDashboardOutcomeCallable CreateDashboardCallable(const CreateDashboardRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateDashboard, request);
  }
 
  template <typename CreateDashboardRequestT = Model::CreateDashboardRequest>
  void CreateDashboardAsync(const CreateDashboardRequestT& request, const CreateDashboardResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateDashboard, request, handler, context);
  }
 
  virtual Model::CreateDataSetOutcome CreateDataSet(const Model::CreateDataSetRequest& request) const;
 
  template <typename CreateDataSetRequestT = Model::CreateDataSetRequest>
  Model::CreateDataSetOutcomeCallable CreateDataSetCallable(const CreateDataSetRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateDataSet, request);
  }
 
  template <typename CreateDataSetRequestT = Model::CreateDataSetRequest>
  void CreateDataSetAsync(const CreateDataSetRequestT& request, const CreateDataSetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateDataSet, request, handler, context);
  }
 
  virtual Model::CreateDataSourceOutcome CreateDataSource(const Model::CreateDataSourceRequest& request) const;
 
  template <typename CreateDataSourceRequestT = Model::CreateDataSourceRequest>
  Model::CreateDataSourceOutcomeCallable CreateDataSourceCallable(const CreateDataSourceRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateDataSource, request);
  }
 
  template <typename CreateDataSourceRequestT = Model::CreateDataSourceRequest>
  void CreateDataSourceAsync(const CreateDataSourceRequestT& request, const CreateDataSourceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateDataSource, request, handler, context);
  }
 
  virtual Model::CreateFlowOutcome CreateFlow(const Model::CreateFlowRequest& request) const;
 
  template <typename CreateFlowRequestT = Model::CreateFlowRequest>
  Model::CreateFlowOutcomeCallable CreateFlowCallable(const CreateFlowRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateFlow, request);
  }
 
  template <typename CreateFlowRequestT = Model::CreateFlowRequest>
  void CreateFlowAsync(const CreateFlowRequestT& request, const CreateFlowResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateFlow, request, handler, context);
  }
 
  virtual Model::CreateFolderOutcome CreateFolder(const Model::CreateFolderRequest& request) const;
 
  template <typename CreateFolderRequestT = Model::CreateFolderRequest>
  Model::CreateFolderOutcomeCallable CreateFolderCallable(const CreateFolderRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateFolder, request);
  }
 
  template <typename CreateFolderRequestT = Model::CreateFolderRequest>
  void CreateFolderAsync(const CreateFolderRequestT& request, const CreateFolderResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateFolder, request, handler, context);
  }
 
  virtual Model::CreateFolderMembershipOutcome CreateFolderMembership(const Model::CreateFolderMembershipRequest& request) const;
 
  template <typename CreateFolderMembershipRequestT = Model::CreateFolderMembershipRequest>
  Model::CreateFolderMembershipOutcomeCallable CreateFolderMembershipCallable(const CreateFolderMembershipRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateFolderMembership, request);
  }
 
  template <typename CreateFolderMembershipRequestT = Model::CreateFolderMembershipRequest>
  void CreateFolderMembershipAsync(const CreateFolderMembershipRequestT& request,
                                   const CreateFolderMembershipResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateFolderMembership, request, handler, context);
  }
 
  virtual Model::CreateGroupOutcome CreateGroup(const Model::CreateGroupRequest& request) const;
 
  template <typename CreateGroupRequestT = Model::CreateGroupRequest>
  Model::CreateGroupOutcomeCallable CreateGroupCallable(const CreateGroupRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateGroup, request);
  }
 
  template <typename CreateGroupRequestT = Model::CreateGroupRequest>
  void CreateGroupAsync(const CreateGroupRequestT& request, const CreateGroupResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateGroup, request, handler, context);
  }
 
  virtual Model::CreateGroupMembershipOutcome CreateGroupMembership(const Model::CreateGroupMembershipRequest& request) const;
 
  template <typename CreateGroupMembershipRequestT = Model::CreateGroupMembershipRequest>
  Model::CreateGroupMembershipOutcomeCallable CreateGroupMembershipCallable(const CreateGroupMembershipRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateGroupMembership, request);
  }
 
  template <typename CreateGroupMembershipRequestT = Model::CreateGroupMembershipRequest>
  void CreateGroupMembershipAsync(const CreateGroupMembershipRequestT& request, const CreateGroupMembershipResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateGroupMembership, request, handler, context);
  }
 
  virtual Model::CreateIAMPolicyAssignmentOutcome CreateIAMPolicyAssignment(const Model::CreateIAMPolicyAssignmentRequest& request) const;
 
  template <typename CreateIAMPolicyAssignmentRequestT = Model::CreateIAMPolicyAssignmentRequest>
  Model::CreateIAMPolicyAssignmentOutcomeCallable CreateIAMPolicyAssignmentCallable(
      const CreateIAMPolicyAssignmentRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateIAMPolicyAssignment, request);
  }
 
  template <typename CreateIAMPolicyAssignmentRequestT = Model::CreateIAMPolicyAssignmentRequest>
  void CreateIAMPolicyAssignmentAsync(const CreateIAMPolicyAssignmentRequestT& request,
                                      const CreateIAMPolicyAssignmentResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateIAMPolicyAssignment, request, handler, context);
  }
 
  virtual Model::CreateIngestionOutcome CreateIngestion(const Model::CreateIngestionRequest& request) const;
 
  template <typename CreateIngestionRequestT = Model::CreateIngestionRequest>
  Model::CreateIngestionOutcomeCallable CreateIngestionCallable(const CreateIngestionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateIngestion, request);
  }
 
  template <typename CreateIngestionRequestT = Model::CreateIngestionRequest>
  void CreateIngestionAsync(const CreateIngestionRequestT& request, const CreateIngestionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateIngestion, request, handler, context);
  }
 
  virtual Model::CreateKnowledgeBaseOutcome CreateKnowledgeBase(const Model::CreateKnowledgeBaseRequest& request) const;
 
  template <typename CreateKnowledgeBaseRequestT = Model::CreateKnowledgeBaseRequest>
  Model::CreateKnowledgeBaseOutcomeCallable CreateKnowledgeBaseCallable(const CreateKnowledgeBaseRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateKnowledgeBase, request);
  }
 
  template <typename CreateKnowledgeBaseRequestT = Model::CreateKnowledgeBaseRequest>
  void CreateKnowledgeBaseAsync(const CreateKnowledgeBaseRequestT& request, const CreateKnowledgeBaseResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateKnowledgeBase, request, handler, context);
  }
 
  virtual Model::CreateNamespaceOutcome CreateNamespace(const Model::CreateNamespaceRequest& request) const;
 
  template <typename CreateNamespaceRequestT = Model::CreateNamespaceRequest>
  Model::CreateNamespaceOutcomeCallable CreateNamespaceCallable(const CreateNamespaceRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateNamespace, request);
  }
 
  template <typename CreateNamespaceRequestT = Model::CreateNamespaceRequest>
  void CreateNamespaceAsync(const CreateNamespaceRequestT& request, const CreateNamespaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateNamespace, request, handler, context);
  }
 
  virtual Model::CreateOAuthClientApplicationOutcome CreateOAuthClientApplication(
      const Model::CreateOAuthClientApplicationRequest& request) const;
 
  template <typename CreateOAuthClientApplicationRequestT = Model::CreateOAuthClientApplicationRequest>
  Model::CreateOAuthClientApplicationOutcomeCallable CreateOAuthClientApplicationCallable(
      const CreateOAuthClientApplicationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateOAuthClientApplication, request);
  }
 
  template <typename CreateOAuthClientApplicationRequestT = Model::CreateOAuthClientApplicationRequest>
  void CreateOAuthClientApplicationAsync(const CreateOAuthClientApplicationRequestT& request,
                                         const CreateOAuthClientApplicationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateOAuthClientApplication, request, handler, context);
  }
 
  virtual Model::CreateRefreshScheduleOutcome CreateRefreshSchedule(const Model::CreateRefreshScheduleRequest& request) const;
 
  template <typename CreateRefreshScheduleRequestT = Model::CreateRefreshScheduleRequest>
  Model::CreateRefreshScheduleOutcomeCallable CreateRefreshScheduleCallable(const CreateRefreshScheduleRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateRefreshSchedule, request);
  }
 
  template <typename CreateRefreshScheduleRequestT = Model::CreateRefreshScheduleRequest>
  void CreateRefreshScheduleAsync(const CreateRefreshScheduleRequestT& request, const CreateRefreshScheduleResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateRefreshSchedule, request, handler, context);
  }
 
  virtual Model::CreateRoleMembershipOutcome CreateRoleMembership(const Model::CreateRoleMembershipRequest& request) const;
 
  template <typename CreateRoleMembershipRequestT = Model::CreateRoleMembershipRequest>
  Model::CreateRoleMembershipOutcomeCallable CreateRoleMembershipCallable(const CreateRoleMembershipRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateRoleMembership, request);
  }
 
  template <typename CreateRoleMembershipRequestT = Model::CreateRoleMembershipRequest>
  void CreateRoleMembershipAsync(const CreateRoleMembershipRequestT& request, const CreateRoleMembershipResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateRoleMembership, request, handler, context);
  }
 
  virtual Model::CreateSpaceOutcome CreateSpace(const Model::CreateSpaceRequest& request) const;
 
  template <typename CreateSpaceRequestT = Model::CreateSpaceRequest>
  Model::CreateSpaceOutcomeCallable CreateSpaceCallable(const CreateSpaceRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateSpace, request);
  }
 
  template <typename CreateSpaceRequestT = Model::CreateSpaceRequest>
  void CreateSpaceAsync(const CreateSpaceRequestT& request, const CreateSpaceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateSpace, request, handler, context);
  }
 
  virtual Model::CreateTemplateOutcome CreateTemplate(const Model::CreateTemplateRequest& request) const;
 
  template <typename CreateTemplateRequestT = Model::CreateTemplateRequest>
  Model::CreateTemplateOutcomeCallable CreateTemplateCallable(const CreateTemplateRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateTemplate, request);
  }
 
  template <typename CreateTemplateRequestT = Model::CreateTemplateRequest>
  void CreateTemplateAsync(const CreateTemplateRequestT& request, const CreateTemplateResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateTemplate, request, handler, context);
  }
 
  virtual Model::CreateTemplateAliasOutcome CreateTemplateAlias(const Model::CreateTemplateAliasRequest& request) const;
 
  template <typename CreateTemplateAliasRequestT = Model::CreateTemplateAliasRequest>
  Model::CreateTemplateAliasOutcomeCallable CreateTemplateAliasCallable(const CreateTemplateAliasRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateTemplateAlias, request);
  }
 
  template <typename CreateTemplateAliasRequestT = Model::CreateTemplateAliasRequest>
  void CreateTemplateAliasAsync(const CreateTemplateAliasRequestT& request, const CreateTemplateAliasResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateTemplateAlias, request, handler, context);
  }
 
  virtual Model::CreateThemeOutcome CreateTheme(const Model::CreateThemeRequest& request) const;
 
  template <typename CreateThemeRequestT = Model::CreateThemeRequest>
  Model::CreateThemeOutcomeCallable CreateThemeCallable(const CreateThemeRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateTheme, request);
  }
 
  template <typename CreateThemeRequestT = Model::CreateThemeRequest>
  void CreateThemeAsync(const CreateThemeRequestT& request, const CreateThemeResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateTheme, request, handler, context);
  }
 
  virtual Model::CreateThemeAliasOutcome CreateThemeAlias(const Model::CreateThemeAliasRequest& request) const;
 
  template <typename CreateThemeAliasRequestT = Model::CreateThemeAliasRequest>
  Model::CreateThemeAliasOutcomeCallable CreateThemeAliasCallable(const CreateThemeAliasRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateThemeAlias, request);
  }
 
  template <typename CreateThemeAliasRequestT = Model::CreateThemeAliasRequest>
  void CreateThemeAliasAsync(const CreateThemeAliasRequestT& request, const CreateThemeAliasResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateThemeAlias, request, handler, context);
  }
 
  virtual Model::CreateTopicOutcome CreateTopic(const Model::CreateTopicRequest& request) const;
 
  template <typename CreateTopicRequestT = Model::CreateTopicRequest>
  Model::CreateTopicOutcomeCallable CreateTopicCallable(const CreateTopicRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateTopic, request);
  }
 
  template <typename CreateTopicRequestT = Model::CreateTopicRequest>
  void CreateTopicAsync(const CreateTopicRequestT& request, const CreateTopicResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateTopic, request, handler, context);
  }
 
  virtual Model::CreateTopicRefreshScheduleOutcome CreateTopicRefreshSchedule(
      const Model::CreateTopicRefreshScheduleRequest& request) const;
 
  template <typename CreateTopicRefreshScheduleRequestT = Model::CreateTopicRefreshScheduleRequest>
  Model::CreateTopicRefreshScheduleOutcomeCallable CreateTopicRefreshScheduleCallable(
      const CreateTopicRefreshScheduleRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateTopicRefreshSchedule, request);
  }
 
  template <typename CreateTopicRefreshScheduleRequestT = Model::CreateTopicRefreshScheduleRequest>
  void CreateTopicRefreshScheduleAsync(const CreateTopicRefreshScheduleRequestT& request,
                                       const CreateTopicRefreshScheduleResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateTopicRefreshSchedule, request, handler, context);
  }
 
  virtual Model::CreateVPCConnectionOutcome CreateVPCConnection(const Model::CreateVPCConnectionRequest& request) const;
 
  template <typename CreateVPCConnectionRequestT = Model::CreateVPCConnectionRequest>
  Model::CreateVPCConnectionOutcomeCallable CreateVPCConnectionCallable(const CreateVPCConnectionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::CreateVPCConnection, request);
  }
 
  template <typename CreateVPCConnectionRequestT = Model::CreateVPCConnectionRequest>
  void CreateVPCConnectionAsync(const CreateVPCConnectionRequestT& request, const CreateVPCConnectionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::CreateVPCConnection, request, handler, context);
  }
 
  virtual Model::DeleteAccountCustomPermissionOutcome DeleteAccountCustomPermission(
      const Model::DeleteAccountCustomPermissionRequest& request) const;
 
  template <typename DeleteAccountCustomPermissionRequestT = Model::DeleteAccountCustomPermissionRequest>
  Model::DeleteAccountCustomPermissionOutcomeCallable DeleteAccountCustomPermissionCallable(
      const DeleteAccountCustomPermissionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteAccountCustomPermission, request);
  }
 
  template <typename DeleteAccountCustomPermissionRequestT = Model::DeleteAccountCustomPermissionRequest>
  void DeleteAccountCustomPermissionAsync(const DeleteAccountCustomPermissionRequestT& request,
                                          const DeleteAccountCustomPermissionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteAccountCustomPermission, request, handler, context);
  }
 
  virtual Model::DeleteAccountCustomizationOutcome DeleteAccountCustomization(
      const Model::DeleteAccountCustomizationRequest& request) const;
 
  template <typename DeleteAccountCustomizationRequestT = Model::DeleteAccountCustomizationRequest>
  Model::DeleteAccountCustomizationOutcomeCallable DeleteAccountCustomizationCallable(
      const DeleteAccountCustomizationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteAccountCustomization, request);
  }
 
  template <typename DeleteAccountCustomizationRequestT = Model::DeleteAccountCustomizationRequest>
  void DeleteAccountCustomizationAsync(const DeleteAccountCustomizationRequestT& request,
                                       const DeleteAccountCustomizationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteAccountCustomization, request, handler, context);
  }
 
  virtual Model::DeleteAccountSubscriptionOutcome DeleteAccountSubscription(const Model::DeleteAccountSubscriptionRequest& request) const;
 
  template <typename DeleteAccountSubscriptionRequestT = Model::DeleteAccountSubscriptionRequest>
  Model::DeleteAccountSubscriptionOutcomeCallable DeleteAccountSubscriptionCallable(
      const DeleteAccountSubscriptionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteAccountSubscription, request);
  }
 
  template <typename DeleteAccountSubscriptionRequestT = Model::DeleteAccountSubscriptionRequest>
  void DeleteAccountSubscriptionAsync(const DeleteAccountSubscriptionRequestT& request,
                                      const DeleteAccountSubscriptionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteAccountSubscription, request, handler, context);
  }
 
  virtual Model::DeleteActionConnectorOutcome DeleteActionConnector(const Model::DeleteActionConnectorRequest& request) const;
 
  template <typename DeleteActionConnectorRequestT = Model::DeleteActionConnectorRequest>
  Model::DeleteActionConnectorOutcomeCallable DeleteActionConnectorCallable(const DeleteActionConnectorRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteActionConnector, request);
  }
 
  template <typename DeleteActionConnectorRequestT = Model::DeleteActionConnectorRequest>
  void DeleteActionConnectorAsync(const DeleteActionConnectorRequestT& request, const DeleteActionConnectorResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteActionConnector, request, handler, context);
  }
 
  virtual Model::DeleteAgentOutcome DeleteAgent(const Model::DeleteAgentRequest& request) const;
 
  template <typename DeleteAgentRequestT = Model::DeleteAgentRequest>
  Model::DeleteAgentOutcomeCallable DeleteAgentCallable(const DeleteAgentRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteAgent, request);
  }
 
  template <typename DeleteAgentRequestT = Model::DeleteAgentRequest>
  void DeleteAgentAsync(const DeleteAgentRequestT& request, const DeleteAgentResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteAgent, request, handler, context);
  }
 
  virtual Model::DeleteAnalysisOutcome DeleteAnalysis(const Model::DeleteAnalysisRequest& request) const;
 
  template <typename DeleteAnalysisRequestT = Model::DeleteAnalysisRequest>
  Model::DeleteAnalysisOutcomeCallable DeleteAnalysisCallable(const DeleteAnalysisRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteAnalysis, request);
  }
 
  template <typename DeleteAnalysisRequestT = Model::DeleteAnalysisRequest>
  void DeleteAnalysisAsync(const DeleteAnalysisRequestT& request, const DeleteAnalysisResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteAnalysis, request, handler, context);
  }
 
  virtual Model::DeleteBrandOutcome DeleteBrand(const Model::DeleteBrandRequest& request) const;
 
  template <typename DeleteBrandRequestT = Model::DeleteBrandRequest>
  Model::DeleteBrandOutcomeCallable DeleteBrandCallable(const DeleteBrandRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteBrand, request);
  }
 
  template <typename DeleteBrandRequestT = Model::DeleteBrandRequest>
  void DeleteBrandAsync(const DeleteBrandRequestT& request, const DeleteBrandResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteBrand, request, handler, context);
  }
 
  virtual Model::DeleteBrandAssignmentOutcome DeleteBrandAssignment(const Model::DeleteBrandAssignmentRequest& request) const;
 
  template <typename DeleteBrandAssignmentRequestT = Model::DeleteBrandAssignmentRequest>
  Model::DeleteBrandAssignmentOutcomeCallable DeleteBrandAssignmentCallable(const DeleteBrandAssignmentRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteBrandAssignment, request);
  }
 
  template <typename DeleteBrandAssignmentRequestT = Model::DeleteBrandAssignmentRequest>
  void DeleteBrandAssignmentAsync(const DeleteBrandAssignmentRequestT& request, const DeleteBrandAssignmentResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteBrandAssignment, request, handler, context);
  }
 
  virtual Model::DeleteCustomPermissionsOutcome DeleteCustomPermissions(const Model::DeleteCustomPermissionsRequest& request) const;
 
  template <typename DeleteCustomPermissionsRequestT = Model::DeleteCustomPermissionsRequest>
  Model::DeleteCustomPermissionsOutcomeCallable DeleteCustomPermissionsCallable(const DeleteCustomPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteCustomPermissions, request);
  }
 
  template <typename DeleteCustomPermissionsRequestT = Model::DeleteCustomPermissionsRequest>
  void DeleteCustomPermissionsAsync(const DeleteCustomPermissionsRequestT& request,
                                    const DeleteCustomPermissionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteCustomPermissions, request, handler, context);
  }
 
  virtual Model::DeleteDashboardOutcome DeleteDashboard(const Model::DeleteDashboardRequest& request) const;
 
  template <typename DeleteDashboardRequestT = Model::DeleteDashboardRequest>
  Model::DeleteDashboardOutcomeCallable DeleteDashboardCallable(const DeleteDashboardRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteDashboard, request);
  }
 
  template <typename DeleteDashboardRequestT = Model::DeleteDashboardRequest>
  void DeleteDashboardAsync(const DeleteDashboardRequestT& request, const DeleteDashboardResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteDashboard, request, handler, context);
  }
 
  virtual Model::DeleteDataSetOutcome DeleteDataSet(const Model::DeleteDataSetRequest& request) const;
 
  template <typename DeleteDataSetRequestT = Model::DeleteDataSetRequest>
  Model::DeleteDataSetOutcomeCallable DeleteDataSetCallable(const DeleteDataSetRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteDataSet, request);
  }
 
  template <typename DeleteDataSetRequestT = Model::DeleteDataSetRequest>
  void DeleteDataSetAsync(const DeleteDataSetRequestT& request, const DeleteDataSetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteDataSet, request, handler, context);
  }
 
  virtual Model::DeleteDataSetRefreshPropertiesOutcome DeleteDataSetRefreshProperties(
      const Model::DeleteDataSetRefreshPropertiesRequest& request) const;
 
  template <typename DeleteDataSetRefreshPropertiesRequestT = Model::DeleteDataSetRefreshPropertiesRequest>
  Model::DeleteDataSetRefreshPropertiesOutcomeCallable DeleteDataSetRefreshPropertiesCallable(
      const DeleteDataSetRefreshPropertiesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteDataSetRefreshProperties, request);
  }
 
  template <typename DeleteDataSetRefreshPropertiesRequestT = Model::DeleteDataSetRefreshPropertiesRequest>
  void DeleteDataSetRefreshPropertiesAsync(const DeleteDataSetRefreshPropertiesRequestT& request,
                                           const DeleteDataSetRefreshPropertiesResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteDataSetRefreshProperties, request, handler, context);
  }
 
  virtual Model::DeleteDataSourceOutcome DeleteDataSource(const Model::DeleteDataSourceRequest& request) const;
 
  template <typename DeleteDataSourceRequestT = Model::DeleteDataSourceRequest>
  Model::DeleteDataSourceOutcomeCallable DeleteDataSourceCallable(const DeleteDataSourceRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteDataSource, request);
  }
 
  template <typename DeleteDataSourceRequestT = Model::DeleteDataSourceRequest>
  void DeleteDataSourceAsync(const DeleteDataSourceRequestT& request, const DeleteDataSourceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteDataSource, request, handler, context);
  }
 
  virtual Model::DeleteDefaultQBusinessApplicationOutcome DeleteDefaultQBusinessApplication(
      const Model::DeleteDefaultQBusinessApplicationRequest& request) const;
 
  template <typename DeleteDefaultQBusinessApplicationRequestT = Model::DeleteDefaultQBusinessApplicationRequest>
  Model::DeleteDefaultQBusinessApplicationOutcomeCallable DeleteDefaultQBusinessApplicationCallable(
      const DeleteDefaultQBusinessApplicationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteDefaultQBusinessApplication, request);
  }
 
  template <typename DeleteDefaultQBusinessApplicationRequestT = Model::DeleteDefaultQBusinessApplicationRequest>
  void DeleteDefaultQBusinessApplicationAsync(const DeleteDefaultQBusinessApplicationRequestT& request,
                                              const DeleteDefaultQBusinessApplicationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteDefaultQBusinessApplication, request, handler, context);
  }
 
  virtual Model::DeleteFlowOutcome DeleteFlow(const Model::DeleteFlowRequest& request) const;
 
  template <typename DeleteFlowRequestT = Model::DeleteFlowRequest>
  Model::DeleteFlowOutcomeCallable DeleteFlowCallable(const DeleteFlowRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteFlow, request);
  }
 
  template <typename DeleteFlowRequestT = Model::DeleteFlowRequest>
  void DeleteFlowAsync(const DeleteFlowRequestT& request, const DeleteFlowResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteFlow, request, handler, context);
  }
 
  virtual Model::DeleteFolderOutcome DeleteFolder(const Model::DeleteFolderRequest& request) const;
 
  template <typename DeleteFolderRequestT = Model::DeleteFolderRequest>
  Model::DeleteFolderOutcomeCallable DeleteFolderCallable(const DeleteFolderRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteFolder, request);
  }
 
  template <typename DeleteFolderRequestT = Model::DeleteFolderRequest>
  void DeleteFolderAsync(const DeleteFolderRequestT& request, const DeleteFolderResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteFolder, request, handler, context);
  }
 
  virtual Model::DeleteFolderMembershipOutcome DeleteFolderMembership(const Model::DeleteFolderMembershipRequest& request) const;
 
  template <typename DeleteFolderMembershipRequestT = Model::DeleteFolderMembershipRequest>
  Model::DeleteFolderMembershipOutcomeCallable DeleteFolderMembershipCallable(const DeleteFolderMembershipRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteFolderMembership, request);
  }
 
  template <typename DeleteFolderMembershipRequestT = Model::DeleteFolderMembershipRequest>
  void DeleteFolderMembershipAsync(const DeleteFolderMembershipRequestT& request,
                                   const DeleteFolderMembershipResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteFolderMembership, request, handler, context);
  }
 
  virtual Model::DeleteGroupOutcome DeleteGroup(const Model::DeleteGroupRequest& request) const;
 
  template <typename DeleteGroupRequestT = Model::DeleteGroupRequest>
  Model::DeleteGroupOutcomeCallable DeleteGroupCallable(const DeleteGroupRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteGroup, request);
  }
 
  template <typename DeleteGroupRequestT = Model::DeleteGroupRequest>
  void DeleteGroupAsync(const DeleteGroupRequestT& request, const DeleteGroupResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteGroup, request, handler, context);
  }
 
  virtual Model::DeleteGroupMembershipOutcome DeleteGroupMembership(const Model::DeleteGroupMembershipRequest& request) const;
 
  template <typename DeleteGroupMembershipRequestT = Model::DeleteGroupMembershipRequest>
  Model::DeleteGroupMembershipOutcomeCallable DeleteGroupMembershipCallable(const DeleteGroupMembershipRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteGroupMembership, request);
  }
 
  template <typename DeleteGroupMembershipRequestT = Model::DeleteGroupMembershipRequest>
  void DeleteGroupMembershipAsync(const DeleteGroupMembershipRequestT& request, const DeleteGroupMembershipResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteGroupMembership, request, handler, context);
  }
 
  virtual Model::DeleteIAMPolicyAssignmentOutcome DeleteIAMPolicyAssignment(const Model::DeleteIAMPolicyAssignmentRequest& request) const;
 
  template <typename DeleteIAMPolicyAssignmentRequestT = Model::DeleteIAMPolicyAssignmentRequest>
  Model::DeleteIAMPolicyAssignmentOutcomeCallable DeleteIAMPolicyAssignmentCallable(
      const DeleteIAMPolicyAssignmentRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteIAMPolicyAssignment, request);
  }
 
  template <typename DeleteIAMPolicyAssignmentRequestT = Model::DeleteIAMPolicyAssignmentRequest>
  void DeleteIAMPolicyAssignmentAsync(const DeleteIAMPolicyAssignmentRequestT& request,
                                      const DeleteIAMPolicyAssignmentResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteIAMPolicyAssignment, request, handler, context);
  }
 
  virtual Model::DeleteIdentityPropagationConfigOutcome DeleteIdentityPropagationConfig(
      const Model::DeleteIdentityPropagationConfigRequest& request) const;
 
  template <typename DeleteIdentityPropagationConfigRequestT = Model::DeleteIdentityPropagationConfigRequest>
  Model::DeleteIdentityPropagationConfigOutcomeCallable DeleteIdentityPropagationConfigCallable(
      const DeleteIdentityPropagationConfigRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteIdentityPropagationConfig, request);
  }
 
  template <typename DeleteIdentityPropagationConfigRequestT = Model::DeleteIdentityPropagationConfigRequest>
  void DeleteIdentityPropagationConfigAsync(const DeleteIdentityPropagationConfigRequestT& request,
                                            const DeleteIdentityPropagationConfigResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteIdentityPropagationConfig, request, handler, context);
  }
 
  virtual Model::DeleteKnowledgeBaseOutcome DeleteKnowledgeBase(const Model::DeleteKnowledgeBaseRequest& request) const;
 
  template <typename DeleteKnowledgeBaseRequestT = Model::DeleteKnowledgeBaseRequest>
  Model::DeleteKnowledgeBaseOutcomeCallable DeleteKnowledgeBaseCallable(const DeleteKnowledgeBaseRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteKnowledgeBase, request);
  }
 
  template <typename DeleteKnowledgeBaseRequestT = Model::DeleteKnowledgeBaseRequest>
  void DeleteKnowledgeBaseAsync(const DeleteKnowledgeBaseRequestT& request, const DeleteKnowledgeBaseResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteKnowledgeBase, request, handler, context);
  }
 
  virtual Model::DeleteNamespaceOutcome DeleteNamespace(const Model::DeleteNamespaceRequest& request) const;
 
  template <typename DeleteNamespaceRequestT = Model::DeleteNamespaceRequest>
  Model::DeleteNamespaceOutcomeCallable DeleteNamespaceCallable(const DeleteNamespaceRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteNamespace, request);
  }
 
  template <typename DeleteNamespaceRequestT = Model::DeleteNamespaceRequest>
  void DeleteNamespaceAsync(const DeleteNamespaceRequestT& request, const DeleteNamespaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteNamespace, request, handler, context);
  }
 
  virtual Model::DeleteOAuthClientApplicationOutcome DeleteOAuthClientApplication(
      const Model::DeleteOAuthClientApplicationRequest& request) const;
 
  template <typename DeleteOAuthClientApplicationRequestT = Model::DeleteOAuthClientApplicationRequest>
  Model::DeleteOAuthClientApplicationOutcomeCallable DeleteOAuthClientApplicationCallable(
      const DeleteOAuthClientApplicationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteOAuthClientApplication, request);
  }
 
  template <typename DeleteOAuthClientApplicationRequestT = Model::DeleteOAuthClientApplicationRequest>
  void DeleteOAuthClientApplicationAsync(const DeleteOAuthClientApplicationRequestT& request,
                                         const DeleteOAuthClientApplicationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteOAuthClientApplication, request, handler, context);
  }
 
  virtual Model::DeleteRefreshScheduleOutcome DeleteRefreshSchedule(const Model::DeleteRefreshScheduleRequest& request) const;
 
  template <typename DeleteRefreshScheduleRequestT = Model::DeleteRefreshScheduleRequest>
  Model::DeleteRefreshScheduleOutcomeCallable DeleteRefreshScheduleCallable(const DeleteRefreshScheduleRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteRefreshSchedule, request);
  }
 
  template <typename DeleteRefreshScheduleRequestT = Model::DeleteRefreshScheduleRequest>
  void DeleteRefreshScheduleAsync(const DeleteRefreshScheduleRequestT& request, const DeleteRefreshScheduleResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteRefreshSchedule, request, handler, context);
  }
 
  virtual Model::DeleteRoleCustomPermissionOutcome DeleteRoleCustomPermission(
      const Model::DeleteRoleCustomPermissionRequest& request) const;
 
  template <typename DeleteRoleCustomPermissionRequestT = Model::DeleteRoleCustomPermissionRequest>
  Model::DeleteRoleCustomPermissionOutcomeCallable DeleteRoleCustomPermissionCallable(
      const DeleteRoleCustomPermissionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteRoleCustomPermission, request);
  }
 
  template <typename DeleteRoleCustomPermissionRequestT = Model::DeleteRoleCustomPermissionRequest>
  void DeleteRoleCustomPermissionAsync(const DeleteRoleCustomPermissionRequestT& request,
                                       const DeleteRoleCustomPermissionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteRoleCustomPermission, request, handler, context);
  }
 
  virtual Model::DeleteRoleMembershipOutcome DeleteRoleMembership(const Model::DeleteRoleMembershipRequest& request) const;
 
  template <typename DeleteRoleMembershipRequestT = Model::DeleteRoleMembershipRequest>
  Model::DeleteRoleMembershipOutcomeCallable DeleteRoleMembershipCallable(const DeleteRoleMembershipRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteRoleMembership, request);
  }
 
  template <typename DeleteRoleMembershipRequestT = Model::DeleteRoleMembershipRequest>
  void DeleteRoleMembershipAsync(const DeleteRoleMembershipRequestT& request, const DeleteRoleMembershipResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteRoleMembership, request, handler, context);
  }
 
  virtual Model::DeleteSpaceOutcome DeleteSpace(const Model::DeleteSpaceRequest& request) const;
 
  template <typename DeleteSpaceRequestT = Model::DeleteSpaceRequest>
  Model::DeleteSpaceOutcomeCallable DeleteSpaceCallable(const DeleteSpaceRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteSpace, request);
  }
 
  template <typename DeleteSpaceRequestT = Model::DeleteSpaceRequest>
  void DeleteSpaceAsync(const DeleteSpaceRequestT& request, const DeleteSpaceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteSpace, request, handler, context);
  }
 
  virtual Model::DeleteTemplateOutcome DeleteTemplate(const Model::DeleteTemplateRequest& request) const;
 
  template <typename DeleteTemplateRequestT = Model::DeleteTemplateRequest>
  Model::DeleteTemplateOutcomeCallable DeleteTemplateCallable(const DeleteTemplateRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteTemplate, request);
  }
 
  template <typename DeleteTemplateRequestT = Model::DeleteTemplateRequest>
  void DeleteTemplateAsync(const DeleteTemplateRequestT& request, const DeleteTemplateResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteTemplate, request, handler, context);
  }
 
  virtual Model::DeleteTemplateAliasOutcome DeleteTemplateAlias(const Model::DeleteTemplateAliasRequest& request) const;
 
  template <typename DeleteTemplateAliasRequestT = Model::DeleteTemplateAliasRequest>
  Model::DeleteTemplateAliasOutcomeCallable DeleteTemplateAliasCallable(const DeleteTemplateAliasRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteTemplateAlias, request);
  }
 
  template <typename DeleteTemplateAliasRequestT = Model::DeleteTemplateAliasRequest>
  void DeleteTemplateAliasAsync(const DeleteTemplateAliasRequestT& request, const DeleteTemplateAliasResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteTemplateAlias, request, handler, context);
  }
 
  virtual Model::DeleteThemeOutcome DeleteTheme(const Model::DeleteThemeRequest& request) const;
 
  template <typename DeleteThemeRequestT = Model::DeleteThemeRequest>
  Model::DeleteThemeOutcomeCallable DeleteThemeCallable(const DeleteThemeRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteTheme, request);
  }
 
  template <typename DeleteThemeRequestT = Model::DeleteThemeRequest>
  void DeleteThemeAsync(const DeleteThemeRequestT& request, const DeleteThemeResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteTheme, request, handler, context);
  }
 
  virtual Model::DeleteThemeAliasOutcome DeleteThemeAlias(const Model::DeleteThemeAliasRequest& request) const;
 
  template <typename DeleteThemeAliasRequestT = Model::DeleteThemeAliasRequest>
  Model::DeleteThemeAliasOutcomeCallable DeleteThemeAliasCallable(const DeleteThemeAliasRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteThemeAlias, request);
  }
 
  template <typename DeleteThemeAliasRequestT = Model::DeleteThemeAliasRequest>
  void DeleteThemeAliasAsync(const DeleteThemeAliasRequestT& request, const DeleteThemeAliasResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteThemeAlias, request, handler, context);
  }
 
  virtual Model::DeleteTopicOutcome DeleteTopic(const Model::DeleteTopicRequest& request) const;
 
  template <typename DeleteTopicRequestT = Model::DeleteTopicRequest>
  Model::DeleteTopicOutcomeCallable DeleteTopicCallable(const DeleteTopicRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteTopic, request);
  }
 
  template <typename DeleteTopicRequestT = Model::DeleteTopicRequest>
  void DeleteTopicAsync(const DeleteTopicRequestT& request, const DeleteTopicResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteTopic, request, handler, context);
  }
 
  virtual Model::DeleteTopicRefreshScheduleOutcome DeleteTopicRefreshSchedule(
      const Model::DeleteTopicRefreshScheduleRequest& request) const;
 
  template <typename DeleteTopicRefreshScheduleRequestT = Model::DeleteTopicRefreshScheduleRequest>
  Model::DeleteTopicRefreshScheduleOutcomeCallable DeleteTopicRefreshScheduleCallable(
      const DeleteTopicRefreshScheduleRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteTopicRefreshSchedule, request);
  }
 
  template <typename DeleteTopicRefreshScheduleRequestT = Model::DeleteTopicRefreshScheduleRequest>
  void DeleteTopicRefreshScheduleAsync(const DeleteTopicRefreshScheduleRequestT& request,
                                       const DeleteTopicRefreshScheduleResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteTopicRefreshSchedule, request, handler, context);
  }
 
  virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const;
 
  template <typename DeleteUserRequestT = Model::DeleteUserRequest>
  Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteUser, request);
  }
 
  template <typename DeleteUserRequestT = Model::DeleteUserRequest>
  void DeleteUserAsync(const DeleteUserRequestT& request, const DeleteUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteUser, request, handler, context);
  }
 
  virtual Model::DeleteUserByPrincipalIdOutcome DeleteUserByPrincipalId(const Model::DeleteUserByPrincipalIdRequest& request) const;
 
  template <typename DeleteUserByPrincipalIdRequestT = Model::DeleteUserByPrincipalIdRequest>
  Model::DeleteUserByPrincipalIdOutcomeCallable DeleteUserByPrincipalIdCallable(const DeleteUserByPrincipalIdRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteUserByPrincipalId, request);
  }
 
  template <typename DeleteUserByPrincipalIdRequestT = Model::DeleteUserByPrincipalIdRequest>
  void DeleteUserByPrincipalIdAsync(const DeleteUserByPrincipalIdRequestT& request,
                                    const DeleteUserByPrincipalIdResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteUserByPrincipalId, request, handler, context);
  }
 
  virtual Model::DeleteUserCustomPermissionOutcome DeleteUserCustomPermission(
      const Model::DeleteUserCustomPermissionRequest& request) const;
 
  template <typename DeleteUserCustomPermissionRequestT = Model::DeleteUserCustomPermissionRequest>
  Model::DeleteUserCustomPermissionOutcomeCallable DeleteUserCustomPermissionCallable(
      const DeleteUserCustomPermissionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteUserCustomPermission, request);
  }
 
  template <typename DeleteUserCustomPermissionRequestT = Model::DeleteUserCustomPermissionRequest>
  void DeleteUserCustomPermissionAsync(const DeleteUserCustomPermissionRequestT& request,
                                       const DeleteUserCustomPermissionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteUserCustomPermission, request, handler, context);
  }
 
  virtual Model::DeleteVPCConnectionOutcome DeleteVPCConnection(const Model::DeleteVPCConnectionRequest& request) const;
 
  template <typename DeleteVPCConnectionRequestT = Model::DeleteVPCConnectionRequest>
  Model::DeleteVPCConnectionOutcomeCallable DeleteVPCConnectionCallable(const DeleteVPCConnectionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DeleteVPCConnection, request);
  }
 
  template <typename DeleteVPCConnectionRequestT = Model::DeleteVPCConnectionRequest>
  void DeleteVPCConnectionAsync(const DeleteVPCConnectionRequestT& request, const DeleteVPCConnectionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DeleteVPCConnection, request, handler, context);
  }
 
  virtual Model::DescribeAccountCustomPermissionOutcome DescribeAccountCustomPermission(
      const Model::DescribeAccountCustomPermissionRequest& request) const;
 
  template <typename DescribeAccountCustomPermissionRequestT = Model::DescribeAccountCustomPermissionRequest>
  Model::DescribeAccountCustomPermissionOutcomeCallable DescribeAccountCustomPermissionCallable(
      const DescribeAccountCustomPermissionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeAccountCustomPermission, request);
  }
 
  template <typename DescribeAccountCustomPermissionRequestT = Model::DescribeAccountCustomPermissionRequest>
  void DescribeAccountCustomPermissionAsync(const DescribeAccountCustomPermissionRequestT& request,
                                            const DescribeAccountCustomPermissionResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeAccountCustomPermission, request, handler, context);
  }
 
  virtual Model::DescribeAccountCustomizationOutcome DescribeAccountCustomization(
      const Model::DescribeAccountCustomizationRequest& request) const;
 
  template <typename DescribeAccountCustomizationRequestT = Model::DescribeAccountCustomizationRequest>
  Model::DescribeAccountCustomizationOutcomeCallable DescribeAccountCustomizationCallable(
      const DescribeAccountCustomizationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeAccountCustomization, request);
  }
 
  template <typename DescribeAccountCustomizationRequestT = Model::DescribeAccountCustomizationRequest>
  void DescribeAccountCustomizationAsync(const DescribeAccountCustomizationRequestT& request,
                                         const DescribeAccountCustomizationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeAccountCustomization, request, handler, context);
  }
 
  virtual Model::DescribeAccountSettingsOutcome DescribeAccountSettings(const Model::DescribeAccountSettingsRequest& request) const;
 
  template <typename DescribeAccountSettingsRequestT = Model::DescribeAccountSettingsRequest>
  Model::DescribeAccountSettingsOutcomeCallable DescribeAccountSettingsCallable(const DescribeAccountSettingsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeAccountSettings, request);
  }
 
  template <typename DescribeAccountSettingsRequestT = Model::DescribeAccountSettingsRequest>
  void DescribeAccountSettingsAsync(const DescribeAccountSettingsRequestT& request,
                                    const DescribeAccountSettingsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeAccountSettings, request, handler, context);
  }
 
  virtual Model::DescribeAccountSubscriptionOutcome DescribeAccountSubscription(
      const Model::DescribeAccountSubscriptionRequest& request) const;
 
  template <typename DescribeAccountSubscriptionRequestT = Model::DescribeAccountSubscriptionRequest>
  Model::DescribeAccountSubscriptionOutcomeCallable DescribeAccountSubscriptionCallable(
      const DescribeAccountSubscriptionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeAccountSubscription, request);
  }
 
  template <typename DescribeAccountSubscriptionRequestT = Model::DescribeAccountSubscriptionRequest>
  void DescribeAccountSubscriptionAsync(const DescribeAccountSubscriptionRequestT& request,
                                        const DescribeAccountSubscriptionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeAccountSubscription, request, handler, context);
  }
 
  virtual Model::DescribeActionConnectorOutcome DescribeActionConnector(const Model::DescribeActionConnectorRequest& request) const;
 
  template <typename DescribeActionConnectorRequestT = Model::DescribeActionConnectorRequest>
  Model::DescribeActionConnectorOutcomeCallable DescribeActionConnectorCallable(const DescribeActionConnectorRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeActionConnector, request);
  }
 
  template <typename DescribeActionConnectorRequestT = Model::DescribeActionConnectorRequest>
  void DescribeActionConnectorAsync(const DescribeActionConnectorRequestT& request,
                                    const DescribeActionConnectorResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeActionConnector, request, handler, context);
  }
 
  virtual Model::DescribeActionConnectorPermissionsOutcome DescribeActionConnectorPermissions(
      const Model::DescribeActionConnectorPermissionsRequest& request) const;
 
  template <typename DescribeActionConnectorPermissionsRequestT = Model::DescribeActionConnectorPermissionsRequest>
  Model::DescribeActionConnectorPermissionsOutcomeCallable DescribeActionConnectorPermissionsCallable(
      const DescribeActionConnectorPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeActionConnectorPermissions, request);
  }
 
  template <typename DescribeActionConnectorPermissionsRequestT = Model::DescribeActionConnectorPermissionsRequest>
  void DescribeActionConnectorPermissionsAsync(const DescribeActionConnectorPermissionsRequestT& request,
                                               const DescribeActionConnectorPermissionsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeActionConnectorPermissions, request, handler, context);
  }
 
  virtual Model::DescribeAgentOutcome DescribeAgent(const Model::DescribeAgentRequest& request) const;
 
  template <typename DescribeAgentRequestT = Model::DescribeAgentRequest>
  Model::DescribeAgentOutcomeCallable DescribeAgentCallable(const DescribeAgentRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeAgent, request);
  }
 
  template <typename DescribeAgentRequestT = Model::DescribeAgentRequest>
  void DescribeAgentAsync(const DescribeAgentRequestT& request, const DescribeAgentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeAgent, request, handler, context);
  }
 
  virtual Model::DescribeAgentPermissionsOutcome DescribeAgentPermissions(const Model::DescribeAgentPermissionsRequest& request) const;
 
  template <typename DescribeAgentPermissionsRequestT = Model::DescribeAgentPermissionsRequest>
  Model::DescribeAgentPermissionsOutcomeCallable DescribeAgentPermissionsCallable(const DescribeAgentPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeAgentPermissions, request);
  }
 
  template <typename DescribeAgentPermissionsRequestT = Model::DescribeAgentPermissionsRequest>
  void DescribeAgentPermissionsAsync(const DescribeAgentPermissionsRequestT& request,
                                     const DescribeAgentPermissionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeAgentPermissions, request, handler, context);
  }
 
  virtual Model::DescribeAnalysisOutcome DescribeAnalysis(const Model::DescribeAnalysisRequest& request) const;
 
  template <typename DescribeAnalysisRequestT = Model::DescribeAnalysisRequest>
  Model::DescribeAnalysisOutcomeCallable DescribeAnalysisCallable(const DescribeAnalysisRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeAnalysis, request);
  }
 
  template <typename DescribeAnalysisRequestT = Model::DescribeAnalysisRequest>
  void DescribeAnalysisAsync(const DescribeAnalysisRequestT& request, const DescribeAnalysisResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeAnalysis, request, handler, context);
  }
 
  virtual Model::DescribeAnalysisDefinitionOutcome DescribeAnalysisDefinition(
      const Model::DescribeAnalysisDefinitionRequest& request) const;
 
  template <typename DescribeAnalysisDefinitionRequestT = Model::DescribeAnalysisDefinitionRequest>
  Model::DescribeAnalysisDefinitionOutcomeCallable DescribeAnalysisDefinitionCallable(
      const DescribeAnalysisDefinitionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeAnalysisDefinition, request);
  }
 
  template <typename DescribeAnalysisDefinitionRequestT = Model::DescribeAnalysisDefinitionRequest>
  void DescribeAnalysisDefinitionAsync(const DescribeAnalysisDefinitionRequestT& request,
                                       const DescribeAnalysisDefinitionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeAnalysisDefinition, request, handler, context);
  }
 
  virtual Model::DescribeAnalysisPermissionsOutcome DescribeAnalysisPermissions(
      const Model::DescribeAnalysisPermissionsRequest& request) const;
 
  template <typename DescribeAnalysisPermissionsRequestT = Model::DescribeAnalysisPermissionsRequest>
  Model::DescribeAnalysisPermissionsOutcomeCallable DescribeAnalysisPermissionsCallable(
      const DescribeAnalysisPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeAnalysisPermissions, request);
  }
 
  template <typename DescribeAnalysisPermissionsRequestT = Model::DescribeAnalysisPermissionsRequest>
  void DescribeAnalysisPermissionsAsync(const DescribeAnalysisPermissionsRequestT& request,
                                        const DescribeAnalysisPermissionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeAnalysisPermissions, request, handler, context);
  }
 
  virtual Model::DescribeAssetBundleExportJobOutcome DescribeAssetBundleExportJob(
      const Model::DescribeAssetBundleExportJobRequest& request) const;
 
  template <typename DescribeAssetBundleExportJobRequestT = Model::DescribeAssetBundleExportJobRequest>
  Model::DescribeAssetBundleExportJobOutcomeCallable DescribeAssetBundleExportJobCallable(
      const DescribeAssetBundleExportJobRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeAssetBundleExportJob, request);
  }
 
  template <typename DescribeAssetBundleExportJobRequestT = Model::DescribeAssetBundleExportJobRequest>
  void DescribeAssetBundleExportJobAsync(const DescribeAssetBundleExportJobRequestT& request,
                                         const DescribeAssetBundleExportJobResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeAssetBundleExportJob, request, handler, context);
  }
 
  virtual Model::DescribeAssetBundleImportJobOutcome DescribeAssetBundleImportJob(
      const Model::DescribeAssetBundleImportJobRequest& request) const;
 
  template <typename DescribeAssetBundleImportJobRequestT = Model::DescribeAssetBundleImportJobRequest>
  Model::DescribeAssetBundleImportJobOutcomeCallable DescribeAssetBundleImportJobCallable(
      const DescribeAssetBundleImportJobRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeAssetBundleImportJob, request);
  }
 
  template <typename DescribeAssetBundleImportJobRequestT = Model::DescribeAssetBundleImportJobRequest>
  void DescribeAssetBundleImportJobAsync(const DescribeAssetBundleImportJobRequestT& request,
                                         const DescribeAssetBundleImportJobResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeAssetBundleImportJob, request, handler, context);
  }
 
  virtual Model::DescribeAutomationJobOutcome DescribeAutomationJob(const Model::DescribeAutomationJobRequest& request) const;
 
  template <typename DescribeAutomationJobRequestT = Model::DescribeAutomationJobRequest>
  Model::DescribeAutomationJobOutcomeCallable DescribeAutomationJobCallable(const DescribeAutomationJobRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeAutomationJob, request);
  }
 
  template <typename DescribeAutomationJobRequestT = Model::DescribeAutomationJobRequest>
  void DescribeAutomationJobAsync(const DescribeAutomationJobRequestT& request, const DescribeAutomationJobResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeAutomationJob, request, handler, context);
  }
 
  virtual Model::DescribeBrandOutcome DescribeBrand(const Model::DescribeBrandRequest& request) const;
 
  template <typename DescribeBrandRequestT = Model::DescribeBrandRequest>
  Model::DescribeBrandOutcomeCallable DescribeBrandCallable(const DescribeBrandRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeBrand, request);
  }
 
  template <typename DescribeBrandRequestT = Model::DescribeBrandRequest>
  void DescribeBrandAsync(const DescribeBrandRequestT& request, const DescribeBrandResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeBrand, request, handler, context);
  }
 
  virtual Model::DescribeBrandAssignmentOutcome DescribeBrandAssignment(const Model::DescribeBrandAssignmentRequest& request) const;
 
  template <typename DescribeBrandAssignmentRequestT = Model::DescribeBrandAssignmentRequest>
  Model::DescribeBrandAssignmentOutcomeCallable DescribeBrandAssignmentCallable(const DescribeBrandAssignmentRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeBrandAssignment, request);
  }
 
  template <typename DescribeBrandAssignmentRequestT = Model::DescribeBrandAssignmentRequest>
  void DescribeBrandAssignmentAsync(const DescribeBrandAssignmentRequestT& request,
                                    const DescribeBrandAssignmentResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeBrandAssignment, request, handler, context);
  }
 
  virtual Model::DescribeBrandPublishedVersionOutcome DescribeBrandPublishedVersion(
      const Model::DescribeBrandPublishedVersionRequest& request) const;
 
  template <typename DescribeBrandPublishedVersionRequestT = Model::DescribeBrandPublishedVersionRequest>
  Model::DescribeBrandPublishedVersionOutcomeCallable DescribeBrandPublishedVersionCallable(
      const DescribeBrandPublishedVersionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeBrandPublishedVersion, request);
  }
 
  template <typename DescribeBrandPublishedVersionRequestT = Model::DescribeBrandPublishedVersionRequest>
  void DescribeBrandPublishedVersionAsync(const DescribeBrandPublishedVersionRequestT& request,
                                          const DescribeBrandPublishedVersionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeBrandPublishedVersion, request, handler, context);
  }
 
  virtual Model::DescribeCustomPermissionsOutcome DescribeCustomPermissions(const Model::DescribeCustomPermissionsRequest& request) const;
 
  template <typename DescribeCustomPermissionsRequestT = Model::DescribeCustomPermissionsRequest>
  Model::DescribeCustomPermissionsOutcomeCallable DescribeCustomPermissionsCallable(
      const DescribeCustomPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeCustomPermissions, request);
  }
 
  template <typename DescribeCustomPermissionsRequestT = Model::DescribeCustomPermissionsRequest>
  void DescribeCustomPermissionsAsync(const DescribeCustomPermissionsRequestT& request,
                                      const DescribeCustomPermissionsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeCustomPermissions, request, handler, context);
  }
 
  virtual Model::DescribeDashboardOutcome DescribeDashboard(const Model::DescribeDashboardRequest& request) const;
 
  template <typename DescribeDashboardRequestT = Model::DescribeDashboardRequest>
  Model::DescribeDashboardOutcomeCallable DescribeDashboardCallable(const DescribeDashboardRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeDashboard, request);
  }
 
  template <typename DescribeDashboardRequestT = Model::DescribeDashboardRequest>
  void DescribeDashboardAsync(const DescribeDashboardRequestT& request, const DescribeDashboardResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeDashboard, request, handler, context);
  }
 
  virtual Model::DescribeDashboardDefinitionOutcome DescribeDashboardDefinition(
      const Model::DescribeDashboardDefinitionRequest& request) const;
 
  template <typename DescribeDashboardDefinitionRequestT = Model::DescribeDashboardDefinitionRequest>
  Model::DescribeDashboardDefinitionOutcomeCallable DescribeDashboardDefinitionCallable(
      const DescribeDashboardDefinitionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeDashboardDefinition, request);
  }
 
  template <typename DescribeDashboardDefinitionRequestT = Model::DescribeDashboardDefinitionRequest>
  void DescribeDashboardDefinitionAsync(const DescribeDashboardDefinitionRequestT& request,
                                        const DescribeDashboardDefinitionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeDashboardDefinition, request, handler, context);
  }
 
  virtual Model::DescribeDashboardPermissionsOutcome DescribeDashboardPermissions(
      const Model::DescribeDashboardPermissionsRequest& request) const;
 
  template <typename DescribeDashboardPermissionsRequestT = Model::DescribeDashboardPermissionsRequest>
  Model::DescribeDashboardPermissionsOutcomeCallable DescribeDashboardPermissionsCallable(
      const DescribeDashboardPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeDashboardPermissions, request);
  }
 
  template <typename DescribeDashboardPermissionsRequestT = Model::DescribeDashboardPermissionsRequest>
  void DescribeDashboardPermissionsAsync(const DescribeDashboardPermissionsRequestT& request,
                                         const DescribeDashboardPermissionsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeDashboardPermissions, request, handler, context);
  }
 
  virtual Model::DescribeDashboardSnapshotJobOutcome DescribeDashboardSnapshotJob(
      const Model::DescribeDashboardSnapshotJobRequest& request) const;
 
  template <typename DescribeDashboardSnapshotJobRequestT = Model::DescribeDashboardSnapshotJobRequest>
  Model::DescribeDashboardSnapshotJobOutcomeCallable DescribeDashboardSnapshotJobCallable(
      const DescribeDashboardSnapshotJobRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeDashboardSnapshotJob, request);
  }
 
  template <typename DescribeDashboardSnapshotJobRequestT = Model::DescribeDashboardSnapshotJobRequest>
  void DescribeDashboardSnapshotJobAsync(const DescribeDashboardSnapshotJobRequestT& request,
                                         const DescribeDashboardSnapshotJobResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeDashboardSnapshotJob, request, handler, context);
  }
 
  virtual Model::DescribeDashboardSnapshotJobResultOutcome DescribeDashboardSnapshotJobResult(
      const Model::DescribeDashboardSnapshotJobResultRequest& request) const;
 
  template <typename DescribeDashboardSnapshotJobResultRequestT = Model::DescribeDashboardSnapshotJobResultRequest>
  Model::DescribeDashboardSnapshotJobResultOutcomeCallable DescribeDashboardSnapshotJobResultCallable(
      const DescribeDashboardSnapshotJobResultRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeDashboardSnapshotJobResult, request);
  }
 
  template <typename DescribeDashboardSnapshotJobResultRequestT = Model::DescribeDashboardSnapshotJobResultRequest>
  void DescribeDashboardSnapshotJobResultAsync(const DescribeDashboardSnapshotJobResultRequestT& request,
                                               const DescribeDashboardSnapshotJobResultResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeDashboardSnapshotJobResult, request, handler, context);
  }
 
  virtual Model::DescribeDashboardsQAConfigurationOutcome DescribeDashboardsQAConfiguration(
      const Model::DescribeDashboardsQAConfigurationRequest& request) const;
 
  template <typename DescribeDashboardsQAConfigurationRequestT = Model::DescribeDashboardsQAConfigurationRequest>
  Model::DescribeDashboardsQAConfigurationOutcomeCallable DescribeDashboardsQAConfigurationCallable(
      const DescribeDashboardsQAConfigurationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeDashboardsQAConfiguration, request);
  }
 
  template <typename DescribeDashboardsQAConfigurationRequestT = Model::DescribeDashboardsQAConfigurationRequest>
  void DescribeDashboardsQAConfigurationAsync(const DescribeDashboardsQAConfigurationRequestT& request,
                                              const DescribeDashboardsQAConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeDashboardsQAConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeDataSetOutcome DescribeDataSet(const Model::DescribeDataSetRequest& request) const;
 
  template <typename DescribeDataSetRequestT = Model::DescribeDataSetRequest>
  Model::DescribeDataSetOutcomeCallable DescribeDataSetCallable(const DescribeDataSetRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeDataSet, request);
  }
 
  template <typename DescribeDataSetRequestT = Model::DescribeDataSetRequest>
  void DescribeDataSetAsync(const DescribeDataSetRequestT& request, const DescribeDataSetResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeDataSet, request, handler, context);
  }
 
  virtual Model::DescribeDataSetPermissionsOutcome DescribeDataSetPermissions(
      const Model::DescribeDataSetPermissionsRequest& request) const;
 
  template <typename DescribeDataSetPermissionsRequestT = Model::DescribeDataSetPermissionsRequest>
  Model::DescribeDataSetPermissionsOutcomeCallable DescribeDataSetPermissionsCallable(
      const DescribeDataSetPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeDataSetPermissions, request);
  }
 
  template <typename DescribeDataSetPermissionsRequestT = Model::DescribeDataSetPermissionsRequest>
  void DescribeDataSetPermissionsAsync(const DescribeDataSetPermissionsRequestT& request,
                                       const DescribeDataSetPermissionsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeDataSetPermissions, request, handler, context);
  }
 
  virtual Model::DescribeDataSetRefreshPropertiesOutcome DescribeDataSetRefreshProperties(
      const Model::DescribeDataSetRefreshPropertiesRequest& request) const;
 
  template <typename DescribeDataSetRefreshPropertiesRequestT = Model::DescribeDataSetRefreshPropertiesRequest>
  Model::DescribeDataSetRefreshPropertiesOutcomeCallable DescribeDataSetRefreshPropertiesCallable(
      const DescribeDataSetRefreshPropertiesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeDataSetRefreshProperties, request);
  }
 
  template <typename DescribeDataSetRefreshPropertiesRequestT = Model::DescribeDataSetRefreshPropertiesRequest>
  void DescribeDataSetRefreshPropertiesAsync(const DescribeDataSetRefreshPropertiesRequestT& request,
                                             const DescribeDataSetRefreshPropertiesResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeDataSetRefreshProperties, request, handler, context);
  }
 
  virtual Model::DescribeDataSourceOutcome DescribeDataSource(const Model::DescribeDataSourceRequest& request) const;
 
  template <typename DescribeDataSourceRequestT = Model::DescribeDataSourceRequest>
  Model::DescribeDataSourceOutcomeCallable DescribeDataSourceCallable(const DescribeDataSourceRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeDataSource, request);
  }
 
  template <typename DescribeDataSourceRequestT = Model::DescribeDataSourceRequest>
  void DescribeDataSourceAsync(const DescribeDataSourceRequestT& request, const DescribeDataSourceResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeDataSource, request, handler, context);
  }
 
  virtual Model::DescribeDataSourcePermissionsOutcome DescribeDataSourcePermissions(
      const Model::DescribeDataSourcePermissionsRequest& request) const;
 
  template <typename DescribeDataSourcePermissionsRequestT = Model::DescribeDataSourcePermissionsRequest>
  Model::DescribeDataSourcePermissionsOutcomeCallable DescribeDataSourcePermissionsCallable(
      const DescribeDataSourcePermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeDataSourcePermissions, request);
  }
 
  template <typename DescribeDataSourcePermissionsRequestT = Model::DescribeDataSourcePermissionsRequest>
  void DescribeDataSourcePermissionsAsync(const DescribeDataSourcePermissionsRequestT& request,
                                          const DescribeDataSourcePermissionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeDataSourcePermissions, request, handler, context);
  }
 
  virtual Model::DescribeDefaultQBusinessApplicationOutcome DescribeDefaultQBusinessApplication(
      const Model::DescribeDefaultQBusinessApplicationRequest& request) const;
 
  template <typename DescribeDefaultQBusinessApplicationRequestT = Model::DescribeDefaultQBusinessApplicationRequest>
  Model::DescribeDefaultQBusinessApplicationOutcomeCallable DescribeDefaultQBusinessApplicationCallable(
      const DescribeDefaultQBusinessApplicationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeDefaultQBusinessApplication, request);
  }
 
  template <typename DescribeDefaultQBusinessApplicationRequestT = Model::DescribeDefaultQBusinessApplicationRequest>
  void DescribeDefaultQBusinessApplicationAsync(const DescribeDefaultQBusinessApplicationRequestT& request,
                                                const DescribeDefaultQBusinessApplicationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeDefaultQBusinessApplication, request, handler, context);
  }
 
  virtual Model::DescribeFlowOutcome DescribeFlow(const Model::DescribeFlowRequest& request) const;
 
  template <typename DescribeFlowRequestT = Model::DescribeFlowRequest>
  Model::DescribeFlowOutcomeCallable DescribeFlowCallable(const DescribeFlowRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeFlow, request);
  }
 
  template <typename DescribeFlowRequestT = Model::DescribeFlowRequest>
  void DescribeFlowAsync(const DescribeFlowRequestT& request, const DescribeFlowResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeFlow, request, handler, context);
  }
 
  virtual Model::DescribeFolderOutcome DescribeFolder(const Model::DescribeFolderRequest& request) const;
 
  template <typename DescribeFolderRequestT = Model::DescribeFolderRequest>
  Model::DescribeFolderOutcomeCallable DescribeFolderCallable(const DescribeFolderRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeFolder, request);
  }
 
  template <typename DescribeFolderRequestT = Model::DescribeFolderRequest>
  void DescribeFolderAsync(const DescribeFolderRequestT& request, const DescribeFolderResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeFolder, request, handler, context);
  }
 
  virtual Model::DescribeFolderPermissionsOutcome DescribeFolderPermissions(const Model::DescribeFolderPermissionsRequest& request) const;
 
  template <typename DescribeFolderPermissionsRequestT = Model::DescribeFolderPermissionsRequest>
  Model::DescribeFolderPermissionsOutcomeCallable DescribeFolderPermissionsCallable(
      const DescribeFolderPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeFolderPermissions, request);
  }
 
  template <typename DescribeFolderPermissionsRequestT = Model::DescribeFolderPermissionsRequest>
  void DescribeFolderPermissionsAsync(const DescribeFolderPermissionsRequestT& request,
                                      const DescribeFolderPermissionsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeFolderPermissions, request, handler, context);
  }
 
  virtual Model::DescribeFolderResolvedPermissionsOutcome DescribeFolderResolvedPermissions(
      const Model::DescribeFolderResolvedPermissionsRequest& request) const;
 
  template <typename DescribeFolderResolvedPermissionsRequestT = Model::DescribeFolderResolvedPermissionsRequest>
  Model::DescribeFolderResolvedPermissionsOutcomeCallable DescribeFolderResolvedPermissionsCallable(
      const DescribeFolderResolvedPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeFolderResolvedPermissions, request);
  }
 
  template <typename DescribeFolderResolvedPermissionsRequestT = Model::DescribeFolderResolvedPermissionsRequest>
  void DescribeFolderResolvedPermissionsAsync(const DescribeFolderResolvedPermissionsRequestT& request,
                                              const DescribeFolderResolvedPermissionsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeFolderResolvedPermissions, request, handler, context);
  }
 
  virtual Model::DescribeGroupOutcome DescribeGroup(const Model::DescribeGroupRequest& request) const;
 
  template <typename DescribeGroupRequestT = Model::DescribeGroupRequest>
  Model::DescribeGroupOutcomeCallable DescribeGroupCallable(const DescribeGroupRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeGroup, request);
  }
 
  template <typename DescribeGroupRequestT = Model::DescribeGroupRequest>
  void DescribeGroupAsync(const DescribeGroupRequestT& request, const DescribeGroupResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeGroup, request, handler, context);
  }
 
  virtual Model::DescribeGroupMembershipOutcome DescribeGroupMembership(const Model::DescribeGroupMembershipRequest& request) const;
 
  template <typename DescribeGroupMembershipRequestT = Model::DescribeGroupMembershipRequest>
  Model::DescribeGroupMembershipOutcomeCallable DescribeGroupMembershipCallable(const DescribeGroupMembershipRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeGroupMembership, request);
  }
 
  template <typename DescribeGroupMembershipRequestT = Model::DescribeGroupMembershipRequest>
  void DescribeGroupMembershipAsync(const DescribeGroupMembershipRequestT& request,
                                    const DescribeGroupMembershipResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeGroupMembership, request, handler, context);
  }
 
  virtual Model::DescribeIAMPolicyAssignmentOutcome DescribeIAMPolicyAssignment(
      const Model::DescribeIAMPolicyAssignmentRequest& request) const;
 
  template <typename DescribeIAMPolicyAssignmentRequestT = Model::DescribeIAMPolicyAssignmentRequest>
  Model::DescribeIAMPolicyAssignmentOutcomeCallable DescribeIAMPolicyAssignmentCallable(
      const DescribeIAMPolicyAssignmentRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeIAMPolicyAssignment, request);
  }
 
  template <typename DescribeIAMPolicyAssignmentRequestT = Model::DescribeIAMPolicyAssignmentRequest>
  void DescribeIAMPolicyAssignmentAsync(const DescribeIAMPolicyAssignmentRequestT& request,
                                        const DescribeIAMPolicyAssignmentResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeIAMPolicyAssignment, request, handler, context);
  }
 
  virtual Model::DescribeIngestionOutcome DescribeIngestion(const Model::DescribeIngestionRequest& request) const;
 
  template <typename DescribeIngestionRequestT = Model::DescribeIngestionRequest>
  Model::DescribeIngestionOutcomeCallable DescribeIngestionCallable(const DescribeIngestionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeIngestion, request);
  }
 
  template <typename DescribeIngestionRequestT = Model::DescribeIngestionRequest>
  void DescribeIngestionAsync(const DescribeIngestionRequestT& request, const DescribeIngestionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeIngestion, request, handler, context);
  }
 
  virtual Model::DescribeIpRestrictionOutcome DescribeIpRestriction(const Model::DescribeIpRestrictionRequest& request) const;
 
  template <typename DescribeIpRestrictionRequestT = Model::DescribeIpRestrictionRequest>
  Model::DescribeIpRestrictionOutcomeCallable DescribeIpRestrictionCallable(const DescribeIpRestrictionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeIpRestriction, request);
  }
 
  template <typename DescribeIpRestrictionRequestT = Model::DescribeIpRestrictionRequest>
  void DescribeIpRestrictionAsync(const DescribeIpRestrictionRequestT& request, const DescribeIpRestrictionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeIpRestriction, request, handler, context);
  }
 
  virtual Model::DescribeKeyRegistrationOutcome DescribeKeyRegistration(const Model::DescribeKeyRegistrationRequest& request) const;
 
  template <typename DescribeKeyRegistrationRequestT = Model::DescribeKeyRegistrationRequest>
  Model::DescribeKeyRegistrationOutcomeCallable DescribeKeyRegistrationCallable(const DescribeKeyRegistrationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeKeyRegistration, request);
  }
 
  template <typename DescribeKeyRegistrationRequestT = Model::DescribeKeyRegistrationRequest>
  void DescribeKeyRegistrationAsync(const DescribeKeyRegistrationRequestT& request,
                                    const DescribeKeyRegistrationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeKeyRegistration, request, handler, context);
  }
 
  virtual Model::DescribeKnowledgeBaseOutcome DescribeKnowledgeBase(const Model::DescribeKnowledgeBaseRequest& request) const;
 
  template <typename DescribeKnowledgeBaseRequestT = Model::DescribeKnowledgeBaseRequest>
  Model::DescribeKnowledgeBaseOutcomeCallable DescribeKnowledgeBaseCallable(const DescribeKnowledgeBaseRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeKnowledgeBase, request);
  }
 
  template <typename DescribeKnowledgeBaseRequestT = Model::DescribeKnowledgeBaseRequest>
  void DescribeKnowledgeBaseAsync(const DescribeKnowledgeBaseRequestT& request, const DescribeKnowledgeBaseResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeKnowledgeBase, request, handler, context);
  }
 
  virtual Model::DescribeKnowledgeBasePermissionsOutcome DescribeKnowledgeBasePermissions(
      const Model::DescribeKnowledgeBasePermissionsRequest& request) const;
 
  template <typename DescribeKnowledgeBasePermissionsRequestT = Model::DescribeKnowledgeBasePermissionsRequest>
  Model::DescribeKnowledgeBasePermissionsOutcomeCallable DescribeKnowledgeBasePermissionsCallable(
      const DescribeKnowledgeBasePermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeKnowledgeBasePermissions, request);
  }
 
  template <typename DescribeKnowledgeBasePermissionsRequestT = Model::DescribeKnowledgeBasePermissionsRequest>
  void DescribeKnowledgeBasePermissionsAsync(const DescribeKnowledgeBasePermissionsRequestT& request,
                                             const DescribeKnowledgeBasePermissionsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeKnowledgeBasePermissions, request, handler, context);
  }
 
  virtual Model::DescribeNamespaceOutcome DescribeNamespace(const Model::DescribeNamespaceRequest& request) const;
 
  template <typename DescribeNamespaceRequestT = Model::DescribeNamespaceRequest>
  Model::DescribeNamespaceOutcomeCallable DescribeNamespaceCallable(const DescribeNamespaceRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeNamespace, request);
  }
 
  template <typename DescribeNamespaceRequestT = Model::DescribeNamespaceRequest>
  void DescribeNamespaceAsync(const DescribeNamespaceRequestT& request, const DescribeNamespaceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeNamespace, request, handler, context);
  }
 
  virtual Model::DescribeOAuthClientApplicationOutcome DescribeOAuthClientApplication(
      const Model::DescribeOAuthClientApplicationRequest& request) const;
 
  template <typename DescribeOAuthClientApplicationRequestT = Model::DescribeOAuthClientApplicationRequest>
  Model::DescribeOAuthClientApplicationOutcomeCallable DescribeOAuthClientApplicationCallable(
      const DescribeOAuthClientApplicationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeOAuthClientApplication, request);
  }
 
  template <typename DescribeOAuthClientApplicationRequestT = Model::DescribeOAuthClientApplicationRequest>
  void DescribeOAuthClientApplicationAsync(const DescribeOAuthClientApplicationRequestT& request,
                                           const DescribeOAuthClientApplicationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeOAuthClientApplication, request, handler, context);
  }
 
  virtual Model::DescribeQPersonalizationConfigurationOutcome DescribeQPersonalizationConfiguration(
      const Model::DescribeQPersonalizationConfigurationRequest& request) const;
 
  template <typename DescribeQPersonalizationConfigurationRequestT = Model::DescribeQPersonalizationConfigurationRequest>
  Model::DescribeQPersonalizationConfigurationOutcomeCallable DescribeQPersonalizationConfigurationCallable(
      const DescribeQPersonalizationConfigurationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeQPersonalizationConfiguration, request);
  }
 
  template <typename DescribeQPersonalizationConfigurationRequestT = Model::DescribeQPersonalizationConfigurationRequest>
  void DescribeQPersonalizationConfigurationAsync(const DescribeQPersonalizationConfigurationRequestT& request,
                                                  const DescribeQPersonalizationConfigurationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeQPersonalizationConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeQuickSightQSearchConfigurationOutcome DescribeQuickSightQSearchConfiguration(
      const Model::DescribeQuickSightQSearchConfigurationRequest& request) const;
 
  template <typename DescribeQuickSightQSearchConfigurationRequestT = Model::DescribeQuickSightQSearchConfigurationRequest>
  Model::DescribeQuickSightQSearchConfigurationOutcomeCallable DescribeQuickSightQSearchConfigurationCallable(
      const DescribeQuickSightQSearchConfigurationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeQuickSightQSearchConfiguration, request);
  }
 
  template <typename DescribeQuickSightQSearchConfigurationRequestT = Model::DescribeQuickSightQSearchConfigurationRequest>
  void DescribeQuickSightQSearchConfigurationAsync(const DescribeQuickSightQSearchConfigurationRequestT& request,
                                                   const DescribeQuickSightQSearchConfigurationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeQuickSightQSearchConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeRefreshScheduleOutcome DescribeRefreshSchedule(const Model::DescribeRefreshScheduleRequest& request) const;
 
  template <typename DescribeRefreshScheduleRequestT = Model::DescribeRefreshScheduleRequest>
  Model::DescribeRefreshScheduleOutcomeCallable DescribeRefreshScheduleCallable(const DescribeRefreshScheduleRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeRefreshSchedule, request);
  }
 
  template <typename DescribeRefreshScheduleRequestT = Model::DescribeRefreshScheduleRequest>
  void DescribeRefreshScheduleAsync(const DescribeRefreshScheduleRequestT& request,
                                    const DescribeRefreshScheduleResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeRefreshSchedule, request, handler, context);
  }
 
  virtual Model::DescribeRoleCustomPermissionOutcome DescribeRoleCustomPermission(
      const Model::DescribeRoleCustomPermissionRequest& request) const;
 
  template <typename DescribeRoleCustomPermissionRequestT = Model::DescribeRoleCustomPermissionRequest>
  Model::DescribeRoleCustomPermissionOutcomeCallable DescribeRoleCustomPermissionCallable(
      const DescribeRoleCustomPermissionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeRoleCustomPermission, request);
  }
 
  template <typename DescribeRoleCustomPermissionRequestT = Model::DescribeRoleCustomPermissionRequest>
  void DescribeRoleCustomPermissionAsync(const DescribeRoleCustomPermissionRequestT& request,
                                         const DescribeRoleCustomPermissionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeRoleCustomPermission, request, handler, context);
  }
 
  virtual Model::DescribeSelfUpgradeConfigurationOutcome DescribeSelfUpgradeConfiguration(
      const Model::DescribeSelfUpgradeConfigurationRequest& request) const;
 
  template <typename DescribeSelfUpgradeConfigurationRequestT = Model::DescribeSelfUpgradeConfigurationRequest>
  Model::DescribeSelfUpgradeConfigurationOutcomeCallable DescribeSelfUpgradeConfigurationCallable(
      const DescribeSelfUpgradeConfigurationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeSelfUpgradeConfiguration, request);
  }
 
  template <typename DescribeSelfUpgradeConfigurationRequestT = Model::DescribeSelfUpgradeConfigurationRequest>
  void DescribeSelfUpgradeConfigurationAsync(const DescribeSelfUpgradeConfigurationRequestT& request,
                                             const DescribeSelfUpgradeConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeSelfUpgradeConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeSpaceOutcome DescribeSpace(const Model::DescribeSpaceRequest& request) const;
 
  template <typename DescribeSpaceRequestT = Model::DescribeSpaceRequest>
  Model::DescribeSpaceOutcomeCallable DescribeSpaceCallable(const DescribeSpaceRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeSpace, request);
  }
 
  template <typename DescribeSpaceRequestT = Model::DescribeSpaceRequest>
  void DescribeSpaceAsync(const DescribeSpaceRequestT& request, const DescribeSpaceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeSpace, request, handler, context);
  }
 
  virtual Model::DescribeSpacePermissionsOutcome DescribeSpacePermissions(const Model::DescribeSpacePermissionsRequest& request) const;
 
  template <typename DescribeSpacePermissionsRequestT = Model::DescribeSpacePermissionsRequest>
  Model::DescribeSpacePermissionsOutcomeCallable DescribeSpacePermissionsCallable(const DescribeSpacePermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeSpacePermissions, request);
  }
 
  template <typename DescribeSpacePermissionsRequestT = Model::DescribeSpacePermissionsRequest>
  void DescribeSpacePermissionsAsync(const DescribeSpacePermissionsRequestT& request,
                                     const DescribeSpacePermissionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeSpacePermissions, request, handler, context);
  }
 
  virtual Model::DescribeTemplateOutcome DescribeTemplate(const Model::DescribeTemplateRequest& request) const;
 
  template <typename DescribeTemplateRequestT = Model::DescribeTemplateRequest>
  Model::DescribeTemplateOutcomeCallable DescribeTemplateCallable(const DescribeTemplateRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeTemplate, request);
  }
 
  template <typename DescribeTemplateRequestT = Model::DescribeTemplateRequest>
  void DescribeTemplateAsync(const DescribeTemplateRequestT& request, const DescribeTemplateResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeTemplate, request, handler, context);
  }
 
  virtual Model::DescribeTemplateAliasOutcome DescribeTemplateAlias(const Model::DescribeTemplateAliasRequest& request) const;
 
  template <typename DescribeTemplateAliasRequestT = Model::DescribeTemplateAliasRequest>
  Model::DescribeTemplateAliasOutcomeCallable DescribeTemplateAliasCallable(const DescribeTemplateAliasRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeTemplateAlias, request);
  }
 
  template <typename DescribeTemplateAliasRequestT = Model::DescribeTemplateAliasRequest>
  void DescribeTemplateAliasAsync(const DescribeTemplateAliasRequestT& request, const DescribeTemplateAliasResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeTemplateAlias, request, handler, context);
  }
 
  virtual Model::DescribeTemplateDefinitionOutcome DescribeTemplateDefinition(
      const Model::DescribeTemplateDefinitionRequest& request) const;
 
  template <typename DescribeTemplateDefinitionRequestT = Model::DescribeTemplateDefinitionRequest>
  Model::DescribeTemplateDefinitionOutcomeCallable DescribeTemplateDefinitionCallable(
      const DescribeTemplateDefinitionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeTemplateDefinition, request);
  }
 
  template <typename DescribeTemplateDefinitionRequestT = Model::DescribeTemplateDefinitionRequest>
  void DescribeTemplateDefinitionAsync(const DescribeTemplateDefinitionRequestT& request,
                                       const DescribeTemplateDefinitionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeTemplateDefinition, request, handler, context);
  }
 
  virtual Model::DescribeTemplatePermissionsOutcome DescribeTemplatePermissions(
      const Model::DescribeTemplatePermissionsRequest& request) const;
 
  template <typename DescribeTemplatePermissionsRequestT = Model::DescribeTemplatePermissionsRequest>
  Model::DescribeTemplatePermissionsOutcomeCallable DescribeTemplatePermissionsCallable(
      const DescribeTemplatePermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeTemplatePermissions, request);
  }
 
  template <typename DescribeTemplatePermissionsRequestT = Model::DescribeTemplatePermissionsRequest>
  void DescribeTemplatePermissionsAsync(const DescribeTemplatePermissionsRequestT& request,
                                        const DescribeTemplatePermissionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeTemplatePermissions, request, handler, context);
  }
 
  virtual Model::DescribeThemeOutcome DescribeTheme(const Model::DescribeThemeRequest& request) const;
 
  template <typename DescribeThemeRequestT = Model::DescribeThemeRequest>
  Model::DescribeThemeOutcomeCallable DescribeThemeCallable(const DescribeThemeRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeTheme, request);
  }
 
  template <typename DescribeThemeRequestT = Model::DescribeThemeRequest>
  void DescribeThemeAsync(const DescribeThemeRequestT& request, const DescribeThemeResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeTheme, request, handler, context);
  }
 
  virtual Model::DescribeThemeAliasOutcome DescribeThemeAlias(const Model::DescribeThemeAliasRequest& request) const;
 
  template <typename DescribeThemeAliasRequestT = Model::DescribeThemeAliasRequest>
  Model::DescribeThemeAliasOutcomeCallable DescribeThemeAliasCallable(const DescribeThemeAliasRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeThemeAlias, request);
  }
 
  template <typename DescribeThemeAliasRequestT = Model::DescribeThemeAliasRequest>
  void DescribeThemeAliasAsync(const DescribeThemeAliasRequestT& request, const DescribeThemeAliasResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeThemeAlias, request, handler, context);
  }
 
  virtual Model::DescribeThemePermissionsOutcome DescribeThemePermissions(const Model::DescribeThemePermissionsRequest& request) const;
 
  template <typename DescribeThemePermissionsRequestT = Model::DescribeThemePermissionsRequest>
  Model::DescribeThemePermissionsOutcomeCallable DescribeThemePermissionsCallable(const DescribeThemePermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeThemePermissions, request);
  }
 
  template <typename DescribeThemePermissionsRequestT = Model::DescribeThemePermissionsRequest>
  void DescribeThemePermissionsAsync(const DescribeThemePermissionsRequestT& request,
                                     const DescribeThemePermissionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeThemePermissions, request, handler, context);
  }
 
  virtual Model::DescribeTopicOutcome DescribeTopic(const Model::DescribeTopicRequest& request) const;
 
  template <typename DescribeTopicRequestT = Model::DescribeTopicRequest>
  Model::DescribeTopicOutcomeCallable DescribeTopicCallable(const DescribeTopicRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeTopic, request);
  }
 
  template <typename DescribeTopicRequestT = Model::DescribeTopicRequest>
  void DescribeTopicAsync(const DescribeTopicRequestT& request, const DescribeTopicResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeTopic, request, handler, context);
  }
 
  virtual Model::DescribeTopicPermissionsOutcome DescribeTopicPermissions(const Model::DescribeTopicPermissionsRequest& request) const;
 
  template <typename DescribeTopicPermissionsRequestT = Model::DescribeTopicPermissionsRequest>
  Model::DescribeTopicPermissionsOutcomeCallable DescribeTopicPermissionsCallable(const DescribeTopicPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeTopicPermissions, request);
  }
 
  template <typename DescribeTopicPermissionsRequestT = Model::DescribeTopicPermissionsRequest>
  void DescribeTopicPermissionsAsync(const DescribeTopicPermissionsRequestT& request,
                                     const DescribeTopicPermissionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeTopicPermissions, request, handler, context);
  }
 
  virtual Model::DescribeTopicRefreshOutcome DescribeTopicRefresh(const Model::DescribeTopicRefreshRequest& request) const;
 
  template <typename DescribeTopicRefreshRequestT = Model::DescribeTopicRefreshRequest>
  Model::DescribeTopicRefreshOutcomeCallable DescribeTopicRefreshCallable(const DescribeTopicRefreshRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeTopicRefresh, request);
  }
 
  template <typename DescribeTopicRefreshRequestT = Model::DescribeTopicRefreshRequest>
  void DescribeTopicRefreshAsync(const DescribeTopicRefreshRequestT& request, const DescribeTopicRefreshResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeTopicRefresh, request, handler, context);
  }
 
  virtual Model::DescribeTopicRefreshScheduleOutcome DescribeTopicRefreshSchedule(
      const Model::DescribeTopicRefreshScheduleRequest& request) const;
 
  template <typename DescribeTopicRefreshScheduleRequestT = Model::DescribeTopicRefreshScheduleRequest>
  Model::DescribeTopicRefreshScheduleOutcomeCallable DescribeTopicRefreshScheduleCallable(
      const DescribeTopicRefreshScheduleRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeTopicRefreshSchedule, request);
  }
 
  template <typename DescribeTopicRefreshScheduleRequestT = Model::DescribeTopicRefreshScheduleRequest>
  void DescribeTopicRefreshScheduleAsync(const DescribeTopicRefreshScheduleRequestT& request,
                                         const DescribeTopicRefreshScheduleResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeTopicRefreshSchedule, request, handler, context);
  }
 
  virtual Model::DescribeUserOutcome DescribeUser(const Model::DescribeUserRequest& request) const;
 
  template <typename DescribeUserRequestT = Model::DescribeUserRequest>
  Model::DescribeUserOutcomeCallable DescribeUserCallable(const DescribeUserRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeUser, request);
  }
 
  template <typename DescribeUserRequestT = Model::DescribeUserRequest>
  void DescribeUserAsync(const DescribeUserRequestT& request, const DescribeUserResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeUser, request, handler, context);
  }
 
  virtual Model::DescribeVPCConnectionOutcome DescribeVPCConnection(const Model::DescribeVPCConnectionRequest& request) const;
 
  template <typename DescribeVPCConnectionRequestT = Model::DescribeVPCConnectionRequest>
  Model::DescribeVPCConnectionOutcomeCallable DescribeVPCConnectionCallable(const DescribeVPCConnectionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::DescribeVPCConnection, request);
  }
 
  template <typename DescribeVPCConnectionRequestT = Model::DescribeVPCConnectionRequest>
  void DescribeVPCConnectionAsync(const DescribeVPCConnectionRequestT& request, const DescribeVPCConnectionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::DescribeVPCConnection, request, handler, context);
  }
 
  virtual Model::GenerateEmbedUrlForAnonymousUserOutcome GenerateEmbedUrlForAnonymousUser(
      const Model::GenerateEmbedUrlForAnonymousUserRequest& request) const;
 
  template <typename GenerateEmbedUrlForAnonymousUserRequestT = Model::GenerateEmbedUrlForAnonymousUserRequest>
  Model::GenerateEmbedUrlForAnonymousUserOutcomeCallable GenerateEmbedUrlForAnonymousUserCallable(
      const GenerateEmbedUrlForAnonymousUserRequestT& request) const {
    return SubmitCallable(&QuickSightClient::GenerateEmbedUrlForAnonymousUser, request);
  }
 
  template <typename GenerateEmbedUrlForAnonymousUserRequestT = Model::GenerateEmbedUrlForAnonymousUserRequest>
  void GenerateEmbedUrlForAnonymousUserAsync(const GenerateEmbedUrlForAnonymousUserRequestT& request,
                                             const GenerateEmbedUrlForAnonymousUserResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::GenerateEmbedUrlForAnonymousUser, request, handler, context);
  }
 
  virtual Model::GenerateEmbedUrlForRegisteredUserOutcome GenerateEmbedUrlForRegisteredUser(
      const Model::GenerateEmbedUrlForRegisteredUserRequest& request) const;
 
  template <typename GenerateEmbedUrlForRegisteredUserRequestT = Model::GenerateEmbedUrlForRegisteredUserRequest>
  Model::GenerateEmbedUrlForRegisteredUserOutcomeCallable GenerateEmbedUrlForRegisteredUserCallable(
      const GenerateEmbedUrlForRegisteredUserRequestT& request) const {
    return SubmitCallable(&QuickSightClient::GenerateEmbedUrlForRegisteredUser, request);
  }
 
  template <typename GenerateEmbedUrlForRegisteredUserRequestT = Model::GenerateEmbedUrlForRegisteredUserRequest>
  void GenerateEmbedUrlForRegisteredUserAsync(const GenerateEmbedUrlForRegisteredUserRequestT& request,
                                              const GenerateEmbedUrlForRegisteredUserResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::GenerateEmbedUrlForRegisteredUser, request, handler, context);
  }
 
  virtual Model::GenerateEmbedUrlForRegisteredUserWithIdentityOutcome GenerateEmbedUrlForRegisteredUserWithIdentity(
      const Model::GenerateEmbedUrlForRegisteredUserWithIdentityRequest& request) const;
 
  template <typename GenerateEmbedUrlForRegisteredUserWithIdentityRequestT = Model::GenerateEmbedUrlForRegisteredUserWithIdentityRequest>
  Model::GenerateEmbedUrlForRegisteredUserWithIdentityOutcomeCallable GenerateEmbedUrlForRegisteredUserWithIdentityCallable(
      const GenerateEmbedUrlForRegisteredUserWithIdentityRequestT& request) const {
    return SubmitCallable(&QuickSightClient::GenerateEmbedUrlForRegisteredUserWithIdentity, request);
  }
 
  template <typename GenerateEmbedUrlForRegisteredUserWithIdentityRequestT = Model::GenerateEmbedUrlForRegisteredUserWithIdentityRequest>
  void GenerateEmbedUrlForRegisteredUserWithIdentityAsync(
      const GenerateEmbedUrlForRegisteredUserWithIdentityRequestT& request,
      const GenerateEmbedUrlForRegisteredUserWithIdentityResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::GenerateEmbedUrlForRegisteredUserWithIdentity, request, handler, context);
  }
 
  virtual Model::GetDashboardEmbedUrlOutcome GetDashboardEmbedUrl(const Model::GetDashboardEmbedUrlRequest& request) const;
 
  template <typename GetDashboardEmbedUrlRequestT = Model::GetDashboardEmbedUrlRequest>
  Model::GetDashboardEmbedUrlOutcomeCallable GetDashboardEmbedUrlCallable(const GetDashboardEmbedUrlRequestT& request) const {
    return SubmitCallable(&QuickSightClient::GetDashboardEmbedUrl, request);
  }
 
  template <typename GetDashboardEmbedUrlRequestT = Model::GetDashboardEmbedUrlRequest>
  void GetDashboardEmbedUrlAsync(const GetDashboardEmbedUrlRequestT& request, const GetDashboardEmbedUrlResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::GetDashboardEmbedUrl, request, handler, context);
  }
 
  virtual Model::GetFlowMetadataOutcome GetFlowMetadata(const Model::GetFlowMetadataRequest& request) const;
 
  template <typename GetFlowMetadataRequestT = Model::GetFlowMetadataRequest>
  Model::GetFlowMetadataOutcomeCallable GetFlowMetadataCallable(const GetFlowMetadataRequestT& request) const {
    return SubmitCallable(&QuickSightClient::GetFlowMetadata, request);
  }
 
  template <typename GetFlowMetadataRequestT = Model::GetFlowMetadataRequest>
  void GetFlowMetadataAsync(const GetFlowMetadataRequestT& request, const GetFlowMetadataResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::GetFlowMetadata, request, handler, context);
  }
 
  virtual Model::GetFlowPermissionsOutcome GetFlowPermissions(const Model::GetFlowPermissionsRequest& request) const;
 
  template <typename GetFlowPermissionsRequestT = Model::GetFlowPermissionsRequest>
  Model::GetFlowPermissionsOutcomeCallable GetFlowPermissionsCallable(const GetFlowPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::GetFlowPermissions, request);
  }
 
  template <typename GetFlowPermissionsRequestT = Model::GetFlowPermissionsRequest>
  void GetFlowPermissionsAsync(const GetFlowPermissionsRequestT& request, const GetFlowPermissionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::GetFlowPermissions, request, handler, context);
  }
 
  virtual Model::GetIdentityContextOutcome GetIdentityContext(const Model::GetIdentityContextRequest& request) const;
 
  template <typename GetIdentityContextRequestT = Model::GetIdentityContextRequest>
  Model::GetIdentityContextOutcomeCallable GetIdentityContextCallable(const GetIdentityContextRequestT& request) const {
    return SubmitCallable(&QuickSightClient::GetIdentityContext, request);
  }
 
  template <typename GetIdentityContextRequestT = Model::GetIdentityContextRequest>
  void GetIdentityContextAsync(const GetIdentityContextRequestT& request, const GetIdentityContextResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::GetIdentityContext, request, handler, context);
  }
 
  virtual Model::GetSessionEmbedUrlOutcome GetSessionEmbedUrl(const Model::GetSessionEmbedUrlRequest& request) const;
 
  template <typename GetSessionEmbedUrlRequestT = Model::GetSessionEmbedUrlRequest>
  Model::GetSessionEmbedUrlOutcomeCallable GetSessionEmbedUrlCallable(const GetSessionEmbedUrlRequestT& request) const {
    return SubmitCallable(&QuickSightClient::GetSessionEmbedUrl, request);
  }
 
  template <typename GetSessionEmbedUrlRequestT = Model::GetSessionEmbedUrlRequest>
  void GetSessionEmbedUrlAsync(const GetSessionEmbedUrlRequestT& request, const GetSessionEmbedUrlResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::GetSessionEmbedUrl, request, handler, context);
  }
 
  virtual Model::ListActionConnectorsOutcome ListActionConnectors(const Model::ListActionConnectorsRequest& request) const;
 
  template <typename ListActionConnectorsRequestT = Model::ListActionConnectorsRequest>
  Model::ListActionConnectorsOutcomeCallable ListActionConnectorsCallable(const ListActionConnectorsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListActionConnectors, request);
  }
 
  template <typename ListActionConnectorsRequestT = Model::ListActionConnectorsRequest>
  void ListActionConnectorsAsync(const ListActionConnectorsRequestT& request, const ListActionConnectorsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListActionConnectors, request, handler, context);
  }
 
  virtual Model::ListAgentsOutcome ListAgents(const Model::ListAgentsRequest& request) const;
 
  template <typename ListAgentsRequestT = Model::ListAgentsRequest>
  Model::ListAgentsOutcomeCallable ListAgentsCallable(const ListAgentsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListAgents, request);
  }
 
  template <typename ListAgentsRequestT = Model::ListAgentsRequest>
  void ListAgentsAsync(const ListAgentsRequestT& request, const ListAgentsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListAgents, request, handler, context);
  }
 
  virtual Model::ListAnalysesOutcome ListAnalyses(const Model::ListAnalysesRequest& request) const;
 
  template <typename ListAnalysesRequestT = Model::ListAnalysesRequest>
  Model::ListAnalysesOutcomeCallable ListAnalysesCallable(const ListAnalysesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListAnalyses, request);
  }
 
  template <typename ListAnalysesRequestT = Model::ListAnalysesRequest>
  void ListAnalysesAsync(const ListAnalysesRequestT& request, const ListAnalysesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListAnalyses, request, handler, context);
  }
 
  virtual Model::ListAssetBundleExportJobsOutcome ListAssetBundleExportJobs(const Model::ListAssetBundleExportJobsRequest& request) const;
 
  template <typename ListAssetBundleExportJobsRequestT = Model::ListAssetBundleExportJobsRequest>
  Model::ListAssetBundleExportJobsOutcomeCallable ListAssetBundleExportJobsCallable(
      const ListAssetBundleExportJobsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListAssetBundleExportJobs, request);
  }
 
  template <typename ListAssetBundleExportJobsRequestT = Model::ListAssetBundleExportJobsRequest>
  void ListAssetBundleExportJobsAsync(const ListAssetBundleExportJobsRequestT& request,
                                      const ListAssetBundleExportJobsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListAssetBundleExportJobs, request, handler, context);
  }
 
  virtual Model::ListAssetBundleImportJobsOutcome ListAssetBundleImportJobs(const Model::ListAssetBundleImportJobsRequest& request) const;
 
  template <typename ListAssetBundleImportJobsRequestT = Model::ListAssetBundleImportJobsRequest>
  Model::ListAssetBundleImportJobsOutcomeCallable ListAssetBundleImportJobsCallable(
      const ListAssetBundleImportJobsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListAssetBundleImportJobs, request);
  }
 
  template <typename ListAssetBundleImportJobsRequestT = Model::ListAssetBundleImportJobsRequest>
  void ListAssetBundleImportJobsAsync(const ListAssetBundleImportJobsRequestT& request,
                                      const ListAssetBundleImportJobsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListAssetBundleImportJobs, request, handler, context);
  }
 
  virtual Model::ListBrandsOutcome ListBrands(const Model::ListBrandsRequest& request) const;
 
  template <typename ListBrandsRequestT = Model::ListBrandsRequest>
  Model::ListBrandsOutcomeCallable ListBrandsCallable(const ListBrandsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListBrands, request);
  }
 
  template <typename ListBrandsRequestT = Model::ListBrandsRequest>
  void ListBrandsAsync(const ListBrandsRequestT& request, const ListBrandsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListBrands, request, handler, context);
  }
 
  virtual Model::ListCustomPermissionsOutcome ListCustomPermissions(const Model::ListCustomPermissionsRequest& request) const;
 
  template <typename ListCustomPermissionsRequestT = Model::ListCustomPermissionsRequest>
  Model::ListCustomPermissionsOutcomeCallable ListCustomPermissionsCallable(const ListCustomPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListCustomPermissions, request);
  }
 
  template <typename ListCustomPermissionsRequestT = Model::ListCustomPermissionsRequest>
  void ListCustomPermissionsAsync(const ListCustomPermissionsRequestT& request, const ListCustomPermissionsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListCustomPermissions, request, handler, context);
  }
 
  virtual Model::ListDashboardVersionsOutcome ListDashboardVersions(const Model::ListDashboardVersionsRequest& request) const;
 
  template <typename ListDashboardVersionsRequestT = Model::ListDashboardVersionsRequest>
  Model::ListDashboardVersionsOutcomeCallable ListDashboardVersionsCallable(const ListDashboardVersionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListDashboardVersions, request);
  }
 
  template <typename ListDashboardVersionsRequestT = Model::ListDashboardVersionsRequest>
  void ListDashboardVersionsAsync(const ListDashboardVersionsRequestT& request, const ListDashboardVersionsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListDashboardVersions, request, handler, context);
  }
 
  virtual Model::ListDashboardsOutcome ListDashboards(const Model::ListDashboardsRequest& request) const;
 
  template <typename ListDashboardsRequestT = Model::ListDashboardsRequest>
  Model::ListDashboardsOutcomeCallable ListDashboardsCallable(const ListDashboardsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListDashboards, request);
  }
 
  template <typename ListDashboardsRequestT = Model::ListDashboardsRequest>
  void ListDashboardsAsync(const ListDashboardsRequestT& request, const ListDashboardsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListDashboards, request, handler, context);
  }
 
  virtual Model::ListDataSetsOutcome ListDataSets(const Model::ListDataSetsRequest& request) const;
 
  template <typename ListDataSetsRequestT = Model::ListDataSetsRequest>
  Model::ListDataSetsOutcomeCallable ListDataSetsCallable(const ListDataSetsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListDataSets, request);
  }
 
  template <typename ListDataSetsRequestT = Model::ListDataSetsRequest>
  void ListDataSetsAsync(const ListDataSetsRequestT& request, const ListDataSetsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListDataSets, request, handler, context);
  }
 
  virtual Model::ListDataSourcesOutcome ListDataSources(const Model::ListDataSourcesRequest& request) const;
 
  template <typename ListDataSourcesRequestT = Model::ListDataSourcesRequest>
  Model::ListDataSourcesOutcomeCallable ListDataSourcesCallable(const ListDataSourcesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListDataSources, request);
  }
 
  template <typename ListDataSourcesRequestT = Model::ListDataSourcesRequest>
  void ListDataSourcesAsync(const ListDataSourcesRequestT& request, const ListDataSourcesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListDataSources, request, handler, context);
  }
 
  virtual Model::ListFlowsOutcome ListFlows(const Model::ListFlowsRequest& request) const;
 
  template <typename ListFlowsRequestT = Model::ListFlowsRequest>
  Model::ListFlowsOutcomeCallable ListFlowsCallable(const ListFlowsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListFlows, request);
  }
 
  template <typename ListFlowsRequestT = Model::ListFlowsRequest>
  void ListFlowsAsync(const ListFlowsRequestT& request, const ListFlowsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListFlows, request, handler, context);
  }
 
  virtual Model::ListFolderMembersOutcome ListFolderMembers(const Model::ListFolderMembersRequest& request) const;
 
  template <typename ListFolderMembersRequestT = Model::ListFolderMembersRequest>
  Model::ListFolderMembersOutcomeCallable ListFolderMembersCallable(const ListFolderMembersRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListFolderMembers, request);
  }
 
  template <typename ListFolderMembersRequestT = Model::ListFolderMembersRequest>
  void ListFolderMembersAsync(const ListFolderMembersRequestT& request, const ListFolderMembersResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListFolderMembers, request, handler, context);
  }
 
  virtual Model::ListFoldersOutcome ListFolders(const Model::ListFoldersRequest& request) const;
 
  template <typename ListFoldersRequestT = Model::ListFoldersRequest>
  Model::ListFoldersOutcomeCallable ListFoldersCallable(const ListFoldersRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListFolders, request);
  }
 
  template <typename ListFoldersRequestT = Model::ListFoldersRequest>
  void ListFoldersAsync(const ListFoldersRequestT& request, const ListFoldersResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListFolders, request, handler, context);
  }
 
  virtual Model::ListFoldersForResourceOutcome ListFoldersForResource(const Model::ListFoldersForResourceRequest& request) const;
 
  template <typename ListFoldersForResourceRequestT = Model::ListFoldersForResourceRequest>
  Model::ListFoldersForResourceOutcomeCallable ListFoldersForResourceCallable(const ListFoldersForResourceRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListFoldersForResource, request);
  }
 
  template <typename ListFoldersForResourceRequestT = Model::ListFoldersForResourceRequest>
  void ListFoldersForResourceAsync(const ListFoldersForResourceRequestT& request,
                                   const ListFoldersForResourceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListFoldersForResource, request, handler, context);
  }
 
  virtual Model::ListGroupMembershipsOutcome ListGroupMemberships(const Model::ListGroupMembershipsRequest& request) const;
 
  template <typename ListGroupMembershipsRequestT = Model::ListGroupMembershipsRequest>
  Model::ListGroupMembershipsOutcomeCallable ListGroupMembershipsCallable(const ListGroupMembershipsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListGroupMemberships, request);
  }
 
  template <typename ListGroupMembershipsRequestT = Model::ListGroupMembershipsRequest>
  void ListGroupMembershipsAsync(const ListGroupMembershipsRequestT& request, const ListGroupMembershipsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListGroupMemberships, request, handler, context);
  }
 
  virtual Model::ListGroupsOutcome ListGroups(const Model::ListGroupsRequest& request) const;
 
  template <typename ListGroupsRequestT = Model::ListGroupsRequest>
  Model::ListGroupsOutcomeCallable ListGroupsCallable(const ListGroupsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListGroups, request);
  }
 
  template <typename ListGroupsRequestT = Model::ListGroupsRequest>
  void ListGroupsAsync(const ListGroupsRequestT& request, const ListGroupsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListGroups, request, handler, context);
  }
 
  virtual Model::ListIAMPolicyAssignmentsOutcome ListIAMPolicyAssignments(const Model::ListIAMPolicyAssignmentsRequest& request) const;
 
  template <typename ListIAMPolicyAssignmentsRequestT = Model::ListIAMPolicyAssignmentsRequest>
  Model::ListIAMPolicyAssignmentsOutcomeCallable ListIAMPolicyAssignmentsCallable(const ListIAMPolicyAssignmentsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListIAMPolicyAssignments, request);
  }
 
  template <typename ListIAMPolicyAssignmentsRequestT = Model::ListIAMPolicyAssignmentsRequest>
  void ListIAMPolicyAssignmentsAsync(const ListIAMPolicyAssignmentsRequestT& request,
                                     const ListIAMPolicyAssignmentsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListIAMPolicyAssignments, request, handler, context);
  }
 
  virtual Model::ListIAMPolicyAssignmentsForUserOutcome ListIAMPolicyAssignmentsForUser(
      const Model::ListIAMPolicyAssignmentsForUserRequest& request) const;
 
  template <typename ListIAMPolicyAssignmentsForUserRequestT = Model::ListIAMPolicyAssignmentsForUserRequest>
  Model::ListIAMPolicyAssignmentsForUserOutcomeCallable ListIAMPolicyAssignmentsForUserCallable(
      const ListIAMPolicyAssignmentsForUserRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListIAMPolicyAssignmentsForUser, request);
  }
 
  template <typename ListIAMPolicyAssignmentsForUserRequestT = Model::ListIAMPolicyAssignmentsForUserRequest>
  void ListIAMPolicyAssignmentsForUserAsync(const ListIAMPolicyAssignmentsForUserRequestT& request,
                                            const ListIAMPolicyAssignmentsForUserResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListIAMPolicyAssignmentsForUser, request, handler, context);
  }
 
  virtual Model::ListIdentityPropagationConfigsOutcome ListIdentityPropagationConfigs(
      const Model::ListIdentityPropagationConfigsRequest& request) const;
 
  template <typename ListIdentityPropagationConfigsRequestT = Model::ListIdentityPropagationConfigsRequest>
  Model::ListIdentityPropagationConfigsOutcomeCallable ListIdentityPropagationConfigsCallable(
      const ListIdentityPropagationConfigsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListIdentityPropagationConfigs, request);
  }
 
  template <typename ListIdentityPropagationConfigsRequestT = Model::ListIdentityPropagationConfigsRequest>
  void ListIdentityPropagationConfigsAsync(const ListIdentityPropagationConfigsRequestT& request,
                                           const ListIdentityPropagationConfigsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListIdentityPropagationConfigs, request, handler, context);
  }
 
  virtual Model::ListIngestionsOutcome ListIngestions(const Model::ListIngestionsRequest& request) const;
 
  template <typename ListIngestionsRequestT = Model::ListIngestionsRequest>
  Model::ListIngestionsOutcomeCallable ListIngestionsCallable(const ListIngestionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListIngestions, request);
  }
 
  template <typename ListIngestionsRequestT = Model::ListIngestionsRequest>
  void ListIngestionsAsync(const ListIngestionsRequestT& request, const ListIngestionsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListIngestions, request, handler, context);
  }
 
  virtual Model::ListKnowledgeBasesOutcome ListKnowledgeBases(const Model::ListKnowledgeBasesRequest& request) const;
 
  template <typename ListKnowledgeBasesRequestT = Model::ListKnowledgeBasesRequest>
  Model::ListKnowledgeBasesOutcomeCallable ListKnowledgeBasesCallable(const ListKnowledgeBasesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListKnowledgeBases, request);
  }
 
  template <typename ListKnowledgeBasesRequestT = Model::ListKnowledgeBasesRequest>
  void ListKnowledgeBasesAsync(const ListKnowledgeBasesRequestT& request, const ListKnowledgeBasesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListKnowledgeBases, request, handler, context);
  }
 
  virtual Model::ListNamespacesOutcome ListNamespaces(const Model::ListNamespacesRequest& request) const;
 
  template <typename ListNamespacesRequestT = Model::ListNamespacesRequest>
  Model::ListNamespacesOutcomeCallable ListNamespacesCallable(const ListNamespacesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListNamespaces, request);
  }
 
  template <typename ListNamespacesRequestT = Model::ListNamespacesRequest>
  void ListNamespacesAsync(const ListNamespacesRequestT& request, const ListNamespacesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListNamespaces, request, handler, context);
  }
 
  virtual Model::ListOAuthClientApplicationsOutcome ListOAuthClientApplications(
      const Model::ListOAuthClientApplicationsRequest& request) const;
 
  template <typename ListOAuthClientApplicationsRequestT = Model::ListOAuthClientApplicationsRequest>
  Model::ListOAuthClientApplicationsOutcomeCallable ListOAuthClientApplicationsCallable(
      const ListOAuthClientApplicationsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListOAuthClientApplications, request);
  }
 
  template <typename ListOAuthClientApplicationsRequestT = Model::ListOAuthClientApplicationsRequest>
  void ListOAuthClientApplicationsAsync(const ListOAuthClientApplicationsRequestT& request,
                                        const ListOAuthClientApplicationsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListOAuthClientApplications, request, handler, context);
  }
 
  virtual Model::ListRefreshSchedulesOutcome ListRefreshSchedules(const Model::ListRefreshSchedulesRequest& request) const;
 
  template <typename ListRefreshSchedulesRequestT = Model::ListRefreshSchedulesRequest>
  Model::ListRefreshSchedulesOutcomeCallable ListRefreshSchedulesCallable(const ListRefreshSchedulesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListRefreshSchedules, request);
  }
 
  template <typename ListRefreshSchedulesRequestT = Model::ListRefreshSchedulesRequest>
  void ListRefreshSchedulesAsync(const ListRefreshSchedulesRequestT& request, const ListRefreshSchedulesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListRefreshSchedules, request, handler, context);
  }
 
  virtual Model::ListRoleMembershipsOutcome ListRoleMemberships(const Model::ListRoleMembershipsRequest& request) const;
 
  template <typename ListRoleMembershipsRequestT = Model::ListRoleMembershipsRequest>
  Model::ListRoleMembershipsOutcomeCallable ListRoleMembershipsCallable(const ListRoleMembershipsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListRoleMemberships, request);
  }
 
  template <typename ListRoleMembershipsRequestT = Model::ListRoleMembershipsRequest>
  void ListRoleMembershipsAsync(const ListRoleMembershipsRequestT& request, const ListRoleMembershipsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListRoleMemberships, request, handler, context);
  }
 
  virtual Model::ListSelfUpgradesOutcome ListSelfUpgrades(const Model::ListSelfUpgradesRequest& request) const;
 
  template <typename ListSelfUpgradesRequestT = Model::ListSelfUpgradesRequest>
  Model::ListSelfUpgradesOutcomeCallable ListSelfUpgradesCallable(const ListSelfUpgradesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListSelfUpgrades, request);
  }
 
  template <typename ListSelfUpgradesRequestT = Model::ListSelfUpgradesRequest>
  void ListSelfUpgradesAsync(const ListSelfUpgradesRequestT& request, const ListSelfUpgradesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListSelfUpgrades, request, handler, context);
  }
 
  virtual Model::ListSpaceResourcesOutcome ListSpaceResources(const Model::ListSpaceResourcesRequest& request) const;
 
  template <typename ListSpaceResourcesRequestT = Model::ListSpaceResourcesRequest>
  Model::ListSpaceResourcesOutcomeCallable ListSpaceResourcesCallable(const ListSpaceResourcesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListSpaceResources, request);
  }
 
  template <typename ListSpaceResourcesRequestT = Model::ListSpaceResourcesRequest>
  void ListSpaceResourcesAsync(const ListSpaceResourcesRequestT& request, const ListSpaceResourcesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListSpaceResources, request, handler, context);
  }
 
  virtual Model::ListSpacesOutcome ListSpaces(const Model::ListSpacesRequest& request) const;
 
  template <typename ListSpacesRequestT = Model::ListSpacesRequest>
  Model::ListSpacesOutcomeCallable ListSpacesCallable(const ListSpacesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListSpaces, request);
  }
 
  template <typename ListSpacesRequestT = Model::ListSpacesRequest>
  void ListSpacesAsync(const ListSpacesRequestT& request, const ListSpacesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListSpaces, 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(&QuickSightClient::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(&QuickSightClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTemplateAliasesOutcome ListTemplateAliases(const Model::ListTemplateAliasesRequest& request) const;
 
  template <typename ListTemplateAliasesRequestT = Model::ListTemplateAliasesRequest>
  Model::ListTemplateAliasesOutcomeCallable ListTemplateAliasesCallable(const ListTemplateAliasesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListTemplateAliases, request);
  }
 
  template <typename ListTemplateAliasesRequestT = Model::ListTemplateAliasesRequest>
  void ListTemplateAliasesAsync(const ListTemplateAliasesRequestT& request, const ListTemplateAliasesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListTemplateAliases, request, handler, context);
  }
 
  virtual Model::ListTemplateVersionsOutcome ListTemplateVersions(const Model::ListTemplateVersionsRequest& request) const;
 
  template <typename ListTemplateVersionsRequestT = Model::ListTemplateVersionsRequest>
  Model::ListTemplateVersionsOutcomeCallable ListTemplateVersionsCallable(const ListTemplateVersionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListTemplateVersions, request);
  }
 
  template <typename ListTemplateVersionsRequestT = Model::ListTemplateVersionsRequest>
  void ListTemplateVersionsAsync(const ListTemplateVersionsRequestT& request, const ListTemplateVersionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListTemplateVersions, request, handler, context);
  }
 
  virtual Model::ListTemplatesOutcome ListTemplates(const Model::ListTemplatesRequest& request) const;
 
  template <typename ListTemplatesRequestT = Model::ListTemplatesRequest>
  Model::ListTemplatesOutcomeCallable ListTemplatesCallable(const ListTemplatesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListTemplates, request);
  }
 
  template <typename ListTemplatesRequestT = Model::ListTemplatesRequest>
  void ListTemplatesAsync(const ListTemplatesRequestT& request, const ListTemplatesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListTemplates, request, handler, context);
  }
 
  virtual Model::ListThemeAliasesOutcome ListThemeAliases(const Model::ListThemeAliasesRequest& request) const;
 
  template <typename ListThemeAliasesRequestT = Model::ListThemeAliasesRequest>
  Model::ListThemeAliasesOutcomeCallable ListThemeAliasesCallable(const ListThemeAliasesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListThemeAliases, request);
  }
 
  template <typename ListThemeAliasesRequestT = Model::ListThemeAliasesRequest>
  void ListThemeAliasesAsync(const ListThemeAliasesRequestT& request, const ListThemeAliasesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListThemeAliases, request, handler, context);
  }
 
  virtual Model::ListThemeVersionsOutcome ListThemeVersions(const Model::ListThemeVersionsRequest& request) const;
 
  template <typename ListThemeVersionsRequestT = Model::ListThemeVersionsRequest>
  Model::ListThemeVersionsOutcomeCallable ListThemeVersionsCallable(const ListThemeVersionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListThemeVersions, request);
  }
 
  template <typename ListThemeVersionsRequestT = Model::ListThemeVersionsRequest>
  void ListThemeVersionsAsync(const ListThemeVersionsRequestT& request, const ListThemeVersionsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListThemeVersions, request, handler, context);
  }
 
  virtual Model::ListThemesOutcome ListThemes(const Model::ListThemesRequest& request) const;
 
  template <typename ListThemesRequestT = Model::ListThemesRequest>
  Model::ListThemesOutcomeCallable ListThemesCallable(const ListThemesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListThemes, request);
  }
 
  template <typename ListThemesRequestT = Model::ListThemesRequest>
  void ListThemesAsync(const ListThemesRequestT& request, const ListThemesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListThemes, request, handler, context);
  }
 
  virtual Model::ListTopicRefreshSchedulesOutcome ListTopicRefreshSchedules(const Model::ListTopicRefreshSchedulesRequest& request) const;
 
  template <typename ListTopicRefreshSchedulesRequestT = Model::ListTopicRefreshSchedulesRequest>
  Model::ListTopicRefreshSchedulesOutcomeCallable ListTopicRefreshSchedulesCallable(
      const ListTopicRefreshSchedulesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListTopicRefreshSchedules, request);
  }
 
  template <typename ListTopicRefreshSchedulesRequestT = Model::ListTopicRefreshSchedulesRequest>
  void ListTopicRefreshSchedulesAsync(const ListTopicRefreshSchedulesRequestT& request,
                                      const ListTopicRefreshSchedulesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListTopicRefreshSchedules, request, handler, context);
  }
 
  virtual Model::ListTopicReviewedAnswersOutcome ListTopicReviewedAnswers(const Model::ListTopicReviewedAnswersRequest& request) const;
 
  template <typename ListTopicReviewedAnswersRequestT = Model::ListTopicReviewedAnswersRequest>
  Model::ListTopicReviewedAnswersOutcomeCallable ListTopicReviewedAnswersCallable(const ListTopicReviewedAnswersRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListTopicReviewedAnswers, request);
  }
 
  template <typename ListTopicReviewedAnswersRequestT = Model::ListTopicReviewedAnswersRequest>
  void ListTopicReviewedAnswersAsync(const ListTopicReviewedAnswersRequestT& request,
                                     const ListTopicReviewedAnswersResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListTopicReviewedAnswers, request, handler, context);
  }
 
  virtual Model::ListTopicsOutcome ListTopics(const Model::ListTopicsRequest& request) const;
 
  template <typename ListTopicsRequestT = Model::ListTopicsRequest>
  Model::ListTopicsOutcomeCallable ListTopicsCallable(const ListTopicsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListTopics, request);
  }
 
  template <typename ListTopicsRequestT = Model::ListTopicsRequest>
  void ListTopicsAsync(const ListTopicsRequestT& request, const ListTopicsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListTopics, request, handler, context);
  }
 
  virtual Model::ListUserGroupsOutcome ListUserGroups(const Model::ListUserGroupsRequest& request) const;
 
  template <typename ListUserGroupsRequestT = Model::ListUserGroupsRequest>
  Model::ListUserGroupsOutcomeCallable ListUserGroupsCallable(const ListUserGroupsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListUserGroups, request);
  }
 
  template <typename ListUserGroupsRequestT = Model::ListUserGroupsRequest>
  void ListUserGroupsAsync(const ListUserGroupsRequestT& request, const ListUserGroupsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListUserGroups, request, handler, context);
  }
 
  virtual Model::ListUsersOutcome ListUsers(const Model::ListUsersRequest& request) const;
 
  template <typename ListUsersRequestT = Model::ListUsersRequest>
  Model::ListUsersOutcomeCallable ListUsersCallable(const ListUsersRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListUsers, request);
  }
 
  template <typename ListUsersRequestT = Model::ListUsersRequest>
  void ListUsersAsync(const ListUsersRequestT& request, const ListUsersResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListUsers, request, handler, context);
  }
 
  virtual Model::ListUsersIndexCapacityOutcome ListUsersIndexCapacity(const Model::ListUsersIndexCapacityRequest& request) const;
 
  template <typename ListUsersIndexCapacityRequestT = Model::ListUsersIndexCapacityRequest>
  Model::ListUsersIndexCapacityOutcomeCallable ListUsersIndexCapacityCallable(const ListUsersIndexCapacityRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListUsersIndexCapacity, request);
  }
 
  template <typename ListUsersIndexCapacityRequestT = Model::ListUsersIndexCapacityRequest>
  void ListUsersIndexCapacityAsync(const ListUsersIndexCapacityRequestT& request,
                                   const ListUsersIndexCapacityResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListUsersIndexCapacity, request, handler, context);
  }
 
  virtual Model::ListVPCConnectionsOutcome ListVPCConnections(const Model::ListVPCConnectionsRequest& request) const;
 
  template <typename ListVPCConnectionsRequestT = Model::ListVPCConnectionsRequest>
  Model::ListVPCConnectionsOutcomeCallable ListVPCConnectionsCallable(const ListVPCConnectionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::ListVPCConnections, request);
  }
 
  template <typename ListVPCConnectionsRequestT = Model::ListVPCConnectionsRequest>
  void ListVPCConnectionsAsync(const ListVPCConnectionsRequestT& request, const ListVPCConnectionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::ListVPCConnections, request, handler, context);
  }
 
  virtual Model::PredictQAResultsOutcome PredictQAResults(const Model::PredictQAResultsRequest& request) const;
 
  template <typename PredictQAResultsRequestT = Model::PredictQAResultsRequest>
  Model::PredictQAResultsOutcomeCallable PredictQAResultsCallable(const PredictQAResultsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::PredictQAResults, request);
  }
 
  template <typename PredictQAResultsRequestT = Model::PredictQAResultsRequest>
  void PredictQAResultsAsync(const PredictQAResultsRequestT& request, const PredictQAResultsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::PredictQAResults, request, handler, context);
  }
 
  virtual Model::PutDataSetRefreshPropertiesOutcome PutDataSetRefreshProperties(
      const Model::PutDataSetRefreshPropertiesRequest& request) const;
 
  template <typename PutDataSetRefreshPropertiesRequestT = Model::PutDataSetRefreshPropertiesRequest>
  Model::PutDataSetRefreshPropertiesOutcomeCallable PutDataSetRefreshPropertiesCallable(
      const PutDataSetRefreshPropertiesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::PutDataSetRefreshProperties, request);
  }
 
  template <typename PutDataSetRefreshPropertiesRequestT = Model::PutDataSetRefreshPropertiesRequest>
  void PutDataSetRefreshPropertiesAsync(const PutDataSetRefreshPropertiesRequestT& request,
                                        const PutDataSetRefreshPropertiesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::PutDataSetRefreshProperties, request, handler, context);
  }
 
  virtual Model::RegisterUserOutcome RegisterUser(const Model::RegisterUserRequest& request) const;
 
  template <typename RegisterUserRequestT = Model::RegisterUserRequest>
  Model::RegisterUserOutcomeCallable RegisterUserCallable(const RegisterUserRequestT& request) const {
    return SubmitCallable(&QuickSightClient::RegisterUser, request);
  }
 
  template <typename RegisterUserRequestT = Model::RegisterUserRequest>
  void RegisterUserAsync(const RegisterUserRequestT& request, const RegisterUserResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::RegisterUser, request, handler, context);
  }
 
  virtual Model::RestoreAnalysisOutcome RestoreAnalysis(const Model::RestoreAnalysisRequest& request) const;
 
  template <typename RestoreAnalysisRequestT = Model::RestoreAnalysisRequest>
  Model::RestoreAnalysisOutcomeCallable RestoreAnalysisCallable(const RestoreAnalysisRequestT& request) const {
    return SubmitCallable(&QuickSightClient::RestoreAnalysis, request);
  }
 
  template <typename RestoreAnalysisRequestT = Model::RestoreAnalysisRequest>
  void RestoreAnalysisAsync(const RestoreAnalysisRequestT& request, const RestoreAnalysisResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::RestoreAnalysis, request, handler, context);
  }
 
  virtual Model::SearchActionConnectorsOutcome SearchActionConnectors(const Model::SearchActionConnectorsRequest& request) const;
 
  template <typename SearchActionConnectorsRequestT = Model::SearchActionConnectorsRequest>
  Model::SearchActionConnectorsOutcomeCallable SearchActionConnectorsCallable(const SearchActionConnectorsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::SearchActionConnectors, request);
  }
 
  template <typename SearchActionConnectorsRequestT = Model::SearchActionConnectorsRequest>
  void SearchActionConnectorsAsync(const SearchActionConnectorsRequestT& request,
                                   const SearchActionConnectorsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::SearchActionConnectors, request, handler, context);
  }
 
  virtual Model::SearchAgentsOutcome SearchAgents(const Model::SearchAgentsRequest& request) const;
 
  template <typename SearchAgentsRequestT = Model::SearchAgentsRequest>
  Model::SearchAgentsOutcomeCallable SearchAgentsCallable(const SearchAgentsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::SearchAgents, request);
  }
 
  template <typename SearchAgentsRequestT = Model::SearchAgentsRequest>
  void SearchAgentsAsync(const SearchAgentsRequestT& request, const SearchAgentsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::SearchAgents, request, handler, context);
  }
 
  virtual Model::SearchAnalysesOutcome SearchAnalyses(const Model::SearchAnalysesRequest& request) const;
 
  template <typename SearchAnalysesRequestT = Model::SearchAnalysesRequest>
  Model::SearchAnalysesOutcomeCallable SearchAnalysesCallable(const SearchAnalysesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::SearchAnalyses, request);
  }
 
  template <typename SearchAnalysesRequestT = Model::SearchAnalysesRequest>
  void SearchAnalysesAsync(const SearchAnalysesRequestT& request, const SearchAnalysesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::SearchAnalyses, request, handler, context);
  }
 
  virtual Model::SearchDashboardsOutcome SearchDashboards(const Model::SearchDashboardsRequest& request) const;
 
  template <typename SearchDashboardsRequestT = Model::SearchDashboardsRequest>
  Model::SearchDashboardsOutcomeCallable SearchDashboardsCallable(const SearchDashboardsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::SearchDashboards, request);
  }
 
  template <typename SearchDashboardsRequestT = Model::SearchDashboardsRequest>
  void SearchDashboardsAsync(const SearchDashboardsRequestT& request, const SearchDashboardsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::SearchDashboards, request, handler, context);
  }
 
  virtual Model::SearchDataSetsOutcome SearchDataSets(const Model::SearchDataSetsRequest& request) const;
 
  template <typename SearchDataSetsRequestT = Model::SearchDataSetsRequest>
  Model::SearchDataSetsOutcomeCallable SearchDataSetsCallable(const SearchDataSetsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::SearchDataSets, request);
  }
 
  template <typename SearchDataSetsRequestT = Model::SearchDataSetsRequest>
  void SearchDataSetsAsync(const SearchDataSetsRequestT& request, const SearchDataSetsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::SearchDataSets, request, handler, context);
  }
 
  virtual Model::SearchDataSourcesOutcome SearchDataSources(const Model::SearchDataSourcesRequest& request) const;
 
  template <typename SearchDataSourcesRequestT = Model::SearchDataSourcesRequest>
  Model::SearchDataSourcesOutcomeCallable SearchDataSourcesCallable(const SearchDataSourcesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::SearchDataSources, request);
  }
 
  template <typename SearchDataSourcesRequestT = Model::SearchDataSourcesRequest>
  void SearchDataSourcesAsync(const SearchDataSourcesRequestT& request, const SearchDataSourcesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::SearchDataSources, request, handler, context);
  }
 
  virtual Model::SearchFlowsOutcome SearchFlows(const Model::SearchFlowsRequest& request) const;
 
  template <typename SearchFlowsRequestT = Model::SearchFlowsRequest>
  Model::SearchFlowsOutcomeCallable SearchFlowsCallable(const SearchFlowsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::SearchFlows, request);
  }
 
  template <typename SearchFlowsRequestT = Model::SearchFlowsRequest>
  void SearchFlowsAsync(const SearchFlowsRequestT& request, const SearchFlowsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::SearchFlows, request, handler, context);
  }
 
  virtual Model::SearchFoldersOutcome SearchFolders(const Model::SearchFoldersRequest& request) const;
 
  template <typename SearchFoldersRequestT = Model::SearchFoldersRequest>
  Model::SearchFoldersOutcomeCallable SearchFoldersCallable(const SearchFoldersRequestT& request) const {
    return SubmitCallable(&QuickSightClient::SearchFolders, request);
  }
 
  template <typename SearchFoldersRequestT = Model::SearchFoldersRequest>
  void SearchFoldersAsync(const SearchFoldersRequestT& request, const SearchFoldersResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::SearchFolders, request, handler, context);
  }
 
  virtual Model::SearchGroupsOutcome SearchGroups(const Model::SearchGroupsRequest& request) const;
 
  template <typename SearchGroupsRequestT = Model::SearchGroupsRequest>
  Model::SearchGroupsOutcomeCallable SearchGroupsCallable(const SearchGroupsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::SearchGroups, request);
  }
 
  template <typename SearchGroupsRequestT = Model::SearchGroupsRequest>
  void SearchGroupsAsync(const SearchGroupsRequestT& request, const SearchGroupsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::SearchGroups, request, handler, context);
  }
 
  virtual Model::SearchKnowledgeBasesOutcome SearchKnowledgeBases(const Model::SearchKnowledgeBasesRequest& request) const;
 
  template <typename SearchKnowledgeBasesRequestT = Model::SearchKnowledgeBasesRequest>
  Model::SearchKnowledgeBasesOutcomeCallable SearchKnowledgeBasesCallable(const SearchKnowledgeBasesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::SearchKnowledgeBases, request);
  }
 
  template <typename SearchKnowledgeBasesRequestT = Model::SearchKnowledgeBasesRequest>
  void SearchKnowledgeBasesAsync(const SearchKnowledgeBasesRequestT& request, const SearchKnowledgeBasesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::SearchKnowledgeBases, request, handler, context);
  }
 
  virtual Model::SearchSpacesOutcome SearchSpaces(const Model::SearchSpacesRequest& request) const;
 
  template <typename SearchSpacesRequestT = Model::SearchSpacesRequest>
  Model::SearchSpacesOutcomeCallable SearchSpacesCallable(const SearchSpacesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::SearchSpaces, request);
  }
 
  template <typename SearchSpacesRequestT = Model::SearchSpacesRequest>
  void SearchSpacesAsync(const SearchSpacesRequestT& request, const SearchSpacesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::SearchSpaces, request, handler, context);
  }
 
  virtual Model::SearchTopicsOutcome SearchTopics(const Model::SearchTopicsRequest& request) const;
 
  template <typename SearchTopicsRequestT = Model::SearchTopicsRequest>
  Model::SearchTopicsOutcomeCallable SearchTopicsCallable(const SearchTopicsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::SearchTopics, request);
  }
 
  template <typename SearchTopicsRequestT = Model::SearchTopicsRequest>
  void SearchTopicsAsync(const SearchTopicsRequestT& request, const SearchTopicsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::SearchTopics, request, handler, context);
  }
 
  virtual Model::StartAssetBundleExportJobOutcome StartAssetBundleExportJob(const Model::StartAssetBundleExportJobRequest& request) const;
 
  template <typename StartAssetBundleExportJobRequestT = Model::StartAssetBundleExportJobRequest>
  Model::StartAssetBundleExportJobOutcomeCallable StartAssetBundleExportJobCallable(
      const StartAssetBundleExportJobRequestT& request) const {
    return SubmitCallable(&QuickSightClient::StartAssetBundleExportJob, request);
  }
 
  template <typename StartAssetBundleExportJobRequestT = Model::StartAssetBundleExportJobRequest>
  void StartAssetBundleExportJobAsync(const StartAssetBundleExportJobRequestT& request,
                                      const StartAssetBundleExportJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::StartAssetBundleExportJob, request, handler, context);
  }
 
  virtual Model::StartAssetBundleImportJobOutcome StartAssetBundleImportJob(const Model::StartAssetBundleImportJobRequest& request) const;
 
  template <typename StartAssetBundleImportJobRequestT = Model::StartAssetBundleImportJobRequest>
  Model::StartAssetBundleImportJobOutcomeCallable StartAssetBundleImportJobCallable(
      const StartAssetBundleImportJobRequestT& request) const {
    return SubmitCallable(&QuickSightClient::StartAssetBundleImportJob, request);
  }
 
  template <typename StartAssetBundleImportJobRequestT = Model::StartAssetBundleImportJobRequest>
  void StartAssetBundleImportJobAsync(const StartAssetBundleImportJobRequestT& request,
                                      const StartAssetBundleImportJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::StartAssetBundleImportJob, request, handler, context);
  }
 
  virtual Model::StartAutomationJobOutcome StartAutomationJob(const Model::StartAutomationJobRequest& request) const;
 
  template <typename StartAutomationJobRequestT = Model::StartAutomationJobRequest>
  Model::StartAutomationJobOutcomeCallable StartAutomationJobCallable(const StartAutomationJobRequestT& request) const {
    return SubmitCallable(&QuickSightClient::StartAutomationJob, request);
  }
 
  template <typename StartAutomationJobRequestT = Model::StartAutomationJobRequest>
  void StartAutomationJobAsync(const StartAutomationJobRequestT& request, const StartAutomationJobResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::StartAutomationJob, request, handler, context);
  }
 
  virtual Model::StartDashboardSnapshotJobOutcome StartDashboardSnapshotJob(const Model::StartDashboardSnapshotJobRequest& request) const;
 
  template <typename StartDashboardSnapshotJobRequestT = Model::StartDashboardSnapshotJobRequest>
  Model::StartDashboardSnapshotJobOutcomeCallable StartDashboardSnapshotJobCallable(
      const StartDashboardSnapshotJobRequestT& request) const {
    return SubmitCallable(&QuickSightClient::StartDashboardSnapshotJob, request);
  }
 
  template <typename StartDashboardSnapshotJobRequestT = Model::StartDashboardSnapshotJobRequest>
  void StartDashboardSnapshotJobAsync(const StartDashboardSnapshotJobRequestT& request,
                                      const StartDashboardSnapshotJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::StartDashboardSnapshotJob, request, handler, context);
  }
 
  virtual Model::StartDashboardSnapshotJobScheduleOutcome StartDashboardSnapshotJobSchedule(
      const Model::StartDashboardSnapshotJobScheduleRequest& request) const;
 
  template <typename StartDashboardSnapshotJobScheduleRequestT = Model::StartDashboardSnapshotJobScheduleRequest>
  Model::StartDashboardSnapshotJobScheduleOutcomeCallable StartDashboardSnapshotJobScheduleCallable(
      const StartDashboardSnapshotJobScheduleRequestT& request) const {
    return SubmitCallable(&QuickSightClient::StartDashboardSnapshotJobSchedule, request);
  }
 
  template <typename StartDashboardSnapshotJobScheduleRequestT = Model::StartDashboardSnapshotJobScheduleRequest>
  void StartDashboardSnapshotJobScheduleAsync(const StartDashboardSnapshotJobScheduleRequestT& request,
                                              const StartDashboardSnapshotJobScheduleResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::StartDashboardSnapshotJobSchedule, 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(&QuickSightClient::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(&QuickSightClient::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(&QuickSightClient::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(&QuickSightClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAccountCustomPermissionOutcome UpdateAccountCustomPermission(
      const Model::UpdateAccountCustomPermissionRequest& request) const;
 
  template <typename UpdateAccountCustomPermissionRequestT = Model::UpdateAccountCustomPermissionRequest>
  Model::UpdateAccountCustomPermissionOutcomeCallable UpdateAccountCustomPermissionCallable(
      const UpdateAccountCustomPermissionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateAccountCustomPermission, request);
  }
 
  template <typename UpdateAccountCustomPermissionRequestT = Model::UpdateAccountCustomPermissionRequest>
  void UpdateAccountCustomPermissionAsync(const UpdateAccountCustomPermissionRequestT& request,
                                          const UpdateAccountCustomPermissionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateAccountCustomPermission, request, handler, context);
  }
 
  virtual Model::UpdateAccountCustomizationOutcome UpdateAccountCustomization(
      const Model::UpdateAccountCustomizationRequest& request) const;
 
  template <typename UpdateAccountCustomizationRequestT = Model::UpdateAccountCustomizationRequest>
  Model::UpdateAccountCustomizationOutcomeCallable UpdateAccountCustomizationCallable(
      const UpdateAccountCustomizationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateAccountCustomization, request);
  }
 
  template <typename UpdateAccountCustomizationRequestT = Model::UpdateAccountCustomizationRequest>
  void UpdateAccountCustomizationAsync(const UpdateAccountCustomizationRequestT& request,
                                       const UpdateAccountCustomizationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateAccountCustomization, request, handler, context);
  }
 
  virtual Model::UpdateAccountSettingsOutcome UpdateAccountSettings(const Model::UpdateAccountSettingsRequest& request) const;
 
  template <typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
  Model::UpdateAccountSettingsOutcomeCallable UpdateAccountSettingsCallable(const UpdateAccountSettingsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateAccountSettings, request);
  }
 
  template <typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
  void UpdateAccountSettingsAsync(const UpdateAccountSettingsRequestT& request, const UpdateAccountSettingsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateAccountSettings, request, handler, context);
  }
 
  virtual Model::UpdateActionConnectorOutcome UpdateActionConnector(const Model::UpdateActionConnectorRequest& request) const;
 
  template <typename UpdateActionConnectorRequestT = Model::UpdateActionConnectorRequest>
  Model::UpdateActionConnectorOutcomeCallable UpdateActionConnectorCallable(const UpdateActionConnectorRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateActionConnector, request);
  }
 
  template <typename UpdateActionConnectorRequestT = Model::UpdateActionConnectorRequest>
  void UpdateActionConnectorAsync(const UpdateActionConnectorRequestT& request, const UpdateActionConnectorResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateActionConnector, request, handler, context);
  }
 
  virtual Model::UpdateActionConnectorPermissionsOutcome UpdateActionConnectorPermissions(
      const Model::UpdateActionConnectorPermissionsRequest& request) const;
 
  template <typename UpdateActionConnectorPermissionsRequestT = Model::UpdateActionConnectorPermissionsRequest>
  Model::UpdateActionConnectorPermissionsOutcomeCallable UpdateActionConnectorPermissionsCallable(
      const UpdateActionConnectorPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateActionConnectorPermissions, request);
  }
 
  template <typename UpdateActionConnectorPermissionsRequestT = Model::UpdateActionConnectorPermissionsRequest>
  void UpdateActionConnectorPermissionsAsync(const UpdateActionConnectorPermissionsRequestT& request,
                                             const UpdateActionConnectorPermissionsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateActionConnectorPermissions, request, handler, context);
  }
 
  virtual Model::UpdateAgentOutcome UpdateAgent(const Model::UpdateAgentRequest& request) const;
 
  template <typename UpdateAgentRequestT = Model::UpdateAgentRequest>
  Model::UpdateAgentOutcomeCallable UpdateAgentCallable(const UpdateAgentRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateAgent, request);
  }
 
  template <typename UpdateAgentRequestT = Model::UpdateAgentRequest>
  void UpdateAgentAsync(const UpdateAgentRequestT& request, const UpdateAgentResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateAgent, request, handler, context);
  }
 
  virtual Model::UpdateAgentPermissionsOutcome UpdateAgentPermissions(const Model::UpdateAgentPermissionsRequest& request) const;
 
  template <typename UpdateAgentPermissionsRequestT = Model::UpdateAgentPermissionsRequest>
  Model::UpdateAgentPermissionsOutcomeCallable UpdateAgentPermissionsCallable(const UpdateAgentPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateAgentPermissions, request);
  }
 
  template <typename UpdateAgentPermissionsRequestT = Model::UpdateAgentPermissionsRequest>
  void UpdateAgentPermissionsAsync(const UpdateAgentPermissionsRequestT& request,
                                   const UpdateAgentPermissionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateAgentPermissions, request, handler, context);
  }
 
  virtual Model::UpdateAnalysisOutcome UpdateAnalysis(const Model::UpdateAnalysisRequest& request) const;
 
  template <typename UpdateAnalysisRequestT = Model::UpdateAnalysisRequest>
  Model::UpdateAnalysisOutcomeCallable UpdateAnalysisCallable(const UpdateAnalysisRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateAnalysis, request);
  }
 
  template <typename UpdateAnalysisRequestT = Model::UpdateAnalysisRequest>
  void UpdateAnalysisAsync(const UpdateAnalysisRequestT& request, const UpdateAnalysisResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateAnalysis, request, handler, context);
  }
 
  virtual Model::UpdateAnalysisPermissionsOutcome UpdateAnalysisPermissions(const Model::UpdateAnalysisPermissionsRequest& request) const;
 
  template <typename UpdateAnalysisPermissionsRequestT = Model::UpdateAnalysisPermissionsRequest>
  Model::UpdateAnalysisPermissionsOutcomeCallable UpdateAnalysisPermissionsCallable(
      const UpdateAnalysisPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateAnalysisPermissions, request);
  }
 
  template <typename UpdateAnalysisPermissionsRequestT = Model::UpdateAnalysisPermissionsRequest>
  void UpdateAnalysisPermissionsAsync(const UpdateAnalysisPermissionsRequestT& request,
                                      const UpdateAnalysisPermissionsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateAnalysisPermissions, request, handler, context);
  }
 
  virtual Model::UpdateApplicationWithTokenExchangeGrantOutcome UpdateApplicationWithTokenExchangeGrant(
      const Model::UpdateApplicationWithTokenExchangeGrantRequest& request) const;
 
  template <typename UpdateApplicationWithTokenExchangeGrantRequestT = Model::UpdateApplicationWithTokenExchangeGrantRequest>
  Model::UpdateApplicationWithTokenExchangeGrantOutcomeCallable UpdateApplicationWithTokenExchangeGrantCallable(
      const UpdateApplicationWithTokenExchangeGrantRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateApplicationWithTokenExchangeGrant, request);
  }
 
  template <typename UpdateApplicationWithTokenExchangeGrantRequestT = Model::UpdateApplicationWithTokenExchangeGrantRequest>
  void UpdateApplicationWithTokenExchangeGrantAsync(const UpdateApplicationWithTokenExchangeGrantRequestT& request,
                                                    const UpdateApplicationWithTokenExchangeGrantResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateApplicationWithTokenExchangeGrant, request, handler, context);
  }
 
  virtual Model::UpdateBrandOutcome UpdateBrand(const Model::UpdateBrandRequest& request) const;
 
  template <typename UpdateBrandRequestT = Model::UpdateBrandRequest>
  Model::UpdateBrandOutcomeCallable UpdateBrandCallable(const UpdateBrandRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateBrand, request);
  }
 
  template <typename UpdateBrandRequestT = Model::UpdateBrandRequest>
  void UpdateBrandAsync(const UpdateBrandRequestT& request, const UpdateBrandResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateBrand, request, handler, context);
  }
 
  virtual Model::UpdateBrandAssignmentOutcome UpdateBrandAssignment(const Model::UpdateBrandAssignmentRequest& request) const;
 
  template <typename UpdateBrandAssignmentRequestT = Model::UpdateBrandAssignmentRequest>
  Model::UpdateBrandAssignmentOutcomeCallable UpdateBrandAssignmentCallable(const UpdateBrandAssignmentRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateBrandAssignment, request);
  }
 
  template <typename UpdateBrandAssignmentRequestT = Model::UpdateBrandAssignmentRequest>
  void UpdateBrandAssignmentAsync(const UpdateBrandAssignmentRequestT& request, const UpdateBrandAssignmentResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateBrandAssignment, request, handler, context);
  }
 
  virtual Model::UpdateBrandPublishedVersionOutcome UpdateBrandPublishedVersion(
      const Model::UpdateBrandPublishedVersionRequest& request) const;
 
  template <typename UpdateBrandPublishedVersionRequestT = Model::UpdateBrandPublishedVersionRequest>
  Model::UpdateBrandPublishedVersionOutcomeCallable UpdateBrandPublishedVersionCallable(
      const UpdateBrandPublishedVersionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateBrandPublishedVersion, request);
  }
 
  template <typename UpdateBrandPublishedVersionRequestT = Model::UpdateBrandPublishedVersionRequest>
  void UpdateBrandPublishedVersionAsync(const UpdateBrandPublishedVersionRequestT& request,
                                        const UpdateBrandPublishedVersionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateBrandPublishedVersion, request, handler, context);
  }
 
  virtual Model::UpdateCustomPermissionsOutcome UpdateCustomPermissions(const Model::UpdateCustomPermissionsRequest& request) const;
 
  template <typename UpdateCustomPermissionsRequestT = Model::UpdateCustomPermissionsRequest>
  Model::UpdateCustomPermissionsOutcomeCallable UpdateCustomPermissionsCallable(const UpdateCustomPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateCustomPermissions, request);
  }
 
  template <typename UpdateCustomPermissionsRequestT = Model::UpdateCustomPermissionsRequest>
  void UpdateCustomPermissionsAsync(const UpdateCustomPermissionsRequestT& request,
                                    const UpdateCustomPermissionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateCustomPermissions, request, handler, context);
  }
 
  virtual Model::UpdateDashboardOutcome UpdateDashboard(const Model::UpdateDashboardRequest& request) const;
 
  template <typename UpdateDashboardRequestT = Model::UpdateDashboardRequest>
  Model::UpdateDashboardOutcomeCallable UpdateDashboardCallable(const UpdateDashboardRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateDashboard, request);
  }
 
  template <typename UpdateDashboardRequestT = Model::UpdateDashboardRequest>
  void UpdateDashboardAsync(const UpdateDashboardRequestT& request, const UpdateDashboardResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateDashboard, request, handler, context);
  }
 
  virtual Model::UpdateDashboardLinksOutcome UpdateDashboardLinks(const Model::UpdateDashboardLinksRequest& request) const;
 
  template <typename UpdateDashboardLinksRequestT = Model::UpdateDashboardLinksRequest>
  Model::UpdateDashboardLinksOutcomeCallable UpdateDashboardLinksCallable(const UpdateDashboardLinksRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateDashboardLinks, request);
  }
 
  template <typename UpdateDashboardLinksRequestT = Model::UpdateDashboardLinksRequest>
  void UpdateDashboardLinksAsync(const UpdateDashboardLinksRequestT& request, const UpdateDashboardLinksResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateDashboardLinks, request, handler, context);
  }
 
  virtual Model::UpdateDashboardPermissionsOutcome UpdateDashboardPermissions(
      const Model::UpdateDashboardPermissionsRequest& request) const;
 
  template <typename UpdateDashboardPermissionsRequestT = Model::UpdateDashboardPermissionsRequest>
  Model::UpdateDashboardPermissionsOutcomeCallable UpdateDashboardPermissionsCallable(
      const UpdateDashboardPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateDashboardPermissions, request);
  }
 
  template <typename UpdateDashboardPermissionsRequestT = Model::UpdateDashboardPermissionsRequest>
  void UpdateDashboardPermissionsAsync(const UpdateDashboardPermissionsRequestT& request,
                                       const UpdateDashboardPermissionsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateDashboardPermissions, request, handler, context);
  }
 
  virtual Model::UpdateDashboardPublishedVersionOutcome UpdateDashboardPublishedVersion(
      const Model::UpdateDashboardPublishedVersionRequest& request) const;
 
  template <typename UpdateDashboardPublishedVersionRequestT = Model::UpdateDashboardPublishedVersionRequest>
  Model::UpdateDashboardPublishedVersionOutcomeCallable UpdateDashboardPublishedVersionCallable(
      const UpdateDashboardPublishedVersionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateDashboardPublishedVersion, request);
  }
 
  template <typename UpdateDashboardPublishedVersionRequestT = Model::UpdateDashboardPublishedVersionRequest>
  void UpdateDashboardPublishedVersionAsync(const UpdateDashboardPublishedVersionRequestT& request,
                                            const UpdateDashboardPublishedVersionResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateDashboardPublishedVersion, request, handler, context);
  }
 
  virtual Model::UpdateDashboardsQAConfigurationOutcome UpdateDashboardsQAConfiguration(
      const Model::UpdateDashboardsQAConfigurationRequest& request) const;
 
  template <typename UpdateDashboardsQAConfigurationRequestT = Model::UpdateDashboardsQAConfigurationRequest>
  Model::UpdateDashboardsQAConfigurationOutcomeCallable UpdateDashboardsQAConfigurationCallable(
      const UpdateDashboardsQAConfigurationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateDashboardsQAConfiguration, request);
  }
 
  template <typename UpdateDashboardsQAConfigurationRequestT = Model::UpdateDashboardsQAConfigurationRequest>
  void UpdateDashboardsQAConfigurationAsync(const UpdateDashboardsQAConfigurationRequestT& request,
                                            const UpdateDashboardsQAConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateDashboardsQAConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateDataSetOutcome UpdateDataSet(const Model::UpdateDataSetRequest& request) const;
 
  template <typename UpdateDataSetRequestT = Model::UpdateDataSetRequest>
  Model::UpdateDataSetOutcomeCallable UpdateDataSetCallable(const UpdateDataSetRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateDataSet, request);
  }
 
  template <typename UpdateDataSetRequestT = Model::UpdateDataSetRequest>
  void UpdateDataSetAsync(const UpdateDataSetRequestT& request, const UpdateDataSetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateDataSet, request, handler, context);
  }
 
  virtual Model::UpdateDataSetPermissionsOutcome UpdateDataSetPermissions(const Model::UpdateDataSetPermissionsRequest& request) const;
 
  template <typename UpdateDataSetPermissionsRequestT = Model::UpdateDataSetPermissionsRequest>
  Model::UpdateDataSetPermissionsOutcomeCallable UpdateDataSetPermissionsCallable(const UpdateDataSetPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateDataSetPermissions, request);
  }
 
  template <typename UpdateDataSetPermissionsRequestT = Model::UpdateDataSetPermissionsRequest>
  void UpdateDataSetPermissionsAsync(const UpdateDataSetPermissionsRequestT& request,
                                     const UpdateDataSetPermissionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateDataSetPermissions, request, handler, context);
  }
 
  virtual Model::UpdateDataSourceOutcome UpdateDataSource(const Model::UpdateDataSourceRequest& request) const;
 
  template <typename UpdateDataSourceRequestT = Model::UpdateDataSourceRequest>
  Model::UpdateDataSourceOutcomeCallable UpdateDataSourceCallable(const UpdateDataSourceRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateDataSource, request);
  }
 
  template <typename UpdateDataSourceRequestT = Model::UpdateDataSourceRequest>
  void UpdateDataSourceAsync(const UpdateDataSourceRequestT& request, const UpdateDataSourceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateDataSource, request, handler, context);
  }
 
  virtual Model::UpdateDataSourcePermissionsOutcome UpdateDataSourcePermissions(
      const Model::UpdateDataSourcePermissionsRequest& request) const;
 
  template <typename UpdateDataSourcePermissionsRequestT = Model::UpdateDataSourcePermissionsRequest>
  Model::UpdateDataSourcePermissionsOutcomeCallable UpdateDataSourcePermissionsCallable(
      const UpdateDataSourcePermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateDataSourcePermissions, request);
  }
 
  template <typename UpdateDataSourcePermissionsRequestT = Model::UpdateDataSourcePermissionsRequest>
  void UpdateDataSourcePermissionsAsync(const UpdateDataSourcePermissionsRequestT& request,
                                        const UpdateDataSourcePermissionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateDataSourcePermissions, request, handler, context);
  }
 
  virtual Model::UpdateDefaultQBusinessApplicationOutcome UpdateDefaultQBusinessApplication(
      const Model::UpdateDefaultQBusinessApplicationRequest& request) const;
 
  template <typename UpdateDefaultQBusinessApplicationRequestT = Model::UpdateDefaultQBusinessApplicationRequest>
  Model::UpdateDefaultQBusinessApplicationOutcomeCallable UpdateDefaultQBusinessApplicationCallable(
      const UpdateDefaultQBusinessApplicationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateDefaultQBusinessApplication, request);
  }
 
  template <typename UpdateDefaultQBusinessApplicationRequestT = Model::UpdateDefaultQBusinessApplicationRequest>
  void UpdateDefaultQBusinessApplicationAsync(const UpdateDefaultQBusinessApplicationRequestT& request,
                                              const UpdateDefaultQBusinessApplicationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateDefaultQBusinessApplication, request, handler, context);
  }
 
  virtual Model::UpdateFlowOutcome UpdateFlow(const Model::UpdateFlowRequest& request) const;
 
  template <typename UpdateFlowRequestT = Model::UpdateFlowRequest>
  Model::UpdateFlowOutcomeCallable UpdateFlowCallable(const UpdateFlowRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateFlow, request);
  }
 
  template <typename UpdateFlowRequestT = Model::UpdateFlowRequest>
  void UpdateFlowAsync(const UpdateFlowRequestT& request, const UpdateFlowResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateFlow, request, handler, context);
  }
 
  virtual Model::UpdateFlowPermissionsOutcome UpdateFlowPermissions(const Model::UpdateFlowPermissionsRequest& request) const;
 
  template <typename UpdateFlowPermissionsRequestT = Model::UpdateFlowPermissionsRequest>
  Model::UpdateFlowPermissionsOutcomeCallable UpdateFlowPermissionsCallable(const UpdateFlowPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateFlowPermissions, request);
  }
 
  template <typename UpdateFlowPermissionsRequestT = Model::UpdateFlowPermissionsRequest>
  void UpdateFlowPermissionsAsync(const UpdateFlowPermissionsRequestT& request, const UpdateFlowPermissionsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateFlowPermissions, request, handler, context);
  }
 
  virtual Model::UpdateFolderOutcome UpdateFolder(const Model::UpdateFolderRequest& request) const;
 
  template <typename UpdateFolderRequestT = Model::UpdateFolderRequest>
  Model::UpdateFolderOutcomeCallable UpdateFolderCallable(const UpdateFolderRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateFolder, request);
  }
 
  template <typename UpdateFolderRequestT = Model::UpdateFolderRequest>
  void UpdateFolderAsync(const UpdateFolderRequestT& request, const UpdateFolderResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateFolder, request, handler, context);
  }
 
  virtual Model::UpdateFolderPermissionsOutcome UpdateFolderPermissions(const Model::UpdateFolderPermissionsRequest& request) const;
 
  template <typename UpdateFolderPermissionsRequestT = Model::UpdateFolderPermissionsRequest>
  Model::UpdateFolderPermissionsOutcomeCallable UpdateFolderPermissionsCallable(const UpdateFolderPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateFolderPermissions, request);
  }
 
  template <typename UpdateFolderPermissionsRequestT = Model::UpdateFolderPermissionsRequest>
  void UpdateFolderPermissionsAsync(const UpdateFolderPermissionsRequestT& request,
                                    const UpdateFolderPermissionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateFolderPermissions, request, handler, context);
  }
 
  virtual Model::UpdateGroupOutcome UpdateGroup(const Model::UpdateGroupRequest& request) const;
 
  template <typename UpdateGroupRequestT = Model::UpdateGroupRequest>
  Model::UpdateGroupOutcomeCallable UpdateGroupCallable(const UpdateGroupRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateGroup, request);
  }
 
  template <typename UpdateGroupRequestT = Model::UpdateGroupRequest>
  void UpdateGroupAsync(const UpdateGroupRequestT& request, const UpdateGroupResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateGroup, request, handler, context);
  }
 
  virtual Model::UpdateIAMPolicyAssignmentOutcome UpdateIAMPolicyAssignment(const Model::UpdateIAMPolicyAssignmentRequest& request) const;
 
  template <typename UpdateIAMPolicyAssignmentRequestT = Model::UpdateIAMPolicyAssignmentRequest>
  Model::UpdateIAMPolicyAssignmentOutcomeCallable UpdateIAMPolicyAssignmentCallable(
      const UpdateIAMPolicyAssignmentRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateIAMPolicyAssignment, request);
  }
 
  template <typename UpdateIAMPolicyAssignmentRequestT = Model::UpdateIAMPolicyAssignmentRequest>
  void UpdateIAMPolicyAssignmentAsync(const UpdateIAMPolicyAssignmentRequestT& request,
                                      const UpdateIAMPolicyAssignmentResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateIAMPolicyAssignment, request, handler, context);
  }
 
  virtual Model::UpdateIdentityPropagationConfigOutcome UpdateIdentityPropagationConfig(
      const Model::UpdateIdentityPropagationConfigRequest& request) const;
 
  template <typename UpdateIdentityPropagationConfigRequestT = Model::UpdateIdentityPropagationConfigRequest>
  Model::UpdateIdentityPropagationConfigOutcomeCallable UpdateIdentityPropagationConfigCallable(
      const UpdateIdentityPropagationConfigRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateIdentityPropagationConfig, request);
  }
 
  template <typename UpdateIdentityPropagationConfigRequestT = Model::UpdateIdentityPropagationConfigRequest>
  void UpdateIdentityPropagationConfigAsync(const UpdateIdentityPropagationConfigRequestT& request,
                                            const UpdateIdentityPropagationConfigResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateIdentityPropagationConfig, request, handler, context);
  }
 
  virtual Model::UpdateIpRestrictionOutcome UpdateIpRestriction(const Model::UpdateIpRestrictionRequest& request) const;
 
  template <typename UpdateIpRestrictionRequestT = Model::UpdateIpRestrictionRequest>
  Model::UpdateIpRestrictionOutcomeCallable UpdateIpRestrictionCallable(const UpdateIpRestrictionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateIpRestriction, request);
  }
 
  template <typename UpdateIpRestrictionRequestT = Model::UpdateIpRestrictionRequest>
  void UpdateIpRestrictionAsync(const UpdateIpRestrictionRequestT& request, const UpdateIpRestrictionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateIpRestriction, request, handler, context);
  }
 
  virtual Model::UpdateKeyRegistrationOutcome UpdateKeyRegistration(const Model::UpdateKeyRegistrationRequest& request) const;
 
  template <typename UpdateKeyRegistrationRequestT = Model::UpdateKeyRegistrationRequest>
  Model::UpdateKeyRegistrationOutcomeCallable UpdateKeyRegistrationCallable(const UpdateKeyRegistrationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateKeyRegistration, request);
  }
 
  template <typename UpdateKeyRegistrationRequestT = Model::UpdateKeyRegistrationRequest>
  void UpdateKeyRegistrationAsync(const UpdateKeyRegistrationRequestT& request, const UpdateKeyRegistrationResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateKeyRegistration, request, handler, context);
  }
 
  virtual Model::UpdateKnowledgeBaseOutcome UpdateKnowledgeBase(const Model::UpdateKnowledgeBaseRequest& request) const;
 
  template <typename UpdateKnowledgeBaseRequestT = Model::UpdateKnowledgeBaseRequest>
  Model::UpdateKnowledgeBaseOutcomeCallable UpdateKnowledgeBaseCallable(const UpdateKnowledgeBaseRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateKnowledgeBase, request);
  }
 
  template <typename UpdateKnowledgeBaseRequestT = Model::UpdateKnowledgeBaseRequest>
  void UpdateKnowledgeBaseAsync(const UpdateKnowledgeBaseRequestT& request, const UpdateKnowledgeBaseResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateKnowledgeBase, request, handler, context);
  }
 
  virtual Model::UpdateKnowledgeBasePermissionsOutcome UpdateKnowledgeBasePermissions(
      const Model::UpdateKnowledgeBasePermissionsRequest& request) const;
 
  template <typename UpdateKnowledgeBasePermissionsRequestT = Model::UpdateKnowledgeBasePermissionsRequest>
  Model::UpdateKnowledgeBasePermissionsOutcomeCallable UpdateKnowledgeBasePermissionsCallable(
      const UpdateKnowledgeBasePermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateKnowledgeBasePermissions, request);
  }
 
  template <typename UpdateKnowledgeBasePermissionsRequestT = Model::UpdateKnowledgeBasePermissionsRequest>
  void UpdateKnowledgeBasePermissionsAsync(const UpdateKnowledgeBasePermissionsRequestT& request,
                                           const UpdateKnowledgeBasePermissionsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateKnowledgeBasePermissions, request, handler, context);
  }
 
  virtual Model::UpdateOAuthClientApplicationOutcome UpdateOAuthClientApplication(
      const Model::UpdateOAuthClientApplicationRequest& request) const;
 
  template <typename UpdateOAuthClientApplicationRequestT = Model::UpdateOAuthClientApplicationRequest>
  Model::UpdateOAuthClientApplicationOutcomeCallable UpdateOAuthClientApplicationCallable(
      const UpdateOAuthClientApplicationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateOAuthClientApplication, request);
  }
 
  template <typename UpdateOAuthClientApplicationRequestT = Model::UpdateOAuthClientApplicationRequest>
  void UpdateOAuthClientApplicationAsync(const UpdateOAuthClientApplicationRequestT& request,
                                         const UpdateOAuthClientApplicationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateOAuthClientApplication, request, handler, context);
  }
 
  virtual Model::UpdatePublicSharingSettingsOutcome UpdatePublicSharingSettings(
      const Model::UpdatePublicSharingSettingsRequest& request) const;
 
  template <typename UpdatePublicSharingSettingsRequestT = Model::UpdatePublicSharingSettingsRequest>
  Model::UpdatePublicSharingSettingsOutcomeCallable UpdatePublicSharingSettingsCallable(
      const UpdatePublicSharingSettingsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdatePublicSharingSettings, request);
  }
 
  template <typename UpdatePublicSharingSettingsRequestT = Model::UpdatePublicSharingSettingsRequest>
  void UpdatePublicSharingSettingsAsync(const UpdatePublicSharingSettingsRequestT& request,
                                        const UpdatePublicSharingSettingsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdatePublicSharingSettings, request, handler, context);
  }
 
  virtual Model::UpdateQPersonalizationConfigurationOutcome UpdateQPersonalizationConfiguration(
      const Model::UpdateQPersonalizationConfigurationRequest& request) const;
 
  template <typename UpdateQPersonalizationConfigurationRequestT = Model::UpdateQPersonalizationConfigurationRequest>
  Model::UpdateQPersonalizationConfigurationOutcomeCallable UpdateQPersonalizationConfigurationCallable(
      const UpdateQPersonalizationConfigurationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateQPersonalizationConfiguration, request);
  }
 
  template <typename UpdateQPersonalizationConfigurationRequestT = Model::UpdateQPersonalizationConfigurationRequest>
  void UpdateQPersonalizationConfigurationAsync(const UpdateQPersonalizationConfigurationRequestT& request,
                                                const UpdateQPersonalizationConfigurationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateQPersonalizationConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateQuickSightQSearchConfigurationOutcome UpdateQuickSightQSearchConfiguration(
      const Model::UpdateQuickSightQSearchConfigurationRequest& request) const;
 
  template <typename UpdateQuickSightQSearchConfigurationRequestT = Model::UpdateQuickSightQSearchConfigurationRequest>
  Model::UpdateQuickSightQSearchConfigurationOutcomeCallable UpdateQuickSightQSearchConfigurationCallable(
      const UpdateQuickSightQSearchConfigurationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateQuickSightQSearchConfiguration, request);
  }
 
  template <typename UpdateQuickSightQSearchConfigurationRequestT = Model::UpdateQuickSightQSearchConfigurationRequest>
  void UpdateQuickSightQSearchConfigurationAsync(const UpdateQuickSightQSearchConfigurationRequestT& request,
                                                 const UpdateQuickSightQSearchConfigurationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateQuickSightQSearchConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateRefreshScheduleOutcome UpdateRefreshSchedule(const Model::UpdateRefreshScheduleRequest& request) const;
 
  template <typename UpdateRefreshScheduleRequestT = Model::UpdateRefreshScheduleRequest>
  Model::UpdateRefreshScheduleOutcomeCallable UpdateRefreshScheduleCallable(const UpdateRefreshScheduleRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateRefreshSchedule, request);
  }
 
  template <typename UpdateRefreshScheduleRequestT = Model::UpdateRefreshScheduleRequest>
  void UpdateRefreshScheduleAsync(const UpdateRefreshScheduleRequestT& request, const UpdateRefreshScheduleResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateRefreshSchedule, request, handler, context);
  }
 
  virtual Model::UpdateRoleCustomPermissionOutcome UpdateRoleCustomPermission(
      const Model::UpdateRoleCustomPermissionRequest& request) const;
 
  template <typename UpdateRoleCustomPermissionRequestT = Model::UpdateRoleCustomPermissionRequest>
  Model::UpdateRoleCustomPermissionOutcomeCallable UpdateRoleCustomPermissionCallable(
      const UpdateRoleCustomPermissionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateRoleCustomPermission, request);
  }
 
  template <typename UpdateRoleCustomPermissionRequestT = Model::UpdateRoleCustomPermissionRequest>
  void UpdateRoleCustomPermissionAsync(const UpdateRoleCustomPermissionRequestT& request,
                                       const UpdateRoleCustomPermissionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateRoleCustomPermission, request, handler, context);
  }
 
  virtual Model::UpdateSPICECapacityConfigurationOutcome UpdateSPICECapacityConfiguration(
      const Model::UpdateSPICECapacityConfigurationRequest& request) const;
 
  template <typename UpdateSPICECapacityConfigurationRequestT = Model::UpdateSPICECapacityConfigurationRequest>
  Model::UpdateSPICECapacityConfigurationOutcomeCallable UpdateSPICECapacityConfigurationCallable(
      const UpdateSPICECapacityConfigurationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateSPICECapacityConfiguration, request);
  }
 
  template <typename UpdateSPICECapacityConfigurationRequestT = Model::UpdateSPICECapacityConfigurationRequest>
  void UpdateSPICECapacityConfigurationAsync(const UpdateSPICECapacityConfigurationRequestT& request,
                                             const UpdateSPICECapacityConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateSPICECapacityConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateSelfUpgradeOutcome UpdateSelfUpgrade(const Model::UpdateSelfUpgradeRequest& request) const;
 
  template <typename UpdateSelfUpgradeRequestT = Model::UpdateSelfUpgradeRequest>
  Model::UpdateSelfUpgradeOutcomeCallable UpdateSelfUpgradeCallable(const UpdateSelfUpgradeRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateSelfUpgrade, request);
  }
 
  template <typename UpdateSelfUpgradeRequestT = Model::UpdateSelfUpgradeRequest>
  void UpdateSelfUpgradeAsync(const UpdateSelfUpgradeRequestT& request, const UpdateSelfUpgradeResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateSelfUpgrade, request, handler, context);
  }
 
  virtual Model::UpdateSelfUpgradeConfigurationOutcome UpdateSelfUpgradeConfiguration(
      const Model::UpdateSelfUpgradeConfigurationRequest& request) const;
 
  template <typename UpdateSelfUpgradeConfigurationRequestT = Model::UpdateSelfUpgradeConfigurationRequest>
  Model::UpdateSelfUpgradeConfigurationOutcomeCallable UpdateSelfUpgradeConfigurationCallable(
      const UpdateSelfUpgradeConfigurationRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateSelfUpgradeConfiguration, request);
  }
 
  template <typename UpdateSelfUpgradeConfigurationRequestT = Model::UpdateSelfUpgradeConfigurationRequest>
  void UpdateSelfUpgradeConfigurationAsync(const UpdateSelfUpgradeConfigurationRequestT& request,
                                           const UpdateSelfUpgradeConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateSelfUpgradeConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateSpaceOutcome UpdateSpace(const Model::UpdateSpaceRequest& request) const;
 
  template <typename UpdateSpaceRequestT = Model::UpdateSpaceRequest>
  Model::UpdateSpaceOutcomeCallable UpdateSpaceCallable(const UpdateSpaceRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateSpace, request);
  }
 
  template <typename UpdateSpaceRequestT = Model::UpdateSpaceRequest>
  void UpdateSpaceAsync(const UpdateSpaceRequestT& request, const UpdateSpaceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateSpace, request, handler, context);
  }
 
  virtual Model::UpdateSpacePermissionsOutcome UpdateSpacePermissions(const Model::UpdateSpacePermissionsRequest& request) const;
 
  template <typename UpdateSpacePermissionsRequestT = Model::UpdateSpacePermissionsRequest>
  Model::UpdateSpacePermissionsOutcomeCallable UpdateSpacePermissionsCallable(const UpdateSpacePermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateSpacePermissions, request);
  }
 
  template <typename UpdateSpacePermissionsRequestT = Model::UpdateSpacePermissionsRequest>
  void UpdateSpacePermissionsAsync(const UpdateSpacePermissionsRequestT& request,
                                   const UpdateSpacePermissionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateSpacePermissions, request, handler, context);
  }
 
  virtual Model::UpdateSpaceResourcesOutcome UpdateSpaceResources(const Model::UpdateSpaceResourcesRequest& request) const;
 
  template <typename UpdateSpaceResourcesRequestT = Model::UpdateSpaceResourcesRequest>
  Model::UpdateSpaceResourcesOutcomeCallable UpdateSpaceResourcesCallable(const UpdateSpaceResourcesRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateSpaceResources, request);
  }
 
  template <typename UpdateSpaceResourcesRequestT = Model::UpdateSpaceResourcesRequest>
  void UpdateSpaceResourcesAsync(const UpdateSpaceResourcesRequestT& request, const UpdateSpaceResourcesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateSpaceResources, request, handler, context);
  }
 
  virtual Model::UpdateTemplateOutcome UpdateTemplate(const Model::UpdateTemplateRequest& request) const;
 
  template <typename UpdateTemplateRequestT = Model::UpdateTemplateRequest>
  Model::UpdateTemplateOutcomeCallable UpdateTemplateCallable(const UpdateTemplateRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateTemplate, request);
  }
 
  template <typename UpdateTemplateRequestT = Model::UpdateTemplateRequest>
  void UpdateTemplateAsync(const UpdateTemplateRequestT& request, const UpdateTemplateResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateTemplate, request, handler, context);
  }
 
  virtual Model::UpdateTemplateAliasOutcome UpdateTemplateAlias(const Model::UpdateTemplateAliasRequest& request) const;
 
  template <typename UpdateTemplateAliasRequestT = Model::UpdateTemplateAliasRequest>
  Model::UpdateTemplateAliasOutcomeCallable UpdateTemplateAliasCallable(const UpdateTemplateAliasRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateTemplateAlias, request);
  }
 
  template <typename UpdateTemplateAliasRequestT = Model::UpdateTemplateAliasRequest>
  void UpdateTemplateAliasAsync(const UpdateTemplateAliasRequestT& request, const UpdateTemplateAliasResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateTemplateAlias, request, handler, context);
  }
 
  virtual Model::UpdateTemplatePermissionsOutcome UpdateTemplatePermissions(const Model::UpdateTemplatePermissionsRequest& request) const;
 
  template <typename UpdateTemplatePermissionsRequestT = Model::UpdateTemplatePermissionsRequest>
  Model::UpdateTemplatePermissionsOutcomeCallable UpdateTemplatePermissionsCallable(
      const UpdateTemplatePermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateTemplatePermissions, request);
  }
 
  template <typename UpdateTemplatePermissionsRequestT = Model::UpdateTemplatePermissionsRequest>
  void UpdateTemplatePermissionsAsync(const UpdateTemplatePermissionsRequestT& request,
                                      const UpdateTemplatePermissionsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateTemplatePermissions, request, handler, context);
  }
 
  virtual Model::UpdateThemeOutcome UpdateTheme(const Model::UpdateThemeRequest& request) const;
 
  template <typename UpdateThemeRequestT = Model::UpdateThemeRequest>
  Model::UpdateThemeOutcomeCallable UpdateThemeCallable(const UpdateThemeRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateTheme, request);
  }
 
  template <typename UpdateThemeRequestT = Model::UpdateThemeRequest>
  void UpdateThemeAsync(const UpdateThemeRequestT& request, const UpdateThemeResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateTheme, request, handler, context);
  }
 
  virtual Model::UpdateThemeAliasOutcome UpdateThemeAlias(const Model::UpdateThemeAliasRequest& request) const;
 
  template <typename UpdateThemeAliasRequestT = Model::UpdateThemeAliasRequest>
  Model::UpdateThemeAliasOutcomeCallable UpdateThemeAliasCallable(const UpdateThemeAliasRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateThemeAlias, request);
  }
 
  template <typename UpdateThemeAliasRequestT = Model::UpdateThemeAliasRequest>
  void UpdateThemeAliasAsync(const UpdateThemeAliasRequestT& request, const UpdateThemeAliasResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateThemeAlias, request, handler, context);
  }
 
  virtual Model::UpdateThemePermissionsOutcome UpdateThemePermissions(const Model::UpdateThemePermissionsRequest& request) const;
 
  template <typename UpdateThemePermissionsRequestT = Model::UpdateThemePermissionsRequest>
  Model::UpdateThemePermissionsOutcomeCallable UpdateThemePermissionsCallable(const UpdateThemePermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateThemePermissions, request);
  }
 
  template <typename UpdateThemePermissionsRequestT = Model::UpdateThemePermissionsRequest>
  void UpdateThemePermissionsAsync(const UpdateThemePermissionsRequestT& request,
                                   const UpdateThemePermissionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateThemePermissions, request, handler, context);
  }
 
  virtual Model::UpdateTopicOutcome UpdateTopic(const Model::UpdateTopicRequest& request) const;
 
  template <typename UpdateTopicRequestT = Model::UpdateTopicRequest>
  Model::UpdateTopicOutcomeCallable UpdateTopicCallable(const UpdateTopicRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateTopic, request);
  }
 
  template <typename UpdateTopicRequestT = Model::UpdateTopicRequest>
  void UpdateTopicAsync(const UpdateTopicRequestT& request, const UpdateTopicResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateTopic, request, handler, context);
  }
 
  virtual Model::UpdateTopicPermissionsOutcome UpdateTopicPermissions(const Model::UpdateTopicPermissionsRequest& request) const;
 
  template <typename UpdateTopicPermissionsRequestT = Model::UpdateTopicPermissionsRequest>
  Model::UpdateTopicPermissionsOutcomeCallable UpdateTopicPermissionsCallable(const UpdateTopicPermissionsRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateTopicPermissions, request);
  }
 
  template <typename UpdateTopicPermissionsRequestT = Model::UpdateTopicPermissionsRequest>
  void UpdateTopicPermissionsAsync(const UpdateTopicPermissionsRequestT& request,
                                   const UpdateTopicPermissionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateTopicPermissions, request, handler, context);
  }
 
  virtual Model::UpdateTopicRefreshScheduleOutcome UpdateTopicRefreshSchedule(
      const Model::UpdateTopicRefreshScheduleRequest& request) const;
 
  template <typename UpdateTopicRefreshScheduleRequestT = Model::UpdateTopicRefreshScheduleRequest>
  Model::UpdateTopicRefreshScheduleOutcomeCallable UpdateTopicRefreshScheduleCallable(
      const UpdateTopicRefreshScheduleRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateTopicRefreshSchedule, request);
  }
 
  template <typename UpdateTopicRefreshScheduleRequestT = Model::UpdateTopicRefreshScheduleRequest>
  void UpdateTopicRefreshScheduleAsync(const UpdateTopicRefreshScheduleRequestT& request,
                                       const UpdateTopicRefreshScheduleResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateTopicRefreshSchedule, request, handler, context);
  }
 
  virtual Model::UpdateUserOutcome UpdateUser(const Model::UpdateUserRequest& request) const;
 
  template <typename UpdateUserRequestT = Model::UpdateUserRequest>
  Model::UpdateUserOutcomeCallable UpdateUserCallable(const UpdateUserRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateUser, request);
  }
 
  template <typename UpdateUserRequestT = Model::UpdateUserRequest>
  void UpdateUserAsync(const UpdateUserRequestT& request, const UpdateUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateUser, request, handler, context);
  }
 
  virtual Model::UpdateUserCustomPermissionOutcome UpdateUserCustomPermission(
      const Model::UpdateUserCustomPermissionRequest& request) const;
 
  template <typename UpdateUserCustomPermissionRequestT = Model::UpdateUserCustomPermissionRequest>
  Model::UpdateUserCustomPermissionOutcomeCallable UpdateUserCustomPermissionCallable(
      const UpdateUserCustomPermissionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateUserCustomPermission, request);
  }
 
  template <typename UpdateUserCustomPermissionRequestT = Model::UpdateUserCustomPermissionRequest>
  void UpdateUserCustomPermissionAsync(const UpdateUserCustomPermissionRequestT& request,
                                       const UpdateUserCustomPermissionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateUserCustomPermission, request, handler, context);
  }
 
  virtual Model::UpdateVPCConnectionOutcome UpdateVPCConnection(const Model::UpdateVPCConnectionRequest& request) const;
 
  template <typename UpdateVPCConnectionRequestT = Model::UpdateVPCConnectionRequest>
  Model::UpdateVPCConnectionOutcomeCallable UpdateVPCConnectionCallable(const UpdateVPCConnectionRequestT& request) const {
    return SubmitCallable(&QuickSightClient::UpdateVPCConnection, request);
  }
 
  template <typename UpdateVPCConnectionRequestT = Model::UpdateVPCConnectionRequest>
  void UpdateVPCConnectionAsync(const UpdateVPCConnectionRequestT& request, const UpdateVPCConnectionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QuickSightClient::UpdateVPCConnection, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<QuickSightEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<QuickSightClient>;
  void init(const QuickSightClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, QuickSightError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  QuickSightClientConfiguration m_clientConfiguration;
  std::shared_ptr<QuickSightEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace QuickSight
}  // namespace Aws