grm-shared-library 1.1.237 → 1.1.239

package/dist/types/modules/incident-sla/interfaces/incident-sla-analytics.d.ts

@@ -0,0 +1,356 @@
+import { IncidentPriority } from '../../incident/enums/incident-priority.enum';
+import { IncidentSlaStage } from '../enums/incident-sla-stage.enum';
+import { SlaPriorityLevel } from '../enums/sla-overall-state.enum';
+/**
+ * Emergency SLA analytics (the admin's SLA Analytics): how fast the control room
+ * and the response units answered the emergencies raised over a period, stage by
+ * stage, against the targets of the policy each emergency ran under - and what
+ * happened when they did not (escalations, alternative units, pauses, exceptions,
+ * notifications).
+ *
+ * One read, computed by clarion-incident from one consistent snapshot. Counts,
+ * rates and durations only.
+ *
+ * How it is counted:
+ *  - Everything belongs to the period its EMERGENCY was raised in (the incident's
+ *    creation): its stage clocks, dispatches, escalations and notifications, even
+ *    when they happened after the period ended. So every figure on the page is
+ *    about the same emergencies.
+ *  - Compliance = met / (met + breached), over stage clocks that were decided.
+ *    An approved exception shows in its own figure; the breach stays a breach.
+ *  - Durations are in SECONDS, measured from the incident's creation (the SLA's
+ *    start) unless the field says otherwise; stage durations exclude paused time.
+ *  - Only measured emergencies count: INCIDENT class, reaching a control room.
+ */
+/** How the period is cut into points for the charts. Chosen by the service from the length of the period. */
+export type IncidentSlaAnalyticsBucket = 'hour' | 'day' | 'week' | 'month';
+export interface IncidentSlaAnalyticsRange {
+    /** Inclusive, ISO 8601. The first emergency when the period asked for was "forever". */
+    from: string;
+    /** Exclusive, ISO 8601. */
+    to: string;
+    bucket: IncidentSlaAnalyticsBucket;
+    /** IANA time zone the buckets and the hour-of-week grid are cut in. */
+    timeZone: string;
+}
+/** A count by a key, largest first unless the section says otherwise. */
+export interface IncidentSlaAnalyticsCount<K extends string = string> {
+    key: K;
+    count: number;
+}
+/** Median and 90th percentile of one duration, in seconds; null when nothing was measured. */
+export interface IncidentSlaDurationSummary {
+    median: number | null;
+    p90: number | null;
+    /** How many were measured. */
+    count: number;
+}
+/**
+ * Durations at percentiles, in seconds. Percentiles are the point: an average
+ * hides the slow tail, and the slow tail is the emergency that went wrong.
+ */
+export interface IncidentSlaDurationPercentiles {
+    p50: number | null;
+    p75: number | null;
+    p90: number | null;
+    p95: number | null;
+    p99: number | null;
+    average: number | null;
+    /** How many were measured. */
+    count: number;
+}
+/** The headline figures of a period. */
+export interface IncidentSlaAnalyticsSummary {
+    /** Measured emergencies raised in the period. */
+    emergencies: number;
+    /** Of those, still being worked (not yet closed / ended). */
+    openNow: number;
+    /** With at least one breached stage. */
+    breachedEmergencies: number;
+    breachedEmergencyPercent: number | null;
+    /** Stage clocks decided: met + breached. */
+    decided: number;
+    met: number;
+    breached: number;
+    breachedWithApprovedException: number;
+    compliancePercent: number | null;
+    complianceWithExceptionsPercent: number | null;
+    acknowledged: number;
+    dispatched: number;
+    /** A unit reached the scene. */
+    arrived: number;
+    resolved: number;
+    closed: number;
+    autoClosed: number;
+    /** Raised to acknowledged. */
+    timeToAcknowledge: IncidentSlaDurationSummary;
+    /** Raised to the first dispatch. */
+    timeToDispatch: IncidentSlaDurationSummary;
+    /** Raised to the first unit on scene - the response time the reporter lives through. */
+    timeToArrival: IncidentSlaDurationSummary;
+    /** First unit assigned to first unit on scene - the travel. */
+    travelTime: IncidentSlaDurationSummary;
+    /** Raised to resolved. */
+    timeToResolve: IncidentSlaDurationSummary;
+    escalations: number;
+    alternativesRecommended: number;
+    reassignments: number;
+    /** Notification requests that reached nobody or only some (FAILED, PARTIAL). */
+    notificationsFailed: number;
+}
+/** One stage across the period's emergencies. */
+export interface IncidentSlaStageAnalytics {
+    stage: IncidentSlaStage;
+    /** Clocks of this stage (one per dispatch for acceptance and mobilization). */
+    instances: number;
+    met: number;
+    breached: number;
+    breachedWithApprovedException: number;
+    /** Still running, or paused. */
+    open: number;
+    waived: number;
+    /** Ended with the incident before its milestone (expired), or never started (cancelled). */
+    expired: number;
+    cancelled: number;
+    /** Reached the warning (75 %) / at-risk (90 %) mark. */
+    warned: number;
+    atRisk: number;
+    compliancePercent: number | null;
+    complianceWithExceptionsPercent: number | null;
+    /** The target most of these clocks ran against (median), seconds. */
+    targetSeconds: number | null;
+    /** Start to milestone, pauses excluded, over the clocks that reached it. */
+    duration: IncidentSlaDurationPercentiles;
+    /** By how much the breached ones were late. */
+    overrun: IncidentSlaDurationSummary;
+}
+/** One stage of one priority, for the priority × stage grid. */
+export interface IncidentSlaStageCell {
+    stage: IncidentSlaStage;
+    met: number;
+    breached: number;
+    compliancePercent: number | null;
+    medianSeconds: number | null;
+}
+export interface IncidentSlaPriorityRow {
+    priority: IncidentPriority;
+    level: SlaPriorityLevel;
+    emergencies: number;
+    breachedEmergencies: number;
+    met: number;
+    breached: number;
+    compliancePercent: number | null;
+    medianSecondsToAcknowledge: number | null;
+    medianSecondsToArrival: number | null;
+    stages: IncidentSlaStageCell[];
+}
+/** One point of the charts. `bucket` is its start, local to the range's zone, without an offset. */
+export interface IncidentSlaTimelinePoint {
+    bucket: string;
+    emergencies: number;
+    breachedEmergencies: number;
+    met: number;
+    breached: number;
+    compliancePercent: number | null;
+    medianSecondsToAcknowledge: number | null;
+    medianSecondsToArrival: number | null;
+    escalations: number;
+}
+export interface IncidentSlaControlCentreRow {
+    /** Null: emergencies no control centre was set on. */
+    controlCentreId: number | null;
+    emergencies: number;
+    breachedEmergencies: number;
+    met: number;
+    breached: number;
+    compliancePercent: number | null;
+    medianSecondsToAcknowledge: number | null;
+    medianSecondsToDispatch: number | null;
+    medianSecondsToArrival: number | null;
+    escalations: number;
+}
+export interface IncidentSlaTypeRow {
+    typeId: number | null;
+    typeName: string | null;
+    categoryId: number | null;
+    categoryName: string | null;
+    emergencies: number;
+    breachedEmergencies: number;
+    met: number;
+    breached: number;
+    compliancePercent: number | null;
+    medianSecondsToArrival: number | null;
+}
+export interface IncidentSlaResponseUnitRow {
+    responseUnitId: number;
+    responseUnitName: string;
+    dispatches: number;
+    /** Acknowledged the dispatch (accepted). */
+    accepted: number;
+    declined: number;
+    stoodDown: number;
+    arrived: number;
+    /** Arrivals inferred from the unit's live tracking. */
+    arrivalsInferred: number;
+    /** The acceptance clock, for this unit. */
+    acceptanceMet: number;
+    acceptanceBreached: number;
+    acceptanceCompliancePercent: number | null;
+    medianSecondsToAccept: number | null;
+    /** Accepted to en route. */
+    medianSecondsToMobilize: number | null;
+    /** Dispatched to on scene. */
+    medianSecondsToArrive: number | null;
+}
+export interface IncidentSlaArrivalAnalytics {
+    arrivals: number;
+    /** How each first arrival is known: inferred from tracking, the responder, the control room (UNKNOWN for older ones). */
+    bySource: IncidentSlaAnalyticsCount[];
+    inferredPercent: number | null;
+    /** Dispatches whose live ETA turned at risk / likely late / uncertain at least once. */
+    etaAtRisk: number;
+    etaLikelyLate: number;
+    etaUncertain: number;
+    /** Emergencies a unit was predicted late for, and of those, how many breached the arrival target. */
+    predictedLate: number;
+    predictedLateAndBreached: number;
+    /** predictedLateAndBreached / predictedLate. */
+    latePredictionPrecisionPercent: number | null;
+    /** How far the first ETA was from the actual arrival (absolute seconds). */
+    firstEtaError: IncidentSlaDurationSummary;
+    /** Straight-line distance of the unit when dispatched, metres. */
+    distanceAtDispatch: IncidentSlaDurationSummary;
+}
+export interface IncidentSlaEscalationAnalytics {
+    total: number;
+    /** SLA_BREACHED, SLA_AT_RISK, ETA_LIKELY_BREACH, DISPATCH_REJECTED... */
+    byTrigger: IncidentSlaAnalyticsCount[];
+    /** DISPATCHER, SUPERVISOR, DUTY_MANAGER, ORGANIZATION_ADMIN. */
+    byLevel: IncidentSlaAnalyticsCount[];
+    byStage: IncidentSlaAnalyticsCount[];
+    /** The policy rules that fired most - the ten commonest. */
+    byRule: IncidentSlaAnalyticsCount[];
+    alternativesRecommended: number;
+    reassignments: number;
+    /** Emergencies escalated at least once. */
+    escalatedEmergencies: number;
+}
+export interface IncidentSlaPauseAnalytics {
+    requested: number;
+    approved: number;
+    rejected: number;
+    /** Waiting for a supervisor. */
+    pending: number;
+    withdrawn: number;
+    totalPausedSeconds: number;
+    pausedTime: IncidentSlaDurationSummary;
+    byReason: IncidentSlaAnalyticsCount[];
+}
+export interface IncidentSlaExceptionAnalytics {
+    requested: number;
+    approved: number;
+    rejected: number;
+    pending: number;
+    byReason: IncidentSlaAnalyticsCount[];
+}
+export interface IncidentSlaNotificationEventRow {
+    /** emergency-created, emergency-sla-breached... */
+    event: string;
+    requests: number;
+    failed: number;
+}
+export interface IncidentSlaNotificationChannelRow {
+    channel: string;
+    recipients: number;
+    sent: number;
+    failed: number;
+    successPercent: number | null;
+}
+export interface IncidentSlaNotificationAnalytics {
+    /** Requests clarion-notification answered. */
+    requests: number;
+    /** SENT, PARTIAL, FAILED, NOT_POSSIBLE. */
+    byStatus: IncidentSlaAnalyticsCount[];
+    byEvent: IncidentSlaNotificationEventRow[];
+    byChannel: IncidentSlaNotificationChannelRow[];
+    /** By audience: REPORTER, DISPATCHER, SUPERVISOR... (people reached). */
+    byAudience: IncidentSlaAnalyticsCount[];
+}
+export interface IncidentSlaClosureAnalytics {
+    resolved: number;
+    closed: number;
+    manual: number;
+    automatic: number;
+    /** Resolved and not closed yet. */
+    awaitingClosure: number;
+    /** Emergencies whose automatic closure waited for a unit still out. */
+    autoCloseDeferred: number;
+    resolvedToClosed: IncidentSlaDurationSummary;
+}
+/** One hour of one weekday (1 = Monday), in the range's zone. */
+export interface IncidentSlaHeatmapCell {
+    weekday: number;
+    hour: number;
+    emergencies: number;
+    breachedEmergencies: number;
+}
+/** The emergencies that went most wrong - by total time over target. */
+export interface IncidentSlaWorstIncident {
+    incidentId: number;
+    /** `#1234`. */
+    reference: string;
+    priority: IncidentPriority;
+    typeName: string | null;
+    controlCentreId: number | null;
+    createdAt: string;
+    breachedStages: number;
+    worstStage: IncidentSlaStage | null;
+    maxOverrunSeconds: number;
+    totalOverrunSeconds: number;
+    timeToArrivalSeconds: number | null;
+}
+/** A Super-Admin's platform view: one row per organization. */
+export interface IncidentSlaOrganizationRow {
+    organizationId: number;
+    emergencies: number;
+    breachedEmergencies: number;
+    met: number;
+    breached: number;
+    compliancePercent: number | null;
+    medianSecondsToAcknowledge: number | null;
+    medianSecondsToArrival: number | null;
+}
+/** `GET /incident-sla/analytics`. */
+export interface IncidentSlaAnalytics {
+    range: IncidentSlaAnalyticsRange;
+    /** The organization the figures are for; null in a Super-Admin's platform view. */
+    organizationId: number | null;
+    controlCentreId: number | null;
+    /** A Super-Admin across every organization (`byOrganization` is filled). */
+    platform: boolean;
+    summary: IncidentSlaAnalyticsSummary;
+    /** The previous period of the same length; null for "forever". */
+    previous: IncidentSlaAnalyticsSummary | null;
+    stages: IncidentSlaStageAnalytics[];
+    /** Critical, High, Medium, Low - in that order, zeros included. */
+    byPriority: IncidentSlaPriorityRow[];
+    timeline: IncidentSlaTimelinePoint[];
+    byControlCentre: IncidentSlaControlCentreRow[];
+    byType: IncidentSlaTypeRow[];
+    /** The 25 units dispatched most. */
+    byResponseUnit: IncidentSlaResponseUnitRow[];
+    arrival: IncidentSlaArrivalAnalytics;
+    escalations: IncidentSlaEscalationAnalytics;
+    pauses: IncidentSlaPauseAnalytics;
+    exceptions: IncidentSlaExceptionAnalytics;
+    notifications: IncidentSlaNotificationAnalytics;
+    closure: IncidentSlaClosureAnalytics;
+    /** emergency, panic... (the alert's own kind). */
+    emergencyTypes: IncidentSlaAnalyticsCount[];
+    heatmap: IncidentSlaHeatmapCell[];
+    worstIncidents: IncidentSlaWorstIncident[];
+    byOrganization: IncidentSlaOrganizationRow[];
+    generatedAt: string;
+}
+/** The name the first release used. */
+export type IncidentSlaAnalyticsResult = IncidentSlaAnalytics;

package/dist/types/modules/incident-sla/interfaces/incident-sla-events.d.ts

@@ -0,0 +1,173 @@
+import { IncidentPriority } from '../../incident/enums/incident-priority.enum';
+import { EmergencyIncidentStage } from '../enums/emergency-incident-stage.enum';
+import { EmergencyNotificationAudience, EmergencyNotificationEvent, EmergencyNotificationResultStatus } from '../enums/emergency-notification.enum';
+import { EtaBasis, EtaStatus } from '../enums/eta-status.enum';
+import { IncidentArrivalSource, IncidentClosureReason } from '../enums/incident-closure.enum';
+import { IncidentActorType, IncidentSlaEventSource } from '../enums/incident-sla-actor.enum';
+import { IncidentSlaEventType } from '../enums/incident-sla-event-type.enum';
+import { IncidentSlaStage } from '../enums/incident-sla-stage.enum';
+import { IncidentSlaStatus } from '../enums/incident-sla-status.enum';
+import { SlaEscalationLevel, SlaEscalationTrigger, SlaNotificationChannel } from '../enums/sla-escalation.enum';
+import { SlaPriorityLevel } from '../enums/sla-overall-state.enum';
+import { IncidentSlaEscalationContact } from './incident-sla-policy';
+/** Fields every emergency/SLA domain event carries. Keyed by incident id on Kafka. */
+export interface EmergencyIncidentEventBase {
+    schemaVersion: 1;
+    /** Deterministic per change, so a redelivery is recognisable. */
+    eventId: string;
+    /** When the change happened (a milestone's own time, a threshold's instant). */
+    occurredAt: string;
+    /** When clarion-incident recorded it. */
+    recordedAt: string;
+    incidentId: number;
+    organizationId: number;
+    controlCentreId: number | null;
+    actorType: IncidentActorType;
+    source: IncidentSlaEventSource;
+    actorUserId: number | null;
+    correlationId: string | null;
+}
+/**
+ * `incident.emergency.milestone-recorded.v1` - the response reached a milestone
+ * (acknowledged, dispatched, on scene, resolved, closed...). No names, numbers
+ * or addresses.
+ */
+export interface EmergencyMilestoneRecordedEventV1 extends EmergencyIncidentEventBase {
+    milestone: EmergencyIncidentStage;
+    currentStage: EmergencyIncidentStage;
+    /** Proven by a later milestone rather than recorded directly. */
+    implied: boolean;
+    incidentStatus: string;
+    responseUnitDispatchId: number | null;
+    responseUnitId: number | null;
+    arrivalSource: IncidentArrivalSource | null;
+    closureReason: IncidentClosureReason | null;
+}
+/** `incident.sla.changed.v1` - one SLA instance changed state. */
+export interface IncidentSlaChangedEventV1 extends EmergencyIncidentEventBase {
+    eventType: IncidentSlaEventType;
+    instanceId: number;
+    stage: IncidentSlaStage;
+    cycle: number;
+    responseUnitDispatchId: number | null;
+    priority: IncidentPriority;
+    previousStatus: IncidentSlaStatus | null;
+    status: IncidentSlaStatus;
+    startedAt: string | null;
+    deadlineAt: string | null;
+    completedAt: string | null;
+    slaPolicyId: number | null;
+    slaPolicyVersion: number | null;
+}
+/** `incident.emergency.eta-changed.v1` - a dispatched unit's ETA status changed. */
+export interface EmergencyEtaChangedEventV1 extends EmergencyIncidentEventBase {
+    responseUnitDispatchId: number;
+    responseUnitId: number;
+    previousStatus: EtaStatus | null;
+    status: EtaStatus;
+    etaSeconds: number | null;
+    predictedArrivalAt: string | null;
+    arrivalDeadlineAt: string | null;
+    distanceMetres: number | null;
+    locationAgeSeconds: number | null;
+    basis: EtaBasis | null;
+}
+/** The incident facts an emergency notification is written from. */
+export interface EmergencyNotificationIncidentFacts {
+    /** `#1234`. */
+    reference: string;
+    typeName: string | null;
+    categoryName: string | null;
+    priority: IncidentPriority | null;
+    priorityLevel: SlaPriorityLevel | null;
+    status: string;
+    /** The description, clamped; null for a sensitive incident. */
+    summary: string | null;
+    address: string | null;
+    latitude: number | null;
+    longitude: number | null;
+    createdAt: string;
+    /** For the reporter's own notifications; never shown to staff by notification. */
+    reporterUserId: number | null;
+    anonymous: boolean;
+    /** The control room working it - the DISPATCHER audience's first recipients. */
+    assigneeIds: number[];
+}
+/** One audience of a notification request: who, by which channels. */
+export interface EmergencyNotificationAudienceSpec {
+    audience: EmergencyNotificationAudience;
+    channels: SlaNotificationChannel[];
+    /** Overrides the audience's default roles (Roles values). */
+    roles: string[];
+    /** Named contacts (a duty manager). */
+    contacts: IncidentSlaEscalationContact[];
+}
+/**
+ * `incident.emergency.notification-requested.v1` - a COMMAND to
+ * clarion-notification. The one emergency message that may carry contact
+ * details (a duty manager's number); it goes to one consumer, and its outbox
+ * copy is masked once published.
+ */
+export interface EmergencyNotificationRequestedV1 {
+    schemaVersion: 1;
+    /** The idempotency base: notification dedupes per (eventId, recipient, channel). */
+    eventId: string;
+    occurredAt: string;
+    incidentId: number;
+    organizationId: number;
+    controlCentreId: number | null;
+    event: EmergencyNotificationEvent;
+    audiences: EmergencyNotificationAudienceSpec[];
+    incident: EmergencyNotificationIncidentFacts;
+    sla: {
+        stage: IncidentSlaStage;
+        status: IncidentSlaStatus;
+        targetSeconds: number | null;
+        deadlineAt: string | null;
+        overdueSeconds: number | null;
+    } | null;
+    eta: {
+        status: EtaStatus;
+        etaSeconds: number | null;
+        predictedArrivalAt: string | null;
+        distanceMetres: number | null;
+    } | null;
+    unit: {
+        responseUnitId: number;
+        name: string | null;
+    } | null;
+    alternative: {
+        responseUnitId: number;
+        name: string | null;
+        distanceMetres: number | null;
+        etaSeconds: number | null;
+    } | null;
+    escalation: {
+        ruleKey: string;
+        trigger: SlaEscalationTrigger;
+        level: SlaEscalationLevel;
+    } | null;
+    workflowId: string | null;
+    correlationId: string | null;
+}
+/** Per audience x channel delivery counts. Counts only: no addresses. */
+export interface EmergencyNotificationDelivery {
+    audience: EmergencyNotificationAudience;
+    channel: SlaNotificationChannel;
+    recipients: number;
+    sent: number;
+    failed: number;
+}
+/** `notification.emergency-incident.notification-result.v1` - what became of one request. */
+export interface EmergencyNotificationResultV1 {
+    schemaVersion: 1;
+    eventId: string;
+    requestEventId: string;
+    incidentId: number;
+    organizationId: number;
+    event: EmergencyNotificationEvent;
+    status: EmergencyNotificationResultStatus;
+    deliveries: EmergencyNotificationDelivery[];
+    failureReason: string | null;
+    occurredAt: string;
+}

package/dist/types/modules/incident-sla/interfaces/incident-sla-policy.d.ts

@@ -0,0 +1,147 @@
+import { IncidentEmergencyType } from '../../incident/enums/incident-emergency-type.enum';
+import { IncidentPriority } from '../../incident/enums/incident-priority.enum';
+import { EmergencyIncidentStage } from '../enums/emergency-incident-stage.enum';
+import { IncidentSlaStage } from '../enums/incident-sla-stage.enum';
+import { SlaEscalationAction, SlaEscalationLevel, SlaEscalationTrigger, SlaNotificationChannel } from '../enums/sla-escalation.enum';
+import { SlaPolicyScope } from '../enums/sla-policy-scope.enum';
+/** A named person outside the role directory an escalation may reach (a duty manager). */
+export interface IncidentSlaEscalationContact {
+    name?: string | null;
+    /** E.164. */
+    phoneNumber?: string | null;
+    email?: string | null;
+}
+/**
+ * One escalation rule: when `trigger` happens on one of `stages` (any, when
+ * empty) for one of `priorities` (any, when empty), wait `delaySeconds` and, if
+ * the situation still stands, reach `level` through `channels` and do `actions`.
+ */
+export interface IncidentSlaEscalationRule {
+    /** Stable within its policy; the workflow and the audit trail name rules by key. */
+    key: string;
+    trigger: SlaEscalationTrigger;
+    stages: IncidentSlaStage[];
+    priorities: IncidentPriority[];
+    level: SlaEscalationLevel;
+    channels: SlaNotificationChannel[];
+    actions: SlaEscalationAction[];
+    delaySeconds: number;
+    /** Overrides the level's default roles (Roles values). Empty = the level's default. */
+    recipientRoles: string[];
+    /** Extra named people (a duty manager). Never leaves clarion-incident except in the notification command. */
+    contacts: IncidentSlaEscalationContact[];
+}
+/** One stage's target for one priority. `targetSeconds: null` = the stage is not measured. */
+export interface IncidentSlaTargetEntry {
+    stage: IncidentSlaStage;
+    priority: IncidentPriority;
+    targetSeconds: number | null;
+}
+/**
+ * Policy settings beside the targets. On a stored policy every field is
+ * optional - absent means "inherit from the less specific policy"; on a
+ * resolved policy every field is filled.
+ */
+export interface IncidentSlaPolicySettings {
+    /** % of the target at which an instance turns WARNING (default 75). */
+    warningThresholdPercent: number;
+    /** % of the target at which an instance turns AT_RISK (default 90). */
+    atRiskThresholdPercent: number;
+    /** Distance from the incident within which a unit counts as at the scene. */
+    arrivalRadiusMetres: number;
+    /** A unit inside the radius only leaves the scene beyond this (hysteresis). */
+    arrivalExitRadiusMetres: number;
+    /** How long a unit must stay inside the radius before arrival is inferred. */
+    arrivalDwellSeconds: number;
+    /** How many in-radius fixes that takes, at least. */
+    arrivalMinObservations: number;
+    /** A fix less accurate than this can never confirm an arrival. */
+    maxLocationAccuracyMetres: number;
+    /** A position older than this is not current: the ETA becomes UNCERTAIN. */
+    trackingStaleSeconds: number;
+    /** ETA within this % of the arrival target before the deadline = AT_RISK. */
+    etaAtRiskMarginPercent: number;
+    /** Speed assumed for an estimated ETA (urban, with stops). */
+    etaAssumedSpeedKph: number;
+    /** Straight line -> road distance factor for an estimated ETA. */
+    etaRoadFactor: number;
+    autoCloseEnabled: boolean;
+    /** Resolution -> automatic closure, default 24 h. */
+    autoCloseAfterSeconds: number;
+    /** May the workflow replace a unit by itself? Default false: the dispatcher decides. */
+    allowAutomaticReassignment: boolean;
+    /** Does a dispatcher's pause wait for a supervisor? Default true. */
+    pauseRequiresApproval: boolean;
+    /** Send the reporter the emergency progress messages (dispatched, arrived, resolved...). */
+    notifyReporter: boolean;
+}
+/** Floors an emergency type puts under the SLA priority (SOS alerts arrive as the column default, Medium). */
+export type IncidentSlaPriorityFloors = Partial<Record<IncidentEmergencyType, IncidentPriority>>;
+/** Which milestone starts each stage's clock (where configurable). */
+export type IncidentSlaStartAnchors = Partial<Record<IncidentSlaStage, EmergencyIncidentStage>>;
+/** The dimensions a policy may be scoped to. Null = any. */
+export interface IncidentSlaPolicyScopeKeys {
+    organizationId: number | null;
+    controlCentreId: number | null;
+    categoryId: number | null;
+    typeId: number | null;
+    priority: IncidentPriority | null;
+    zoneId: number | null;
+}
+/** A stored policy version, as the API returns it. */
+export interface IncidentSlaPolicyRecord extends IncidentSlaPolicyScopeKeys {
+    id: number;
+    /** The policy across its versions. */
+    policyKey: string;
+    version: number;
+    name: string;
+    description: string | null;
+    scope: SlaPolicyScope;
+    incidentClass: string;
+    effectiveFrom: string;
+    effectiveTo: string | null;
+    active: boolean;
+    settings: Partial<IncidentSlaPolicySettings>;
+    priorityFloors: IncidentSlaPriorityFloors | null;
+    startAnchors: IncidentSlaStartAnchors | null;
+    targets: IncidentSlaTargetEntry[];
+    /** Null = inherit the less specific policy's rules; [] = no escalation at all. */
+    escalationRules: IncidentSlaEscalationRule[] | null;
+    /** How many incidents froze this version (it is immutable once > 0). */
+    usageCount?: number;
+    createdBy: number | null;
+    updatedBy: number | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** One policy version that contributed to a resolution, least specific first. */
+export interface IncidentSlaContributingPolicy {
+    policyId: number;
+    policyKey: string;
+    version: number;
+    name: string;
+    scope: SlaPolicyScope;
+}
+/**
+ * The policy an incident runs under, resolved once when its SLA starts and
+ * frozen on the incident. A later policy change never touches it.
+ */
+export interface ResolvedIncidentSlaPolicy {
+    schemaVersion: 1;
+    /** The most specific contributing version; null when only the built-in defaults applied. */
+    policyId: number | null;
+    policyKey: string | null;
+    policyVersion: number | null;
+    policyName: string;
+    scope: SlaPolicyScope;
+    contributingPolicies: IncidentSlaContributingPolicy[];
+    /** The instant the policy was resolved for (the incident's creation time). */
+    effectiveAt: string;
+    resolvedAt: string;
+    /** Every stage x priority target, so a triaged priority needs no re-resolution. Seconds, null = not measured. */
+    targets: Record<IncidentPriority, Record<IncidentSlaStage, number | null>>;
+    startAnchors: Record<IncidentSlaStage, EmergencyIncidentStage>;
+    settings: IncidentSlaPolicySettings;
+    priorityFloors: IncidentSlaPriorityFloors;
+    escalationRules: IncidentSlaEscalationRule[];
+}