---
schema_version: "1"
id: d003eaf79d51f58fcf092ea1da73a3b367660be49643290a37658bacf8d80811
title: Issue Multi-Root Insurance Policy Action
collection: legacydeveloper
version: current
locale: en-us
portal_url: https://docs.salesforce.com/legacydeveloper/current/en-us/insurance_developer_guide/actions_obj_issue_multi_root_insurance_policy.md
canonical_url: https://developer.salesforce.com/docs/atlas.en-us.insurance_developer_guide.meta/insurance_developer_guide/actions_obj_issue_multi_root_insurance_policy.htm
source_site: developer.salesforce.com
content_type: documentation
content_hash: ffe7ada1bfd8cfe93d4b4630865e8825469d170a44d626d27b6d2fb80164ae65
description: Create a new multi-root insurance policy along with its associated child policies asynchronously.
---
# Issue Multi-Root Insurance Policy Action

Create a new multi-root insurance policy along with its associated child policies asynchronously.

This action is available in API version 66.0 and later.

## Supported REST HTTP Methods

**URI**: /services/data/vXX.X/actions/standard/issueMultiRootInsurancePolicy

Where XX.X is the latest API version.

**Formats**: JSON, XML

**HTTP Methods**: POST

**Authentication**: Authorization: Bearer TOKEN

Where TOKEN is your OAuth access token.

## Inputs

| Input | Type | Description |
| --- | --- | --- |
| issueMultiRootPolicyInputRep | Apex-defined | Required. An Apex ConnectApi.IssueMultiRootPolicyInputRep record that contains the details to create a new multi-root insurance policy along with its child policies. To calculate billing, specify billingRecord details if Career Billing is enabled in your org. |

## Outputs

| Output | Type | Description |
| --- | --- | --- |
| jobIdentifier | string | A unique system-generated ID for the asynchronous job that processes the issuance of a new multi-root insurance policy. |

## Example

**POST**

This sample request is for the Issue Multi-Root Insurance Policy action.

{
  "inputs": \[
    {
      "issueMultiRootPolicyInputRep": {
        "contextId": "c98a08a0a9725b7a7d42c35d02e49d80c77a5aae4ea687b0bf09a7997d2af3d3",
        "insurancePolicy": {
          "policyName": "Test Auto Ins policy Via REST",
          "policyNumber": "PLC5678987",
          "effectiveFromDate": "2024-01-01",
          "effectiveToDate": "2024-12-31",
          "referencePolicyNumber": "1011"
        },
        "transactionRecord": {
          "name": "Sold Policy Transaction"
        },
        "billingRecord": {
           "billDayOfMonth": 15,
            "billToContact": "003xx000000001aEAA"
        },
        "additionalInput": \[
          {
            "instanceKey": "AutoBundle2",
            "additionalFieldsList": \[
              {
                "key": "AssetDescription\_\_c",
                "value": "Test\_AssetDescription\_\_c"
              },
              {
                "key": "SourceSystem",
                "value": "Test\_SourceSystem"
              }
            \]
          },
          {
            "instanceKey": "AutoDriver",
            "additionalFieldsList": \[
              {
                "key": "ParticipantName",
                "value": "Test\_ParticipantName"
              },
              {
                "key": "Participant\_Hometown\_\_c",
                "value": "Test\_Participant\_Hometown\_\_c"
              }
            \]
          },
          {
            "instanceKey": "AutoRoot",
            "additionalFieldsList": \[
              {
                "key": "Primary\_Policy\_Holder\_\_c",
                "value": "Test\_Primary\_Policy\_Holder\_\_c"
              },
              {
                "key": "PolicyDescription",
                "value": "Test\_PolicyDescription"
              }
            \]
          },
          {
            "instanceKey": "AutoBundle2\_AutoComp1",
            "additionalFieldsList": \[
              {
                "key": "Coverage\_Description\_\_c",
                "value": "Test\_Coverage\_Description\_\_c"
              },
              {
                "key": "Description",
                "value": "Test\_Description"
              }
            \]
          }
        \]
      }
    }
  \]
}

This is a sample code to call the Issue Multi-Root Insurance Policy action from Apex.

public with sharing class MultiRootPolicyIssuanceInvocable {
    
    /\*\*
     \* Execute Multi-Root Policy Issuance with parameters map
     \* Usage: MultiRootPolicyIssuanceInvocable.executeMultiRootIssuance(paramsMap);
     \* 
     \* @param params Map of parameters:
     \*   - contextId (String, REQUIRED)
     \*   - policyName (String, optional)
     \*   - policyNumber (String, optional)
     \*   - referencePolicyNumber (String, optional)
     \*   - effectiveFromDate (String, optional)
     \*   - effectiveToDate (String, optional)
     \*   - transactionName (String, optional)
     \*   - additionalFields (Map<String, Map<String, String>>, optional)
     \*/
    public static void executeMultiRootIssuance(Map<String, Object> params) {
        // Extract and validate contextId (REQUIRED)
        String contextId = (String) params.get('contextId');
        if (String.isBlank(contextId)) {
            System.debug('ERROR: contextId is required');
            return;
        }
        
        // Multi-Root Issue Policy IA - Create the standard Invocable Action
        Invocable.Action action = Invocable.Action.createStandardAction('issueMultiRootInsurancePolicy');
        
        // Instantiate the IA input object for Multi-Root Policy Issuance
        // IMPORTANT: Use IssueMultiRootPolicyInputRep, NOT IssuePolicyIAInputRep
        ConnectApi.IssueMultiRootPolicyInputRep policyInput = 
            new ConnectApi.IssueMultiRootPolicyInputRep();
        
        // Set context ID (REQUIRED)
        policyInput.contextId = contextId;
        
        // Extract optional parameters
        String policyName = (String) params.get('policyName');
        String policyNumber = (String) params.get('policyNumber');
        String referencePolicyNumber = (String) params.get('referencePolicyNumber');
        String effectiveFromDate = (String) params.get('effectiveFromDate');
        String effectiveToDate = (String) params.get('effectiveToDate');
        String transactionName = (String) params.get('transactionName');
        Map<String, Map<String, String>> additionalFields = 
            (Map<String, Map<String, String>>) params.get('additionalFields');
        
        // Populate Insurance Policy details (using IA classes) - all optional
        if (!String.isBlank(policyName) || !String.isBlank(policyNumber) || 
            !String.isBlank(referencePolicyNumber) || !String.isBlank(effectiveFromDate) || 
            !String.isBlank(effectiveToDate)) {
            
            ConnectApi.InsPolicyIAInputRep insurancePolicy = 
                new ConnectApi.InsPolicyIAInputRep();
            
            if (!String.isBlank(policyName)) {
                insurancePolicy.policyName = policyName;
            }
            if (!String.isBlank(policyNumber)) {
                insurancePolicy.policyNumber = policyNumber;
            }
            if (!String.isBlank(referencePolicyNumber)) {
                insurancePolicy.referencePolicyNumber = referencePolicyNumber;
            }
            if (!String.isBlank(effectiveFromDate)) {
                insurancePolicy.effectiveFromDate = effectiveFromDate;
            }
            if (!String.isBlank(effectiveToDate)) {
                insurancePolicy.effectiveToDate = effectiveToDate;
            }
            
            policyInput.insurancePolicy = insurancePolicy;
        }
        
        // Populate Transaction record (using IA transaction representation) - optional
        if (!String.isBlank(transactionName)) {
            ConnectApi.InsPolicyTrxnIAInputRep transactionRecord = 
                new ConnectApi.InsPolicyTrxnIAInputRep();
            transactionRecord.name = transactionName;
            policyInput.transactionRecord = transactionRecord;
        }
        
        // Populate additional input for multi-root policies - optional
        if (additionalFields != null && !additionalFields.isEmpty()) {
            List<ConnectApi.InsPolicyAddlInputIARep> additionalInputList = new List<ConnectApi.InsPolicyAddlInputIARep>();
            
            for (String instanceKey : additionalFields.keySet()) {
                ConnectApi.InsPolicyAddlInputIARep additionalInput = 
                    new ConnectApi.InsPolicyAddlInputIARep();
                
                // Set instance key (e.g., "AutoSilver", "FamilyHealth")
                additionalInput.instanceKey = instanceKey;
                
                // Build additional fields list for this instance
                Map<String, String> fieldsMap = additionalFields.get(instanceKey);
                if (fieldsMap != null && !fieldsMap.isEmpty()) {
                    List<ConnectApi.AdditionalFieldIARep> fieldsList = new List<ConnectApi.AdditionalFieldIARep>();
                    
                    for (String fieldKey : fieldsMap.keySet()) {
                        ConnectApi.AdditionalFieldIARep field = new ConnectApi.AdditionalFieldIARep();
                        field.key = fieldKey;
                        field.value = fieldsMap.get(fieldKey);
                        fieldsList.add(field);
                    }
                    
                    additionalInput.additionalFieldsList = fieldsList;
                }
                
                additionalInputList.add(additionalInput);
            }
            
            policyInput.additionalInput = additionalInputList;
        }
        
        // Set invocation parameters
        // IMPORTANT: Parameter name is issueMultiRootPolicyInputRep (camelCase)
        action.setInvocationParameter('issueMultiRootPolicyInputRep', policyInput);
        
        System.debug('Starting Multi-Root Policy Issuance Invocable Action (issueMultiRootInsurancePolicy)...');
        System.debug('Context ID: ' + contextId);
        if (!String.isBlank(policyName)) {
            System.debug('Policy Name: ' + policyName);
        }
        
        try {
            // Invoke the action
            List<Invocable.Action.Result> results = action.invoke();
            
            System.debug('Multi-Root Policy Issuance IA result = ' + results);
            
            // Process results
            for (Invocable.Action.Result result : results) {
                if (result.isSuccess()) {
                    System.debug('SUCCESS: Multi-Root Policy Issuance completed successfully!');
                    Object outputValue = result.getOutputParameters().get('jobIdentifier');
                    if (outputValue != null) {
                        System.debug('Job Identifier: ' + outputValue);
                    } else {
                        System.debug('Multi-Root Policy Issuance job started - result: ' + result.getOutputParameters());
                    }
                } else {
                    System.debug('ERROR: Multi-Root Policy Issuance failed');
                    System.debug('Error Details: ' + result.getErrors());
                }
            }
            
        } catch (Exception e) {
            System.debug('EXCEPTION in Multi-Root Policy Issuance Invocable Action: ' + e.getMessage());
            System.debug('Stack Trace: ' + e.getStackTraceString());
        }
    }
}


/\*
 \* USAGE EXAMPLE:
 \* Copy and paste this code into Developer Console Execute Anonymous Window
 \*/
Map<String, Object> params = new Map<String, Object>();
params.put('contextId', <your-context-id-here>);
params.put('policyName', 'James Multi-Root Policy');
params.put('policyNumber', 'James Multi-Root Policy');
params.put('referencePolicyNumber', 'James1234');
params.put('effectiveFromDate', '2026-01-01');
params.put('effectiveToDate', '2026-10-31');
params.put('transactionName', 'Sold Policy Transaction');

// Build additional fields configuration
Map<String, Map<String, String>> additionalFields = new Map<String, Map<String, String>>();

// Configuration for AutoSilver instance
Map<String, String> autoFields = new Map<String, String>();
autoFields.put('PolicyName', 'James Auto Policy');
autoFields.put('Name', 'James Auto Policy');
additionalFields.put(<your-instanceKey-goes-here>, autoFields);

// Configuration for FamilyHealth instance
Map<String, String> healthFields = new Map<String, String>();
healthFields.put('PolicyName', 'James Medical Policy');
healthFields.put('Name', 'James Medical Policy');
additionalFields.put(<your-instanceKey-goes-here>, healthFields);

params.put('additionalFields', additionalFields);

MultiRootPolicyIssuanceInvocable.executeMultiRootIssuance(params);

This sample response is for the Issue Multi-Root Insurance Policy action.

\[
  {
    "actionName": "issueMultiRootInsurancePolicy",
    "errors": null,
    "invocationId": null,
    "isSuccess": true,
    "outcome": null,
    "outputValues": {
      "jobIdentifier": "55SG000000PgSH4A0"
    },
    "sortOrder": -1,
    "version": 1
  }
\]