EntityResolutionClient.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/entityresolution/EntityResolutionPaginationBase.h>
#include <aws/entityresolution/EntityResolutionServiceClientModel.h>
#include <aws/entityresolution/EntityResolutionWaiter.h>
#include <aws/entityresolution/EntityResolution_EXPORTS.h>
 
namespace Aws {
namespace EntityResolution {
class AWS_ENTITYRESOLUTION_API EntityResolutionClient : public Aws::Client::AWSJsonClient,
                                                        public Aws::Client::ClientWithAsyncTemplateMethods<EntityResolutionClient>,
                                                        public EntityResolutionPaginationBase<EntityResolutionClient>,
                                                        public EntityResolutionWaiter<EntityResolutionClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef EntityResolutionClientConfiguration ClientConfigurationType;
  typedef EntityResolutionEndpointProvider EndpointProviderType;
 
  EntityResolutionClient(const Aws::EntityResolution::EntityResolutionClientConfiguration& clientConfiguration =
                             Aws::EntityResolution::EntityResolutionClientConfiguration(),
                         std::shared_ptr<EntityResolutionEndpointProviderBase> endpointProvider = nullptr);
 
  EntityResolutionClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<EntityResolutionEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::EntityResolution::EntityResolutionClientConfiguration& clientConfiguration =
                             Aws::EntityResolution::EntityResolutionClientConfiguration());
 
  EntityResolutionClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<EntityResolutionEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::EntityResolution::EntityResolutionClientConfiguration& clientConfiguration =
                             Aws::EntityResolution::EntityResolutionClientConfiguration());
 
  /* Legacy constructors due deprecation */
  EntityResolutionClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  EntityResolutionClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  EntityResolutionClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~EntityResolutionClient();
 
  virtual Model::AddPolicyStatementOutcome AddPolicyStatement(const Model::AddPolicyStatementRequest& request) const;
 
  template <typename AddPolicyStatementRequestT = Model::AddPolicyStatementRequest>
  Model::AddPolicyStatementOutcomeCallable AddPolicyStatementCallable(const AddPolicyStatementRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::AddPolicyStatement, request);
  }
 
  template <typename AddPolicyStatementRequestT = Model::AddPolicyStatementRequest>
  void AddPolicyStatementAsync(const AddPolicyStatementRequestT& request, const AddPolicyStatementResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::AddPolicyStatement, request, handler, context);
  }
 
  virtual Model::BatchDeleteUniqueIdOutcome BatchDeleteUniqueId(const Model::BatchDeleteUniqueIdRequest& request) const;
 
  template <typename BatchDeleteUniqueIdRequestT = Model::BatchDeleteUniqueIdRequest>
  Model::BatchDeleteUniqueIdOutcomeCallable BatchDeleteUniqueIdCallable(const BatchDeleteUniqueIdRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::BatchDeleteUniqueId, request);
  }
 
  template <typename BatchDeleteUniqueIdRequestT = Model::BatchDeleteUniqueIdRequest>
  void BatchDeleteUniqueIdAsync(const BatchDeleteUniqueIdRequestT& request, const BatchDeleteUniqueIdResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::BatchDeleteUniqueId, request, handler, context);
  }
 
  virtual Model::CreateIdMappingWorkflowOutcome CreateIdMappingWorkflow(const Model::CreateIdMappingWorkflowRequest& request) const;
 
  template <typename CreateIdMappingWorkflowRequestT = Model::CreateIdMappingWorkflowRequest>
  Model::CreateIdMappingWorkflowOutcomeCallable CreateIdMappingWorkflowCallable(const CreateIdMappingWorkflowRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::CreateIdMappingWorkflow, request);
  }
 
  template <typename CreateIdMappingWorkflowRequestT = Model::CreateIdMappingWorkflowRequest>
  void CreateIdMappingWorkflowAsync(const CreateIdMappingWorkflowRequestT& request,
                                    const CreateIdMappingWorkflowResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::CreateIdMappingWorkflow, request, handler, context);
  }
 
  virtual Model::CreateIdNamespaceOutcome CreateIdNamespace(const Model::CreateIdNamespaceRequest& request) const;
 
  template <typename CreateIdNamespaceRequestT = Model::CreateIdNamespaceRequest>
  Model::CreateIdNamespaceOutcomeCallable CreateIdNamespaceCallable(const CreateIdNamespaceRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::CreateIdNamespace, request);
  }
 
  template <typename CreateIdNamespaceRequestT = Model::CreateIdNamespaceRequest>
  void CreateIdNamespaceAsync(const CreateIdNamespaceRequestT& request, const CreateIdNamespaceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::CreateIdNamespace, request, handler, context);
  }
 
  virtual Model::CreateMatchingWorkflowOutcome CreateMatchingWorkflow(const Model::CreateMatchingWorkflowRequest& request) const;
 
  template <typename CreateMatchingWorkflowRequestT = Model::CreateMatchingWorkflowRequest>
  Model::CreateMatchingWorkflowOutcomeCallable CreateMatchingWorkflowCallable(const CreateMatchingWorkflowRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::CreateMatchingWorkflow, request);
  }
 
  template <typename CreateMatchingWorkflowRequestT = Model::CreateMatchingWorkflowRequest>
  void CreateMatchingWorkflowAsync(const CreateMatchingWorkflowRequestT& request,
                                   const CreateMatchingWorkflowResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::CreateMatchingWorkflow, request, handler, context);
  }
 
  virtual Model::CreateSchemaMappingOutcome CreateSchemaMapping(const Model::CreateSchemaMappingRequest& request) const;
 
  template <typename CreateSchemaMappingRequestT = Model::CreateSchemaMappingRequest>
  Model::CreateSchemaMappingOutcomeCallable CreateSchemaMappingCallable(const CreateSchemaMappingRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::CreateSchemaMapping, request);
  }
 
  template <typename CreateSchemaMappingRequestT = Model::CreateSchemaMappingRequest>
  void CreateSchemaMappingAsync(const CreateSchemaMappingRequestT& request, const CreateSchemaMappingResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::CreateSchemaMapping, request, handler, context);
  }
 
  virtual Model::DeleteIdMappingWorkflowOutcome DeleteIdMappingWorkflow(const Model::DeleteIdMappingWorkflowRequest& request) const;
 
  template <typename DeleteIdMappingWorkflowRequestT = Model::DeleteIdMappingWorkflowRequest>
  Model::DeleteIdMappingWorkflowOutcomeCallable DeleteIdMappingWorkflowCallable(const DeleteIdMappingWorkflowRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::DeleteIdMappingWorkflow, request);
  }
 
  template <typename DeleteIdMappingWorkflowRequestT = Model::DeleteIdMappingWorkflowRequest>
  void DeleteIdMappingWorkflowAsync(const DeleteIdMappingWorkflowRequestT& request,
                                    const DeleteIdMappingWorkflowResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::DeleteIdMappingWorkflow, request, handler, context);
  }
 
  virtual Model::DeleteIdNamespaceOutcome DeleteIdNamespace(const Model::DeleteIdNamespaceRequest& request) const;
 
  template <typename DeleteIdNamespaceRequestT = Model::DeleteIdNamespaceRequest>
  Model::DeleteIdNamespaceOutcomeCallable DeleteIdNamespaceCallable(const DeleteIdNamespaceRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::DeleteIdNamespace, request);
  }
 
  template <typename DeleteIdNamespaceRequestT = Model::DeleteIdNamespaceRequest>
  void DeleteIdNamespaceAsync(const DeleteIdNamespaceRequestT& request, const DeleteIdNamespaceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::DeleteIdNamespace, request, handler, context);
  }
 
  virtual Model::DeleteMatchingWorkflowOutcome DeleteMatchingWorkflow(const Model::DeleteMatchingWorkflowRequest& request) const;
 
  template <typename DeleteMatchingWorkflowRequestT = Model::DeleteMatchingWorkflowRequest>
  Model::DeleteMatchingWorkflowOutcomeCallable DeleteMatchingWorkflowCallable(const DeleteMatchingWorkflowRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::DeleteMatchingWorkflow, request);
  }
 
  template <typename DeleteMatchingWorkflowRequestT = Model::DeleteMatchingWorkflowRequest>
  void DeleteMatchingWorkflowAsync(const DeleteMatchingWorkflowRequestT& request,
                                   const DeleteMatchingWorkflowResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::DeleteMatchingWorkflow, request, handler, context);
  }
 
  virtual Model::DeletePolicyStatementOutcome DeletePolicyStatement(const Model::DeletePolicyStatementRequest& request) const;
 
  template <typename DeletePolicyStatementRequestT = Model::DeletePolicyStatementRequest>
  Model::DeletePolicyStatementOutcomeCallable DeletePolicyStatementCallable(const DeletePolicyStatementRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::DeletePolicyStatement, request);
  }
 
  template <typename DeletePolicyStatementRequestT = Model::DeletePolicyStatementRequest>
  void DeletePolicyStatementAsync(const DeletePolicyStatementRequestT& request, const DeletePolicyStatementResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::DeletePolicyStatement, request, handler, context);
  }
 
  virtual Model::DeleteSchemaMappingOutcome DeleteSchemaMapping(const Model::DeleteSchemaMappingRequest& request) const;
 
  template <typename DeleteSchemaMappingRequestT = Model::DeleteSchemaMappingRequest>
  Model::DeleteSchemaMappingOutcomeCallable DeleteSchemaMappingCallable(const DeleteSchemaMappingRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::DeleteSchemaMapping, request);
  }
 
  template <typename DeleteSchemaMappingRequestT = Model::DeleteSchemaMappingRequest>
  void DeleteSchemaMappingAsync(const DeleteSchemaMappingRequestT& request, const DeleteSchemaMappingResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::DeleteSchemaMapping, request, handler, context);
  }
 
  virtual Model::GenerateMatchIdOutcome GenerateMatchId(const Model::GenerateMatchIdRequest& request) const;
 
  template <typename GenerateMatchIdRequestT = Model::GenerateMatchIdRequest>
  Model::GenerateMatchIdOutcomeCallable GenerateMatchIdCallable(const GenerateMatchIdRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::GenerateMatchId, request);
  }
 
  template <typename GenerateMatchIdRequestT = Model::GenerateMatchIdRequest>
  void GenerateMatchIdAsync(const GenerateMatchIdRequestT& request, const GenerateMatchIdResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::GenerateMatchId, request, handler, context);
  }
 
  virtual Model::GetIdMappingJobOutcome GetIdMappingJob(const Model::GetIdMappingJobRequest& request) const;
 
  template <typename GetIdMappingJobRequestT = Model::GetIdMappingJobRequest>
  Model::GetIdMappingJobOutcomeCallable GetIdMappingJobCallable(const GetIdMappingJobRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::GetIdMappingJob, request);
  }
 
  template <typename GetIdMappingJobRequestT = Model::GetIdMappingJobRequest>
  void GetIdMappingJobAsync(const GetIdMappingJobRequestT& request, const GetIdMappingJobResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::GetIdMappingJob, request, handler, context);
  }
 
  virtual Model::GetIdMappingWorkflowOutcome GetIdMappingWorkflow(const Model::GetIdMappingWorkflowRequest& request) const;
 
  template <typename GetIdMappingWorkflowRequestT = Model::GetIdMappingWorkflowRequest>
  Model::GetIdMappingWorkflowOutcomeCallable GetIdMappingWorkflowCallable(const GetIdMappingWorkflowRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::GetIdMappingWorkflow, request);
  }
 
  template <typename GetIdMappingWorkflowRequestT = Model::GetIdMappingWorkflowRequest>
  void GetIdMappingWorkflowAsync(const GetIdMappingWorkflowRequestT& request, const GetIdMappingWorkflowResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::GetIdMappingWorkflow, request, handler, context);
  }
 
  virtual Model::GetIdNamespaceOutcome GetIdNamespace(const Model::GetIdNamespaceRequest& request) const;
 
  template <typename GetIdNamespaceRequestT = Model::GetIdNamespaceRequest>
  Model::GetIdNamespaceOutcomeCallable GetIdNamespaceCallable(const GetIdNamespaceRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::GetIdNamespace, request);
  }
 
  template <typename GetIdNamespaceRequestT = Model::GetIdNamespaceRequest>
  void GetIdNamespaceAsync(const GetIdNamespaceRequestT& request, const GetIdNamespaceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::GetIdNamespace, request, handler, context);
  }
 
  virtual Model::GetMatchIdOutcome GetMatchId(const Model::GetMatchIdRequest& request) const;
 
  template <typename GetMatchIdRequestT = Model::GetMatchIdRequest>
  Model::GetMatchIdOutcomeCallable GetMatchIdCallable(const GetMatchIdRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::GetMatchId, request);
  }
 
  template <typename GetMatchIdRequestT = Model::GetMatchIdRequest>
  void GetMatchIdAsync(const GetMatchIdRequestT& request, const GetMatchIdResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::GetMatchId, request, handler, context);
  }
 
  virtual Model::GetMatchingJobOutcome GetMatchingJob(const Model::GetMatchingJobRequest& request) const;
 
  template <typename GetMatchingJobRequestT = Model::GetMatchingJobRequest>
  Model::GetMatchingJobOutcomeCallable GetMatchingJobCallable(const GetMatchingJobRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::GetMatchingJob, request);
  }
 
  template <typename GetMatchingJobRequestT = Model::GetMatchingJobRequest>
  void GetMatchingJobAsync(const GetMatchingJobRequestT& request, const GetMatchingJobResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::GetMatchingJob, request, handler, context);
  }
 
  virtual Model::GetMatchingWorkflowOutcome GetMatchingWorkflow(const Model::GetMatchingWorkflowRequest& request) const;
 
  template <typename GetMatchingWorkflowRequestT = Model::GetMatchingWorkflowRequest>
  Model::GetMatchingWorkflowOutcomeCallable GetMatchingWorkflowCallable(const GetMatchingWorkflowRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::GetMatchingWorkflow, request);
  }
 
  template <typename GetMatchingWorkflowRequestT = Model::GetMatchingWorkflowRequest>
  void GetMatchingWorkflowAsync(const GetMatchingWorkflowRequestT& request, const GetMatchingWorkflowResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::GetMatchingWorkflow, request, handler, context);
  }
 
  virtual Model::GetPolicyOutcome GetPolicy(const Model::GetPolicyRequest& request) const;
 
  template <typename GetPolicyRequestT = Model::GetPolicyRequest>
  Model::GetPolicyOutcomeCallable GetPolicyCallable(const GetPolicyRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::GetPolicy, request);
  }
 
  template <typename GetPolicyRequestT = Model::GetPolicyRequest>
  void GetPolicyAsync(const GetPolicyRequestT& request, const GetPolicyResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::GetPolicy, request, handler, context);
  }
 
  virtual Model::GetProviderServiceOutcome GetProviderService(const Model::GetProviderServiceRequest& request) const;
 
  template <typename GetProviderServiceRequestT = Model::GetProviderServiceRequest>
  Model::GetProviderServiceOutcomeCallable GetProviderServiceCallable(const GetProviderServiceRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::GetProviderService, request);
  }
 
  template <typename GetProviderServiceRequestT = Model::GetProviderServiceRequest>
  void GetProviderServiceAsync(const GetProviderServiceRequestT& request, const GetProviderServiceResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::GetProviderService, request, handler, context);
  }
 
  virtual Model::GetSchemaMappingOutcome GetSchemaMapping(const Model::GetSchemaMappingRequest& request) const;
 
  template <typename GetSchemaMappingRequestT = Model::GetSchemaMappingRequest>
  Model::GetSchemaMappingOutcomeCallable GetSchemaMappingCallable(const GetSchemaMappingRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::GetSchemaMapping, request);
  }
 
  template <typename GetSchemaMappingRequestT = Model::GetSchemaMappingRequest>
  void GetSchemaMappingAsync(const GetSchemaMappingRequestT& request, const GetSchemaMappingResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::GetSchemaMapping, request, handler, context);
  }
 
  virtual Model::ListIdMappingJobsOutcome ListIdMappingJobs(const Model::ListIdMappingJobsRequest& request) const;
 
  template <typename ListIdMappingJobsRequestT = Model::ListIdMappingJobsRequest>
  Model::ListIdMappingJobsOutcomeCallable ListIdMappingJobsCallable(const ListIdMappingJobsRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::ListIdMappingJobs, request);
  }
 
  template <typename ListIdMappingJobsRequestT = Model::ListIdMappingJobsRequest>
  void ListIdMappingJobsAsync(const ListIdMappingJobsRequestT& request, const ListIdMappingJobsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::ListIdMappingJobs, request, handler, context);
  }
 
  virtual Model::ListIdMappingWorkflowsOutcome ListIdMappingWorkflows(const Model::ListIdMappingWorkflowsRequest& request = {}) const;
 
  template <typename ListIdMappingWorkflowsRequestT = Model::ListIdMappingWorkflowsRequest>
  Model::ListIdMappingWorkflowsOutcomeCallable ListIdMappingWorkflowsCallable(const ListIdMappingWorkflowsRequestT& request = {}) const {
    return SubmitCallable(&EntityResolutionClient::ListIdMappingWorkflows, request);
  }
 
  template <typename ListIdMappingWorkflowsRequestT = Model::ListIdMappingWorkflowsRequest>
  void ListIdMappingWorkflowsAsync(const ListIdMappingWorkflowsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListIdMappingWorkflowsRequestT& request = {}) const {
    return SubmitAsync(&EntityResolutionClient::ListIdMappingWorkflows, request, handler, context);
  }
 
  virtual Model::ListIdNamespacesOutcome ListIdNamespaces(const Model::ListIdNamespacesRequest& request = {}) const;
 
  template <typename ListIdNamespacesRequestT = Model::ListIdNamespacesRequest>
  Model::ListIdNamespacesOutcomeCallable ListIdNamespacesCallable(const ListIdNamespacesRequestT& request = {}) const {
    return SubmitCallable(&EntityResolutionClient::ListIdNamespaces, request);
  }
 
  template <typename ListIdNamespacesRequestT = Model::ListIdNamespacesRequest>
  void ListIdNamespacesAsync(const ListIdNamespacesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListIdNamespacesRequestT& request = {}) const {
    return SubmitAsync(&EntityResolutionClient::ListIdNamespaces, request, handler, context);
  }
 
  virtual Model::ListMatchingJobsOutcome ListMatchingJobs(const Model::ListMatchingJobsRequest& request) const;
 
  template <typename ListMatchingJobsRequestT = Model::ListMatchingJobsRequest>
  Model::ListMatchingJobsOutcomeCallable ListMatchingJobsCallable(const ListMatchingJobsRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::ListMatchingJobs, request);
  }
 
  template <typename ListMatchingJobsRequestT = Model::ListMatchingJobsRequest>
  void ListMatchingJobsAsync(const ListMatchingJobsRequestT& request, const ListMatchingJobsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::ListMatchingJobs, request, handler, context);
  }
 
  virtual Model::ListMatchingWorkflowsOutcome ListMatchingWorkflows(const Model::ListMatchingWorkflowsRequest& request = {}) const;
 
  template <typename ListMatchingWorkflowsRequestT = Model::ListMatchingWorkflowsRequest>
  Model::ListMatchingWorkflowsOutcomeCallable ListMatchingWorkflowsCallable(const ListMatchingWorkflowsRequestT& request = {}) const {
    return SubmitCallable(&EntityResolutionClient::ListMatchingWorkflows, request);
  }
 
  template <typename ListMatchingWorkflowsRequestT = Model::ListMatchingWorkflowsRequest>
  void ListMatchingWorkflowsAsync(const ListMatchingWorkflowsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListMatchingWorkflowsRequestT& request = {}) const {
    return SubmitAsync(&EntityResolutionClient::ListMatchingWorkflows, request, handler, context);
  }
 
  virtual Model::ListProviderServicesOutcome ListProviderServices(const Model::ListProviderServicesRequest& request = {}) const;
 
  template <typename ListProviderServicesRequestT = Model::ListProviderServicesRequest>
  Model::ListProviderServicesOutcomeCallable ListProviderServicesCallable(const ListProviderServicesRequestT& request = {}) const {
    return SubmitCallable(&EntityResolutionClient::ListProviderServices, request);
  }
 
  template <typename ListProviderServicesRequestT = Model::ListProviderServicesRequest>
  void ListProviderServicesAsync(const ListProviderServicesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListProviderServicesRequestT& request = {}) const {
    return SubmitAsync(&EntityResolutionClient::ListProviderServices, request, handler, context);
  }
 
  virtual Model::ListSchemaMappingsOutcome ListSchemaMappings(const Model::ListSchemaMappingsRequest& request = {}) const;
 
  template <typename ListSchemaMappingsRequestT = Model::ListSchemaMappingsRequest>
  Model::ListSchemaMappingsOutcomeCallable ListSchemaMappingsCallable(const ListSchemaMappingsRequestT& request = {}) const {
    return SubmitCallable(&EntityResolutionClient::ListSchemaMappings, request);
  }
 
  template <typename ListSchemaMappingsRequestT = Model::ListSchemaMappingsRequest>
  void ListSchemaMappingsAsync(const ListSchemaMappingsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListSchemaMappingsRequestT& request = {}) const {
    return SubmitAsync(&EntityResolutionClient::ListSchemaMappings, 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(&EntityResolutionClient::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(&EntityResolutionClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutPolicyOutcome PutPolicy(const Model::PutPolicyRequest& request) const;
 
  template <typename PutPolicyRequestT = Model::PutPolicyRequest>
  Model::PutPolicyOutcomeCallable PutPolicyCallable(const PutPolicyRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::PutPolicy, request);
  }
 
  template <typename PutPolicyRequestT = Model::PutPolicyRequest>
  void PutPolicyAsync(const PutPolicyRequestT& request, const PutPolicyResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::PutPolicy, request, handler, context);
  }
 
  virtual Model::StartIdMappingJobOutcome StartIdMappingJob(const Model::StartIdMappingJobRequest& request) const;
 
  template <typename StartIdMappingJobRequestT = Model::StartIdMappingJobRequest>
  Model::StartIdMappingJobOutcomeCallable StartIdMappingJobCallable(const StartIdMappingJobRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::StartIdMappingJob, request);
  }
 
  template <typename StartIdMappingJobRequestT = Model::StartIdMappingJobRequest>
  void StartIdMappingJobAsync(const StartIdMappingJobRequestT& request, const StartIdMappingJobResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::StartIdMappingJob, request, handler, context);
  }
 
  virtual Model::StartMatchingJobOutcome StartMatchingJob(const Model::StartMatchingJobRequest& request) const;
 
  template <typename StartMatchingJobRequestT = Model::StartMatchingJobRequest>
  Model::StartMatchingJobOutcomeCallable StartMatchingJobCallable(const StartMatchingJobRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::StartMatchingJob, request);
  }
 
  template <typename StartMatchingJobRequestT = Model::StartMatchingJobRequest>
  void StartMatchingJobAsync(const StartMatchingJobRequestT& request, const StartMatchingJobResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::StartMatchingJob, 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(&EntityResolutionClient::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(&EntityResolutionClient::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(&EntityResolutionClient::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(&EntityResolutionClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateIdMappingWorkflowOutcome UpdateIdMappingWorkflow(const Model::UpdateIdMappingWorkflowRequest& request) const;
 
  template <typename UpdateIdMappingWorkflowRequestT = Model::UpdateIdMappingWorkflowRequest>
  Model::UpdateIdMappingWorkflowOutcomeCallable UpdateIdMappingWorkflowCallable(const UpdateIdMappingWorkflowRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::UpdateIdMappingWorkflow, request);
  }
 
  template <typename UpdateIdMappingWorkflowRequestT = Model::UpdateIdMappingWorkflowRequest>
  void UpdateIdMappingWorkflowAsync(const UpdateIdMappingWorkflowRequestT& request,
                                    const UpdateIdMappingWorkflowResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::UpdateIdMappingWorkflow, request, handler, context);
  }
 
  virtual Model::UpdateIdNamespaceOutcome UpdateIdNamespace(const Model::UpdateIdNamespaceRequest& request) const;
 
  template <typename UpdateIdNamespaceRequestT = Model::UpdateIdNamespaceRequest>
  Model::UpdateIdNamespaceOutcomeCallable UpdateIdNamespaceCallable(const UpdateIdNamespaceRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::UpdateIdNamespace, request);
  }
 
  template <typename UpdateIdNamespaceRequestT = Model::UpdateIdNamespaceRequest>
  void UpdateIdNamespaceAsync(const UpdateIdNamespaceRequestT& request, const UpdateIdNamespaceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::UpdateIdNamespace, request, handler, context);
  }
 
  virtual Model::UpdateMatchingWorkflowOutcome UpdateMatchingWorkflow(const Model::UpdateMatchingWorkflowRequest& request) const;
 
  template <typename UpdateMatchingWorkflowRequestT = Model::UpdateMatchingWorkflowRequest>
  Model::UpdateMatchingWorkflowOutcomeCallable UpdateMatchingWorkflowCallable(const UpdateMatchingWorkflowRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::UpdateMatchingWorkflow, request);
  }
 
  template <typename UpdateMatchingWorkflowRequestT = Model::UpdateMatchingWorkflowRequest>
  void UpdateMatchingWorkflowAsync(const UpdateMatchingWorkflowRequestT& request,
                                   const UpdateMatchingWorkflowResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::UpdateMatchingWorkflow, request, handler, context);
  }
 
  virtual Model::UpdateSchemaMappingOutcome UpdateSchemaMapping(const Model::UpdateSchemaMappingRequest& request) const;
 
  template <typename UpdateSchemaMappingRequestT = Model::UpdateSchemaMappingRequest>
  Model::UpdateSchemaMappingOutcomeCallable UpdateSchemaMappingCallable(const UpdateSchemaMappingRequestT& request) const {
    return SubmitCallable(&EntityResolutionClient::UpdateSchemaMapping, request);
  }
 
  template <typename UpdateSchemaMappingRequestT = Model::UpdateSchemaMappingRequest>
  void UpdateSchemaMappingAsync(const UpdateSchemaMappingRequestT& request, const UpdateSchemaMappingResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EntityResolutionClient::UpdateSchemaMapping, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<EntityResolutionEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<EntityResolutionClient>;
  void init(const EntityResolutionClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, EntityResolutionError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  EntityResolutionClientConfiguration m_clientConfiguration;
  std::shared_ptr<EntityResolutionEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace EntityResolution
}  // namespace Aws