TMF Outbound Notifications Framework

The Outbound Notifications Framework serves as a standardized mechanism for managing outbound notifications across TMF Open APIs. From Summer’25, notification framework is available for these TMF APIs.

• TMF 621 v4 Trouble Ticket Management
• TMF 622 v4 Product Ordering Management
• TMF 629 v4 Customer Management
• TMF 632 v4 Party Management
• TMF 637 v4 Product Inventory Management
• TMF 651 v4 Agreement Management

This framework provides a structured approach to capturing, processing, and triggering API calls based on changes to entities within the system.

The framework is responsible for detecting and handling events triggered by create or update operations on an entity. Upon successful CDC event generation, the subscriber processes the event data and calls the appropriate outbound TMF Open API endpoint, as configured within the consumption framework. This framework standardizes outbound notification handling across all TMF Open API implementations, ensuring a scalable, configurable, and efficient mechanism for processing entity-level changes. It also ensures compatibility with entities from both the Salesforce Core platform and CME managed packages.

• Event-Driven Architecture

  • Captures changes occurring at the entity level, triggered by create or update actions.
  • Supports real-time processing of modifications across different entities.

• Dynamic API Invocation

  • Allows seamless integration with TMF Open APIs for further data processing.
  • Supports configurable API endpoints based on entity changes.

• Support for Core and CME Managed Packages

  • Ensures compatibility with entities available on Salesforce Core platform as well as those in managed package.
  • Provides flexibility for various deployment models.

• The delete operation is not supported on the TMF primary resource, but delete actions on its sub-resources are supported and can be configured as needed.
• Event subscription is not available through the UI. It must be configured through the Tooling API.

• Connect your Salesforce and MuleSoft instances. See Connect Your Salesforce and MuleSoft Instances.

To ensure notifications are triggered correctly, the Salesforce Notification Framework must be configured with the required settings. See Outbound Notification Framework Configuration.

Notifications are generated in the these scenarios.

1. Changes to the Primary TMF Resource

   • Create and update operations on the primary TMF resource generate outbound notifications.

2. Changes in Associations with Sub-Resources

   • Notifications are triggered when supported sub-resources are associated or disassociated with the primary resource.
   • This applies only to relationship changes, not to internal attribute updates within the sub-resource.
   • Example (TMF622): Linking or unlinking a RelatedParty for example Account, to a ProductOrder triggers a notification. Attribute-level changes to the Account itself do not trigger a TMF622 notification; such updates are instead handled through TMF629.

3. Changes in Supported Sub-Resources

   • Create, update, or delete operations on supported sub-resources for example ProductOrderItem records linked to a ProductOrder, can trigger notifications.
   • Some sub-resources are mapped directly from attributes of the parent entity; in such cases, configuration must be applied at the parent entity level.

The diagram illustrates the Outbound Notifications Framework and how it processes entity changes to trigger external API calls. Here’s a breakdown of the flow:

• Process

  • A business process updates the database, leading to modifications in specific entities.

• Change Data Capture (CDC) and Events

  • Monitors the database for changes to configured entities.
  • When an entity is created or updated CDC raises an event.
  • The subscriber, that is listening for change events, receives the notifications from CDC and processes them.

• Outbound Notification Configurations

  • The subscriber cross-references the setup entity (ObjIntegProviderDefMapping) to determine which entities and fields should trigger notifications.
  • The configuration defines the Integration Definition Name, which helps determine the next steps.

• Consumption Framework and Integration Definition

  • Processes the event using a process integration provider and named credentials for authentication.
  • The Integration Definition determines how the event should be handled.
  • By default, the Integration Definition generates the sample payload shown below when invoking the outbound API for the received list of events.
  1[
  2    {
  3      "entityId": "801LT00000l35svYAA",
  4      "entityName": "Order",
  5      "eventId": "00008f91-e414-b7d9-dd96-088578a42fb1_1",
  6      "commitTimestamp": 1751702988000,
  7      "commitNumber": 1751702989291831298,
  8      "correlationId": "00008f91-e414-b7d9-dd96-088578a42fb1",
  9      "changedFields": {
  10        "Status": "Activated"
  11      },
  12      "changeEventType": "Update",
  13      "enrichedFields": {
  14        "OrderNumber": "00000449"
  15    }
  16  }
  17 ]

• Call TMF Outbound Notification APIs Based on the configuration, the framework invokes the appropriate TMF Outbound Notification API through endpoints of the MuleSoft Direct Application.. For example: TMF651 v4, supports these event notifications.

For example:

• AgreementCreateEvent
• POST: /api/notification/agreementCreateEvent
• AgreementAttributeValueChangeEvent
• POST: /api/notification/agreementAttributeValueChangeEvent
• AgreementStateChangeEvent (status field)
• POST: /api/notification/agreementStateChangeEvent

This is a sample flow of the TMFXXX v4 Outbound Notification.

• Automated Data Synchronization: Ensures data consistency with external systems by automatically triggering API calls when entity data is modified.
• Workflow Automation: Enables real-time actions based on business rules, such as notifying external systems upon key entity updates.
• Event-Driven Integrations: Facilitates seamless integration between different TMF Open API implementations by reacting to entity modifications.

These licenses are required for the outbound notification framework. Add-on License:

• CommunicationsCloudAddOn
• IndustriesServiceExcellenceAddOn- (For Integration Definition)

Platform License:

• Communications Cloud Growth

Perform these steps to configure the Outbound Notification Framework for your organization. This configuration enables the framework to capture change events and send outbound notification payloads to the Mule API.

1. From Setup, enter Communications Cloud in the Quick Find box.

2. Navigate to Services Setup within Communications Cloud.

3. Locate the option Enable TMF Notification. Toggle the switch ON to enable notifications.

   

4. Navigate to Setup > Integration > MuleSoft > MuleSoft Direct to enable the API you intend to deploy to your Anypoint platform. For detailed guidance on enabling the integration, see Enable Integrations.

5. To locate the Named Credential created for the deployed API, go to Setup > Security > Named Credentials.

6. Create Integration Definitions.

   • Navigate to Setup > Integration Definitions.

   • Click on New to create an Integration Definition.

   • Select the Type as Standard, enter appropriate details for Name, Developer Name as shown below and click Next.

     

   • In the Standard Provider dropdown, select TMFNotificationCalloutIntegrationProvider. This provider is available out-of-the box for the notification framework.

   • Enter Attribute Values.

     • Named Credentials: Enter the name of the Named Credential created earlier (see Step 5).
     • Path: Enter the remaining portion of the notification URL path. This will be appended to the base URL defined in the Named Credential.
     • Timeout (ms): Specify the timeout value in milliseconds, based on your system or integration requirements.

   • After saving, click Activate to enable the integration definition.

   The integrationProviderDefinitionId can be located in the URL of the window.

   To create Integration Definitions for events such as AttributeValueChange and StateChange, repeat the steps mentioned above.

   Note

7. Enable Remote Site access by navigating to Setup > Remote Site Settings > New Remote Site.

8. Enter the Name and the URL of the API deployed in Anypoint, click on Save.

   

9. Create the required Object Integration Definitions for the relevant resources and sub-resources, based on the applicable TMF API. These definitions determine which change events (create, update, delete) and which object attributes to monitor, allowing the framework to trigger the appropriate outbound notifications.

   See Setting Up Object Integration Definitions for further details and examples of creating these object integration definitions.

To create the Object Integration Definitions for the necessary entities, use this to submit the request payloads.

/services/data/v65.0/tooling/sobjects/ObjIntegProviderDefMapping

The following table describes the payload structure of an Object Integration Definition, which allows the notification framework to capture specific event types and their details and forward this event data to the Mule API.

Role of RelatedFieldName in Object Integration Definitions

When defining Object Integration Definitions for change events on an entity, ensure that the RelatedFieldName is configured correctly. This field specifies which attribute from the source entity is included in the enrichedFields object of the notification request payload.

Correct configuration of the RelatedFieldName in Object Integration Definitions enables two key integration behaviors:

1. Event Grouping for Outbound Notifications

   • When multiple change events are included in a single notification request payload, the Mule layer uses the value of the RelatedFieldName field to determine whether the events relate to the same parent entity.
   • Events sharing the same value are grouped, and a single outbound notification is generated for the group.
   • This ensures deduplication and avoids sending multiple notifications for the same parent entity.

2. Parent Entity Identification for Inbound GET API Calls

   • The enrichedFields object includes the parent entity ID as specified by the RelatedFieldName.
   • This ID is used by the Mule API to perform the Inbound GET API call to retrieve the full parent resource data.
   • The response is then used to construct the final outbound notification payload.

Refer to the corresponding TMF API documentation to identify the RelatedFieldName values that must be configured for each resource and its associated sub-resources. Proper configuration is essential to ensure the API functions as intended.

The following example defines an Object Integration Definition to capture create events on the Contract entity.

1{
2"ChangeEventType": "Create",
3"ObjectApiName": "Contract",
4"DeveloperName": "AgreementCreationEvent123",
5"MasterLabel":  "AgreementCreationEvent",
6"IntegrationProviderDefId": "0z2LT0000000BMrYAM",
7"RelatedFieldName":"Id"
8}

This example defines an Object Integration Definition to capture update events specifically for changes to the Status field on the Contract entity.

1{
2"FieldApiName":"Status",
3"ChangeEventType":"Update",
4"ObjectApiName":"Contract",
5"DeveloperName":"ContractStatusUpdateEvent123",
6"MasterLabel":"ContractStatusUpdateEvent",
7"IntegrationProviderDefId":"0z2LT0000000BQ5YAM",
8"RelatedFieldName": "Id"
9}

The following example illustrates how to define an Object Integration Definition to capture delete events on the Obligation entity when it is associated with a parent Contract.

1{
2"ChangeEventType": "Delete",
3"ObjectApiName": "Obligation",
4"DeveloperName": "ObligationDeletionEvent123",
5"MasterLabel":  "ObligationDeletionEvent",
6"IntegrationProviderDefId": "0z2LT0000000BOTYA2",
7"RelatedFieldName":"ReferenceObjectId"
8}

1[
2  {
3  "entityId": "0ZzLT00000001gr0AA",
4  "entityName": "Obligation",
5  "eventId": "00000690-691f-ccf0-d64e-7e934b648d6e_1",
6  "commitTimestamp": 1750319450000,
7  "commitNumber": 1750319450000384001,
8  "correlationId": "00000690-691f-ccf0-d64e-7e934b648d6e",
9  "changedFields": {},
10  "changeEventType": "Delete",
11  "enrichedFields": {
12    "ReferenceObjectId": "800LT00000BAR5RYAX"
13     }
14  }
15]

To retrieve or delete an Object Integration Definition Mapping, use the following URL, replacing {ID} with the ID of the mapping. The {ID} is the identifier returned when the Object Integration Definition Mapping is created.

/services/data/v65.0/tooling/sobjects/ObjIntegProviderDefMapping/{ID}

Send a GET request to retrieve the mapping or a DELETE request to remove it.

j

Documentation Changelog

Industry API - Inbound

MuleSoft Direct Integrations - Outbound

Get Started with MuleSoft Direct Integrations

Accept Terms and Enable Access

Deployment Availability of TMF Outbound APIs

TMF620 v4 Product Catalog Management

TMF622 v4 Product Ordering Management

TMF674 v4 Geographic Site

TMF675 v4 Geographic Location

TMF Outbound Notifications Framework

TMF621 v4 Trouble Ticket Management - Outbound Notification

TMF622 v4 Product Ordering Management - Outbound Notification

TMF629 v4 Customer Management - Outbound Notification

TMF632 v4 Party Management - Outbound Notification

TMF637 v4 Product Inventory Management - Outbound Notification

TMF651 v4 Agreement Management - Outbound Notification

Setting Up TMF Notifications - Example Configuration for TMF 622

Resource Mappings

Use Cases

Known Issues

FAQ