clarion-shared-types 1.0.116 → 1.0.118

package/dist/esm/modules/incident-sla/enums/incident-sla-enums.js

@@ -0,0 +1,238 @@
+/*
+ * Emergency incident SLA - the admin's copy of grm-shared-library's
+ * incident-sla enums. Same names, same values; the `__tests__` spec pins the
+ * values so a drift fails a build rather than a screen.
+ */
+/** The milestones an emergency is measured against, each with its own clock. */
+export var IncidentSlaStage;
+(function (IncidentSlaStage) {
+    IncidentSlaStage["ACKNOWLEDGEMENT"] = "ACKNOWLEDGEMENT";
+    IncidentSlaStage["TRIAGE"] = "TRIAGE";
+    IncidentSlaStage["DISPATCH"] = "DISPATCH";
+    IncidentSlaStage["RESPONSE_UNIT_ACCEPTANCE"] = "RESPONSE_UNIT_ACCEPTANCE";
+    IncidentSlaStage["MOBILIZATION"] = "MOBILIZATION";
+    IncidentSlaStage["ARRIVAL"] = "ARRIVAL";
+    IncidentSlaStage["INITIAL_ASSESSMENT"] = "INITIAL_ASSESSMENT";
+    IncidentSlaStage["RESOLUTION"] = "RESOLUTION";
+    IncidentSlaStage["CLOSURE"] = "CLOSURE";
+})(IncidentSlaStage || (IncidentSlaStage = {}));
+/** Where one SLA instance stands. BREACHED is permanent; an exception only changes how it counts. */
+export var IncidentSlaStatus;
+(function (IncidentSlaStatus) {
+    IncidentSlaStatus["NOT_STARTED"] = "NOT_STARTED";
+    IncidentSlaStatus["RUNNING"] = "RUNNING";
+    IncidentSlaStatus["WARNING"] = "WARNING";
+    IncidentSlaStatus["AT_RISK"] = "AT_RISK";
+    IncidentSlaStatus["PAUSED"] = "PAUSED";
+    IncidentSlaStatus["BREACHED"] = "BREACHED";
+    IncidentSlaStatus["MET"] = "MET";
+    IncidentSlaStatus["WAIVED"] = "WAIVED";
+    IncidentSlaStatus["CANCELLED"] = "CANCELLED";
+    IncidentSlaStatus["EXPIRED"] = "EXPIRED";
+})(IncidentSlaStatus || (IncidentSlaStatus = {}));
+/** The response's milestones (not the incident's status, which is unchanged). */
+export var EmergencyIncidentStage;
+(function (EmergencyIncidentStage) {
+    EmergencyIncidentStage["INCIDENT_CREATED"] = "INCIDENT_CREATED";
+    EmergencyIncidentStage["ACKNOWLEDGED"] = "ACKNOWLEDGED";
+    EmergencyIncidentStage["TRIAGED"] = "TRIAGED";
+    EmergencyIncidentStage["DISPATCH_INITIATED"] = "DISPATCH_INITIATED";
+    EmergencyIncidentStage["RESPONSE_UNIT_ASSIGNED"] = "RESPONSE_UNIT_ASSIGNED";
+    EmergencyIncidentStage["RESPONSE_UNIT_ACCEPTED"] = "RESPONSE_UNIT_ACCEPTED";
+    EmergencyIncidentStage["EN_ROUTE"] = "EN_ROUTE";
+    EmergencyIncidentStage["ON_SCENE"] = "ON_SCENE";
+    EmergencyIncidentStage["STABILIZING"] = "STABILIZING";
+    EmergencyIncidentStage["RESOLVED"] = "RESOLVED";
+    EmergencyIncidentStage["CLOSED"] = "CLOSED";
+})(EmergencyIncidentStage || (EmergencyIncidentStage = {}));
+export var IncidentSlaEventType;
+(function (IncidentSlaEventType) {
+    IncidentSlaEventType["SLA_STARTED"] = "SLA_STARTED";
+    IncidentSlaEventType["SLA_WARNING"] = "SLA_WARNING";
+    IncidentSlaEventType["SLA_AT_RISK"] = "SLA_AT_RISK";
+    IncidentSlaEventType["SLA_BREACHED"] = "SLA_BREACHED";
+    IncidentSlaEventType["SLA_MET"] = "SLA_MET";
+    IncidentSlaEventType["SLA_COMPLETED_LATE"] = "SLA_COMPLETED_LATE";
+    IncidentSlaEventType["SLA_CANCELLED"] = "SLA_CANCELLED";
+    IncidentSlaEventType["SLA_EXPIRED"] = "SLA_EXPIRED";
+    IncidentSlaEventType["SLA_WAIVED"] = "SLA_WAIVED";
+    IncidentSlaEventType["SLA_PAUSE_REQUESTED"] = "SLA_PAUSE_REQUESTED";
+    IncidentSlaEventType["SLA_PAUSE_REJECTED"] = "SLA_PAUSE_REJECTED";
+    IncidentSlaEventType["SLA_PAUSED"] = "SLA_PAUSED";
+    IncidentSlaEventType["SLA_RESUMED"] = "SLA_RESUMED";
+    IncidentSlaEventType["SLA_EXCEPTION_REQUESTED"] = "SLA_EXCEPTION_REQUESTED";
+    IncidentSlaEventType["SLA_EXCEPTION_APPROVED"] = "SLA_EXCEPTION_APPROVED";
+    IncidentSlaEventType["SLA_EXCEPTION_REJECTED"] = "SLA_EXCEPTION_REJECTED";
+    IncidentSlaEventType["MILESTONE_RECORDED"] = "MILESTONE_RECORDED";
+    IncidentSlaEventType["PRIORITY_TRIAGED"] = "PRIORITY_TRIAGED";
+    IncidentSlaEventType["ETA_CHANGED"] = "ETA_CHANGED";
+    IncidentSlaEventType["ARRIVAL_INFERRED"] = "ARRIVAL_INFERRED";
+    IncidentSlaEventType["ARRIVAL_CONFIRMED"] = "ARRIVAL_CONFIRMED";
+    IncidentSlaEventType["UNIT_RECOMMENDED"] = "UNIT_RECOMMENDED";
+    IncidentSlaEventType["UNIT_REASSIGNED"] = "UNIT_REASSIGNED";
+    IncidentSlaEventType["ESCALATED"] = "ESCALATED";
+    IncidentSlaEventType["NOTIFICATION_SENT"] = "NOTIFICATION_SENT";
+    IncidentSlaEventType["NOTIFICATION_FAILED"] = "NOTIFICATION_FAILED";
+    IncidentSlaEventType["AUTO_CLOSE_DEFERRED"] = "AUTO_CLOSE_DEFERRED";
+    IncidentSlaEventType["INCIDENT_AUTO_CLOSED"] = "INCIDENT_AUTO_CLOSED";
+    IncidentSlaEventType["INCIDENT_CLOSED"] = "INCIDENT_CLOSED";
+})(IncidentSlaEventType || (IncidentSlaEventType = {}));
+export var IncidentActorType;
+(function (IncidentActorType) {
+    IncidentActorType["CONTROL_CENTRE"] = "CONTROL_CENTRE";
+    IncidentActorType["RESPONDER"] = "RESPONDER";
+    IncidentActorType["SYSTEM"] = "SYSTEM";
+    IncidentActorType["TRACKING"] = "TRACKING";
+    IncidentActorType["REPORTER"] = "REPORTER";
+    IncidentActorType["PARTNER"] = "PARTNER";
+})(IncidentActorType || (IncidentActorType = {}));
+export var IncidentSlaEventSource;
+(function (IncidentSlaEventSource) {
+    IncidentSlaEventSource["CONTROL_ROOM"] = "CONTROL_ROOM";
+    IncidentSlaEventSource["RESPONDER_APP"] = "RESPONDER_APP";
+    IncidentSlaEventSource["WORKFLOW"] = "WORKFLOW";
+    IncidentSlaEventSource["TRACKING"] = "TRACKING";
+    IncidentSlaEventSource["INCIDENT_LIFECYCLE"] = "INCIDENT_LIFECYCLE";
+    IncidentSlaEventSource["DISPATCH"] = "DISPATCH";
+    IncidentSlaEventSource["PARTNER"] = "PARTNER";
+    IncidentSlaEventSource["NOTIFICATION"] = "NOTIFICATION";
+    IncidentSlaEventSource["SYSTEM"] = "SYSTEM";
+})(IncidentSlaEventSource || (IncidentSlaEventSource = {}));
+export var SlaEscalationLevel;
+(function (SlaEscalationLevel) {
+    SlaEscalationLevel["DISPATCHER"] = "DISPATCHER";
+    SlaEscalationLevel["SUPERVISOR"] = "SUPERVISOR";
+    SlaEscalationLevel["DUTY_MANAGER"] = "DUTY_MANAGER";
+    SlaEscalationLevel["ORGANIZATION_ADMIN"] = "ORGANIZATION_ADMIN";
+})(SlaEscalationLevel || (SlaEscalationLevel = {}));
+export var SlaEscalationTrigger;
+(function (SlaEscalationTrigger) {
+    SlaEscalationTrigger["SLA_WARNING"] = "SLA_WARNING";
+    SlaEscalationTrigger["SLA_AT_RISK"] = "SLA_AT_RISK";
+    SlaEscalationTrigger["SLA_BREACHED"] = "SLA_BREACHED";
+    SlaEscalationTrigger["ETA_AT_RISK"] = "ETA_AT_RISK";
+    SlaEscalationTrigger["ETA_LIKELY_BREACH"] = "ETA_LIKELY_BREACH";
+    SlaEscalationTrigger["ETA_UNCERTAIN"] = "ETA_UNCERTAIN";
+    SlaEscalationTrigger["DISPATCH_REJECTED"] = "DISPATCH_REJECTED";
+    SlaEscalationTrigger["DISPATCH_CANCELLED"] = "DISPATCH_CANCELLED";
+})(SlaEscalationTrigger || (SlaEscalationTrigger = {}));
+export var SlaPauseReason;
+(function (SlaPauseReason) {
+    SlaPauseReason["WAITING_FOR_CUSTOMER"] = "WAITING_FOR_CUSTOMER";
+    SlaPauseReason["WAITING_FOR_EXTERNAL_AGENCY"] = "WAITING_FOR_EXTERNAL_AGENCY";
+    SlaPauseReason["LOCATION_INACCESSIBLE"] = "LOCATION_INACCESSIBLE";
+    SlaPauseReason["ENVIRONMENT_UNSAFE"] = "ENVIRONMENT_UNSAFE";
+    SlaPauseReason["INCIDENT_DEESCALATED"] = "INCIDENT_DEESCALATED";
+    SlaPauseReason["OTHER_APPROVED_REASON"] = "OTHER_APPROVED_REASON";
+})(SlaPauseReason || (SlaPauseReason = {}));
+export var SlaPauseStatus;
+(function (SlaPauseStatus) {
+    SlaPauseStatus["REQUESTED"] = "REQUESTED";
+    SlaPauseStatus["ACTIVE"] = "ACTIVE";
+    SlaPauseStatus["ENDED"] = "ENDED";
+    SlaPauseStatus["REJECTED"] = "REJECTED";
+    SlaPauseStatus["WITHDRAWN"] = "WITHDRAWN";
+})(SlaPauseStatus || (SlaPauseStatus = {}));
+export var SlaExceptionReason;
+(function (SlaExceptionReason) {
+    SlaExceptionReason["ROAD_INACCESSIBLE"] = "ROAD_INACCESSIBLE";
+    SlaExceptionReason["SEVERE_WEATHER"] = "SEVERE_WEATHER";
+    SlaExceptionReason["CUSTOMER_UNREACHABLE"] = "CUSTOMER_UNREACHABLE";
+    SlaExceptionReason["INCORRECT_LOCATION"] = "INCORRECT_LOCATION";
+    SlaExceptionReason["EXTERNAL_AGENCY_DELAY"] = "EXTERNAL_AGENCY_DELAY";
+    SlaExceptionReason["SAFETY_HOLD"] = "SAFETY_HOLD";
+    SlaExceptionReason["SYSTEM_OUTAGE"] = "SYSTEM_OUTAGE";
+    SlaExceptionReason["OTHER"] = "OTHER";
+})(SlaExceptionReason || (SlaExceptionReason = {}));
+export var SlaExceptionStatus;
+(function (SlaExceptionStatus) {
+    SlaExceptionStatus["NONE"] = "NONE";
+    SlaExceptionStatus["REQUESTED"] = "REQUESTED";
+    SlaExceptionStatus["APPROVED"] = "APPROVED";
+    SlaExceptionStatus["REJECTED"] = "REJECTED";
+})(SlaExceptionStatus || (SlaExceptionStatus = {}));
+export var SlaPolicyScope;
+(function (SlaPolicyScope) {
+    SlaPolicyScope["PLATFORM"] = "PLATFORM";
+    SlaPolicyScope["ORGANIZATION"] = "ORGANIZATION";
+    SlaPolicyScope["CONTROL_CENTRE"] = "CONTROL_CENTRE";
+    SlaPolicyScope["INCIDENT_CATEGORY"] = "INCIDENT_CATEGORY";
+    SlaPolicyScope["INCIDENT_TYPE"] = "INCIDENT_TYPE";
+    SlaPolicyScope["PRIORITY"] = "PRIORITY";
+    SlaPolicyScope["ZONE"] = "ZONE";
+})(SlaPolicyScope || (SlaPolicyScope = {}));
+export var IncidentClosureReason;
+(function (IncidentClosureReason) {
+    IncidentClosureReason["MANUAL"] = "MANUAL";
+    IncidentClosureReason["AUTO_CLOSED_AFTER_RESOLUTION_TIMEOUT"] = "AUTO_CLOSED_AFTER_RESOLUTION_TIMEOUT";
+})(IncidentClosureReason || (IncidentClosureReason = {}));
+export var IncidentArrivalSource;
+(function (IncidentArrivalSource) {
+    IncidentArrivalSource["ARRIVAL_CONFIRMED_BY_RESPONDER"] = "ARRIVAL_CONFIRMED_BY_RESPONDER";
+    IncidentArrivalSource["ARRIVAL_CONFIRMED_BY_CONTROL_CENTRE"] = "ARRIVAL_CONFIRMED_BY_CONTROL_CENTRE";
+    IncidentArrivalSource["ARRIVAL_INFERRED_FROM_TRACKING"] = "ARRIVAL_INFERRED_FROM_TRACKING";
+})(IncidentArrivalSource || (IncidentArrivalSource = {}));
+export var EtaStatus;
+(function (EtaStatus) {
+    EtaStatus["ON_TRACK"] = "ON_TRACK";
+    EtaStatus["AT_RISK"] = "AT_RISK";
+    EtaStatus["LIKELY_BREACH"] = "LIKELY_BREACH";
+    EtaStatus["UNCERTAIN"] = "UNCERTAIN";
+    EtaStatus["NO_TARGET"] = "NO_TARGET";
+    EtaStatus["ARRIVED"] = "ARRIVED";
+})(EtaStatus || (EtaStatus = {}));
+export var EtaBasis;
+(function (EtaBasis) {
+    EtaBasis["ESTIMATE"] = "ESTIMATE";
+    EtaBasis["ROAD_ROUTE"] = "ROAD_ROUTE";
+})(EtaBasis || (EtaBasis = {}));
+export var SlaOverallState;
+(function (SlaOverallState) {
+    SlaOverallState["NOT_TRACKED"] = "NOT_TRACKED";
+    SlaOverallState["ON_TRACK"] = "ON_TRACK";
+    SlaOverallState["WARNING"] = "WARNING";
+    SlaOverallState["AT_RISK"] = "AT_RISK";
+    SlaOverallState["BREACHED"] = "BREACHED";
+    SlaOverallState["PAUSED"] = "PAUSED";
+    SlaOverallState["MET"] = "MET";
+    SlaOverallState["EXCEPTION"] = "EXCEPTION";
+})(SlaOverallState || (SlaOverallState = {}));
+export var SlaPriorityLevel;
+(function (SlaPriorityLevel) {
+    SlaPriorityLevel["P1"] = "P1";
+    SlaPriorityLevel["P2"] = "P2";
+    SlaPriorityLevel["P3"] = "P3";
+    SlaPriorityLevel["P4"] = "P4";
+})(SlaPriorityLevel || (SlaPriorityLevel = {}));
+export var IncidentSlaErrorCode;
+(function (IncidentSlaErrorCode) {
+    IncidentSlaErrorCode["SLA_NOT_TRACKED"] = "SLA_NOT_TRACKED";
+    IncidentSlaErrorCode["SLA_INSTANCE_NOT_FOUND"] = "SLA_INSTANCE_NOT_FOUND";
+    IncidentSlaErrorCode["SLA_PAUSE_NOT_FOUND"] = "SLA_PAUSE_NOT_FOUND";
+    IncidentSlaErrorCode["SLA_POLICY_NOT_FOUND"] = "SLA_POLICY_NOT_FOUND";
+    IncidentSlaErrorCode["SLA_INVALID_STATE"] = "SLA_INVALID_STATE";
+    IncidentSlaErrorCode["SLA_APPROVER_REQUIRED"] = "SLA_APPROVER_REQUIRED";
+    IncidentSlaErrorCode["SLA_SELF_APPROVAL"] = "SLA_SELF_APPROVAL";
+    IncidentSlaErrorCode["SLA_POLICY_INVALID"] = "SLA_POLICY_INVALID";
+    IncidentSlaErrorCode["SLA_POLICY_FORBIDDEN"] = "SLA_POLICY_FORBIDDEN";
+    IncidentSlaErrorCode["INCIDENT_NOT_EMERGENCY"] = "INCIDENT_NOT_EMERGENCY";
+    IncidentSlaErrorCode["INCIDENT_ENDED"] = "INCIDENT_ENDED";
+    IncidentSlaErrorCode["SLA_ESCALATION_RULE_NOT_FOUND"] = "SLA_ESCALATION_RULE_NOT_FOUND";
+})(IncidentSlaErrorCode || (IncidentSlaErrorCode = {}));
+/** The channels an escalation rule reaches people through. */
+export var SlaNotificationChannel;
+(function (SlaNotificationChannel) {
+    /** The admin's in-app notification. */
+    SlaNotificationChannel["WEB"] = "WEB";
+    SlaNotificationChannel["SMS"] = "SMS";
+    SlaNotificationChannel["EMAIL"] = "EMAIL";
+    /** Mobile push. */
+    SlaNotificationChannel["PUSH"] = "PUSH";
+})(SlaNotificationChannel || (SlaNotificationChannel = {}));
+/** What an escalation rule does beside telling people. */
+export var SlaEscalationAction;
+(function (SlaEscalationAction) {
+    SlaEscalationAction["NOTIFY"] = "NOTIFY";
+    SlaEscalationAction["RECOMMEND_ALTERNATIVE"] = "RECOMMEND_ALTERNATIVE";
+})(SlaEscalationAction || (SlaEscalationAction = {}));
+//# sourceMappingURL=incident-sla-enums.js.map

package/dist/esm/modules/incident-sla/enums/incident-sla-enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"incident-sla-enums.js","sourceRoot":"","sources":["../../../../../src/modules/incident-sla/enums/incident-sla-enums.ts"],"names":[],"mappings":"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"}

package/dist/esm/modules/incident-sla/index.js

@@ -0,0 +1,7 @@
+// Enums
+export * from './enums/incident-sla-enums';
+// Interfaces
+export * from './interfaces/incident-sla.dto';
+// Utilities
+export * from './utils/incident-sla-display.util';
+//# sourceMappingURL=index.js.map

package/dist/esm/modules/incident-sla/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/modules/incident-sla/index.ts"],"names":[],"mappings":"AAAA,QAAQ;AACR,cAAc,4BAA4B,CAAC;AAE3C,aAAa;AACb,cAAc,+BAA+B,CAAC;AAE9C,YAAY;AACZ,cAAc,mCAAmC,CAAC"}

package/dist/esm/modules/incident-sla/interfaces/incident-sla.dto.js

@@ -0,0 +1,29 @@
+/** The bounds the API enforces on a policy (grm-shared-library INCIDENT_SLA_LIMITS), for the admin's form. */
+export const INCIDENT_SLA_POLICY_LIMITS = {
+    minTargetSeconds: 5,
+    maxTargetSeconds: 30 * 24 * 3600,
+    minThresholdPercent: 10,
+    maxThresholdPercent: 99,
+    minRadiusMetres: 10,
+    maxRadiusMetres: 5000,
+    maxDwellSeconds: 30 * 60,
+    maxObservations: 20,
+    minAccuracyMetres: 5,
+    maxAccuracyMetres: 5000,
+    minStaleSeconds: 15,
+    maxStaleSeconds: 2 * 3600,
+    maxEtaMarginPercent: 90,
+    minSpeedKph: 5,
+    maxSpeedKph: 150,
+    minRoadFactor: 1,
+    maxRoadFactor: 3,
+    minAutoCloseSeconds: 5 * 60,
+    maxAutoCloseSeconds: 30 * 24 * 3600,
+    maxEscalationDelaySeconds: 24 * 3600,
+    maxEscalationRules: 50,
+    maxEscalationContacts: 10,
+    policyNameMaxLength: 120,
+    policyDescriptionMaxLength: 1000,
+    ruleKeyMaxLength: 60,
+};
+//# sourceMappingURL=incident-sla.dto.js.map

package/dist/esm/modules/incident-sla/interfaces/incident-sla.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"incident-sla.dto.js","sourceRoot":"","sources":["../../../../../src/modules/incident-sla/interfaces/incident-sla.dto.ts"],"names":[],"mappings":"AA0rBA,8GAA8G;AAC9G,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACtC,gBAAgB,EAAE,CAAC;IACnB,gBAAgB,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI;IAChC,mBAAmB,EAAE,EAAE;IACvB,mBAAmB,EAAE,EAAE;IACvB,eAAe,EAAE,EAAE;IACnB,eAAe,EAAE,IAAI;IACrB,eAAe,EAAE,EAAE,GAAG,EAAE;IACxB,eAAe,EAAE,EAAE;IACnB,iBAAiB,EAAE,CAAC;IACpB,iBAAiB,EAAE,IAAI;IACvB,eAAe,EAAE,EAAE;IACnB,eAAe,EAAE,CAAC,GAAG,IAAI;IACzB,mBAAmB,EAAE,EAAE;IACvB,WAAW,EAAE,CAAC;IACd,WAAW,EAAE,GAAG;IAChB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,CAAC;IAChB,mBAAmB,EAAE,CAAC,GAAG,EAAE;IAC3B,mBAAmB,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI;IACnC,yBAAyB,EAAE,EAAE,GAAG,IAAI;IACpC,kBAAkB,EAAE,EAAE;IACtB,qBAAqB,EAAE,EAAE;IACzB,mBAAmB,EAAE,GAAG;IACxB,0BAA0B,EAAE,IAAI;IAChC,gBAAgB,EAAE,EAAE;CACd,CAAC"}

package/dist/esm/modules/incident-sla/utils/incident-sla-display.util.js

@@ -0,0 +1,326 @@
+import { EmergencyIncidentStage, EtaStatus, IncidentActorType, IncidentArrivalSource, IncidentSlaEventType, IncidentSlaStage, IncidentSlaStatus, SlaExceptionReason, SlaExceptionStatus, SlaOverallState, SlaEscalationAction, SlaEscalationLevel, SlaEscalationTrigger, SlaNotificationChannel, SlaPauseReason, SlaPolicyScope, SlaPriorityLevel, } from '../enums/incident-sla-enums';
+export const INCIDENT_SLA_STAGE_LABELS = {
+    [IncidentSlaStage.ACKNOWLEDGEMENT]: 'Acknowledgement',
+    [IncidentSlaStage.TRIAGE]: 'Triage',
+    [IncidentSlaStage.DISPATCH]: 'Dispatch',
+    [IncidentSlaStage.RESPONSE_UNIT_ACCEPTANCE]: 'Unit acceptance',
+    [IncidentSlaStage.MOBILIZATION]: 'Mobilization',
+    [IncidentSlaStage.ARRIVAL]: 'Arrival',
+    [IncidentSlaStage.INITIAL_ASSESSMENT]: 'Initial assessment',
+    [IncidentSlaStage.RESOLUTION]: 'Resolution',
+    [IncidentSlaStage.CLOSURE]: 'Closure',
+};
+export const INCIDENT_SLA_STATUS_LABELS = {
+    [IncidentSlaStatus.NOT_STARTED]: 'Not started',
+    [IncidentSlaStatus.RUNNING]: 'On track',
+    [IncidentSlaStatus.WARNING]: 'Warning',
+    [IncidentSlaStatus.AT_RISK]: 'At risk',
+    [IncidentSlaStatus.PAUSED]: 'Paused',
+    [IncidentSlaStatus.BREACHED]: 'Breached',
+    [IncidentSlaStatus.MET]: 'Met',
+    [IncidentSlaStatus.WAIVED]: 'Waived',
+    [IncidentSlaStatus.CANCELLED]: 'Not applicable',
+    [IncidentSlaStatus.EXPIRED]: 'Ended',
+};
+export const SLA_OVERALL_STATE_LABELS = {
+    [SlaOverallState.NOT_TRACKED]: 'Not tracked',
+    [SlaOverallState.ON_TRACK]: 'On track',
+    [SlaOverallState.WARNING]: 'Warning',
+    [SlaOverallState.AT_RISK]: 'At risk',
+    [SlaOverallState.BREACHED]: 'Breached',
+    [SlaOverallState.PAUSED]: 'Paused',
+    [SlaOverallState.MET]: 'Met',
+    [SlaOverallState.EXCEPTION]: 'Exception approved',
+};
+export const EMERGENCY_INCIDENT_STAGE_LABELS = {
+    [EmergencyIncidentStage.INCIDENT_CREATED]: 'Incident raised',
+    [EmergencyIncidentStage.ACKNOWLEDGED]: 'Acknowledged',
+    [EmergencyIncidentStage.TRIAGED]: 'Triaged',
+    [EmergencyIncidentStage.DISPATCH_INITIATED]: 'Dispatch initiated',
+    [EmergencyIncidentStage.RESPONSE_UNIT_ASSIGNED]: 'Unit assigned',
+    [EmergencyIncidentStage.RESPONSE_UNIT_ACCEPTED]: 'Unit accepted',
+    [EmergencyIncidentStage.EN_ROUTE]: 'En route',
+    [EmergencyIncidentStage.ON_SCENE]: 'On scene',
+    [EmergencyIncidentStage.STABILIZING]: 'Responding',
+    [EmergencyIncidentStage.RESOLVED]: 'Resolved',
+    [EmergencyIncidentStage.CLOSED]: 'Closed',
+};
+export const SLA_PAUSE_REASON_LABELS = {
+    [SlaPauseReason.WAITING_FOR_CUSTOMER]: 'Waiting for the customer',
+    [SlaPauseReason.WAITING_FOR_EXTERNAL_AGENCY]: 'Waiting for an external agency',
+    [SlaPauseReason.LOCATION_INACCESSIBLE]: 'Location inaccessible',
+    [SlaPauseReason.ENVIRONMENT_UNSAFE]: 'Environment unsafe',
+    [SlaPauseReason.INCIDENT_DEESCALATED]: 'Incident de-escalated',
+    [SlaPauseReason.OTHER_APPROVED_REASON]: 'Other approved reason',
+};
+export const SLA_EXCEPTION_REASON_LABELS = {
+    [SlaExceptionReason.ROAD_INACCESSIBLE]: 'Road inaccessible',
+    [SlaExceptionReason.SEVERE_WEATHER]: 'Severe weather',
+    [SlaExceptionReason.CUSTOMER_UNREACHABLE]: 'Customer unreachable',
+    [SlaExceptionReason.INCORRECT_LOCATION]: 'Incorrect location given',
+    [SlaExceptionReason.EXTERNAL_AGENCY_DELAY]: 'External agency delay',
+    [SlaExceptionReason.SAFETY_HOLD]: 'Held back for safety',
+    [SlaExceptionReason.SYSTEM_OUTAGE]: 'System outage',
+    [SlaExceptionReason.OTHER]: 'Other',
+};
+export const SLA_EXCEPTION_STATUS_LABELS = {
+    [SlaExceptionStatus.NONE]: '',
+    [SlaExceptionStatus.REQUESTED]: 'Exception requested',
+    [SlaExceptionStatus.APPROVED]: 'Exception approved',
+    [SlaExceptionStatus.REJECTED]: 'Exception rejected',
+};
+export const ETA_STATUS_LABELS = {
+    [EtaStatus.ON_TRACK]: 'On track',
+    [EtaStatus.AT_RISK]: 'At risk',
+    [EtaStatus.LIKELY_BREACH]: 'Will be late',
+    [EtaStatus.UNCERTAIN]: 'Uncertain',
+    [EtaStatus.NO_TARGET]: 'No target',
+    [EtaStatus.ARRIVED]: 'Arrived',
+};
+export const INCIDENT_ARRIVAL_SOURCE_LABELS = {
+    [IncidentArrivalSource.ARRIVAL_CONFIRMED_BY_RESPONDER]: 'Confirmed by the responder',
+    [IncidentArrivalSource.ARRIVAL_CONFIRMED_BY_CONTROL_CENTRE]: 'Confirmed by the control room',
+    [IncidentArrivalSource.ARRIVAL_INFERRED_FROM_TRACKING]: 'Inferred from live tracking',
+};
+export const INCIDENT_ACTOR_TYPE_LABELS = {
+    [IncidentActorType.CONTROL_CENTRE]: 'Control room',
+    [IncidentActorType.RESPONDER]: 'Responder',
+    [IncidentActorType.SYSTEM]: 'System',
+    [IncidentActorType.TRACKING]: 'Live tracking',
+    [IncidentActorType.REPORTER]: 'Reporter',
+    [IncidentActorType.PARTNER]: 'Partner',
+};
+export const INCIDENT_SLA_EVENT_TYPE_LABELS = {
+    [IncidentSlaEventType.SLA_STARTED]: 'Clock started',
+    [IncidentSlaEventType.SLA_WARNING]: 'Warning',
+    [IncidentSlaEventType.SLA_AT_RISK]: 'At risk',
+    [IncidentSlaEventType.SLA_BREACHED]: 'Breached',
+    [IncidentSlaEventType.SLA_MET]: 'Met',
+    [IncidentSlaEventType.SLA_COMPLETED_LATE]: 'Reached late',
+    [IncidentSlaEventType.SLA_CANCELLED]: 'Not applicable',
+    [IncidentSlaEventType.SLA_EXPIRED]: 'Ended unreached',
+    [IncidentSlaEventType.SLA_WAIVED]: 'Waived',
+    [IncidentSlaEventType.SLA_PAUSE_REQUESTED]: 'Pause requested',
+    [IncidentSlaEventType.SLA_PAUSE_REJECTED]: 'Pause rejected',
+    [IncidentSlaEventType.SLA_PAUSED]: 'Paused',
+    [IncidentSlaEventType.SLA_RESUMED]: 'Resumed',
+    [IncidentSlaEventType.SLA_EXCEPTION_REQUESTED]: 'Exception requested',
+    [IncidentSlaEventType.SLA_EXCEPTION_APPROVED]: 'Exception approved',
+    [IncidentSlaEventType.SLA_EXCEPTION_REJECTED]: 'Exception rejected',
+    [IncidentSlaEventType.MILESTONE_RECORDED]: 'Milestone',
+    [IncidentSlaEventType.PRIORITY_TRIAGED]: 'Priority set at triage',
+    [IncidentSlaEventType.ETA_CHANGED]: 'ETA changed',
+    [IncidentSlaEventType.ARRIVAL_INFERRED]: 'Arrival inferred from tracking',
+    [IncidentSlaEventType.ARRIVAL_CONFIRMED]: 'Arrival confirmed',
+    [IncidentSlaEventType.UNIT_RECOMMENDED]: 'Alternative unit recommended',
+    [IncidentSlaEventType.UNIT_REASSIGNED]: 'Unit reassigned',
+    [IncidentSlaEventType.ESCALATED]: 'Escalated',
+    [IncidentSlaEventType.NOTIFICATION_SENT]: 'Notification sent',
+    [IncidentSlaEventType.NOTIFICATION_FAILED]: 'Notification failed',
+    [IncidentSlaEventType.AUTO_CLOSE_DEFERRED]: 'Automatic closure deferred',
+    [IncidentSlaEventType.INCIDENT_AUTO_CLOSED]: 'Closed automatically',
+    [IncidentSlaEventType.INCIDENT_CLOSED]: 'Closed',
+};
+/** The colour of an instance's status chip. */
+export function incidentSlaStatusTone(status, exceptionStatus) {
+    switch (status) {
+        case IncidentSlaStatus.MET:
+            return 'success';
+        case IncidentSlaStatus.RUNNING:
+            return 'info';
+        case IncidentSlaStatus.WARNING:
+        case IncidentSlaStatus.AT_RISK:
+            return 'warning';
+        case IncidentSlaStatus.BREACHED:
+            return exceptionStatus === SlaExceptionStatus.APPROVED ? 'accent' : 'error';
+        case IncidentSlaStatus.PAUSED:
+            return 'primary';
+        default:
+            return 'grey';
+    }
+}
+export function slaOverallStateTone(state) {
+    switch (state) {
+        case SlaOverallState.ON_TRACK:
+            return 'info';
+        case SlaOverallState.MET:
+            return 'success';
+        case SlaOverallState.WARNING:
+        case SlaOverallState.AT_RISK:
+            return 'warning';
+        case SlaOverallState.BREACHED:
+            return 'error';
+        case SlaOverallState.PAUSED:
+            return 'primary';
+        case SlaOverallState.EXCEPTION:
+            return 'accent';
+        default:
+            return 'grey';
+    }
+}
+export function etaStatusTone(status) {
+    switch (status) {
+        case EtaStatus.ON_TRACK:
+        case EtaStatus.ARRIVED:
+            return 'success';
+        case EtaStatus.AT_RISK:
+            return 'warning';
+        case EtaStatus.LIKELY_BREACH:
+            return 'error';
+        default:
+            return 'grey';
+    }
+}
+/** "01:12", "12:05", "1:05:00", and overdue as "+00:45". */
+export function formatSlaClock(seconds) {
+    if (seconds === null || seconds === undefined || !Number.isFinite(seconds))
+        return '';
+    const overdue = seconds < 0;
+    const total = Math.abs(Math.round(seconds));
+    const h = Math.floor(total / 3600);
+    const m = Math.floor((total % 3600) / 60);
+    const s = total % 60;
+    const pad = (n) => String(n).padStart(2, '0');
+    const body = h > 0 ? `${h}:${pad(m)}:${pad(s)}` : `${pad(m)}:${pad(s)}`;
+    return overdue ? `+${body}` : body;
+}
+/** "15 sec", "2 min", "1 h 30 min", "1 d 2 h". */
+export function formatSlaTarget(seconds) {
+    if (seconds === null || seconds === undefined || !Number.isFinite(seconds))
+        return '';
+    const value = Math.max(0, Math.round(seconds));
+    if (value < 60)
+        return `${value} sec`;
+    if (value < 3600)
+        return value % 60 === 0 ? `${value / 60} min` : `${Math.floor(value / 60)} min ${value % 60} sec`;
+    if (value < 86400) {
+        const minutes = Math.round((value % 3600) / 60);
+        return minutes ? `${Math.floor(value / 3600)} h ${minutes} min` : `${Math.floor(value / 3600)} h`;
+    }
+    const hours = Math.round((value % 86400) / 3600);
+    return hours ? `${Math.floor(value / 86400)} d ${hours} h` : `${Math.floor(value / 86400)} d`;
+}
+/**
+ * Seconds left on an instance at the browser's `nowMs`, corrected for the
+ * difference between the server's clock and the browser's (`skewMs` = server -
+ * browser, measured when the summary arrived). Null when its clock is not
+ * running. Display only - the server decides every transition.
+ */
+export function liveRemainingSeconds(instance, nowMs, skewMs = 0) {
+    const running = instance.status === IncidentSlaStatus.RUNNING || instance.status === IncidentSlaStatus.WARNING || instance.status === IncidentSlaStatus.AT_RISK || instance.status === IncidentSlaStatus.BREACHED;
+    if (!running || !instance.deadlineAt)
+        return null;
+    return Math.round((Date.parse(instance.deadlineAt) - (nowMs + skewMs)) / 1000);
+}
+/**
+ * The status an open instance shows at `nowMs`: what the server said, or the
+ * next threshold if the clock has passed it since (the server's own event
+ * follows within seconds). Never goes backwards.
+ */
+export function liveIncidentSlaStatus(instance, nowMs, skewMs = 0) {
+    const order = [IncidentSlaStatus.RUNNING, IncidentSlaStatus.WARNING, IncidentSlaStatus.AT_RISK, IncidentSlaStatus.BREACHED];
+    const rank = order.indexOf(instance.status);
+    if (rank < 0 || instance.completedAt)
+        return instance.status;
+    const t = nowMs + skewMs;
+    let byTime = 0;
+    if (instance.deadlineAt && t >= Date.parse(instance.deadlineAt))
+        byTime = 3;
+    else if (instance.atRiskAt && t >= Date.parse(instance.atRiskAt))
+        byTime = 2;
+    else if (instance.warningAt && t >= Date.parse(instance.warningAt))
+        byTime = 1;
+    return order[Math.max(rank, byTime)];
+}
+/** Statuses whose clock is running (or paused). */
+export function isOpenIncidentSlaStatus(status) {
+    return status === IncidentSlaStatus.RUNNING || status === IncidentSlaStatus.WARNING || status === IncidentSlaStatus.AT_RISK || status === IncidentSlaStatus.PAUSED;
+}
+/** Stages in the order an emergency goes through them. */
+export const INCIDENT_SLA_STAGE_ORDER = [
+    IncidentSlaStage.ACKNOWLEDGEMENT,
+    IncidentSlaStage.TRIAGE,
+    IncidentSlaStage.DISPATCH,
+    IncidentSlaStage.RESPONSE_UNIT_ACCEPTANCE,
+    IncidentSlaStage.MOBILIZATION,
+    IncidentSlaStage.ARRIVAL,
+    IncidentSlaStage.INITIAL_ASSESSMENT,
+    IncidentSlaStage.RESOLUTION,
+    IncidentSlaStage.CLOSURE,
+];
+export const SLA_ESCALATION_TRIGGER_LABELS = {
+    [SlaEscalationTrigger.SLA_WARNING]: 'Stage at its warning mark',
+    [SlaEscalationTrigger.SLA_AT_RISK]: 'Stage at risk',
+    [SlaEscalationTrigger.SLA_BREACHED]: 'Stage breached',
+    [SlaEscalationTrigger.ETA_AT_RISK]: 'Arrival ETA at risk',
+    [SlaEscalationTrigger.ETA_LIKELY_BREACH]: 'Unit predicted late',
+    [SlaEscalationTrigger.ETA_UNCERTAIN]: 'Unit stopped reporting its position',
+    [SlaEscalationTrigger.DISPATCH_REJECTED]: 'Unit declined',
+    [SlaEscalationTrigger.DISPATCH_CANCELLED]: 'Unit stood down',
+};
+export const SLA_ESCALATION_LEVEL_LABELS = {
+    [SlaEscalationLevel.DISPATCHER]: 'Dispatchers',
+    [SlaEscalationLevel.SUPERVISOR]: 'Supervisors',
+    [SlaEscalationLevel.DUTY_MANAGER]: 'Duty manager',
+    [SlaEscalationLevel.ORGANIZATION_ADMIN]: 'Organization admins',
+};
+export const SLA_NOTIFICATION_CHANNEL_LABELS = {
+    [SlaNotificationChannel.WEB]: 'In-app',
+    [SlaNotificationChannel.SMS]: 'SMS',
+    [SlaNotificationChannel.EMAIL]: 'Email',
+    [SlaNotificationChannel.PUSH]: 'Push',
+};
+export const SLA_ESCALATION_ACTION_LABELS = {
+    [SlaEscalationAction.NOTIFY]: 'Notify',
+    [SlaEscalationAction.RECOMMEND_ALTERNATIVE]: 'Suggest another unit',
+};
+export const SLA_POLICY_SCOPE_LABELS = {
+    [SlaPolicyScope.PLATFORM]: 'Platform',
+    [SlaPolicyScope.ORGANIZATION]: 'Organization',
+    [SlaPolicyScope.CONTROL_CENTRE]: 'Control centre',
+    [SlaPolicyScope.INCIDENT_CATEGORY]: 'Incident category',
+    [SlaPolicyScope.INCIDENT_TYPE]: 'Incident type',
+    [SlaPolicyScope.PRIORITY]: 'Priority',
+    [SlaPolicyScope.ZONE]: 'Zone',
+};
+/** The emergency notifications, as clarion-incident asks for them. */
+export const EMERGENCY_NOTIFICATION_EVENT_LABELS = {
+    'emergency-created': 'Alert received (reporter)',
+    'emergency-acknowledged': 'Acknowledged (reporter)',
+    'emergency-dispatched': 'Help dispatched (reporter)',
+    'emergency-unit-assigned': 'Unit assigned',
+    'emergency-unit-en-route': 'Unit on the way (reporter)',
+    'emergency-arrived': 'Unit arrived (reporter)',
+    'emergency-at-risk': 'At risk (staff)',
+    'emergency-sla-breached': 'SLA breached (staff)',
+    'emergency-escalated': 'Escalated (staff)',
+    'emergency-resolved': 'Resolved (reporter)',
+    'emergency-closed': 'Closed (reporter)',
+};
+/** The SLA level of each priority (P1 = Critical ... P4 = Low). */
+export const INCIDENT_PRIORITY_SLA_LEVEL = {
+    Critical: SlaPriorityLevel.P1,
+    High: SlaPriorityLevel.P2,
+    Medium: SlaPriorityLevel.P3,
+    Low: SlaPriorityLevel.P4,
+};
+/** What each policy setting means, for the policy editor. */
+export const INCIDENT_SLA_SETTING_LABELS = {
+    warningThresholdPercent: { label: 'Warning at', unit: '% of target', help: 'When a clock turns amber.' },
+    atRiskThresholdPercent: { label: 'At risk at', unit: '% of target', help: 'When a clock turns red and dispatchers are told.' },
+    arrivalRadiusMetres: { label: 'Arrival radius', unit: 'm', help: 'A unit this close to the incident counts as at the scene.' },
+    arrivalExitRadiusMetres: { label: 'Exit radius', unit: 'm', help: 'A unit at the scene only leaves it beyond this.' },
+    arrivalDwellSeconds: { label: 'Dwell before arrival', unit: 'seconds', help: 'How long a unit must stay inside the radius.' },
+    arrivalMinObservations: { label: 'Positions inside the radius', unit: 'fixes', help: 'At least this many before an arrival is inferred.' },
+    maxLocationAccuracyMetres: { label: 'Worst usable accuracy', unit: 'm', help: 'A less accurate position never confirms an arrival.' },
+    trackingStaleSeconds: { label: 'Position goes stale after', unit: 'seconds', help: 'Then the ETA is uncertain and dispatchers are told.' },
+    etaAtRiskMarginPercent: { label: 'ETA at-risk margin', unit: '% of target', help: 'An ETA this close to the deadline is at risk.' },
+    etaAssumedSpeedKph: { label: 'Assumed speed', unit: 'km/h', help: 'For an estimated ETA (no road routing).' },
+    etaRoadFactor: { label: 'Road factor', unit: '× straight line', help: 'Straight-line distance to road distance.' },
+    autoCloseEnabled: { label: 'Close automatically', unit: '', help: 'Close an emergency some time after it is resolved.' },
+    autoCloseAfterSeconds: { label: 'Close after', unit: 'seconds', help: 'Resolved to closed (default 24 hours).' },
+    allowAutomaticReassignment: { label: 'Automatic reassignment', unit: '', help: 'Let the workflow send another unit by itself when one will be late. Off: the dispatcher decides.' },
+    pauseRequiresApproval: { label: 'Pauses need a supervisor', unit: '', help: 'A dispatcher\'s pause waits for an approver.' },
+    notifyReporter: { label: 'Tell the reporter', unit: '', help: 'Progress messages to the person who raised the emergency.' },
+};
+//# sourceMappingURL=incident-sla-display.util.js.map