QuickSightClient.h

 
#pragma once
#include <aws/quicksight/QuickSight_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/quicksight/QuickSightServiceClientModel.h>
 
namespace Aws
{
namespace QuickSight
{
  class AWS_QUICKSIGHT_API QuickSightClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<QuickSightEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<QuickSightClient>;
      void init(const QuickSightClientConfiguration& clientConfiguration);
 
      QuickSightClientConfiguration m_clientConfiguration;
      std::shared_ptr<QuickSightEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace QuickSight
} // namespace Aws