VoiceIDClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/voice-id/VoiceIDServiceClientModel.h>
#include <aws/voice-id/VoiceID_EXPORTS.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