Module types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that Amazon Connect Customer Profiles can respond with.

Structs

• AdditionalSearchKey

  A data type pair that consists of a KeyName and Values list that is used in conjunction with the KeyName and Values parameters to search for profiles using the SearchProfiles API.

• Address

  A generic address associated with the customer that is not mailing, shipping, or billing.

• AddressDimension

  Object that segments on Customer Profile's address object.

• AppflowIntegration

  Details for workflow of type APPFLOW_INTEGRATION.

• AppflowIntegrationWorkflowAttributes

  Structure holding all APPFLOW_INTEGRATION specific workflow attributes.

• AppflowIntegrationWorkflowMetrics

  Workflow specific execution metrics for APPFLOW_INTEGRATION workflow.

• AppflowIntegrationWorkflowStep

  Workflow step details for APPFLOW_INTEGRATION workflow.

• AttributeDetails

  Mathematical expression and a list of attribute items specified in that expression.

• AttributeDimension

  Object that segments on various Customer Profile's fields.

• AttributeItem

  The details of a single attribute item specified in the mathematical expression.

• AttributeTypesSelector

  Configuration information about the AttributeTypesSelector where the rule-based identity resolution uses to match profiles. You can choose how profiles are compared across attribute types and which attribute to use for matching from each type. There are three attribute types you can configure:

  • Email type

    • You can choose from Email, BusinessEmail, and PersonalEmail

  • Phone number type

    • You can choose from Phone, HomePhone, and MobilePhone

  • Address type

    • You can choose from Address, BusinessAddress, MaillingAddress, and ShippingAddress

  You can either choose ONE_TO_ONE or MANY_TO_MANY as the AttributeMatchingModel. When choosing MANY_TO_MANY, the system can match attribute across the sub-types of an attribute type. For example, if the value of the Email field of Profile A and the value of BusinessEmail field of Profile B matches, the two profiles are matched on the Email type. When choosing ONE_TO_ONE the system can only match if the sub-types are exact matches. For example, only when the value of the Email field of Profile A and the value of the Email field of Profile B matches, the two profiles are matched on the Email type.

• AttributeValueItem

  List containing the values for the given attribute.

• AutoMerging

  Configuration settings for how to perform the auto-merging of profiles.

• Batch

  Batch defines the boundaries for ingestion for each step in APPFLOW_INTEGRATION workflow. APPFLOW_INTEGRATION workflow splits ingestion based on these boundaries.

• BatchGetCalculatedAttributeForProfileError

  Error object describing why a specific profile and calculated attribute failed.

• BatchGetProfileError

  Error object describing why a specific profile failed.

• CalculatedAttributeDimension

  Object that segments on Customer Profile's Calculated Attributes.

• CalculatedAttributeValue

  The object containing the values of a single calculated attribute value.

• ConditionOverrides

  An object to override the original condition block of a calculated attribute.

• Conditions

  The conditions including range, object count, and threshold for the calculated attribute.

• ConflictResolution

  How the auto-merging process should resolve conflicts between different profiles.

• ConnectorOperator

  The operation to be performed on the provided source fields.

• Consolidation

  The matching criteria to be used during the auto-merging process.

• DateDimension

  Object that segments on various Customer Profile's date fields.

• DestinationSummary

  Summary information about the Kinesis data stream

• DetectedProfileObjectType

  Contains ProfileObjectType mapping information from the model.

• DomainStats

  Usage-specific statistics about the domain.

• EventStreamDestinationDetails

  Details of the destination being used for the EventStream.

• EventStreamSummary

  An instance of EventStream in a list of EventStreams.

• EventTriggerCondition

  Specifies the circumstances under which the event should trigger the destination.

• EventTriggerDimension

  A specific event dimension to be assessed.

• EventTriggerLimits

  Defines limits controlling whether an event triggers the destination, based on ingestion latency and the number of invocations per profile over specific time periods.

• EventTriggerSummaryItem

  The summary of the event trigger.

• ExportingConfig

  Configuration information about the S3 bucket where Identity Resolution Jobs writes result files.

  You need to give Customer Profiles service principal write permission to your S3 bucket. Otherwise, you'll get an exception in the API response. For an example policy, see Amazon Connect Customer Profiles cross-service confused deputy prevention.

• ExportingLocation

  The S3 location where Identity Resolution Jobs write result files.

• ExtraLengthValueProfileDimension

  Object that segments on various Customer profile's fields that are larger than normal.

• FieldSourceProfileIds

  A duplicate customer profile that is to be merged into a main profile.

• Filter

  Defines how to filter the objects coming in for calculated attributes.

• FilterAttributeDimension

  Object that defines how to filter the incoming objects for the calculated attribute.

• FilterDimension

  Contains the map of attribute names to attribute dimensions.

• FilterGroup

  Object that holds the dimensions to filter on.

• FlowDefinition

  The configurations that control how Customer Profiles retrieves data from the source, Amazon AppFlow. Customer Profiles uses this information to create an AppFlow flow on behalf of customers.

• FoundByKeyValue

  A data type pair that consists of a KeyName and Values list that were used to find a profile returned in response to a SearchProfiles request.

• Group

  Contains dimensions that determine what to segment on.

• IdentityResolutionJob

  Information about the Identity Resolution Job.

• IncrementalPullConfig

  Specifies the configuration used when importing incremental records from the source.

• IntegrationConfig

  Configuration data for integration workflow.

• JobSchedule

  The day and time when do you want to start the Identity Resolution Job every week.

• JobStats

  Statistics about the Identity Resolution Job.

• ListCalculatedAttributeDefinitionItem

  The details of a single calculated attribute definition.

• ListCalculatedAttributeForProfileItem

  The details of a single calculated attribute for a profile.

• ListDomainItem

  An object in a list that represents a domain.

• ListIntegrationItem

  An integration in list of integrations.

• ListObjectTypeAttributeItem

  Item that contains the attribute and when it was last updated.

• ListProfileObjectTypeItem

  A ProfileObjectType instance.

• ListProfileObjectTypeTemplateItem

  A ProfileObjectTypeTemplate in a list of ProfileObjectTypeTemplates.

• ListProfileObjectsItem

  A ProfileObject in a list of ProfileObjects.

• ListWorkflowsItem

  A workflow in list of workflows.

• MarketoSourceProperties

  The properties that are applied when Marketo is being used as a source.

• MatchItem

  The Match group object.

• MatchingRequest

  The flag that enables the matching process of duplicate profiles.

• MatchingResponse

  The flag that enables the matching process of duplicate profiles.

• MatchingRule

  Specifies how does the rule-based matching process should match profiles. You can choose from the following attributes to build the matching Rule:

  • AccountNumber

  • Address.Address

  • Address.City

  • Address.Country

  • Address.County

  • Address.PostalCode

  • Address.State

  • Address.Province

  • BirthDate

  • BusinessName

  • EmailAddress

  • FirstName

  • Gender

  • LastName

  • MiddleName

  • PhoneNumber

  • Any customized profile attributes that start with the Attributes

• ObjectAttribute

  The criteria that a specific object attribute must meet to trigger the destination.

• ObjectFilter

  The filter applied to ListProfileObjects response to include profile objects with the specified index values.

• ObjectTypeField

  Represents a field in a ProfileObjectType.

• ObjectTypeKey

  An object that defines the Key element of a ProfileObject. A Key is a special element that can be used to search for a customer profile.

• Period

  Defines a limit and the time period during which it is enforced.

• Profile

  The standard profile of a customer.

• ProfileAttributes

  The object used to segment on attributes within the customer profile.

• ProfileDimension

  Object to hold the dimensions of a profile's fields to segment on.

• ProfileQueryFailures

  Object that holds failures for membership.

• ProfileQueryResult

  Object that holds the results for membership.

• Range

  The relative time period over which data is included in the aggregation.

• RangeOverride

  Overrides the original range on a calculated attribute definition.

• RuleBasedMatchingRequest

  The request to enable the rule-based matching.

• RuleBasedMatchingResponse

  The response of the Rule-based matching request.

• S3ExportingConfig

  Configuration information about the S3 bucket where Identity Resolution Jobs write result files.

• S3ExportingLocation

  The S3 location where Identity Resolution Jobs write result files.

• S3SourceProperties

  The properties that are applied when Amazon S3 is being used as the flow source.

• SalesforceSourceProperties

  The properties that are applied when Salesforce is being used as a source.

• ScheduledTriggerProperties

  Specifies the configuration details of a scheduled-trigger flow that you define. Currently, these settings only apply to the scheduled-trigger type.

• SegmentDefinitionItem

  Object holding the segment definition fields.

• SegmentGroup

  Contains all groups of the segment definition.

• SegmentGroupStructure

  Contains all groups of the segment definition.

• ServiceNowSourceProperties

  The properties that are applied when ServiceNow is being used as a source.

• SourceConnectorProperties

  Specifies the information that is required to query a particular Amazon AppFlow connector. Customer Profiles supports Salesforce, Zendesk, Marketo, ServiceNow and Amazon S3.

• SourceFlowConfig

  Contains information about the configuration of the source connector used in the flow.

• SourceSegment

  The source segments to build off of.

• Task

  A class for modeling different type of tasks. Task implementation varies based on the TaskType.

• Threshold

  The threshold for the calculated attribute.

• TriggerConfig

  The trigger settings that determine how and when Amazon AppFlow runs the specified flow.

• TriggerProperties

  Specifies the configuration details that control the trigger for a flow. Currently, these settings only apply to the Scheduled trigger type.

• UpdateAddress

  Updates associated with the address properties of a customer profile.

• WorkflowAttributes

  Structure to hold workflow attributes.

• WorkflowMetrics

  Generic object containing workflow execution metrics.

• WorkflowStepItem

  List containing steps in workflow.

• ZendeskSourceProperties

  The properties that are applied when using Zendesk as a flow source.

Enums

• AttributeDimensionType
  When writing a match expression against AttributeDimensionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AttributeMatchingModel
  When writing a match expression against AttributeMatchingModel, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ComparisonOperator
  When writing a match expression against ComparisonOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ConflictResolvingModel
  When writing a match expression against ConflictResolvingModel, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DataFormat
  When writing a match expression against DataFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DataPullMode
  When writing a match expression against DataPullMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DateDimensionType
  When writing a match expression against DateDimensionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Dimension

  Object that holds what profile and calculated attributes to segment on.

• EstimateStatus
  When writing a match expression against EstimateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• EventStreamDestinationStatus
  When writing a match expression against EventStreamDestinationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• EventStreamState
  When writing a match expression against EventStreamState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• EventTriggerLogicalOperator
  When writing a match expression against EventTriggerLogicalOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• FieldContentType
  When writing a match expression against FieldContentType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• FilterDimensionType
  When writing a match expression against FilterDimensionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• GenderDeprecated
  When writing a match expression against Gender, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• IdentityResolutionJobStatus
  When writing a match expression against IdentityResolutionJobStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Include
  When writing a match expression against Include, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• IncludeOptions
  When writing a match expression against IncludeOptions, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• JobScheduleDayOfTheWeek
  When writing a match expression against JobScheduleDayOfTheWeek, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• LogicalOperator
  When writing a match expression against LogicalOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• MarketoConnectorOperator
  When writing a match expression against MarketoConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• MatchType
  When writing a match expression against MatchType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Operator
  When writing a match expression against Operator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• OperatorPropertiesKeys
  When writing a match expression against OperatorPropertiesKeys, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• PartyTypeDeprecated
  When writing a match expression against PartyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• PeriodUnit
  When writing a match expression against PeriodUnit, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• QueryResult
  When writing a match expression against QueryResult, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RangeUnit
  When writing a match expression against RangeUnit, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RuleBasedMatchingStatus
  When writing a match expression against RuleBasedMatchingStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• S3ConnectorOperator
  When writing a match expression against S3ConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SalesforceConnectorOperator
  When writing a match expression against SalesforceConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SegmentSnapshotStatus
  When writing a match expression against SegmentSnapshotStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ServiceNowConnectorOperator
  When writing a match expression against ServiceNowConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SourceConnectorType
  When writing a match expression against SourceConnectorType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• StandardIdentifier
  When writing a match expression against StandardIdentifier, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Statistic
  When writing a match expression against Statistic, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Status
  When writing a match expression against Status, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• StringDimensionType
  When writing a match expression against StringDimensionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• TaskType
  When writing a match expression against TaskType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• TriggerType
  When writing a match expression against TriggerType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Type
  When writing a match expression against Type, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Unit
  When writing a match expression against Unit, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• WorkflowType
  When writing a match expression against WorkflowType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ZendeskConnectorOperator
  When writing a match expression against ZendeskConnectorOperator, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.