claim_exposures

Code
Adds a recovery transaction to a claim or exposure.

Request Payload
---------------
recovery_details : dict
    {
        "api_key": str,
        "recovery_details": {
            "exposure_id": str | null if claim_id is provided
            "claim_id": str | null if exposure_id is provided
            "category": str,
            "amount": number,
            "description": str,
            "date": str (date "YYYY-MM-DD", stored as-is, or date-time,
                   whose America/Chicago calendar day is stored)
        }
    }

Returns
-------
success : bool
    True if successful, false otherwise.
messages : list of str | dict
    List of human-readable error or success messages.
data : dict
    {
        "amount": number,
        "category": str,
        "claim_id": str | null if exposure_id is provided
        "date": str (date),
        "description": str,
        "exposure_id": str | null if claim_id is provided
        "id": str,
        "reinsuranceContractContactId": str | null
    }

Code
Adds a recovery reserve to a claim or exposure.

Request Payload
---------------
recovery_reserve_details : dict
    {
        "api_key": str,
        "recovery_reserve_details": {
            "exposure_id": str | null,
            "claim_id": str | null,
            "reinsurance_amount": number,
            "reinsurancelae_amount": number,
            "salvage_amount": number,
            "subrogation_amount": number,
            "transaction_date": str (date "YYYY-MM-DD", stored as-is, or date-time,
                   whose America/Chicago calendar day is stored)
        }
    }

Returns
-------
success : bool
    True if successful, false otherwise.
messages : list of str | dict
    List of human-readable error or success messages.
data : dict
    {
        "claim_id": str | null,
        "exposure_id": str | null,
        "reinsurance_amount": number,
        "reinsurancelae_amount": number,
        "salvage_amount": number,
        "subrogation_amount": number,
        "transaction_date": str (date)
    }

Code
Add or update reserve values for an exposure.

Request Payload
---------------
reserve_details : dict
    {
        "exposure_id": str,
        "loss_amount": number,
        "adjusting_amount": number,
        "legal_amount": number,
        "transaction_date": str (date "YYYY-MM-DD", stored as-is, or date-time,
               whose America/Chicago calendar day is stored)
    }

Returns
-------
dict
    On success, the reserve values (``validate_data`` / ``warning``
    envelope fields are added by the decorator)::

        {
            "exposure_id": str,
            "loss_amount": number,
            "adjusting_amount": number,
            "legal_amount": number,
            "transaction_date": "YYYY-MM-DD"
        }

    If authority limits are exceeded::

        {"brokenLimits": [...], "adminData": {...}}

Code
Create a claim exposure record.

Request Payload
---------------
claim_exposure : dict
    {
        "claim_id": str,
        "coverage_id": str,
        "loss_type": "property" | "vehicle" | "injury",   # optional but recommended
        "loss_id": str,                                    # optional
        "claimant_id": str,                                # optional
        "representative": {                                # optional
            "contact_id": str,
            "start_date": "YYYY-MM-DD"
        }
    }

Returns
-------
dict
    {
        "id": str,
        "claim_id": str,
        "coverage_id": str,
        "coverage_type_id": str,
        "loss_id": str,
        "loss_type": "property" | "vehicle" | "injury",
        "claimant_id": str,
        "representative": {
            "contact_id": str,
            "start_date": "YYYY-MM-DD",
            "name": str
        },
        "loss": {"id": str, "name": str},
        "coverage": {"id": str, "name": str, "deductible": number, ...},
        "claimant": {"id": str, "name": str, "type": str, ...},
        "coverage_deductible": number,
        "override": bool,
        "is_borrowed": bool,
        "date_updated": str (datetime),
        "is_liability": bool
    }

Notes
-----
- ``claim_id`` and ``coverage_id`` are required by service validation.
- Duplicate exposures (same claimant + coverage + claim + loss) are rejected.

Code
Delete a claim exposure by ID.

Parameters
----------
id : str
    Exposure ID.

Returns
-------
None
    Successful deletion returns an empty standard API response.

Code
Retrieve accounting summary for all exposures on a claim.

Parameters
----------
claim_id : str
    Claim ID.

Returns
-------
dict
    {
        "exposure_summaries": [<exposure_accounting_summary>, ...],
        "summary": <exposure_accounting_summary>
    }

    Each ``<exposure_accounting_summary>`` has the shape documented in
    ``get_exposure_accounting_data``.

Code
Retrieves detailed loss accounting data for a claim, including exposure-level
and total loss details. Provides comprehensive breakdown of loss, legal, and
adjusting reserves and payments for financial analysis and reporting.
Uses pagination for exposure data.

Permissions
-----------
Requires read access to at least one of:
    - 'britecore/claims/exposures'
    - 'britecore/claims/accounting'
    - 'agent/claims'

Parameters
----------
claim_id : str
    The ID of the claim for which to retrieve loss details.
page : int, optional
    The page number for paginated exposures (default: 1).
page_size : int, optional
    The number of exposures per page (default: 100).

Returns
-------
dict
    {
        'exposure_loss_details': [
            {
                'id': str,                    # Exposure/claim item UUID
                'claimant_name': str|null,    # Name of the claimant
                'coverage_name': str,         # Insurance coverage name
                'loss_name': str,             # Description of the loss/damage
                'loss_details': {
                    'loss_reserve': float,        # Current loss reserve amount
                    'loss_paid': float,           # Total loss payments made
                    'legal_reserve': float,       # Current legal reserve amount
                    'legal_paid': float,          # Total legal payments made
                    'adjusting_reserve': float,   # Current adjusting reserve amount
                    'adjusting_paid': float       # Total adjusting payments made
                }
            },
            ...
        ],
        'total_loss_details': {
            'loss_reserve': float,        # Sum of all exposure loss reserves
            'loss_paid': float,           # Sum of all exposure loss payments
            'legal_reserve': float,       # Sum of all exposure legal reserves
            'legal_paid': float,          # Sum of all exposure legal payments
            'adjusting_reserve': float,   # Sum of all exposure adjusting reserves
            'adjusting_paid': float       # Sum of all exposure adjusting payments
        },
        'total_records': int            # Total number of exposures for pagination
    }

Code
Retrieves comprehensive accounting overview data for a claim,
including claim-level overview, exposure-level overviews, and total summaries.
This endpoint provides financial data for reserves, payments, incurred amounts,
recoveries, and net incurred calculations. Uses pagination for exposure data.

Permissions
-----------
Requires read access to at least one of:
    - 'britecore/claims/exposures'
    - 'britecore/claims/accounting'
    - 'agent/claims'

Parameters
----------
claim_id : str
    The ID of the claim for which to retrieve accounting overview data.
page : int, optional
    The page number for paginated exposures (default: 1).
page_size : int, optional
    The number of exposures per page (default: 100).

Returns
-------
dict
    {
        'claim_level_overview': {
            'total_reserve': float,      # Always 0.0 at claim level
            'total_payment': float,      # Always 0.0 at claim level
            'total_incurred': float,     # Always 0.0 at claim level
            'total_recovery': float,     # Sum of all recovery reserves + recovered amounts
            'net_incurred': float        # total_incurred - total_recovery (always negative)
        },
        'exposure_level_overview': [
            {
                'id': str,                    # Exposure/claim item UUID
                'claimant_name': str|null,    # Name of the claimant
                'coverage_name': str,         # Insurance coverage name
                'loss_name': str,             # Description of the loss/damage
                'overview': {
                    'total_reserve': float,    # Sum of loss, legal, and adjusting reserves
                    'total_payment': float,    # Sum of all payments made
                    'total_incurred': float,   # total_reserve + total_payment
                    'total_recovery': float,   # Sum of recovery reserves + recovered amounts
                    'net_incurred': float      # total_incurred - total_recovery
                }
            },
            ...
        ],
        'total_overview': {
            'total_reserve': float,      # Sum of all exposure reserves
            'total_payment': float,      # Sum of all exposure payments
            'total_incurred': float,     # total_reserve + total_payment
            'total_recovery': float,     # Sum of all recovery data (claim + exposure level)
            'net_incurred': float        # total_incurred - total_recovery
        },
        'total_records': int            # Total number of exposures for pagination
    }

Code
Retrieves accounting recoveries summary data for a claim,
including claim-level, exposure-level recoveries and total recoveries.
This endpoint uses pagination to return the data.

Permissions
-----------
Requires read access to at least one of:
    - 'britecore/claims/exposures'
    - 'britecore/claims/accounting'
    - 'agent/claims'

Parameters
----------
claim_id : str
    The ID of the claim for which to retrieve recoveries data.
page : int, optional
    The page number for paginated exposures (default: 1).
page_size : int, optional
    The number of exposures per page (default: 100).

Returns
-------
dict
    {
        'claim_level_recoveries': {
            'reinsurance_summary': {
                'total_recovery_reserve': Decimal,
                'total_recovered': Decimal
            },
            'reinsurancelae_summary': {
                'total_recovery_reserve': Decimal,
                'total_recovered': Decimal
            },
            'salvage_summary': {
                'total_recovery_reserve': Decimal,
                'total_recovered': Decimal
            },
            'subrogation_summary': {
                'total_recovery_reserve': Decimal,
                'total_recovered': Decimal
            }
        },
        'exposure_level_recoveries': [
            {
                'id': str,
                'claimant_name': str,
                'coverage_name': str,
                'loss_name': str,
                'recoveries': {
                    'reinsurance_summary': {
                        'total_recovery_reserve': Decimal,
                        'total_recovered': Decimal
                    },
                    'reinsurancelae_summary': {
                        'total_recovery_reserve': Decimal,
                        'total_recovered': Decimal
                    },
                    'salvage_summary': {
                        'total_recovery_reserve': Decimal,
                        'total_recovered': Decimal
                    },
                    'subrogation_summary': {
                        'total_recovery_reserve': Decimal,
                        'total_recovered': Decimal
                    }
                }
            },
            ...
        ],
        'total_recoveries': {
            'reinsurance_summary': {
                'total_recovery_reserve': Decimal,
                'total_recovered': Decimal
            },
            'reinsurancelae_summary': {
                'total_recovery_reserve': Decimal,
                'total_recovered': Decimal
            },
            'salvage_summary': {
                'total_recovery_reserve': Decimal,
                'total_recovered': Decimal
            },
            'subrogation_summary': {
                'total_recovery_reserve': Decimal,
                'total_recovered': Decimal
            }
        }
    }

get_broken_limits

Code
Retrieve claim accounting summary filtered to one coverage.

Parameters
----------
claim_id : str
    Claim ID.
coverage_id : str
    Coverage ID.

Returns
-------
dict
    Same shape as ``get_accounting_data`` (``exposure_summaries`` list +
    ``summary``), filtered to exposures matching *coverage_id*.

Code
Retrieve accounting summary for a single exposure.

Parameters
----------
exposure_id : str
    Exposure ID.

Returns
-------
dict
    Exposure accounting summary.  Reserve-category summaries (``loss_summary``,
    ``adjusting_summary``, ``legal_summary``) each contain::

        {"id", "reserve_category_type", "total_reserve", "total_payments",
         "total_recovery", "total_incurred", "net_incurred"}

    Recovery-category summaries (``reinsurance_summary``,
    ``reinsurancelae_summary``, ``salvage_summary``,
    ``subrogation_summary``) each contain::

        {"id", "recovery_category_type", "total_recovery_reserve",
         "total_recovered", "total_recovery"}

    Top-level aggregates::

        {
            "id": str,
            "exposure": <exposure object>,
            "loss_summary": <reserve_category>,
            "adjusting_summary": <reserve_category>,
            "legal_summary": <reserve_category>,
            "reinsurance_summary": <recovery_category>,
            "reinsurancelae_summary": <recovery_category>,
            "salvage_summary": <recovery_category>,
            "subrogation_summary": <recovery_category>,
            "total_recovered": number,
            "total_recovery_reserve": number,
            "total_recovery": number,
            "total_reserve": number,
            "total_payments": number,
            "total_incurred": number,
            "net_incurred": number
        }

Code
Returns whether an exposure is editable.

Code
Get transactions for an exposure with optional filtering and sorting.

This endpoint returns all accounting transactions for a specific exposure.
When no filter parameters are provided, returns all transactions sorted by
date (newest first).

Permissions
-----------
Requires read access to at least one of:
    - 'britecore/claims/accounting/transactions'
    - 'agent/claims'

Parameters
----------
exposure_id : str
    UUID of the exposure
transaction_types : str (optional)
    Filter by transaction type(s): reserve, payment, recovery, recovery_reserve
categories : List[str] (optional)
    Filter by category(ies): loss, adjuster, legal, reinsurance, subrogation,
    salvage, reinsurancelae
statuses : List[str] (optional)
    Filter by status(es): voided
payment_methods : List[str] (optional)
    Filter by payment method(s): NoAuth, CC, ACH
date_from : str (optional)
    Filter transactions on or after this date (YYYY-MM-DD format)
date_to : str (optional)
    Filter transactions on or before this date (YYYY-MM-DD format)
sort_by : str (optional, default: "transaction_datetime")
    Field to sort by: transaction_datetime, amount, payee, transaction_category
sort_order : str (optional, default: "desc")
    Sort order: asc, desc

Returns
-------
    List of serialized ClaimExposureAccountingTransactionWithExposureDetailsModel

Code
Retrieve a payment by its id (claim transaction id).

Parameters
----------
payment_id : str
    Claim transaction ID.

Returns
-------
dict
    Payment object (same shape as ``make_payment`` response).

Code
List all exposures for a claim.

Parameters
----------
claim_id : str
    Claim ID.

Returns
-------
list[dict]
    List of exposure objects.  Each element has the same shape as the
    ``create_exposure`` response (see its docstring for the full schema).

Code
Create a single payment distributed across multiple exposures.

Request Payload
---------------
payment_details : dict
    {
        "claim_id": str,
        "exposures": [
            {"id": str, "loss_paid": number, "adjusting_paid": number, "legal_paid": number}
        ],
        "payee_ids": [str, ...],
        "date": "YYYY-MM-DD",
        "display_on_check": str,
        "payment_method": str,
        "memo": str                         # optional
    }

Returns
-------
dict
    On success, the created multi-exposure payment::

        {
            "id": str,
            "claim_id": str,
            "exposures": [
                {"id": str, "loss_paid": number,
                 "adjusting_paid": number, "legal_paid": number}
            ],
            "payee_ids": [str, ...],
            "date": "YYYY-MM-DD",
            "display_on_check": str,
            "payment_method": str,
            "payment_classification": str,
            "address_id": str,
            "deductible_amount": number,
            "memo": str,
            "system_tags": dict,
            "amount": number
        }

    If authority limits are exceeded::

        {"brokenLimits": [...], "adminData": {...}}

Code
Create a payment transaction for an exposure.

Request Payload
---------------
payment_details : dict
    {
        "exposure_id": str,
        "payee_ids": [str, ...],
        "date": "YYYY-MM-DD",
        "display_on_check": str,
        "payment_method": str,
        "loss_paid": number,
        "adjusting_paid": number,
        "legal_paid": number,
        "deductible_amount": number,      # optional
        "memo": str,                      # optional
        "payment_classification": str,    # optional
        "address_id": str                 # optional
    }

Returns
-------
dict
    On success, the created payment::

        {
            "id": str,
            "exposure_id": str,
            "payee_ids": [str, ...],
            "date": "YYYY-MM-DD",
            "display_on_check": str,
            "payment_method": str,
            "payment_classification": str,
            "address_id": str,
            "loss_paid": number,
            "adjusting_paid": number,
            "legal_paid": number,
            "deductible_amount": number,
            "memo": str,
            "system_tags": dict,
            "amount": number
        }

    If authority limits are exceeded::

        {"brokenLimits": [...], "adminData": {...}}

Code
Updates an existing exposure's claimant, coverage, or loss/risk.
Blocked when payments exist on the exposure.

Code
Update an existing payment transaction.

Request Payload
---------------
payment_details : dict
    Partial payment payload that includes ``id`` and one or more
    updatable fields from ``make_payment``.

Returns
-------
dict
    On success, the updated payment object (same shape as
    ``make_payment`` response).

    If authority limits are exceeded::

        {"brokenLimits": [...], "adminData": {...}}

Code
Void a claim accounting transaction.

Parameters
----------
transaction_id : str
    Transaction ID.

Returns
-------
str
    The voided transaction ID.