ConnectWisdomServiceClient.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/wisdom/ConnectWisdomServicePaginationBase.h>
#include <aws/wisdom/ConnectWisdomServiceServiceClientModel.h>
#include <aws/wisdom/ConnectWisdomServiceWaiter.h>
#include <aws/wisdom/ConnectWisdomService_EXPORTS.h>
 
namespace Aws {
namespace ConnectWisdomService {
class AWS_CONNECTWISDOMSERVICE_API ConnectWisdomServiceClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<ConnectWisdomServiceClient>,
      public ConnectWisdomServicePaginationBase<ConnectWisdomServiceClient>,
      public ConnectWisdomServiceWaiter<ConnectWisdomServiceClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ConnectWisdomServiceClientConfiguration ClientConfigurationType;
  typedef ConnectWisdomServiceEndpointProvider EndpointProviderType;
 
  ConnectWisdomServiceClient(const Aws::ConnectWisdomService::ConnectWisdomServiceClientConfiguration& clientConfiguration =
                                 Aws::ConnectWisdomService::ConnectWisdomServiceClientConfiguration(),
                             std::shared_ptr<ConnectWisdomServiceEndpointProviderBase> endpointProvider = nullptr);
 
  ConnectWisdomServiceClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<ConnectWisdomServiceEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::ConnectWisdomService::ConnectWisdomServiceClientConfiguration& clientConfiguration =
                                 Aws::ConnectWisdomService::ConnectWisdomServiceClientConfiguration());
 
  ConnectWisdomServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<ConnectWisdomServiceEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::ConnectWisdomService::ConnectWisdomServiceClientConfiguration& clientConfiguration =
                                 Aws::ConnectWisdomService::ConnectWisdomServiceClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ConnectWisdomServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ConnectWisdomServiceClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ConnectWisdomServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ConnectWisdomServiceClient();
 
  virtual Model::CreateAssistantOutcome CreateAssistant(const Model::CreateAssistantRequest& request) const;
 
  template <typename CreateAssistantRequestT = Model::CreateAssistantRequest>
  Model::CreateAssistantOutcomeCallable CreateAssistantCallable(const CreateAssistantRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::CreateAssistant, request);
  }
 
  template <typename CreateAssistantRequestT = Model::CreateAssistantRequest>
  void CreateAssistantAsync(const CreateAssistantRequestT& request, const CreateAssistantResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::CreateAssistant, request, handler, context);
  }
 
  virtual Model::CreateAssistantAssociationOutcome CreateAssistantAssociation(
      const Model::CreateAssistantAssociationRequest& request) const;
 
  template <typename CreateAssistantAssociationRequestT = Model::CreateAssistantAssociationRequest>
  Model::CreateAssistantAssociationOutcomeCallable CreateAssistantAssociationCallable(
      const CreateAssistantAssociationRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::CreateAssistantAssociation, request);
  }
 
  template <typename CreateAssistantAssociationRequestT = Model::CreateAssistantAssociationRequest>
  void CreateAssistantAssociationAsync(const CreateAssistantAssociationRequestT& request,
                                       const CreateAssistantAssociationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::CreateAssistantAssociation, request, handler, context);
  }
 
  virtual Model::CreateContentOutcome CreateContent(const Model::CreateContentRequest& request) const;
 
  template <typename CreateContentRequestT = Model::CreateContentRequest>
  Model::CreateContentOutcomeCallable CreateContentCallable(const CreateContentRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::CreateContent, request);
  }
 
  template <typename CreateContentRequestT = Model::CreateContentRequest>
  void CreateContentAsync(const CreateContentRequestT& request, const CreateContentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::CreateContent, request, handler, context);
  }
 
  virtual Model::CreateKnowledgeBaseOutcome CreateKnowledgeBase(const Model::CreateKnowledgeBaseRequest& request) const;
 
  template <typename CreateKnowledgeBaseRequestT = Model::CreateKnowledgeBaseRequest>
  Model::CreateKnowledgeBaseOutcomeCallable CreateKnowledgeBaseCallable(const CreateKnowledgeBaseRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::CreateKnowledgeBase, request);
  }
 
  template <typename CreateKnowledgeBaseRequestT = Model::CreateKnowledgeBaseRequest>
  void CreateKnowledgeBaseAsync(const CreateKnowledgeBaseRequestT& request, const CreateKnowledgeBaseResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::CreateKnowledgeBase, request, handler, context);
  }
 
  virtual Model::CreateQuickResponseOutcome CreateQuickResponse(const Model::CreateQuickResponseRequest& request) const;
 
  template <typename CreateQuickResponseRequestT = Model::CreateQuickResponseRequest>
  Model::CreateQuickResponseOutcomeCallable CreateQuickResponseCallable(const CreateQuickResponseRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::CreateQuickResponse, request);
  }
 
  template <typename CreateQuickResponseRequestT = Model::CreateQuickResponseRequest>
  void CreateQuickResponseAsync(const CreateQuickResponseRequestT& request, const CreateQuickResponseResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::CreateQuickResponse, request, handler, context);
  }
 
  virtual Model::CreateSessionOutcome CreateSession(const Model::CreateSessionRequest& request) const;
 
  template <typename CreateSessionRequestT = Model::CreateSessionRequest>
  Model::CreateSessionOutcomeCallable CreateSessionCallable(const CreateSessionRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::CreateSession, request);
  }
 
  template <typename CreateSessionRequestT = Model::CreateSessionRequest>
  void CreateSessionAsync(const CreateSessionRequestT& request, const CreateSessionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::CreateSession, request, handler, context);
  }
 
  virtual Model::DeleteAssistantOutcome DeleteAssistant(const Model::DeleteAssistantRequest& request) const;
 
  template <typename DeleteAssistantRequestT = Model::DeleteAssistantRequest>
  Model::DeleteAssistantOutcomeCallable DeleteAssistantCallable(const DeleteAssistantRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::DeleteAssistant, request);
  }
 
  template <typename DeleteAssistantRequestT = Model::DeleteAssistantRequest>
  void DeleteAssistantAsync(const DeleteAssistantRequestT& request, const DeleteAssistantResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::DeleteAssistant, request, handler, context);
  }
 
  virtual Model::DeleteAssistantAssociationOutcome DeleteAssistantAssociation(
      const Model::DeleteAssistantAssociationRequest& request) const;
 
  template <typename DeleteAssistantAssociationRequestT = Model::DeleteAssistantAssociationRequest>
  Model::DeleteAssistantAssociationOutcomeCallable DeleteAssistantAssociationCallable(
      const DeleteAssistantAssociationRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::DeleteAssistantAssociation, request);
  }
 
  template <typename DeleteAssistantAssociationRequestT = Model::DeleteAssistantAssociationRequest>
  void DeleteAssistantAssociationAsync(const DeleteAssistantAssociationRequestT& request,
                                       const DeleteAssistantAssociationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::DeleteAssistantAssociation, request, handler, context);
  }
 
  virtual Model::DeleteContentOutcome DeleteContent(const Model::DeleteContentRequest& request) const;
 
  template <typename DeleteContentRequestT = Model::DeleteContentRequest>
  Model::DeleteContentOutcomeCallable DeleteContentCallable(const DeleteContentRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::DeleteContent, request);
  }
 
  template <typename DeleteContentRequestT = Model::DeleteContentRequest>
  void DeleteContentAsync(const DeleteContentRequestT& request, const DeleteContentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::DeleteContent, request, handler, context);
  }
 
  virtual Model::DeleteImportJobOutcome DeleteImportJob(const Model::DeleteImportJobRequest& request) const;
 
  template <typename DeleteImportJobRequestT = Model::DeleteImportJobRequest>
  Model::DeleteImportJobOutcomeCallable DeleteImportJobCallable(const DeleteImportJobRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::DeleteImportJob, request);
  }
 
  template <typename DeleteImportJobRequestT = Model::DeleteImportJobRequest>
  void DeleteImportJobAsync(const DeleteImportJobRequestT& request, const DeleteImportJobResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::DeleteImportJob, request, handler, context);
  }
 
  virtual Model::DeleteKnowledgeBaseOutcome DeleteKnowledgeBase(const Model::DeleteKnowledgeBaseRequest& request) const;
 
  template <typename DeleteKnowledgeBaseRequestT = Model::DeleteKnowledgeBaseRequest>
  Model::DeleteKnowledgeBaseOutcomeCallable DeleteKnowledgeBaseCallable(const DeleteKnowledgeBaseRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::DeleteKnowledgeBase, request);
  }
 
  template <typename DeleteKnowledgeBaseRequestT = Model::DeleteKnowledgeBaseRequest>
  void DeleteKnowledgeBaseAsync(const DeleteKnowledgeBaseRequestT& request, const DeleteKnowledgeBaseResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::DeleteKnowledgeBase, request, handler, context);
  }
 
  virtual Model::DeleteQuickResponseOutcome DeleteQuickResponse(const Model::DeleteQuickResponseRequest& request) const;
 
  template <typename DeleteQuickResponseRequestT = Model::DeleteQuickResponseRequest>
  Model::DeleteQuickResponseOutcomeCallable DeleteQuickResponseCallable(const DeleteQuickResponseRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::DeleteQuickResponse, request);
  }
 
  template <typename DeleteQuickResponseRequestT = Model::DeleteQuickResponseRequest>
  void DeleteQuickResponseAsync(const DeleteQuickResponseRequestT& request, const DeleteQuickResponseResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::DeleteQuickResponse, request, handler, context);
  }
 
  virtual Model::GetAssistantOutcome GetAssistant(const Model::GetAssistantRequest& request) const;
 
  template <typename GetAssistantRequestT = Model::GetAssistantRequest>
  Model::GetAssistantOutcomeCallable GetAssistantCallable(const GetAssistantRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::GetAssistant, request);
  }
 
  template <typename GetAssistantRequestT = Model::GetAssistantRequest>
  void GetAssistantAsync(const GetAssistantRequestT& request, const GetAssistantResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::GetAssistant, request, handler, context);
  }
 
  virtual Model::GetAssistantAssociationOutcome GetAssistantAssociation(const Model::GetAssistantAssociationRequest& request) const;
 
  template <typename GetAssistantAssociationRequestT = Model::GetAssistantAssociationRequest>
  Model::GetAssistantAssociationOutcomeCallable GetAssistantAssociationCallable(const GetAssistantAssociationRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::GetAssistantAssociation, request);
  }
 
  template <typename GetAssistantAssociationRequestT = Model::GetAssistantAssociationRequest>
  void GetAssistantAssociationAsync(const GetAssistantAssociationRequestT& request,
                                    const GetAssistantAssociationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::GetAssistantAssociation, request, handler, context);
  }
 
  virtual Model::GetContentOutcome GetContent(const Model::GetContentRequest& request) const;
 
  template <typename GetContentRequestT = Model::GetContentRequest>
  Model::GetContentOutcomeCallable GetContentCallable(const GetContentRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::GetContent, request);
  }
 
  template <typename GetContentRequestT = Model::GetContentRequest>
  void GetContentAsync(const GetContentRequestT& request, const GetContentResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::GetContent, request, handler, context);
  }
 
  virtual Model::GetContentSummaryOutcome GetContentSummary(const Model::GetContentSummaryRequest& request) const;
 
  template <typename GetContentSummaryRequestT = Model::GetContentSummaryRequest>
  Model::GetContentSummaryOutcomeCallable GetContentSummaryCallable(const GetContentSummaryRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::GetContentSummary, request);
  }
 
  template <typename GetContentSummaryRequestT = Model::GetContentSummaryRequest>
  void GetContentSummaryAsync(const GetContentSummaryRequestT& request, const GetContentSummaryResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::GetContentSummary, request, handler, context);
  }
 
  virtual Model::GetImportJobOutcome GetImportJob(const Model::GetImportJobRequest& request) const;
 
  template <typename GetImportJobRequestT = Model::GetImportJobRequest>
  Model::GetImportJobOutcomeCallable GetImportJobCallable(const GetImportJobRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::GetImportJob, request);
  }
 
  template <typename GetImportJobRequestT = Model::GetImportJobRequest>
  void GetImportJobAsync(const GetImportJobRequestT& request, const GetImportJobResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::GetImportJob, request, handler, context);
  }
 
  virtual Model::GetKnowledgeBaseOutcome GetKnowledgeBase(const Model::GetKnowledgeBaseRequest& request) const;
 
  template <typename GetKnowledgeBaseRequestT = Model::GetKnowledgeBaseRequest>
  Model::GetKnowledgeBaseOutcomeCallable GetKnowledgeBaseCallable(const GetKnowledgeBaseRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::GetKnowledgeBase, request);
  }
 
  template <typename GetKnowledgeBaseRequestT = Model::GetKnowledgeBaseRequest>
  void GetKnowledgeBaseAsync(const GetKnowledgeBaseRequestT& request, const GetKnowledgeBaseResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::GetKnowledgeBase, request, handler, context);
  }
 
  virtual Model::GetQuickResponseOutcome GetQuickResponse(const Model::GetQuickResponseRequest& request) const;
 
  template <typename GetQuickResponseRequestT = Model::GetQuickResponseRequest>
  Model::GetQuickResponseOutcomeCallable GetQuickResponseCallable(const GetQuickResponseRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::GetQuickResponse, request);
  }
 
  template <typename GetQuickResponseRequestT = Model::GetQuickResponseRequest>
  void GetQuickResponseAsync(const GetQuickResponseRequestT& request, const GetQuickResponseResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::GetQuickResponse, request, handler, context);
  }
 
  virtual Model::GetSessionOutcome GetSession(const Model::GetSessionRequest& request) const;
 
  template <typename GetSessionRequestT = Model::GetSessionRequest>
  Model::GetSessionOutcomeCallable GetSessionCallable(const GetSessionRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::GetSession, request);
  }
 
  template <typename GetSessionRequestT = Model::GetSessionRequest>
  void GetSessionAsync(const GetSessionRequestT& request, const GetSessionResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::GetSession, request, handler, context);
  }
 
  virtual Model::ListAssistantAssociationsOutcome ListAssistantAssociations(const Model::ListAssistantAssociationsRequest& request) const;
 
  template <typename ListAssistantAssociationsRequestT = Model::ListAssistantAssociationsRequest>
  Model::ListAssistantAssociationsOutcomeCallable ListAssistantAssociationsCallable(
      const ListAssistantAssociationsRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::ListAssistantAssociations, request);
  }
 
  template <typename ListAssistantAssociationsRequestT = Model::ListAssistantAssociationsRequest>
  void ListAssistantAssociationsAsync(const ListAssistantAssociationsRequestT& request,
                                      const ListAssistantAssociationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::ListAssistantAssociations, request, handler, context);
  }
 
  virtual Model::ListAssistantsOutcome ListAssistants(const Model::ListAssistantsRequest& request = {}) const;
 
  template <typename ListAssistantsRequestT = Model::ListAssistantsRequest>
  Model::ListAssistantsOutcomeCallable ListAssistantsCallable(const ListAssistantsRequestT& request = {}) const {
    return SubmitCallable(&ConnectWisdomServiceClient::ListAssistants, request);
  }
 
  template <typename ListAssistantsRequestT = Model::ListAssistantsRequest>
  void ListAssistantsAsync(const ListAssistantsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListAssistantsRequestT& request = {}) const {
    return SubmitAsync(&ConnectWisdomServiceClient::ListAssistants, request, handler, context);
  }
 
  virtual Model::ListContentsOutcome ListContents(const Model::ListContentsRequest& request) const;
 
  template <typename ListContentsRequestT = Model::ListContentsRequest>
  Model::ListContentsOutcomeCallable ListContentsCallable(const ListContentsRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::ListContents, request);
  }
 
  template <typename ListContentsRequestT = Model::ListContentsRequest>
  void ListContentsAsync(const ListContentsRequestT& request, const ListContentsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::ListContents, request, handler, context);
  }
 
  virtual Model::ListImportJobsOutcome ListImportJobs(const Model::ListImportJobsRequest& request) const;
 
  template <typename ListImportJobsRequestT = Model::ListImportJobsRequest>
  Model::ListImportJobsOutcomeCallable ListImportJobsCallable(const ListImportJobsRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::ListImportJobs, request);
  }
 
  template <typename ListImportJobsRequestT = Model::ListImportJobsRequest>
  void ListImportJobsAsync(const ListImportJobsRequestT& request, const ListImportJobsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::ListImportJobs, request, handler, context);
  }
 
  virtual Model::ListKnowledgeBasesOutcome ListKnowledgeBases(const Model::ListKnowledgeBasesRequest& request = {}) const;
 
  template <typename ListKnowledgeBasesRequestT = Model::ListKnowledgeBasesRequest>
  Model::ListKnowledgeBasesOutcomeCallable ListKnowledgeBasesCallable(const ListKnowledgeBasesRequestT& request = {}) const {
    return SubmitCallable(&ConnectWisdomServiceClient::ListKnowledgeBases, request);
  }
 
  template <typename ListKnowledgeBasesRequestT = Model::ListKnowledgeBasesRequest>
  void ListKnowledgeBasesAsync(const ListKnowledgeBasesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListKnowledgeBasesRequestT& request = {}) const {
    return SubmitAsync(&ConnectWisdomServiceClient::ListKnowledgeBases, request, handler, context);
  }
 
  virtual Model::ListQuickResponsesOutcome ListQuickResponses(const Model::ListQuickResponsesRequest& request) const;
 
  template <typename ListQuickResponsesRequestT = Model::ListQuickResponsesRequest>
  Model::ListQuickResponsesOutcomeCallable ListQuickResponsesCallable(const ListQuickResponsesRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::ListQuickResponses, request);
  }
 
  template <typename ListQuickResponsesRequestT = Model::ListQuickResponsesRequest>
  void ListQuickResponsesAsync(const ListQuickResponsesRequestT& request, const ListQuickResponsesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::ListQuickResponses, 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(&ConnectWisdomServiceClient::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(&ConnectWisdomServiceClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::NotifyRecommendationsReceivedOutcome NotifyRecommendationsReceived(
      const Model::NotifyRecommendationsReceivedRequest& request) const;
 
  template <typename NotifyRecommendationsReceivedRequestT = Model::NotifyRecommendationsReceivedRequest>
  Model::NotifyRecommendationsReceivedOutcomeCallable NotifyRecommendationsReceivedCallable(
      const NotifyRecommendationsReceivedRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::NotifyRecommendationsReceived, request);
  }
 
  template <typename NotifyRecommendationsReceivedRequestT = Model::NotifyRecommendationsReceivedRequest>
  void NotifyRecommendationsReceivedAsync(const NotifyRecommendationsReceivedRequestT& request,
                                          const NotifyRecommendationsReceivedResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::NotifyRecommendationsReceived, request, handler, context);
  }
 
  virtual Model::RemoveKnowledgeBaseTemplateUriOutcome RemoveKnowledgeBaseTemplateUri(
      const Model::RemoveKnowledgeBaseTemplateUriRequest& request) const;
 
  template <typename RemoveKnowledgeBaseTemplateUriRequestT = Model::RemoveKnowledgeBaseTemplateUriRequest>
  Model::RemoveKnowledgeBaseTemplateUriOutcomeCallable RemoveKnowledgeBaseTemplateUriCallable(
      const RemoveKnowledgeBaseTemplateUriRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::RemoveKnowledgeBaseTemplateUri, request);
  }
 
  template <typename RemoveKnowledgeBaseTemplateUriRequestT = Model::RemoveKnowledgeBaseTemplateUriRequest>
  void RemoveKnowledgeBaseTemplateUriAsync(const RemoveKnowledgeBaseTemplateUriRequestT& request,
                                           const RemoveKnowledgeBaseTemplateUriResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::RemoveKnowledgeBaseTemplateUri, request, handler, context);
  }
 
  virtual Model::SearchContentOutcome SearchContent(const Model::SearchContentRequest& request) const;
 
  template <typename SearchContentRequestT = Model::SearchContentRequest>
  Model::SearchContentOutcomeCallable SearchContentCallable(const SearchContentRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::SearchContent, request);
  }
 
  template <typename SearchContentRequestT = Model::SearchContentRequest>
  void SearchContentAsync(const SearchContentRequestT& request, const SearchContentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::SearchContent, request, handler, context);
  }
 
  virtual Model::SearchQuickResponsesOutcome SearchQuickResponses(const Model::SearchQuickResponsesRequest& request) const;
 
  template <typename SearchQuickResponsesRequestT = Model::SearchQuickResponsesRequest>
  Model::SearchQuickResponsesOutcomeCallable SearchQuickResponsesCallable(const SearchQuickResponsesRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::SearchQuickResponses, request);
  }
 
  template <typename SearchQuickResponsesRequestT = Model::SearchQuickResponsesRequest>
  void SearchQuickResponsesAsync(const SearchQuickResponsesRequestT& request, const SearchQuickResponsesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::SearchQuickResponses, request, handler, context);
  }
 
  virtual Model::SearchSessionsOutcome SearchSessions(const Model::SearchSessionsRequest& request) const;
 
  template <typename SearchSessionsRequestT = Model::SearchSessionsRequest>
  Model::SearchSessionsOutcomeCallable SearchSessionsCallable(const SearchSessionsRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::SearchSessions, request);
  }
 
  template <typename SearchSessionsRequestT = Model::SearchSessionsRequest>
  void SearchSessionsAsync(const SearchSessionsRequestT& request, const SearchSessionsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::SearchSessions, request, handler, context);
  }
 
  virtual Model::StartContentUploadOutcome StartContentUpload(const Model::StartContentUploadRequest& request) const;
 
  template <typename StartContentUploadRequestT = Model::StartContentUploadRequest>
  Model::StartContentUploadOutcomeCallable StartContentUploadCallable(const StartContentUploadRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::StartContentUpload, request);
  }
 
  template <typename StartContentUploadRequestT = Model::StartContentUploadRequest>
  void StartContentUploadAsync(const StartContentUploadRequestT& request, const StartContentUploadResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::StartContentUpload, request, handler, context);
  }
 
  virtual Model::StartImportJobOutcome StartImportJob(const Model::StartImportJobRequest& request) const;
 
  template <typename StartImportJobRequestT = Model::StartImportJobRequest>
  Model::StartImportJobOutcomeCallable StartImportJobCallable(const StartImportJobRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::StartImportJob, request);
  }
 
  template <typename StartImportJobRequestT = Model::StartImportJobRequest>
  void StartImportJobAsync(const StartImportJobRequestT& request, const StartImportJobResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::StartImportJob, 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(&ConnectWisdomServiceClient::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(&ConnectWisdomServiceClient::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(&ConnectWisdomServiceClient::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(&ConnectWisdomServiceClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateContentOutcome UpdateContent(const Model::UpdateContentRequest& request) const;
 
  template <typename UpdateContentRequestT = Model::UpdateContentRequest>
  Model::UpdateContentOutcomeCallable UpdateContentCallable(const UpdateContentRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::UpdateContent, request);
  }
 
  template <typename UpdateContentRequestT = Model::UpdateContentRequest>
  void UpdateContentAsync(const UpdateContentRequestT& request, const UpdateContentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::UpdateContent, request, handler, context);
  }
 
  virtual Model::UpdateKnowledgeBaseTemplateUriOutcome UpdateKnowledgeBaseTemplateUri(
      const Model::UpdateKnowledgeBaseTemplateUriRequest& request) const;
 
  template <typename UpdateKnowledgeBaseTemplateUriRequestT = Model::UpdateKnowledgeBaseTemplateUriRequest>
  Model::UpdateKnowledgeBaseTemplateUriOutcomeCallable UpdateKnowledgeBaseTemplateUriCallable(
      const UpdateKnowledgeBaseTemplateUriRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::UpdateKnowledgeBaseTemplateUri, request);
  }
 
  template <typename UpdateKnowledgeBaseTemplateUriRequestT = Model::UpdateKnowledgeBaseTemplateUriRequest>
  void UpdateKnowledgeBaseTemplateUriAsync(const UpdateKnowledgeBaseTemplateUriRequestT& request,
                                           const UpdateKnowledgeBaseTemplateUriResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::UpdateKnowledgeBaseTemplateUri, request, handler, context);
  }
 
  virtual Model::UpdateQuickResponseOutcome UpdateQuickResponse(const Model::UpdateQuickResponseRequest& request) const;
 
  template <typename UpdateQuickResponseRequestT = Model::UpdateQuickResponseRequest>
  Model::UpdateQuickResponseOutcomeCallable UpdateQuickResponseCallable(const UpdateQuickResponseRequestT& request) const {
    return SubmitCallable(&ConnectWisdomServiceClient::UpdateQuickResponse, request);
  }
 
  template <typename UpdateQuickResponseRequestT = Model::UpdateQuickResponseRequest>
  void UpdateQuickResponseAsync(const UpdateQuickResponseRequestT& request, const UpdateQuickResponseResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectWisdomServiceClient::UpdateQuickResponse, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ConnectWisdomServiceEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ConnectWisdomServiceClient>;
  void init(const ConnectWisdomServiceClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ConnectWisdomServiceError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  ConnectWisdomServiceClientConfiguration m_clientConfiguration;
  std::shared_ptr<ConnectWisdomServiceEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ConnectWisdomService
}  // namespace Aws