QBusinessClient.h

 
#pragma once
#include <aws/qbusiness/QBusiness_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/qbusiness/QBusinessServiceClientModel.h>
 
namespace Aws
{
namespace QBusiness
{
  class AWS_QBUSINESS_API QBusinessClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<QBusinessClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef QBusinessClientConfiguration ClientConfigurationType;
      typedef QBusinessEndpointProvider EndpointProviderType;
 
        QBusinessClient(const Aws::QBusiness::QBusinessClientConfiguration& clientConfiguration = Aws::QBusiness::QBusinessClientConfiguration(),
                        std::shared_ptr<QBusinessEndpointProviderBase> endpointProvider = nullptr);
 
        QBusinessClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<QBusinessEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::QBusiness::QBusinessClientConfiguration& clientConfiguration = Aws::QBusiness::QBusinessClientConfiguration());
 
        QBusinessClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<QBusinessEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::QBusiness::QBusinessClientConfiguration& clientConfiguration = Aws::QBusiness::QBusinessClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        QBusinessClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        QBusinessClient(const Aws::Auth::AWSCredentials& credentials,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        QBusinessClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~QBusinessClient();
 
        virtual Model::AssociatePermissionOutcome AssociatePermission(const Model::AssociatePermissionRequest& request) const;
 
        template<typename AssociatePermissionRequestT = Model::AssociatePermissionRequest>
        Model::AssociatePermissionOutcomeCallable AssociatePermissionCallable(const AssociatePermissionRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::AssociatePermission, request);
        }
 
        template<typename AssociatePermissionRequestT = Model::AssociatePermissionRequest>
        void AssociatePermissionAsync(const AssociatePermissionRequestT& request, const AssociatePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::AssociatePermission, request, handler, context);
        }
 
        virtual Model::BatchDeleteDocumentOutcome BatchDeleteDocument(const Model::BatchDeleteDocumentRequest& request) const;
 
        template<typename BatchDeleteDocumentRequestT = Model::BatchDeleteDocumentRequest>
        Model::BatchDeleteDocumentOutcomeCallable BatchDeleteDocumentCallable(const BatchDeleteDocumentRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::BatchDeleteDocument, request);
        }
 
        template<typename BatchDeleteDocumentRequestT = Model::BatchDeleteDocumentRequest>
        void BatchDeleteDocumentAsync(const BatchDeleteDocumentRequestT& request, const BatchDeleteDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::BatchDeleteDocument, request, handler, context);
        }
 
        virtual Model::BatchPutDocumentOutcome BatchPutDocument(const Model::BatchPutDocumentRequest& request) const;
 
        template<typename BatchPutDocumentRequestT = Model::BatchPutDocumentRequest>
        Model::BatchPutDocumentOutcomeCallable BatchPutDocumentCallable(const BatchPutDocumentRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::BatchPutDocument, request);
        }
 
        template<typename BatchPutDocumentRequestT = Model::BatchPutDocumentRequest>
        void BatchPutDocumentAsync(const BatchPutDocumentRequestT& request, const BatchPutDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::BatchPutDocument, request, handler, context);
        }
 
        virtual Model::CancelSubscriptionOutcome CancelSubscription(const Model::CancelSubscriptionRequest& request) const;
 
        template<typename CancelSubscriptionRequestT = Model::CancelSubscriptionRequest>
        Model::CancelSubscriptionOutcomeCallable CancelSubscriptionCallable(const CancelSubscriptionRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::CancelSubscription, request);
        }
 
        template<typename CancelSubscriptionRequestT = Model::CancelSubscriptionRequest>
        void CancelSubscriptionAsync(const CancelSubscriptionRequestT& request, const CancelSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::CancelSubscription, request, handler, context);
        }
 
        virtual void ChatAsync(Model::ChatRequest& request,
                const ChatStreamReadyHandler& streamReadyHandler,
                const ChatResponseReceivedHandler& handler,
                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& handlerContext = nullptr) const;
 
        virtual Model::ChatSyncOutcome ChatSync(const Model::ChatSyncRequest& request) const;
 
        template<typename ChatSyncRequestT = Model::ChatSyncRequest>
        Model::ChatSyncOutcomeCallable ChatSyncCallable(const ChatSyncRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ChatSync, request);
        }
 
        template<typename ChatSyncRequestT = Model::ChatSyncRequest>
        void ChatSyncAsync(const ChatSyncRequestT& request, const ChatSyncResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ChatSync, request, handler, context);
        }
 
        virtual Model::CheckDocumentAccessOutcome CheckDocumentAccess(const Model::CheckDocumentAccessRequest& request) const;
 
        template<typename CheckDocumentAccessRequestT = Model::CheckDocumentAccessRequest>
        Model::CheckDocumentAccessOutcomeCallable CheckDocumentAccessCallable(const CheckDocumentAccessRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::CheckDocumentAccess, request);
        }
 
        template<typename CheckDocumentAccessRequestT = Model::CheckDocumentAccessRequest>
        void CheckDocumentAccessAsync(const CheckDocumentAccessRequestT& request, const CheckDocumentAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::CheckDocumentAccess, request, handler, context);
        }
 
        virtual Model::CreateAnonymousWebExperienceUrlOutcome CreateAnonymousWebExperienceUrl(const Model::CreateAnonymousWebExperienceUrlRequest& request) const;
 
        template<typename CreateAnonymousWebExperienceUrlRequestT = Model::CreateAnonymousWebExperienceUrlRequest>
        Model::CreateAnonymousWebExperienceUrlOutcomeCallable CreateAnonymousWebExperienceUrlCallable(const CreateAnonymousWebExperienceUrlRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::CreateAnonymousWebExperienceUrl, request);
        }
 
        template<typename CreateAnonymousWebExperienceUrlRequestT = Model::CreateAnonymousWebExperienceUrlRequest>
        void CreateAnonymousWebExperienceUrlAsync(const CreateAnonymousWebExperienceUrlRequestT& request, const CreateAnonymousWebExperienceUrlResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::CreateAnonymousWebExperienceUrl, request, handler, context);
        }
 
        virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
        template<typename CreateApplicationRequestT = Model::CreateApplicationRequest>
        Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::CreateApplication, request);
        }
 
        template<typename CreateApplicationRequestT = Model::CreateApplicationRequest>
        void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::CreateApplication, request, handler, context);
        }
 
        virtual Model::CreateChatResponseConfigurationOutcome CreateChatResponseConfiguration(const Model::CreateChatResponseConfigurationRequest& request) const;
 
        template<typename CreateChatResponseConfigurationRequestT = Model::CreateChatResponseConfigurationRequest>
        Model::CreateChatResponseConfigurationOutcomeCallable CreateChatResponseConfigurationCallable(const CreateChatResponseConfigurationRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::CreateChatResponseConfiguration, request);
        }
 
        template<typename CreateChatResponseConfigurationRequestT = Model::CreateChatResponseConfigurationRequest>
        void CreateChatResponseConfigurationAsync(const CreateChatResponseConfigurationRequestT& request, const CreateChatResponseConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::CreateChatResponseConfiguration, request, handler, context);
        }
 
        virtual Model::CreateDataAccessorOutcome CreateDataAccessor(const Model::CreateDataAccessorRequest& request) const;
 
        template<typename CreateDataAccessorRequestT = Model::CreateDataAccessorRequest>
        Model::CreateDataAccessorOutcomeCallable CreateDataAccessorCallable(const CreateDataAccessorRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::CreateDataAccessor, request);
        }
 
        template<typename CreateDataAccessorRequestT = Model::CreateDataAccessorRequest>
        void CreateDataAccessorAsync(const CreateDataAccessorRequestT& request, const CreateDataAccessorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::CreateDataAccessor, 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(&QBusinessClient::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(&QBusinessClient::CreateDataSource, request, handler, context);
        }
 
        virtual Model::CreateIndexOutcome CreateIndex(const Model::CreateIndexRequest& request) const;
 
        template<typename CreateIndexRequestT = Model::CreateIndexRequest>
        Model::CreateIndexOutcomeCallable CreateIndexCallable(const CreateIndexRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::CreateIndex, request);
        }
 
        template<typename CreateIndexRequestT = Model::CreateIndexRequest>
        void CreateIndexAsync(const CreateIndexRequestT& request, const CreateIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::CreateIndex, request, handler, context);
        }
 
        virtual Model::CreatePluginOutcome CreatePlugin(const Model::CreatePluginRequest& request) const;
 
        template<typename CreatePluginRequestT = Model::CreatePluginRequest>
        Model::CreatePluginOutcomeCallable CreatePluginCallable(const CreatePluginRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::CreatePlugin, request);
        }
 
        template<typename CreatePluginRequestT = Model::CreatePluginRequest>
        void CreatePluginAsync(const CreatePluginRequestT& request, const CreatePluginResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::CreatePlugin, request, handler, context);
        }
 
        virtual Model::CreateRetrieverOutcome CreateRetriever(const Model::CreateRetrieverRequest& request) const;
 
        template<typename CreateRetrieverRequestT = Model::CreateRetrieverRequest>
        Model::CreateRetrieverOutcomeCallable CreateRetrieverCallable(const CreateRetrieverRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::CreateRetriever, request);
        }
 
        template<typename CreateRetrieverRequestT = Model::CreateRetrieverRequest>
        void CreateRetrieverAsync(const CreateRetrieverRequestT& request, const CreateRetrieverResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::CreateRetriever, request, handler, context);
        }
 
        virtual Model::CreateSubscriptionOutcome CreateSubscription(const Model::CreateSubscriptionRequest& request) const;
 
        template<typename CreateSubscriptionRequestT = Model::CreateSubscriptionRequest>
        Model::CreateSubscriptionOutcomeCallable CreateSubscriptionCallable(const CreateSubscriptionRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::CreateSubscription, request);
        }
 
        template<typename CreateSubscriptionRequestT = Model::CreateSubscriptionRequest>
        void CreateSubscriptionAsync(const CreateSubscriptionRequestT& request, const CreateSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::CreateSubscription, request, handler, context);
        }
 
        virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const;
 
        template<typename CreateUserRequestT = Model::CreateUserRequest>
        Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::CreateUser, request);
        }
 
        template<typename CreateUserRequestT = Model::CreateUserRequest>
        void CreateUserAsync(const CreateUserRequestT& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::CreateUser, request, handler, context);
        }
 
        virtual Model::CreateWebExperienceOutcome CreateWebExperience(const Model::CreateWebExperienceRequest& request) const;
 
        template<typename CreateWebExperienceRequestT = Model::CreateWebExperienceRequest>
        Model::CreateWebExperienceOutcomeCallable CreateWebExperienceCallable(const CreateWebExperienceRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::CreateWebExperience, request);
        }
 
        template<typename CreateWebExperienceRequestT = Model::CreateWebExperienceRequest>
        void CreateWebExperienceAsync(const CreateWebExperienceRequestT& request, const CreateWebExperienceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::CreateWebExperience, request, handler, context);
        }
 
        virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
        template<typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
        Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::DeleteApplication, request);
        }
 
        template<typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
        void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::DeleteApplication, request, handler, context);
        }
 
        virtual Model::DeleteAttachmentOutcome DeleteAttachment(const Model::DeleteAttachmentRequest& request) const;
 
        template<typename DeleteAttachmentRequestT = Model::DeleteAttachmentRequest>
        Model::DeleteAttachmentOutcomeCallable DeleteAttachmentCallable(const DeleteAttachmentRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::DeleteAttachment, request);
        }
 
        template<typename DeleteAttachmentRequestT = Model::DeleteAttachmentRequest>
        void DeleteAttachmentAsync(const DeleteAttachmentRequestT& request, const DeleteAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::DeleteAttachment, request, handler, context);
        }
 
        virtual Model::DeleteChatControlsConfigurationOutcome DeleteChatControlsConfiguration(const Model::DeleteChatControlsConfigurationRequest& request) const;
 
        template<typename DeleteChatControlsConfigurationRequestT = Model::DeleteChatControlsConfigurationRequest>
        Model::DeleteChatControlsConfigurationOutcomeCallable DeleteChatControlsConfigurationCallable(const DeleteChatControlsConfigurationRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::DeleteChatControlsConfiguration, request);
        }
 
        template<typename DeleteChatControlsConfigurationRequestT = Model::DeleteChatControlsConfigurationRequest>
        void DeleteChatControlsConfigurationAsync(const DeleteChatControlsConfigurationRequestT& request, const DeleteChatControlsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::DeleteChatControlsConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteChatResponseConfigurationOutcome DeleteChatResponseConfiguration(const Model::DeleteChatResponseConfigurationRequest& request) const;
 
        template<typename DeleteChatResponseConfigurationRequestT = Model::DeleteChatResponseConfigurationRequest>
        Model::DeleteChatResponseConfigurationOutcomeCallable DeleteChatResponseConfigurationCallable(const DeleteChatResponseConfigurationRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::DeleteChatResponseConfiguration, request);
        }
 
        template<typename DeleteChatResponseConfigurationRequestT = Model::DeleteChatResponseConfigurationRequest>
        void DeleteChatResponseConfigurationAsync(const DeleteChatResponseConfigurationRequestT& request, const DeleteChatResponseConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::DeleteChatResponseConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteConversationOutcome DeleteConversation(const Model::DeleteConversationRequest& request) const;
 
        template<typename DeleteConversationRequestT = Model::DeleteConversationRequest>
        Model::DeleteConversationOutcomeCallable DeleteConversationCallable(const DeleteConversationRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::DeleteConversation, request);
        }
 
        template<typename DeleteConversationRequestT = Model::DeleteConversationRequest>
        void DeleteConversationAsync(const DeleteConversationRequestT& request, const DeleteConversationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::DeleteConversation, request, handler, context);
        }
 
        virtual Model::DeleteDataAccessorOutcome DeleteDataAccessor(const Model::DeleteDataAccessorRequest& request) const;
 
        template<typename DeleteDataAccessorRequestT = Model::DeleteDataAccessorRequest>
        Model::DeleteDataAccessorOutcomeCallable DeleteDataAccessorCallable(const DeleteDataAccessorRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::DeleteDataAccessor, request);
        }
 
        template<typename DeleteDataAccessorRequestT = Model::DeleteDataAccessorRequest>
        void DeleteDataAccessorAsync(const DeleteDataAccessorRequestT& request, const DeleteDataAccessorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::DeleteDataAccessor, 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(&QBusinessClient::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(&QBusinessClient::DeleteDataSource, 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(&QBusinessClient::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(&QBusinessClient::DeleteGroup, request, handler, context);
        }
 
        virtual Model::DeleteIndexOutcome DeleteIndex(const Model::DeleteIndexRequest& request) const;
 
        template<typename DeleteIndexRequestT = Model::DeleteIndexRequest>
        Model::DeleteIndexOutcomeCallable DeleteIndexCallable(const DeleteIndexRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::DeleteIndex, request);
        }
 
        template<typename DeleteIndexRequestT = Model::DeleteIndexRequest>
        void DeleteIndexAsync(const DeleteIndexRequestT& request, const DeleteIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::DeleteIndex, request, handler, context);
        }
 
        virtual Model::DeletePluginOutcome DeletePlugin(const Model::DeletePluginRequest& request) const;
 
        template<typename DeletePluginRequestT = Model::DeletePluginRequest>
        Model::DeletePluginOutcomeCallable DeletePluginCallable(const DeletePluginRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::DeletePlugin, request);
        }
 
        template<typename DeletePluginRequestT = Model::DeletePluginRequest>
        void DeletePluginAsync(const DeletePluginRequestT& request, const DeletePluginResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::DeletePlugin, request, handler, context);
        }
 
        virtual Model::DeleteRetrieverOutcome DeleteRetriever(const Model::DeleteRetrieverRequest& request) const;
 
        template<typename DeleteRetrieverRequestT = Model::DeleteRetrieverRequest>
        Model::DeleteRetrieverOutcomeCallable DeleteRetrieverCallable(const DeleteRetrieverRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::DeleteRetriever, request);
        }
 
        template<typename DeleteRetrieverRequestT = Model::DeleteRetrieverRequest>
        void DeleteRetrieverAsync(const DeleteRetrieverRequestT& request, const DeleteRetrieverResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::DeleteRetriever, 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(&QBusinessClient::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(&QBusinessClient::DeleteUser, request, handler, context);
        }
 
        virtual Model::DeleteWebExperienceOutcome DeleteWebExperience(const Model::DeleteWebExperienceRequest& request) const;
 
        template<typename DeleteWebExperienceRequestT = Model::DeleteWebExperienceRequest>
        Model::DeleteWebExperienceOutcomeCallable DeleteWebExperienceCallable(const DeleteWebExperienceRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::DeleteWebExperience, request);
        }
 
        template<typename DeleteWebExperienceRequestT = Model::DeleteWebExperienceRequest>
        void DeleteWebExperienceAsync(const DeleteWebExperienceRequestT& request, const DeleteWebExperienceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::DeleteWebExperience, request, handler, context);
        }
 
        virtual Model::DisassociatePermissionOutcome DisassociatePermission(const Model::DisassociatePermissionRequest& request) const;
 
        template<typename DisassociatePermissionRequestT = Model::DisassociatePermissionRequest>
        Model::DisassociatePermissionOutcomeCallable DisassociatePermissionCallable(const DisassociatePermissionRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::DisassociatePermission, request);
        }
 
        template<typename DisassociatePermissionRequestT = Model::DisassociatePermissionRequest>
        void DisassociatePermissionAsync(const DisassociatePermissionRequestT& request, const DisassociatePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::DisassociatePermission, request, handler, context);
        }
 
        virtual Model::GetApplicationOutcome GetApplication(const Model::GetApplicationRequest& request) const;
 
        template<typename GetApplicationRequestT = Model::GetApplicationRequest>
        Model::GetApplicationOutcomeCallable GetApplicationCallable(const GetApplicationRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::GetApplication, request);
        }
 
        template<typename GetApplicationRequestT = Model::GetApplicationRequest>
        void GetApplicationAsync(const GetApplicationRequestT& request, const GetApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::GetApplication, request, handler, context);
        }
 
        virtual Model::GetChatControlsConfigurationOutcome GetChatControlsConfiguration(const Model::GetChatControlsConfigurationRequest& request) const;
 
        template<typename GetChatControlsConfigurationRequestT = Model::GetChatControlsConfigurationRequest>
        Model::GetChatControlsConfigurationOutcomeCallable GetChatControlsConfigurationCallable(const GetChatControlsConfigurationRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::GetChatControlsConfiguration, request);
        }
 
        template<typename GetChatControlsConfigurationRequestT = Model::GetChatControlsConfigurationRequest>
        void GetChatControlsConfigurationAsync(const GetChatControlsConfigurationRequestT& request, const GetChatControlsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::GetChatControlsConfiguration, request, handler, context);
        }
 
        virtual Model::GetChatResponseConfigurationOutcome GetChatResponseConfiguration(const Model::GetChatResponseConfigurationRequest& request) const;
 
        template<typename GetChatResponseConfigurationRequestT = Model::GetChatResponseConfigurationRequest>
        Model::GetChatResponseConfigurationOutcomeCallable GetChatResponseConfigurationCallable(const GetChatResponseConfigurationRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::GetChatResponseConfiguration, request);
        }
 
        template<typename GetChatResponseConfigurationRequestT = Model::GetChatResponseConfigurationRequest>
        void GetChatResponseConfigurationAsync(const GetChatResponseConfigurationRequestT& request, const GetChatResponseConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::GetChatResponseConfiguration, request, handler, context);
        }
 
        virtual Model::GetDataAccessorOutcome GetDataAccessor(const Model::GetDataAccessorRequest& request) const;
 
        template<typename GetDataAccessorRequestT = Model::GetDataAccessorRequest>
        Model::GetDataAccessorOutcomeCallable GetDataAccessorCallable(const GetDataAccessorRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::GetDataAccessor, request);
        }
 
        template<typename GetDataAccessorRequestT = Model::GetDataAccessorRequest>
        void GetDataAccessorAsync(const GetDataAccessorRequestT& request, const GetDataAccessorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::GetDataAccessor, request, handler, context);
        }
 
        virtual Model::GetDataSourceOutcome GetDataSource(const Model::GetDataSourceRequest& request) const;
 
        template<typename GetDataSourceRequestT = Model::GetDataSourceRequest>
        Model::GetDataSourceOutcomeCallable GetDataSourceCallable(const GetDataSourceRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::GetDataSource, request);
        }
 
        template<typename GetDataSourceRequestT = Model::GetDataSourceRequest>
        void GetDataSourceAsync(const GetDataSourceRequestT& request, const GetDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::GetDataSource, request, handler, context);
        }
 
        virtual Model::GetDocumentContentOutcome GetDocumentContent(const Model::GetDocumentContentRequest& request) const;
 
        template<typename GetDocumentContentRequestT = Model::GetDocumentContentRequest>
        Model::GetDocumentContentOutcomeCallable GetDocumentContentCallable(const GetDocumentContentRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::GetDocumentContent, request);
        }
 
        template<typename GetDocumentContentRequestT = Model::GetDocumentContentRequest>
        void GetDocumentContentAsync(const GetDocumentContentRequestT& request, const GetDocumentContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::GetDocumentContent, request, handler, context);
        }
 
        virtual Model::GetGroupOutcome GetGroup(const Model::GetGroupRequest& request) const;
 
        template<typename GetGroupRequestT = Model::GetGroupRequest>
        Model::GetGroupOutcomeCallable GetGroupCallable(const GetGroupRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::GetGroup, request);
        }
 
        template<typename GetGroupRequestT = Model::GetGroupRequest>
        void GetGroupAsync(const GetGroupRequestT& request, const GetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::GetGroup, request, handler, context);
        }
 
        virtual Model::GetIndexOutcome GetIndex(const Model::GetIndexRequest& request) const;
 
        template<typename GetIndexRequestT = Model::GetIndexRequest>
        Model::GetIndexOutcomeCallable GetIndexCallable(const GetIndexRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::GetIndex, request);
        }
 
        template<typename GetIndexRequestT = Model::GetIndexRequest>
        void GetIndexAsync(const GetIndexRequestT& request, const GetIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::GetIndex, request, handler, context);
        }
 
        virtual Model::GetMediaOutcome GetMedia(const Model::GetMediaRequest& request) const;
 
        template<typename GetMediaRequestT = Model::GetMediaRequest>
        Model::GetMediaOutcomeCallable GetMediaCallable(const GetMediaRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::GetMedia, request);
        }
 
        template<typename GetMediaRequestT = Model::GetMediaRequest>
        void GetMediaAsync(const GetMediaRequestT& request, const GetMediaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::GetMedia, request, handler, context);
        }
 
        virtual Model::GetPluginOutcome GetPlugin(const Model::GetPluginRequest& request) const;
 
        template<typename GetPluginRequestT = Model::GetPluginRequest>
        Model::GetPluginOutcomeCallable GetPluginCallable(const GetPluginRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::GetPlugin, request);
        }
 
        template<typename GetPluginRequestT = Model::GetPluginRequest>
        void GetPluginAsync(const GetPluginRequestT& request, const GetPluginResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::GetPlugin, request, handler, context);
        }
 
        virtual Model::GetPolicyOutcome GetPolicy(const Model::GetPolicyRequest& request) const;
 
        template<typename GetPolicyRequestT = Model::GetPolicyRequest>
        Model::GetPolicyOutcomeCallable GetPolicyCallable(const GetPolicyRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::GetPolicy, request);
        }
 
        template<typename GetPolicyRequestT = Model::GetPolicyRequest>
        void GetPolicyAsync(const GetPolicyRequestT& request, const GetPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::GetPolicy, request, handler, context);
        }
 
        virtual Model::GetRetrieverOutcome GetRetriever(const Model::GetRetrieverRequest& request) const;
 
        template<typename GetRetrieverRequestT = Model::GetRetrieverRequest>
        Model::GetRetrieverOutcomeCallable GetRetrieverCallable(const GetRetrieverRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::GetRetriever, request);
        }
 
        template<typename GetRetrieverRequestT = Model::GetRetrieverRequest>
        void GetRetrieverAsync(const GetRetrieverRequestT& request, const GetRetrieverResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::GetRetriever, request, handler, context);
        }
 
        virtual Model::GetUserOutcome GetUser(const Model::GetUserRequest& request) const;
 
        template<typename GetUserRequestT = Model::GetUserRequest>
        Model::GetUserOutcomeCallable GetUserCallable(const GetUserRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::GetUser, request);
        }
 
        template<typename GetUserRequestT = Model::GetUserRequest>
        void GetUserAsync(const GetUserRequestT& request, const GetUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::GetUser, request, handler, context);
        }
 
        virtual Model::GetWebExperienceOutcome GetWebExperience(const Model::GetWebExperienceRequest& request) const;
 
        template<typename GetWebExperienceRequestT = Model::GetWebExperienceRequest>
        Model::GetWebExperienceOutcomeCallable GetWebExperienceCallable(const GetWebExperienceRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::GetWebExperience, request);
        }
 
        template<typename GetWebExperienceRequestT = Model::GetWebExperienceRequest>
        void GetWebExperienceAsync(const GetWebExperienceRequestT& request, const GetWebExperienceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::GetWebExperience, request, handler, context);
        }
 
        virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
        template<typename ListApplicationsRequestT = Model::ListApplicationsRequest>
        Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const
        {
            return SubmitCallable(&QBusinessClient::ListApplications, request);
        }
 
        template<typename ListApplicationsRequestT = Model::ListApplicationsRequest>
        void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListApplicationsRequestT& request = {}) const
        {
            return SubmitAsync(&QBusinessClient::ListApplications, request, handler, context);
        }
 
        virtual Model::ListAttachmentsOutcome ListAttachments(const Model::ListAttachmentsRequest& request) const;
 
        template<typename ListAttachmentsRequestT = Model::ListAttachmentsRequest>
        Model::ListAttachmentsOutcomeCallable ListAttachmentsCallable(const ListAttachmentsRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ListAttachments, request);
        }
 
        template<typename ListAttachmentsRequestT = Model::ListAttachmentsRequest>
        void ListAttachmentsAsync(const ListAttachmentsRequestT& request, const ListAttachmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ListAttachments, request, handler, context);
        }
 
        virtual Model::ListChatResponseConfigurationsOutcome ListChatResponseConfigurations(const Model::ListChatResponseConfigurationsRequest& request) const;
 
        template<typename ListChatResponseConfigurationsRequestT = Model::ListChatResponseConfigurationsRequest>
        Model::ListChatResponseConfigurationsOutcomeCallable ListChatResponseConfigurationsCallable(const ListChatResponseConfigurationsRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ListChatResponseConfigurations, request);
        }
 
        template<typename ListChatResponseConfigurationsRequestT = Model::ListChatResponseConfigurationsRequest>
        void ListChatResponseConfigurationsAsync(const ListChatResponseConfigurationsRequestT& request, const ListChatResponseConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ListChatResponseConfigurations, request, handler, context);
        }
 
        virtual Model::ListConversationsOutcome ListConversations(const Model::ListConversationsRequest& request) const;
 
        template<typename ListConversationsRequestT = Model::ListConversationsRequest>
        Model::ListConversationsOutcomeCallable ListConversationsCallable(const ListConversationsRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ListConversations, request);
        }
 
        template<typename ListConversationsRequestT = Model::ListConversationsRequest>
        void ListConversationsAsync(const ListConversationsRequestT& request, const ListConversationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ListConversations, request, handler, context);
        }
 
        virtual Model::ListDataAccessorsOutcome ListDataAccessors(const Model::ListDataAccessorsRequest& request) const;
 
        template<typename ListDataAccessorsRequestT = Model::ListDataAccessorsRequest>
        Model::ListDataAccessorsOutcomeCallable ListDataAccessorsCallable(const ListDataAccessorsRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ListDataAccessors, request);
        }
 
        template<typename ListDataAccessorsRequestT = Model::ListDataAccessorsRequest>
        void ListDataAccessorsAsync(const ListDataAccessorsRequestT& request, const ListDataAccessorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ListDataAccessors, request, handler, context);
        }
 
        virtual Model::ListDataSourceSyncJobsOutcome ListDataSourceSyncJobs(const Model::ListDataSourceSyncJobsRequest& request) const;
 
        template<typename ListDataSourceSyncJobsRequestT = Model::ListDataSourceSyncJobsRequest>
        Model::ListDataSourceSyncJobsOutcomeCallable ListDataSourceSyncJobsCallable(const ListDataSourceSyncJobsRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ListDataSourceSyncJobs, request);
        }
 
        template<typename ListDataSourceSyncJobsRequestT = Model::ListDataSourceSyncJobsRequest>
        void ListDataSourceSyncJobsAsync(const ListDataSourceSyncJobsRequestT& request, const ListDataSourceSyncJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ListDataSourceSyncJobs, 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(&QBusinessClient::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(&QBusinessClient::ListDataSources, request, handler, context);
        }
 
        virtual Model::ListDocumentsOutcome ListDocuments(const Model::ListDocumentsRequest& request) const;
 
        template<typename ListDocumentsRequestT = Model::ListDocumentsRequest>
        Model::ListDocumentsOutcomeCallable ListDocumentsCallable(const ListDocumentsRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ListDocuments, request);
        }
 
        template<typename ListDocumentsRequestT = Model::ListDocumentsRequest>
        void ListDocumentsAsync(const ListDocumentsRequestT& request, const ListDocumentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ListDocuments, 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(&QBusinessClient::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(&QBusinessClient::ListGroups, request, handler, context);
        }
 
        virtual Model::ListIndicesOutcome ListIndices(const Model::ListIndicesRequest& request) const;
 
        template<typename ListIndicesRequestT = Model::ListIndicesRequest>
        Model::ListIndicesOutcomeCallable ListIndicesCallable(const ListIndicesRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ListIndices, request);
        }
 
        template<typename ListIndicesRequestT = Model::ListIndicesRequest>
        void ListIndicesAsync(const ListIndicesRequestT& request, const ListIndicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ListIndices, request, handler, context);
        }
 
        virtual Model::ListMessagesOutcome ListMessages(const Model::ListMessagesRequest& request) const;
 
        template<typename ListMessagesRequestT = Model::ListMessagesRequest>
        Model::ListMessagesOutcomeCallable ListMessagesCallable(const ListMessagesRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ListMessages, request);
        }
 
        template<typename ListMessagesRequestT = Model::ListMessagesRequest>
        void ListMessagesAsync(const ListMessagesRequestT& request, const ListMessagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ListMessages, request, handler, context);
        }
 
        virtual Model::ListPluginActionsOutcome ListPluginActions(const Model::ListPluginActionsRequest& request) const;
 
        template<typename ListPluginActionsRequestT = Model::ListPluginActionsRequest>
        Model::ListPluginActionsOutcomeCallable ListPluginActionsCallable(const ListPluginActionsRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ListPluginActions, request);
        }
 
        template<typename ListPluginActionsRequestT = Model::ListPluginActionsRequest>
        void ListPluginActionsAsync(const ListPluginActionsRequestT& request, const ListPluginActionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ListPluginActions, request, handler, context);
        }
 
        virtual Model::ListPluginTypeActionsOutcome ListPluginTypeActions(const Model::ListPluginTypeActionsRequest& request) const;
 
        template<typename ListPluginTypeActionsRequestT = Model::ListPluginTypeActionsRequest>
        Model::ListPluginTypeActionsOutcomeCallable ListPluginTypeActionsCallable(const ListPluginTypeActionsRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ListPluginTypeActions, request);
        }
 
        template<typename ListPluginTypeActionsRequestT = Model::ListPluginTypeActionsRequest>
        void ListPluginTypeActionsAsync(const ListPluginTypeActionsRequestT& request, const ListPluginTypeActionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ListPluginTypeActions, request, handler, context);
        }
 
        virtual Model::ListPluginTypeMetadataOutcome ListPluginTypeMetadata(const Model::ListPluginTypeMetadataRequest& request = {}) const;
 
        template<typename ListPluginTypeMetadataRequestT = Model::ListPluginTypeMetadataRequest>
        Model::ListPluginTypeMetadataOutcomeCallable ListPluginTypeMetadataCallable(const ListPluginTypeMetadataRequestT& request = {}) const
        {
            return SubmitCallable(&QBusinessClient::ListPluginTypeMetadata, request);
        }
 
        template<typename ListPluginTypeMetadataRequestT = Model::ListPluginTypeMetadataRequest>
        void ListPluginTypeMetadataAsync(const ListPluginTypeMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPluginTypeMetadataRequestT& request = {}) const
        {
            return SubmitAsync(&QBusinessClient::ListPluginTypeMetadata, request, handler, context);
        }
 
        virtual Model::ListPluginsOutcome ListPlugins(const Model::ListPluginsRequest& request) const;
 
        template<typename ListPluginsRequestT = Model::ListPluginsRequest>
        Model::ListPluginsOutcomeCallable ListPluginsCallable(const ListPluginsRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ListPlugins, request);
        }
 
        template<typename ListPluginsRequestT = Model::ListPluginsRequest>
        void ListPluginsAsync(const ListPluginsRequestT& request, const ListPluginsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ListPlugins, request, handler, context);
        }
 
        virtual Model::ListRetrieversOutcome ListRetrievers(const Model::ListRetrieversRequest& request) const;
 
        template<typename ListRetrieversRequestT = Model::ListRetrieversRequest>
        Model::ListRetrieversOutcomeCallable ListRetrieversCallable(const ListRetrieversRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ListRetrievers, request);
        }
 
        template<typename ListRetrieversRequestT = Model::ListRetrieversRequest>
        void ListRetrieversAsync(const ListRetrieversRequestT& request, const ListRetrieversResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ListRetrievers, request, handler, context);
        }
 
        virtual Model::ListSubscriptionsOutcome ListSubscriptions(const Model::ListSubscriptionsRequest& request) const;
 
        template<typename ListSubscriptionsRequestT = Model::ListSubscriptionsRequest>
        Model::ListSubscriptionsOutcomeCallable ListSubscriptionsCallable(const ListSubscriptionsRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ListSubscriptions, request);
        }
 
        template<typename ListSubscriptionsRequestT = Model::ListSubscriptionsRequest>
        void ListSubscriptionsAsync(const ListSubscriptionsRequestT& request, const ListSubscriptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ListSubscriptions, 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(&QBusinessClient::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(&QBusinessClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListWebExperiencesOutcome ListWebExperiences(const Model::ListWebExperiencesRequest& request) const;
 
        template<typename ListWebExperiencesRequestT = Model::ListWebExperiencesRequest>
        Model::ListWebExperiencesOutcomeCallable ListWebExperiencesCallable(const ListWebExperiencesRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::ListWebExperiences, request);
        }
 
        template<typename ListWebExperiencesRequestT = Model::ListWebExperiencesRequest>
        void ListWebExperiencesAsync(const ListWebExperiencesRequestT& request, const ListWebExperiencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::ListWebExperiences, request, handler, context);
        }
 
        virtual Model::PutFeedbackOutcome PutFeedback(const Model::PutFeedbackRequest& request) const;
 
        template<typename PutFeedbackRequestT = Model::PutFeedbackRequest>
        Model::PutFeedbackOutcomeCallable PutFeedbackCallable(const PutFeedbackRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::PutFeedback, request);
        }
 
        template<typename PutFeedbackRequestT = Model::PutFeedbackRequest>
        void PutFeedbackAsync(const PutFeedbackRequestT& request, const PutFeedbackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::PutFeedback, request, handler, context);
        }
 
        virtual Model::PutGroupOutcome PutGroup(const Model::PutGroupRequest& request) const;
 
        template<typename PutGroupRequestT = Model::PutGroupRequest>
        Model::PutGroupOutcomeCallable PutGroupCallable(const PutGroupRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::PutGroup, request);
        }
 
        template<typename PutGroupRequestT = Model::PutGroupRequest>
        void PutGroupAsync(const PutGroupRequestT& request, const PutGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::PutGroup, request, handler, context);
        }
 
        virtual Model::SearchRelevantContentOutcome SearchRelevantContent(const Model::SearchRelevantContentRequest& request) const;
 
        template<typename SearchRelevantContentRequestT = Model::SearchRelevantContentRequest>
        Model::SearchRelevantContentOutcomeCallable SearchRelevantContentCallable(const SearchRelevantContentRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::SearchRelevantContent, request);
        }
 
        template<typename SearchRelevantContentRequestT = Model::SearchRelevantContentRequest>
        void SearchRelevantContentAsync(const SearchRelevantContentRequestT& request, const SearchRelevantContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::SearchRelevantContent, request, handler, context);
        }
 
        virtual Model::StartDataSourceSyncJobOutcome StartDataSourceSyncJob(const Model::StartDataSourceSyncJobRequest& request) const;
 
        template<typename StartDataSourceSyncJobRequestT = Model::StartDataSourceSyncJobRequest>
        Model::StartDataSourceSyncJobOutcomeCallable StartDataSourceSyncJobCallable(const StartDataSourceSyncJobRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::StartDataSourceSyncJob, request);
        }
 
        template<typename StartDataSourceSyncJobRequestT = Model::StartDataSourceSyncJobRequest>
        void StartDataSourceSyncJobAsync(const StartDataSourceSyncJobRequestT& request, const StartDataSourceSyncJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::StartDataSourceSyncJob, request, handler, context);
        }
 
        virtual Model::StopDataSourceSyncJobOutcome StopDataSourceSyncJob(const Model::StopDataSourceSyncJobRequest& request) const;
 
        template<typename StopDataSourceSyncJobRequestT = Model::StopDataSourceSyncJobRequest>
        Model::StopDataSourceSyncJobOutcomeCallable StopDataSourceSyncJobCallable(const StopDataSourceSyncJobRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::StopDataSourceSyncJob, request);
        }
 
        template<typename StopDataSourceSyncJobRequestT = Model::StopDataSourceSyncJobRequest>
        void StopDataSourceSyncJobAsync(const StopDataSourceSyncJobRequestT& request, const StopDataSourceSyncJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::StopDataSourceSyncJob, 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(&QBusinessClient::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(&QBusinessClient::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(&QBusinessClient::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(&QBusinessClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
        template<typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
        Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::UpdateApplication, request);
        }
 
        template<typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
        void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::UpdateApplication, request, handler, context);
        }
 
        virtual Model::UpdateChatControlsConfigurationOutcome UpdateChatControlsConfiguration(const Model::UpdateChatControlsConfigurationRequest& request) const;
 
        template<typename UpdateChatControlsConfigurationRequestT = Model::UpdateChatControlsConfigurationRequest>
        Model::UpdateChatControlsConfigurationOutcomeCallable UpdateChatControlsConfigurationCallable(const UpdateChatControlsConfigurationRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::UpdateChatControlsConfiguration, request);
        }
 
        template<typename UpdateChatControlsConfigurationRequestT = Model::UpdateChatControlsConfigurationRequest>
        void UpdateChatControlsConfigurationAsync(const UpdateChatControlsConfigurationRequestT& request, const UpdateChatControlsConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::UpdateChatControlsConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateChatResponseConfigurationOutcome UpdateChatResponseConfiguration(const Model::UpdateChatResponseConfigurationRequest& request) const;
 
        template<typename UpdateChatResponseConfigurationRequestT = Model::UpdateChatResponseConfigurationRequest>
        Model::UpdateChatResponseConfigurationOutcomeCallable UpdateChatResponseConfigurationCallable(const UpdateChatResponseConfigurationRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::UpdateChatResponseConfiguration, request);
        }
 
        template<typename UpdateChatResponseConfigurationRequestT = Model::UpdateChatResponseConfigurationRequest>
        void UpdateChatResponseConfigurationAsync(const UpdateChatResponseConfigurationRequestT& request, const UpdateChatResponseConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::UpdateChatResponseConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateDataAccessorOutcome UpdateDataAccessor(const Model::UpdateDataAccessorRequest& request) const;
 
        template<typename UpdateDataAccessorRequestT = Model::UpdateDataAccessorRequest>
        Model::UpdateDataAccessorOutcomeCallable UpdateDataAccessorCallable(const UpdateDataAccessorRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::UpdateDataAccessor, request);
        }
 
        template<typename UpdateDataAccessorRequestT = Model::UpdateDataAccessorRequest>
        void UpdateDataAccessorAsync(const UpdateDataAccessorRequestT& request, const UpdateDataAccessorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::UpdateDataAccessor, 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(&QBusinessClient::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(&QBusinessClient::UpdateDataSource, request, handler, context);
        }
 
        virtual Model::UpdateIndexOutcome UpdateIndex(const Model::UpdateIndexRequest& request) const;
 
        template<typename UpdateIndexRequestT = Model::UpdateIndexRequest>
        Model::UpdateIndexOutcomeCallable UpdateIndexCallable(const UpdateIndexRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::UpdateIndex, request);
        }
 
        template<typename UpdateIndexRequestT = Model::UpdateIndexRequest>
        void UpdateIndexAsync(const UpdateIndexRequestT& request, const UpdateIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::UpdateIndex, request, handler, context);
        }
 
        virtual Model::UpdatePluginOutcome UpdatePlugin(const Model::UpdatePluginRequest& request) const;
 
        template<typename UpdatePluginRequestT = Model::UpdatePluginRequest>
        Model::UpdatePluginOutcomeCallable UpdatePluginCallable(const UpdatePluginRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::UpdatePlugin, request);
        }
 
        template<typename UpdatePluginRequestT = Model::UpdatePluginRequest>
        void UpdatePluginAsync(const UpdatePluginRequestT& request, const UpdatePluginResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::UpdatePlugin, request, handler, context);
        }
 
        virtual Model::UpdateRetrieverOutcome UpdateRetriever(const Model::UpdateRetrieverRequest& request) const;
 
        template<typename UpdateRetrieverRequestT = Model::UpdateRetrieverRequest>
        Model::UpdateRetrieverOutcomeCallable UpdateRetrieverCallable(const UpdateRetrieverRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::UpdateRetriever, request);
        }
 
        template<typename UpdateRetrieverRequestT = Model::UpdateRetrieverRequest>
        void UpdateRetrieverAsync(const UpdateRetrieverRequestT& request, const UpdateRetrieverResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::UpdateRetriever, request, handler, context);
        }
 
        virtual Model::UpdateSubscriptionOutcome UpdateSubscription(const Model::UpdateSubscriptionRequest& request) const;
 
        template<typename UpdateSubscriptionRequestT = Model::UpdateSubscriptionRequest>
        Model::UpdateSubscriptionOutcomeCallable UpdateSubscriptionCallable(const UpdateSubscriptionRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::UpdateSubscription, request);
        }
 
        template<typename UpdateSubscriptionRequestT = Model::UpdateSubscriptionRequest>
        void UpdateSubscriptionAsync(const UpdateSubscriptionRequestT& request, const UpdateSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::UpdateSubscription, 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(&QBusinessClient::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(&QBusinessClient::UpdateUser, request, handler, context);
        }
 
        virtual Model::UpdateWebExperienceOutcome UpdateWebExperience(const Model::UpdateWebExperienceRequest& request) const;
 
        template<typename UpdateWebExperienceRequestT = Model::UpdateWebExperienceRequest>
        Model::UpdateWebExperienceOutcomeCallable UpdateWebExperienceCallable(const UpdateWebExperienceRequestT& request) const
        {
            return SubmitCallable(&QBusinessClient::UpdateWebExperience, request);
        }
 
        template<typename UpdateWebExperienceRequestT = Model::UpdateWebExperienceRequest>
        void UpdateWebExperienceAsync(const UpdateWebExperienceRequestT& request, const UpdateWebExperienceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QBusinessClient::UpdateWebExperience, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<QBusinessEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<QBusinessClient>;
      void init(const QBusinessClientConfiguration& clientConfiguration);
 
      QBusinessClientConfiguration m_clientConfiguration;
      std::shared_ptr<QBusinessEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace QBusiness
} // namespace Aws