CustomerProfilesClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/customer-profiles/CustomerProfilesServiceClientModel.h>
#include <aws/customer-profiles/CustomerProfiles_EXPORTS.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::CreateRecommenderOutcome CreateRecommender(const Model::CreateRecommenderRequest& request) const;
 
  template <typename CreateRecommenderRequestT = Model::CreateRecommenderRequest>
  Model::CreateRecommenderOutcomeCallable CreateRecommenderCallable(const CreateRecommenderRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::CreateRecommender, request);
  }
 
  template <typename CreateRecommenderRequestT = Model::CreateRecommenderRequest>
  void CreateRecommenderAsync(const CreateRecommenderRequestT& request, const CreateRecommenderResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::CreateRecommender, 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::DeleteDomainObjectTypeOutcome DeleteDomainObjectType(const Model::DeleteDomainObjectTypeRequest& request) const;
 
  template <typename DeleteDomainObjectTypeRequestT = Model::DeleteDomainObjectTypeRequest>
  Model::DeleteDomainObjectTypeOutcomeCallable DeleteDomainObjectTypeCallable(const DeleteDomainObjectTypeRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::DeleteDomainObjectType, request);
  }
 
  template <typename DeleteDomainObjectTypeRequestT = Model::DeleteDomainObjectTypeRequest>
  void DeleteDomainObjectTypeAsync(const DeleteDomainObjectTypeRequestT& request,
                                   const DeleteDomainObjectTypeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::DeleteDomainObjectType, 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::DeleteRecommenderOutcome DeleteRecommender(const Model::DeleteRecommenderRequest& request) const;
 
  template <typename DeleteRecommenderRequestT = Model::DeleteRecommenderRequest>
  Model::DeleteRecommenderOutcomeCallable DeleteRecommenderCallable(const DeleteRecommenderRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::DeleteRecommender, request);
  }
 
  template <typename DeleteRecommenderRequestT = Model::DeleteRecommenderRequest>
  void DeleteRecommenderAsync(const DeleteRecommenderRequestT& request, const DeleteRecommenderResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::DeleteRecommender, 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::GetDomainObjectTypeOutcome GetDomainObjectType(const Model::GetDomainObjectTypeRequest& request) const;
 
  template <typename GetDomainObjectTypeRequestT = Model::GetDomainObjectTypeRequest>
  Model::GetDomainObjectTypeOutcomeCallable GetDomainObjectTypeCallable(const GetDomainObjectTypeRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::GetDomainObjectType, request);
  }
 
  template <typename GetDomainObjectTypeRequestT = Model::GetDomainObjectTypeRequest>
  void GetDomainObjectTypeAsync(const GetDomainObjectTypeRequestT& request, const GetDomainObjectTypeResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::GetDomainObjectType, 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::GetObjectTypeAttributeStatisticsOutcome GetObjectTypeAttributeStatistics(
      const Model::GetObjectTypeAttributeStatisticsRequest& request) const;
 
  template <typename GetObjectTypeAttributeStatisticsRequestT = Model::GetObjectTypeAttributeStatisticsRequest>
  Model::GetObjectTypeAttributeStatisticsOutcomeCallable GetObjectTypeAttributeStatisticsCallable(
      const GetObjectTypeAttributeStatisticsRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::GetObjectTypeAttributeStatistics, request);
  }
 
  template <typename GetObjectTypeAttributeStatisticsRequestT = Model::GetObjectTypeAttributeStatisticsRequest>
  void GetObjectTypeAttributeStatisticsAsync(const GetObjectTypeAttributeStatisticsRequestT& request,
                                             const GetObjectTypeAttributeStatisticsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::GetObjectTypeAttributeStatistics, request, handler, context);
  }
 
  virtual Model::GetProfileHistoryRecordOutcome GetProfileHistoryRecord(const Model::GetProfileHistoryRecordRequest& request) const;
 
  template <typename GetProfileHistoryRecordRequestT = Model::GetProfileHistoryRecordRequest>
  Model::GetProfileHistoryRecordOutcomeCallable GetProfileHistoryRecordCallable(const GetProfileHistoryRecordRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::GetProfileHistoryRecord, request);
  }
 
  template <typename GetProfileHistoryRecordRequestT = Model::GetProfileHistoryRecordRequest>
  void GetProfileHistoryRecordAsync(const GetProfileHistoryRecordRequestT& request,
                                    const GetProfileHistoryRecordResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::GetProfileHistoryRecord, 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::GetProfileRecommendationsOutcome GetProfileRecommendations(const Model::GetProfileRecommendationsRequest& request) const;
 
  template <typename GetProfileRecommendationsRequestT = Model::GetProfileRecommendationsRequest>
  Model::GetProfileRecommendationsOutcomeCallable GetProfileRecommendationsCallable(
      const GetProfileRecommendationsRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::GetProfileRecommendations, request);
  }
 
  template <typename GetProfileRecommendationsRequestT = Model::GetProfileRecommendationsRequest>
  void GetProfileRecommendationsAsync(const GetProfileRecommendationsRequestT& request,
                                      const GetProfileRecommendationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::GetProfileRecommendations, request, handler, context);
  }
 
  virtual Model::GetRecommenderOutcome GetRecommender(const Model::GetRecommenderRequest& request) const;
 
  template <typename GetRecommenderRequestT = Model::GetRecommenderRequest>
  Model::GetRecommenderOutcomeCallable GetRecommenderCallable(const GetRecommenderRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::GetRecommender, request);
  }
 
  template <typename GetRecommenderRequestT = Model::GetRecommenderRequest>
  void GetRecommenderAsync(const GetRecommenderRequestT& request, const GetRecommenderResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::GetRecommender, 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::ListDomainObjectTypesOutcome ListDomainObjectTypes(const Model::ListDomainObjectTypesRequest& request) const;
 
  template <typename ListDomainObjectTypesRequestT = Model::ListDomainObjectTypesRequest>
  Model::ListDomainObjectTypesOutcomeCallable ListDomainObjectTypesCallable(const ListDomainObjectTypesRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::ListDomainObjectTypes, request);
  }
 
  template <typename ListDomainObjectTypesRequestT = Model::ListDomainObjectTypesRequest>
  void ListDomainObjectTypesAsync(const ListDomainObjectTypesRequestT& request, const ListDomainObjectTypesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::ListDomainObjectTypes, 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::ListObjectTypeAttributeValuesOutcome ListObjectTypeAttributeValues(
      const Model::ListObjectTypeAttributeValuesRequest& request) const;
 
  template <typename ListObjectTypeAttributeValuesRequestT = Model::ListObjectTypeAttributeValuesRequest>
  Model::ListObjectTypeAttributeValuesOutcomeCallable ListObjectTypeAttributeValuesCallable(
      const ListObjectTypeAttributeValuesRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::ListObjectTypeAttributeValues, request);
  }
 
  template <typename ListObjectTypeAttributeValuesRequestT = Model::ListObjectTypeAttributeValuesRequest>
  void ListObjectTypeAttributeValuesAsync(const ListObjectTypeAttributeValuesRequestT& request,
                                          const ListObjectTypeAttributeValuesResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::ListObjectTypeAttributeValues, 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::ListProfileHistoryRecordsOutcome ListProfileHistoryRecords(const Model::ListProfileHistoryRecordsRequest& request) const;
 
  template <typename ListProfileHistoryRecordsRequestT = Model::ListProfileHistoryRecordsRequest>
  Model::ListProfileHistoryRecordsOutcomeCallable ListProfileHistoryRecordsCallable(
      const ListProfileHistoryRecordsRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::ListProfileHistoryRecords, request);
  }
 
  template <typename ListProfileHistoryRecordsRequestT = Model::ListProfileHistoryRecordsRequest>
  void ListProfileHistoryRecordsAsync(const ListProfileHistoryRecordsRequestT& request,
                                      const ListProfileHistoryRecordsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::ListProfileHistoryRecords, 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::ListRecommenderRecipesOutcome ListRecommenderRecipes(const Model::ListRecommenderRecipesRequest& request = {}) const;
 
  template <typename ListRecommenderRecipesRequestT = Model::ListRecommenderRecipesRequest>
  Model::ListRecommenderRecipesOutcomeCallable ListRecommenderRecipesCallable(const ListRecommenderRecipesRequestT& request = {}) const {
    return SubmitCallable(&CustomerProfilesClient::ListRecommenderRecipes, request);
  }
 
  template <typename ListRecommenderRecipesRequestT = Model::ListRecommenderRecipesRequest>
  void ListRecommenderRecipesAsync(const ListRecommenderRecipesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListRecommenderRecipesRequestT& request = {}) const {
    return SubmitAsync(&CustomerProfilesClient::ListRecommenderRecipes, request, handler, context);
  }
 
  virtual Model::ListRecommendersOutcome ListRecommenders(const Model::ListRecommendersRequest& request) const;
 
  template <typename ListRecommendersRequestT = Model::ListRecommendersRequest>
  Model::ListRecommendersOutcomeCallable ListRecommendersCallable(const ListRecommendersRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::ListRecommenders, request);
  }
 
  template <typename ListRecommendersRequestT = Model::ListRecommendersRequest>
  void ListRecommendersAsync(const ListRecommendersRequestT& request, const ListRecommendersResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::ListRecommenders, 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::PutDomainObjectTypeOutcome PutDomainObjectType(const Model::PutDomainObjectTypeRequest& request) const;
 
  template <typename PutDomainObjectTypeRequestT = Model::PutDomainObjectTypeRequest>
  Model::PutDomainObjectTypeOutcomeCallable PutDomainObjectTypeCallable(const PutDomainObjectTypeRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::PutDomainObjectType, request);
  }
 
  template <typename PutDomainObjectTypeRequestT = Model::PutDomainObjectTypeRequest>
  void PutDomainObjectTypeAsync(const PutDomainObjectTypeRequestT& request, const PutDomainObjectTypeResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::PutDomainObjectType, 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::StartRecommenderOutcome StartRecommender(const Model::StartRecommenderRequest& request) const;
 
  template <typename StartRecommenderRequestT = Model::StartRecommenderRequest>
  Model::StartRecommenderOutcomeCallable StartRecommenderCallable(const StartRecommenderRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::StartRecommender, request);
  }
 
  template <typename StartRecommenderRequestT = Model::StartRecommenderRequest>
  void StartRecommenderAsync(const StartRecommenderRequestT& request, const StartRecommenderResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::StartRecommender, 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::StopRecommenderOutcome StopRecommender(const Model::StopRecommenderRequest& request) const;
 
  template <typename StopRecommenderRequestT = Model::StopRecommenderRequest>
  Model::StopRecommenderOutcomeCallable StopRecommenderCallable(const StopRecommenderRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::StopRecommender, request);
  }
 
  template <typename StopRecommenderRequestT = Model::StopRecommenderRequest>
  void StopRecommenderAsync(const StopRecommenderRequestT& request, const StopRecommenderResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::StopRecommender, 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);
  }
 
  virtual Model::UpdateRecommenderOutcome UpdateRecommender(const Model::UpdateRecommenderRequest& request) const;
 
  template <typename UpdateRecommenderRequestT = Model::UpdateRecommenderRequest>
  Model::UpdateRecommenderOutcomeCallable UpdateRecommenderCallable(const UpdateRecommenderRequestT& request) const {
    return SubmitCallable(&CustomerProfilesClient::UpdateRecommender, request);
  }
 
  template <typename UpdateRecommenderRequestT = Model::UpdateRecommenderRequest>
  void UpdateRecommenderAsync(const UpdateRecommenderRequestT& request, const UpdateRecommenderResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CustomerProfilesClient::UpdateRecommender, 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