grm-shared-library 1.1.236 → 1.1.238

package/dist/types/modules/incident-sla/enums/emergency-notification.enum.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The emergency (INCIDENT-class) notifications - a namespace of their own,
+ * never the grievance templates. Each value names one message, rendered per
+ * channel by clarion-notification (`templates/incident/`).
+ */
+export declare enum EmergencyNotificationEvent {
+    EMERGENCY_CREATED = "emergency-created",
+    EMERGENCY_ACKNOWLEDGED = "emergency-acknowledged",
+    EMERGENCY_DISPATCHED = "emergency-dispatched",
+    EMERGENCY_UNIT_ASSIGNED = "emergency-unit-assigned",
+    EMERGENCY_UNIT_EN_ROUTE = "emergency-unit-en-route",
+    EMERGENCY_ARRIVED = "emergency-arrived",
+    EMERGENCY_AT_RISK = "emergency-at-risk",
+    EMERGENCY_SLA_BREACHED = "emergency-sla-breached",
+    EMERGENCY_ESCALATED = "emergency-escalated",
+    EMERGENCY_RESOLVED = "emergency-resolved",
+    EMERGENCY_CLOSED = "emergency-closed"
+}
+/** Who an emergency notification is addressed to. */
+export declare enum EmergencyNotificationAudience {
+    REPORTER = "REPORTER",
+    DISPATCHER = "DISPATCHER",
+    SUPERVISOR = "SUPERVISOR",
+    DUTY_MANAGER = "DUTY_MANAGER",
+    ORGANIZATION_ADMIN = "ORGANIZATION_ADMIN"
+}
+/** clarion-notification's answer to one emergency notification request. */
+export declare enum EmergencyNotificationResultStatus {
+    /** Every attempted delivery went out. */
+    SENT = "SENT",
+    /** Some deliveries went out, some failed. */
+    PARTIAL = "PARTIAL",
+    /** Nothing went out, though somebody should have received it. */
+    FAILED = "FAILED",
+    /** Nobody to deliver to (no recipients resolved, no contact configured). */
+    NOT_POSSIBLE = "NOT_POSSIBLE"
+}

package/dist/types/modules/incident-sla/enums/eta-status.enum.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Whether a dispatched unit is predicted to make the arrival deadline, from its
+ * live position. UNCERTAIN is a first-class answer: a stale or missing position
+ * must never produce confidence the data does not support.
+ */
+export declare enum EtaStatus {
+    /** Predicted arrival comfortably before the deadline. */
+    ON_TRACK = "ON_TRACK",
+    /** Predicted arrival inside the at-risk margin before the deadline. */
+    AT_RISK = "AT_RISK",
+    /** Predicted arrival after the deadline. */
+    LIKELY_BREACH = "LIKELY_BREACH",
+    /** No current position (stale, offline, never tracked, poor accuracy). */
+    UNCERTAIN = "UNCERTAIN",
+    /** The incident has no arrival target to compare with. */
+    NO_TARGET = "NO_TARGET",
+    /** The unit is on scene. */
+    ARRIVED = "ARRIVED"
+}
+/** How an ETA was worked out. */
+export declare enum EtaBasis {
+    /** Straight-line distance x road factor at an assumed urban speed (clarion-gis's ESTIMATE profile). */
+    ESTIMATE = "ESTIMATE",
+    /** A road route with traffic from clarion-gis. */
+    ROAD_ROUTE = "ROAD_ROUTE"
+}

package/dist/types/modules/incident-sla/enums/incident-closure.enum.d.ts

@@ -0,0 +1,17 @@
+/** Why an emergency incident was closed. */
+export declare enum IncidentClosureReason {
+    /** A control-room user closed it. */
+    MANUAL = "MANUAL",
+    /** The policy's resolution-to-closure period passed with nobody closing it. */
+    AUTO_CLOSED_AFTER_RESOLUTION_TIMEOUT = "AUTO_CLOSED_AFTER_RESOLUTION_TIMEOUT"
+}
+/**
+ * How a unit's arrival on scene came to be known. Kept apart on purpose: an
+ * arrival inferred from GPS is evidence, a responder's confirmation is a claim
+ * from the scene, and an auditor must be able to tell them apart.
+ */
+export declare enum IncidentArrivalSource {
+    ARRIVAL_CONFIRMED_BY_RESPONDER = "ARRIVAL_CONFIRMED_BY_RESPONDER",
+    ARRIVAL_CONFIRMED_BY_CONTROL_CENTRE = "ARRIVAL_CONFIRMED_BY_CONTROL_CENTRE",
+    ARRIVAL_INFERRED_FROM_TRACKING = "ARRIVAL_INFERRED_FROM_TRACKING"
+}

package/dist/types/modules/incident-sla/enums/incident-sla-actor.enum.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Who an operational event came from. The workflow contract never assumes the
+ * control room is the source: today almost everything is CONTROL_CENTRE, and a
+ * responder app will send the same events as RESPONDER without any redesign.
+ */
+export declare enum IncidentActorType {
+    /** A control-room user (dispatcher, supervisor, administrator). */
+    CONTROL_CENTRE = "CONTROL_CENTRE",
+    /** A responder, through the future responder app. */
+    RESPONDER = "RESPONDER",
+    /** The platform itself - the workflow, a timer, a lifecycle rule. Uses the system user. */
+    SYSTEM = "SYSTEM",
+    /** Inferred from live tracking (e.g. arrival in the geofence). */
+    TRACKING = "TRACKING",
+    /** The person who raised the incident. */
+    REPORTER = "REPORTER",
+    /** A third-party partner (e.g. an ambulance provider) through its integration. */
+    PARTNER = "PARTNER"
+}
+/** The channel an SLA event arrived through - recorded beside the actor for the audit trail. */
+export declare enum IncidentSlaEventSource {
+    /** The admin's incident view or the gateway API, by a control-room user. */
+    CONTROL_ROOM = "CONTROL_ROOM",
+    /** Reserved: the responder app. */
+    RESPONDER_APP = "RESPONDER_APP",
+    /** clarion-workflow-manager's emergency incident workflow (timers, escalation, auto-close). */
+    WORKFLOW = "WORKFLOW",
+    /** clarion-incident's evaluation of live tracking positions. */
+    TRACKING = "TRACKING",
+    /** A change of the incident's own status (resolved, closed...). */
+    INCIDENT_LIFECYCLE = "INCIDENT_LIFECYCLE",
+    /** A response-unit dispatch record (created, acknowledged, en route, on scene...). */
+    DISPATCH = "DISPATCH",
+    /** A third-party partner's progress (partner routing). */
+    PARTNER = "PARTNER",
+    /** clarion-notification reporting a delivery. */
+    NOTIFICATION = "NOTIFICATION",
+    /** Anything else the platform does on its own (initialisation, reconciliation). */
+    SYSTEM = "SYSTEM"
+}

package/dist/types/modules/incident-sla/enums/incident-sla-error-code.enum.d.ts

@@ -0,0 +1,21 @@
+/** Machine-readable `code` on a refused SLA request. */
+export declare enum IncidentSlaErrorCode {
+    /** Grievances, alerts that never reach the control room, and incidents with SLA switched off. */
+    SLA_NOT_TRACKED = "SLA_NOT_TRACKED",
+    SLA_INSTANCE_NOT_FOUND = "SLA_INSTANCE_NOT_FOUND",
+    SLA_PAUSE_NOT_FOUND = "SLA_PAUSE_NOT_FOUND",
+    SLA_POLICY_NOT_FOUND = "SLA_POLICY_NOT_FOUND",
+    /** The instance is not in a state that allows this (e.g. pausing a breached one). */
+    SLA_INVALID_STATE = "SLA_INVALID_STATE",
+    /** Approving needs a supervisor (Control-Centre:Admin, Organization Owner/Admin). */
+    SLA_APPROVER_REQUIRED = "SLA_APPROVER_REQUIRED",
+    /** Somebody may not approve their own request. */
+    SLA_SELF_APPROVAL = "SLA_SELF_APPROVAL",
+    SLA_POLICY_INVALID = "SLA_POLICY_INVALID",
+    /** Only Super-Admin manages platform policies; an organization manages its own. */
+    SLA_POLICY_FORBIDDEN = "SLA_POLICY_FORBIDDEN",
+    INCIDENT_NOT_EMERGENCY = "INCIDENT_NOT_EMERGENCY",
+    INCIDENT_ENDED = "INCIDENT_ENDED",
+    /** No escalation rule with that key in the incident's frozen policy. */
+    SLA_ESCALATION_RULE_NOT_FOUND = "SLA_ESCALATION_RULE_NOT_FOUND"
+}

package/dist/types/modules/incident-sla/enums/incident-sla-event-type.enum.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Every entry in an incident's SLA history. The history is append-only: a
+ * transition is a new row, never an edit of an old one.
+ */
+export declare enum IncidentSlaEventType {
+    SLA_STARTED = "SLA_STARTED",
+    SLA_WARNING = "SLA_WARNING",
+    SLA_AT_RISK = "SLA_AT_RISK",
+    SLA_BREACHED = "SLA_BREACHED",
+    SLA_MET = "SLA_MET",
+    /** The milestone was reached after the deadline: the breach stands, completedAt is recorded. */
+    SLA_COMPLETED_LATE = "SLA_COMPLETED_LATE",
+    SLA_CANCELLED = "SLA_CANCELLED",
+    SLA_EXPIRED = "SLA_EXPIRED",
+    SLA_WAIVED = "SLA_WAIVED",
+    SLA_PAUSE_REQUESTED = "SLA_PAUSE_REQUESTED",
+    SLA_PAUSE_REJECTED = "SLA_PAUSE_REJECTED",
+    SLA_PAUSED = "SLA_PAUSED",
+    SLA_RESUMED = "SLA_RESUMED",
+    SLA_EXCEPTION_REQUESTED = "SLA_EXCEPTION_REQUESTED",
+    SLA_EXCEPTION_APPROVED = "SLA_EXCEPTION_APPROVED",
+    SLA_EXCEPTION_REJECTED = "SLA_EXCEPTION_REJECTED",
+    MILESTONE_RECORDED = "MILESTONE_RECORDED",
+    PRIORITY_TRIAGED = "PRIORITY_TRIAGED",
+    ETA_CHANGED = "ETA_CHANGED",
+    ARRIVAL_INFERRED = "ARRIVAL_INFERRED",
+    ARRIVAL_CONFIRMED = "ARRIVAL_CONFIRMED",
+    UNIT_RECOMMENDED = "UNIT_RECOMMENDED",
+    UNIT_REASSIGNED = "UNIT_REASSIGNED",
+    ESCALATED = "ESCALATED",
+    NOTIFICATION_SENT = "NOTIFICATION_SENT",
+    NOTIFICATION_FAILED = "NOTIFICATION_FAILED",
+    AUTO_CLOSE_DEFERRED = "AUTO_CLOSE_DEFERRED",
+    INCIDENT_AUTO_CLOSED = "INCIDENT_AUTO_CLOSED",
+    INCIDENT_CLOSED = "INCIDENT_CLOSED"
+}

package/dist/types/modules/incident-sla/enums/incident-sla-stage.enum.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The milestones an emergency incident is measured against. Each is its own SLA
+ * instance with its own clock, so "acknowledged on time, arrived late" is a
+ * fact the record can state - one incident-wide deadline could not.
+ *
+ * RESPONSE_UNIT_ACCEPTANCE and MOBILIZATION are measured per dispatch (a unit
+ * that is stood down and replaced starts a new cycle); every other stage once
+ * per incident. ARRIVAL in particular never restarts on a reassignment - the
+ * person waiting does not get a new clock because a different unit is coming.
+ */
+export declare enum IncidentSlaStage {
+    ACKNOWLEDGEMENT = "ACKNOWLEDGEMENT",
+    TRIAGE = "TRIAGE",
+    DISPATCH = "DISPATCH",
+    RESPONSE_UNIT_ACCEPTANCE = "RESPONSE_UNIT_ACCEPTANCE",
+    MOBILIZATION = "MOBILIZATION",
+    ARRIVAL = "ARRIVAL",
+    INITIAL_ASSESSMENT = "INITIAL_ASSESSMENT",
+    RESOLUTION = "RESOLUTION",
+    CLOSURE = "CLOSURE"
+}

package/dist/types/modules/incident-sla/enums/incident-sla-status.enum.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Where one SLA instance stands.
+ *
+ * RUNNING -> WARNING -> AT_RISK -> BREACHED as its clock passes the policy's
+ * thresholds (75 % / 90 % / 100 % by default), and MET when its milestone is
+ * reached before the deadline. Whether an instance was met or breached is
+ * decided by timestamps (completedAt against deadlineAt), never by when a timer
+ * happened to fire.
+ *
+ * BREACHED is permanent: completing the milestone afterwards records
+ * completedAt but leaves the status BREACHED, and an approved exception changes
+ * only how the breach counts for compliance, not the record of it.
+ *
+ * - PAUSED: an approved pause (location inaccessible, waiting for the customer...).
+ *   Only an unbreached instance can be paused; a pause never hides a breach.
+ * - WAIVED: an authorised supervisor declared the stage not applicable before it completed.
+ * - CANCELLED: made not applicable by an event (the unit rejected the dispatch,
+ *   it was stood down, the incident ended before the stage ever started).
+ * - EXPIRED: the incident ended while the stage was still running, before its deadline.
+ * - NOT_STARTED: the stage's start milestone has not happened yet.
+ */
+export declare enum IncidentSlaStatus {
+    NOT_STARTED = "NOT_STARTED",
+    RUNNING = "RUNNING",
+    WARNING = "WARNING",
+    AT_RISK = "AT_RISK",
+    PAUSED = "PAUSED",
+    BREACHED = "BREACHED",
+    MET = "MET",
+    WAIVED = "WAIVED",
+    CANCELLED = "CANCELLED",
+    EXPIRED = "EXPIRED"
+}

package/dist/types/modules/incident-sla/enums/sla-escalation.enum.d.ts

@@ -0,0 +1,42 @@
+/** Who an escalation reaches. Each level resolves to people within the incident's own tenancy. */
+export declare enum SlaEscalationLevel {
+    /** The control room working the incident: its assignees and the control centre's users. */
+    DISPATCHER = "DISPATCHER",
+    /** The control centre's supervisors (Control-Centre:Admin). */
+    SUPERVISOR = "SUPERVISOR",
+    /** Contacts configured on the escalation rule - only "where configured". */
+    DUTY_MANAGER = "DUTY_MANAGER",
+    /** The organization's owners and administrators. */
+    ORGANIZATION_ADMIN = "ORGANIZATION_ADMIN"
+}
+/** What makes an escalation rule fire. */
+export declare enum SlaEscalationTrigger {
+    SLA_WARNING = "SLA_WARNING",
+    SLA_AT_RISK = "SLA_AT_RISK",
+    SLA_BREACHED = "SLA_BREACHED",
+    /** The assigned unit's predicted arrival is close to the arrival deadline. */
+    ETA_AT_RISK = "ETA_AT_RISK",
+    /** The assigned unit is predicted to arrive after the arrival deadline. */
+    ETA_LIKELY_BREACH = "ETA_LIKELY_BREACH",
+    /** Tracking went quiet: no current position to predict an arrival from. */
+    ETA_UNCERTAIN = "ETA_UNCERTAIN",
+    /** A unit declined a dispatch. */
+    DISPATCH_REJECTED = "DISPATCH_REJECTED",
+    /** A unit was stood down before arriving (became unavailable, reassigned...). */
+    DISPATCH_CANCELLED = "DISPATCH_CANCELLED"
+}
+/** What an escalation does besides telling people. */
+export declare enum SlaEscalationAction {
+    NOTIFY = "NOTIFY",
+    /** Re-evaluate the eligible units and put the best alternative in front of the dispatcher. */
+    RECOMMEND_ALTERNATIVE = "RECOMMEND_ALTERNATIVE"
+}
+/** How an escalation or emergency notification is delivered. */
+export declare enum SlaNotificationChannel {
+    /** The admin's in-app notification (web notification + realtime toast). */
+    WEB = "WEB",
+    SMS = "SMS",
+    EMAIL = "EMAIL",
+    /** Mobile push (the reporter's app). */
+    PUSH = "PUSH"
+}

package/dist/types/modules/incident-sla/enums/sla-exception.enum.d.ts

@@ -0,0 +1,21 @@
+/** Why a breach should be treated as excused for compliance reporting. */
+export declare enum SlaExceptionReason {
+    ROAD_INACCESSIBLE = "ROAD_INACCESSIBLE",
+    SEVERE_WEATHER = "SEVERE_WEATHER",
+    CUSTOMER_UNREACHABLE = "CUSTOMER_UNREACHABLE",
+    INCORRECT_LOCATION = "INCORRECT_LOCATION",
+    EXTERNAL_AGENCY_DELAY = "EXTERNAL_AGENCY_DELAY",
+    SAFETY_HOLD = "SAFETY_HOLD",
+    SYSTEM_OUTAGE = "SYSTEM_OUTAGE",
+    OTHER = "OTHER"
+}
+/**
+ * An exception's state. Approval never changes the instance's timestamps or its
+ * BREACHED status - only how the breach is counted for compliance.
+ */
+export declare enum SlaExceptionStatus {
+    NONE = "NONE",
+    REQUESTED = "REQUESTED",
+    APPROVED = "APPROVED",
+    REJECTED = "REJECTED"
+}

package/dist/types/modules/incident-sla/enums/sla-overall-state.enum.d.ts

@@ -0,0 +1,22 @@
+/**
+ * One word for an incident's SLA right now, for the card's headline. Derived
+ * from its instances: the worst open one, else how the finished ones went.
+ */
+export declare enum SlaOverallState {
+    NOT_TRACKED = "NOT_TRACKED",
+    ON_TRACK = "ON_TRACK",
+    WARNING = "WARNING",
+    AT_RISK = "AT_RISK",
+    BREACHED = "BREACHED",
+    PAUSED = "PAUSED",
+    MET = "MET",
+    /** Every breach on the incident has an approved exception. */
+    EXCEPTION = "EXCEPTION"
+}
+/** The emergency-desk names for incident priorities: P1 Critical ... P4 Low. */
+export declare enum SlaPriorityLevel {
+    P1 = "P1",
+    P2 = "P2",
+    P3 = "P3",
+    P4 = "P4"
+}

package/dist/types/modules/incident-sla/enums/sla-pause.enum.d.ts

@@ -0,0 +1,22 @@
+/** The only reasons an SLA clock may be paused. There is no free-form reason on purpose. */
+export declare enum SlaPauseReason {
+    WAITING_FOR_CUSTOMER = "WAITING_FOR_CUSTOMER",
+    WAITING_FOR_EXTERNAL_AGENCY = "WAITING_FOR_EXTERNAL_AGENCY",
+    LOCATION_INACCESSIBLE = "LOCATION_INACCESSIBLE",
+    ENVIRONMENT_UNSAFE = "ENVIRONMENT_UNSAFE",
+    INCIDENT_DEESCALATED = "INCIDENT_DEESCALATED",
+    OTHER_APPROVED_REASON = "OTHER_APPROVED_REASON"
+}
+/**
+ * A pause request's life. REQUESTED pauses nothing - the clock keeps running
+ * until a supervisor approves, so asking for a pause can never be used to
+ * stop a clock retroactively.
+ */
+export declare enum SlaPauseStatus {
+    REQUESTED = "REQUESTED",
+    ACTIVE = "ACTIVE",
+    ENDED = "ENDED",
+    REJECTED = "REJECTED",
+    /** The instance completed or the incident ended while the request was pending. */
+    WITHDRAWN = "WITHDRAWN"
+}

package/dist/types/modules/incident-sla/enums/sla-policy-scope.enum.d.ts

@@ -0,0 +1,14 @@
+/**
+ * How specific an SLA policy is - the most specific dimension it is scoped to.
+ * Resolution layers policies from PLATFORM (least specific) to ZONE (most), so
+ * an organization can override only the arrival target and inherit the rest.
+ */
+export declare enum SlaPolicyScope {
+    PLATFORM = "PLATFORM",
+    ORGANIZATION = "ORGANIZATION",
+    CONTROL_CENTRE = "CONTROL_CENTRE",
+    INCIDENT_CATEGORY = "INCIDENT_CATEGORY",
+    INCIDENT_TYPE = "INCIDENT_TYPE",
+    PRIORITY = "PRIORITY",
+    ZONE = "ZONE"
+}

package/dist/types/modules/incident-sla/index.d.ts

@@ -0,0 +1,31 @@
+export * from './enums/incident-sla-stage.enum';
+export * from './enums/incident-sla-status.enum';
+export * from './enums/emergency-incident-stage.enum';
+export * from './enums/incident-sla-event-type.enum';
+export * from './enums/incident-sla-actor.enum';
+export * from './enums/sla-escalation.enum';
+export * from './enums/sla-pause.enum';
+export * from './enums/sla-exception.enum';
+export * from './enums/sla-policy-scope.enum';
+export * from './enums/incident-closure.enum';
+export * from './enums/eta-status.enum';
+export * from './enums/sla-overall-state.enum';
+export * from './enums/incident-sla-error-code.enum';
+export * from './enums/emergency-notification.enum';
+export * from './interfaces/incident-sla-policy';
+export * from './interfaces/incident-sla-views';
+export * from './interfaces/incident-sla-events';
+export * from './interfaces/emergency-workflow';
+export * from './interfaces/incident-sla-analytics';
+export * from './constants/incident-sla-defaults.const';
+export * from './constants/incident-sla-kafka.const';
+export * from './constants/emergency-incident-workflow.const';
+export * from './dtos/emergency-operations.dto';
+export * from './dtos/incident-sla-policy.dto';
+export * from './dtos/emergency-workflow.dto';
+export * from './dtos/emergency-notification.dto';
+export * from './dtos/incident-sla-analytics-query.dto';
+export * from './utils/incident-sla-priority.util';
+export * from './utils/incident-sla-time.util';
+export * from './utils/incident-sla-eta.util';
+export * from './utils/incident-sla-event-id.util';

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

@@ -0,0 +1,131 @@
+import { IncidentPriority } from '../../incident/enums/incident-priority.enum';
+import { ResponseUnitDispatchStatus } from '../../dispatch/enums/response-unit-dispatch-status.enum';
+import { EmergencyIncidentStage } from '../enums/emergency-incident-stage.enum';
+import { EtaStatus } from '../enums/eta-status.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 { SlaEscalationAction, SlaEscalationLevel, SlaEscalationTrigger, SlaNotificationChannel } from '../enums/sla-escalation.enum';
+/**
+ * The contract between clarion-workflow-manager's emergency workflow and
+ * clarion-incident's internal emergency routes. The workflow keeps no copy of
+ * the incident: every activity returns a fresh plan read from the database,
+ * and the workflow only decides WHEN to call next.
+ */
+/** An open SLA instance the workflow times. */
+export interface EmergencySlaPlanInstance {
+    instanceId: number;
+    stage: IncidentSlaStage;
+    cycle: number;
+    status: IncidentSlaStatus;
+    responseUnitDispatchId: number | null;
+    startedAt: string | null;
+    warningAt: string | null;
+    atRiskAt: string | null;
+    deadlineAt: string | null;
+    paused: boolean;
+}
+/** An escalation rule as the workflow sees it: no contact details. */
+export interface EmergencyWorkflowEscalationRule {
+    key: string;
+    trigger: SlaEscalationTrigger;
+    stages: IncidentSlaStage[];
+    priorities: IncidentPriority[];
+    level: SlaEscalationLevel;
+    channels: SlaNotificationChannel[];
+    actions: SlaEscalationAction[];
+    delaySeconds: number;
+}
+export interface EmergencyPlanDispatch {
+    dispatchId: number;
+    responseUnitId: number;
+    status: ResponseUnitDispatchStatus;
+    etaStatus: EtaStatus | null;
+}
+/** `POST /incidents/internal/emergency/:id/plan` and every activity's answer. */
+export interface EmergencySlaPlan {
+    incidentId: number;
+    organizationId: number;
+    controlCentreId: number | null;
+    /** False: not an emergency the SLA covers (grievance, never reaches the control room, SLA off). */
+    tracked: boolean;
+    notTrackedReason: string | null;
+    incidentStatus: string;
+    /** Resolved, Closed, Unresolved or Archived. */
+    ended: boolean;
+    /** Closed or Archived - the workflow is done. */
+    closed: boolean;
+    currentStage: EmergencyIncidentStage | null;
+    slaPriority: IncidentPriority | null;
+    serverTime: string;
+    openInstances: EmergencySlaPlanInstance[];
+    autoClose: {
+        enabled: boolean;
+        afterSeconds: number;
+        resolvedAt: string | null;
+        dueAt: string | null;
+    };
+    /** When to ask whether each en-route unit's tracking has gone quiet. */
+    trackingWatch: {
+        dispatchId: number;
+        responseUnitId: number;
+        checkAt: string;
+    }[];
+    activeDispatches: EmergencyPlanDispatch[];
+    escalationRules: EmergencyWorkflowEscalationRule[];
+    allowAutomaticReassignment: boolean;
+    policyId: number | null;
+    policyVersion: number | null;
+}
+export interface RecordSlaThresholdResult {
+    applied: boolean;
+    eventType: IncidentSlaEventType | null;
+    stage: IncidentSlaStage | null;
+    /** Why nothing happened: completed meanwhile, paused, deadline moved... */
+    reason: string | null;
+    plan: EmergencySlaPlan;
+}
+export interface EmergencyAlternativeRecommendation {
+    responseUnitId: number;
+    responseUnitName: string | null;
+    distanceMetres: number | null;
+    etaSeconds: number | null;
+}
+export interface EmergencyEscalationResult {
+    escalated: boolean;
+    skippedReason: string | null;
+    notificationRequested: boolean;
+    alternative: EmergencyAlternativeRecommendation | null;
+    plan: EmergencySlaPlan;
+}
+export interface EmergencyReassignmentResult {
+    reassigned: boolean;
+    reason: string | null;
+    newDispatchId: number | null;
+    cancelledDispatchId: number | null;
+    plan: EmergencySlaPlan;
+}
+export type EmergencyAutoCloseOutcome = 'CLOSED' | 'ALREADY_CLOSED' | 'NOT_RESOLVED' | 'DEFERRED' | 'RESCHEDULED' | 'DISABLED' | 'NOT_TRACKED';
+export interface EmergencyAutoCloseResult {
+    outcome: EmergencyAutoCloseOutcome;
+    /** DEFERRED / RESCHEDULED: try again then. */
+    retryAt: string | null;
+    plan: EmergencySlaPlan;
+}
+export interface EmergencyTrackingFreshnessResult {
+    /** Dispatches whose ETA turned UNCERTAIN on this check. */
+    becameUncertain: number[];
+    plan: EmergencySlaPlan;
+}
+export interface EmergencyMilestoneResult {
+    recorded: boolean;
+    reason: string | null;
+    plan: EmergencySlaPlan;
+}
+/** `GET /incidents/internal/emergency/open` - the reconciler's view. */
+export interface EmergencyOpenIncidentRef {
+    incidentId: number;
+    organizationId: number;
+    createdAt: string;
+    workflowId: string | null;
+}

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

@@ -0,0 +1,35 @@
+import { IncidentSlaStage } from '../enums/incident-sla-stage.enum';
+/**
+ * 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;
+}
+export interface IncidentSlaStageAnalytics {
+    stage: IncidentSlaStage;
+    instances: number;
+    met: number;
+    breached: number;
+    breachedWithApprovedException: number;
+    compliancePercent: number | null;
+    complianceWithExceptionsPercent: number | null;
+    /** Start to milestone, pauses excluded, over the instances that reached it. */
+    duration: IncidentSlaDurationPercentiles;
+}
+/** `GET /incident-sla/analytics`. */
+export interface IncidentSlaAnalyticsResult {
+    from: string;
+    to: string;
+    organizationId: number | null;
+    controlCentreId: number | null;
+    incidents: number;
+    breachedIncidents: number;
+    stages: IncidentSlaStageAnalytics[];
+    generatedAt: string;
+}