KendraClient.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/kendra/KendraServiceClientModel.h>
#include <aws/kendra/Kendra_EXPORTS.h>
 
namespace Aws {
namespace kendra {
class AWS_KENDRA_API KendraClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<KendraClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef KendraClientConfiguration ClientConfigurationType;
  typedef KendraEndpointProvider EndpointProviderType;
 
  KendraClient(const Aws::kendra::KendraClientConfiguration& clientConfiguration = Aws::kendra::KendraClientConfiguration(),
               std::shared_ptr<KendraEndpointProviderBase> endpointProvider = nullptr);
 
  KendraClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<KendraEndpointProviderBase> endpointProvider = nullptr,
               const Aws::kendra::KendraClientConfiguration& clientConfiguration = Aws::kendra::KendraClientConfiguration());
 
  KendraClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
               std::shared_ptr<KendraEndpointProviderBase> endpointProvider = nullptr,
               const Aws::kendra::KendraClientConfiguration& clientConfiguration = Aws::kendra::KendraClientConfiguration());
 
  /* Legacy constructors due deprecation */
  KendraClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KendraClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KendraClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
               const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~KendraClient();
 
  virtual Model::AssociateEntitiesToExperienceOutcome AssociateEntitiesToExperience(
      const Model::AssociateEntitiesToExperienceRequest& request) const;
 
  template <typename AssociateEntitiesToExperienceRequestT = Model::AssociateEntitiesToExperienceRequest>
  Model::AssociateEntitiesToExperienceOutcomeCallable AssociateEntitiesToExperienceCallable(
      const AssociateEntitiesToExperienceRequestT& request) const {
    return SubmitCallable(&KendraClient::AssociateEntitiesToExperience, request);
  }
 
  template <typename AssociateEntitiesToExperienceRequestT = Model::AssociateEntitiesToExperienceRequest>
  void AssociateEntitiesToExperienceAsync(const AssociateEntitiesToExperienceRequestT& request,
                                          const AssociateEntitiesToExperienceResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::AssociateEntitiesToExperience, request, handler, context);
  }
 
  virtual Model::AssociatePersonasToEntitiesOutcome AssociatePersonasToEntities(
      const Model::AssociatePersonasToEntitiesRequest& request) const;
 
  template <typename AssociatePersonasToEntitiesRequestT = Model::AssociatePersonasToEntitiesRequest>
  Model::AssociatePersonasToEntitiesOutcomeCallable AssociatePersonasToEntitiesCallable(
      const AssociatePersonasToEntitiesRequestT& request) const {
    return SubmitCallable(&KendraClient::AssociatePersonasToEntities, request);
  }
 
  template <typename AssociatePersonasToEntitiesRequestT = Model::AssociatePersonasToEntitiesRequest>
  void AssociatePersonasToEntitiesAsync(const AssociatePersonasToEntitiesRequestT& request,
                                        const AssociatePersonasToEntitiesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::AssociatePersonasToEntities, 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(&KendraClient::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(&KendraClient::BatchDeleteDocument, request, handler, context);
  }
 
  virtual Model::BatchDeleteFeaturedResultsSetOutcome BatchDeleteFeaturedResultsSet(
      const Model::BatchDeleteFeaturedResultsSetRequest& request) const;
 
  template <typename BatchDeleteFeaturedResultsSetRequestT = Model::BatchDeleteFeaturedResultsSetRequest>
  Model::BatchDeleteFeaturedResultsSetOutcomeCallable BatchDeleteFeaturedResultsSetCallable(
      const BatchDeleteFeaturedResultsSetRequestT& request) const {
    return SubmitCallable(&KendraClient::BatchDeleteFeaturedResultsSet, request);
  }
 
  template <typename BatchDeleteFeaturedResultsSetRequestT = Model::BatchDeleteFeaturedResultsSetRequest>
  void BatchDeleteFeaturedResultsSetAsync(const BatchDeleteFeaturedResultsSetRequestT& request,
                                          const BatchDeleteFeaturedResultsSetResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::BatchDeleteFeaturedResultsSet, request, handler, context);
  }
 
  virtual Model::BatchGetDocumentStatusOutcome BatchGetDocumentStatus(const Model::BatchGetDocumentStatusRequest& request) const;
 
  template <typename BatchGetDocumentStatusRequestT = Model::BatchGetDocumentStatusRequest>
  Model::BatchGetDocumentStatusOutcomeCallable BatchGetDocumentStatusCallable(const BatchGetDocumentStatusRequestT& request) const {
    return SubmitCallable(&KendraClient::BatchGetDocumentStatus, request);
  }
 
  template <typename BatchGetDocumentStatusRequestT = Model::BatchGetDocumentStatusRequest>
  void BatchGetDocumentStatusAsync(const BatchGetDocumentStatusRequestT& request,
                                   const BatchGetDocumentStatusResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::BatchGetDocumentStatus, 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(&KendraClient::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(&KendraClient::BatchPutDocument, request, handler, context);
  }
 
  virtual Model::ClearQuerySuggestionsOutcome ClearQuerySuggestions(const Model::ClearQuerySuggestionsRequest& request) const;
 
  template <typename ClearQuerySuggestionsRequestT = Model::ClearQuerySuggestionsRequest>
  Model::ClearQuerySuggestionsOutcomeCallable ClearQuerySuggestionsCallable(const ClearQuerySuggestionsRequestT& request) const {
    return SubmitCallable(&KendraClient::ClearQuerySuggestions, request);
  }
 
  template <typename ClearQuerySuggestionsRequestT = Model::ClearQuerySuggestionsRequest>
  void ClearQuerySuggestionsAsync(const ClearQuerySuggestionsRequestT& request, const ClearQuerySuggestionsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::ClearQuerySuggestions, request, handler, context);
  }
 
  virtual Model::CreateAccessControlConfigurationOutcome CreateAccessControlConfiguration(
      const Model::CreateAccessControlConfigurationRequest& request) const;
 
  template <typename CreateAccessControlConfigurationRequestT = Model::CreateAccessControlConfigurationRequest>
  Model::CreateAccessControlConfigurationOutcomeCallable CreateAccessControlConfigurationCallable(
      const CreateAccessControlConfigurationRequestT& request) const {
    return SubmitCallable(&KendraClient::CreateAccessControlConfiguration, request);
  }
 
  template <typename CreateAccessControlConfigurationRequestT = Model::CreateAccessControlConfigurationRequest>
  void CreateAccessControlConfigurationAsync(const CreateAccessControlConfigurationRequestT& request,
                                             const CreateAccessControlConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::CreateAccessControlConfiguration, 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(&KendraClient::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(&KendraClient::CreateDataSource, request, handler, context);
  }
 
  virtual Model::CreateExperienceOutcome CreateExperience(const Model::CreateExperienceRequest& request) const;
 
  template <typename CreateExperienceRequestT = Model::CreateExperienceRequest>
  Model::CreateExperienceOutcomeCallable CreateExperienceCallable(const CreateExperienceRequestT& request) const {
    return SubmitCallable(&KendraClient::CreateExperience, request);
  }
 
  template <typename CreateExperienceRequestT = Model::CreateExperienceRequest>
  void CreateExperienceAsync(const CreateExperienceRequestT& request, const CreateExperienceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::CreateExperience, request, handler, context);
  }
 
  virtual Model::CreateFaqOutcome CreateFaq(const Model::CreateFaqRequest& request) const;
 
  template <typename CreateFaqRequestT = Model::CreateFaqRequest>
  Model::CreateFaqOutcomeCallable CreateFaqCallable(const CreateFaqRequestT& request) const {
    return SubmitCallable(&KendraClient::CreateFaq, request);
  }
 
  template <typename CreateFaqRequestT = Model::CreateFaqRequest>
  void CreateFaqAsync(const CreateFaqRequestT& request, const CreateFaqResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::CreateFaq, request, handler, context);
  }
 
  virtual Model::CreateFeaturedResultsSetOutcome CreateFeaturedResultsSet(const Model::CreateFeaturedResultsSetRequest& request) const;
 
  template <typename CreateFeaturedResultsSetRequestT = Model::CreateFeaturedResultsSetRequest>
  Model::CreateFeaturedResultsSetOutcomeCallable CreateFeaturedResultsSetCallable(const CreateFeaturedResultsSetRequestT& request) const {
    return SubmitCallable(&KendraClient::CreateFeaturedResultsSet, request);
  }
 
  template <typename CreateFeaturedResultsSetRequestT = Model::CreateFeaturedResultsSetRequest>
  void CreateFeaturedResultsSetAsync(const CreateFeaturedResultsSetRequestT& request,
                                     const CreateFeaturedResultsSetResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::CreateFeaturedResultsSet, 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(&KendraClient::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(&KendraClient::CreateIndex, request, handler, context);
  }
 
  virtual Model::CreateQuerySuggestionsBlockListOutcome CreateQuerySuggestionsBlockList(
      const Model::CreateQuerySuggestionsBlockListRequest& request) const;
 
  template <typename CreateQuerySuggestionsBlockListRequestT = Model::CreateQuerySuggestionsBlockListRequest>
  Model::CreateQuerySuggestionsBlockListOutcomeCallable CreateQuerySuggestionsBlockListCallable(
      const CreateQuerySuggestionsBlockListRequestT& request) const {
    return SubmitCallable(&KendraClient::CreateQuerySuggestionsBlockList, request);
  }
 
  template <typename CreateQuerySuggestionsBlockListRequestT = Model::CreateQuerySuggestionsBlockListRequest>
  void CreateQuerySuggestionsBlockListAsync(const CreateQuerySuggestionsBlockListRequestT& request,
                                            const CreateQuerySuggestionsBlockListResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::CreateQuerySuggestionsBlockList, request, handler, context);
  }
 
  virtual Model::CreateThesaurusOutcome CreateThesaurus(const Model::CreateThesaurusRequest& request) const;
 
  template <typename CreateThesaurusRequestT = Model::CreateThesaurusRequest>
  Model::CreateThesaurusOutcomeCallable CreateThesaurusCallable(const CreateThesaurusRequestT& request) const {
    return SubmitCallable(&KendraClient::CreateThesaurus, request);
  }
 
  template <typename CreateThesaurusRequestT = Model::CreateThesaurusRequest>
  void CreateThesaurusAsync(const CreateThesaurusRequestT& request, const CreateThesaurusResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::CreateThesaurus, request, handler, context);
  }
 
  virtual Model::DeleteAccessControlConfigurationOutcome DeleteAccessControlConfiguration(
      const Model::DeleteAccessControlConfigurationRequest& request) const;
 
  template <typename DeleteAccessControlConfigurationRequestT = Model::DeleteAccessControlConfigurationRequest>
  Model::DeleteAccessControlConfigurationOutcomeCallable DeleteAccessControlConfigurationCallable(
      const DeleteAccessControlConfigurationRequestT& request) const {
    return SubmitCallable(&KendraClient::DeleteAccessControlConfiguration, request);
  }
 
  template <typename DeleteAccessControlConfigurationRequestT = Model::DeleteAccessControlConfigurationRequest>
  void DeleteAccessControlConfigurationAsync(const DeleteAccessControlConfigurationRequestT& request,
                                             const DeleteAccessControlConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DeleteAccessControlConfiguration, 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(&KendraClient::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(&KendraClient::DeleteDataSource, request, handler, context);
  }
 
  virtual Model::DeleteExperienceOutcome DeleteExperience(const Model::DeleteExperienceRequest& request) const;
 
  template <typename DeleteExperienceRequestT = Model::DeleteExperienceRequest>
  Model::DeleteExperienceOutcomeCallable DeleteExperienceCallable(const DeleteExperienceRequestT& request) const {
    return SubmitCallable(&KendraClient::DeleteExperience, request);
  }
 
  template <typename DeleteExperienceRequestT = Model::DeleteExperienceRequest>
  void DeleteExperienceAsync(const DeleteExperienceRequestT& request, const DeleteExperienceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DeleteExperience, request, handler, context);
  }
 
  virtual Model::DeleteFaqOutcome DeleteFaq(const Model::DeleteFaqRequest& request) const;
 
  template <typename DeleteFaqRequestT = Model::DeleteFaqRequest>
  Model::DeleteFaqOutcomeCallable DeleteFaqCallable(const DeleteFaqRequestT& request) const {
    return SubmitCallable(&KendraClient::DeleteFaq, request);
  }
 
  template <typename DeleteFaqRequestT = Model::DeleteFaqRequest>
  void DeleteFaqAsync(const DeleteFaqRequestT& request, const DeleteFaqResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DeleteFaq, 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(&KendraClient::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(&KendraClient::DeleteIndex, request, handler, context);
  }
 
  virtual Model::DeletePrincipalMappingOutcome DeletePrincipalMapping(const Model::DeletePrincipalMappingRequest& request) const;
 
  template <typename DeletePrincipalMappingRequestT = Model::DeletePrincipalMappingRequest>
  Model::DeletePrincipalMappingOutcomeCallable DeletePrincipalMappingCallable(const DeletePrincipalMappingRequestT& request) const {
    return SubmitCallable(&KendraClient::DeletePrincipalMapping, request);
  }
 
  template <typename DeletePrincipalMappingRequestT = Model::DeletePrincipalMappingRequest>
  void DeletePrincipalMappingAsync(const DeletePrincipalMappingRequestT& request,
                                   const DeletePrincipalMappingResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DeletePrincipalMapping, request, handler, context);
  }
 
  virtual Model::DeleteQuerySuggestionsBlockListOutcome DeleteQuerySuggestionsBlockList(
      const Model::DeleteQuerySuggestionsBlockListRequest& request) const;
 
  template <typename DeleteQuerySuggestionsBlockListRequestT = Model::DeleteQuerySuggestionsBlockListRequest>
  Model::DeleteQuerySuggestionsBlockListOutcomeCallable DeleteQuerySuggestionsBlockListCallable(
      const DeleteQuerySuggestionsBlockListRequestT& request) const {
    return SubmitCallable(&KendraClient::DeleteQuerySuggestionsBlockList, request);
  }
 
  template <typename DeleteQuerySuggestionsBlockListRequestT = Model::DeleteQuerySuggestionsBlockListRequest>
  void DeleteQuerySuggestionsBlockListAsync(const DeleteQuerySuggestionsBlockListRequestT& request,
                                            const DeleteQuerySuggestionsBlockListResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DeleteQuerySuggestionsBlockList, request, handler, context);
  }
 
  virtual Model::DeleteThesaurusOutcome DeleteThesaurus(const Model::DeleteThesaurusRequest& request) const;
 
  template <typename DeleteThesaurusRequestT = Model::DeleteThesaurusRequest>
  Model::DeleteThesaurusOutcomeCallable DeleteThesaurusCallable(const DeleteThesaurusRequestT& request) const {
    return SubmitCallable(&KendraClient::DeleteThesaurus, request);
  }
 
  template <typename DeleteThesaurusRequestT = Model::DeleteThesaurusRequest>
  void DeleteThesaurusAsync(const DeleteThesaurusRequestT& request, const DeleteThesaurusResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DeleteThesaurus, request, handler, context);
  }
 
  virtual Model::DescribeAccessControlConfigurationOutcome DescribeAccessControlConfiguration(
      const Model::DescribeAccessControlConfigurationRequest& request) const;
 
  template <typename DescribeAccessControlConfigurationRequestT = Model::DescribeAccessControlConfigurationRequest>
  Model::DescribeAccessControlConfigurationOutcomeCallable DescribeAccessControlConfigurationCallable(
      const DescribeAccessControlConfigurationRequestT& request) const {
    return SubmitCallable(&KendraClient::DescribeAccessControlConfiguration, request);
  }
 
  template <typename DescribeAccessControlConfigurationRequestT = Model::DescribeAccessControlConfigurationRequest>
  void DescribeAccessControlConfigurationAsync(const DescribeAccessControlConfigurationRequestT& request,
                                               const DescribeAccessControlConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DescribeAccessControlConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeDataSourceOutcome DescribeDataSource(const Model::DescribeDataSourceRequest& request) const;
 
  template <typename DescribeDataSourceRequestT = Model::DescribeDataSourceRequest>
  Model::DescribeDataSourceOutcomeCallable DescribeDataSourceCallable(const DescribeDataSourceRequestT& request) const {
    return SubmitCallable(&KendraClient::DescribeDataSource, request);
  }
 
  template <typename DescribeDataSourceRequestT = Model::DescribeDataSourceRequest>
  void DescribeDataSourceAsync(const DescribeDataSourceRequestT& request, const DescribeDataSourceResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DescribeDataSource, request, handler, context);
  }
 
  virtual Model::DescribeExperienceOutcome DescribeExperience(const Model::DescribeExperienceRequest& request) const;
 
  template <typename DescribeExperienceRequestT = Model::DescribeExperienceRequest>
  Model::DescribeExperienceOutcomeCallable DescribeExperienceCallable(const DescribeExperienceRequestT& request) const {
    return SubmitCallable(&KendraClient::DescribeExperience, request);
  }
 
  template <typename DescribeExperienceRequestT = Model::DescribeExperienceRequest>
  void DescribeExperienceAsync(const DescribeExperienceRequestT& request, const DescribeExperienceResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DescribeExperience, request, handler, context);
  }
 
  virtual Model::DescribeFaqOutcome DescribeFaq(const Model::DescribeFaqRequest& request) const;
 
  template <typename DescribeFaqRequestT = Model::DescribeFaqRequest>
  Model::DescribeFaqOutcomeCallable DescribeFaqCallable(const DescribeFaqRequestT& request) const {
    return SubmitCallable(&KendraClient::DescribeFaq, request);
  }
 
  template <typename DescribeFaqRequestT = Model::DescribeFaqRequest>
  void DescribeFaqAsync(const DescribeFaqRequestT& request, const DescribeFaqResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DescribeFaq, request, handler, context);
  }
 
  virtual Model::DescribeFeaturedResultsSetOutcome DescribeFeaturedResultsSet(
      const Model::DescribeFeaturedResultsSetRequest& request) const;
 
  template <typename DescribeFeaturedResultsSetRequestT = Model::DescribeFeaturedResultsSetRequest>
  Model::DescribeFeaturedResultsSetOutcomeCallable DescribeFeaturedResultsSetCallable(
      const DescribeFeaturedResultsSetRequestT& request) const {
    return SubmitCallable(&KendraClient::DescribeFeaturedResultsSet, request);
  }
 
  template <typename DescribeFeaturedResultsSetRequestT = Model::DescribeFeaturedResultsSetRequest>
  void DescribeFeaturedResultsSetAsync(const DescribeFeaturedResultsSetRequestT& request,
                                       const DescribeFeaturedResultsSetResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DescribeFeaturedResultsSet, request, handler, context);
  }
 
  virtual Model::DescribeIndexOutcome DescribeIndex(const Model::DescribeIndexRequest& request) const;
 
  template <typename DescribeIndexRequestT = Model::DescribeIndexRequest>
  Model::DescribeIndexOutcomeCallable DescribeIndexCallable(const DescribeIndexRequestT& request) const {
    return SubmitCallable(&KendraClient::DescribeIndex, request);
  }
 
  template <typename DescribeIndexRequestT = Model::DescribeIndexRequest>
  void DescribeIndexAsync(const DescribeIndexRequestT& request, const DescribeIndexResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DescribeIndex, request, handler, context);
  }
 
  virtual Model::DescribePrincipalMappingOutcome DescribePrincipalMapping(const Model::DescribePrincipalMappingRequest& request) const;
 
  template <typename DescribePrincipalMappingRequestT = Model::DescribePrincipalMappingRequest>
  Model::DescribePrincipalMappingOutcomeCallable DescribePrincipalMappingCallable(const DescribePrincipalMappingRequestT& request) const {
    return SubmitCallable(&KendraClient::DescribePrincipalMapping, request);
  }
 
  template <typename DescribePrincipalMappingRequestT = Model::DescribePrincipalMappingRequest>
  void DescribePrincipalMappingAsync(const DescribePrincipalMappingRequestT& request,
                                     const DescribePrincipalMappingResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DescribePrincipalMapping, request, handler, context);
  }
 
  virtual Model::DescribeQuerySuggestionsBlockListOutcome DescribeQuerySuggestionsBlockList(
      const Model::DescribeQuerySuggestionsBlockListRequest& request) const;
 
  template <typename DescribeQuerySuggestionsBlockListRequestT = Model::DescribeQuerySuggestionsBlockListRequest>
  Model::DescribeQuerySuggestionsBlockListOutcomeCallable DescribeQuerySuggestionsBlockListCallable(
      const DescribeQuerySuggestionsBlockListRequestT& request) const {
    return SubmitCallable(&KendraClient::DescribeQuerySuggestionsBlockList, request);
  }
 
  template <typename DescribeQuerySuggestionsBlockListRequestT = Model::DescribeQuerySuggestionsBlockListRequest>
  void DescribeQuerySuggestionsBlockListAsync(const DescribeQuerySuggestionsBlockListRequestT& request,
                                              const DescribeQuerySuggestionsBlockListResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DescribeQuerySuggestionsBlockList, request, handler, context);
  }
 
  virtual Model::DescribeQuerySuggestionsConfigOutcome DescribeQuerySuggestionsConfig(
      const Model::DescribeQuerySuggestionsConfigRequest& request) const;
 
  template <typename DescribeQuerySuggestionsConfigRequestT = Model::DescribeQuerySuggestionsConfigRequest>
  Model::DescribeQuerySuggestionsConfigOutcomeCallable DescribeQuerySuggestionsConfigCallable(
      const DescribeQuerySuggestionsConfigRequestT& request) const {
    return SubmitCallable(&KendraClient::DescribeQuerySuggestionsConfig, request);
  }
 
  template <typename DescribeQuerySuggestionsConfigRequestT = Model::DescribeQuerySuggestionsConfigRequest>
  void DescribeQuerySuggestionsConfigAsync(const DescribeQuerySuggestionsConfigRequestT& request,
                                           const DescribeQuerySuggestionsConfigResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DescribeQuerySuggestionsConfig, request, handler, context);
  }
 
  virtual Model::DescribeThesaurusOutcome DescribeThesaurus(const Model::DescribeThesaurusRequest& request) const;
 
  template <typename DescribeThesaurusRequestT = Model::DescribeThesaurusRequest>
  Model::DescribeThesaurusOutcomeCallable DescribeThesaurusCallable(const DescribeThesaurusRequestT& request) const {
    return SubmitCallable(&KendraClient::DescribeThesaurus, request);
  }
 
  template <typename DescribeThesaurusRequestT = Model::DescribeThesaurusRequest>
  void DescribeThesaurusAsync(const DescribeThesaurusRequestT& request, const DescribeThesaurusResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DescribeThesaurus, request, handler, context);
  }
 
  virtual Model::DisassociateEntitiesFromExperienceOutcome DisassociateEntitiesFromExperience(
      const Model::DisassociateEntitiesFromExperienceRequest& request) const;
 
  template <typename DisassociateEntitiesFromExperienceRequestT = Model::DisassociateEntitiesFromExperienceRequest>
  Model::DisassociateEntitiesFromExperienceOutcomeCallable DisassociateEntitiesFromExperienceCallable(
      const DisassociateEntitiesFromExperienceRequestT& request) const {
    return SubmitCallable(&KendraClient::DisassociateEntitiesFromExperience, request);
  }
 
  template <typename DisassociateEntitiesFromExperienceRequestT = Model::DisassociateEntitiesFromExperienceRequest>
  void DisassociateEntitiesFromExperienceAsync(const DisassociateEntitiesFromExperienceRequestT& request,
                                               const DisassociateEntitiesFromExperienceResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DisassociateEntitiesFromExperience, request, handler, context);
  }
 
  virtual Model::DisassociatePersonasFromEntitiesOutcome DisassociatePersonasFromEntities(
      const Model::DisassociatePersonasFromEntitiesRequest& request) const;
 
  template <typename DisassociatePersonasFromEntitiesRequestT = Model::DisassociatePersonasFromEntitiesRequest>
  Model::DisassociatePersonasFromEntitiesOutcomeCallable DisassociatePersonasFromEntitiesCallable(
      const DisassociatePersonasFromEntitiesRequestT& request) const {
    return SubmitCallable(&KendraClient::DisassociatePersonasFromEntities, request);
  }
 
  template <typename DisassociatePersonasFromEntitiesRequestT = Model::DisassociatePersonasFromEntitiesRequest>
  void DisassociatePersonasFromEntitiesAsync(const DisassociatePersonasFromEntitiesRequestT& request,
                                             const DisassociatePersonasFromEntitiesResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::DisassociatePersonasFromEntities, request, handler, context);
  }
 
  virtual Model::GetQuerySuggestionsOutcome GetQuerySuggestions(const Model::GetQuerySuggestionsRequest& request) const;
 
  template <typename GetQuerySuggestionsRequestT = Model::GetQuerySuggestionsRequest>
  Model::GetQuerySuggestionsOutcomeCallable GetQuerySuggestionsCallable(const GetQuerySuggestionsRequestT& request) const {
    return SubmitCallable(&KendraClient::GetQuerySuggestions, request);
  }
 
  template <typename GetQuerySuggestionsRequestT = Model::GetQuerySuggestionsRequest>
  void GetQuerySuggestionsAsync(const GetQuerySuggestionsRequestT& request, const GetQuerySuggestionsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::GetQuerySuggestions, request, handler, context);
  }
 
  virtual Model::GetSnapshotsOutcome GetSnapshots(const Model::GetSnapshotsRequest& request) const;
 
  template <typename GetSnapshotsRequestT = Model::GetSnapshotsRequest>
  Model::GetSnapshotsOutcomeCallable GetSnapshotsCallable(const GetSnapshotsRequestT& request) const {
    return SubmitCallable(&KendraClient::GetSnapshots, request);
  }
 
  template <typename GetSnapshotsRequestT = Model::GetSnapshotsRequest>
  void GetSnapshotsAsync(const GetSnapshotsRequestT& request, const GetSnapshotsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::GetSnapshots, request, handler, context);
  }
 
  virtual Model::ListAccessControlConfigurationsOutcome ListAccessControlConfigurations(
      const Model::ListAccessControlConfigurationsRequest& request) const;
 
  template <typename ListAccessControlConfigurationsRequestT = Model::ListAccessControlConfigurationsRequest>
  Model::ListAccessControlConfigurationsOutcomeCallable ListAccessControlConfigurationsCallable(
      const ListAccessControlConfigurationsRequestT& request) const {
    return SubmitCallable(&KendraClient::ListAccessControlConfigurations, request);
  }
 
  template <typename ListAccessControlConfigurationsRequestT = Model::ListAccessControlConfigurationsRequest>
  void ListAccessControlConfigurationsAsync(const ListAccessControlConfigurationsRequestT& request,
                                            const ListAccessControlConfigurationsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::ListAccessControlConfigurations, 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(&KendraClient::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(&KendraClient::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(&KendraClient::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(&KendraClient::ListDataSources, request, handler, context);
  }
 
  virtual Model::ListEntityPersonasOutcome ListEntityPersonas(const Model::ListEntityPersonasRequest& request) const;
 
  template <typename ListEntityPersonasRequestT = Model::ListEntityPersonasRequest>
  Model::ListEntityPersonasOutcomeCallable ListEntityPersonasCallable(const ListEntityPersonasRequestT& request) const {
    return SubmitCallable(&KendraClient::ListEntityPersonas, request);
  }
 
  template <typename ListEntityPersonasRequestT = Model::ListEntityPersonasRequest>
  void ListEntityPersonasAsync(const ListEntityPersonasRequestT& request, const ListEntityPersonasResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::ListEntityPersonas, request, handler, context);
  }
 
  virtual Model::ListExperienceEntitiesOutcome ListExperienceEntities(const Model::ListExperienceEntitiesRequest& request) const;
 
  template <typename ListExperienceEntitiesRequestT = Model::ListExperienceEntitiesRequest>
  Model::ListExperienceEntitiesOutcomeCallable ListExperienceEntitiesCallable(const ListExperienceEntitiesRequestT& request) const {
    return SubmitCallable(&KendraClient::ListExperienceEntities, request);
  }
 
  template <typename ListExperienceEntitiesRequestT = Model::ListExperienceEntitiesRequest>
  void ListExperienceEntitiesAsync(const ListExperienceEntitiesRequestT& request,
                                   const ListExperienceEntitiesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::ListExperienceEntities, request, handler, context);
  }
 
  virtual Model::ListExperiencesOutcome ListExperiences(const Model::ListExperiencesRequest& request) const;
 
  template <typename ListExperiencesRequestT = Model::ListExperiencesRequest>
  Model::ListExperiencesOutcomeCallable ListExperiencesCallable(const ListExperiencesRequestT& request) const {
    return SubmitCallable(&KendraClient::ListExperiences, request);
  }
 
  template <typename ListExperiencesRequestT = Model::ListExperiencesRequest>
  void ListExperiencesAsync(const ListExperiencesRequestT& request, const ListExperiencesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::ListExperiences, request, handler, context);
  }
 
  virtual Model::ListFaqsOutcome ListFaqs(const Model::ListFaqsRequest& request) const;
 
  template <typename ListFaqsRequestT = Model::ListFaqsRequest>
  Model::ListFaqsOutcomeCallable ListFaqsCallable(const ListFaqsRequestT& request) const {
    return SubmitCallable(&KendraClient::ListFaqs, request);
  }
 
  template <typename ListFaqsRequestT = Model::ListFaqsRequest>
  void ListFaqsAsync(const ListFaqsRequestT& request, const ListFaqsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::ListFaqs, request, handler, context);
  }
 
  virtual Model::ListFeaturedResultsSetsOutcome ListFeaturedResultsSets(const Model::ListFeaturedResultsSetsRequest& request) const;
 
  template <typename ListFeaturedResultsSetsRequestT = Model::ListFeaturedResultsSetsRequest>
  Model::ListFeaturedResultsSetsOutcomeCallable ListFeaturedResultsSetsCallable(const ListFeaturedResultsSetsRequestT& request) const {
    return SubmitCallable(&KendraClient::ListFeaturedResultsSets, request);
  }
 
  template <typename ListFeaturedResultsSetsRequestT = Model::ListFeaturedResultsSetsRequest>
  void ListFeaturedResultsSetsAsync(const ListFeaturedResultsSetsRequestT& request,
                                    const ListFeaturedResultsSetsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::ListFeaturedResultsSets, request, handler, context);
  }
 
  virtual Model::ListGroupsOlderThanOrderingIdOutcome ListGroupsOlderThanOrderingId(
      const Model::ListGroupsOlderThanOrderingIdRequest& request) const;
 
  template <typename ListGroupsOlderThanOrderingIdRequestT = Model::ListGroupsOlderThanOrderingIdRequest>
  Model::ListGroupsOlderThanOrderingIdOutcomeCallable ListGroupsOlderThanOrderingIdCallable(
      const ListGroupsOlderThanOrderingIdRequestT& request) const {
    return SubmitCallable(&KendraClient::ListGroupsOlderThanOrderingId, request);
  }
 
  template <typename ListGroupsOlderThanOrderingIdRequestT = Model::ListGroupsOlderThanOrderingIdRequest>
  void ListGroupsOlderThanOrderingIdAsync(const ListGroupsOlderThanOrderingIdRequestT& request,
                                          const ListGroupsOlderThanOrderingIdResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::ListGroupsOlderThanOrderingId, 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(&KendraClient::ListIndices, request);
  }
 
  template <typename ListIndicesRequestT = Model::ListIndicesRequest>
  void ListIndicesAsync(const ListIndicesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListIndicesRequestT& request = {}) const {
    return SubmitAsync(&KendraClient::ListIndices, request, handler, context);
  }
 
  virtual Model::ListQuerySuggestionsBlockListsOutcome ListQuerySuggestionsBlockLists(
      const Model::ListQuerySuggestionsBlockListsRequest& request) const;
 
  template <typename ListQuerySuggestionsBlockListsRequestT = Model::ListQuerySuggestionsBlockListsRequest>
  Model::ListQuerySuggestionsBlockListsOutcomeCallable ListQuerySuggestionsBlockListsCallable(
      const ListQuerySuggestionsBlockListsRequestT& request) const {
    return SubmitCallable(&KendraClient::ListQuerySuggestionsBlockLists, request);
  }
 
  template <typename ListQuerySuggestionsBlockListsRequestT = Model::ListQuerySuggestionsBlockListsRequest>
  void ListQuerySuggestionsBlockListsAsync(const ListQuerySuggestionsBlockListsRequestT& request,
                                           const ListQuerySuggestionsBlockListsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::ListQuerySuggestionsBlockLists, 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(&KendraClient::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(&KendraClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListThesauriOutcome ListThesauri(const Model::ListThesauriRequest& request) const;
 
  template <typename ListThesauriRequestT = Model::ListThesauriRequest>
  Model::ListThesauriOutcomeCallable ListThesauriCallable(const ListThesauriRequestT& request) const {
    return SubmitCallable(&KendraClient::ListThesauri, request);
  }
 
  template <typename ListThesauriRequestT = Model::ListThesauriRequest>
  void ListThesauriAsync(const ListThesauriRequestT& request, const ListThesauriResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::ListThesauri, request, handler, context);
  }
 
  virtual Model::PutPrincipalMappingOutcome PutPrincipalMapping(const Model::PutPrincipalMappingRequest& request) const;
 
  template <typename PutPrincipalMappingRequestT = Model::PutPrincipalMappingRequest>
  Model::PutPrincipalMappingOutcomeCallable PutPrincipalMappingCallable(const PutPrincipalMappingRequestT& request) const {
    return SubmitCallable(&KendraClient::PutPrincipalMapping, request);
  }
 
  template <typename PutPrincipalMappingRequestT = Model::PutPrincipalMappingRequest>
  void PutPrincipalMappingAsync(const PutPrincipalMappingRequestT& request, const PutPrincipalMappingResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::PutPrincipalMapping, request, handler, context);
  }
 
  virtual Model::QueryOutcome Query(const Model::QueryRequest& request) const;
 
  template <typename QueryRequestT = Model::QueryRequest>
  Model::QueryOutcomeCallable QueryCallable(const QueryRequestT& request) const {
    return SubmitCallable(&KendraClient::Query, request);
  }
 
  template <typename QueryRequestT = Model::QueryRequest>
  void QueryAsync(const QueryRequestT& request, const QueryResponseReceivedHandler& handler,
                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::Query, request, handler, context);
  }
 
  virtual Model::RetrieveOutcome Retrieve(const Model::RetrieveRequest& request) const;
 
  template <typename RetrieveRequestT = Model::RetrieveRequest>
  Model::RetrieveOutcomeCallable RetrieveCallable(const RetrieveRequestT& request) const {
    return SubmitCallable(&KendraClient::Retrieve, request);
  }
 
  template <typename RetrieveRequestT = Model::RetrieveRequest>
  void RetrieveAsync(const RetrieveRequestT& request, const RetrieveResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::Retrieve, 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(&KendraClient::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(&KendraClient::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(&KendraClient::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(&KendraClient::StopDataSourceSyncJob, request, handler, context);
  }
 
  virtual Model::SubmitFeedbackOutcome SubmitFeedback(const Model::SubmitFeedbackRequest& request) const;
 
  template <typename SubmitFeedbackRequestT = Model::SubmitFeedbackRequest>
  Model::SubmitFeedbackOutcomeCallable SubmitFeedbackCallable(const SubmitFeedbackRequestT& request) const {
    return SubmitCallable(&KendraClient::SubmitFeedback, request);
  }
 
  template <typename SubmitFeedbackRequestT = Model::SubmitFeedbackRequest>
  void SubmitFeedbackAsync(const SubmitFeedbackRequestT& request, const SubmitFeedbackResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::SubmitFeedback, 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(&KendraClient::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(&KendraClient::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(&KendraClient::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(&KendraClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAccessControlConfigurationOutcome UpdateAccessControlConfiguration(
      const Model::UpdateAccessControlConfigurationRequest& request) const;
 
  template <typename UpdateAccessControlConfigurationRequestT = Model::UpdateAccessControlConfigurationRequest>
  Model::UpdateAccessControlConfigurationOutcomeCallable UpdateAccessControlConfigurationCallable(
      const UpdateAccessControlConfigurationRequestT& request) const {
    return SubmitCallable(&KendraClient::UpdateAccessControlConfiguration, request);
  }
 
  template <typename UpdateAccessControlConfigurationRequestT = Model::UpdateAccessControlConfigurationRequest>
  void UpdateAccessControlConfigurationAsync(const UpdateAccessControlConfigurationRequestT& request,
                                             const UpdateAccessControlConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::UpdateAccessControlConfiguration, 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(&KendraClient::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(&KendraClient::UpdateDataSource, request, handler, context);
  }
 
  virtual Model::UpdateExperienceOutcome UpdateExperience(const Model::UpdateExperienceRequest& request) const;
 
  template <typename UpdateExperienceRequestT = Model::UpdateExperienceRequest>
  Model::UpdateExperienceOutcomeCallable UpdateExperienceCallable(const UpdateExperienceRequestT& request) const {
    return SubmitCallable(&KendraClient::UpdateExperience, request);
  }
 
  template <typename UpdateExperienceRequestT = Model::UpdateExperienceRequest>
  void UpdateExperienceAsync(const UpdateExperienceRequestT& request, const UpdateExperienceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::UpdateExperience, request, handler, context);
  }
 
  virtual Model::UpdateFeaturedResultsSetOutcome UpdateFeaturedResultsSet(const Model::UpdateFeaturedResultsSetRequest& request) const;
 
  template <typename UpdateFeaturedResultsSetRequestT = Model::UpdateFeaturedResultsSetRequest>
  Model::UpdateFeaturedResultsSetOutcomeCallable UpdateFeaturedResultsSetCallable(const UpdateFeaturedResultsSetRequestT& request) const {
    return SubmitCallable(&KendraClient::UpdateFeaturedResultsSet, request);
  }
 
  template <typename UpdateFeaturedResultsSetRequestT = Model::UpdateFeaturedResultsSetRequest>
  void UpdateFeaturedResultsSetAsync(const UpdateFeaturedResultsSetRequestT& request,
                                     const UpdateFeaturedResultsSetResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::UpdateFeaturedResultsSet, 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(&KendraClient::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(&KendraClient::UpdateIndex, request, handler, context);
  }
 
  virtual Model::UpdateQuerySuggestionsBlockListOutcome UpdateQuerySuggestionsBlockList(
      const Model::UpdateQuerySuggestionsBlockListRequest& request) const;
 
  template <typename UpdateQuerySuggestionsBlockListRequestT = Model::UpdateQuerySuggestionsBlockListRequest>
  Model::UpdateQuerySuggestionsBlockListOutcomeCallable UpdateQuerySuggestionsBlockListCallable(
      const UpdateQuerySuggestionsBlockListRequestT& request) const {
    return SubmitCallable(&KendraClient::UpdateQuerySuggestionsBlockList, request);
  }
 
  template <typename UpdateQuerySuggestionsBlockListRequestT = Model::UpdateQuerySuggestionsBlockListRequest>
  void UpdateQuerySuggestionsBlockListAsync(const UpdateQuerySuggestionsBlockListRequestT& request,
                                            const UpdateQuerySuggestionsBlockListResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::UpdateQuerySuggestionsBlockList, request, handler, context);
  }
 
  virtual Model::UpdateQuerySuggestionsConfigOutcome UpdateQuerySuggestionsConfig(
      const Model::UpdateQuerySuggestionsConfigRequest& request) const;
 
  template <typename UpdateQuerySuggestionsConfigRequestT = Model::UpdateQuerySuggestionsConfigRequest>
  Model::UpdateQuerySuggestionsConfigOutcomeCallable UpdateQuerySuggestionsConfigCallable(
      const UpdateQuerySuggestionsConfigRequestT& request) const {
    return SubmitCallable(&KendraClient::UpdateQuerySuggestionsConfig, request);
  }
 
  template <typename UpdateQuerySuggestionsConfigRequestT = Model::UpdateQuerySuggestionsConfigRequest>
  void UpdateQuerySuggestionsConfigAsync(const UpdateQuerySuggestionsConfigRequestT& request,
                                         const UpdateQuerySuggestionsConfigResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::UpdateQuerySuggestionsConfig, request, handler, context);
  }
 
  virtual Model::UpdateThesaurusOutcome UpdateThesaurus(const Model::UpdateThesaurusRequest& request) const;
 
  template <typename UpdateThesaurusRequestT = Model::UpdateThesaurusRequest>
  Model::UpdateThesaurusOutcomeCallable UpdateThesaurusCallable(const UpdateThesaurusRequestT& request) const {
    return SubmitCallable(&KendraClient::UpdateThesaurus, request);
  }
 
  template <typename UpdateThesaurusRequestT = Model::UpdateThesaurusRequest>
  void UpdateThesaurusAsync(const UpdateThesaurusRequestT& request, const UpdateThesaurusResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraClient::UpdateThesaurus, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<KendraEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<KendraClient>;
  void init(const KendraClientConfiguration& clientConfiguration);
 
  KendraClientConfiguration m_clientConfiguration;
  std::shared_ptr<KendraEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace kendra
}  // namespace Aws