RekognitionClient.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/rekognition/RekognitionServiceClientModel.h>
#include <aws/rekognition/Rekognition_EXPORTS.h>
 
namespace Aws {
namespace Rekognition {
class AWS_REKOGNITION_API RekognitionClient : public Aws::Client::AWSJsonClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<RekognitionClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef RekognitionClientConfiguration ClientConfigurationType;
  typedef RekognitionEndpointProvider EndpointProviderType;
 
  RekognitionClient(
      const Aws::Rekognition::RekognitionClientConfiguration& clientConfiguration = Aws::Rekognition::RekognitionClientConfiguration(),
      std::shared_ptr<RekognitionEndpointProviderBase> endpointProvider = nullptr);
 
  RekognitionClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<RekognitionEndpointProviderBase> endpointProvider = nullptr,
      const Aws::Rekognition::RekognitionClientConfiguration& clientConfiguration = Aws::Rekognition::RekognitionClientConfiguration());
 
  RekognitionClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<RekognitionEndpointProviderBase> endpointProvider = nullptr,
      const Aws::Rekognition::RekognitionClientConfiguration& clientConfiguration = Aws::Rekognition::RekognitionClientConfiguration());
 
  /* Legacy constructors due deprecation */
  RekognitionClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  RekognitionClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  RekognitionClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~RekognitionClient();
 
  virtual Model::AssociateFacesOutcome AssociateFaces(const Model::AssociateFacesRequest& request) const;
 
  template <typename AssociateFacesRequestT = Model::AssociateFacesRequest>
  Model::AssociateFacesOutcomeCallable AssociateFacesCallable(const AssociateFacesRequestT& request) const {
    return SubmitCallable(&RekognitionClient::AssociateFaces, request);
  }
 
  template <typename AssociateFacesRequestT = Model::AssociateFacesRequest>
  void AssociateFacesAsync(const AssociateFacesRequestT& request, const AssociateFacesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::AssociateFaces, request, handler, context);
  }
 
  virtual Model::CompareFacesOutcome CompareFaces(const Model::CompareFacesRequest& request) const;
 
  template <typename CompareFacesRequestT = Model::CompareFacesRequest>
  Model::CompareFacesOutcomeCallable CompareFacesCallable(const CompareFacesRequestT& request) const {
    return SubmitCallable(&RekognitionClient::CompareFaces, request);
  }
 
  template <typename CompareFacesRequestT = Model::CompareFacesRequest>
  void CompareFacesAsync(const CompareFacesRequestT& request, const CompareFacesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::CompareFaces, request, handler, context);
  }
 
  virtual Model::CopyProjectVersionOutcome CopyProjectVersion(const Model::CopyProjectVersionRequest& request) const;
 
  template <typename CopyProjectVersionRequestT = Model::CopyProjectVersionRequest>
  Model::CopyProjectVersionOutcomeCallable CopyProjectVersionCallable(const CopyProjectVersionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::CopyProjectVersion, request);
  }
 
  template <typename CopyProjectVersionRequestT = Model::CopyProjectVersionRequest>
  void CopyProjectVersionAsync(const CopyProjectVersionRequestT& request, const CopyProjectVersionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::CopyProjectVersion, request, handler, context);
  }
 
  virtual Model::CreateCollectionOutcome CreateCollection(const Model::CreateCollectionRequest& request) const;
 
  template <typename CreateCollectionRequestT = Model::CreateCollectionRequest>
  Model::CreateCollectionOutcomeCallable CreateCollectionCallable(const CreateCollectionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::CreateCollection, request);
  }
 
  template <typename CreateCollectionRequestT = Model::CreateCollectionRequest>
  void CreateCollectionAsync(const CreateCollectionRequestT& request, const CreateCollectionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::CreateCollection, request, handler, context);
  }
 
  virtual Model::CreateDatasetOutcome CreateDataset(const Model::CreateDatasetRequest& request) const;
 
  template <typename CreateDatasetRequestT = Model::CreateDatasetRequest>
  Model::CreateDatasetOutcomeCallable CreateDatasetCallable(const CreateDatasetRequestT& request) const {
    return SubmitCallable(&RekognitionClient::CreateDataset, request);
  }
 
  template <typename CreateDatasetRequestT = Model::CreateDatasetRequest>
  void CreateDatasetAsync(const CreateDatasetRequestT& request, const CreateDatasetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::CreateDataset, request, handler, context);
  }
 
  virtual Model::CreateFaceLivenessSessionOutcome CreateFaceLivenessSession(
      const Model::CreateFaceLivenessSessionRequest& request = {}) const;
 
  template <typename CreateFaceLivenessSessionRequestT = Model::CreateFaceLivenessSessionRequest>
  Model::CreateFaceLivenessSessionOutcomeCallable CreateFaceLivenessSessionCallable(
      const CreateFaceLivenessSessionRequestT& request = {}) const {
    return SubmitCallable(&RekognitionClient::CreateFaceLivenessSession, request);
  }
 
  template <typename CreateFaceLivenessSessionRequestT = Model::CreateFaceLivenessSessionRequest>
  void CreateFaceLivenessSessionAsync(const CreateFaceLivenessSessionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const CreateFaceLivenessSessionRequestT& request = {}) const {
    return SubmitAsync(&RekognitionClient::CreateFaceLivenessSession, request, handler, context);
  }
 
  virtual Model::CreateProjectOutcome CreateProject(const Model::CreateProjectRequest& request) const;
 
  template <typename CreateProjectRequestT = Model::CreateProjectRequest>
  Model::CreateProjectOutcomeCallable CreateProjectCallable(const CreateProjectRequestT& request) const {
    return SubmitCallable(&RekognitionClient::CreateProject, request);
  }
 
  template <typename CreateProjectRequestT = Model::CreateProjectRequest>
  void CreateProjectAsync(const CreateProjectRequestT& request, const CreateProjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::CreateProject, request, handler, context);
  }
 
  virtual Model::CreateProjectVersionOutcome CreateProjectVersion(const Model::CreateProjectVersionRequest& request) const;
 
  template <typename CreateProjectVersionRequestT = Model::CreateProjectVersionRequest>
  Model::CreateProjectVersionOutcomeCallable CreateProjectVersionCallable(const CreateProjectVersionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::CreateProjectVersion, request);
  }
 
  template <typename CreateProjectVersionRequestT = Model::CreateProjectVersionRequest>
  void CreateProjectVersionAsync(const CreateProjectVersionRequestT& request, const CreateProjectVersionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::CreateProjectVersion, request, handler, context);
  }
 
  virtual Model::CreateStreamProcessorOutcome CreateStreamProcessor(const Model::CreateStreamProcessorRequest& request) const;
 
  template <typename CreateStreamProcessorRequestT = Model::CreateStreamProcessorRequest>
  Model::CreateStreamProcessorOutcomeCallable CreateStreamProcessorCallable(const CreateStreamProcessorRequestT& request) const {
    return SubmitCallable(&RekognitionClient::CreateStreamProcessor, request);
  }
 
  template <typename CreateStreamProcessorRequestT = Model::CreateStreamProcessorRequest>
  void CreateStreamProcessorAsync(const CreateStreamProcessorRequestT& request, const CreateStreamProcessorResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::CreateStreamProcessor, request, handler, context);
  }
 
  virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const;
 
  template <typename CreateUserRequestT = Model::CreateUserRequest>
  Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const {
    return SubmitCallable(&RekognitionClient::CreateUser, request);
  }
 
  template <typename CreateUserRequestT = Model::CreateUserRequest>
  void CreateUserAsync(const CreateUserRequestT& request, const CreateUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::CreateUser, request, handler, context);
  }
 
  virtual Model::DeleteCollectionOutcome DeleteCollection(const Model::DeleteCollectionRequest& request) const;
 
  template <typename DeleteCollectionRequestT = Model::DeleteCollectionRequest>
  Model::DeleteCollectionOutcomeCallable DeleteCollectionCallable(const DeleteCollectionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DeleteCollection, request);
  }
 
  template <typename DeleteCollectionRequestT = Model::DeleteCollectionRequest>
  void DeleteCollectionAsync(const DeleteCollectionRequestT& request, const DeleteCollectionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DeleteCollection, request, handler, context);
  }
 
  virtual Model::DeleteDatasetOutcome DeleteDataset(const Model::DeleteDatasetRequest& request) const;
 
  template <typename DeleteDatasetRequestT = Model::DeleteDatasetRequest>
  Model::DeleteDatasetOutcomeCallable DeleteDatasetCallable(const DeleteDatasetRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DeleteDataset, request);
  }
 
  template <typename DeleteDatasetRequestT = Model::DeleteDatasetRequest>
  void DeleteDatasetAsync(const DeleteDatasetRequestT& request, const DeleteDatasetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DeleteDataset, request, handler, context);
  }
 
  virtual Model::DeleteFacesOutcome DeleteFaces(const Model::DeleteFacesRequest& request) const;
 
  template <typename DeleteFacesRequestT = Model::DeleteFacesRequest>
  Model::DeleteFacesOutcomeCallable DeleteFacesCallable(const DeleteFacesRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DeleteFaces, request);
  }
 
  template <typename DeleteFacesRequestT = Model::DeleteFacesRequest>
  void DeleteFacesAsync(const DeleteFacesRequestT& request, const DeleteFacesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DeleteFaces, request, handler, context);
  }
 
  virtual Model::DeleteProjectOutcome DeleteProject(const Model::DeleteProjectRequest& request) const;
 
  template <typename DeleteProjectRequestT = Model::DeleteProjectRequest>
  Model::DeleteProjectOutcomeCallable DeleteProjectCallable(const DeleteProjectRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DeleteProject, request);
  }
 
  template <typename DeleteProjectRequestT = Model::DeleteProjectRequest>
  void DeleteProjectAsync(const DeleteProjectRequestT& request, const DeleteProjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DeleteProject, request, handler, context);
  }
 
  virtual Model::DeleteProjectPolicyOutcome DeleteProjectPolicy(const Model::DeleteProjectPolicyRequest& request) const;
 
  template <typename DeleteProjectPolicyRequestT = Model::DeleteProjectPolicyRequest>
  Model::DeleteProjectPolicyOutcomeCallable DeleteProjectPolicyCallable(const DeleteProjectPolicyRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DeleteProjectPolicy, request);
  }
 
  template <typename DeleteProjectPolicyRequestT = Model::DeleteProjectPolicyRequest>
  void DeleteProjectPolicyAsync(const DeleteProjectPolicyRequestT& request, const DeleteProjectPolicyResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DeleteProjectPolicy, request, handler, context);
  }
 
  virtual Model::DeleteProjectVersionOutcome DeleteProjectVersion(const Model::DeleteProjectVersionRequest& request) const;
 
  template <typename DeleteProjectVersionRequestT = Model::DeleteProjectVersionRequest>
  Model::DeleteProjectVersionOutcomeCallable DeleteProjectVersionCallable(const DeleteProjectVersionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DeleteProjectVersion, request);
  }
 
  template <typename DeleteProjectVersionRequestT = Model::DeleteProjectVersionRequest>
  void DeleteProjectVersionAsync(const DeleteProjectVersionRequestT& request, const DeleteProjectVersionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DeleteProjectVersion, request, handler, context);
  }
 
  virtual Model::DeleteStreamProcessorOutcome DeleteStreamProcessor(const Model::DeleteStreamProcessorRequest& request) const;
 
  template <typename DeleteStreamProcessorRequestT = Model::DeleteStreamProcessorRequest>
  Model::DeleteStreamProcessorOutcomeCallable DeleteStreamProcessorCallable(const DeleteStreamProcessorRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DeleteStreamProcessor, request);
  }
 
  template <typename DeleteStreamProcessorRequestT = Model::DeleteStreamProcessorRequest>
  void DeleteStreamProcessorAsync(const DeleteStreamProcessorRequestT& request, const DeleteStreamProcessorResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DeleteStreamProcessor, request, handler, context);
  }
 
  virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const;
 
  template <typename DeleteUserRequestT = Model::DeleteUserRequest>
  Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DeleteUser, request);
  }
 
  template <typename DeleteUserRequestT = Model::DeleteUserRequest>
  void DeleteUserAsync(const DeleteUserRequestT& request, const DeleteUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DeleteUser, request, handler, context);
  }
 
  virtual Model::DescribeCollectionOutcome DescribeCollection(const Model::DescribeCollectionRequest& request) const;
 
  template <typename DescribeCollectionRequestT = Model::DescribeCollectionRequest>
  Model::DescribeCollectionOutcomeCallable DescribeCollectionCallable(const DescribeCollectionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DescribeCollection, request);
  }
 
  template <typename DescribeCollectionRequestT = Model::DescribeCollectionRequest>
  void DescribeCollectionAsync(const DescribeCollectionRequestT& request, const DescribeCollectionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DescribeCollection, request, handler, context);
  }
 
  virtual Model::DescribeDatasetOutcome DescribeDataset(const Model::DescribeDatasetRequest& request) const;
 
  template <typename DescribeDatasetRequestT = Model::DescribeDatasetRequest>
  Model::DescribeDatasetOutcomeCallable DescribeDatasetCallable(const DescribeDatasetRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DescribeDataset, request);
  }
 
  template <typename DescribeDatasetRequestT = Model::DescribeDatasetRequest>
  void DescribeDatasetAsync(const DescribeDatasetRequestT& request, const DescribeDatasetResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DescribeDataset, request, handler, context);
  }
 
  virtual Model::DescribeProjectVersionsOutcome DescribeProjectVersions(const Model::DescribeProjectVersionsRequest& request) const;
 
  template <typename DescribeProjectVersionsRequestT = Model::DescribeProjectVersionsRequest>
  Model::DescribeProjectVersionsOutcomeCallable DescribeProjectVersionsCallable(const DescribeProjectVersionsRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DescribeProjectVersions, request);
  }
 
  template <typename DescribeProjectVersionsRequestT = Model::DescribeProjectVersionsRequest>
  void DescribeProjectVersionsAsync(const DescribeProjectVersionsRequestT& request,
                                    const DescribeProjectVersionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DescribeProjectVersions, request, handler, context);
  }
 
  virtual Model::DescribeProjectsOutcome DescribeProjects(const Model::DescribeProjectsRequest& request = {}) const;
 
  template <typename DescribeProjectsRequestT = Model::DescribeProjectsRequest>
  Model::DescribeProjectsOutcomeCallable DescribeProjectsCallable(const DescribeProjectsRequestT& request = {}) const {
    return SubmitCallable(&RekognitionClient::DescribeProjects, request);
  }
 
  template <typename DescribeProjectsRequestT = Model::DescribeProjectsRequest>
  void DescribeProjectsAsync(const DescribeProjectsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const DescribeProjectsRequestT& request = {}) const {
    return SubmitAsync(&RekognitionClient::DescribeProjects, request, handler, context);
  }
 
  virtual Model::DescribeStreamProcessorOutcome DescribeStreamProcessor(const Model::DescribeStreamProcessorRequest& request) const;
 
  template <typename DescribeStreamProcessorRequestT = Model::DescribeStreamProcessorRequest>
  Model::DescribeStreamProcessorOutcomeCallable DescribeStreamProcessorCallable(const DescribeStreamProcessorRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DescribeStreamProcessor, request);
  }
 
  template <typename DescribeStreamProcessorRequestT = Model::DescribeStreamProcessorRequest>
  void DescribeStreamProcessorAsync(const DescribeStreamProcessorRequestT& request,
                                    const DescribeStreamProcessorResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DescribeStreamProcessor, request, handler, context);
  }
 
  virtual Model::DetectCustomLabelsOutcome DetectCustomLabels(const Model::DetectCustomLabelsRequest& request) const;
 
  template <typename DetectCustomLabelsRequestT = Model::DetectCustomLabelsRequest>
  Model::DetectCustomLabelsOutcomeCallable DetectCustomLabelsCallable(const DetectCustomLabelsRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DetectCustomLabels, request);
  }
 
  template <typename DetectCustomLabelsRequestT = Model::DetectCustomLabelsRequest>
  void DetectCustomLabelsAsync(const DetectCustomLabelsRequestT& request, const DetectCustomLabelsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DetectCustomLabels, request, handler, context);
  }
 
  virtual Model::DetectFacesOutcome DetectFaces(const Model::DetectFacesRequest& request) const;
 
  template <typename DetectFacesRequestT = Model::DetectFacesRequest>
  Model::DetectFacesOutcomeCallable DetectFacesCallable(const DetectFacesRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DetectFaces, request);
  }
 
  template <typename DetectFacesRequestT = Model::DetectFacesRequest>
  void DetectFacesAsync(const DetectFacesRequestT& request, const DetectFacesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DetectFaces, request, handler, context);
  }
 
  virtual Model::DetectLabelsOutcome DetectLabels(const Model::DetectLabelsRequest& request) const;
 
  template <typename DetectLabelsRequestT = Model::DetectLabelsRequest>
  Model::DetectLabelsOutcomeCallable DetectLabelsCallable(const DetectLabelsRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DetectLabels, request);
  }
 
  template <typename DetectLabelsRequestT = Model::DetectLabelsRequest>
  void DetectLabelsAsync(const DetectLabelsRequestT& request, const DetectLabelsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DetectLabels, request, handler, context);
  }
 
  virtual Model::DetectModerationLabelsOutcome DetectModerationLabels(const Model::DetectModerationLabelsRequest& request) const;
 
  template <typename DetectModerationLabelsRequestT = Model::DetectModerationLabelsRequest>
  Model::DetectModerationLabelsOutcomeCallable DetectModerationLabelsCallable(const DetectModerationLabelsRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DetectModerationLabels, request);
  }
 
  template <typename DetectModerationLabelsRequestT = Model::DetectModerationLabelsRequest>
  void DetectModerationLabelsAsync(const DetectModerationLabelsRequestT& request,
                                   const DetectModerationLabelsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DetectModerationLabels, request, handler, context);
  }
 
  virtual Model::DetectProtectiveEquipmentOutcome DetectProtectiveEquipment(const Model::DetectProtectiveEquipmentRequest& request) const;
 
  template <typename DetectProtectiveEquipmentRequestT = Model::DetectProtectiveEquipmentRequest>
  Model::DetectProtectiveEquipmentOutcomeCallable DetectProtectiveEquipmentCallable(
      const DetectProtectiveEquipmentRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DetectProtectiveEquipment, request);
  }
 
  template <typename DetectProtectiveEquipmentRequestT = Model::DetectProtectiveEquipmentRequest>
  void DetectProtectiveEquipmentAsync(const DetectProtectiveEquipmentRequestT& request,
                                      const DetectProtectiveEquipmentResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DetectProtectiveEquipment, request, handler, context);
  }
 
  virtual Model::DetectTextOutcome DetectText(const Model::DetectTextRequest& request) const;
 
  template <typename DetectTextRequestT = Model::DetectTextRequest>
  Model::DetectTextOutcomeCallable DetectTextCallable(const DetectTextRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DetectText, request);
  }
 
  template <typename DetectTextRequestT = Model::DetectTextRequest>
  void DetectTextAsync(const DetectTextRequestT& request, const DetectTextResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DetectText, request, handler, context);
  }
 
  virtual Model::DisassociateFacesOutcome DisassociateFaces(const Model::DisassociateFacesRequest& request) const;
 
  template <typename DisassociateFacesRequestT = Model::DisassociateFacesRequest>
  Model::DisassociateFacesOutcomeCallable DisassociateFacesCallable(const DisassociateFacesRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DisassociateFaces, request);
  }
 
  template <typename DisassociateFacesRequestT = Model::DisassociateFacesRequest>
  void DisassociateFacesAsync(const DisassociateFacesRequestT& request, const DisassociateFacesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DisassociateFaces, request, handler, context);
  }
 
  virtual Model::DistributeDatasetEntriesOutcome DistributeDatasetEntries(const Model::DistributeDatasetEntriesRequest& request) const;
 
  template <typename DistributeDatasetEntriesRequestT = Model::DistributeDatasetEntriesRequest>
  Model::DistributeDatasetEntriesOutcomeCallable DistributeDatasetEntriesCallable(const DistributeDatasetEntriesRequestT& request) const {
    return SubmitCallable(&RekognitionClient::DistributeDatasetEntries, request);
  }
 
  template <typename DistributeDatasetEntriesRequestT = Model::DistributeDatasetEntriesRequest>
  void DistributeDatasetEntriesAsync(const DistributeDatasetEntriesRequestT& request,
                                     const DistributeDatasetEntriesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::DistributeDatasetEntries, request, handler, context);
  }
 
  virtual Model::GetCelebrityInfoOutcome GetCelebrityInfo(const Model::GetCelebrityInfoRequest& request) const;
 
  template <typename GetCelebrityInfoRequestT = Model::GetCelebrityInfoRequest>
  Model::GetCelebrityInfoOutcomeCallable GetCelebrityInfoCallable(const GetCelebrityInfoRequestT& request) const {
    return SubmitCallable(&RekognitionClient::GetCelebrityInfo, request);
  }
 
  template <typename GetCelebrityInfoRequestT = Model::GetCelebrityInfoRequest>
  void GetCelebrityInfoAsync(const GetCelebrityInfoRequestT& request, const GetCelebrityInfoResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::GetCelebrityInfo, request, handler, context);
  }
 
  virtual Model::GetCelebrityRecognitionOutcome GetCelebrityRecognition(const Model::GetCelebrityRecognitionRequest& request) const;
 
  template <typename GetCelebrityRecognitionRequestT = Model::GetCelebrityRecognitionRequest>
  Model::GetCelebrityRecognitionOutcomeCallable GetCelebrityRecognitionCallable(const GetCelebrityRecognitionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::GetCelebrityRecognition, request);
  }
 
  template <typename GetCelebrityRecognitionRequestT = Model::GetCelebrityRecognitionRequest>
  void GetCelebrityRecognitionAsync(const GetCelebrityRecognitionRequestT& request,
                                    const GetCelebrityRecognitionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::GetCelebrityRecognition, request, handler, context);
  }
 
  virtual Model::GetContentModerationOutcome GetContentModeration(const Model::GetContentModerationRequest& request) const;
 
  template <typename GetContentModerationRequestT = Model::GetContentModerationRequest>
  Model::GetContentModerationOutcomeCallable GetContentModerationCallable(const GetContentModerationRequestT& request) const {
    return SubmitCallable(&RekognitionClient::GetContentModeration, request);
  }
 
  template <typename GetContentModerationRequestT = Model::GetContentModerationRequest>
  void GetContentModerationAsync(const GetContentModerationRequestT& request, const GetContentModerationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::GetContentModeration, request, handler, context);
  }
 
  virtual Model::GetFaceDetectionOutcome GetFaceDetection(const Model::GetFaceDetectionRequest& request) const;
 
  template <typename GetFaceDetectionRequestT = Model::GetFaceDetectionRequest>
  Model::GetFaceDetectionOutcomeCallable GetFaceDetectionCallable(const GetFaceDetectionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::GetFaceDetection, request);
  }
 
  template <typename GetFaceDetectionRequestT = Model::GetFaceDetectionRequest>
  void GetFaceDetectionAsync(const GetFaceDetectionRequestT& request, const GetFaceDetectionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::GetFaceDetection, request, handler, context);
  }
 
  virtual Model::GetFaceLivenessSessionResultsOutcome GetFaceLivenessSessionResults(
      const Model::GetFaceLivenessSessionResultsRequest& request) const;
 
  template <typename GetFaceLivenessSessionResultsRequestT = Model::GetFaceLivenessSessionResultsRequest>
  Model::GetFaceLivenessSessionResultsOutcomeCallable GetFaceLivenessSessionResultsCallable(
      const GetFaceLivenessSessionResultsRequestT& request) const {
    return SubmitCallable(&RekognitionClient::GetFaceLivenessSessionResults, request);
  }
 
  template <typename GetFaceLivenessSessionResultsRequestT = Model::GetFaceLivenessSessionResultsRequest>
  void GetFaceLivenessSessionResultsAsync(const GetFaceLivenessSessionResultsRequestT& request,
                                          const GetFaceLivenessSessionResultsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::GetFaceLivenessSessionResults, request, handler, context);
  }
 
  virtual Model::GetFaceSearchOutcome GetFaceSearch(const Model::GetFaceSearchRequest& request) const;
 
  template <typename GetFaceSearchRequestT = Model::GetFaceSearchRequest>
  Model::GetFaceSearchOutcomeCallable GetFaceSearchCallable(const GetFaceSearchRequestT& request) const {
    return SubmitCallable(&RekognitionClient::GetFaceSearch, request);
  }
 
  template <typename GetFaceSearchRequestT = Model::GetFaceSearchRequest>
  void GetFaceSearchAsync(const GetFaceSearchRequestT& request, const GetFaceSearchResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::GetFaceSearch, request, handler, context);
  }
 
  virtual Model::GetLabelDetectionOutcome GetLabelDetection(const Model::GetLabelDetectionRequest& request) const;
 
  template <typename GetLabelDetectionRequestT = Model::GetLabelDetectionRequest>
  Model::GetLabelDetectionOutcomeCallable GetLabelDetectionCallable(const GetLabelDetectionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::GetLabelDetection, request);
  }
 
  template <typename GetLabelDetectionRequestT = Model::GetLabelDetectionRequest>
  void GetLabelDetectionAsync(const GetLabelDetectionRequestT& request, const GetLabelDetectionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::GetLabelDetection, request, handler, context);
  }
 
  virtual Model::GetMediaAnalysisJobOutcome GetMediaAnalysisJob(const Model::GetMediaAnalysisJobRequest& request) const;
 
  template <typename GetMediaAnalysisJobRequestT = Model::GetMediaAnalysisJobRequest>
  Model::GetMediaAnalysisJobOutcomeCallable GetMediaAnalysisJobCallable(const GetMediaAnalysisJobRequestT& request) const {
    return SubmitCallable(&RekognitionClient::GetMediaAnalysisJob, request);
  }
 
  template <typename GetMediaAnalysisJobRequestT = Model::GetMediaAnalysisJobRequest>
  void GetMediaAnalysisJobAsync(const GetMediaAnalysisJobRequestT& request, const GetMediaAnalysisJobResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::GetMediaAnalysisJob, request, handler, context);
  }
 
  virtual Model::GetPersonTrackingOutcome GetPersonTracking(const Model::GetPersonTrackingRequest& request) const;
 
  template <typename GetPersonTrackingRequestT = Model::GetPersonTrackingRequest>
  Model::GetPersonTrackingOutcomeCallable GetPersonTrackingCallable(const GetPersonTrackingRequestT& request) const {
    return SubmitCallable(&RekognitionClient::GetPersonTracking, request);
  }
 
  template <typename GetPersonTrackingRequestT = Model::GetPersonTrackingRequest>
  void GetPersonTrackingAsync(const GetPersonTrackingRequestT& request, const GetPersonTrackingResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::GetPersonTracking, request, handler, context);
  }
 
  virtual Model::GetSegmentDetectionOutcome GetSegmentDetection(const Model::GetSegmentDetectionRequest& request) const;
 
  template <typename GetSegmentDetectionRequestT = Model::GetSegmentDetectionRequest>
  Model::GetSegmentDetectionOutcomeCallable GetSegmentDetectionCallable(const GetSegmentDetectionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::GetSegmentDetection, request);
  }
 
  template <typename GetSegmentDetectionRequestT = Model::GetSegmentDetectionRequest>
  void GetSegmentDetectionAsync(const GetSegmentDetectionRequestT& request, const GetSegmentDetectionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::GetSegmentDetection, request, handler, context);
  }
 
  virtual Model::GetTextDetectionOutcome GetTextDetection(const Model::GetTextDetectionRequest& request) const;
 
  template <typename GetTextDetectionRequestT = Model::GetTextDetectionRequest>
  Model::GetTextDetectionOutcomeCallable GetTextDetectionCallable(const GetTextDetectionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::GetTextDetection, request);
  }
 
  template <typename GetTextDetectionRequestT = Model::GetTextDetectionRequest>
  void GetTextDetectionAsync(const GetTextDetectionRequestT& request, const GetTextDetectionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::GetTextDetection, request, handler, context);
  }
 
  virtual Model::IndexFacesOutcome IndexFaces(const Model::IndexFacesRequest& request) const;
 
  template <typename IndexFacesRequestT = Model::IndexFacesRequest>
  Model::IndexFacesOutcomeCallable IndexFacesCallable(const IndexFacesRequestT& request) const {
    return SubmitCallable(&RekognitionClient::IndexFaces, request);
  }
 
  template <typename IndexFacesRequestT = Model::IndexFacesRequest>
  void IndexFacesAsync(const IndexFacesRequestT& request, const IndexFacesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::IndexFaces, request, handler, context);
  }
 
  virtual Model::ListCollectionsOutcome ListCollections(const Model::ListCollectionsRequest& request = {}) const;
 
  template <typename ListCollectionsRequestT = Model::ListCollectionsRequest>
  Model::ListCollectionsOutcomeCallable ListCollectionsCallable(const ListCollectionsRequestT& request = {}) const {
    return SubmitCallable(&RekognitionClient::ListCollections, request);
  }
 
  template <typename ListCollectionsRequestT = Model::ListCollectionsRequest>
  void ListCollectionsAsync(const ListCollectionsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListCollectionsRequestT& request = {}) const {
    return SubmitAsync(&RekognitionClient::ListCollections, request, handler, context);
  }
 
  virtual Model::ListDatasetEntriesOutcome ListDatasetEntries(const Model::ListDatasetEntriesRequest& request) const;
 
  template <typename ListDatasetEntriesRequestT = Model::ListDatasetEntriesRequest>
  Model::ListDatasetEntriesOutcomeCallable ListDatasetEntriesCallable(const ListDatasetEntriesRequestT& request) const {
    return SubmitCallable(&RekognitionClient::ListDatasetEntries, request);
  }
 
  template <typename ListDatasetEntriesRequestT = Model::ListDatasetEntriesRequest>
  void ListDatasetEntriesAsync(const ListDatasetEntriesRequestT& request, const ListDatasetEntriesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::ListDatasetEntries, request, handler, context);
  }
 
  virtual Model::ListDatasetLabelsOutcome ListDatasetLabels(const Model::ListDatasetLabelsRequest& request) const;
 
  template <typename ListDatasetLabelsRequestT = Model::ListDatasetLabelsRequest>
  Model::ListDatasetLabelsOutcomeCallable ListDatasetLabelsCallable(const ListDatasetLabelsRequestT& request) const {
    return SubmitCallable(&RekognitionClient::ListDatasetLabels, request);
  }
 
  template <typename ListDatasetLabelsRequestT = Model::ListDatasetLabelsRequest>
  void ListDatasetLabelsAsync(const ListDatasetLabelsRequestT& request, const ListDatasetLabelsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::ListDatasetLabels, request, handler, context);
  }
 
  virtual Model::ListFacesOutcome ListFaces(const Model::ListFacesRequest& request) const;
 
  template <typename ListFacesRequestT = Model::ListFacesRequest>
  Model::ListFacesOutcomeCallable ListFacesCallable(const ListFacesRequestT& request) const {
    return SubmitCallable(&RekognitionClient::ListFaces, request);
  }
 
  template <typename ListFacesRequestT = Model::ListFacesRequest>
  void ListFacesAsync(const ListFacesRequestT& request, const ListFacesResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::ListFaces, request, handler, context);
  }
 
  virtual Model::ListMediaAnalysisJobsOutcome ListMediaAnalysisJobs(const Model::ListMediaAnalysisJobsRequest& request = {}) const;
 
  template <typename ListMediaAnalysisJobsRequestT = Model::ListMediaAnalysisJobsRequest>
  Model::ListMediaAnalysisJobsOutcomeCallable ListMediaAnalysisJobsCallable(const ListMediaAnalysisJobsRequestT& request = {}) const {
    return SubmitCallable(&RekognitionClient::ListMediaAnalysisJobs, request);
  }
 
  template <typename ListMediaAnalysisJobsRequestT = Model::ListMediaAnalysisJobsRequest>
  void ListMediaAnalysisJobsAsync(const ListMediaAnalysisJobsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListMediaAnalysisJobsRequestT& request = {}) const {
    return SubmitAsync(&RekognitionClient::ListMediaAnalysisJobs, request, handler, context);
  }
 
  virtual Model::ListProjectPoliciesOutcome ListProjectPolicies(const Model::ListProjectPoliciesRequest& request) const;
 
  template <typename ListProjectPoliciesRequestT = Model::ListProjectPoliciesRequest>
  Model::ListProjectPoliciesOutcomeCallable ListProjectPoliciesCallable(const ListProjectPoliciesRequestT& request) const {
    return SubmitCallable(&RekognitionClient::ListProjectPolicies, request);
  }
 
  template <typename ListProjectPoliciesRequestT = Model::ListProjectPoliciesRequest>
  void ListProjectPoliciesAsync(const ListProjectPoliciesRequestT& request, const ListProjectPoliciesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::ListProjectPolicies, request, handler, context);
  }
 
  virtual Model::ListStreamProcessorsOutcome ListStreamProcessors(const Model::ListStreamProcessorsRequest& request = {}) const;
 
  template <typename ListStreamProcessorsRequestT = Model::ListStreamProcessorsRequest>
  Model::ListStreamProcessorsOutcomeCallable ListStreamProcessorsCallable(const ListStreamProcessorsRequestT& request = {}) const {
    return SubmitCallable(&RekognitionClient::ListStreamProcessors, request);
  }
 
  template <typename ListStreamProcessorsRequestT = Model::ListStreamProcessorsRequest>
  void ListStreamProcessorsAsync(const ListStreamProcessorsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListStreamProcessorsRequestT& request = {}) const {
    return SubmitAsync(&RekognitionClient::ListStreamProcessors, 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(&RekognitionClient::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(&RekognitionClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListUsersOutcome ListUsers(const Model::ListUsersRequest& request) const;
 
  template <typename ListUsersRequestT = Model::ListUsersRequest>
  Model::ListUsersOutcomeCallable ListUsersCallable(const ListUsersRequestT& request) const {
    return SubmitCallable(&RekognitionClient::ListUsers, request);
  }
 
  template <typename ListUsersRequestT = Model::ListUsersRequest>
  void ListUsersAsync(const ListUsersRequestT& request, const ListUsersResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::ListUsers, request, handler, context);
  }
 
  virtual Model::PutProjectPolicyOutcome PutProjectPolicy(const Model::PutProjectPolicyRequest& request) const;
 
  template <typename PutProjectPolicyRequestT = Model::PutProjectPolicyRequest>
  Model::PutProjectPolicyOutcomeCallable PutProjectPolicyCallable(const PutProjectPolicyRequestT& request) const {
    return SubmitCallable(&RekognitionClient::PutProjectPolicy, request);
  }
 
  template <typename PutProjectPolicyRequestT = Model::PutProjectPolicyRequest>
  void PutProjectPolicyAsync(const PutProjectPolicyRequestT& request, const PutProjectPolicyResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::PutProjectPolicy, request, handler, context);
  }
 
  virtual Model::RecognizeCelebritiesOutcome RecognizeCelebrities(const Model::RecognizeCelebritiesRequest& request) const;
 
  template <typename RecognizeCelebritiesRequestT = Model::RecognizeCelebritiesRequest>
  Model::RecognizeCelebritiesOutcomeCallable RecognizeCelebritiesCallable(const RecognizeCelebritiesRequestT& request) const {
    return SubmitCallable(&RekognitionClient::RecognizeCelebrities, request);
  }
 
  template <typename RecognizeCelebritiesRequestT = Model::RecognizeCelebritiesRequest>
  void RecognizeCelebritiesAsync(const RecognizeCelebritiesRequestT& request, const RecognizeCelebritiesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::RecognizeCelebrities, request, handler, context);
  }
 
  virtual Model::SearchFacesOutcome SearchFaces(const Model::SearchFacesRequest& request) const;
 
  template <typename SearchFacesRequestT = Model::SearchFacesRequest>
  Model::SearchFacesOutcomeCallable SearchFacesCallable(const SearchFacesRequestT& request) const {
    return SubmitCallable(&RekognitionClient::SearchFaces, request);
  }
 
  template <typename SearchFacesRequestT = Model::SearchFacesRequest>
  void SearchFacesAsync(const SearchFacesRequestT& request, const SearchFacesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::SearchFaces, request, handler, context);
  }
 
  virtual Model::SearchFacesByImageOutcome SearchFacesByImage(const Model::SearchFacesByImageRequest& request) const;
 
  template <typename SearchFacesByImageRequestT = Model::SearchFacesByImageRequest>
  Model::SearchFacesByImageOutcomeCallable SearchFacesByImageCallable(const SearchFacesByImageRequestT& request) const {
    return SubmitCallable(&RekognitionClient::SearchFacesByImage, request);
  }
 
  template <typename SearchFacesByImageRequestT = Model::SearchFacesByImageRequest>
  void SearchFacesByImageAsync(const SearchFacesByImageRequestT& request, const SearchFacesByImageResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::SearchFacesByImage, request, handler, context);
  }
 
  virtual Model::SearchUsersOutcome SearchUsers(const Model::SearchUsersRequest& request) const;
 
  template <typename SearchUsersRequestT = Model::SearchUsersRequest>
  Model::SearchUsersOutcomeCallable SearchUsersCallable(const SearchUsersRequestT& request) const {
    return SubmitCallable(&RekognitionClient::SearchUsers, request);
  }
 
  template <typename SearchUsersRequestT = Model::SearchUsersRequest>
  void SearchUsersAsync(const SearchUsersRequestT& request, const SearchUsersResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::SearchUsers, request, handler, context);
  }
 
  virtual Model::SearchUsersByImageOutcome SearchUsersByImage(const Model::SearchUsersByImageRequest& request) const;
 
  template <typename SearchUsersByImageRequestT = Model::SearchUsersByImageRequest>
  Model::SearchUsersByImageOutcomeCallable SearchUsersByImageCallable(const SearchUsersByImageRequestT& request) const {
    return SubmitCallable(&RekognitionClient::SearchUsersByImage, request);
  }
 
  template <typename SearchUsersByImageRequestT = Model::SearchUsersByImageRequest>
  void SearchUsersByImageAsync(const SearchUsersByImageRequestT& request, const SearchUsersByImageResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::SearchUsersByImage, request, handler, context);
  }
 
  virtual Model::StartCelebrityRecognitionOutcome StartCelebrityRecognition(const Model::StartCelebrityRecognitionRequest& request) const;
 
  template <typename StartCelebrityRecognitionRequestT = Model::StartCelebrityRecognitionRequest>
  Model::StartCelebrityRecognitionOutcomeCallable StartCelebrityRecognitionCallable(
      const StartCelebrityRecognitionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::StartCelebrityRecognition, request);
  }
 
  template <typename StartCelebrityRecognitionRequestT = Model::StartCelebrityRecognitionRequest>
  void StartCelebrityRecognitionAsync(const StartCelebrityRecognitionRequestT& request,
                                      const StartCelebrityRecognitionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::StartCelebrityRecognition, request, handler, context);
  }
 
  virtual Model::StartContentModerationOutcome StartContentModeration(const Model::StartContentModerationRequest& request) const;
 
  template <typename StartContentModerationRequestT = Model::StartContentModerationRequest>
  Model::StartContentModerationOutcomeCallable StartContentModerationCallable(const StartContentModerationRequestT& request) const {
    return SubmitCallable(&RekognitionClient::StartContentModeration, request);
  }
 
  template <typename StartContentModerationRequestT = Model::StartContentModerationRequest>
  void StartContentModerationAsync(const StartContentModerationRequestT& request,
                                   const StartContentModerationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::StartContentModeration, request, handler, context);
  }
 
  virtual Model::StartFaceDetectionOutcome StartFaceDetection(const Model::StartFaceDetectionRequest& request) const;
 
  template <typename StartFaceDetectionRequestT = Model::StartFaceDetectionRequest>
  Model::StartFaceDetectionOutcomeCallable StartFaceDetectionCallable(const StartFaceDetectionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::StartFaceDetection, request);
  }
 
  template <typename StartFaceDetectionRequestT = Model::StartFaceDetectionRequest>
  void StartFaceDetectionAsync(const StartFaceDetectionRequestT& request, const StartFaceDetectionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::StartFaceDetection, request, handler, context);
  }
 
  virtual Model::StartFaceSearchOutcome StartFaceSearch(const Model::StartFaceSearchRequest& request) const;
 
  template <typename StartFaceSearchRequestT = Model::StartFaceSearchRequest>
  Model::StartFaceSearchOutcomeCallable StartFaceSearchCallable(const StartFaceSearchRequestT& request) const {
    return SubmitCallable(&RekognitionClient::StartFaceSearch, request);
  }
 
  template <typename StartFaceSearchRequestT = Model::StartFaceSearchRequest>
  void StartFaceSearchAsync(const StartFaceSearchRequestT& request, const StartFaceSearchResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::StartFaceSearch, request, handler, context);
  }
 
  virtual Model::StartLabelDetectionOutcome StartLabelDetection(const Model::StartLabelDetectionRequest& request) const;
 
  template <typename StartLabelDetectionRequestT = Model::StartLabelDetectionRequest>
  Model::StartLabelDetectionOutcomeCallable StartLabelDetectionCallable(const StartLabelDetectionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::StartLabelDetection, request);
  }
 
  template <typename StartLabelDetectionRequestT = Model::StartLabelDetectionRequest>
  void StartLabelDetectionAsync(const StartLabelDetectionRequestT& request, const StartLabelDetectionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::StartLabelDetection, request, handler, context);
  }
 
  virtual Model::StartMediaAnalysisJobOutcome StartMediaAnalysisJob(const Model::StartMediaAnalysisJobRequest& request) const;
 
  template <typename StartMediaAnalysisJobRequestT = Model::StartMediaAnalysisJobRequest>
  Model::StartMediaAnalysisJobOutcomeCallable StartMediaAnalysisJobCallable(const StartMediaAnalysisJobRequestT& request) const {
    return SubmitCallable(&RekognitionClient::StartMediaAnalysisJob, request);
  }
 
  template <typename StartMediaAnalysisJobRequestT = Model::StartMediaAnalysisJobRequest>
  void StartMediaAnalysisJobAsync(const StartMediaAnalysisJobRequestT& request, const StartMediaAnalysisJobResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::StartMediaAnalysisJob, request, handler, context);
  }
 
  virtual Model::StartPersonTrackingOutcome StartPersonTracking(const Model::StartPersonTrackingRequest& request) const;
 
  template <typename StartPersonTrackingRequestT = Model::StartPersonTrackingRequest>
  Model::StartPersonTrackingOutcomeCallable StartPersonTrackingCallable(const StartPersonTrackingRequestT& request) const {
    return SubmitCallable(&RekognitionClient::StartPersonTracking, request);
  }
 
  template <typename StartPersonTrackingRequestT = Model::StartPersonTrackingRequest>
  void StartPersonTrackingAsync(const StartPersonTrackingRequestT& request, const StartPersonTrackingResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::StartPersonTracking, request, handler, context);
  }
 
  virtual Model::StartProjectVersionOutcome StartProjectVersion(const Model::StartProjectVersionRequest& request) const;
 
  template <typename StartProjectVersionRequestT = Model::StartProjectVersionRequest>
  Model::StartProjectVersionOutcomeCallable StartProjectVersionCallable(const StartProjectVersionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::StartProjectVersion, request);
  }
 
  template <typename StartProjectVersionRequestT = Model::StartProjectVersionRequest>
  void StartProjectVersionAsync(const StartProjectVersionRequestT& request, const StartProjectVersionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::StartProjectVersion, request, handler, context);
  }
 
  virtual Model::StartSegmentDetectionOutcome StartSegmentDetection(const Model::StartSegmentDetectionRequest& request) const;
 
  template <typename StartSegmentDetectionRequestT = Model::StartSegmentDetectionRequest>
  Model::StartSegmentDetectionOutcomeCallable StartSegmentDetectionCallable(const StartSegmentDetectionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::StartSegmentDetection, request);
  }
 
  template <typename StartSegmentDetectionRequestT = Model::StartSegmentDetectionRequest>
  void StartSegmentDetectionAsync(const StartSegmentDetectionRequestT& request, const StartSegmentDetectionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::StartSegmentDetection, request, handler, context);
  }
 
  virtual Model::StartStreamProcessorOutcome StartStreamProcessor(const Model::StartStreamProcessorRequest& request) const;
 
  template <typename StartStreamProcessorRequestT = Model::StartStreamProcessorRequest>
  Model::StartStreamProcessorOutcomeCallable StartStreamProcessorCallable(const StartStreamProcessorRequestT& request) const {
    return SubmitCallable(&RekognitionClient::StartStreamProcessor, request);
  }
 
  template <typename StartStreamProcessorRequestT = Model::StartStreamProcessorRequest>
  void StartStreamProcessorAsync(const StartStreamProcessorRequestT& request, const StartStreamProcessorResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::StartStreamProcessor, request, handler, context);
  }
 
  virtual Model::StartTextDetectionOutcome StartTextDetection(const Model::StartTextDetectionRequest& request) const;
 
  template <typename StartTextDetectionRequestT = Model::StartTextDetectionRequest>
  Model::StartTextDetectionOutcomeCallable StartTextDetectionCallable(const StartTextDetectionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::StartTextDetection, request);
  }
 
  template <typename StartTextDetectionRequestT = Model::StartTextDetectionRequest>
  void StartTextDetectionAsync(const StartTextDetectionRequestT& request, const StartTextDetectionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::StartTextDetection, request, handler, context);
  }
 
  virtual Model::StopProjectVersionOutcome StopProjectVersion(const Model::StopProjectVersionRequest& request) const;
 
  template <typename StopProjectVersionRequestT = Model::StopProjectVersionRequest>
  Model::StopProjectVersionOutcomeCallable StopProjectVersionCallable(const StopProjectVersionRequestT& request) const {
    return SubmitCallable(&RekognitionClient::StopProjectVersion, request);
  }
 
  template <typename StopProjectVersionRequestT = Model::StopProjectVersionRequest>
  void StopProjectVersionAsync(const StopProjectVersionRequestT& request, const StopProjectVersionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::StopProjectVersion, request, handler, context);
  }
 
  virtual Model::StopStreamProcessorOutcome StopStreamProcessor(const Model::StopStreamProcessorRequest& request) const;
 
  template <typename StopStreamProcessorRequestT = Model::StopStreamProcessorRequest>
  Model::StopStreamProcessorOutcomeCallable StopStreamProcessorCallable(const StopStreamProcessorRequestT& request) const {
    return SubmitCallable(&RekognitionClient::StopStreamProcessor, request);
  }
 
  template <typename StopStreamProcessorRequestT = Model::StopStreamProcessorRequest>
  void StopStreamProcessorAsync(const StopStreamProcessorRequestT& request, const StopStreamProcessorResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::StopStreamProcessor, 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(&RekognitionClient::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(&RekognitionClient::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(&RekognitionClient::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(&RekognitionClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateDatasetEntriesOutcome UpdateDatasetEntries(const Model::UpdateDatasetEntriesRequest& request) const;
 
  template <typename UpdateDatasetEntriesRequestT = Model::UpdateDatasetEntriesRequest>
  Model::UpdateDatasetEntriesOutcomeCallable UpdateDatasetEntriesCallable(const UpdateDatasetEntriesRequestT& request) const {
    return SubmitCallable(&RekognitionClient::UpdateDatasetEntries, request);
  }
 
  template <typename UpdateDatasetEntriesRequestT = Model::UpdateDatasetEntriesRequest>
  void UpdateDatasetEntriesAsync(const UpdateDatasetEntriesRequestT& request, const UpdateDatasetEntriesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::UpdateDatasetEntries, request, handler, context);
  }
 
  virtual Model::UpdateStreamProcessorOutcome UpdateStreamProcessor(const Model::UpdateStreamProcessorRequest& request) const;
 
  template <typename UpdateStreamProcessorRequestT = Model::UpdateStreamProcessorRequest>
  Model::UpdateStreamProcessorOutcomeCallable UpdateStreamProcessorCallable(const UpdateStreamProcessorRequestT& request) const {
    return SubmitCallable(&RekognitionClient::UpdateStreamProcessor, request);
  }
 
  template <typename UpdateStreamProcessorRequestT = Model::UpdateStreamProcessorRequest>
  void UpdateStreamProcessorAsync(const UpdateStreamProcessorRequestT& request, const UpdateStreamProcessorResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RekognitionClient::UpdateStreamProcessor, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<RekognitionEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<RekognitionClient>;
  void init(const RekognitionClientConfiguration& clientConfiguration);
 
  RekognitionClientConfiguration m_clientConfiguration;
  std::shared_ptr<RekognitionEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Rekognition
}  // namespace Aws