CustomerProfilesClient.h

 
#pragma once
#include <aws/customer-profiles/CustomerProfiles_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/customer-profiles/CustomerProfilesServiceClientModel.h>
 
namespace Aws
{
namespace CustomerProfiles
{
  class AWS_CUSTOMERPROFILES_API CustomerProfilesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<CustomerProfilesClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef CustomerProfilesClientConfiguration ClientConfigurationType;
      typedef CustomerProfilesEndpointProvider EndpointProviderType;
 
        CustomerProfilesClient(const Aws::CustomerProfiles::CustomerProfilesClientConfiguration& clientConfiguration = Aws::CustomerProfiles::CustomerProfilesClientConfiguration(),
                               std::shared_ptr<CustomerProfilesEndpointProviderBase> endpointProvider = nullptr);
 
        CustomerProfilesClient(const Aws::Auth::AWSCredentials& credentials,
                               std::shared_ptr<CustomerProfilesEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::CustomerProfiles::CustomerProfilesClientConfiguration& clientConfiguration = Aws::CustomerProfiles::CustomerProfilesClientConfiguration());
 
        CustomerProfilesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               std::shared_ptr<CustomerProfilesEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::CustomerProfiles::CustomerProfilesClientConfiguration& clientConfiguration = Aws::CustomerProfiles::CustomerProfilesClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        CustomerProfilesClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CustomerProfilesClient(const Aws::Auth::AWSCredentials& credentials,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CustomerProfilesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~CustomerProfilesClient();
 
        virtual Model::AddProfileKeyOutcome AddProfileKey(const Model::AddProfileKeyRequest& request) const;
 
        template<typename AddProfileKeyRequestT = Model::AddProfileKeyRequest>
        Model::AddProfileKeyOutcomeCallable AddProfileKeyCallable(const AddProfileKeyRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::AddProfileKey, request);
        }
 
        template<typename AddProfileKeyRequestT = Model::AddProfileKeyRequest>
        void AddProfileKeyAsync(const AddProfileKeyRequestT& request, const AddProfileKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::AddProfileKey, request, handler, context);
        }
 
        virtual Model::BatchGetCalculatedAttributeForProfileOutcome BatchGetCalculatedAttributeForProfile(const Model::BatchGetCalculatedAttributeForProfileRequest& request) const;
 
        template<typename BatchGetCalculatedAttributeForProfileRequestT = Model::BatchGetCalculatedAttributeForProfileRequest>
        Model::BatchGetCalculatedAttributeForProfileOutcomeCallable BatchGetCalculatedAttributeForProfileCallable(const BatchGetCalculatedAttributeForProfileRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::BatchGetCalculatedAttributeForProfile, request);
        }
 
        template<typename BatchGetCalculatedAttributeForProfileRequestT = Model::BatchGetCalculatedAttributeForProfileRequest>
        void BatchGetCalculatedAttributeForProfileAsync(const BatchGetCalculatedAttributeForProfileRequestT& request, const BatchGetCalculatedAttributeForProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::BatchGetCalculatedAttributeForProfile, request, handler, context);
        }
 
        virtual Model::BatchGetProfileOutcome BatchGetProfile(const Model::BatchGetProfileRequest& request) const;
 
        template<typename BatchGetProfileRequestT = Model::BatchGetProfileRequest>
        Model::BatchGetProfileOutcomeCallable BatchGetProfileCallable(const BatchGetProfileRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::BatchGetProfile, request);
        }
 
        template<typename BatchGetProfileRequestT = Model::BatchGetProfileRequest>
        void BatchGetProfileAsync(const BatchGetProfileRequestT& request, const BatchGetProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::BatchGetProfile, request, handler, context);
        }
 
        virtual Model::CreateCalculatedAttributeDefinitionOutcome CreateCalculatedAttributeDefinition(const Model::CreateCalculatedAttributeDefinitionRequest& request) const;
 
        template<typename CreateCalculatedAttributeDefinitionRequestT = Model::CreateCalculatedAttributeDefinitionRequest>
        Model::CreateCalculatedAttributeDefinitionOutcomeCallable CreateCalculatedAttributeDefinitionCallable(const CreateCalculatedAttributeDefinitionRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::CreateCalculatedAttributeDefinition, request);
        }
 
        template<typename CreateCalculatedAttributeDefinitionRequestT = Model::CreateCalculatedAttributeDefinitionRequest>
        void CreateCalculatedAttributeDefinitionAsync(const CreateCalculatedAttributeDefinitionRequestT& request, const CreateCalculatedAttributeDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::CreateCalculatedAttributeDefinition, 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(&CustomerProfilesClient::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(&CustomerProfilesClient::CreateDomain, request, handler, context);
        }
 
        virtual Model::CreateDomainLayoutOutcome CreateDomainLayout(const Model::CreateDomainLayoutRequest& request) const;
 
        template<typename CreateDomainLayoutRequestT = Model::CreateDomainLayoutRequest>
        Model::CreateDomainLayoutOutcomeCallable CreateDomainLayoutCallable(const CreateDomainLayoutRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::CreateDomainLayout, request);
        }
 
        template<typename CreateDomainLayoutRequestT = Model::CreateDomainLayoutRequest>
        void CreateDomainLayoutAsync(const CreateDomainLayoutRequestT& request, const CreateDomainLayoutResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::CreateDomainLayout, request, handler, context);
        }
 
        virtual Model::CreateEventStreamOutcome CreateEventStream(const Model::CreateEventStreamRequest& request) const;
 
        template<typename CreateEventStreamRequestT = Model::CreateEventStreamRequest>
        Model::CreateEventStreamOutcomeCallable CreateEventStreamCallable(const CreateEventStreamRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::CreateEventStream, request);
        }
 
        template<typename CreateEventStreamRequestT = Model::CreateEventStreamRequest>
        void CreateEventStreamAsync(const CreateEventStreamRequestT& request, const CreateEventStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::CreateEventStream, request, handler, context);
        }
 
        virtual Model::CreateEventTriggerOutcome CreateEventTrigger(const Model::CreateEventTriggerRequest& request) const;
 
        template<typename CreateEventTriggerRequestT = Model::CreateEventTriggerRequest>
        Model::CreateEventTriggerOutcomeCallable CreateEventTriggerCallable(const CreateEventTriggerRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::CreateEventTrigger, request);
        }
 
        template<typename CreateEventTriggerRequestT = Model::CreateEventTriggerRequest>
        void CreateEventTriggerAsync(const CreateEventTriggerRequestT& request, const CreateEventTriggerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::CreateEventTrigger, request, handler, context);
        }
 
        virtual Model::CreateIntegrationWorkflowOutcome CreateIntegrationWorkflow(const Model::CreateIntegrationWorkflowRequest& request) const;
 
        template<typename CreateIntegrationWorkflowRequestT = Model::CreateIntegrationWorkflowRequest>
        Model::CreateIntegrationWorkflowOutcomeCallable CreateIntegrationWorkflowCallable(const CreateIntegrationWorkflowRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::CreateIntegrationWorkflow, request);
        }
 
        template<typename CreateIntegrationWorkflowRequestT = Model::CreateIntegrationWorkflowRequest>
        void CreateIntegrationWorkflowAsync(const CreateIntegrationWorkflowRequestT& request, const CreateIntegrationWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::CreateIntegrationWorkflow, request, handler, context);
        }
 
        virtual Model::CreateProfileOutcome CreateProfile(const Model::CreateProfileRequest& request) const;
 
        template<typename CreateProfileRequestT = Model::CreateProfileRequest>
        Model::CreateProfileOutcomeCallable CreateProfileCallable(const CreateProfileRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::CreateProfile, request);
        }
 
        template<typename CreateProfileRequestT = Model::CreateProfileRequest>
        void CreateProfileAsync(const CreateProfileRequestT& request, const CreateProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::CreateProfile, request, handler, context);
        }
 
        virtual Model::CreateSegmentDefinitionOutcome CreateSegmentDefinition(const Model::CreateSegmentDefinitionRequest& request) const;
 
        template<typename CreateSegmentDefinitionRequestT = Model::CreateSegmentDefinitionRequest>
        Model::CreateSegmentDefinitionOutcomeCallable CreateSegmentDefinitionCallable(const CreateSegmentDefinitionRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::CreateSegmentDefinition, request);
        }
 
        template<typename CreateSegmentDefinitionRequestT = Model::CreateSegmentDefinitionRequest>
        void CreateSegmentDefinitionAsync(const CreateSegmentDefinitionRequestT& request, const CreateSegmentDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::CreateSegmentDefinition, request, handler, context);
        }
 
        virtual Model::CreateSegmentEstimateOutcome CreateSegmentEstimate(const Model::CreateSegmentEstimateRequest& request) const;
 
        template<typename CreateSegmentEstimateRequestT = Model::CreateSegmentEstimateRequest>
        Model::CreateSegmentEstimateOutcomeCallable CreateSegmentEstimateCallable(const CreateSegmentEstimateRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::CreateSegmentEstimate, request);
        }
 
        template<typename CreateSegmentEstimateRequestT = Model::CreateSegmentEstimateRequest>
        void CreateSegmentEstimateAsync(const CreateSegmentEstimateRequestT& request, const CreateSegmentEstimateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::CreateSegmentEstimate, request, handler, context);
        }
 
        virtual Model::CreateSegmentSnapshotOutcome CreateSegmentSnapshot(const Model::CreateSegmentSnapshotRequest& request) const;
 
        template<typename CreateSegmentSnapshotRequestT = Model::CreateSegmentSnapshotRequest>
        Model::CreateSegmentSnapshotOutcomeCallable CreateSegmentSnapshotCallable(const CreateSegmentSnapshotRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::CreateSegmentSnapshot, request);
        }
 
        template<typename CreateSegmentSnapshotRequestT = Model::CreateSegmentSnapshotRequest>
        void CreateSegmentSnapshotAsync(const CreateSegmentSnapshotRequestT& request, const CreateSegmentSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::CreateSegmentSnapshot, request, handler, context);
        }
 
        virtual Model::CreateUploadJobOutcome CreateUploadJob(const Model::CreateUploadJobRequest& request) const;
 
        template<typename CreateUploadJobRequestT = Model::CreateUploadJobRequest>
        Model::CreateUploadJobOutcomeCallable CreateUploadJobCallable(const CreateUploadJobRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::CreateUploadJob, request);
        }
 
        template<typename CreateUploadJobRequestT = Model::CreateUploadJobRequest>
        void CreateUploadJobAsync(const CreateUploadJobRequestT& request, const CreateUploadJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::CreateUploadJob, request, handler, context);
        }
 
        virtual Model::DeleteCalculatedAttributeDefinitionOutcome DeleteCalculatedAttributeDefinition(const Model::DeleteCalculatedAttributeDefinitionRequest& request) const;
 
        template<typename DeleteCalculatedAttributeDefinitionRequestT = Model::DeleteCalculatedAttributeDefinitionRequest>
        Model::DeleteCalculatedAttributeDefinitionOutcomeCallable DeleteCalculatedAttributeDefinitionCallable(const DeleteCalculatedAttributeDefinitionRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::DeleteCalculatedAttributeDefinition, request);
        }
 
        template<typename DeleteCalculatedAttributeDefinitionRequestT = Model::DeleteCalculatedAttributeDefinitionRequest>
        void DeleteCalculatedAttributeDefinitionAsync(const DeleteCalculatedAttributeDefinitionRequestT& request, const DeleteCalculatedAttributeDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::DeleteCalculatedAttributeDefinition, 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(&CustomerProfilesClient::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(&CustomerProfilesClient::DeleteDomain, request, handler, context);
        }
 
        virtual Model::DeleteDomainLayoutOutcome DeleteDomainLayout(const Model::DeleteDomainLayoutRequest& request) const;
 
        template<typename DeleteDomainLayoutRequestT = Model::DeleteDomainLayoutRequest>
        Model::DeleteDomainLayoutOutcomeCallable DeleteDomainLayoutCallable(const DeleteDomainLayoutRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::DeleteDomainLayout, request);
        }
 
        template<typename DeleteDomainLayoutRequestT = Model::DeleteDomainLayoutRequest>
        void DeleteDomainLayoutAsync(const DeleteDomainLayoutRequestT& request, const DeleteDomainLayoutResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::DeleteDomainLayout, request, handler, context);
        }
 
        virtual Model::DeleteEventStreamOutcome DeleteEventStream(const Model::DeleteEventStreamRequest& request) const;
 
        template<typename DeleteEventStreamRequestT = Model::DeleteEventStreamRequest>
        Model::DeleteEventStreamOutcomeCallable DeleteEventStreamCallable(const DeleteEventStreamRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::DeleteEventStream, request);
        }
 
        template<typename DeleteEventStreamRequestT = Model::DeleteEventStreamRequest>
        void DeleteEventStreamAsync(const DeleteEventStreamRequestT& request, const DeleteEventStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::DeleteEventStream, request, handler, context);
        }
 
        virtual Model::DeleteEventTriggerOutcome DeleteEventTrigger(const Model::DeleteEventTriggerRequest& request) const;
 
        template<typename DeleteEventTriggerRequestT = Model::DeleteEventTriggerRequest>
        Model::DeleteEventTriggerOutcomeCallable DeleteEventTriggerCallable(const DeleteEventTriggerRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::DeleteEventTrigger, request);
        }
 
        template<typename DeleteEventTriggerRequestT = Model::DeleteEventTriggerRequest>
        void DeleteEventTriggerAsync(const DeleteEventTriggerRequestT& request, const DeleteEventTriggerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::DeleteEventTrigger, request, handler, context);
        }
 
        virtual Model::DeleteIntegrationOutcome DeleteIntegration(const Model::DeleteIntegrationRequest& request) const;
 
        template<typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
        Model::DeleteIntegrationOutcomeCallable DeleteIntegrationCallable(const DeleteIntegrationRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::DeleteIntegration, request);
        }
 
        template<typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
        void DeleteIntegrationAsync(const DeleteIntegrationRequestT& request, const DeleteIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::DeleteIntegration, request, handler, context);
        }
 
        virtual Model::DeleteProfileOutcome DeleteProfile(const Model::DeleteProfileRequest& request) const;
 
        template<typename DeleteProfileRequestT = Model::DeleteProfileRequest>
        Model::DeleteProfileOutcomeCallable DeleteProfileCallable(const DeleteProfileRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::DeleteProfile, request);
        }
 
        template<typename DeleteProfileRequestT = Model::DeleteProfileRequest>
        void DeleteProfileAsync(const DeleteProfileRequestT& request, const DeleteProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::DeleteProfile, request, handler, context);
        }
 
        virtual Model::DeleteProfileKeyOutcome DeleteProfileKey(const Model::DeleteProfileKeyRequest& request) const;
 
        template<typename DeleteProfileKeyRequestT = Model::DeleteProfileKeyRequest>
        Model::DeleteProfileKeyOutcomeCallable DeleteProfileKeyCallable(const DeleteProfileKeyRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::DeleteProfileKey, request);
        }
 
        template<typename DeleteProfileKeyRequestT = Model::DeleteProfileKeyRequest>
        void DeleteProfileKeyAsync(const DeleteProfileKeyRequestT& request, const DeleteProfileKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::DeleteProfileKey, request, handler, context);
        }
 
        virtual Model::DeleteProfileObjectOutcome DeleteProfileObject(const Model::DeleteProfileObjectRequest& request) const;
 
        template<typename DeleteProfileObjectRequestT = Model::DeleteProfileObjectRequest>
        Model::DeleteProfileObjectOutcomeCallable DeleteProfileObjectCallable(const DeleteProfileObjectRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::DeleteProfileObject, request);
        }
 
        template<typename DeleteProfileObjectRequestT = Model::DeleteProfileObjectRequest>
        void DeleteProfileObjectAsync(const DeleteProfileObjectRequestT& request, const DeleteProfileObjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::DeleteProfileObject, request, handler, context);
        }
 
        virtual Model::DeleteProfileObjectTypeOutcome DeleteProfileObjectType(const Model::DeleteProfileObjectTypeRequest& request) const;
 
        template<typename DeleteProfileObjectTypeRequestT = Model::DeleteProfileObjectTypeRequest>
        Model::DeleteProfileObjectTypeOutcomeCallable DeleteProfileObjectTypeCallable(const DeleteProfileObjectTypeRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::DeleteProfileObjectType, request);
        }
 
        template<typename DeleteProfileObjectTypeRequestT = Model::DeleteProfileObjectTypeRequest>
        void DeleteProfileObjectTypeAsync(const DeleteProfileObjectTypeRequestT& request, const DeleteProfileObjectTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::DeleteProfileObjectType, request, handler, context);
        }
 
        virtual Model::DeleteSegmentDefinitionOutcome DeleteSegmentDefinition(const Model::DeleteSegmentDefinitionRequest& request) const;
 
        template<typename DeleteSegmentDefinitionRequestT = Model::DeleteSegmentDefinitionRequest>
        Model::DeleteSegmentDefinitionOutcomeCallable DeleteSegmentDefinitionCallable(const DeleteSegmentDefinitionRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::DeleteSegmentDefinition, request);
        }
 
        template<typename DeleteSegmentDefinitionRequestT = Model::DeleteSegmentDefinitionRequest>
        void DeleteSegmentDefinitionAsync(const DeleteSegmentDefinitionRequestT& request, const DeleteSegmentDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::DeleteSegmentDefinition, request, handler, context);
        }
 
        virtual Model::DeleteWorkflowOutcome DeleteWorkflow(const Model::DeleteWorkflowRequest& request) const;
 
        template<typename DeleteWorkflowRequestT = Model::DeleteWorkflowRequest>
        Model::DeleteWorkflowOutcomeCallable DeleteWorkflowCallable(const DeleteWorkflowRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::DeleteWorkflow, request);
        }
 
        template<typename DeleteWorkflowRequestT = Model::DeleteWorkflowRequest>
        void DeleteWorkflowAsync(const DeleteWorkflowRequestT& request, const DeleteWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::DeleteWorkflow, request, handler, context);
        }
 
        virtual Model::DetectProfileObjectTypeOutcome DetectProfileObjectType(const Model::DetectProfileObjectTypeRequest& request) const;
 
        template<typename DetectProfileObjectTypeRequestT = Model::DetectProfileObjectTypeRequest>
        Model::DetectProfileObjectTypeOutcomeCallable DetectProfileObjectTypeCallable(const DetectProfileObjectTypeRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::DetectProfileObjectType, request);
        }
 
        template<typename DetectProfileObjectTypeRequestT = Model::DetectProfileObjectTypeRequest>
        void DetectProfileObjectTypeAsync(const DetectProfileObjectTypeRequestT& request, const DetectProfileObjectTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::DetectProfileObjectType, request, handler, context);
        }
 
        virtual Model::GetAutoMergingPreviewOutcome GetAutoMergingPreview(const Model::GetAutoMergingPreviewRequest& request) const;
 
        template<typename GetAutoMergingPreviewRequestT = Model::GetAutoMergingPreviewRequest>
        Model::GetAutoMergingPreviewOutcomeCallable GetAutoMergingPreviewCallable(const GetAutoMergingPreviewRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetAutoMergingPreview, request);
        }
 
        template<typename GetAutoMergingPreviewRequestT = Model::GetAutoMergingPreviewRequest>
        void GetAutoMergingPreviewAsync(const GetAutoMergingPreviewRequestT& request, const GetAutoMergingPreviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetAutoMergingPreview, request, handler, context);
        }
 
        virtual Model::GetCalculatedAttributeDefinitionOutcome GetCalculatedAttributeDefinition(const Model::GetCalculatedAttributeDefinitionRequest& request) const;
 
        template<typename GetCalculatedAttributeDefinitionRequestT = Model::GetCalculatedAttributeDefinitionRequest>
        Model::GetCalculatedAttributeDefinitionOutcomeCallable GetCalculatedAttributeDefinitionCallable(const GetCalculatedAttributeDefinitionRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetCalculatedAttributeDefinition, request);
        }
 
        template<typename GetCalculatedAttributeDefinitionRequestT = Model::GetCalculatedAttributeDefinitionRequest>
        void GetCalculatedAttributeDefinitionAsync(const GetCalculatedAttributeDefinitionRequestT& request, const GetCalculatedAttributeDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetCalculatedAttributeDefinition, request, handler, context);
        }
 
        virtual Model::GetCalculatedAttributeForProfileOutcome GetCalculatedAttributeForProfile(const Model::GetCalculatedAttributeForProfileRequest& request) const;
 
        template<typename GetCalculatedAttributeForProfileRequestT = Model::GetCalculatedAttributeForProfileRequest>
        Model::GetCalculatedAttributeForProfileOutcomeCallable GetCalculatedAttributeForProfileCallable(const GetCalculatedAttributeForProfileRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetCalculatedAttributeForProfile, request);
        }
 
        template<typename GetCalculatedAttributeForProfileRequestT = Model::GetCalculatedAttributeForProfileRequest>
        void GetCalculatedAttributeForProfileAsync(const GetCalculatedAttributeForProfileRequestT& request, const GetCalculatedAttributeForProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetCalculatedAttributeForProfile, request, handler, context);
        }
 
        virtual Model::GetDomainOutcome GetDomain(const Model::GetDomainRequest& request) const;
 
        template<typename GetDomainRequestT = Model::GetDomainRequest>
        Model::GetDomainOutcomeCallable GetDomainCallable(const GetDomainRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetDomain, request);
        }
 
        template<typename GetDomainRequestT = Model::GetDomainRequest>
        void GetDomainAsync(const GetDomainRequestT& request, const GetDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetDomain, request, handler, context);
        }
 
        virtual Model::GetDomainLayoutOutcome GetDomainLayout(const Model::GetDomainLayoutRequest& request) const;
 
        template<typename GetDomainLayoutRequestT = Model::GetDomainLayoutRequest>
        Model::GetDomainLayoutOutcomeCallable GetDomainLayoutCallable(const GetDomainLayoutRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetDomainLayout, request);
        }
 
        template<typename GetDomainLayoutRequestT = Model::GetDomainLayoutRequest>
        void GetDomainLayoutAsync(const GetDomainLayoutRequestT& request, const GetDomainLayoutResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetDomainLayout, request, handler, context);
        }
 
        virtual Model::GetEventStreamOutcome GetEventStream(const Model::GetEventStreamRequest& request) const;
 
        template<typename GetEventStreamRequestT = Model::GetEventStreamRequest>
        Model::GetEventStreamOutcomeCallable GetEventStreamCallable(const GetEventStreamRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetEventStream, request);
        }
 
        template<typename GetEventStreamRequestT = Model::GetEventStreamRequest>
        void GetEventStreamAsync(const GetEventStreamRequestT& request, const GetEventStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetEventStream, request, handler, context);
        }
 
        virtual Model::GetEventTriggerOutcome GetEventTrigger(const Model::GetEventTriggerRequest& request) const;
 
        template<typename GetEventTriggerRequestT = Model::GetEventTriggerRequest>
        Model::GetEventTriggerOutcomeCallable GetEventTriggerCallable(const GetEventTriggerRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetEventTrigger, request);
        }
 
        template<typename GetEventTriggerRequestT = Model::GetEventTriggerRequest>
        void GetEventTriggerAsync(const GetEventTriggerRequestT& request, const GetEventTriggerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetEventTrigger, request, handler, context);
        }
 
        virtual Model::GetIdentityResolutionJobOutcome GetIdentityResolutionJob(const Model::GetIdentityResolutionJobRequest& request) const;
 
        template<typename GetIdentityResolutionJobRequestT = Model::GetIdentityResolutionJobRequest>
        Model::GetIdentityResolutionJobOutcomeCallable GetIdentityResolutionJobCallable(const GetIdentityResolutionJobRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetIdentityResolutionJob, request);
        }
 
        template<typename GetIdentityResolutionJobRequestT = Model::GetIdentityResolutionJobRequest>
        void GetIdentityResolutionJobAsync(const GetIdentityResolutionJobRequestT& request, const GetIdentityResolutionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetIdentityResolutionJob, request, handler, context);
        }
 
        virtual Model::GetIntegrationOutcome GetIntegration(const Model::GetIntegrationRequest& request) const;
 
        template<typename GetIntegrationRequestT = Model::GetIntegrationRequest>
        Model::GetIntegrationOutcomeCallable GetIntegrationCallable(const GetIntegrationRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetIntegration, request);
        }
 
        template<typename GetIntegrationRequestT = Model::GetIntegrationRequest>
        void GetIntegrationAsync(const GetIntegrationRequestT& request, const GetIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetIntegration, request, handler, context);
        }
 
        virtual Model::GetMatchesOutcome GetMatches(const Model::GetMatchesRequest& request) const;
 
        template<typename GetMatchesRequestT = Model::GetMatchesRequest>
        Model::GetMatchesOutcomeCallable GetMatchesCallable(const GetMatchesRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetMatches, request);
        }
 
        template<typename GetMatchesRequestT = Model::GetMatchesRequest>
        void GetMatchesAsync(const GetMatchesRequestT& request, const GetMatchesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetMatches, request, handler, context);
        }
 
        virtual Model::GetProfileObjectTypeOutcome GetProfileObjectType(const Model::GetProfileObjectTypeRequest& request) const;
 
        template<typename GetProfileObjectTypeRequestT = Model::GetProfileObjectTypeRequest>
        Model::GetProfileObjectTypeOutcomeCallable GetProfileObjectTypeCallable(const GetProfileObjectTypeRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetProfileObjectType, request);
        }
 
        template<typename GetProfileObjectTypeRequestT = Model::GetProfileObjectTypeRequest>
        void GetProfileObjectTypeAsync(const GetProfileObjectTypeRequestT& request, const GetProfileObjectTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetProfileObjectType, request, handler, context);
        }
 
        virtual Model::GetProfileObjectTypeTemplateOutcome GetProfileObjectTypeTemplate(const Model::GetProfileObjectTypeTemplateRequest& request) const;
 
        template<typename GetProfileObjectTypeTemplateRequestT = Model::GetProfileObjectTypeTemplateRequest>
        Model::GetProfileObjectTypeTemplateOutcomeCallable GetProfileObjectTypeTemplateCallable(const GetProfileObjectTypeTemplateRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetProfileObjectTypeTemplate, request);
        }
 
        template<typename GetProfileObjectTypeTemplateRequestT = Model::GetProfileObjectTypeTemplateRequest>
        void GetProfileObjectTypeTemplateAsync(const GetProfileObjectTypeTemplateRequestT& request, const GetProfileObjectTypeTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetProfileObjectTypeTemplate, request, handler, context);
        }
 
        virtual Model::GetSegmentDefinitionOutcome GetSegmentDefinition(const Model::GetSegmentDefinitionRequest& request) const;
 
        template<typename GetSegmentDefinitionRequestT = Model::GetSegmentDefinitionRequest>
        Model::GetSegmentDefinitionOutcomeCallable GetSegmentDefinitionCallable(const GetSegmentDefinitionRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetSegmentDefinition, request);
        }
 
        template<typename GetSegmentDefinitionRequestT = Model::GetSegmentDefinitionRequest>
        void GetSegmentDefinitionAsync(const GetSegmentDefinitionRequestT& request, const GetSegmentDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetSegmentDefinition, request, handler, context);
        }
 
        virtual Model::GetSegmentEstimateOutcome GetSegmentEstimate(const Model::GetSegmentEstimateRequest& request) const;
 
        template<typename GetSegmentEstimateRequestT = Model::GetSegmentEstimateRequest>
        Model::GetSegmentEstimateOutcomeCallable GetSegmentEstimateCallable(const GetSegmentEstimateRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetSegmentEstimate, request);
        }
 
        template<typename GetSegmentEstimateRequestT = Model::GetSegmentEstimateRequest>
        void GetSegmentEstimateAsync(const GetSegmentEstimateRequestT& request, const GetSegmentEstimateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetSegmentEstimate, request, handler, context);
        }
 
        virtual Model::GetSegmentMembershipOutcome GetSegmentMembership(const Model::GetSegmentMembershipRequest& request) const;
 
        template<typename GetSegmentMembershipRequestT = Model::GetSegmentMembershipRequest>
        Model::GetSegmentMembershipOutcomeCallable GetSegmentMembershipCallable(const GetSegmentMembershipRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetSegmentMembership, request);
        }
 
        template<typename GetSegmentMembershipRequestT = Model::GetSegmentMembershipRequest>
        void GetSegmentMembershipAsync(const GetSegmentMembershipRequestT& request, const GetSegmentMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetSegmentMembership, request, handler, context);
        }
 
        virtual Model::GetSegmentSnapshotOutcome GetSegmentSnapshot(const Model::GetSegmentSnapshotRequest& request) const;
 
        template<typename GetSegmentSnapshotRequestT = Model::GetSegmentSnapshotRequest>
        Model::GetSegmentSnapshotOutcomeCallable GetSegmentSnapshotCallable(const GetSegmentSnapshotRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetSegmentSnapshot, request);
        }
 
        template<typename GetSegmentSnapshotRequestT = Model::GetSegmentSnapshotRequest>
        void GetSegmentSnapshotAsync(const GetSegmentSnapshotRequestT& request, const GetSegmentSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetSegmentSnapshot, request, handler, context);
        }
 
        virtual Model::GetSimilarProfilesOutcome GetSimilarProfiles(const Model::GetSimilarProfilesRequest& request) const;
 
        template<typename GetSimilarProfilesRequestT = Model::GetSimilarProfilesRequest>
        Model::GetSimilarProfilesOutcomeCallable GetSimilarProfilesCallable(const GetSimilarProfilesRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetSimilarProfiles, request);
        }
 
        template<typename GetSimilarProfilesRequestT = Model::GetSimilarProfilesRequest>
        void GetSimilarProfilesAsync(const GetSimilarProfilesRequestT& request, const GetSimilarProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetSimilarProfiles, request, handler, context);
        }
 
        virtual Model::GetUploadJobOutcome GetUploadJob(const Model::GetUploadJobRequest& request) const;
 
        template<typename GetUploadJobRequestT = Model::GetUploadJobRequest>
        Model::GetUploadJobOutcomeCallable GetUploadJobCallable(const GetUploadJobRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetUploadJob, request);
        }
 
        template<typename GetUploadJobRequestT = Model::GetUploadJobRequest>
        void GetUploadJobAsync(const GetUploadJobRequestT& request, const GetUploadJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetUploadJob, request, handler, context);
        }
 
        virtual Model::GetUploadJobPathOutcome GetUploadJobPath(const Model::GetUploadJobPathRequest& request) const;
 
        template<typename GetUploadJobPathRequestT = Model::GetUploadJobPathRequest>
        Model::GetUploadJobPathOutcomeCallable GetUploadJobPathCallable(const GetUploadJobPathRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetUploadJobPath, request);
        }
 
        template<typename GetUploadJobPathRequestT = Model::GetUploadJobPathRequest>
        void GetUploadJobPathAsync(const GetUploadJobPathRequestT& request, const GetUploadJobPathResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetUploadJobPath, request, handler, context);
        }
 
        virtual Model::GetWorkflowOutcome GetWorkflow(const Model::GetWorkflowRequest& request) const;
 
        template<typename GetWorkflowRequestT = Model::GetWorkflowRequest>
        Model::GetWorkflowOutcomeCallable GetWorkflowCallable(const GetWorkflowRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetWorkflow, request);
        }
 
        template<typename GetWorkflowRequestT = Model::GetWorkflowRequest>
        void GetWorkflowAsync(const GetWorkflowRequestT& request, const GetWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetWorkflow, request, handler, context);
        }
 
        virtual Model::GetWorkflowStepsOutcome GetWorkflowSteps(const Model::GetWorkflowStepsRequest& request) const;
 
        template<typename GetWorkflowStepsRequestT = Model::GetWorkflowStepsRequest>
        Model::GetWorkflowStepsOutcomeCallable GetWorkflowStepsCallable(const GetWorkflowStepsRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::GetWorkflowSteps, request);
        }
 
        template<typename GetWorkflowStepsRequestT = Model::GetWorkflowStepsRequest>
        void GetWorkflowStepsAsync(const GetWorkflowStepsRequestT& request, const GetWorkflowStepsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::GetWorkflowSteps, request, handler, context);
        }
 
        virtual Model::ListAccountIntegrationsOutcome ListAccountIntegrations(const Model::ListAccountIntegrationsRequest& request) const;
 
        template<typename ListAccountIntegrationsRequestT = Model::ListAccountIntegrationsRequest>
        Model::ListAccountIntegrationsOutcomeCallable ListAccountIntegrationsCallable(const ListAccountIntegrationsRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListAccountIntegrations, request);
        }
 
        template<typename ListAccountIntegrationsRequestT = Model::ListAccountIntegrationsRequest>
        void ListAccountIntegrationsAsync(const ListAccountIntegrationsRequestT& request, const ListAccountIntegrationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListAccountIntegrations, request, handler, context);
        }
 
        virtual Model::ListCalculatedAttributeDefinitionsOutcome ListCalculatedAttributeDefinitions(const Model::ListCalculatedAttributeDefinitionsRequest& request) const;
 
        template<typename ListCalculatedAttributeDefinitionsRequestT = Model::ListCalculatedAttributeDefinitionsRequest>
        Model::ListCalculatedAttributeDefinitionsOutcomeCallable ListCalculatedAttributeDefinitionsCallable(const ListCalculatedAttributeDefinitionsRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListCalculatedAttributeDefinitions, request);
        }
 
        template<typename ListCalculatedAttributeDefinitionsRequestT = Model::ListCalculatedAttributeDefinitionsRequest>
        void ListCalculatedAttributeDefinitionsAsync(const ListCalculatedAttributeDefinitionsRequestT& request, const ListCalculatedAttributeDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListCalculatedAttributeDefinitions, request, handler, context);
        }
 
        virtual Model::ListCalculatedAttributesForProfileOutcome ListCalculatedAttributesForProfile(const Model::ListCalculatedAttributesForProfileRequest& request) const;
 
        template<typename ListCalculatedAttributesForProfileRequestT = Model::ListCalculatedAttributesForProfileRequest>
        Model::ListCalculatedAttributesForProfileOutcomeCallable ListCalculatedAttributesForProfileCallable(const ListCalculatedAttributesForProfileRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListCalculatedAttributesForProfile, request);
        }
 
        template<typename ListCalculatedAttributesForProfileRequestT = Model::ListCalculatedAttributesForProfileRequest>
        void ListCalculatedAttributesForProfileAsync(const ListCalculatedAttributesForProfileRequestT& request, const ListCalculatedAttributesForProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListCalculatedAttributesForProfile, request, handler, context);
        }
 
        virtual Model::ListDomainLayoutsOutcome ListDomainLayouts(const Model::ListDomainLayoutsRequest& request) const;
 
        template<typename ListDomainLayoutsRequestT = Model::ListDomainLayoutsRequest>
        Model::ListDomainLayoutsOutcomeCallable ListDomainLayoutsCallable(const ListDomainLayoutsRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListDomainLayouts, request);
        }
 
        template<typename ListDomainLayoutsRequestT = Model::ListDomainLayoutsRequest>
        void ListDomainLayoutsAsync(const ListDomainLayoutsRequestT& request, const ListDomainLayoutsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListDomainLayouts, 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(&CustomerProfilesClient::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(&CustomerProfilesClient::ListDomains, request, handler, context);
        }
 
        virtual Model::ListEventStreamsOutcome ListEventStreams(const Model::ListEventStreamsRequest& request) const;
 
        template<typename ListEventStreamsRequestT = Model::ListEventStreamsRequest>
        Model::ListEventStreamsOutcomeCallable ListEventStreamsCallable(const ListEventStreamsRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListEventStreams, request);
        }
 
        template<typename ListEventStreamsRequestT = Model::ListEventStreamsRequest>
        void ListEventStreamsAsync(const ListEventStreamsRequestT& request, const ListEventStreamsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListEventStreams, request, handler, context);
        }
 
        virtual Model::ListEventTriggersOutcome ListEventTriggers(const Model::ListEventTriggersRequest& request) const;
 
        template<typename ListEventTriggersRequestT = Model::ListEventTriggersRequest>
        Model::ListEventTriggersOutcomeCallable ListEventTriggersCallable(const ListEventTriggersRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListEventTriggers, request);
        }
 
        template<typename ListEventTriggersRequestT = Model::ListEventTriggersRequest>
        void ListEventTriggersAsync(const ListEventTriggersRequestT& request, const ListEventTriggersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListEventTriggers, request, handler, context);
        }
 
        virtual Model::ListIdentityResolutionJobsOutcome ListIdentityResolutionJobs(const Model::ListIdentityResolutionJobsRequest& request) const;
 
        template<typename ListIdentityResolutionJobsRequestT = Model::ListIdentityResolutionJobsRequest>
        Model::ListIdentityResolutionJobsOutcomeCallable ListIdentityResolutionJobsCallable(const ListIdentityResolutionJobsRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListIdentityResolutionJobs, request);
        }
 
        template<typename ListIdentityResolutionJobsRequestT = Model::ListIdentityResolutionJobsRequest>
        void ListIdentityResolutionJobsAsync(const ListIdentityResolutionJobsRequestT& request, const ListIdentityResolutionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListIdentityResolutionJobs, request, handler, context);
        }
 
        virtual Model::ListIntegrationsOutcome ListIntegrations(const Model::ListIntegrationsRequest& request) const;
 
        template<typename ListIntegrationsRequestT = Model::ListIntegrationsRequest>
        Model::ListIntegrationsOutcomeCallable ListIntegrationsCallable(const ListIntegrationsRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListIntegrations, request);
        }
 
        template<typename ListIntegrationsRequestT = Model::ListIntegrationsRequest>
        void ListIntegrationsAsync(const ListIntegrationsRequestT& request, const ListIntegrationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListIntegrations, request, handler, context);
        }
 
        virtual Model::ListObjectTypeAttributesOutcome ListObjectTypeAttributes(const Model::ListObjectTypeAttributesRequest& request) const;
 
        template<typename ListObjectTypeAttributesRequestT = Model::ListObjectTypeAttributesRequest>
        Model::ListObjectTypeAttributesOutcomeCallable ListObjectTypeAttributesCallable(const ListObjectTypeAttributesRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListObjectTypeAttributes, request);
        }
 
        template<typename ListObjectTypeAttributesRequestT = Model::ListObjectTypeAttributesRequest>
        void ListObjectTypeAttributesAsync(const ListObjectTypeAttributesRequestT& request, const ListObjectTypeAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListObjectTypeAttributes, request, handler, context);
        }
 
        virtual Model::ListProfileAttributeValuesOutcome ListProfileAttributeValues(const Model::ListProfileAttributeValuesRequest& request) const;
 
        template<typename ListProfileAttributeValuesRequestT = Model::ListProfileAttributeValuesRequest>
        Model::ListProfileAttributeValuesOutcomeCallable ListProfileAttributeValuesCallable(const ListProfileAttributeValuesRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListProfileAttributeValues, request);
        }
 
        template<typename ListProfileAttributeValuesRequestT = Model::ListProfileAttributeValuesRequest>
        void ListProfileAttributeValuesAsync(const ListProfileAttributeValuesRequestT& request, const ListProfileAttributeValuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListProfileAttributeValues, request, handler, context);
        }
 
        virtual Model::ListProfileObjectTypeTemplatesOutcome ListProfileObjectTypeTemplates(const Model::ListProfileObjectTypeTemplatesRequest& request = {}) const;
 
        template<typename ListProfileObjectTypeTemplatesRequestT = Model::ListProfileObjectTypeTemplatesRequest>
        Model::ListProfileObjectTypeTemplatesOutcomeCallable ListProfileObjectTypeTemplatesCallable(const ListProfileObjectTypeTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListProfileObjectTypeTemplates, request);
        }
 
        template<typename ListProfileObjectTypeTemplatesRequestT = Model::ListProfileObjectTypeTemplatesRequest>
        void ListProfileObjectTypeTemplatesAsync(const ListProfileObjectTypeTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProfileObjectTypeTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListProfileObjectTypeTemplates, request, handler, context);
        }
 
        virtual Model::ListProfileObjectTypesOutcome ListProfileObjectTypes(const Model::ListProfileObjectTypesRequest& request) const;
 
        template<typename ListProfileObjectTypesRequestT = Model::ListProfileObjectTypesRequest>
        Model::ListProfileObjectTypesOutcomeCallable ListProfileObjectTypesCallable(const ListProfileObjectTypesRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListProfileObjectTypes, request);
        }
 
        template<typename ListProfileObjectTypesRequestT = Model::ListProfileObjectTypesRequest>
        void ListProfileObjectTypesAsync(const ListProfileObjectTypesRequestT& request, const ListProfileObjectTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListProfileObjectTypes, request, handler, context);
        }
 
        virtual Model::ListProfileObjectsOutcome ListProfileObjects(const Model::ListProfileObjectsRequest& request) const;
 
        template<typename ListProfileObjectsRequestT = Model::ListProfileObjectsRequest>
        Model::ListProfileObjectsOutcomeCallable ListProfileObjectsCallable(const ListProfileObjectsRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListProfileObjects, request);
        }
 
        template<typename ListProfileObjectsRequestT = Model::ListProfileObjectsRequest>
        void ListProfileObjectsAsync(const ListProfileObjectsRequestT& request, const ListProfileObjectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListProfileObjects, request, handler, context);
        }
 
        virtual Model::ListRuleBasedMatchesOutcome ListRuleBasedMatches(const Model::ListRuleBasedMatchesRequest& request) const;
 
        template<typename ListRuleBasedMatchesRequestT = Model::ListRuleBasedMatchesRequest>
        Model::ListRuleBasedMatchesOutcomeCallable ListRuleBasedMatchesCallable(const ListRuleBasedMatchesRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListRuleBasedMatches, request);
        }
 
        template<typename ListRuleBasedMatchesRequestT = Model::ListRuleBasedMatchesRequest>
        void ListRuleBasedMatchesAsync(const ListRuleBasedMatchesRequestT& request, const ListRuleBasedMatchesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListRuleBasedMatches, request, handler, context);
        }
 
        virtual Model::ListSegmentDefinitionsOutcome ListSegmentDefinitions(const Model::ListSegmentDefinitionsRequest& request) const;
 
        template<typename ListSegmentDefinitionsRequestT = Model::ListSegmentDefinitionsRequest>
        Model::ListSegmentDefinitionsOutcomeCallable ListSegmentDefinitionsCallable(const ListSegmentDefinitionsRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListSegmentDefinitions, request);
        }
 
        template<typename ListSegmentDefinitionsRequestT = Model::ListSegmentDefinitionsRequest>
        void ListSegmentDefinitionsAsync(const ListSegmentDefinitionsRequestT& request, const ListSegmentDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListSegmentDefinitions, 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(&CustomerProfilesClient::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(&CustomerProfilesClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListUploadJobsOutcome ListUploadJobs(const Model::ListUploadJobsRequest& request) const;
 
        template<typename ListUploadJobsRequestT = Model::ListUploadJobsRequest>
        Model::ListUploadJobsOutcomeCallable ListUploadJobsCallable(const ListUploadJobsRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListUploadJobs, request);
        }
 
        template<typename ListUploadJobsRequestT = Model::ListUploadJobsRequest>
        void ListUploadJobsAsync(const ListUploadJobsRequestT& request, const ListUploadJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListUploadJobs, request, handler, context);
        }
 
        virtual Model::ListWorkflowsOutcome ListWorkflows(const Model::ListWorkflowsRequest& request) const;
 
        template<typename ListWorkflowsRequestT = Model::ListWorkflowsRequest>
        Model::ListWorkflowsOutcomeCallable ListWorkflowsCallable(const ListWorkflowsRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::ListWorkflows, request);
        }
 
        template<typename ListWorkflowsRequestT = Model::ListWorkflowsRequest>
        void ListWorkflowsAsync(const ListWorkflowsRequestT& request, const ListWorkflowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::ListWorkflows, request, handler, context);
        }
 
        virtual Model::MergeProfilesOutcome MergeProfiles(const Model::MergeProfilesRequest& request) const;
 
        template<typename MergeProfilesRequestT = Model::MergeProfilesRequest>
        Model::MergeProfilesOutcomeCallable MergeProfilesCallable(const MergeProfilesRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::MergeProfiles, request);
        }
 
        template<typename MergeProfilesRequestT = Model::MergeProfilesRequest>
        void MergeProfilesAsync(const MergeProfilesRequestT& request, const MergeProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::MergeProfiles, request, handler, context);
        }
 
        virtual Model::PutIntegrationOutcome PutIntegration(const Model::PutIntegrationRequest& request) const;
 
        template<typename PutIntegrationRequestT = Model::PutIntegrationRequest>
        Model::PutIntegrationOutcomeCallable PutIntegrationCallable(const PutIntegrationRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::PutIntegration, request);
        }
 
        template<typename PutIntegrationRequestT = Model::PutIntegrationRequest>
        void PutIntegrationAsync(const PutIntegrationRequestT& request, const PutIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::PutIntegration, request, handler, context);
        }
 
        virtual Model::PutProfileObjectOutcome PutProfileObject(const Model::PutProfileObjectRequest& request) const;
 
        template<typename PutProfileObjectRequestT = Model::PutProfileObjectRequest>
        Model::PutProfileObjectOutcomeCallable PutProfileObjectCallable(const PutProfileObjectRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::PutProfileObject, request);
        }
 
        template<typename PutProfileObjectRequestT = Model::PutProfileObjectRequest>
        void PutProfileObjectAsync(const PutProfileObjectRequestT& request, const PutProfileObjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::PutProfileObject, request, handler, context);
        }
 
        virtual Model::PutProfileObjectTypeOutcome PutProfileObjectType(const Model::PutProfileObjectTypeRequest& request) const;
 
        template<typename PutProfileObjectTypeRequestT = Model::PutProfileObjectTypeRequest>
        Model::PutProfileObjectTypeOutcomeCallable PutProfileObjectTypeCallable(const PutProfileObjectTypeRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::PutProfileObjectType, request);
        }
 
        template<typename PutProfileObjectTypeRequestT = Model::PutProfileObjectTypeRequest>
        void PutProfileObjectTypeAsync(const PutProfileObjectTypeRequestT& request, const PutProfileObjectTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::PutProfileObjectType, request, handler, context);
        }
 
        virtual Model::SearchProfilesOutcome SearchProfiles(const Model::SearchProfilesRequest& request) const;
 
        template<typename SearchProfilesRequestT = Model::SearchProfilesRequest>
        Model::SearchProfilesOutcomeCallable SearchProfilesCallable(const SearchProfilesRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::SearchProfiles, request);
        }
 
        template<typename SearchProfilesRequestT = Model::SearchProfilesRequest>
        void SearchProfilesAsync(const SearchProfilesRequestT& request, const SearchProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::SearchProfiles, request, handler, context);
        }
 
        virtual Model::StartUploadJobOutcome StartUploadJob(const Model::StartUploadJobRequest& request) const;
 
        template<typename StartUploadJobRequestT = Model::StartUploadJobRequest>
        Model::StartUploadJobOutcomeCallable StartUploadJobCallable(const StartUploadJobRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::StartUploadJob, request);
        }
 
        template<typename StartUploadJobRequestT = Model::StartUploadJobRequest>
        void StartUploadJobAsync(const StartUploadJobRequestT& request, const StartUploadJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::StartUploadJob, request, handler, context);
        }
 
        virtual Model::StopUploadJobOutcome StopUploadJob(const Model::StopUploadJobRequest& request) const;
 
        template<typename StopUploadJobRequestT = Model::StopUploadJobRequest>
        Model::StopUploadJobOutcomeCallable StopUploadJobCallable(const StopUploadJobRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::StopUploadJob, request);
        }
 
        template<typename StopUploadJobRequestT = Model::StopUploadJobRequest>
        void StopUploadJobAsync(const StopUploadJobRequestT& request, const StopUploadJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::StopUploadJob, 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(&CustomerProfilesClient::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(&CustomerProfilesClient::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(&CustomerProfilesClient::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(&CustomerProfilesClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateCalculatedAttributeDefinitionOutcome UpdateCalculatedAttributeDefinition(const Model::UpdateCalculatedAttributeDefinitionRequest& request) const;
 
        template<typename UpdateCalculatedAttributeDefinitionRequestT = Model::UpdateCalculatedAttributeDefinitionRequest>
        Model::UpdateCalculatedAttributeDefinitionOutcomeCallable UpdateCalculatedAttributeDefinitionCallable(const UpdateCalculatedAttributeDefinitionRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::UpdateCalculatedAttributeDefinition, request);
        }
 
        template<typename UpdateCalculatedAttributeDefinitionRequestT = Model::UpdateCalculatedAttributeDefinitionRequest>
        void UpdateCalculatedAttributeDefinitionAsync(const UpdateCalculatedAttributeDefinitionRequestT& request, const UpdateCalculatedAttributeDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::UpdateCalculatedAttributeDefinition, 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(&CustomerProfilesClient::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(&CustomerProfilesClient::UpdateDomain, request, handler, context);
        }
 
        virtual Model::UpdateDomainLayoutOutcome UpdateDomainLayout(const Model::UpdateDomainLayoutRequest& request) const;
 
        template<typename UpdateDomainLayoutRequestT = Model::UpdateDomainLayoutRequest>
        Model::UpdateDomainLayoutOutcomeCallable UpdateDomainLayoutCallable(const UpdateDomainLayoutRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::UpdateDomainLayout, request);
        }
 
        template<typename UpdateDomainLayoutRequestT = Model::UpdateDomainLayoutRequest>
        void UpdateDomainLayoutAsync(const UpdateDomainLayoutRequestT& request, const UpdateDomainLayoutResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::UpdateDomainLayout, request, handler, context);
        }
 
        virtual Model::UpdateEventTriggerOutcome UpdateEventTrigger(const Model::UpdateEventTriggerRequest& request) const;
 
        template<typename UpdateEventTriggerRequestT = Model::UpdateEventTriggerRequest>
        Model::UpdateEventTriggerOutcomeCallable UpdateEventTriggerCallable(const UpdateEventTriggerRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::UpdateEventTrigger, request);
        }
 
        template<typename UpdateEventTriggerRequestT = Model::UpdateEventTriggerRequest>
        void UpdateEventTriggerAsync(const UpdateEventTriggerRequestT& request, const UpdateEventTriggerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::UpdateEventTrigger, request, handler, context);
        }
 
        virtual Model::UpdateProfileOutcome UpdateProfile(const Model::UpdateProfileRequest& request) const;
 
        template<typename UpdateProfileRequestT = Model::UpdateProfileRequest>
        Model::UpdateProfileOutcomeCallable UpdateProfileCallable(const UpdateProfileRequestT& request) const
        {
            return SubmitCallable(&CustomerProfilesClient::UpdateProfile, request);
        }
 
        template<typename UpdateProfileRequestT = Model::UpdateProfileRequest>
        void UpdateProfileAsync(const UpdateProfileRequestT& request, const UpdateProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CustomerProfilesClient::UpdateProfile, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CustomerProfilesEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CustomerProfilesClient>;
      void init(const CustomerProfilesClientConfiguration& clientConfiguration);
 
      CustomerProfilesClientConfiguration m_clientConfiguration;
      std::shared_ptr<CustomerProfilesEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CustomerProfiles
} // namespace Aws