VoiceIDClient.h

 
#pragma once
#include <aws/voice-id/VoiceID_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/voice-id/VoiceIDServiceClientModel.h>
 
namespace Aws
{
namespace VoiceID
{
  class AWS_VOICEID_API VoiceIDClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<VoiceIDClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef VoiceIDClientConfiguration ClientConfigurationType;
      typedef VoiceIDEndpointProvider EndpointProviderType;
 
        VoiceIDClient(const Aws::VoiceID::VoiceIDClientConfiguration& clientConfiguration = Aws::VoiceID::VoiceIDClientConfiguration(),
                      std::shared_ptr<VoiceIDEndpointProviderBase> endpointProvider = nullptr);
 
        VoiceIDClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<VoiceIDEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::VoiceID::VoiceIDClientConfiguration& clientConfiguration = Aws::VoiceID::VoiceIDClientConfiguration());
 
        VoiceIDClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<VoiceIDEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::VoiceID::VoiceIDClientConfiguration& clientConfiguration = Aws::VoiceID::VoiceIDClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        VoiceIDClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        VoiceIDClient(const Aws::Auth::AWSCredentials& credentials,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        VoiceIDClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~VoiceIDClient();
 
        virtual Model::AssociateFraudsterOutcome AssociateFraudster(const Model::AssociateFraudsterRequest& request) const;
 
        template<typename AssociateFraudsterRequestT = Model::AssociateFraudsterRequest>
        Model::AssociateFraudsterOutcomeCallable AssociateFraudsterCallable(const AssociateFraudsterRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::AssociateFraudster, request);
        }
 
        template<typename AssociateFraudsterRequestT = Model::AssociateFraudsterRequest>
        void AssociateFraudsterAsync(const AssociateFraudsterRequestT& request, const AssociateFraudsterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::AssociateFraudster, request, handler, context);
        }
 
        virtual Model::CreateDomainOutcome CreateDomain(const Model::CreateDomainRequest& request) const;
 
        template<typename CreateDomainRequestT = Model::CreateDomainRequest>
        Model::CreateDomainOutcomeCallable CreateDomainCallable(const CreateDomainRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::CreateDomain, request);
        }
 
        template<typename CreateDomainRequestT = Model::CreateDomainRequest>
        void CreateDomainAsync(const CreateDomainRequestT& request, const CreateDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::CreateDomain, request, handler, context);
        }
 
        virtual Model::CreateWatchlistOutcome CreateWatchlist(const Model::CreateWatchlistRequest& request) const;
 
        template<typename CreateWatchlistRequestT = Model::CreateWatchlistRequest>
        Model::CreateWatchlistOutcomeCallable CreateWatchlistCallable(const CreateWatchlistRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::CreateWatchlist, request);
        }
 
        template<typename CreateWatchlistRequestT = Model::CreateWatchlistRequest>
        void CreateWatchlistAsync(const CreateWatchlistRequestT& request, const CreateWatchlistResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::CreateWatchlist, request, handler, context);
        }
 
        virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest& request) const;
 
        template<typename DeleteDomainRequestT = Model::DeleteDomainRequest>
        Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::DeleteDomain, request);
        }
 
        template<typename DeleteDomainRequestT = Model::DeleteDomainRequest>
        void DeleteDomainAsync(const DeleteDomainRequestT& request, const DeleteDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::DeleteDomain, request, handler, context);
        }
 
        virtual Model::DeleteFraudsterOutcome DeleteFraudster(const Model::DeleteFraudsterRequest& request) const;
 
        template<typename DeleteFraudsterRequestT = Model::DeleteFraudsterRequest>
        Model::DeleteFraudsterOutcomeCallable DeleteFraudsterCallable(const DeleteFraudsterRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::DeleteFraudster, request);
        }
 
        template<typename DeleteFraudsterRequestT = Model::DeleteFraudsterRequest>
        void DeleteFraudsterAsync(const DeleteFraudsterRequestT& request, const DeleteFraudsterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::DeleteFraudster, request, handler, context);
        }
 
        virtual Model::DeleteSpeakerOutcome DeleteSpeaker(const Model::DeleteSpeakerRequest& request) const;
 
        template<typename DeleteSpeakerRequestT = Model::DeleteSpeakerRequest>
        Model::DeleteSpeakerOutcomeCallable DeleteSpeakerCallable(const DeleteSpeakerRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::DeleteSpeaker, request);
        }
 
        template<typename DeleteSpeakerRequestT = Model::DeleteSpeakerRequest>
        void DeleteSpeakerAsync(const DeleteSpeakerRequestT& request, const DeleteSpeakerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::DeleteSpeaker, request, handler, context);
        }
 
        virtual Model::DeleteWatchlistOutcome DeleteWatchlist(const Model::DeleteWatchlistRequest& request) const;
 
        template<typename DeleteWatchlistRequestT = Model::DeleteWatchlistRequest>
        Model::DeleteWatchlistOutcomeCallable DeleteWatchlistCallable(const DeleteWatchlistRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::DeleteWatchlist, request);
        }
 
        template<typename DeleteWatchlistRequestT = Model::DeleteWatchlistRequest>
        void DeleteWatchlistAsync(const DeleteWatchlistRequestT& request, const DeleteWatchlistResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::DeleteWatchlist, request, handler, context);
        }
 
        virtual Model::DescribeDomainOutcome DescribeDomain(const Model::DescribeDomainRequest& request) const;
 
        template<typename DescribeDomainRequestT = Model::DescribeDomainRequest>
        Model::DescribeDomainOutcomeCallable DescribeDomainCallable(const DescribeDomainRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::DescribeDomain, request);
        }
 
        template<typename DescribeDomainRequestT = Model::DescribeDomainRequest>
        void DescribeDomainAsync(const DescribeDomainRequestT& request, const DescribeDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::DescribeDomain, request, handler, context);
        }
 
        virtual Model::DescribeFraudsterOutcome DescribeFraudster(const Model::DescribeFraudsterRequest& request) const;
 
        template<typename DescribeFraudsterRequestT = Model::DescribeFraudsterRequest>
        Model::DescribeFraudsterOutcomeCallable DescribeFraudsterCallable(const DescribeFraudsterRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::DescribeFraudster, request);
        }
 
        template<typename DescribeFraudsterRequestT = Model::DescribeFraudsterRequest>
        void DescribeFraudsterAsync(const DescribeFraudsterRequestT& request, const DescribeFraudsterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::DescribeFraudster, request, handler, context);
        }
 
        virtual Model::DescribeFraudsterRegistrationJobOutcome DescribeFraudsterRegistrationJob(const Model::DescribeFraudsterRegistrationJobRequest& request) const;
 
        template<typename DescribeFraudsterRegistrationJobRequestT = Model::DescribeFraudsterRegistrationJobRequest>
        Model::DescribeFraudsterRegistrationJobOutcomeCallable DescribeFraudsterRegistrationJobCallable(const DescribeFraudsterRegistrationJobRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::DescribeFraudsterRegistrationJob, request);
        }
 
        template<typename DescribeFraudsterRegistrationJobRequestT = Model::DescribeFraudsterRegistrationJobRequest>
        void DescribeFraudsterRegistrationJobAsync(const DescribeFraudsterRegistrationJobRequestT& request, const DescribeFraudsterRegistrationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::DescribeFraudsterRegistrationJob, request, handler, context);
        }
 
        virtual Model::DescribeSpeakerOutcome DescribeSpeaker(const Model::DescribeSpeakerRequest& request) const;
 
        template<typename DescribeSpeakerRequestT = Model::DescribeSpeakerRequest>
        Model::DescribeSpeakerOutcomeCallable DescribeSpeakerCallable(const DescribeSpeakerRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::DescribeSpeaker, request);
        }
 
        template<typename DescribeSpeakerRequestT = Model::DescribeSpeakerRequest>
        void DescribeSpeakerAsync(const DescribeSpeakerRequestT& request, const DescribeSpeakerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::DescribeSpeaker, request, handler, context);
        }
 
        virtual Model::DescribeSpeakerEnrollmentJobOutcome DescribeSpeakerEnrollmentJob(const Model::DescribeSpeakerEnrollmentJobRequest& request) const;
 
        template<typename DescribeSpeakerEnrollmentJobRequestT = Model::DescribeSpeakerEnrollmentJobRequest>
        Model::DescribeSpeakerEnrollmentJobOutcomeCallable DescribeSpeakerEnrollmentJobCallable(const DescribeSpeakerEnrollmentJobRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::DescribeSpeakerEnrollmentJob, request);
        }
 
        template<typename DescribeSpeakerEnrollmentJobRequestT = Model::DescribeSpeakerEnrollmentJobRequest>
        void DescribeSpeakerEnrollmentJobAsync(const DescribeSpeakerEnrollmentJobRequestT& request, const DescribeSpeakerEnrollmentJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::DescribeSpeakerEnrollmentJob, request, handler, context);
        }
 
        virtual Model::DescribeWatchlistOutcome DescribeWatchlist(const Model::DescribeWatchlistRequest& request) const;
 
        template<typename DescribeWatchlistRequestT = Model::DescribeWatchlistRequest>
        Model::DescribeWatchlistOutcomeCallable DescribeWatchlistCallable(const DescribeWatchlistRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::DescribeWatchlist, request);
        }
 
        template<typename DescribeWatchlistRequestT = Model::DescribeWatchlistRequest>
        void DescribeWatchlistAsync(const DescribeWatchlistRequestT& request, const DescribeWatchlistResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::DescribeWatchlist, request, handler, context);
        }
 
        virtual Model::DisassociateFraudsterOutcome DisassociateFraudster(const Model::DisassociateFraudsterRequest& request) const;
 
        template<typename DisassociateFraudsterRequestT = Model::DisassociateFraudsterRequest>
        Model::DisassociateFraudsterOutcomeCallable DisassociateFraudsterCallable(const DisassociateFraudsterRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::DisassociateFraudster, request);
        }
 
        template<typename DisassociateFraudsterRequestT = Model::DisassociateFraudsterRequest>
        void DisassociateFraudsterAsync(const DisassociateFraudsterRequestT& request, const DisassociateFraudsterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::DisassociateFraudster, request, handler, context);
        }
 
        virtual Model::EvaluateSessionOutcome EvaluateSession(const Model::EvaluateSessionRequest& request) const;
 
        template<typename EvaluateSessionRequestT = Model::EvaluateSessionRequest>
        Model::EvaluateSessionOutcomeCallable EvaluateSessionCallable(const EvaluateSessionRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::EvaluateSession, request);
        }
 
        template<typename EvaluateSessionRequestT = Model::EvaluateSessionRequest>
        void EvaluateSessionAsync(const EvaluateSessionRequestT& request, const EvaluateSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::EvaluateSession, request, handler, context);
        }
 
        virtual Model::ListDomainsOutcome ListDomains(const Model::ListDomainsRequest& request = {}) const;
 
        template<typename ListDomainsRequestT = Model::ListDomainsRequest>
        Model::ListDomainsOutcomeCallable ListDomainsCallable(const ListDomainsRequestT& request = {}) const
        {
            return SubmitCallable(&VoiceIDClient::ListDomains, request);
        }
 
        template<typename ListDomainsRequestT = Model::ListDomainsRequest>
        void ListDomainsAsync(const ListDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDomainsRequestT& request = {}) const
        {
            return SubmitAsync(&VoiceIDClient::ListDomains, request, handler, context);
        }
 
        virtual Model::ListFraudsterRegistrationJobsOutcome ListFraudsterRegistrationJobs(const Model::ListFraudsterRegistrationJobsRequest& request) const;
 
        template<typename ListFraudsterRegistrationJobsRequestT = Model::ListFraudsterRegistrationJobsRequest>
        Model::ListFraudsterRegistrationJobsOutcomeCallable ListFraudsterRegistrationJobsCallable(const ListFraudsterRegistrationJobsRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::ListFraudsterRegistrationJobs, request);
        }
 
        template<typename ListFraudsterRegistrationJobsRequestT = Model::ListFraudsterRegistrationJobsRequest>
        void ListFraudsterRegistrationJobsAsync(const ListFraudsterRegistrationJobsRequestT& request, const ListFraudsterRegistrationJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::ListFraudsterRegistrationJobs, request, handler, context);
        }
 
        virtual Model::ListFraudstersOutcome ListFraudsters(const Model::ListFraudstersRequest& request) const;
 
        template<typename ListFraudstersRequestT = Model::ListFraudstersRequest>
        Model::ListFraudstersOutcomeCallable ListFraudstersCallable(const ListFraudstersRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::ListFraudsters, request);
        }
 
        template<typename ListFraudstersRequestT = Model::ListFraudstersRequest>
        void ListFraudstersAsync(const ListFraudstersRequestT& request, const ListFraudstersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::ListFraudsters, request, handler, context);
        }
 
        virtual Model::ListSpeakerEnrollmentJobsOutcome ListSpeakerEnrollmentJobs(const Model::ListSpeakerEnrollmentJobsRequest& request) const;
 
        template<typename ListSpeakerEnrollmentJobsRequestT = Model::ListSpeakerEnrollmentJobsRequest>
        Model::ListSpeakerEnrollmentJobsOutcomeCallable ListSpeakerEnrollmentJobsCallable(const ListSpeakerEnrollmentJobsRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::ListSpeakerEnrollmentJobs, request);
        }
 
        template<typename ListSpeakerEnrollmentJobsRequestT = Model::ListSpeakerEnrollmentJobsRequest>
        void ListSpeakerEnrollmentJobsAsync(const ListSpeakerEnrollmentJobsRequestT& request, const ListSpeakerEnrollmentJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::ListSpeakerEnrollmentJobs, request, handler, context);
        }
 
        virtual Model::ListSpeakersOutcome ListSpeakers(const Model::ListSpeakersRequest& request) const;
 
        template<typename ListSpeakersRequestT = Model::ListSpeakersRequest>
        Model::ListSpeakersOutcomeCallable ListSpeakersCallable(const ListSpeakersRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::ListSpeakers, request);
        }
 
        template<typename ListSpeakersRequestT = Model::ListSpeakersRequest>
        void ListSpeakersAsync(const ListSpeakersRequestT& request, const ListSpeakersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::ListSpeakers, 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(&VoiceIDClient::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(&VoiceIDClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListWatchlistsOutcome ListWatchlists(const Model::ListWatchlistsRequest& request) const;
 
        template<typename ListWatchlistsRequestT = Model::ListWatchlistsRequest>
        Model::ListWatchlistsOutcomeCallable ListWatchlistsCallable(const ListWatchlistsRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::ListWatchlists, request);
        }
 
        template<typename ListWatchlistsRequestT = Model::ListWatchlistsRequest>
        void ListWatchlistsAsync(const ListWatchlistsRequestT& request, const ListWatchlistsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::ListWatchlists, request, handler, context);
        }
 
        virtual Model::OptOutSpeakerOutcome OptOutSpeaker(const Model::OptOutSpeakerRequest& request) const;
 
        template<typename OptOutSpeakerRequestT = Model::OptOutSpeakerRequest>
        Model::OptOutSpeakerOutcomeCallable OptOutSpeakerCallable(const OptOutSpeakerRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::OptOutSpeaker, request);
        }
 
        template<typename OptOutSpeakerRequestT = Model::OptOutSpeakerRequest>
        void OptOutSpeakerAsync(const OptOutSpeakerRequestT& request, const OptOutSpeakerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::OptOutSpeaker, request, handler, context);
        }
 
        virtual Model::StartFraudsterRegistrationJobOutcome StartFraudsterRegistrationJob(const Model::StartFraudsterRegistrationJobRequest& request) const;
 
        template<typename StartFraudsterRegistrationJobRequestT = Model::StartFraudsterRegistrationJobRequest>
        Model::StartFraudsterRegistrationJobOutcomeCallable StartFraudsterRegistrationJobCallable(const StartFraudsterRegistrationJobRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::StartFraudsterRegistrationJob, request);
        }
 
        template<typename StartFraudsterRegistrationJobRequestT = Model::StartFraudsterRegistrationJobRequest>
        void StartFraudsterRegistrationJobAsync(const StartFraudsterRegistrationJobRequestT& request, const StartFraudsterRegistrationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::StartFraudsterRegistrationJob, request, handler, context);
        }
 
        virtual Model::StartSpeakerEnrollmentJobOutcome StartSpeakerEnrollmentJob(const Model::StartSpeakerEnrollmentJobRequest& request) const;
 
        template<typename StartSpeakerEnrollmentJobRequestT = Model::StartSpeakerEnrollmentJobRequest>
        Model::StartSpeakerEnrollmentJobOutcomeCallable StartSpeakerEnrollmentJobCallable(const StartSpeakerEnrollmentJobRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::StartSpeakerEnrollmentJob, request);
        }
 
        template<typename StartSpeakerEnrollmentJobRequestT = Model::StartSpeakerEnrollmentJobRequest>
        void StartSpeakerEnrollmentJobAsync(const StartSpeakerEnrollmentJobRequestT& request, const StartSpeakerEnrollmentJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::StartSpeakerEnrollmentJob, 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(&VoiceIDClient::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(&VoiceIDClient::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(&VoiceIDClient::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(&VoiceIDClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateDomainOutcome UpdateDomain(const Model::UpdateDomainRequest& request) const;
 
        template<typename UpdateDomainRequestT = Model::UpdateDomainRequest>
        Model::UpdateDomainOutcomeCallable UpdateDomainCallable(const UpdateDomainRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::UpdateDomain, request);
        }
 
        template<typename UpdateDomainRequestT = Model::UpdateDomainRequest>
        void UpdateDomainAsync(const UpdateDomainRequestT& request, const UpdateDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::UpdateDomain, request, handler, context);
        }
 
        virtual Model::UpdateWatchlistOutcome UpdateWatchlist(const Model::UpdateWatchlistRequest& request) const;
 
        template<typename UpdateWatchlistRequestT = Model::UpdateWatchlistRequest>
        Model::UpdateWatchlistOutcomeCallable UpdateWatchlistCallable(const UpdateWatchlistRequestT& request) const
        {
            return SubmitCallable(&VoiceIDClient::UpdateWatchlist, request);
        }
 
        template<typename UpdateWatchlistRequestT = Model::UpdateWatchlistRequest>
        void UpdateWatchlistAsync(const UpdateWatchlistRequestT& request, const UpdateWatchlistResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&VoiceIDClient::UpdateWatchlist, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<VoiceIDEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<VoiceIDClient>;
      void init(const VoiceIDClientConfiguration& clientConfiguration);
 
      VoiceIDClientConfiguration m_clientConfiguration;
      std::shared_ptr<VoiceIDEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace VoiceID
} // namespace Aws