/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace CustomerProfiles { /** * Amazon Connect Customer Profiles

Amazon Connect Customer * Profiles is a unified customer profile for your contact center that has * pre-built connectors powered by AppFlow that make it easy to combine customer * information from third party applications, such as Salesforce (CRM), ServiceNow * (ITSM), and your enterprise resource planning (ERP), with contact history from * your Amazon Connect contact center. If you're new to Amazon Connect, you might * find it helpful to review the Amazon Connect * Administrator Guide.

*/ class AWS_CUSTOMERPROFILES_API CustomerProfilesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef CustomerProfilesClientConfiguration ClientConfigurationType; typedef CustomerProfilesEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ CustomerProfilesClient(const Aws::CustomerProfiles::CustomerProfilesClientConfiguration& clientConfiguration = Aws::CustomerProfiles::CustomerProfilesClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ CustomerProfilesClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::CustomerProfiles::CustomerProfilesClientConfiguration& clientConfiguration = Aws::CustomerProfiles::CustomerProfilesClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ CustomerProfilesClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::CustomerProfiles::CustomerProfilesClientConfiguration& clientConfiguration = Aws::CustomerProfiles::CustomerProfilesClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ CustomerProfilesClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ CustomerProfilesClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ CustomerProfilesClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~CustomerProfilesClient(); /** *

Associates a new key value with a specific profile, such as a Contact Record * ContactId.

A profile object can have a single unique key and any number * of additional keys that can be used to identify the profile that it belongs * to.

See Also:

AWS * API Reference

*/ virtual Model::AddProfileKeyOutcome AddProfileKey(const Model::AddProfileKeyRequest& request) const; /** * A Callable wrapper for AddProfileKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddProfileKeyOutcomeCallable AddProfileKeyCallable(const AddProfileKeyRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::AddProfileKey, request); } /** * An Async wrapper for AddProfileKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddProfileKeyAsync(const AddProfileKeyRequestT& request, const AddProfileKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::AddProfileKey, request, handler, context); } /** *

Creates a new calculated attribute definition. After creation, new object * data ingested into Customer Profiles will be included in the calculated * attribute, which can be retrieved for a profile using the GetCalculatedAttributeForProfile * API. Defining a calculated attribute makes it available for all profiles within * a domain. Each calculated attribute can only reference one * ObjectType and at most, two fields from that * ObjectType.

See Also:

AWS * API Reference

*/ virtual Model::CreateCalculatedAttributeDefinitionOutcome CreateCalculatedAttributeDefinition(const Model::CreateCalculatedAttributeDefinitionRequest& request) const; /** * A Callable wrapper for CreateCalculatedAttributeDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCalculatedAttributeDefinitionOutcomeCallable CreateCalculatedAttributeDefinitionCallable(const CreateCalculatedAttributeDefinitionRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::CreateCalculatedAttributeDefinition, request); } /** * An Async wrapper for CreateCalculatedAttributeDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCalculatedAttributeDefinitionAsync(const CreateCalculatedAttributeDefinitionRequestT& request, const CreateCalculatedAttributeDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::CreateCalculatedAttributeDefinition, request, handler, context); } /** *

Creates a domain, which is a container for all customer data, such as * customer profile attributes, object types, profile keys, and encryption keys. * You can create multiple domains, and each domain can have multiple third-party * integrations.

Each Amazon Connect instance can be associated with only * one domain. Multiple Amazon Connect instances can be associated with one * domain.

Use this API or UpdateDomain * to enable identity * resolution: set Matching to true.

To prevent * cross-service impersonation when you call this API, see Cross-service * confused deputy prevention for sample policies that you should apply. *

See Also:

AWS * API Reference

*/ virtual Model::CreateDomainOutcome CreateDomain(const Model::CreateDomainRequest& request) const; /** * A Callable wrapper for CreateDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDomainOutcomeCallable CreateDomainCallable(const CreateDomainRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::CreateDomain, request); } /** * An Async wrapper for CreateDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDomainAsync(const CreateDomainRequestT& request, const CreateDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::CreateDomain, request, handler, context); } /** *

Creates an event stream, which is a subscription to real-time events, such as * when profiles are created and updated through Amazon Connect Customer * Profiles.

Each event stream can be associated with only one Kinesis Data * Stream destination in the same region and Amazon Web Services account as the * customer profiles domain

See Also:

AWS * API Reference

*/ virtual Model::CreateEventStreamOutcome CreateEventStream(const Model::CreateEventStreamRequest& request) const; /** * A Callable wrapper for CreateEventStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEventStreamOutcomeCallable CreateEventStreamCallable(const CreateEventStreamRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::CreateEventStream, request); } /** * An Async wrapper for CreateEventStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEventStreamAsync(const CreateEventStreamRequestT& request, const CreateEventStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::CreateEventStream, request, handler, context); } /** *

Creates an integration workflow. An integration workflow is an async process * which ingests historic data and sets up an integration for ongoing updates. The * supported Amazon AppFlow sources are Salesforce, ServiceNow, and Marketo. *

See Also:

AWS * API Reference

*/ virtual Model::CreateIntegrationWorkflowOutcome CreateIntegrationWorkflow(const Model::CreateIntegrationWorkflowRequest& request) const; /** * A Callable wrapper for CreateIntegrationWorkflow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateIntegrationWorkflowOutcomeCallable CreateIntegrationWorkflowCallable(const CreateIntegrationWorkflowRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::CreateIntegrationWorkflow, request); } /** * An Async wrapper for CreateIntegrationWorkflow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateIntegrationWorkflowAsync(const CreateIntegrationWorkflowRequestT& request, const CreateIntegrationWorkflowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::CreateIntegrationWorkflow, request, handler, context); } /** *

Creates a standard profile.

A standard profile represents the * following attributes for a customer profile in a domain.

See * Also:

AWS * API Reference

*/ virtual Model::CreateProfileOutcome CreateProfile(const Model::CreateProfileRequest& request) const; /** * A Callable wrapper for CreateProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateProfileOutcomeCallable CreateProfileCallable(const CreateProfileRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::CreateProfile, request); } /** * An Async wrapper for CreateProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateProfileAsync(const CreateProfileRequestT& request, const CreateProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::CreateProfile, request, handler, context); } /** *

Deletes an existing calculated attribute definition. Note that deleting a * default calculated attribute is possible, however once deleted, you will be * unable to undo that action and will need to recreate it on your own using the * CreateCalculatedAttributeDefinition API if you want it back.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteCalculatedAttributeDefinitionOutcome DeleteCalculatedAttributeDefinition(const Model::DeleteCalculatedAttributeDefinitionRequest& request) const; /** * A Callable wrapper for DeleteCalculatedAttributeDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCalculatedAttributeDefinitionOutcomeCallable DeleteCalculatedAttributeDefinitionCallable(const DeleteCalculatedAttributeDefinitionRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::DeleteCalculatedAttributeDefinition, request); } /** * An Async wrapper for DeleteCalculatedAttributeDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCalculatedAttributeDefinitionAsync(const DeleteCalculatedAttributeDefinitionRequestT& request, const DeleteCalculatedAttributeDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::DeleteCalculatedAttributeDefinition, request, handler, context); } /** *

Deletes a specific domain and all of its customer data, such as customer * profile attributes and their related objects.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest& request) const; /** * A Callable wrapper for DeleteDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::DeleteDomain, request); } /** * An Async wrapper for DeleteDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDomainAsync(const DeleteDomainRequestT& request, const DeleteDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::DeleteDomain, request, handler, context); } /** *

Disables and deletes the specified event stream.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteEventStreamOutcome DeleteEventStream(const Model::DeleteEventStreamRequest& request) const; /** * A Callable wrapper for DeleteEventStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEventStreamOutcomeCallable DeleteEventStreamCallable(const DeleteEventStreamRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::DeleteEventStream, request); } /** * An Async wrapper for DeleteEventStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEventStreamAsync(const DeleteEventStreamRequestT& request, const DeleteEventStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::DeleteEventStream, request, handler, context); } /** *

Removes an integration from a specific domain.

See Also:

AWS * API Reference

*/ virtual Model::DeleteIntegrationOutcome DeleteIntegration(const Model::DeleteIntegrationRequest& request) const; /** * A Callable wrapper for DeleteIntegration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteIntegrationOutcomeCallable DeleteIntegrationCallable(const DeleteIntegrationRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::DeleteIntegration, request); } /** * An Async wrapper for DeleteIntegration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteIntegrationAsync(const DeleteIntegrationRequestT& request, const DeleteIntegrationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::DeleteIntegration, request, handler, context); } /** *

Deletes the standard customer profile and all data pertaining to the * profile.

See Also:

AWS * API Reference

*/ virtual Model::DeleteProfileOutcome DeleteProfile(const Model::DeleteProfileRequest& request) const; /** * A Callable wrapper for DeleteProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteProfileOutcomeCallable DeleteProfileCallable(const DeleteProfileRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::DeleteProfile, request); } /** * An Async wrapper for DeleteProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteProfileAsync(const DeleteProfileRequestT& request, const DeleteProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::DeleteProfile, request, handler, context); } /** *

Removes a searchable key from a customer profile.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteProfileKeyOutcome DeleteProfileKey(const Model::DeleteProfileKeyRequest& request) const; /** * A Callable wrapper for DeleteProfileKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteProfileKeyOutcomeCallable DeleteProfileKeyCallable(const DeleteProfileKeyRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::DeleteProfileKey, request); } /** * An Async wrapper for DeleteProfileKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteProfileKeyAsync(const DeleteProfileKeyRequestT& request, const DeleteProfileKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::DeleteProfileKey, request, handler, context); } /** *

Removes an object associated with a profile of a given * ProfileObjectType.

See Also:

AWS * API Reference

*/ virtual Model::DeleteProfileObjectOutcome DeleteProfileObject(const Model::DeleteProfileObjectRequest& request) const; /** * A Callable wrapper for DeleteProfileObject that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteProfileObjectOutcomeCallable DeleteProfileObjectCallable(const DeleteProfileObjectRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::DeleteProfileObject, request); } /** * An Async wrapper for DeleteProfileObject that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteProfileObjectAsync(const DeleteProfileObjectRequestT& request, const DeleteProfileObjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::DeleteProfileObject, request, handler, context); } /** *

Removes a ProfileObjectType from a specific domain as well as removes all the * ProfileObjects of that type. It also disables integrations from this specific * ProfileObjectType. In addition, it scrubs all of the fields of the standard * profile that were populated from this ProfileObjectType.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteProfileObjectTypeOutcome DeleteProfileObjectType(const Model::DeleteProfileObjectTypeRequest& request) const; /** * A Callable wrapper for DeleteProfileObjectType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteProfileObjectTypeOutcomeCallable DeleteProfileObjectTypeCallable(const DeleteProfileObjectTypeRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::DeleteProfileObjectType, request); } /** * An Async wrapper for DeleteProfileObjectType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteProfileObjectTypeAsync(const DeleteProfileObjectTypeRequestT& request, const DeleteProfileObjectTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::DeleteProfileObjectType, request, handler, context); } /** *

Deletes the specified workflow and all its corresponding resources. This is * an async process.

See Also:

AWS * API Reference

*/ virtual Model::DeleteWorkflowOutcome DeleteWorkflow(const Model::DeleteWorkflowRequest& request) const; /** * A Callable wrapper for DeleteWorkflow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteWorkflowOutcomeCallable DeleteWorkflowCallable(const DeleteWorkflowRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::DeleteWorkflow, request); } /** * An Async wrapper for DeleteWorkflow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteWorkflowAsync(const DeleteWorkflowRequestT& request, const DeleteWorkflowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::DeleteWorkflow, request, handler, context); } /** *

Tests the auto-merging settings of your Identity Resolution Job without * merging your data. It randomly selects a sample of matching groups from the * existing matching results, and applies the automerging settings that you * provided. You can then view the number of profiles in the sample, the number of * matches, and the number of profiles identified to be merged. This enables you to * evaluate the accuracy of the attributes in your matching list.

You can't * view which profiles are matched and would be merged.

We * strongly recommend you use this API to do a dry run of the automerging process * before running the Identity Resolution Job. Include at least two matching * attributes. If your matching list includes too few attributes (such as only * FirstName or only LastName), there may be a large * number of matches. This increases the chances of erroneous merges.

*

See Also:

AWS * API Reference

*/ virtual Model::GetAutoMergingPreviewOutcome GetAutoMergingPreview(const Model::GetAutoMergingPreviewRequest& request) const; /** * A Callable wrapper for GetAutoMergingPreview that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAutoMergingPreviewOutcomeCallable GetAutoMergingPreviewCallable(const GetAutoMergingPreviewRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::GetAutoMergingPreview, request); } /** * An Async wrapper for GetAutoMergingPreview that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAutoMergingPreviewAsync(const GetAutoMergingPreviewRequestT& request, const GetAutoMergingPreviewResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::GetAutoMergingPreview, request, handler, context); } /** *

Provides more information on a calculated attribute definition for Customer * Profiles.

See Also:

AWS * API Reference

*/ virtual Model::GetCalculatedAttributeDefinitionOutcome GetCalculatedAttributeDefinition(const Model::GetCalculatedAttributeDefinitionRequest& request) const; /** * A Callable wrapper for GetCalculatedAttributeDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCalculatedAttributeDefinitionOutcomeCallable GetCalculatedAttributeDefinitionCallable(const GetCalculatedAttributeDefinitionRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::GetCalculatedAttributeDefinition, request); } /** * An Async wrapper for GetCalculatedAttributeDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCalculatedAttributeDefinitionAsync(const GetCalculatedAttributeDefinitionRequestT& request, const GetCalculatedAttributeDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::GetCalculatedAttributeDefinition, request, handler, context); } /** *

Retrieve a calculated attribute for a customer profile.

See * Also:

AWS * API Reference

*/ virtual Model::GetCalculatedAttributeForProfileOutcome GetCalculatedAttributeForProfile(const Model::GetCalculatedAttributeForProfileRequest& request) const; /** * A Callable wrapper for GetCalculatedAttributeForProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCalculatedAttributeForProfileOutcomeCallable GetCalculatedAttributeForProfileCallable(const GetCalculatedAttributeForProfileRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::GetCalculatedAttributeForProfile, request); } /** * An Async wrapper for GetCalculatedAttributeForProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCalculatedAttributeForProfileAsync(const GetCalculatedAttributeForProfileRequestT& request, const GetCalculatedAttributeForProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::GetCalculatedAttributeForProfile, request, handler, context); } /** *

Returns information about a specific domain.

See Also:

AWS * API Reference

*/ virtual Model::GetDomainOutcome GetDomain(const Model::GetDomainRequest& request) const; /** * A Callable wrapper for GetDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDomainOutcomeCallable GetDomainCallable(const GetDomainRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::GetDomain, request); } /** * An Async wrapper for GetDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDomainAsync(const GetDomainRequestT& request, const GetDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::GetDomain, request, handler, context); } /** *

Returns information about the specified event stream in a specific * domain.

See Also:

AWS * API Reference

*/ virtual Model::GetEventStreamOutcome GetEventStream(const Model::GetEventStreamRequest& request) const; /** * A Callable wrapper for GetEventStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEventStreamOutcomeCallable GetEventStreamCallable(const GetEventStreamRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::GetEventStream, request); } /** * An Async wrapper for GetEventStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEventStreamAsync(const GetEventStreamRequestT& request, const GetEventStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::GetEventStream, request, handler, context); } /** *

Returns information about an Identity Resolution Job in a specific domain. *

Identity Resolution Jobs are set up using the Amazon Connect admin * console. For more information, see Use * Identity Resolution to consolidate similar profiles.

See * Also:

AWS * API Reference

*/ virtual Model::GetIdentityResolutionJobOutcome GetIdentityResolutionJob(const Model::GetIdentityResolutionJobRequest& request) const; /** * A Callable wrapper for GetIdentityResolutionJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIdentityResolutionJobOutcomeCallable GetIdentityResolutionJobCallable(const GetIdentityResolutionJobRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::GetIdentityResolutionJob, request); } /** * An Async wrapper for GetIdentityResolutionJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIdentityResolutionJobAsync(const GetIdentityResolutionJobRequestT& request, const GetIdentityResolutionJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::GetIdentityResolutionJob, request, handler, context); } /** *

Returns an integration for a domain.

See Also:

AWS * API Reference

*/ virtual Model::GetIntegrationOutcome GetIntegration(const Model::GetIntegrationRequest& request) const; /** * A Callable wrapper for GetIntegration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIntegrationOutcomeCallable GetIntegrationCallable(const GetIntegrationRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::GetIntegration, request); } /** * An Async wrapper for GetIntegration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIntegrationAsync(const GetIntegrationRequestT& request, const GetIntegrationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::GetIntegration, request, handler, context); } /** *

Before calling this API, use CreateDomain * or UpdateDomain * to enable identity resolution: set Matching to true.

*

GetMatches returns potentially matching profiles, based on the results of the * latest run of a machine learning process.

The process of * matching duplicate profiles. If Matching = true, * Amazon Connect Customer Profiles starts a weekly batch process called Identity * Resolution Job. If you do not specify a date and time for Identity Resolution * Job to run, by default it runs every Saturday at 12AM UTC to detect duplicate * profiles in your domains.

After the Identity Resolution Job completes, * use the GetMatches * API to return and review the results. Or, if you have configured * ExportingConfig in the MatchingRequest, you can * download the results from S3.

Amazon Connect uses the * following profile attributes to identify matches:

  • *

    PhoneNumber

  • HomePhoneNumber

  • *

    BusinessPhoneNumber

  • MobilePhoneNumber

  • *

    EmailAddress

  • PersonalEmailAddress

  • *

    BusinessEmailAddress

  • FullName

For * example, two or more profiles—with spelling mistakes such as John Doe and * Jhn Doe, or different casing email addresses such as * JOHN_DOE@ANYCOMPANY.COM and johndoe@anycompany.com, or different * phone number formats such as 555-010-0000 and +1-555-010-0000—can * be detected as belonging to the same customer John Doe and merged into a * unified profile.

See Also:

AWS * API Reference

*/ virtual Model::GetMatchesOutcome GetMatches(const Model::GetMatchesRequest& request) const; /** * A Callable wrapper for GetMatches that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMatchesOutcomeCallable GetMatchesCallable(const GetMatchesRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::GetMatches, request); } /** * An Async wrapper for GetMatches that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMatchesAsync(const GetMatchesRequestT& request, const GetMatchesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::GetMatches, request, handler, context); } /** *

Returns the object types for a specific domain.

See Also:

AWS * API Reference

*/ virtual Model::GetProfileObjectTypeOutcome GetProfileObjectType(const Model::GetProfileObjectTypeRequest& request) const; /** * A Callable wrapper for GetProfileObjectType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetProfileObjectTypeOutcomeCallable GetProfileObjectTypeCallable(const GetProfileObjectTypeRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::GetProfileObjectType, request); } /** * An Async wrapper for GetProfileObjectType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetProfileObjectTypeAsync(const GetProfileObjectTypeRequestT& request, const GetProfileObjectTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::GetProfileObjectType, request, handler, context); } /** *

Returns the template information for a specific object type.

A * template is a predefined ProfileObjectType, such as “Salesforce-Account” or * “Salesforce-Contact.” When a user sends a ProfileObject, using the * PutProfileObject API, with an ObjectTypeName that matches one of the * TemplateIds, it uses the mappings from the template.

See Also:

* AWS * API Reference

*/ virtual Model::GetProfileObjectTypeTemplateOutcome GetProfileObjectTypeTemplate(const Model::GetProfileObjectTypeTemplateRequest& request) const; /** * A Callable wrapper for GetProfileObjectTypeTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetProfileObjectTypeTemplateOutcomeCallable GetProfileObjectTypeTemplateCallable(const GetProfileObjectTypeTemplateRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::GetProfileObjectTypeTemplate, request); } /** * An Async wrapper for GetProfileObjectTypeTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetProfileObjectTypeTemplateAsync(const GetProfileObjectTypeTemplateRequestT& request, const GetProfileObjectTypeTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::GetProfileObjectTypeTemplate, request, handler, context); } /** *

Returns a set of profiles that belong to the same matching group using the * matchId or profileId. You can also specify the type of * matching that you want for finding similar profiles using either * RULE_BASED_MATCHING or * ML_BASED_MATCHING.

See Also:

AWS * API Reference

*/ virtual Model::GetSimilarProfilesOutcome GetSimilarProfiles(const Model::GetSimilarProfilesRequest& request) const; /** * A Callable wrapper for GetSimilarProfiles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSimilarProfilesOutcomeCallable GetSimilarProfilesCallable(const GetSimilarProfilesRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::GetSimilarProfiles, request); } /** * An Async wrapper for GetSimilarProfiles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSimilarProfilesAsync(const GetSimilarProfilesRequestT& request, const GetSimilarProfilesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::GetSimilarProfiles, request, handler, context); } /** *

Get details of specified workflow.

See Also:

AWS * API Reference

*/ virtual Model::GetWorkflowOutcome GetWorkflow(const Model::GetWorkflowRequest& request) const; /** * A Callable wrapper for GetWorkflow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetWorkflowOutcomeCallable GetWorkflowCallable(const GetWorkflowRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::GetWorkflow, request); } /** * An Async wrapper for GetWorkflow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetWorkflowAsync(const GetWorkflowRequestT& request, const GetWorkflowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::GetWorkflow, request, handler, context); } /** *

Get granular list of steps in workflow.

See Also:

AWS * API Reference

*/ virtual Model::GetWorkflowStepsOutcome GetWorkflowSteps(const Model::GetWorkflowStepsRequest& request) const; /** * A Callable wrapper for GetWorkflowSteps that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetWorkflowStepsOutcomeCallable GetWorkflowStepsCallable(const GetWorkflowStepsRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::GetWorkflowSteps, request); } /** * An Async wrapper for GetWorkflowSteps that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetWorkflowStepsAsync(const GetWorkflowStepsRequestT& request, const GetWorkflowStepsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::GetWorkflowSteps, request, handler, context); } /** *

Lists all of the integrations associated to a specific URI in the AWS * account.

See Also:

AWS * API Reference

*/ virtual Model::ListAccountIntegrationsOutcome ListAccountIntegrations(const Model::ListAccountIntegrationsRequest& request) const; /** * A Callable wrapper for ListAccountIntegrations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAccountIntegrationsOutcomeCallable ListAccountIntegrationsCallable(const ListAccountIntegrationsRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::ListAccountIntegrations, request); } /** * An Async wrapper for ListAccountIntegrations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAccountIntegrationsAsync(const ListAccountIntegrationsRequestT& request, const ListAccountIntegrationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::ListAccountIntegrations, request, handler, context); } /** *

Lists calculated attribute definitions for Customer Profiles

See * Also:

AWS * API Reference

*/ virtual Model::ListCalculatedAttributeDefinitionsOutcome ListCalculatedAttributeDefinitions(const Model::ListCalculatedAttributeDefinitionsRequest& request) const; /** * A Callable wrapper for ListCalculatedAttributeDefinitions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCalculatedAttributeDefinitionsOutcomeCallable ListCalculatedAttributeDefinitionsCallable(const ListCalculatedAttributeDefinitionsRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::ListCalculatedAttributeDefinitions, request); } /** * An Async wrapper for ListCalculatedAttributeDefinitions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCalculatedAttributeDefinitionsAsync(const ListCalculatedAttributeDefinitionsRequestT& request, const ListCalculatedAttributeDefinitionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::ListCalculatedAttributeDefinitions, request, handler, context); } /** *

Retrieve a list of calculated attributes for a customer * profile.

See Also:

AWS * API Reference

*/ virtual Model::ListCalculatedAttributesForProfileOutcome ListCalculatedAttributesForProfile(const Model::ListCalculatedAttributesForProfileRequest& request) const; /** * A Callable wrapper for ListCalculatedAttributesForProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCalculatedAttributesForProfileOutcomeCallable ListCalculatedAttributesForProfileCallable(const ListCalculatedAttributesForProfileRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::ListCalculatedAttributesForProfile, request); } /** * An Async wrapper for ListCalculatedAttributesForProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCalculatedAttributesForProfileAsync(const ListCalculatedAttributesForProfileRequestT& request, const ListCalculatedAttributesForProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::ListCalculatedAttributesForProfile, request, handler, context); } /** *

Returns a list of all the domains for an AWS account that have been * created.

See Also:

AWS * API Reference

*/ virtual Model::ListDomainsOutcome ListDomains(const Model::ListDomainsRequest& request) const; /** * A Callable wrapper for ListDomains that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDomainsOutcomeCallable ListDomainsCallable(const ListDomainsRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::ListDomains, request); } /** * An Async wrapper for ListDomains that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDomainsAsync(const ListDomainsRequestT& request, const ListDomainsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::ListDomains, request, handler, context); } /** *

Returns a list of all the event streams in a specific domain.

See * Also:

AWS * API Reference

*/ virtual Model::ListEventStreamsOutcome ListEventStreams(const Model::ListEventStreamsRequest& request) const; /** * A Callable wrapper for ListEventStreams that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEventStreamsOutcomeCallable ListEventStreamsCallable(const ListEventStreamsRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::ListEventStreams, request); } /** * An Async wrapper for ListEventStreams that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEventStreamsAsync(const ListEventStreamsRequestT& request, const ListEventStreamsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::ListEventStreams, request, handler, context); } /** *

Lists all of the Identity Resolution Jobs in your domain. The response sorts * the list by JobStartTime.

See Also:

AWS * API Reference

*/ virtual Model::ListIdentityResolutionJobsOutcome ListIdentityResolutionJobs(const Model::ListIdentityResolutionJobsRequest& request) const; /** * A Callable wrapper for ListIdentityResolutionJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListIdentityResolutionJobsOutcomeCallable ListIdentityResolutionJobsCallable(const ListIdentityResolutionJobsRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::ListIdentityResolutionJobs, request); } /** * An Async wrapper for ListIdentityResolutionJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListIdentityResolutionJobsAsync(const ListIdentityResolutionJobsRequestT& request, const ListIdentityResolutionJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::ListIdentityResolutionJobs, request, handler, context); } /** *

Lists all of the integrations in your domain.

See Also:

AWS * API Reference

*/ virtual Model::ListIntegrationsOutcome ListIntegrations(const Model::ListIntegrationsRequest& request) const; /** * A Callable wrapper for ListIntegrations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListIntegrationsOutcomeCallable ListIntegrationsCallable(const ListIntegrationsRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::ListIntegrations, request); } /** * An Async wrapper for ListIntegrations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListIntegrationsAsync(const ListIntegrationsRequestT& request, const ListIntegrationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::ListIntegrations, request, handler, context); } /** *

Lists all of the template information for object types.

See * Also:

AWS * API Reference

*/ virtual Model::ListProfileObjectTypeTemplatesOutcome ListProfileObjectTypeTemplates(const Model::ListProfileObjectTypeTemplatesRequest& request) const; /** * A Callable wrapper for ListProfileObjectTypeTemplates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListProfileObjectTypeTemplatesOutcomeCallable ListProfileObjectTypeTemplatesCallable(const ListProfileObjectTypeTemplatesRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::ListProfileObjectTypeTemplates, request); } /** * An Async wrapper for ListProfileObjectTypeTemplates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListProfileObjectTypeTemplatesAsync(const ListProfileObjectTypeTemplatesRequestT& request, const ListProfileObjectTypeTemplatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::ListProfileObjectTypeTemplates, request, handler, context); } /** *

Lists all of the templates available within the service.

See * Also:

AWS * API Reference

*/ virtual Model::ListProfileObjectTypesOutcome ListProfileObjectTypes(const Model::ListProfileObjectTypesRequest& request) const; /** * A Callable wrapper for ListProfileObjectTypes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListProfileObjectTypesOutcomeCallable ListProfileObjectTypesCallable(const ListProfileObjectTypesRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::ListProfileObjectTypes, request); } /** * An Async wrapper for ListProfileObjectTypes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListProfileObjectTypesAsync(const ListProfileObjectTypesRequestT& request, const ListProfileObjectTypesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::ListProfileObjectTypes, request, handler, context); } /** *

Returns a list of objects associated with a profile of a given * ProfileObjectType.

See Also:

AWS * API Reference

*/ virtual Model::ListProfileObjectsOutcome ListProfileObjects(const Model::ListProfileObjectsRequest& request) const; /** * A Callable wrapper for ListProfileObjects that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListProfileObjectsOutcomeCallable ListProfileObjectsCallable(const ListProfileObjectsRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::ListProfileObjects, request); } /** * An Async wrapper for ListProfileObjects that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListProfileObjectsAsync(const ListProfileObjectsRequestT& request, const ListProfileObjectsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::ListProfileObjects, request, handler, context); } /** *

Returns a set of MatchIds that belong to the given * domain.

See Also:

AWS * API Reference

*/ virtual Model::ListRuleBasedMatchesOutcome ListRuleBasedMatches(const Model::ListRuleBasedMatchesRequest& request) const; /** * A Callable wrapper for ListRuleBasedMatches that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRuleBasedMatchesOutcomeCallable ListRuleBasedMatchesCallable(const ListRuleBasedMatchesRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::ListRuleBasedMatches, request); } /** * An Async wrapper for ListRuleBasedMatches that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRuleBasedMatchesAsync(const ListRuleBasedMatchesRequestT& request, const ListRuleBasedMatchesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::ListRuleBasedMatches, request, handler, context); } /** *

Displays the tags associated with an Amazon Connect Customer Profiles * resource. In Connect Customer Profiles, domains, profile object types, and * integrations can be tagged.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::ListTagsForResource, request, handler, context); } /** *

Query to list all workflows.

See Also:

AWS * API Reference

*/ virtual Model::ListWorkflowsOutcome ListWorkflows(const Model::ListWorkflowsRequest& request) const; /** * A Callable wrapper for ListWorkflows that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListWorkflowsOutcomeCallable ListWorkflowsCallable(const ListWorkflowsRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::ListWorkflows, request); } /** * An Async wrapper for ListWorkflows that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListWorkflowsAsync(const ListWorkflowsRequestT& request, const ListWorkflowsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::ListWorkflows, request, handler, context); } /** *

Runs an AWS Lambda job that does the following:

  1. All the * profileKeys in the ProfileToBeMerged will be moved to the main * profile.

  2. All the objects in the ProfileToBeMerged * will be moved to the main profile.

  3. All the * ProfileToBeMerged will be deleted at the end.

  4. All * the profileKeys in the ProfileIdsToBeMerged will be moved to the * main profile.

  5. Standard fields are merged as follows:

      *

    1. Fields are always "union"-ed if there are no conflicts in standard * fields or attributeKeys.

    2. When there are conflicting * fields:

      1. If no SourceProfileIds entry is specified, * the main Profile value is always taken.

      2. If a * SourceProfileIds entry is specified, the specified profileId is * always taken, even if it is a NULL value.

    6. *

You can use MergeProfiles together with GetMatches, * which returns potentially matching profiles, or use it with the results of * another matching system. After profiles have been merged, they cannot be * separated (unmerged).

See Also:

AWS * API Reference

*/ virtual Model::MergeProfilesOutcome MergeProfiles(const Model::MergeProfilesRequest& request) const; /** * A Callable wrapper for MergeProfiles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::MergeProfilesOutcomeCallable MergeProfilesCallable(const MergeProfilesRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::MergeProfiles, request); } /** * An Async wrapper for MergeProfiles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void MergeProfilesAsync(const MergeProfilesRequestT& request, const MergeProfilesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::MergeProfiles, request, handler, context); } /** *

Adds an integration between the service and a third-party service, which * includes Amazon AppFlow and Amazon Connect.

An integration can belong to * only one domain.

To add or remove tags on an existing Integration, see * TagResource / * UntagResource.

See Also:

AWS * API Reference

*/ virtual Model::PutIntegrationOutcome PutIntegration(const Model::PutIntegrationRequest& request) const; /** * A Callable wrapper for PutIntegration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutIntegrationOutcomeCallable PutIntegrationCallable(const PutIntegrationRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::PutIntegration, request); } /** * An Async wrapper for PutIntegration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutIntegrationAsync(const PutIntegrationRequestT& request, const PutIntegrationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::PutIntegration, request, handler, context); } /** *

Adds additional objects to customer profiles of a given ObjectType.

*

When adding a specific profile object, like a Contact Record, an inferred * profile can get created if it is not mapped to an existing profile. The * resulting profile will only have a phone number populated in the standard * ProfileObject. Any additional Contact Records with the same phone number will be * mapped to the same inferred profile.

When a ProfileObject is created and * if a ProfileObjectType already exists for the ProfileObject, it will provide * data to a standard profile depending on the ProfileObjectType definition.

*

PutProfileObject needs an ObjectType, which can be created using * PutProfileObjectType.

See Also:

AWS * API Reference

*/ virtual Model::PutProfileObjectOutcome PutProfileObject(const Model::PutProfileObjectRequest& request) const; /** * A Callable wrapper for PutProfileObject that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutProfileObjectOutcomeCallable PutProfileObjectCallable(const PutProfileObjectRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::PutProfileObject, request); } /** * An Async wrapper for PutProfileObject that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutProfileObjectAsync(const PutProfileObjectRequestT& request, const PutProfileObjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::PutProfileObject, request, handler, context); } /** *

Defines a ProfileObjectType.

To add or remove tags on an existing * ObjectType, see * TagResource/UntagResource.

See * Also:

AWS * API Reference

*/ virtual Model::PutProfileObjectTypeOutcome PutProfileObjectType(const Model::PutProfileObjectTypeRequest& request) const; /** * A Callable wrapper for PutProfileObjectType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutProfileObjectTypeOutcomeCallable PutProfileObjectTypeCallable(const PutProfileObjectTypeRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::PutProfileObjectType, request); } /** * An Async wrapper for PutProfileObjectType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutProfileObjectTypeAsync(const PutProfileObjectTypeRequestT& request, const PutProfileObjectTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::PutProfileObjectType, request, handler, context); } /** *

Searches for profiles within a specific domain using one or more predefined * search keys (e.g., _fullName, _phone, _email, _account, etc.) and/or * custom-defined search keys. A search key is a data type pair that consists of a * KeyName and Values list.

This operation * supports searching for profiles with a minimum of 1 key-value(s) pair and up to * 5 key-value(s) pairs using either AND or OR * logic.

See Also:

AWS * API Reference

*/ virtual Model::SearchProfilesOutcome SearchProfiles(const Model::SearchProfilesRequest& request) const; /** * A Callable wrapper for SearchProfiles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchProfilesOutcomeCallable SearchProfilesCallable(const SearchProfilesRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::SearchProfiles, request); } /** * An Async wrapper for SearchProfiles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchProfilesAsync(const SearchProfilesRequestT& request, const SearchProfilesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::SearchProfiles, request, handler, context); } /** *

Assigns one or more tags (key-value pairs) to the specified Amazon Connect * Customer Profiles resource. Tags can help you organize and categorize your * resources. You can also use them to scope user permissions by granting a user * permission to access or change only resources with certain tag values. In * Connect Customer Profiles, domains, profile object types, and integrations can * be tagged.

Tags don't have any semantic meaning to AWS and are * interpreted strictly as strings of characters.

You can use the * TagResource action with a resource that already has tags. If you specify a new * tag key, this tag is appended to the list of tags associated with the resource. * If you specify a tag key that is already associated with the resource, the new * tag value that you specify replaces the previous value for that tag.

You * can associate as many as 50 tags with a resource.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::TagResource, request, handler, context); } /** *

Removes one or more tags from the specified Amazon Connect Customer Profiles * resource. In Connect Customer Profiles, domains, profile object types, and * integrations can be tagged.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::UntagResource, request, handler, context); } /** *

Updates an existing calculated attribute definition. When updating the * Conditions, note that increasing the date range of a calculated attribute will * not trigger inclusion of historical data greater than the current date * range.

See Also:

AWS * API Reference

*/ virtual Model::UpdateCalculatedAttributeDefinitionOutcome UpdateCalculatedAttributeDefinition(const Model::UpdateCalculatedAttributeDefinitionRequest& request) const; /** * A Callable wrapper for UpdateCalculatedAttributeDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateCalculatedAttributeDefinitionOutcomeCallable UpdateCalculatedAttributeDefinitionCallable(const UpdateCalculatedAttributeDefinitionRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::UpdateCalculatedAttributeDefinition, request); } /** * An Async wrapper for UpdateCalculatedAttributeDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateCalculatedAttributeDefinitionAsync(const UpdateCalculatedAttributeDefinitionRequestT& request, const UpdateCalculatedAttributeDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::UpdateCalculatedAttributeDefinition, request, handler, context); } /** *

Updates the properties of a domain, including creating or selecting a dead * letter queue or an encryption key.

After a domain is created, the name * can’t be changed.

Use this API or CreateDomain * to enable identity * resolution: set Matching to true.

To prevent * cross-service impersonation when you call this API, see Cross-service * confused deputy prevention for sample policies that you should apply.

*

To add or remove tags on an existing Domain, see TagResource/UntagResource.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateDomainOutcome UpdateDomain(const Model::UpdateDomainRequest& request) const; /** * A Callable wrapper for UpdateDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDomainOutcomeCallable UpdateDomainCallable(const UpdateDomainRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::UpdateDomain, request); } /** * An Async wrapper for UpdateDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDomainAsync(const UpdateDomainRequestT& request, const UpdateDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::UpdateDomain, request, handler, context); } /** *

Updates the properties of a profile. The ProfileId is required for updating a * customer profile.

When calling the UpdateProfile API, specifying an empty * string value means that any existing value will be removed. Not specifying a * string value means that any value already there will be kept.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateProfileOutcome UpdateProfile(const Model::UpdateProfileRequest& request) const; /** * A Callable wrapper for UpdateProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateProfileOutcomeCallable UpdateProfileCallable(const UpdateProfileRequestT& request) const { return SubmitCallable(&CustomerProfilesClient::UpdateProfile, request); } /** * An Async wrapper for UpdateProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateProfileAsync(const UpdateProfileRequestT& request, const UpdateProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CustomerProfilesClient::UpdateProfile, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const CustomerProfilesClientConfiguration& clientConfiguration); CustomerProfilesClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace CustomerProfiles } // namespace Aws