QBusinessClient.h

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