grm-shared-library 1.1.236 → 1.1.238

package/dist/types/modules/dispatch/utils/response-capability-match.util.d.ts

@@ -0,0 +1,26 @@
+import { ResponseCapability } from '../../response-unit/enums/response-unit/response-capability.enum';
+import { ResponseUnitCapabilityMatch } from '../enums/response-unit-capability-match.enum';
+import { ResponseCapabilityRequirement } from '../interfaces/response-unit-recommendation';
+/**
+ * What an incident needs: its TYPE's list when the type names one, otherwise
+ * its CATEGORY's, otherwise nothing. A type's list replaces the category's
+ * rather than adding to it - "Road accident with casualties" under a "Traffic"
+ * category that asks for roadside assistance must be able to ask for an
+ * ambulance instead.
+ */
+export declare function resolveResponseCapabilityRequirement(type: {
+    responseCapabilities?: unknown;
+} | null | undefined, category: {
+    responseCapabilities?: unknown;
+} | null | undefined): ResponseCapabilityRequirement;
+export interface ResponseCapabilityMatchResult {
+    match: ResponseUnitCapabilityMatch;
+    /** The required capabilities the unit has. */
+    matched: ResponseCapability[];
+}
+/**
+ * Compare a unit with a requirement. A unit qualifies with ANY required
+ * capability - a requirement is the set of services that would do, not a
+ * checklist one vehicle must tick.
+ */
+export declare function matchResponseCapabilities(required: readonly ResponseCapability[], unitCapabilities: readonly ResponseCapability[]): ResponseCapabilityMatchResult;

package/dist/types/modules/dispatch/utils/response-unit-dispatch-event.util.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Deterministic event id: the same change always produces the same id, so a
+ * consumer that sees one twice (an outbox re-publish, a Kafka redelivery) knows
+ * it already handled it. `discriminator` separates changes of the same kind on
+ * one dispatch (the target status, the notification attempt number).
+ */
+export declare function buildResponseUnitDispatchEventId(kind: 'created' | 'status-changed' | 'notification-requested' | 'notification-result', dispatchId: number, discriminator?: string | number): string;
+/** An incident as a control room quotes it: `#1234`. */
+export declare function formatIncidentReference(incidentId: number): string;

package/dist/types/modules/dispatch/utils/response-unit-dispatch-status.util.d.ts

@@ -0,0 +1,16 @@
+import { ResponseUnitDispatchStatus } from '../enums/response-unit-dispatch-status.enum';
+/**
+ * Where a dispatch may go next. Forward only, and steps may be skipped: a crew
+ * that radios in "on scene" never said "en route", and refusing to record the
+ * truth because a step was missed would leave the record wrong. Nothing leaves
+ * COMPLETED or CANCELLED - a unit sent again is a new dispatch, with its own
+ * audit trail, not a resurrected one.
+ */
+export declare const RESPONSE_UNIT_DISPATCH_TRANSITIONS: Readonly<Record<ResponseUnitDispatchStatus, readonly ResponseUnitDispatchStatus[]>>;
+export declare function isActiveResponseUnitDispatchStatus(status: string | null | undefined): boolean;
+export declare function isTerminalResponseUnitDispatchStatus(status: string | null | undefined): boolean;
+export declare function canTransitionResponseUnitDispatch(from: ResponseUnitDispatchStatus, to: ResponseUnitDispatchStatus): boolean;
+/** The statuses a dispatch in `from` may be moved to. */
+export declare function nextResponseUnitDispatchStatuses(from: ResponseUnitDispatchStatus): ResponseUnitDispatchStatus[];
+/** The milestone column each status stamps, for the statuses that have one. */
+export declare const RESPONSE_UNIT_DISPATCH_MILESTONE_FIELD: Readonly<Partial<Record<ResponseUnitDispatchStatus, 'acknowledgedAt' | 'enRouteAt' | 'onSceneAt' | 'completedAt' | 'cancelledAt' | 'rejectedAt'>>>;

package/dist/types/modules/incident/dtos/category/create-incident-category.dto.d.ts

@@ -1,5 +1,11 @@
+import { ResponseCapability } from "../../../response-unit/enums/response-unit/response-capability.enum";
 export declare class CreateIncidentCategoryDto {
     name: string;
     description?: string;
     organizationId: number;
+    /**
+     * Response capabilities an incident in this category needs, unless its type names its own; a unit with ANY of them is suitable.
+     * Empty or absent = no requirement, so every available unit is suitable.
+     */
+    responseCapabilities?: ResponseCapability[];
 }

package/dist/types/modules/incident/dtos/type/create-incident-type.dto.d.ts

@@ -1,6 +1,12 @@
+import { ResponseCapability } from "../../../response-unit/enums/response-unit/response-capability.enum";
 export declare class CreateIncidentTypeDto {
     name: string;
     description?: string;
     categoryId?: number;
     organizationId: number;
+    /**
+     * Response capabilities an incident of this type needs; a unit with ANY of them is suitable. Overrides the category's requirement.
+     * Empty or absent = no requirement, so every available unit is suitable.
+     */
+    responseCapabilities?: ResponseCapability[];
 }

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

@@ -8,6 +8,14 @@ export declare enum IncidentActions {
     AUTO_STOPPED = "Auto-Stopped",
     ASSIGNED = "Assigned",
     RESPONSE_UNIT_ASSIGNED = "Response Unit Assigned",
+    /** A unit was dispatched through the dispatch command (recommend + dispatch). */
+    RESPONSE_UNIT_DISPATCHED = "Response Unit Dispatched",
+    /** A dispatch moved on (acknowledged, en route, on scene, completed, stood down) or its message was reported on. */
+    RESPONSE_UNIT_DISPATCH_UPDATED = "Response Unit Dispatch Updated",
+    /** The emergency response reached a milestone (acknowledged, triaged, arrival inferred, assessed...). */
+    EMERGENCY_MILESTONE = "Emergency Milestone",
+    /** The emergency SLA changed (a clock warned, breached, paused, was excused...) or escalated. */
+    SLA_UPDATED = "SLA Updated",
     REOPENED = "Reopened",
     REPORT_CREATED = "Report Created",
     COMMENTED = "Commented",

package/dist/types/modules/incident/intefaces/incident-category.d.ts

@@ -1,3 +1,4 @@
+import { ResponseCapability } from "../../response-unit/enums/response-unit/response-capability.enum";
 import { IncidentType } from "./incident-type";
 export interface IncidentCategory {
     id?: number;
@@ -14,5 +15,10 @@ export interface IncidentCategory {
      * sheet and from package configuration, and not editable or deletable.
      */
     isSystem?: boolean;
+    /**
+     * Response capabilities this kind of incident needs (a unit with ANY of them
+     * is suitable). A type's list overrides its category's; empty = no requirement.
+     */
+    responseCapabilities?: ResponseCapability[];
     types?: IncidentType[];
 }

package/dist/types/modules/incident/intefaces/incident-type.d.ts

@@ -1,3 +1,4 @@
+import { ResponseCapability } from "../../response-unit/enums/response-unit/response-capability.enum";
 import { IncidentCategory } from "./incident-category";
 export interface IncidentType {
     id?: number;
@@ -15,5 +16,10 @@ export interface IncidentType {
      * sheet and from package configuration, and not editable or deletable.
      */
     isSystem?: boolean;
+    /**
+     * Response capabilities this kind of incident needs (a unit with ANY of them
+     * is suitable). A type's list overrides its category's; empty = no requirement.
+     */
+    responseCapabilities?: ResponseCapability[];
     category?: IncidentCategory;
 }

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,15 @@
+import { IncidentPriority } from '../../incident/enums/incident-priority.enum';
+import { IncidentSlaStage } from '../enums/incident-sla-stage.enum';
+/** `GET /incident-sla/analytics` - by instance start time, default the last 30 days. */
+export declare class IncidentSlaAnalyticsQueryDto {
+    from?: string;
+    to?: string;
+    /** Honoured for Super-Admin only; everybody else is held to their own scope. */
+    organizationId?: number;
+    controlCentreId?: number;
+    priority?: IncidentPriority;
+    stage?: IncidentSlaStage;
+    typeId?: number;
+    categoryId?: number;
+    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"
+}