RekognitionClient.h

 
#pragma once
#include <aws/rekognition/Rekognition_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/rekognition/RekognitionServiceClientModel.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