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::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 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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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