# Policy Transactions API



<EndpointIndex
  names={[
  	'fetchTransaction',
  	'fetchPolicyTransactionWithUpdatedChanges',
  	'getTransactionsBranchesByPolicy',
  	'fetchTransactionSegment',
  	'fetchPolicySegment',
  	'fetchIssuedTransactions',
  	'createPolicyTransaction',
  	'changePolicy',
  	'renewPolicy',
  	'cancelPolicy',
  	'reinstatePolicy',
  	'reversePolicyChange',
  	'initializeTransaction',
  	'addElementsToPolicyWithTransaction',
  	'updateElementsInPolicyWithTransaction',
  	'removeElementsFromPolicyWithTransaction',
  	'createPolicyChangeInstruction',
  	'updateChangeInstruction',
  	'deleteChangeInstructionFromTransaction',
  	'validateTransaction',
  	'transactionValidatePreview',
  	'priceTransaction',
  	'fetchTransactionPricing',
  	'transactionPricePreview',
  	'underwriteTransaction',
  	'underwritePreview',
  	'updateUnderwritingFlagsForPolicyTransaction',
  	'fetchUnderwritingFlagsForTransaction',
  	'addApproveUnderwritingFlagsForTransaction',
  	'addDeclineUnderwritingFlagsForTransaction',
  	'addBlockUnderwritingFlagsForTransaction',
  	'addRejectUnderwritingFlagsForTransaction',
  	'addInfoUnderwritingFlagsForTransaction',
  	'clearApproveUnderwritingFlagsForTransaction',
  	'clearDeclineUnderwritingFlagsForTransaction',
  	'clearBlockUnderwritingFlagsForTransaction',
  	'clearRejectUnderwritingFlagsForTransaction',
  	'clearInfoUnderwritingFlagsForTransaction',
  	'acceptTransaction',
  	'issueTransaction',
  	'fetchPreferencesForATransaction',
  	'fetchAffectedTransactions',
  	'resetTransaction',
  	'refuseTransaction',
  	'discardTransaction',
  	'precommitTransaction',
  	'fetchAffectedTransactionsForListEndpoint',
  	'fetchTransactionSegments',
  	'fetchPolicySegmentEx',
  ]}
  titles={{
  	fetchTransaction: 'Fetch a Transaction',
  	getTransactionsBranchesByPolicy: 'Fetch Transaction Branches by Policy',
  	fetchTransactionSegment: 'Fetch Policy Segment for a Transaction',
  	fetchPolicySegment: 'Fetch a Policy Segment',
  	createPolicyTransaction: 'Create a Transaction',
  	changePolicy: 'Create a Policy Change Transaction',
  	renewPolicy: 'Create a Renewal Transaction',
  	cancelPolicy: 'Create a Cancellation Transaction',
  	reinstatePolicy: 'Create a Reinstatement Transaction',
  	reversePolicyChange: 'Create a Reversal Transaction',
  	createPolicyChangeInstruction: 'Add a Change Instruction to a Transaction',
  	updateChangeInstruction:
  		"Update One of a Transaction's Change Instructions",
  	deleteChangeInstructionFromTransaction:
  		'Delete a Change Instruction from a Transaction',
  	validateTransaction: 'Validate a Transaction',
  	transactionValidatePreview:
  		'Get a stateless validation preview for a hypothetical transaction',
  	priceTransaction: 'Price a Transaction',
  	fetchTransactionPricing: 'Fetch Pricing for a Transaction',
  	transactionPricePreview:
  		'Get a stateless price preview for a hypothetical transaction',
  	underwriteTransaction: 'Underwrite a Transaction',
  	underwritePreview:
  		'Get a stateless underwriting preview for a hypothetical transaction',
  	updateUnderwritingFlagsForPolicyTransaction:
  		"Update a Transaction's Underwriting Flags",
  	fetchUnderwritingFlagsForTransaction: 'Fetch Underwriting Flags',
  	addApproveUnderwritingFlagsForTransaction:
  		'Add Approve Level Underwriting Flag for Transaction',
  	addDeclineUnderwritingFlagsForTransaction:
  		'Add Decline Level Underwriting Flag for Transaction',
  	addBlockUnderwritingFlagsForTransaction:
  		'Add Block Level Underwriting Flag for Transaction',
  	addRejectUnderwritingFlagsForTransaction:
  		'Add Reject Level Underwriting Flag for Transaction',
  	addInfoUnderwritingFlagsForTransaction:
  		'Add Info Level Underwriting Flag for Transaction',
  	clearApproveUnderwritingFlagsForTransaction:
  		'Clear Approve Level Underwriting Flag for Transaction',
  	clearDeclineUnderwritingFlagsForTransaction:
  		'Clear Decline Level Underwriting Flag for Transaction',
  	clearBlockUnderwritingFlagsForTransaction:
  		'Clear Block Level Underwriting Flag for Transaction',
  	clearRejectUnderwritingFlagsForTransaction:
  		'Clear Reject Level Underwriting Flag for Transaction',
  	clearInfoUnderwritingFlagsForTransaction:
  		'Clear Info Level Underwriting Flag for Transaction',
  	acceptTransaction: 'Accept a Transaction',
  	issueTransaction: 'Issue a Transaction',
  	resetTransaction: 'Reset a Transaction',
  	refuseTransaction: 'Refuse a Transaction',
  	discardTransaction: 'Discard a Transaction',
  	precommitTransaction:
  		'Invoke the precommit plugin for a draft or initialized transaction',
  }}
/>

Main Flow [#main-flow]

<Callout>
  For unissued transactions that are elible for issuance, you can attempt to advance to any subsequent state. If the transaction fails to validate, the response will be `HTTP 200`, but the transaction itself will not be in the requested new state. The actual state of the transaction will be included in the payload.
</Callout>

Fetch [#fetch]

Fetch a Transaction [#fetch-a-transaction]

<ApiEndpoint name="fetchTransaction" title="Fetch a Transaction" />

<ApiSchema name="PolicyTransactionResponse" />

<Callout>
  The `staticLocator` of the transaction equals the `locator` for the original version of a transaction. When transactions are reapplied, as in [out-of-sequence transactions](/features/policy-management/out-of-sequence-transactions), the `staticLocator` will equal the `staticLocator` of the transaction this it is based on.
</Callout>

<ApiSchema name="PreferencesResponse" />

<ApiSchema name="InstallmentPreferences" />

Fetch Policy Transaction With Updated Changes [#fetch-policy-transaction-with-updated-changes]

<ApiEndpoint name="fetchPolicyTransactionWithUpdatedChanges" />

Fetch Transaction Branches by Policy [#fetch-transaction-branches-by-policy]

<ApiEndpoint name="getTransactionsBranchesByPolicy" title="Fetch Transaction Branches by Policy" />

Fetch Policy Segment for a Transaction [#fetch-policy-segment-for-a-transaction]

<ApiEndpoint name="fetchTransactionSegment" title="Fetch Policy Segment for a Transaction" />

Fetch a Policy Segment [#fetch-a-policy-segment]

<ApiEndpoint name="fetchPolicySegment" title="Fetch a Policy Segment" />

<ApiSchema name="SegmentResponse" />

<ApiSchema name="ProducerInfo" />

<ApiSchema name="ChangeInstructionResponse" />

<ApiSchema name="AddChangeInstructionResponse" />

<ApiSchema name="ModifyChangeInstructionResponse" />

<ApiSchema name="ParamsChangeInstructionResponse" />

<ApiSchema name="DeleteChangeInstructionResponse" />

<ApiSchema name="ProducersChangeInstructionResponse" />

<ApiSchema name="MigrateChangeInstructionResponse" />

Fetch Issued Transactions [#fetch-issued-transactions]

<ApiEndpoint name="fetchIssuedTransactions" />

<ApiSchema name="PolicyTransactionListResponse" />

Transaction Creation [#transaction-creation]

Create a Transaction [#create-a-transaction]

<ApiEndpoint name="createPolicyTransaction" title="Create a Transaction" />

Create a Policy Change Transaction [#create-a-policy-change-transaction]

<ApiEndpoint name="changePolicy" title="Create a Policy Change Transaction" />

Create a Renewal Transaction [#create-a-renewal-transaction]

<ApiEndpoint name="renewPolicy" title="Create a Renewal Transaction" />

Create a Cancellation Transaction [#create-a-cancellation-transaction]

<ApiEndpoint name="cancelPolicy" title="Create a Cancellation Transaction" />

Create a Reinstatement Transaction [#create-a-reinstatement-transaction]

<ApiEndpoint name="reinstatePolicy" title="Create a Reinstatement Transaction" />

<ApiSchema name="AddChangeInstructionCreateRequest" />

<ApiSchema name="ParamsChangeInstructionCreateRequest" />

<ApiSchema name="ModifyChangeInstructionCreateRequest" />

<ApiSchema name="DeleteChangeInstructionCreateRequest" />

<ApiSchema name="ProducersChangeInstructionCreateRequest" />

<ApiSchema name="MigrateChangeInstructionCreateRequest" />

Create a Reversal Transaction [#create-a-reversal-transaction]

<ApiEndpoint name="reversePolicyChange" title="Create a Reversal Transaction" />

<ApiSchema name="PolicyTransactionReversalRequest" />

Updating [#updating]

Initialize Transaction [#initialize-transaction]

<ApiEndpoint name="initializeTransaction" />

Add Elements To Policy With Transaction [#add-elements-to-policy-with-transaction]

<ApiEndpoint name="addElementsToPolicyWithTransaction" />

Update Elements In Policy With Transaction [#update-elements-in-policy-with-transaction]

<ApiEndpoint name="updateElementsInPolicyWithTransaction" />

Remove Elements From Policy With Transaction [#remove-elements-from-policy-with-transaction]

<ApiEndpoint name="removeElementsFromPolicyWithTransaction" />

Add a Change Instruction to a Transaction [#add-a-change-instruction-to-a-transaction]

<ApiEndpoint name="createPolicyChangeInstruction" title="Add a Change Instruction to a Transaction" />

Update One of a Transaction's Change Instructions [#update-one-of-a-transactions-change-instructions]

<ApiEndpoint name="updateChangeInstruction" title="Update One of a Transaction's Change Instructions" />

Delete a Change Instruction from a Transaction [#delete-a-change-instruction-from-a-transaction]

<ApiEndpoint name="deleteChangeInstructionFromTransaction" title="Delete a Change Instruction from a Transaction" />

<Callout>
  Transactions can only be updated when they are in `draft` state.
</Callout>

Validation [#validation]

Validate a Transaction [#validate-a-transaction]

<ApiEndpoint name="validateTransaction" title="Validate a Transaction" />

<ApiSchema name="ValidationResult" />

<ApiSchema name="ValidationItemResponse" />

Get a stateless validation preview for a hypothetical transaction [#get-a-stateless-validation-preview-for-a-hypothetical-transaction]

<ApiEndpoint name="transactionValidatePreview" title="Get a stateless validation preview for a hypothetical transaction" />

Pricing [#pricing]

Price a Transaction [#price-a-transaction]

<ApiEndpoint name="priceTransaction" title="Price a Transaction" />

Fetch Pricing for a Transaction [#fetch-pricing-for-a-transaction]

<ApiEndpoint name="fetchTransactionPricing" title="Fetch Pricing for a Transaction" />

<ApiSchema name="TransactionPriceResponse" />

<ApiSchema name="PolicyChargeResponse" />

Get a stateless price preview for a hypothetical transaction [#get-a-stateless-price-preview-for-a-hypothetical-transaction]

<ApiEndpoint name="transactionPricePreview" title="Get a stateless price preview for a hypothetical transaction" />

<span id="policyTransactionUnderwritingApi" />

Underwriting [#underwriting]

Underwrite a Transaction [#underwrite-a-transaction]

<ApiEndpoint name="underwriteTransaction" title="Underwrite a Transaction" />

<ApiSchema name="TransactionUnderwritingResponse" />

Get a stateless underwriting preview for a hypothetical transaction [#get-a-stateless-underwriting-preview-for-a-hypothetical-transaction]

<ApiEndpoint name="underwritePreview" title="Get a stateless underwriting preview for a hypothetical transaction" />

Underwriting Flags [#underwriting-flags]

Update a Transaction's Underwriting Flags [#update-a-transactions-underwriting-flags]

<ApiEndpoint name="updateUnderwritingFlagsForPolicyTransaction" title="Update a Transaction's Underwriting Flags" />

Fetch Underwriting Flags [#fetch-underwriting-flags]

<ApiEndpoint name="fetchUnderwritingFlagsForTransaction" title="Fetch Underwriting Flags" />

<ApiSchema name="TransactionUnderwritingFlagsResponse" />

<ApiSchema name="UnderwritingFlagResponse" />

Add Approve Level Underwriting Flag for Transaction [#add-approve-level-underwriting-flag-for-transaction]

<ApiEndpoint name="addApproveUnderwritingFlagsForTransaction" title="Add Approve Level Underwriting Flag for Transaction" />

Add Decline Level Underwriting Flag for Transaction [#add-decline-level-underwriting-flag-for-transaction]

<ApiEndpoint name="addDeclineUnderwritingFlagsForTransaction" title="Add Decline Level Underwriting Flag for Transaction" />

Add Block Level Underwriting Flag for Transaction [#add-block-level-underwriting-flag-for-transaction]

<ApiEndpoint name="addBlockUnderwritingFlagsForTransaction" title="Add Block Level Underwriting Flag for Transaction" />

Add Reject Level Underwriting Flag for Transaction [#add-reject-level-underwriting-flag-for-transaction]

<ApiEndpoint name="addRejectUnderwritingFlagsForTransaction" title="Add Reject Level Underwriting Flag for Transaction" />

Add Info Level Underwriting Flag for Transaction [#add-info-level-underwriting-flag-for-transaction]

<ApiEndpoint name="addInfoUnderwritingFlagsForTransaction" title="Add Info Level Underwriting Flag for Transaction" />

Clear Approve Level Underwriting Flag for Transaction [#clear-approve-level-underwriting-flag-for-transaction]

<ApiEndpoint name="clearApproveUnderwritingFlagsForTransaction" title="Clear Approve Level Underwriting Flag for Transaction" />

Clear Decline Level Underwriting Flag for Transaction [#clear-decline-level-underwriting-flag-for-transaction]

<ApiEndpoint name="clearDeclineUnderwritingFlagsForTransaction" title="Clear Decline Level Underwriting Flag for Transaction" />

Clear Block Level Underwriting Flag for Transaction [#clear-block-level-underwriting-flag-for-transaction]

<ApiEndpoint name="clearBlockUnderwritingFlagsForTransaction" title="Clear Block Level Underwriting Flag for Transaction" />

Clear Reject Level Underwriting Flag for Transaction [#clear-reject-level-underwriting-flag-for-transaction]

<ApiEndpoint name="clearRejectUnderwritingFlagsForTransaction" title="Clear Reject Level Underwriting Flag for Transaction" />

Clear Info Level Underwriting Flag for Transaction [#clear-info-level-underwriting-flag-for-transaction]

<ApiEndpoint name="clearInfoUnderwritingFlagsForTransaction" title="Clear Info Level Underwriting Flag for Transaction" />

Acceptance [#acceptance]

Accept a Transaction [#accept-a-transaction]

<ApiEndpoint name="acceptTransaction" title="Accept a Transaction" />

Issuance [#issuance]

Issue a Transaction [#issue-a-transaction]

<ApiEndpoint name="issueTransaction" title="Issue a Transaction" />

Documents [#documents]

Fetch Documents For Transaction [#fetch-documents-for-transaction]

<ApiEndpoint name="fetchDocumentsForTransaction" />

Fetch Documents For Segment [#fetch-documents-for-segment]

<ApiEndpoint name="fetchDocumentsForSegment" />

<ApiSchema name="DocumentInstanceResponse" />

Transaction Details [#transaction-details]

Fetch Preferences For ATransaction [#fetch-preferences-for-atransaction]

<ApiEndpoint name="fetchPreferencesForATransaction" />

Fetch Affected Transactions [#fetch-affected-transactions]

<ApiEndpoint name="fetchAffectedTransactions" />

<ApiSchema name="AffectedTransaction" />

Atypical States and Operations [#atypical-states-and-operations]

Reset a Transaction [#reset-a-transaction]

<ApiEndpoint name="resetTransaction" title="Reset a Transaction" />

<ApiSchema name="ResetOptions" />

<Callout>
  If the query parameter `resetToDraft` is `true`, then the transaction will revert to `draft` state and the generated segment data, including elements and data, will be discarded. If `false` (the default), then the transaction will revert to `initialized` state and the segment data will be retained. This is useful to preserve the locator data for generated elements.
</Callout>

Refuse a Transaction [#refuse-a-transaction]

<ApiEndpoint name="refuseTransaction" title="Refuse a Transaction" />

Discard a Transaction [#discard-a-transaction]

<ApiEndpoint name="discardTransaction" title="Discard a Transaction" />

Invoke the precommit plugin for a draft or initialized transaction [#invoke-the-precommit-plugin-for-a-draft-or-initialized-transaction]

<ApiEndpoint name="precommitTransaction" title="Invoke the precommit plugin for a draft or initialized transaction" />

Deprecated Items [#deprecated-items]

Fetch Affected Transactions For List Endpoint [#fetch-affected-transactions-for-list-endpoint]

<ApiEndpoint name="fetchAffectedTransactionsForListEndpoint" />

Fetch Transaction Segments [#fetch-transaction-segments]

<ApiEndpoint name="fetchTransactionSegments" />

Fetch Policy Segment Ex [#fetch-policy-segment-ex]

<ApiEndpoint name="fetchPolicySegmentEx" />


## API Reference

GET /policy/{tenantLocator}/transactions/{locator} — fetchTransaction
Tags: transactions-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 PolicyTransactionResponse — OK

GET /policy/{tenantLocator}/transactions/{locator}/elements/changes — fetchPolicyTransactionWithUpdatedChanges
Tags: transactions-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 PolicyTransactionResponse — OK

GET /policy/{tenantLocator}/policies/{locator}/branches — getTransactionsBranchesByPolicy
Tags: policies-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 map<string, PolicyTransactionResponse[]> — OK

GET /policy/{tenantLocator}/transactions/{locator}/segment — fetchTransactionSegment
Tags: transactions-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 SegmentResponse — OK

GET /policy/{tenantLocator}/transactions/segments/{segmentLocator} — fetchPolicySegment
Tags: transactions-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  segmentLocator (ulid, path, required)
Responses:
  200 SegmentResponse — OK

GET /policy/{tenantLocator}/policies/{locator}/issuedTransactions/list — fetchIssuedTransactions
Fetches the 'local stack' of issued transactions, excluding those that have been reversed or reapplied
Tags: policies-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  offset (integer, query)
  count (integer, query)
  extended (boolean, query) — When false, returns a bare array.
Responses:
  200 PolicyTransactionListResponse — OK

PATCH /policy/{tenantLocator}/policies/{locator}/{transactionType} — createPolicyTransaction
Tags: policies-controller
Permissions: write
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  transactionType (string, path, required)
  baseLocator (ulid, query)
Request body (oneOf<AddChangeInstructionCreateRequest,DeleteChangeInstructionCreateRequest,MigrateChangeInstructionCreateRequest,ModifyChangeInstructionCreateRequest,ParamsChangeInstructionCreateRequest,ProducersChangeInstructionCreateRequest>[]):
Responses:
  200 PolicyTransactionResponse — OK

PATCH /policy/{tenantLocator}/policies/{locator}/change — changePolicy
Tags: policies-controller
Permissions: write
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  baseLocator (ulid, query)
Request body (oneOf<AddChangeInstructionCreateRequest,DeleteChangeInstructionCreateRequest,MigrateChangeInstructionCreateRequest,ModifyChangeInstructionCreateRequest,ParamsChangeInstructionCreateRequest,ProducersChangeInstructionCreateRequest>[]):
Responses:
  200 PolicyTransactionResponse — OK

PATCH /policy/{tenantLocator}/policies/{locator}/renew — renewPolicy
Tags: policies-controller
Permissions: write
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  baseLocator (ulid, query)
Request body (oneOf<AddChangeInstructionCreateRequest,DeleteChangeInstructionCreateRequest,MigrateChangeInstructionCreateRequest,ModifyChangeInstructionCreateRequest,ParamsChangeInstructionCreateRequest,ProducersChangeInstructionCreateRequest>[]):
Responses:
  200 PolicyTransactionResponse — OK

PATCH /policy/{tenantLocator}/policies/{locator}/cancel — cancelPolicy
Tags: policies-controller
Permissions: write
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  baseLocator (ulid, query)
Request body (ParamsChangeInstructionCreateRequest):
Responses:
  200 PolicyTransactionResponse — OK

PATCH /policy/{tenantLocator}/policies/{locator}/reinstate — reinstatePolicy
Tags: policies-controller
Permissions: write
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  baseLocator (ulid, query)
Request body (oneOf<AddChangeInstructionCreateRequest,DeleteChangeInstructionCreateRequest,MigrateChangeInstructionCreateRequest,ModifyChangeInstructionCreateRequest,ParamsChangeInstructionCreateRequest,ProducersChangeInstructionCreateRequest>[]):
Responses:
  200 PolicyTransactionResponse — OK

PATCH /policy/{tenantLocator}/policies/{locator}/reversal — reversePolicyChange
Tags: policies-controller
Permissions: write
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Request body (PolicyTransactionReversalRequest):
Responses:
  200 PolicyTransactionResponse — OK

PATCH /policy/{tenantLocator}/transactions/{locator}/initialize — initializeTransaction
Tags: transactions-controller
Permissions: write, initialize
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 PolicyTransactionResponse — OK

PUT /policy/{tenantLocator}/transactions/{locator}/elements — addElementsToPolicyWithTransaction
Tags: transactions-controller
Permissions: write, elements-add
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Request body (ElementCreateRequest[]):
Responses:
  200 SegmentResponse[] — OK

PATCH /policy/{tenantLocator}/transactions/{locator}/elements — updateElementsInPolicyWithTransaction
Tags: transactions-controller
Permissions: write, elements-update
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Request body (ElementUpdateRequest):
Responses:
  200 SegmentResponse[] — OK

DELETE /policy/{tenantLocator}/transactions/{locator}/elements — removeElementsFromPolicyWithTransaction
Tags: transactions-controller
Permissions: write, elements-delete
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Request body (ulid[]):
Responses:
  200 SegmentResponse[] — OK

PUT /policy/{tenantLocator}/transactions/{locator}/changeInstructions — createPolicyChangeInstruction
Tags: transactions-controller
Permissions: write, change-instruction-add
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Request body (oneOf<AddChangeInstructionCreateRequest,DeleteChangeInstructionCreateRequest,MigrateChangeInstructionCreateRequest,ModifyChangeInstructionCreateRequest,ParamsChangeInstructionCreateRequest,ProducersChangeInstructionCreateRequest>):
Responses:
  200 PolicyTransactionResponse — OK

PATCH /policy/{tenantLocator}/transactions/{locator}/changeInstructions/{instructionLocator} — updateChangeInstruction
Tags: transactions-controller
Permissions: write, change-instruction-update
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  instructionLocator (ulid, path, required)
Request body (oneOf<AddChangeInstructionCreateRequest,DeleteChangeInstructionCreateRequest,MigrateChangeInstructionCreateRequest,ModifyChangeInstructionCreateRequest,ParamsChangeInstructionCreateRequest,ProducersChangeInstructionCreateRequest>):
Responses:
  200 PolicyTransactionResponse — OK

DELETE /policy/{tenantLocator}/transactions/{locator}/changeInstructions/{instructionLocator} — deleteChangeInstructionFromTransaction
Tags: transactions-controller
Permissions: write, change-instruction-delete
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  instructionLocator (ulid, path, required)
Responses:
  200 PolicyTransactionResponse — OK

PATCH /policy/{tenantLocator}/transactions/{locator}/validate — validateTransaction
Tags: transactions-controller
Permissions: write, validate
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  stateless (boolean, query)
Responses:
  200 PolicyTransactionResponse — OK

PATCH /policy/{tenantLocator}/policies/{locator}/{transactionType}/validatePreview — transactionValidatePreview
Tags: policies-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  transactionType (string, path, required)
  baseLocator (ulid, query)
Request body (oneOf<AddChangeInstructionCreateRequest,DeleteChangeInstructionCreateRequest,MigrateChangeInstructionCreateRequest,ModifyChangeInstructionCreateRequest,ParamsChangeInstructionCreateRequest,ProducersChangeInstructionCreateRequest>[]):
Responses:
  200 PolicyTransactionResponse — OK

PATCH /policy/{tenantLocator}/transactions/{locator}/price — priceTransaction
Tags: transactions-controller
Permissions: write, price
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  stateless (boolean, query)
Responses:
  200 TransactionPriceResponse — OK

GET /policy/{tenantLocator}/transactions/{locator}/price — fetchTransactionPricing
Tags: transactions-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 TransactionPriceResponse — OK

PATCH /policy/{tenantLocator}/policies/{locator}/{transactionType}/pricePreview — transactionPricePreview
Tags: policies-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  transactionType (string, path, required)
  baseLocator (ulid, query)
Request body (oneOf<AddChangeInstructionCreateRequest,DeleteChangeInstructionCreateRequest,MigrateChangeInstructionCreateRequest,ModifyChangeInstructionCreateRequest,ParamsChangeInstructionCreateRequest,ProducersChangeInstructionCreateRequest>[]):
Responses:
  200 TransactionPriceResponse — OK

PATCH /policy/{tenantLocator}/transactions/{locator}/underwrite — underwriteTransaction
Tags: transactions-controller
Permissions: write, underwrite
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  stateless (boolean, query)
Responses:
  200 TransactionUnderwritingResponse — OK

PATCH /policy/{tenantLocator}/policies/{locator}/{transactionType}/underwritePreview — underwritePreview
Tags: policies-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  transactionType (string, path, required)
  baseLocator (ulid, query)
Request body (oneOf<AddChangeInstructionCreateRequest,DeleteChangeInstructionCreateRequest,MigrateChangeInstructionCreateRequest,ModifyChangeInstructionCreateRequest,ParamsChangeInstructionCreateRequest,ProducersChangeInstructionCreateRequest>[]):
Responses:
  200 TransactionUnderwritingResponse — OK

PATCH /policy/{tenantLocator}/transactions/{locator}/underwritingFlags — updateUnderwritingFlagsForPolicyTransaction
Tags: transactions-controller
Permissions: write
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Request body (UnderwritingFlagsUpdateRequest):
Responses:
  200 TransactionUnderwritingFlagsResponse — OK

GET /policy/{tenantLocator}/transactions/{locator}/underwritingFlags — fetchUnderwritingFlagsForTransaction
Tags: transactions-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 TransactionUnderwritingFlagsResponse — OK

POST /policy/{tenantLocator}/transactions/{locator}/underwritingFlags/approve — addApproveUnderwritingFlagsForTransaction
Tags: transactions-controller
Permissions: write, approve-add
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Request body (UnderwritingFlagCreateRequest):
Responses:
  200 TransactionUnderwritingFlagsResponse — OK

POST /policy/{tenantLocator}/transactions/{locator}/underwritingFlags/decline — addDeclineUnderwritingFlagsForTransaction
Tags: transactions-controller
Permissions: write, decline-add
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Request body (UnderwritingFlagCreateRequest):
Responses:
  200 TransactionUnderwritingFlagsResponse — OK

POST /policy/{tenantLocator}/transactions/{locator}/underwritingFlags/block — addBlockUnderwritingFlagsForTransaction
Tags: transactions-controller
Permissions: write, block-add
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Request body (UnderwritingFlagCreateRequest):
Responses:
  200 TransactionUnderwritingFlagsResponse — OK

POST /policy/{tenantLocator}/transactions/{locator}/underwritingFlags/reject — addRejectUnderwritingFlagsForTransaction
Tags: transactions-controller
Permissions: write, reject-add
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Request body (UnderwritingFlagCreateRequest):
Responses:
  200 TransactionUnderwritingFlagsResponse — OK

POST /policy/{tenantLocator}/transactions/{locator}/underwritingFlags/info — addInfoUnderwritingFlagsForTransaction
Tags: transactions-controller
Permissions: write, info-add
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Request body (UnderwritingFlagCreateRequest):
Responses:
  200 TransactionUnderwritingFlagsResponse — OK

DELETE /policy/{tenantLocator}/transactions/{locator}/underwritingFlags/approve/{flagLocator} — clearApproveUnderwritingFlagsForTransaction
Tags: transactions-controller
Permissions: write, approve-clear
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  flagLocator (ulid, path, required)
Responses:
  200 TransactionUnderwritingFlagsResponse — OK

DELETE /policy/{tenantLocator}/transactions/{locator}/underwritingFlags/decline/{flagLocator} — clearDeclineUnderwritingFlagsForTransaction
Tags: transactions-controller
Permissions: write, decline-clear
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  flagLocator (ulid, path, required)
Responses:
  200 TransactionUnderwritingFlagsResponse — OK

DELETE /policy/{tenantLocator}/transactions/{locator}/underwritingFlags/block/{flagLocator} — clearBlockUnderwritingFlagsForTransaction
Tags: transactions-controller
Permissions: write, block-clear
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  flagLocator (ulid, path, required)
Responses:
  200 TransactionUnderwritingFlagsResponse — OK

DELETE /policy/{tenantLocator}/transactions/{locator}/underwritingFlags/reject/{flagLocator} — clearRejectUnderwritingFlagsForTransaction
Tags: transactions-controller
Permissions: write, reject-clear
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  flagLocator (ulid, path, required)
Responses:
  200 TransactionUnderwritingFlagsResponse — OK

DELETE /policy/{tenantLocator}/transactions/{locator}/underwritingFlags/info/{flagLocator} — clearInfoUnderwritingFlagsForTransaction
Tags: transactions-controller
Permissions: write, info-clear
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  flagLocator (ulid, path, required)
Responses:
  200 TransactionUnderwritingFlagsResponse — OK

PATCH /policy/{tenantLocator}/transactions/{locator}/accept — acceptTransaction
Tags: transactions-controller
Permissions: write, accept
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 PolicyTransactionResponse — OK

PATCH /policy/{tenantLocator}/transactions/{locator}/issue — issueTransaction
Tags: transactions-controller
Permissions: write, issue
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  autoRebase (boolean, query)
Responses:
  200 PolicyTransactionResponse — OK

GET /document/{tenantLocator}/documents/transaction/{locator}/list — fetchDocumentsForTransaction
Tags: transaction-documents-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  offset (integer, query)
  count (integer, query)
  extended (boolean, query) — When false, returns a bare array.
  suppressRenderingData (boolean, query)
Responses:
  200 DocumentListResponse — OK

GET /document/{tenantLocator}/documents/segment/{locator}/list — fetchDocumentsForSegment
Tags: segment-documents-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  offset (integer, query)
  count (integer, query)
  extended (boolean, query) — When false, returns a bare array.
  suppressRenderingData (boolean, query)
Responses:
  200 DocumentListResponse — OK

GET /policy/{tenantLocator}/transactions/{locator}/preferences — fetchPreferencesForATransaction
Tags: transactions-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 PreferencesResponse — OK

GET /policy/{tenantLocator}/transactions/{locator}/affectedTransactions — fetchAffectedTransactions
Tags: transactions-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 AffectedTransaction[] — OK

PATCH /policy/{tenantLocator}/transactions/{locator}/reset — resetTransaction
Tags: transactions-controller
Permissions: write, reset
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  resetToDraft (boolean, query)
Request body (ResetOptions):
Responses:
  200 PolicyTransactionResponse — OK

PATCH /policy/{tenantLocator}/transactions/{locator}/refuse — refuseTransaction
Tags: transactions-controller
Permissions: write, refuse
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 PolicyTransactionResponse — OK

PATCH /policy/{tenantLocator}/transactions/{locator}/discard — discardTransaction
Tags: transactions-controller
Permissions: write, discard
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 PolicyTransactionResponse — OK

PATCH /policy/{tenantLocator}/transactions/{locator}/precommit — precommitTransaction
Tags: transactions-controller
Permissions: write, precommit
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 PolicyTransactionResponse — OK

GET /policy/{tenantLocator}/transactions/{locator}/affectedTransactions/list — fetchAffectedTransactionsForListEndpoint
Tags: transactions-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 AffectedTransaction[] — OK

GET /policy/{tenantLocator}/transactions/{locator}/segments/list — fetchTransactionSegments
Tags: transactions-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
Responses:
  200 SegmentResponse[] — OK

GET /policy/{tenantLocator}/transactions/{locator}/segments/{segmentLocator} — fetchPolicySegmentEx
Tags: transactions-controller
Permissions: read
Parameters:
  tenantLocator (uuid, path, required)
  locator (ulid, path, required)
  segmentLocator (ulid, path, required)
Responses:
  200 SegmentResponse — OK

PolicyTransactionResponse
Properties:
  locator (ulid, required)
  transactionCategory (Enum issuance | change | renewal | cancellation | reinstatement | reversal | aggregate, required)
  transactionState (Enum draft | initialized | validated | earlyUnderwritten | priced | underwritten | accepted | issued | underwrittenBlocked | declined | rejected | refused | discarded | invalidated | reversed, required)
  underwritingStatus (string)
  policyLocator (ulid, required)
  baseTransactionLocator (ulid)
  aggregateTransactionLocator (ulid)
  createdAt (datetime, required)
  createdBy (uuid, required)
  validationResult (ValidationResult)
  changeInstructions (object[])
  effectiveTime (datetime, required)
  aggregatedTransactions (PolicyTransactionResponse[])
  termLocator (ulid, required)
  preferences (PreferencesResponse)
  transactionType (string, required)
  issuedTime (datetime)
  acceptedTime (datetime)
  reapplicationOfLocator (ulid)
  maskingLevel (Enum none | level1 | level2)
  anonymizedAt (datetime)
  staticLocator (ulid, required) — Equals the locator of the first transaction this is based on.
  expirationTime (datetime)

PreferencesResponse
Properties:
  installmentPreferences (InstallmentPreferences)

InstallmentPreferences
Properties:
  cadence (Enum none | fullPay | weekly | everyOtherWeek | monthly | quarterly | semiannually | annually | thirtyDays | everyNDays)
  anchorMode (Enum generateDay | termStartDay | dueDay)
  generateLeadDays (integer)
  dueLeadDays (integer)
  installmentWeights (number[], required)
  maxInstallmentsPerTerm (integer)
  installmentPlanName (string)
  anchorType (Enum none | dayOfMonth | anchorTime | dayOfWeek | weekOfMonth)
  dayOfMonth (integer)
  dayOfWeek (Enum monday | tuesday | wednesday | thursday | friday | saturday | sunday)
  weekOfMonth (Enum none | first | second | third | fourth | fifth)
  anchorTime (datetime)
  autopayLeadDays (number)

SegmentResponse
Properties:
  locator (ulid, required)
  transactionLocator (ulid, required)
  segmentType (Enum coverage | gap, required)
  startTime (datetime, required)
  endTime (datetime, required)
  element (ElementResponse, required) — The root element in the hierarchy
  duration (number, required)
  basedOn (ulid)
  anonymizedAt (datetime)
  producerInfo (ProducerInfo)

ProducerInfo
Properties:
  producerCode (string)
  producerCodeOfRecord (string)

ChangeInstructionResponse
Properties:
  action (string, required)

AddChangeInstructionResponse
Properties:
  locator (ulid, required)
  action (Enum add, required)
  elements (ElementCreateRequest[], required)

ModifyChangeInstructionResponse
Properties:
  locator (ulid, required)
  action (Enum modify, required)
  staticLocator (ulid, required)
  setData (map<string, object>, required)
  removeData (map<string, object>, required)
  setCoverageTerms (map<string, object>, required)
  removeCoverageTerms (map<string, object>, required)

ParamsChangeInstructionResponse
Properties:
  locator (ulid, required)
  action (Enum params, required)
  effectiveTime (datetime, required)
  newPolicyEndTime (datetime)
  preferences (PreferencesResponse)
  billingModeChange (boolean) [deprecated] — Use triggerBillingChange instead.
  triggerBillingChange (boolean)
  inheritSettings (boolean) [deprecated]
  expirationTime (datetime)

DeleteChangeInstructionResponse
Properties:
  locator (ulid, required)
  action (Enum delete, required)
  staticElementLocators (ulid[], required)

ProducersChangeInstructionResponse
Properties:
  locator (ulid, required)
  action (Enum producers, required)
  setProducerCode (string)
  clearProducerCode (boolean)
  setProducerCodeOfRecord (string)
  revertProducerCodeOfRecord (boolean)

MigrateChangeInstructionResponse
Properties:
  locator (ulid, required)
  action (Enum migrate, required)
  configVersionLocator (ulid)

PolicyTransactionListResponse
Properties:
  listCompleted (boolean, required)
  items (PolicyTransactionResponse[], required)

AddChangeInstructionCreateRequest
Properties:
  action (Enum add, required)
  elements (ElementCreateRequest[], required)

ParamsChangeInstructionCreateRequest
Properties:
  action (Enum params, required)
  effectiveTime (datetime, required)
  newPolicyEndTime (datetime)
  preferences (PreferencesResponse)
  billingModeChange (boolean) [deprecated] — Use triggerBillingChange instead.
  triggerBillingChange (boolean)
  inheritSettings (boolean) [deprecated]
  expirationTime (datetime)

ModifyChangeInstructionCreateRequest
Properties:
  action (Enum modify, required)
  staticLocator (ulid, required)
  setData (map<string, object>, required)
  removeData (map<string, object>, required)
  setCoverageTerms (map<string, object>, required)
  removeCoverageTerms (map<string, object>, required)

DeleteChangeInstructionCreateRequest
Properties:
  action (Enum delete, required)
  staticElementLocators (ulid[], required)

ProducersChangeInstructionCreateRequest
Properties:
  action (Enum producers, required)
  setProducerCode (string)
  clearProducerCode (boolean)
  setProducerCodeOfRecord (string)
  revertProducerCodeOfRecord (boolean)

MigrateChangeInstructionCreateRequest
Properties:
  action (Enum migrate, required)
  configVersionLocator (ulid)

PolicyTransactionReversalRequest
Properties:
  toTransaction (ulid, required)
  reverseTransactions (ulid[], required)
  baseLocator (ulid, required)

ValidationResult
Properties:
  validationItems (ValidationItemResponse[])
  success (boolean, required)

ValidationItemResponse
Properties:
  elementType (string, required)
  locator (ulid, required)
  errors (string[], required)

TransactionPriceResponse
Properties:
  locator (ulid, required)
  policyLocator (ulid, required)
  transactionCategory (Enum issuance | change | renewal | cancellation | reinstatement | reversal | aggregate, required)
  transactionState (Enum draft | initialized | validated | earlyUnderwritten | priced | underwritten | accepted | issued | underwrittenBlocked | declined | rejected | refused | discarded | invalidated | reversed, required)
  effectiveTime (datetime, required)
  charges (PolicyChargeResponse[], required)
  aggregatedTransactions (TransactionPriceResponse[])
  validationResult (ValidationResult)

PolicyChargeResponse
Properties:
  locator (ulid, required)
  elementLocator (ulid, required)
  chargeType (string, required)
  chargeCategory (Enum none | premium | tax | fee | credit | invoiceFee | cededPremium | nonFinancial | surcharge, required)
  amount (number, required)
  rate (number, required)
  referenceRate (number, required)
  tag (string)
  rateDifference (number)
  elementStaticLocator (ulid, required)
  reversalOfLocator (ulid)
  handling (Enum flat | normal | retention, required)
  invoicing (Enum scheduled | next | immediate, required)

TransactionUnderwritingResponse
Properties:
  locator (ulid, required)
  policyLocator (ulid, required)
  transactionCategory (Enum issuance | change | renewal | cancellation | reinstatement | reversal | aggregate, required)
  transactionState (Enum draft | initialized | validated | earlyUnderwritten | priced | underwritten | accepted | issued | underwrittenBlocked | declined | rejected | refused | discarded | invalidated | reversed, required)
  effectiveTime (datetime, required)
  underwritingStatus (string, required)
  underwritingFlags (UnderwritingFlagResponse[])
  aggregatedTransactions (TransactionUnderwritingResponse[])
  validationResult (ValidationResult)

TransactionUnderwritingFlagsResponse
Properties:
  transactionLocator (ulid, required)
  flags (UnderwritingFlagResponse[], required)
  clearedFlags (UnderwritingFlagResponse[], required)

UnderwritingFlagResponse
Properties:
  locator (ulid, required)
  level (Enum info | block | decline | reject | approve, required)
  referenceType (Enum quote | transaction, required)
  referenceLocator (ulid, required)
  note (string, required)
  tag (string, required)
  elementLocator (ulid)
  createdBy (uuid, required)
  createdTime (datetime, required)
  clearedBy (uuid, required)
  clearedTime (datetime, required)
  taskCreationResponse (TaskCreationResponse, required)

DocumentInstanceResponse
Properties:
  locator (ulid, required)
  referenceLocator (ulid, required)
  referenceType (Enum quote | policy | invoice | transaction | segment | term, required)
  referenceDocumentLocator (ulid)
  transactionLocator (ulid)
  segmentLocator (ulid)
  termLocator (ulid)
  policyLocator (ulid)
  name (string)
  staticName (string)
  documentInstanceState (Enum draft | dataReady | ready | dataError | renderError | conversionError, required)
  documentFormat (Enum csv | doc | docx | html | jpeg | jpg | pdf | text | txt | xls | xlsx | zip, required)
  metadata (map<string, object>, required)
  createdAt (datetime, required)
  createdBy (uuid)
  readyAt (datetime)
  renderingData (map<string, object>, required)
  processingErrors (string)
  external (boolean, required)
  category (string)
  consolidatedFrom (ulid[], required)
  consolidatedTo (ulid[], required)
  copyOnIssuance (boolean)

AffectedTransaction
Properties:
  locator (ulid, required)
  action (Enum reversed | reapplied | invalidated, required)

ResetOptions
Properties:
  resetAllUnderwritingFlags (boolean, required)
  resetFlags (ulid[], required)
  resetFlagsAction (Enum clear | delete, required)
  deleteAllAutomaticDocuments (boolean, required)
  discardSchedules (boolean, required)
  deleteDocuments (ulid[], required)