lines

Code
Attaches a new stock form (a PDF file) to a Policy Type, and creates
its print-flag metadata row (x_policy_types_docs).

Parameters
----------
form : dict
    policy_type_id : str, required
    file_name : str, required
    file_base64 : str, required - base64-encoded file content
    mime_type : str, optional - defaults to 'application/pdf'
    metadata : dict, optional - fields matching PolicyTypeFormMetadataSchema

Returns
-------
dict
    {"file": {...}, "metadata": {...} or None}

Code
Attaches a new stock form (a PDF file) to a Policy Type Item, and
creates its print-flag metadata row (x_policy_type_items_docs).

Parameters
----------
form : dict
    policy_type_item_id : str, required
    file_name : str, required
    file_base64 : str, required - base64-encoded file content
    mime_type : str, optional - defaults to 'application/pdf'
    metadata : dict, optional - fields matching PolicyTypeItemFormMetadataSchema

Returns
-------
dict
    {"file": {...}, "metadata": {...} or None}

Copy line items between effective dates, states, policy types, line types and sub-lines.

Code
Parameters:
-----------
from_effective_date_id : str
to_effective_date_id : str
from_state_id : str
to_state_id : str
json_dict:
    A JSON object defining what items to copy, what those
    items are, and what to copy them into.
validate_only: bool, optional
    Whether to just validate the parameters, defaults to False.

Returns
-------
success: bool
    True if successful, false if not
messages: list of str
    List of human-readable error messages
data: list
    The data response having the form:
    ::
        {
            "data": [
                {
                    "fromEffectiveDate": 'YYYY-MM-DD HH:MM:SS',
                    "toEffectiveData": 'YYYY-MM-DD HH:MM:SS',
                    "fromState": str,
                    "toState": str,
                    "fromPolicyType": str,
                    "toPolicyType": str,
                    "copiedItems": {}
                },
            ],
            "messages": [],
            "success": true
        }

API method to copy a policy type to a new effective date and state.

Code
Parameters
----------
policy_type_id : str, required
from_effective_date_id : str, required
to_effective_date_id : str, required
from_state_id : str, required
to_state_id : str, required
validate_only : bool, optional
    Whether to just validate the parameters, defaults to False

Returns
-------
success : bool
    True if successful, False if not
messages : list of str
    List of human-readable error messages
data : array containing applicable policy type data
    ::
    {
        "data": [],
        "messages": [],
        "success": bool
    }

Copies underwriting rules from one effective date, state and policy type to another.

Code
Parameters:
-----------
from_effective_date_id : str
    UUID of an effective date
from_state_id : str
    UUID of a state
from_policy_type_id : str
    UUID of a policy type
to_effective_date_id : str
    UUID of an effective date
to_state_id : str
    UUID of a state
to_policy_type_id : str
    UUID of a policy type
json_dict : dict
        {
                "underwriting_rule_ids": [],
                "auto_infer_refs": bool
            }
validate_only: bool
    Whether to just validate the parameters, defaults to False
manual_items: list
    An optional list of policy type ids to review manually

Returns
-------
success : bool
    True if successful, false if not
messages : list of str
    List of human-readable error messages
data : list
    The data response having the form:
    ::
        {
            "data": [
                {
                    "fromEffectiveDate": 'YYYY-MM-DD',
                    "fromState": str,
                    "fromPolicyType": str,
                    "toEffectiveData": 'YYYY-MM-DD',
                    "toState": str,
                    "toPolicyType": str
                },
            ],
            "messages": [],
            "success": true
        }

Creates a mapping to supply persistent builder with an explicit change.

Code
Parameters:
-----------
mapping_type : str, required
from_mapped_name : str, required
to_mapped_name : str, required
validate_only : bool, optional
    True validates only, False validates and creates

Returns
-------
success : bool
    True if successful, false if not
messages : list of str
    List of human-readable error messages
data : list
    The data response having the form:
    ::
        {
            "data": [
                {
                    "mapping_type": str,
                    "old_name": str,
                    "new_name": str
                },
            ],
            "messages": [],
            "success": true
        }

Code
Creates an effective date with the given parameters
@param params_data: dict (id, effective_date, policy_type_ids, policy_type_external_system_references, force)

Code
Creates a policy type with the given parameters.

Code
Creates a single line item on an existing policy type.
Requires policy_type_id, name, category, and type.

Creates a new rating grid definition.

Code
Args:
    payload (dict): The data for the new rating grid definition.

Returns:
    dict: The serialized created rating grid definition.

Code
Creates a single subline on an existing policy type.
Requires policy_type_id, name, category, and type.

Deletes an explicit mapping in persistent builder.

Code
Parameters:
-----------
mapping_type : str
from_mapped_name : str
to_mapped_name : str
validate_only : bool
    True validates only, False validates and deletes

Returns
-------
success : bool
    True if successful, false if not
messages : list of str
    List of human-readable error messages
data : list
    The data response having the form:
    ::
        {
            "data": [
                {
                    "mapping_type": str,
                    "old_name": str,
                    "new_name": str
                },
            ],
            "messages": [],
            "success": true
        }

Code
Deletes an effective date.

API method to delete the line item specified by id.

Code
Parameters
----------
item_id : str, required
    UUID of an existing line item.

Returns
-------
success : bool
    True if successful, false if not
messages : list of str
    List of human-readable error messages
data :
    ::
    {
        "messages": [],
        "success": bool
    }

Code
Deletes a policy type.

Code
Deletes a rating table.

Code
Deletes a rating table file
:param file_id: str (id of the file)
:return: bool

API method to delete a subline (and cascade-delete its child items).

Code
Mirrors ``delete_line_item``: live sites are blocked outright, no
backend dependency gate. The caller (Copilot, future UI) is
responsible for previewing dependencies via
``lines/get_policies_with_sub_line`` and confirming with the user
before invoking this endpoint.

Returns
-------
success : bool
messages : list of str
data : dict
    On success: ``{"deleted_items": int, "affected_policies":
    [policy_number, ...]}``.

find_effective_date

Retrieves information about all effective dates.

Code
Parameters
----------

Returns
-------
success : bool
    True if successful, false if not
messages : list of str
    List of human-readable error messages
data : list
    The data response having the form:
    ::
        {
            "data": [
                {
                    "description": str,
                    "creation_date": 'YYYY-MM-DD HH:MM:SS',
                    "override_lock": bool,
                    "effective_date": 'YYYY-MM-DD',
                    "change_history": [],
                    "id": UUID
                },
            ],
            "messages": [],
            "success": true
        }

Retrieves information about all lines for an effective date.

Code
Parameters
----------
effective_date_id : str, required
    UUID of an effective date
location_id : str, optional
    UUID of a location. If empty, all lines for all locations returned.

Returns
-------
success : bool
    True if successful, false if not
messages : list of str
    List of human-readable error messages
data : list
    The data response having the form:
    ::
        {
            "data": [
                {
                    "inheritance_id": UUID,
                    "name": str,
                    "date_updated": 'YYYY-MM-DD HH:MM:SS',
                    "system_tags": dict,
                    "effective_id": UUID,
                    "location_id": UUID,
                    "id": UUID
                },
            ],
            "messages": [],
            "success": true
        }

Retrieves information about all policy types for an effective date.

Code
Parameters
----------
effective_date_id : str, required
    UUID for an effective date
location_id : str, required
    UUID for a location. If empty, all policy types for all locations returned.

Returns
-------
success : bool
    True if successful, false if not
messages : list of str
    List of human-readable error messages
data : list
    The data response having the form:
    ::
        {
            "data": [
                {
                    "always_display_wizard_credit_score_button": bool,
                    "skip_insured_quoting_step": bool,
                    "allow_motor_vehicle_reports": bool,
                    "months_mvr_valid": int,
                    "date_updated": 'YYYY-MM-DD HH:MM:SS',
                    "three_month": bool,
                    "app_id": str,
                    "six_month": bool,
                    "rating_info_title": str,
                    "sort_order": int,
                    "britelines_product_name": str,
                    "requires_approval": bool,
                    "one_year_quote": bool,
                    "location_id": UUID,
                    "id": UUID,
                    "three_year": bool,
                    "require_risk_address": bool,
                    "maximum_risk_count": int,
                    "protection_class": str,
                    "is_protection_class_btn_visible": bool,
                    "allow_property_valuation": bool,
                    "one_year": bool,
                    "open_to_quoting": bool,
                    "nine_month": bool,
                    "separate_dec_sections": bool,
                    "three_year_quote": bool,
                    "inheritance_id": UUID,
                    "description": str,
                    "trust_risk_premiums": bool,
                    "three_year_factor": Decimal('0.0000'),
                    "six_month_quote": bool,
                    "system_tags": dict,
                    "line_id": UUID,
                    "sequence_id": UUID,
                    "six_month_factor": Decimal('0.0000'),
                    "one_year_factor": Decimal('0.0000'),
                    "three_month_quote": bool,
                    "use_rating_v1": bool,
                    "underwriting": str,
                    "dec_display_options": str,
                    "name": str,
                    "three_month_factor": Decimal('0.0000'),
                    "nine_month_quote": bool,
                    "multiple_property_status": bool,
                    "limit_threshold": Decimal('0.00'),
                    "show_optional_builder_items_inline": bool,
                    "effective_id": UUID,
                    "nine_month_factor": Decimal('0.0000'),
                    "require_credit_score": bool,
                    "limit_warning": int
                },
            ],
            "messages": [],
            "success": true
        }

Retrieves information about all states or for a specific effective date.

Code
Parameters
----------
effective_date_id : str, optional
    UUID of an effective date. Leave blank to return all states
    without filtering by effective date.

Returns
-------
success : bool
    True if successful, false if not
messages : list of str
    List of human-readable error messages
data : list
    The data response having the form:
    ::
        {
            "data": [
                {
                    "life_cycle_parameters": str,
                    "checked": bool,
                    "name": str,
                    "county_specifications": list,
                    "date_updated": 'YYYY-MM-DD HH:MM:SS',
                    "country_id": UUID,
                    "abbreviation": str,
                    "cities": list,
                    "id": UUID,
                    "counties": list
                },
            ],
            "messages": [],
            "success": true
        }

Code
Returns an effective date
@param id

Retrieves file data for exporting a line.

Code
Parameters
----------
curr_line_id : str, required
    The line id.
curr_eff_date_id : str, required
    The effective date id,
curr_state_id : str, required
    The state id
include_custom_sequences : bool, optional
    Whether or not to include any non-default data from custom_sequences that is associated with the policy types

Returns
-------
success : bool
    True if successful, false if not
messages : list of str
    List of human-readable error messages
data : list
    The data response having the form:
    ::
        {
            "data": JSON data respresenting a line export
            "messages": [],
            "success": true
        }

API method to get all policies using a specified (by id) line item.

Code
Parameters
----------
item_id : str, required
    UUID of an existing line item.
limit : int, optional
    number of policies to return, 0 means all

Returns
-------
success : bool
    True if successful, false if not
messages : list of str
    List of human-readable error messages
data : dict
    ``{"count": int, "policies": [policy_number, ...],
    "rule_count": int, "form_count": int}``

API method to get all policies using a specified (by id) subline.

Code
Mirrors the shape of ``get_policies_with_line_item``: returns a count
plus a list of policy numbers clamped to ``limit``, alongside the
rule/form dependency counts for the subline's child items.

Parameters
----------
sub_line_id : str, required
    UUID of an existing subline.
limit : int, optional
    Number of policies to return. 0 (default) means all.

Returns
-------
success : bool
messages : list of str
data : dict
    ``{"count": int, "policies": [policy_number, ...],
    "rule_count": int, "form_count": int}``

Code
Retrieves a policy type with the given ID.

Code
Retrieves a single line item with the given ID, including its rate_chain.

Code
Retrieves a policy type with the given ID, excluding rate_chain data from items.

Code
Retrieves the rate chains of all line items for the policy types in scope
in a single batched call.

Built for scan/audit flows (e.g. "find all year categories missing 2025
across all policy types") that would otherwise fetch thousands of items
one get_policy_type_item call at a time.

Parameters
----------
effective_date_id : str, optional
    UUID of an effective date. Required unless policy_type_ids is given.
    All policy types under this effective date are included.
location_id : str, optional
    UUID of a location/state to narrow the effective date scope.
policy_type_ids : list of str, optional
    Explicit policy type UUIDs. When given, effective_date_id and
    location_id are ignored.
step_types : list of str, optional
    Rate chain step types to include (e.g. ["CATEGORIES"]). Steps of
    other types are dropped before serialization, keeping the response
    small. When omitted, full rate chains are returned.

Returns
-------
data : list of dict
    One entry per line item (top-level and subline items):
    ::
        {
            "policy_type_id": UUID,
            "policy_type_name": str,
            "item_id": UUID,
            "item_name": str,
            "rate_chain": [ ...steps... ]
        }

Code
Returns a template for rating tables or vehicle prefill fallback tables

Query Parameters:
    table_type: Optional[str] - Type of table template to generate ('grid_points' or 'prefill_vehicle_fallback')

Code
Get auto-fill answers for underwriting questions based on template risks.
Returns answers that are opposite of yes_no_prevent_continue values.
Args:
    policy_type_id: Policy type identifier
Returns:
    List of auto-fill answers with question_id and suggested_answer

import_line

Code
Imports a rating table
@param params_data: dict (
    table_definition_id: str - ID of the table definition,
    location_id: str - ID of the state,
    name: str - Name of the table,
    effective_date: str - Effective date for the table,
    renewal_effective_date: str - Optional renewal effective date,
    file_id: str - ID of the uploaded file
)

Code
Returns a list of effective dates
@param params_data: dict (page, page_size, sort_by, sort_order)

Code
Lists every form attached to a Policy Type (active or not, matching what
actually renders), including both ids a caller needs: file_id (the File
row) and form_id (the
XPolicyTypesDoc row's own id, required by update_form_on_policy_type/
remove_form_from_policy_type). Mirrors legacy retrieveDocuments
(lib/lines/views.py:1930).

Parameters
----------
policy_type_id : str, required

Returns
-------
list of dict
    Each dict has file_id, form_id, title, and the 7
    policy-type-level metadata fields (form_code, edition_number,
    description, suppress_printing, always_print_on_renewal,
    always_print_on_endorsement, mortgagee_types).

Code
Lists every form attached to a Policy Type Item (active or not, matching
what actually renders), including both ids a caller needs: file_id (the
File row) and form_id (the
XPolicyTypeItemsDoc row's own id, required by
update_form_on_policy_type_item/remove_form_from_policy_type_item).
Mirrors legacy retrieveDocuments (lib/lines/views.py:1930).

Parameters
----------
policy_type_item_id : str, required

Returns
-------
list of dict
    Each dict has file_id, form_id, title, and all 14 metadata
    fields (see domain.form.PolicyTypeItemFormMetadataSchema).

Code
Lists policy types based on the given parameters.

Get rating grid definitions.

Code
Returns:
    A list of serialized RatingTableDefinition objects.

Code
Returns a list of rating tables

Code
Update an effective date with the given parameters
@param params_data: dict

Code
Modifies a policy type with the given parameters.

Code
Modifies a line item with the given parameters.