KendraRankingClient.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-ranking/KendraRankingPaginationBase.h>
#include <aws/kendra-ranking/KendraRankingServiceClientModel.h>
#include <aws/kendra-ranking/KendraRankingWaiter.h>
#include <aws/kendra-ranking/KendraRanking_EXPORTS.h>
 
namespace Aws {
namespace KendraRanking {
class AWS_KENDRARANKING_API KendraRankingClient : public Aws::Client::AWSJsonClient,
                                                  public Aws::Client::ClientWithAsyncTemplateMethods<KendraRankingClient>,
                                                  public KendraRankingPaginationBase<KendraRankingClient>,
                                                  public KendraRankingWaiter<KendraRankingClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef KendraRankingClientConfiguration ClientConfigurationType;
  typedef KendraRankingEndpointProvider EndpointProviderType;
 
  KendraRankingClient(const Aws::KendraRanking::KendraRankingClientConfiguration& clientConfiguration =
                          Aws::KendraRanking::KendraRankingClientConfiguration(),
                      std::shared_ptr<KendraRankingEndpointProviderBase> endpointProvider = nullptr);
 
  KendraRankingClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<KendraRankingEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::KendraRanking::KendraRankingClientConfiguration& clientConfiguration =
                          Aws::KendraRanking::KendraRankingClientConfiguration());
 
  KendraRankingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<KendraRankingEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::KendraRanking::KendraRankingClientConfiguration& clientConfiguration =
                          Aws::KendraRanking::KendraRankingClientConfiguration());
 
  /* Legacy constructors due deprecation */
  KendraRankingClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KendraRankingClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KendraRankingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~KendraRankingClient();
 
  virtual Model::CreateRescoreExecutionPlanOutcome CreateRescoreExecutionPlan(
      const Model::CreateRescoreExecutionPlanRequest& request) const;
 
  template <typename CreateRescoreExecutionPlanRequestT = Model::CreateRescoreExecutionPlanRequest>
  Model::CreateRescoreExecutionPlanOutcomeCallable CreateRescoreExecutionPlanCallable(
      const CreateRescoreExecutionPlanRequestT& request) const {
    return SubmitCallable(&KendraRankingClient::CreateRescoreExecutionPlan, request);
  }
 
  template <typename CreateRescoreExecutionPlanRequestT = Model::CreateRescoreExecutionPlanRequest>
  void CreateRescoreExecutionPlanAsync(const CreateRescoreExecutionPlanRequestT& request,
                                       const CreateRescoreExecutionPlanResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraRankingClient::CreateRescoreExecutionPlan, request, handler, context);
  }
 
  virtual Model::DeleteRescoreExecutionPlanOutcome DeleteRescoreExecutionPlan(
      const Model::DeleteRescoreExecutionPlanRequest& request) const;
 
  template <typename DeleteRescoreExecutionPlanRequestT = Model::DeleteRescoreExecutionPlanRequest>
  Model::DeleteRescoreExecutionPlanOutcomeCallable DeleteRescoreExecutionPlanCallable(
      const DeleteRescoreExecutionPlanRequestT& request) const {
    return SubmitCallable(&KendraRankingClient::DeleteRescoreExecutionPlan, request);
  }
 
  template <typename DeleteRescoreExecutionPlanRequestT = Model::DeleteRescoreExecutionPlanRequest>
  void DeleteRescoreExecutionPlanAsync(const DeleteRescoreExecutionPlanRequestT& request,
                                       const DeleteRescoreExecutionPlanResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraRankingClient::DeleteRescoreExecutionPlan, request, handler, context);
  }
 
  virtual Model::DescribeRescoreExecutionPlanOutcome DescribeRescoreExecutionPlan(
      const Model::DescribeRescoreExecutionPlanRequest& request) const;
 
  template <typename DescribeRescoreExecutionPlanRequestT = Model::DescribeRescoreExecutionPlanRequest>
  Model::DescribeRescoreExecutionPlanOutcomeCallable DescribeRescoreExecutionPlanCallable(
      const DescribeRescoreExecutionPlanRequestT& request) const {
    return SubmitCallable(&KendraRankingClient::DescribeRescoreExecutionPlan, request);
  }
 
  template <typename DescribeRescoreExecutionPlanRequestT = Model::DescribeRescoreExecutionPlanRequest>
  void DescribeRescoreExecutionPlanAsync(const DescribeRescoreExecutionPlanRequestT& request,
                                         const DescribeRescoreExecutionPlanResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraRankingClient::DescribeRescoreExecutionPlan, request, handler, context);
  }
 
  virtual Model::ListRescoreExecutionPlansOutcome ListRescoreExecutionPlans(
      const Model::ListRescoreExecutionPlansRequest& request = {}) const;
 
  template <typename ListRescoreExecutionPlansRequestT = Model::ListRescoreExecutionPlansRequest>
  Model::ListRescoreExecutionPlansOutcomeCallable ListRescoreExecutionPlansCallable(
      const ListRescoreExecutionPlansRequestT& request = {}) const {
    return SubmitCallable(&KendraRankingClient::ListRescoreExecutionPlans, request);
  }
 
  template <typename ListRescoreExecutionPlansRequestT = Model::ListRescoreExecutionPlansRequest>
  void ListRescoreExecutionPlansAsync(const ListRescoreExecutionPlansResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListRescoreExecutionPlansRequestT& request = {}) const {
    return SubmitAsync(&KendraRankingClient::ListRescoreExecutionPlans, 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(&KendraRankingClient::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(&KendraRankingClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RescoreOutcome Rescore(const Model::RescoreRequest& request) const;
 
  template <typename RescoreRequestT = Model::RescoreRequest>
  Model::RescoreOutcomeCallable RescoreCallable(const RescoreRequestT& request) const {
    return SubmitCallable(&KendraRankingClient::Rescore, request);
  }
 
  template <typename RescoreRequestT = Model::RescoreRequest>
  void RescoreAsync(const RescoreRequestT& request, const RescoreResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraRankingClient::Rescore, 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(&KendraRankingClient::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(&KendraRankingClient::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(&KendraRankingClient::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(&KendraRankingClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateRescoreExecutionPlanOutcome UpdateRescoreExecutionPlan(
      const Model::UpdateRescoreExecutionPlanRequest& request) const;
 
  template <typename UpdateRescoreExecutionPlanRequestT = Model::UpdateRescoreExecutionPlanRequest>
  Model::UpdateRescoreExecutionPlanOutcomeCallable UpdateRescoreExecutionPlanCallable(
      const UpdateRescoreExecutionPlanRequestT& request) const {
    return SubmitCallable(&KendraRankingClient::UpdateRescoreExecutionPlan, request);
  }
 
  template <typename UpdateRescoreExecutionPlanRequestT = Model::UpdateRescoreExecutionPlanRequest>
  void UpdateRescoreExecutionPlanAsync(const UpdateRescoreExecutionPlanRequestT& request,
                                       const UpdateRescoreExecutionPlanResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KendraRankingClient::UpdateRescoreExecutionPlan, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<KendraRankingEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<KendraRankingClient>;
  void init(const KendraRankingClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, KendraRankingError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  KendraRankingClientConfiguration m_clientConfiguration;
  std::shared_ptr<KendraRankingEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace KendraRanking
}  // namespace Aws