KendraClient.h

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