EntityResolutionClient.h

 
#pragma once
#include <aws/entityresolution/EntityResolution_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/entityresolution/EntityResolutionServiceClientModel.h>
 
namespace Aws
{
namespace EntityResolution
{
  class AWS_ENTITYRESOLUTION_API EntityResolutionClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<EntityResolutionEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<EntityResolutionClient>;
      void init(const EntityResolutionClientConfiguration& clientConfiguration);
 
      EntityResolutionClientConfiguration m_clientConfiguration;
      std::shared_ptr<EntityResolutionEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace EntityResolution
} // namespace Aws