clarion-shared-types 1.0.116 → 1.0.118

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

@@ -0,0 +1,656 @@
+import { IncidentEmergencyType } from '../../incident/enums/incident-emergency-type.enum';
+import { IncidentPriority } from '../../incident/enums/incident-priority.enum';
+import { EmergencyIncidentStage, EtaBasis, EtaStatus, IncidentActorType, IncidentArrivalSource, IncidentClosureReason, IncidentSlaEventSource, IncidentSlaEventType, IncidentSlaStage, IncidentSlaStatus, SlaEscalationLevel, SlaEscalationTrigger, SlaExceptionReason, SlaExceptionStatus, SlaOverallState, SlaPauseReason, SlaPauseStatus, SlaPolicyScope, SlaPriorityLevel } from '../enums/incident-sla-enums';
+export interface IncidentSlaExceptionDto {
+    status: SlaExceptionStatus;
+    reason: SlaExceptionReason | null;
+    note: string | null;
+    requestedBy: number | null;
+    requestedAt: string | null;
+    decidedBy: number | null;
+    decidedAt: string | null;
+    decisionNote: string | null;
+}
+export interface IncidentSlaInstanceDto {
+    id: number;
+    stage: IncidentSlaStage;
+    cycle: number;
+    responseUnitDispatchId: number | null;
+    responseUnitId: number | null;
+    responseUnitName: string | null;
+    priority: IncidentPriority;
+    status: IncidentSlaStatus;
+    targetSeconds: number | null;
+    startedAt: string | null;
+    deadlineAt: string | null;
+    originalDeadlineAt: string | null;
+    warningAt: string | null;
+    atRiskAt: string | null;
+    warnedAt: string | null;
+    atRiskSince: string | null;
+    breachedAt: string | null;
+    completedAt: string | null;
+    endedAt: string | null;
+    endReason: string | null;
+    pausedAt: string | null;
+    totalPausedSeconds: number;
+    elapsedSeconds: number | null;
+    remainingSeconds: number | null;
+    overdueSeconds: number | null;
+    exception: IncidentSlaExceptionDto | null;
+    waivedBy: number | null;
+    waivedAt: string | null;
+    waiveReason: string | null;
+    slaPolicyId: number | null;
+    slaPolicyVersion: number | null;
+}
+export type IncidentSlaTimelineState = 'DONE' | 'CURRENT' | 'PENDING' | 'SKIPPED';
+export interface IncidentSlaTimelineItemDto {
+    milestone: EmergencyIncidentStage;
+    state: IncidentSlaTimelineState;
+    at: string | null;
+    implied: boolean;
+    actorType: IncidentActorType | null;
+    source: IncidentSlaEventSource | null;
+    stage: IncidentSlaStage | null;
+    slaStatus: IncidentSlaStatus | null;
+    targetAt: string | null;
+    etaAt: string | null;
+    arrivalSource: IncidentArrivalSource | null;
+}
+export interface IncidentSlaStatsDto {
+    total: number;
+    decided: number;
+    met: number;
+    breached: number;
+    breachedWithApprovedException: number;
+    open: number;
+    warnings: number;
+    atRisk: number;
+    compliancePercent: number | null;
+    complianceWithExceptionsPercent: number | null;
+}
+export interface IncidentEtaDto {
+    dispatchId: number;
+    responseUnitId: number;
+    responseUnitName: string | null;
+    status: EtaStatus;
+    etaSeconds: number | null;
+    predictedArrivalAt: string | null;
+    distanceMetres: number | null;
+    basis: EtaBasis | null;
+    computedAt: string | null;
+    lastLocationAt: string | null;
+    locationAgeSeconds: number | null;
+    arrivalDeadlineAt: string | null;
+}
+export interface IncidentSlaPauseDto {
+    id: number;
+    instanceId: number;
+    stage: IncidentSlaStage;
+    reason: SlaPauseReason;
+    note: string | null;
+    status: SlaPauseStatus;
+    requestedBy: number | null;
+    requestedAt: string;
+    decidedBy: number | null;
+    decidedAt: string | null;
+    decisionNote: string | null;
+    startedAt: string | null;
+    endedAt: string | null;
+    pausedSeconds: number;
+}
+export interface IncidentSlaAlternativeDto {
+    responseUnitId: number;
+    responseUnitName: string | null;
+    distanceMetres: number | null;
+    etaSeconds: number | null;
+    trigger: SlaEscalationTrigger;
+    forDispatchId: number | null;
+    recommendedAt: string;
+}
+export interface IncidentSlaAllowedActionsDto {
+    acknowledge: boolean;
+    triage: boolean;
+    recordAssessment: boolean;
+    requestPause: boolean;
+    approvePause: boolean;
+    endPause: boolean;
+    requestException: boolean;
+    approveException: boolean;
+    waive: boolean;
+}
+export interface IncidentSlaClosureDto {
+    resolvedAt: string | null;
+    closedAt: string | null;
+    closureReason: IncidentClosureReason | null;
+    closedBy: number | null;
+    autoCloseEnabled: boolean;
+    autoCloseAt: string | null;
+}
+export interface IncidentSlaContributingPolicyDto {
+    policyId: number;
+    policyKey: string;
+    version: number;
+    name: string;
+    scope: SlaPolicyScope;
+}
+export interface IncidentSlaPolicyReferenceDto {
+    id: number | null;
+    key: string | null;
+    version: number | null;
+    name: string;
+    scope: SlaPolicyScope;
+    contributingPolicies: IncidentSlaContributingPolicyDto[];
+}
+/** `GET /api/incidents/:id/sla`. */
+export interface IncidentSlaSummaryDto {
+    incidentId: number;
+    tracked: boolean;
+    notTrackedReason: string | null;
+    serverTime: string;
+    priority: IncidentPriority | null;
+    priorityLevel: SlaPriorityLevel | null;
+    policy: IncidentSlaPolicyReferenceDto | null;
+    overall: SlaOverallState;
+    currentStage: EmergencyIncidentStage | null;
+    currentInstance: IncidentSlaInstanceDto | null;
+    instances: IncidentSlaInstanceDto[];
+    timeline: IncidentSlaTimelineItemDto[];
+    stats: IncidentSlaStatsDto;
+    etas: IncidentEtaDto[];
+    primaryEta: IncidentEtaDto | null;
+    pauses: IncidentSlaPauseDto[];
+    alternative: IncidentSlaAlternativeDto | null;
+    closure: IncidentSlaClosureDto;
+    allowedActions: IncidentSlaAllowedActionsDto;
+    workflowId: string | null;
+}
+/** One row of `GET /api/incidents/:id/sla/events`. */
+export interface IncidentSlaEventDto {
+    id: number;
+    eventType: IncidentSlaEventType;
+    stage: IncidentSlaStage | null;
+    cycle: number | null;
+    instanceId: number | null;
+    milestone: EmergencyIncidentStage | null;
+    fromStatus: IncidentSlaStatus | null;
+    toStatus: IncidentSlaStatus | null;
+    actorUserId: number | null;
+    actorType: IncidentActorType;
+    source: IncidentSlaEventSource;
+    reason: string | null;
+    note: string | null;
+    metadata: Record<string, unknown> | null;
+    correlationId: string | null;
+    workflowId: string | null;
+    occurredAt: string;
+    recordedAt: string;
+}
+export interface IncidentSlaEventPageDto {
+    data: IncidentSlaEventDto[];
+    total: number;
+    page: number;
+    limit: number;
+}
+/** Bodies of the SLA write routes. */
+export interface TriageEmergencyIncidentRequest {
+    priority?: IncidentPriority;
+    note?: string;
+}
+export interface RequestSlaPauseRequest {
+    reason: SlaPauseReason;
+    note?: string;
+    instanceIds?: number[];
+}
+export interface RequestSlaExceptionRequest {
+    reason: SlaExceptionReason;
+    note: string;
+}
+/** A stored SLA policy version (`GET /api/incident-sla/policies`). */
+export interface IncidentSlaPolicyDto {
+    id: number;
+    policyKey: string;
+    version: number;
+    name: string;
+    description: string | null;
+    scope: SlaPolicyScope;
+    organizationId: number | null;
+    controlCentreId: number | null;
+    categoryId: number | null;
+    typeId: number | null;
+    priority: IncidentPriority | null;
+    zoneId: number | null;
+    incidentClass: string;
+    effectiveFrom: string;
+    effectiveTo: string | null;
+    active: boolean;
+    settings: Record<string, number | boolean>;
+    priorityFloors: Partial<Record<IncidentEmergencyType, IncidentPriority>> | null;
+    startAnchors: Partial<Record<IncidentSlaStage, EmergencyIncidentStage>> | null;
+    targets: {
+        stage: IncidentSlaStage;
+        priority: IncidentPriority;
+        targetSeconds: number | null;
+    }[];
+    escalationRules: {
+        key: string;
+        trigger: SlaEscalationTrigger;
+        stages: IncidentSlaStage[];
+        priorities: IncidentPriority[];
+        level: SlaEscalationLevel;
+        channels: string[];
+        actions: string[];
+        delaySeconds: number;
+        recipientRoles: string[];
+        contacts: {
+            name?: string | null;
+            phoneNumber?: string | null;
+            email?: string | null;
+        }[];
+    }[] | null;
+    usageCount?: number;
+    createdBy: number | null;
+    updatedBy: number | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export type IncidentSlaAnalyticsBucket = 'hour' | 'day' | 'week' | 'month';
+export interface IncidentSlaAnalyticsRangeDto {
+    from: string;
+    to: string;
+    bucket: IncidentSlaAnalyticsBucket;
+    timeZone: string;
+}
+export interface IncidentSlaAnalyticsCountDto {
+    key: string;
+    count: number;
+}
+export interface IncidentSlaDurationSummaryDto {
+    median: number | null;
+    p90: number | null;
+    count: number;
+}
+export interface IncidentSlaDurationPercentilesDto {
+    p50: number | null;
+    p75: number | null;
+    p90: number | null;
+    p95: number | null;
+    p99: number | null;
+    average: number | null;
+    count: number;
+}
+export interface IncidentSlaAnalyticsSummaryDto {
+    emergencies: number;
+    openNow: number;
+    breachedEmergencies: number;
+    breachedEmergencyPercent: number | null;
+    decided: number;
+    met: number;
+    breached: number;
+    breachedWithApprovedException: number;
+    compliancePercent: number | null;
+    complianceWithExceptionsPercent: number | null;
+    acknowledged: number;
+    dispatched: number;
+    arrived: number;
+    resolved: number;
+    closed: number;
+    autoClosed: number;
+    timeToAcknowledge: IncidentSlaDurationSummaryDto;
+    timeToDispatch: IncidentSlaDurationSummaryDto;
+    timeToArrival: IncidentSlaDurationSummaryDto;
+    travelTime: IncidentSlaDurationSummaryDto;
+    timeToResolve: IncidentSlaDurationSummaryDto;
+    escalations: number;
+    alternativesRecommended: number;
+    reassignments: number;
+    notificationsFailed: number;
+}
+export interface IncidentSlaStageAnalyticsDto {
+    stage: IncidentSlaStage;
+    instances: number;
+    met: number;
+    breached: number;
+    breachedWithApprovedException: number;
+    open: number;
+    waived: number;
+    expired: number;
+    cancelled: number;
+    warned: number;
+    atRisk: number;
+    compliancePercent: number | null;
+    complianceWithExceptionsPercent: number | null;
+    targetSeconds: number | null;
+    duration: IncidentSlaDurationPercentilesDto;
+    overrun: IncidentSlaDurationSummaryDto;
+}
+export interface IncidentSlaStageCellDto {
+    stage: IncidentSlaStage;
+    met: number;
+    breached: number;
+    compliancePercent: number | null;
+    medianSeconds: number | null;
+}
+export interface IncidentSlaPriorityRowDto {
+    priority: IncidentPriority;
+    level: SlaPriorityLevel;
+    emergencies: number;
+    breachedEmergencies: number;
+    met: number;
+    breached: number;
+    compliancePercent: number | null;
+    medianSecondsToAcknowledge: number | null;
+    medianSecondsToArrival: number | null;
+    stages: IncidentSlaStageCellDto[];
+}
+export interface IncidentSlaTimelinePointDto {
+    bucket: string;
+    emergencies: number;
+    breachedEmergencies: number;
+    met: number;
+    breached: number;
+    compliancePercent: number | null;
+    medianSecondsToAcknowledge: number | null;
+    medianSecondsToArrival: number | null;
+    escalations: number;
+}
+export interface IncidentSlaControlCentreRowDto {
+    controlCentreId: number | null;
+    emergencies: number;
+    breachedEmergencies: number;
+    met: number;
+    breached: number;
+    compliancePercent: number | null;
+    medianSecondsToAcknowledge: number | null;
+    medianSecondsToDispatch: number | null;
+    medianSecondsToArrival: number | null;
+    escalations: number;
+}
+export interface IncidentSlaTypeRowDto {
+    typeId: number | null;
+    typeName: string | null;
+    categoryId: number | null;
+    categoryName: string | null;
+    emergencies: number;
+    breachedEmergencies: number;
+    met: number;
+    breached: number;
+    compliancePercent: number | null;
+    medianSecondsToArrival: number | null;
+}
+export interface IncidentSlaResponseUnitRowDto {
+    responseUnitId: number;
+    responseUnitName: string;
+    dispatches: number;
+    accepted: number;
+    declined: number;
+    stoodDown: number;
+    arrived: number;
+    arrivalsInferred: number;
+    acceptanceMet: number;
+    acceptanceBreached: number;
+    acceptanceCompliancePercent: number | null;
+    medianSecondsToAccept: number | null;
+    medianSecondsToMobilize: number | null;
+    medianSecondsToArrive: number | null;
+}
+export interface IncidentSlaArrivalAnalyticsDto {
+    arrivals: number;
+    bySource: IncidentSlaAnalyticsCountDto[];
+    inferredPercent: number | null;
+    etaAtRisk: number;
+    etaLikelyLate: number;
+    etaUncertain: number;
+    predictedLate: number;
+    predictedLateAndBreached: number;
+    latePredictionPrecisionPercent: number | null;
+    firstEtaError: IncidentSlaDurationSummaryDto;
+    distanceAtDispatch: IncidentSlaDurationSummaryDto;
+}
+export interface IncidentSlaEscalationAnalyticsDto {
+    total: number;
+    byTrigger: IncidentSlaAnalyticsCountDto[];
+    byLevel: IncidentSlaAnalyticsCountDto[];
+    byStage: IncidentSlaAnalyticsCountDto[];
+    byRule: IncidentSlaAnalyticsCountDto[];
+    alternativesRecommended: number;
+    reassignments: number;
+    escalatedEmergencies: number;
+}
+export interface IncidentSlaPauseAnalyticsDto {
+    requested: number;
+    approved: number;
+    rejected: number;
+    pending: number;
+    withdrawn: number;
+    totalPausedSeconds: number;
+    pausedTime: IncidentSlaDurationSummaryDto;
+    byReason: IncidentSlaAnalyticsCountDto[];
+}
+export interface IncidentSlaExceptionAnalyticsDto {
+    requested: number;
+    approved: number;
+    rejected: number;
+    pending: number;
+    byReason: IncidentSlaAnalyticsCountDto[];
+}
+export interface IncidentSlaNotificationEventRowDto {
+    event: string;
+    requests: number;
+    failed: number;
+}
+export interface IncidentSlaNotificationChannelRowDto {
+    channel: string;
+    recipients: number;
+    sent: number;
+    failed: number;
+    successPercent: number | null;
+}
+export interface IncidentSlaNotificationAnalyticsDto {
+    requests: number;
+    byStatus: IncidentSlaAnalyticsCountDto[];
+    byEvent: IncidentSlaNotificationEventRowDto[];
+    byChannel: IncidentSlaNotificationChannelRowDto[];
+    byAudience: IncidentSlaAnalyticsCountDto[];
+}
+export interface IncidentSlaClosureAnalyticsDto {
+    resolved: number;
+    closed: number;
+    manual: number;
+    automatic: number;
+    awaitingClosure: number;
+    autoCloseDeferred: number;
+    resolvedToClosed: IncidentSlaDurationSummaryDto;
+}
+export interface IncidentSlaHeatmapCellDto {
+    weekday: number;
+    hour: number;
+    emergencies: number;
+    breachedEmergencies: number;
+}
+export interface IncidentSlaWorstIncidentDto {
+    incidentId: number;
+    reference: string;
+    priority: IncidentPriority;
+    typeName: string | null;
+    controlCentreId: number | null;
+    createdAt: string;
+    breachedStages: number;
+    worstStage: IncidentSlaStage | null;
+    maxOverrunSeconds: number;
+    totalOverrunSeconds: number;
+    timeToArrivalSeconds: number | null;
+}
+export interface IncidentSlaOrganizationRowDto {
+    organizationId: number;
+    emergencies: number;
+    breachedEmergencies: number;
+    met: number;
+    breached: number;
+    compliancePercent: number | null;
+    medianSecondsToAcknowledge: number | null;
+    medianSecondsToArrival: number | null;
+}
+/** `GET /api/incident-sla/analytics`. */
+export interface IncidentSlaAnalyticsDto {
+    range: IncidentSlaAnalyticsRangeDto;
+    organizationId: number | null;
+    controlCentreId: number | null;
+    platform: boolean;
+    summary: IncidentSlaAnalyticsSummaryDto;
+    previous: IncidentSlaAnalyticsSummaryDto | null;
+    stages: IncidentSlaStageAnalyticsDto[];
+    byPriority: IncidentSlaPriorityRowDto[];
+    timeline: IncidentSlaTimelinePointDto[];
+    byControlCentre: IncidentSlaControlCentreRowDto[];
+    byType: IncidentSlaTypeRowDto[];
+    byResponseUnit: IncidentSlaResponseUnitRowDto[];
+    arrival: IncidentSlaArrivalAnalyticsDto;
+    escalations: IncidentSlaEscalationAnalyticsDto;
+    pauses: IncidentSlaPauseAnalyticsDto;
+    exceptions: IncidentSlaExceptionAnalyticsDto;
+    notifications: IncidentSlaNotificationAnalyticsDto;
+    closure: IncidentSlaClosureAnalyticsDto;
+    emergencyTypes: IncidentSlaAnalyticsCountDto[];
+    heatmap: IncidentSlaHeatmapCellDto[];
+    worstIncidents: IncidentSlaWorstIncidentDto[];
+    byOrganization: IncidentSlaOrganizationRowDto[];
+    generatedAt: string;
+}
+/** The query of `GET /api/incident-sla/analytics`. */
+export interface IncidentSlaAnalyticsQuery {
+    from?: string;
+    to?: string;
+    timeZone?: string;
+    organizationId?: number;
+    controlCentreId?: number;
+    priority?: IncidentPriority;
+    stage?: IncidentSlaStage;
+    typeId?: number;
+    categoryId?: number;
+    responseUnitId?: number;
+}
+/** Policy settings beside the targets. On a stored policy every field is optional (absent = inherit). */
+export interface 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;
+}
+export interface IncidentSlaEscalationContactRequest {
+    name?: string;
+    phoneNumber?: string;
+    email?: string;
+}
+export interface IncidentSlaEscalationRuleRequest {
+    key: string;
+    trigger: SlaEscalationTrigger;
+    stages: IncidentSlaStage[];
+    priorities: IncidentPriority[];
+    level: SlaEscalationLevel;
+    channels: string[];
+    actions: string[];
+    delaySeconds: number;
+    recipientRoles: string[];
+    contacts: IncidentSlaEscalationContactRequest[];
+}
+/** The body of a new policy version (and, with a scope, of a new policy). */
+export interface IncidentSlaPolicyContentRequest {
+    name: string;
+    description?: string;
+    effectiveFrom?: string;
+    effectiveTo?: string;
+    settings?: Partial<IncidentSlaPolicySettingsDto>;
+    targets?: {
+        stage: IncidentSlaStage;
+        priority: IncidentPriority;
+        targetSeconds: number | null;
+    }[];
+    priorityFloors?: {
+        emergencyType: IncidentEmergencyType;
+        priority: IncidentPriority;
+    }[];
+    /** Absent: inherit the less specific policy's rules. [] : no escalation at all. */
+    escalationRules?: IncidentSlaEscalationRuleRequest[];
+}
+export interface CreateIncidentSlaPolicyRequest extends IncidentSlaPolicyContentRequest {
+    organizationId?: number;
+    controlCentreId?: number;
+    categoryId?: number;
+    typeId?: number;
+    priority?: IncidentPriority;
+    zoneId?: number;
+}
+/** The policy an incident like the one described would run under (`GET /api/incident-sla/policies/effective`). */
+export interface ResolvedIncidentSlaPolicyDto {
+    schemaVersion: 1;
+    policyId: number | null;
+    policyKey: string | null;
+    policyVersion: number | null;
+    policyName: string;
+    scope: SlaPolicyScope;
+    contributingPolicies: IncidentSlaContributingPolicyDto[];
+    effectiveAt: string;
+    resolvedAt: string;
+    targets: Record<IncidentPriority, Record<IncidentSlaStage, number | null>>;
+    startAnchors: Record<IncidentSlaStage, EmergencyIncidentStage>;
+    settings: IncidentSlaPolicySettingsDto;
+    priorityFloors: Partial<Record<IncidentEmergencyType, IncidentPriority>>;
+    escalationRules: IncidentSlaEscalationRuleRequest[];
+}
+export interface EffectiveIncidentSlaPolicyQuery {
+    organizationId: number;
+    controlCentreId?: number;
+    categoryId?: number;
+    typeId?: number;
+    priority?: IncidentPriority;
+    emergencyType?: IncidentEmergencyType;
+    zoneId?: number;
+    at?: string;
+}
+export interface IncidentSlaPolicyListQuery {
+    organizationId?: number;
+    activeOnly?: boolean;
+    includePlatform?: boolean;
+}
+/** The bounds the API enforces on a policy (grm-shared-library INCIDENT_SLA_LIMITS), for the admin's form. */
+export declare const INCIDENT_SLA_POLICY_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 minAccuracyMetres: 5;
+    readonly maxAccuracyMetres: 5000;
+    readonly minStaleSeconds: 15;
+    readonly maxStaleSeconds: number;
+    readonly maxEtaMarginPercent: 90;
+    readonly minSpeedKph: 5;
+    readonly maxSpeedKph: 150;
+    readonly minRoadFactor: 1;
+    readonly maxRoadFactor: 3;
+    readonly minAutoCloseSeconds: number;
+    readonly maxAutoCloseSeconds: number;
+    readonly maxEscalationDelaySeconds: number;
+    readonly maxEscalationRules: 50;
+    readonly maxEscalationContacts: 10;
+    readonly policyNameMaxLength: 120;
+    readonly policyDescriptionMaxLength: 1000;
+    readonly ruleKeyMaxLength: 60;
+};

package/dist/types/modules/incident-sla/utils/incident-sla-display.util.d.ts

@@ -0,0 +1,55 @@
+import { EmergencyIncidentStage, EtaStatus, IncidentActorType, IncidentArrivalSource, IncidentSlaEventType, IncidentSlaStage, IncidentSlaStatus, SlaExceptionReason, SlaExceptionStatus, SlaOverallState, SlaEscalationAction, SlaEscalationLevel, SlaEscalationTrigger, SlaNotificationChannel, SlaPauseReason, SlaPolicyScope, SlaPriorityLevel } from '../enums/incident-sla-enums';
+import { IncidentSlaInstanceDto } from '../interfaces/incident-sla.dto';
+/** A Clarion colour family: bg-light-{tone} text-{tone}. */
+export type SlaTone = 'success' | 'info' | 'warning' | 'error' | 'grey' | 'primary' | 'accent';
+export declare const INCIDENT_SLA_STAGE_LABELS: Readonly<Record<IncidentSlaStage, string>>;
+export declare const INCIDENT_SLA_STATUS_LABELS: Readonly<Record<IncidentSlaStatus, string>>;
+export declare const SLA_OVERALL_STATE_LABELS: Readonly<Record<SlaOverallState, string>>;
+export declare const EMERGENCY_INCIDENT_STAGE_LABELS: Readonly<Record<EmergencyIncidentStage, string>>;
+export declare const SLA_PAUSE_REASON_LABELS: Readonly<Record<SlaPauseReason, string>>;
+export declare const SLA_EXCEPTION_REASON_LABELS: Readonly<Record<SlaExceptionReason, string>>;
+export declare const SLA_EXCEPTION_STATUS_LABELS: Readonly<Record<SlaExceptionStatus, string>>;
+export declare const ETA_STATUS_LABELS: Readonly<Record<EtaStatus, string>>;
+export declare const INCIDENT_ARRIVAL_SOURCE_LABELS: Readonly<Record<IncidentArrivalSource, string>>;
+export declare const INCIDENT_ACTOR_TYPE_LABELS: Readonly<Record<IncidentActorType, string>>;
+export declare const INCIDENT_SLA_EVENT_TYPE_LABELS: Readonly<Record<IncidentSlaEventType, string>>;
+/** The colour of an instance's status chip. */
+export declare function incidentSlaStatusTone(status: IncidentSlaStatus | string | null | undefined, exceptionStatus?: SlaExceptionStatus | string | null): SlaTone;
+export declare function slaOverallStateTone(state: SlaOverallState | string | null | undefined): SlaTone;
+export declare function etaStatusTone(status: EtaStatus | string | null | undefined): SlaTone;
+/** "01:12", "12:05", "1:05:00", and overdue as "+00:45". */
+export declare function formatSlaClock(seconds: number | null | undefined): string;
+/** "15 sec", "2 min", "1 h 30 min", "1 d 2 h". */
+export declare function formatSlaTarget(seconds: number | null | undefined): string;
+/**
+ * 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 declare function liveRemainingSeconds(instance: Pick<IncidentSlaInstanceDto, 'status' | 'deadlineAt'>, nowMs: number, skewMs?: number): number | null;
+/**
+ * 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 declare function liveIncidentSlaStatus(instance: Pick<IncidentSlaInstanceDto, 'status' | 'warningAt' | 'atRiskAt' | 'deadlineAt' | 'completedAt'>, nowMs: number, skewMs?: number): IncidentSlaStatus;
+/** Statuses whose clock is running (or paused). */
+export declare function isOpenIncidentSlaStatus(status: IncidentSlaStatus | string | null | undefined): boolean;
+/** Stages in the order an emergency goes through them. */
+export declare const INCIDENT_SLA_STAGE_ORDER: readonly IncidentSlaStage[];
+export declare const SLA_ESCALATION_TRIGGER_LABELS: Readonly<Record<SlaEscalationTrigger, string>>;
+export declare const SLA_ESCALATION_LEVEL_LABELS: Readonly<Record<SlaEscalationLevel, string>>;
+export declare const SLA_NOTIFICATION_CHANNEL_LABELS: Readonly<Record<SlaNotificationChannel, string>>;
+export declare const SLA_ESCALATION_ACTION_LABELS: Readonly<Record<SlaEscalationAction, string>>;
+export declare const SLA_POLICY_SCOPE_LABELS: Readonly<Record<SlaPolicyScope, string>>;
+/** The emergency notifications, as clarion-incident asks for them. */
+export declare const EMERGENCY_NOTIFICATION_EVENT_LABELS: Readonly<Record<string, string>>;
+/** The SLA level of each priority (P1 = Critical ... P4 = Low). */
+export declare const INCIDENT_PRIORITY_SLA_LEVEL: Readonly<Record<string, SlaPriorityLevel>>;
+/** What each policy setting means, for the policy editor. */
+export declare const INCIDENT_SLA_SETTING_LABELS: Readonly<Record<string, {
+    label: string;
+    unit: string;
+    help: string;
+}>>;