grm-shared-library 1.1.237 → 1.1.239

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

@@ -0,0 +1,46 @@
+/**
+ * The emergency incident workflow's names, shared by clarion-workflow-manager
+ * (which runs it) and anything that signals it. Workflow code cannot import this
+ * library (the Temporal sandbox), so workflow-manager keeps a local copy and a
+ * drift test pins it to these values.
+ */
+export declare const EMERGENCY_INCIDENT_WORKFLOW: {
+    readonly type: "emergencyIncidentWorkflow";
+    /** One workflow per incident: `emergency-incident-{incidentId}`. */
+    readonly idPrefix: "emergency-incident-";
+    /** The existing incident queue (IncidentWorkflowTaskQueueName.INCIDENT_QUEUE). */
+    readonly defaultTaskQueue: "incident-task-queue";
+    readonly query: "emergencyIncidentState";
+    readonly reconciliationWorkflowType: "emergencyIncidentReconciliationWorkflow";
+    readonly reconciliationScheduleId: "emergency-incident-reconciliation";
+    readonly signals: {
+        readonly acknowledgeIncident: "acknowledgeIncident";
+        readonly triageIncident: "triageIncident";
+        readonly assignResponseUnit: "assignResponseUnit";
+        readonly acceptDispatch: "acceptDispatch";
+        readonly rejectDispatch: "rejectDispatch";
+        readonly startTravel: "startTravel";
+        readonly reportArrival: "reportArrival";
+        readonly reportAssessment: "reportAssessment";
+        readonly updateIncidentStatus: "updateIncidentStatus";
+        readonly reportResolution: "reportResolution";
+        readonly pauseSla: "pauseSla";
+        readonly resumeSla: "resumeSla";
+        readonly requestSlaException: "requestSlaException";
+        readonly etaChanged: "etaChanged";
+        readonly slaChanged: "slaChanged";
+        readonly dispatchCancelled: "dispatchCancelled";
+    };
+};
+export declare function emergencyIncidentWorkflowId(incidentId: number): string;
+/** Internal routes clarion-incident serves to the workflow (token-protected, never proxied). */
+export declare const EMERGENCY_INCIDENT_INTERNAL_PATHS: {
+    readonly plan: (incidentId: number) => string;
+    readonly threshold: (incidentId: number) => string;
+    readonly milestone: (incidentId: number) => string;
+    readonly escalation: (incidentId: number) => string;
+    readonly reassignment: (incidentId: number) => string;
+    readonly trackingFreshness: (incidentId: number) => string;
+    readonly autoClose: (incidentId: number) => string;
+    readonly open: "/incidents/internal/emergency/open";
+};

package/dist/types/modules/incident-sla/constants/incident-sla-defaults.const.d.ts

@@ -0,0 +1,81 @@
+import { IncidentPriority } from '../../incident/enums/incident-priority.enum';
+import { Roles } from '../../role/enums/role.enum';
+import { EmergencyIncidentStage } from '../enums/emergency-incident-stage.enum';
+import { IncidentSlaStage } from '../enums/incident-sla-stage.enum';
+import { IncidentSlaStatus } from '../enums/incident-sla-status.enum';
+import { SlaEscalationLevel } from '../enums/sla-escalation.enum';
+import { SlaPriorityLevel } from '../enums/sla-overall-state.enum';
+import { IncidentSlaEscalationRule, IncidentSlaPolicySettings, IncidentSlaPriorityFloors } from '../interfaces/incident-sla-policy';
+/** Every stage, in the order an emergency moves through them. */
+export declare const INCIDENT_SLA_STAGE_ORDER: readonly IncidentSlaStage[];
+/** Every milestone, in order. */
+export declare const EMERGENCY_INCIDENT_STAGE_ORDER: readonly EmergencyIncidentStage[];
+/** Stages measured once per dispatch (cycle = the dispatch's ordinal); the rest once per incident. */
+export declare const PER_DISPATCH_INCIDENT_SLA_STAGES: readonly IncidentSlaStage[];
+/** The milestone that completes each stage. */
+export declare const INCIDENT_SLA_STOP_MILESTONE: Readonly<Record<IncidentSlaStage, EmergencyIncidentStage>>;
+/**
+ * The milestone that starts each stage's clock, by default. ACCEPTANCE and
+ * MOBILIZATION are per dispatch and always start at that dispatch's own
+ * dispatch / acceptance; for the rest a policy may choose (e.g. measure ARRIVAL
+ * from the incident's creation instead of from the first dispatch).
+ */
+export declare const DEFAULT_INCIDENT_SLA_START_ANCHORS: Readonly<Record<IncidentSlaStage, EmergencyIncidentStage>>;
+/** The start milestones a policy may choose per stage (the first is the default). */
+export declare const ALLOWED_INCIDENT_SLA_START_ANCHORS: Readonly<Record<IncidentSlaStage, readonly EmergencyIncidentStage[]>>;
+/**
+ * Clarion's DEFAULT policy, in seconds - a starting point every organization
+ * may override, not a regulatory requirement. P1 Critical ... P4 Low.
+ * RESOLUTION and CLOSURE have no default target (null = not measured).
+ */
+export declare const DEFAULT_INCIDENT_SLA_TARGETS: Readonly<Record<IncidentPriority, Readonly<Record<IncidentSlaStage, number | null>>>>;
+/** The default settings. Every one is overridable per policy. */
+export declare const DEFAULT_INCIDENT_SLA_SETTINGS: Readonly<IncidentSlaPolicySettings>;
+/**
+ * SOS and safety alerts arrive with the priority column's default (Medium), so
+ * by default an emergency or panic alert is measured as Critical. A triage
+ * decision replaces the floor for the stages that have not started yet.
+ */
+export declare const DEFAULT_INCIDENT_SLA_PRIORITY_FLOORS: Readonly<IncidentSlaPriorityFloors>;
+/** Who each escalation level reaches when a rule names no roles. */
+export declare const DEFAULT_SLA_ESCALATION_LEVEL_ROLES: Readonly<Record<SlaEscalationLevel, readonly Roles[]>>;
+/**
+ * The default escalation rules. A duty manager is reached only "where
+ * configured" - so there is no default rule for that level; an organization
+ * adds one with its contacts.
+ *
+ * One breach reaches a supervisor once: the general breach rules leave out
+ * acknowledgement, which the two ack rules already cover.
+ */
+export declare const DEFAULT_INCIDENT_SLA_ESCALATION_RULES: readonly IncidentSlaEscalationRule[];
+/** The SLA priority level of each incident priority. */
+export declare const INCIDENT_PRIORITY_SLA_LEVEL: Readonly<Record<IncidentPriority, SlaPriorityLevel>>;
+/** Highest first: the order a floor and a comparison use. */
+export declare const INCIDENT_PRIORITY_RANK: Readonly<Record<IncidentPriority, number>>;
+/** Instance statuses whose clock is running (or paused) - the ones the workflow times. */
+export declare const OPEN_INCIDENT_SLA_STATUSES: readonly IncidentSlaStatus[];
+/** Instance statuses that are final (a BREACHED instance may still record completedAt). */
+export declare const FINAL_INCIDENT_SLA_STATUSES: readonly IncidentSlaStatus[];
+/** Bounds every stored or requested value must respect. */
+export declare const INCIDENT_SLA_LIMITS: {
+    readonly minTargetSeconds: 5;
+    readonly maxTargetSeconds: number;
+    readonly minThresholdPercent: 10;
+    readonly maxThresholdPercent: 99;
+    readonly minRadiusMetres: 10;
+    readonly maxRadiusMetres: 5000;
+    readonly maxDwellSeconds: number;
+    readonly maxObservations: 20;
+    readonly minStaleSeconds: 15;
+    readonly maxStaleSeconds: number;
+    readonly minAutoCloseSeconds: number;
+    readonly maxAutoCloseSeconds: number;
+    readonly maxEscalationDelaySeconds: number;
+    readonly maxEscalationRules: 50;
+    readonly maxEscalationContacts: 10;
+    readonly noteMaxLength: 1000;
+    readonly reasonMaxLength: 500;
+    readonly policyNameMaxLength: 120;
+    readonly policyDescriptionMaxLength: 1000;
+    readonly ruleKeyMaxLength: 60;
+};

package/dist/types/modules/incident-sla/constants/incident-sla-kafka.const.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Grouped view of the emergency-incident / SLA topics. The strings live in
+ * {@link KAFKA_TOPICS}; this only references them.
+ *
+ * Producer clarion-incident, through its transactional outbox, keyed by
+ * incident id so one incident's history stays in order:
+ * MILESTONE_RECORDED, SLA_CHANGED, ETA_CHANGED (domain events - no names,
+ * numbers or addresses) and NOTIFICATION_REQUESTED (a command to
+ * clarion-notification). Producer clarion-notification: NOTIFICATION_RESULT.
+ *
+ * A consumer of a topic that does not exist yet fails its boot in prod
+ * (Strimzi): declare each as a KafkaTopic BEFORE deploying a consumer.
+ */
+export declare const INCIDENT_SLA_KAFKA_TOPICS: {
+    readonly MILESTONE_RECORDED: string;
+    readonly SLA_CHANGED: string;
+    readonly ETA_CHANGED: string;
+    readonly NOTIFICATION_REQUESTED: string;
+    readonly NOTIFICATION_RESULT: string;
+};
+/** Current schema version of every emergency-incident / SLA event. */
+export declare const INCIDENT_SLA_SCHEMA_VERSION: 1;

package/dist/types/modules/incident-sla/dtos/emergency-notification.dto.d.ts

@@ -0,0 +1,99 @@
+import { IncidentPriority } from '../../incident/enums/incident-priority.enum';
+import { EmergencyNotificationAudience, EmergencyNotificationEvent, EmergencyNotificationResultStatus } from '../enums/emergency-notification.enum';
+import { EtaStatus } from '../enums/eta-status.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 { EmergencyNotificationAudienceSpec, EmergencyNotificationDelivery, EmergencyNotificationIncidentFacts, EmergencyNotificationRequestedV1, EmergencyNotificationResultV1 } from '../interfaces/incident-sla-events';
+import { IncidentSlaEscalationContact } from '../interfaces/incident-sla-policy';
+export declare class EmergencyNotificationContactDto implements IncidentSlaEscalationContact {
+    name?: string | null;
+    phoneNumber?: string | null;
+    email?: string | null;
+}
+export declare class EmergencyNotificationAudienceDto implements EmergencyNotificationAudienceSpec {
+    audience: EmergencyNotificationAudience;
+    channels: SlaNotificationChannel[];
+    roles: string[];
+    contacts: EmergencyNotificationContactDto[];
+}
+export declare class EmergencyNotificationIncidentDto implements EmergencyNotificationIncidentFacts {
+    reference: string;
+    typeName: string | null;
+    categoryName: string | null;
+    priority: IncidentPriority | null;
+    priorityLevel: SlaPriorityLevel | null;
+    status: string;
+    summary: string | null;
+    address: string | null;
+    latitude: number | null;
+    longitude: number | null;
+    createdAt: string;
+    reporterUserId: number | null;
+    anonymous: boolean;
+    assigneeIds: number[];
+}
+export declare class EmergencyNotificationSlaDto {
+    stage: IncidentSlaStage;
+    status: IncidentSlaStatus;
+    targetSeconds: number | null;
+    deadlineAt: string | null;
+    overdueSeconds: number | null;
+}
+export declare class EmergencyNotificationEtaDto {
+    status: EtaStatus;
+    etaSeconds: number | null;
+    predictedArrivalAt: string | null;
+    distanceMetres: number | null;
+}
+export declare class EmergencyNotificationUnitDto {
+    responseUnitId: number;
+    name: string | null;
+}
+export declare class EmergencyNotificationAlternativeDto extends EmergencyNotificationUnitDto {
+    distanceMetres: number | null;
+    etaSeconds: number | null;
+}
+export declare class EmergencyNotificationEscalationDto {
+    ruleKey: string;
+    trigger: SlaEscalationTrigger;
+    level: SlaEscalationLevel;
+}
+export declare class EmergencyNotificationRequestedDto implements EmergencyNotificationRequestedV1 {
+    schemaVersion: 1;
+    eventId: string;
+    occurredAt: string;
+    incidentId: number;
+    organizationId: number;
+    controlCentreId: number | null;
+    event: EmergencyNotificationEvent;
+    audiences: EmergencyNotificationAudienceDto[];
+    incident: EmergencyNotificationIncidentDto;
+    sla: EmergencyNotificationSlaDto | null;
+    eta: EmergencyNotificationEtaDto | null;
+    unit: EmergencyNotificationUnitDto | null;
+    alternative: EmergencyNotificationAlternativeDto | null;
+    escalation: EmergencyNotificationEscalationDto | null;
+    workflowId: string | null;
+    correlationId: string | null;
+}
+export declare class EmergencyNotificationDeliveryDto implements EmergencyNotificationDelivery {
+    audience: EmergencyNotificationAudience;
+    channel: SlaNotificationChannel;
+    recipients: number;
+    sent: number;
+    failed: number;
+}
+export declare class EmergencyNotificationResultDto implements EmergencyNotificationResultV1 {
+    schemaVersion: 1;
+    eventId: string;
+    requestEventId: string;
+    incidentId: number;
+    organizationId: number;
+    event: EmergencyNotificationEvent;
+    status: EmergencyNotificationResultStatus;
+    deliveries: EmergencyNotificationDeliveryDto[];
+    failureReason: string | null;
+    occurredAt: string;
+}

package/dist/types/modules/incident-sla/dtos/emergency-operations.dto.d.ts

@@ -0,0 +1,52 @@
+import { IncidentPriority } from '../../incident/enums/incident-priority.enum';
+import { SlaExceptionReason } from '../enums/sla-exception.enum';
+import { SlaPauseReason } from '../enums/sla-pause.enum';
+/** `POST /incidents/:id/sla/acknowledge` - the control room has seen the emergency. */
+export declare class AcknowledgeEmergencyIncidentDto {
+    note?: string;
+}
+/**
+ * `POST /incidents/:id/sla/triage` - the emergency has been assessed and its
+ * priority confirmed (or changed). A changed priority applies to the stages
+ * that have not started yet; running clocks keep their deadlines.
+ */
+export declare class TriageEmergencyIncidentDto {
+    priority?: IncidentPriority;
+    note?: string;
+}
+/** `POST /incidents/:id/sla/assessment` - the first unit on scene reported its initial assessment. */
+export declare class RecordEmergencyAssessmentDto {
+    note?: string;
+}
+/**
+ * `POST /incidents/:id/sla/pauses` - ask to pause running clocks. Pauses
+ * nothing until a supervisor approves, unless the caller is one (or the policy
+ * needs no approval). A breached clock cannot be paused.
+ */
+export declare class RequestSlaPauseDto {
+    reason: SlaPauseReason;
+    note?: string;
+    /** The instances to pause; every running, unbreached one when omitted. */
+    instanceIds?: number[];
+}
+/** Approving or rejecting a pause or an exception, and ending a pause. */
+export declare class DecideSlaRequestDto {
+    note?: string;
+}
+/**
+ * `POST /incidents/:id/sla/instances/:instanceId/exception` - ask for a breach
+ * to be excused in compliance reporting. The breach itself stays on record.
+ */
+export declare class RequestSlaExceptionDto {
+    reason: SlaExceptionReason;
+    note: string;
+}
+/** `POST /incidents/:id/sla/instances/:instanceId/waive` - a supervisor declares an unfinished stage not applicable. */
+export declare class WaiveSlaInstanceDto {
+    reason: string;
+}
+/** `GET /incidents/:id/sla/events`. */
+export declare class IncidentSlaEventsQueryDto {
+    page?: number;
+    limit?: number;
+}

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

@@ -0,0 +1,55 @@
+import { EmergencyIncidentStage } from '../enums/emergency-incident-stage.enum';
+import { IncidentArrivalSource } from '../enums/incident-closure.enum';
+import { IncidentActorType, IncidentSlaEventSource } from '../enums/incident-sla-actor.enum';
+import { IncidentSlaStatus } from '../enums/incident-sla-status.enum';
+import { SlaEscalationTrigger } from '../enums/sla-escalation.enum';
+/** The thresholds a timer can report. */
+export declare const SLA_THRESHOLD_STATUSES: readonly [IncidentSlaStatus.WARNING, IncidentSlaStatus.AT_RISK, IncidentSlaStatus.BREACHED];
+export type SlaThresholdStatus = (typeof SLA_THRESHOLD_STATUSES)[number];
+/** The milestones a workflow (or a future responder integration through it) may record directly. */
+export declare const DIRECTLY_RECORDABLE_MILESTONES: readonly EmergencyIncidentStage[];
+export declare class EmergencyPlanRequestDto {
+    workflowId?: string;
+}
+export declare class RecordSlaThresholdDto {
+    instanceId: number;
+    threshold: SlaThresholdStatus;
+    workflowId?: string;
+}
+export declare class RecordEmergencyMilestoneDto {
+    milestone: EmergencyIncidentStage;
+    /** When it happened; defaults to now. Never in the future. */
+    at?: string;
+    actorType: IncidentActorType;
+    source: IncidentSlaEventSource;
+    actorUserId?: number;
+    /** Required for the dispatch milestones (accepted, en route, on scene). */
+    dispatchId?: number;
+    arrivalSource?: IncidentArrivalSource;
+    note?: string;
+    eventKey: string;
+    workflowId?: string;
+}
+export declare class EmergencyEscalationRequestDto {
+    ruleKey: string;
+    trigger: SlaEscalationTrigger;
+    instanceId?: number;
+    dispatchId?: number;
+    eventKey: string;
+    workflowId?: string;
+}
+export declare class EmergencyReassignmentRequestDto {
+    fromDispatchId: number;
+    toResponseUnitId: number;
+    trigger: SlaEscalationTrigger;
+    eventKey: string;
+    workflowId?: string;
+}
+export declare class EmergencyTrackingFreshnessRequestDto {
+    workflowId?: string;
+}
+export declare class EmergencyAutoCloseRequestDto {
+    workflowId: string;
+    /** The resolution the timer was armed for; a later re-resolution reschedules instead of closing early. */
+    expectedResolvedAt?: string;
+}

package/dist/types/modules/incident-sla/dtos/incident-sla-analytics-query.dto.d.ts

@@ -0,0 +1,23 @@
+import { IncidentPriority } from '../../incident/enums/incident-priority.enum';
+import { IncidentSlaStage } from '../enums/incident-sla-stage.enum';
+/**
+ * `GET /incident-sla/analytics` - the emergencies raised in a period. Both ends
+ * optional: no `from` is "forever", no `to` is now.
+ */
+export declare class IncidentSlaAnalyticsQueryDto {
+    from?: string;
+    to?: string;
+    timeZone?: string;
+    /** Honoured for Super-Admin only; everybody else is held to their own scope. */
+    organizationId?: number;
+    /** Narrows an organization's figures to one control centre; a control centre's staff are held to their own. */
+    controlCentreId?: number;
+    /** The priority each emergency was measured at. */
+    priority?: IncidentPriority;
+    /** Narrows the stage figures (compliance, durations) to one stage. */
+    stage?: IncidentSlaStage;
+    typeId?: number;
+    categoryId?: number;
+    /** The emergencies a unit was dispatched to. */
+    responseUnitId?: number;
+}

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

@@ -0,0 +1,104 @@
+import { IncidentEmergencyType } from '../../incident/enums/incident-emergency-type.enum';
+import { IncidentPriority } from '../../incident/enums/incident-priority.enum';
+import { Roles } from '../../role/enums/role.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';
+/** Policy settings - every field optional: an absent field inherits from the less specific policy. */
+export declare class IncidentSlaPolicySettingsDto {
+    warningThresholdPercent?: number;
+    atRiskThresholdPercent?: number;
+    arrivalRadiusMetres?: number;
+    arrivalExitRadiusMetres?: number;
+    arrivalDwellSeconds?: number;
+    arrivalMinObservations?: number;
+    maxLocationAccuracyMetres?: number;
+    trackingStaleSeconds?: number;
+    etaAtRiskMarginPercent?: number;
+    etaAssumedSpeedKph?: number;
+    etaRoadFactor?: number;
+    autoCloseEnabled?: boolean;
+    autoCloseAfterSeconds?: number;
+    allowAutomaticReassignment?: boolean;
+    pauseRequiresApproval?: boolean;
+    notifyReporter?: boolean;
+}
+/** One stage's target for one priority. `targetSeconds: null` switches the stage off for that priority. */
+export declare class IncidentSlaTargetDto {
+    stage: IncidentSlaStage;
+    priority: IncidentPriority;
+    targetSeconds: number | null;
+}
+export declare class IncidentSlaStartAnchorDto {
+    stage: IncidentSlaStage;
+    milestone: EmergencyIncidentStage;
+}
+export declare class IncidentSlaPriorityFloorDto {
+    emergencyType: IncidentEmergencyType;
+    priority: IncidentPriority;
+}
+export declare class IncidentSlaEscalationContactDto {
+    name?: string;
+    phoneNumber?: string;
+    email?: string;
+}
+export declare class IncidentSlaEscalationRuleDto {
+    key: string;
+    trigger: SlaEscalationTrigger;
+    stages?: IncidentSlaStage[];
+    priorities?: IncidentPriority[];
+    level: SlaEscalationLevel;
+    channels: SlaNotificationChannel[];
+    actions?: SlaEscalationAction[];
+    delaySeconds?: number;
+    recipientRoles?: Roles[];
+    contacts?: IncidentSlaEscalationContactDto[];
+}
+/** What a policy version carries apart from its scope. */
+export declare class IncidentSlaPolicyContentDto {
+    name: string;
+    description?: string;
+    /** Defaults to now. A version only governs incidents created at or after it. */
+    effectiveFrom?: string;
+    effectiveTo?: string;
+    settings?: IncidentSlaPolicySettingsDto;
+    targets?: IncidentSlaTargetDto[];
+    startAnchors?: IncidentSlaStartAnchorDto[];
+    priorityFloors?: IncidentSlaPriorityFloorDto[];
+    /** Absent = inherit the less specific policy's rules; [] = no escalation at all. */
+    escalationRules?: IncidentSlaEscalationRuleDto[];
+}
+/**
+ * `POST /incident-sla/policies` - a new policy (version 1). The scope fields
+ * pick what it governs; none set = a platform policy (Super-Admin only).
+ */
+export declare class CreateIncidentSlaPolicyDto extends IncidentSlaPolicyContentDto {
+    organizationId?: number;
+    controlCentreId?: number;
+    categoryId?: number;
+    typeId?: number;
+    priority?: IncidentPriority;
+    zoneId?: number;
+}
+/** `POST /incident-sla/policies/:id/versions` - the next version of a policy (same scope). */
+export declare class CreateIncidentSlaPolicyVersionDto extends IncidentSlaPolicyContentDto {
+}
+/** `GET /incident-sla/policies`. */
+export declare class IncidentSlaPolicyQueryDto {
+    organizationId?: number;
+    activeOnly?: boolean;
+    /** Include the platform policies alongside the organization's (default true). */
+    includePlatform?: boolean;
+}
+/** `GET /incident-sla/policies/effective` - which policy an incident like this would run under. */
+export declare class EffectiveIncidentSlaPolicyQueryDto {
+    organizationId: number;
+    controlCentreId?: number;
+    categoryId?: number;
+    typeId?: number;
+    priority?: IncidentPriority;
+    emergencyType?: IncidentEmergencyType;
+    zoneId?: number;
+    /** Resolve as at this instant (default now). */
+    at?: string;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * The operational lifecycle of an emergency (INCIDENT-class) incident, as
+ * milestones. Each is recorded once, with when it happened, who or what
+ * recorded it and from where; the incident's current stage is the latest one
+ * reached.
+ *
+ * This is deliberately NOT a second status machine. The incident's status
+ * (Received, In-Progress, Resolved, Closed...) is unchanged and still owned by
+ * the incident's own transitions; these milestones say how far the RESPONSE
+ * has got, which is what an emergency SLA measures.
+ *
+ * STABILIZING is the stage after the first unit's initial assessment is
+ * reported (the "stabilizing / responding" phase).
+ */
+export declare enum EmergencyIncidentStage {
+    INCIDENT_CREATED = "INCIDENT_CREATED",
+    ACKNOWLEDGED = "ACKNOWLEDGED",
+    TRIAGED = "TRIAGED",
+    DISPATCH_INITIATED = "DISPATCH_INITIATED",
+    RESPONSE_UNIT_ASSIGNED = "RESPONSE_UNIT_ASSIGNED",
+    RESPONSE_UNIT_ACCEPTED = "RESPONSE_UNIT_ACCEPTED",
+    EN_ROUTE = "EN_ROUTE",
+    ON_SCENE = "ON_SCENE",
+    STABILIZING = "STABILIZING",
+    RESOLVED = "RESOLVED",
+    CLOSED = "CLOSED"
+}

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"
+}