clarion-shared-types 1.0.117 → 1.0.119

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

@@ -255,6 +255,22 @@ export interface IncidentSlaPolicyDto {
     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;
@@ -262,6 +278,34 @@ export interface IncidentSlaDurationPercentilesDto {
     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;
@@ -269,18 +313,344 @@ export interface IncidentSlaStageAnalyticsDto {
     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 {
-    from: string;
-    to: string;
+    range: IncidentSlaAnalyticsRangeDto;
     organizationId: number | null;
     controlCentreId: number | null;
-    incidents: number;
-    breachedIncidents: number;
+    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

@@ -1,4 +1,4 @@
-import { EmergencyIncidentStage, EtaStatus, IncidentActorType, IncidentArrivalSource, IncidentSlaEventType, IncidentSlaStage, IncidentSlaStatus, SlaExceptionReason, SlaExceptionStatus, SlaOverallState, SlaPauseReason } from '../enums/incident-sla-enums';
+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';
@@ -36,3 +36,20 @@ export declare function liveRemainingSeconds(instance: Pick<IncidentSlaInstanceD
 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;
+}>>;

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

@@ -199,6 +199,9 @@ export declare enum PermissionActions {
     READ_INCIDENT_SLA_POLICY = "read:incident-sla-policy",
     MANAGE_INCIDENT_SLA_POLICY = "manage:incident-sla-policy",
     READ_INCIDENT_SLA_ANALYTICS = "read:incident-sla-analytics",
+    USE_RESPONDER_APP = "use:responder-app",
+    RESPOND_RESPONSE_UNIT_DISPATCH = "respond:response-unit-dispatch",
+    REPORT_RESPONDER_POSITION = "report:responder-position",
     /** @deprecated Retiring: split into the connection / message / screened-message / analytics actions. */
     READ_ALERT_INTAKE = "read:alert-intake",
     /** @deprecated Retiring: split into the connection / message / screened-message / analytics actions. */

package/dist/types/modules/permission/enums/permissions-moudule.enum.d.ts

@@ -16,5 +16,6 @@ export declare enum PermissionsModule {
     ALERT_INTAKE = "Alert Intake",
     SAFETY = "Safety",
     PLACES = "Places",
-    INCIDENT_SLA = "Incident SLA"
+    INCIDENT_SLA = "Incident SLA",
+    RESPONDER = "Responder"
 }

package/dist/types/modules/responder/enums/responder-enums.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The responder app, as the control room sees it: field personnel (role
+ * `Responder`) linked to the response units they may staff, going on duty with
+ * one of them and reporting how each dispatch ended.
+ *
+ * The admin's mirror of grm-shared-library `src/modules/responder` - the string
+ * values MUST stay identical to the backend's (pinned by responder-display.spec.ts).
+ */
+/** A duty session's own lifecycle. One session is ACTIVE per responder at most. */
+export declare enum ResponderDutySessionStatus {
+    ACTIVE = "ACTIVE",
+    ENDED = "ENDED"
+}
+/** Why a duty session ended. */
+export declare enum ResponderDutyEndReason {
+    /** The responder went off duty in the app. */
+    RESPONDER = "RESPONDER",
+    /** The control room ended it (update:response-unit). */
+    CONTROL_CENTRE = "CONTROL_CENTRE",
+    /** The responder was removed from the unit while on duty with it. */
+    MEMBERSHIP_REMOVED = "MEMBERSHIP_REMOVED",
+    /** The unit was deactivated or deleted while the responder was on duty with it. */
+    UNIT_DEACTIVATED = "UNIT_DEACTIVATED"
+}
+/** How a response ended, as the responder reports it. */
+export declare enum ResponderReportOutcome {
+    RESOLVED_ON_SCENE = "RESOLVED_ON_SCENE",
+    HANDED_OVER = "HANDED_OVER",
+    REFERRED = "REFERRED",
+    NO_ACTION_REQUIRED = "NO_ACTION_REQUIRED",
+    FALSE_ALARM = "FALSE_ALARM",
+    UNABLE_TO_LOCATE = "UNABLE_TO_LOCATE",
+    OTHER = "OTHER"
+}
+/**
+ * Machine-readable refusals of the responder endpoints, in the error body's
+ * `code` (or `details.code` behind the gateway) - the same
+ * `{statusCode, code, message, ...details}` envelope the dispatch endpoints use.
+ */
+export declare enum ResponderErrorCode {
+    /** The caller does not hold the Responder role. */
+    NOT_A_RESPONDER = "RESPONDER_NOT_A_RESPONDER",
+    /** The responder account has no control centre, so nothing can be scoped. */
+    NO_CONTROL_CENTRE = "RESPONDER_NO_CONTROL_CENTRE",
+    UNIT_NOT_FOUND = "RESPONDER_UNIT_NOT_FOUND",
+    /** The caller is not a member of that unit. */
+    NOT_A_UNIT_MEMBER = "RESPONDER_NOT_A_UNIT_MEMBER",
+    UNIT_INACTIVE = "RESPONDER_UNIT_INACTIVE",
+    /** Already on duty with ANOTHER unit; end that duty first. `details.activeDuty` names it. */
+    ALREADY_ON_DUTY = "RESPONDER_ALREADY_ON_DUTY",
+    NOT_ON_DUTY = "RESPONDER_NOT_ON_DUTY",
+    /** Membership: the user is not a Responder of the unit's organization and control centre. */
+    USER_NOT_ELIGIBLE = "RESPONDER_USER_NOT_ELIGIBLE",
+    ALREADY_A_MEMBER = "RESPONDER_ALREADY_A_MEMBER",
+    MEMBERSHIP_NOT_FOUND = "RESPONDER_MEMBERSHIP_NOT_FOUND",
+    /** The dispatch does not exist or is not for one of the caller's units (never says which). */
+    DISPATCH_NOT_FOUND = "RESPONDER_DISPATCH_NOT_FOUND",
+    /** The move is not one a responder may make from the current status. `details.currentStatus`. */
+    INVALID_STATUS_TRANSITION = "RESPONDER_INVALID_STATUS_TRANSITION",
+    REASON_REQUIRED = "RESPONDER_REASON_REQUIRED",
+    DECLINE_NOT_ALLOWED = "RESPONDER_DECLINE_NOT_ALLOWED",
+    MANUAL_ARRIVAL_NOT_ALLOWED = "RESPONDER_MANUAL_ARRIVAL_NOT_ALLOWED",
+    /** Completing needs the response report first (organization policy). */
+    REPORT_REQUIRED = "RESPONDER_REPORT_REQUIRED",
+    /** A report can only be written once the unit reached the scene. */
+    REPORT_NOT_ALLOWED = "RESPONDER_REPORT_NOT_ALLOWED",
+    /** The report changed since the version the client edited. `details.currentVersion`. */
+    REPORT_VERSION_CONFLICT = "RESPONDER_REPORT_VERSION_CONFLICT",
+    /** The incident is closed or archived, so its reports can no longer be amended. */
+    REPORT_LOCKED = "RESPONDER_REPORT_LOCKED",
+    /** A required report field or checklist item is missing. `details.missing`. */
+    REPORT_INCOMPLETE = "RESPONDER_REPORT_INCOMPLETE",
+    /** An attachment id is not a file the caller may link. */
+    ATTACHMENT_NOT_READABLE = "RESPONDER_ATTACHMENT_NOT_READABLE"
+}

package/dist/types/modules/responder/index.d.ts

@@ -0,0 +1,3 @@
+export * from './enums/responder-enums';
+export * from './interfaces/responder.dto';
+export * from './utils/responder-display.util';

package/dist/types/modules/responder/interfaces/responder.dto.d.ts

@@ -0,0 +1,87 @@
+import { ResponderDutyEndReason, ResponderDutySessionStatus, ResponderReportOutcome } from '../enums/responder-enums';
+/**
+ * A responder linked to a unit, as the unit screen lists them.
+ * `GET|POST /api/response-units/:id/responders`.
+ */
+export interface ResponseUnitResponder {
+    id: number;
+    responseUnitId: number;
+    userId: number;
+    organizationId: number;
+    controlCentreId: number | null;
+    createdByUserId: number | null;
+    createdAt: string;
+    /** The account, when clarion-authentication could be read; null otherwise. */
+    user: {
+        id: number;
+        name: string;
+        email: string | null;
+        phoneNumber: string | null;
+    } | null;
+    /** Set while this responder is on duty with THIS unit. */
+    activeDuty: {
+        sessionId: number;
+        startedAt: string;
+    } | null;
+}
+/** `POST /api/response-units/:id/responders` - link a Responder account to a unit. */
+export interface AddResponseUnitResponderRequest {
+    userId: number;
+}
+/** `POST /api/response-units/:id/responders/:userId/end-duty` - the control room ends someone's duty. */
+export interface EndResponderDutyRequest {
+    /** At most RESPONDER_DUTY_END_REASON_MAX_LENGTH characters. */
+    reason?: string;
+}
+/** One stretch of duty: a responder staffing one unit. */
+export interface ResponderDutySession {
+    id: number;
+    userId: number;
+    responseUnitId: number;
+    /** Copied at start so the record reads right after a rename. */
+    responseUnitName: string;
+    organizationId: number;
+    controlCentreId: number | null;
+    status: ResponderDutySessionStatus;
+    startedAt: string;
+    endedAt: string | null;
+    endReason: ResponderDutyEndReason | null;
+    endReasonText: string | null;
+    /** Who ended it - the responder, or the control-room user. */
+    endedByUserId: number | null;
+}
+/** One answer on a responder report's closure checklist. */
+export interface ResponderReportChecklistAnswer {
+    /** The organization policy's stable item id (the label lives in the policy). */
+    itemId: string;
+    checked: boolean;
+}
+/**
+ * What the responder reported about one dispatch. One per dispatch, amended in
+ * versions. `GET /api/incidents/:id/responder-reports` lists an incident's.
+ */
+export interface ResponderDispatchReport {
+    id: number;
+    reference: string;
+    dispatchId: number;
+    incidentId: number;
+    responseUnitId: number;
+    submittedByUserId: number;
+    /** Starts at 1; every amendment adds one. */
+    version: number;
+    summary: string;
+    actionsTaken: string | null;
+    outcome: ResponderReportOutcome;
+    personsContacted: string | null;
+    handoverTo: string | null;
+    followUpRequired: boolean;
+    followUpNotes: string | null;
+    remarks: string | null;
+    checklist: ResponderReportChecklistAnswer[];
+    /** dms file ids; the files are also appended to the incident's attachments. */
+    attachmentIds: number[];
+    submittedAt: string;
+    updatedAt: string;
+    /** Whether the CALLER may still amend it (submitter, incident not closed) - always false for the control room. */
+    amendable: boolean;
+}

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

@@ -0,0 +1,26 @@
+import { ResponderDutyEndReason, ResponderDutySessionStatus, ResponderReportOutcome } from '../enums/responder-enums';
+import { ResponderReportChecklistAnswer, ResponseUnitResponder } from '../interfaces/responder.dto';
+/** The backend's limit on a duty-end reason (grm-shared-library RESPONDER_FIELD_LIMITS.dutyEndReason). */
+export declare const RESPONDER_DUTY_END_REASON_MAX_LENGTH = 300;
+export declare const RESPONDER_REPORT_OUTCOME_LABELS: Readonly<Record<ResponderReportOutcome, string>>;
+export declare const RESPONDER_DUTY_END_REASON_LABELS: Readonly<Record<ResponderDutyEndReason, string>>;
+export declare const RESPONDER_DUTY_SESSION_STATUS_LABELS: Readonly<Record<ResponderDutySessionStatus, string>>;
+/** The colour an outcome is shown in: settled is green, passed on is blue, not found is amber, the rest neutral. */
+export type ResponderReportOutcomeTone = 'success' | 'info' | 'warning' | 'grey';
+export declare function responderReportOutcomeTone(outcome: ResponderReportOutcome | string | null | undefined): ResponderReportOutcomeTone;
+/** The outcome's label, or the raw value when this package does not know it yet. */
+export declare function responderReportOutcomeLabel(outcome: ResponderReportOutcome | string | null | undefined): string;
+/** The end reason's label, or the raw value when this package does not know it yet. */
+export declare function responderDutyEndReasonLabel(reason: ResponderDutyEndReason | string | null | undefined): string;
+/**
+ * A checklist item id as words, for a screen that has the answers but not the
+ * organization's policy (where the labels live): "scene-made-safe",
+ * "scene_made_safe" and "sceneMadeSafe" all read "Scene made safe".
+ */
+export declare function humanizeResponderChecklistItem(itemId: string | null | undefined): string;
+/** "3 of 4 confirmed"; '' for an empty checklist. */
+export declare function describeResponderChecklist(checklist: readonly ResponderReportChecklistAnswer[] | null | undefined): string;
+/** The responder's name - or, when their account could not be read, its number. */
+export declare function responderDisplayName(responder: Pick<ResponseUnitResponder, 'userId' | 'user'>): string;
+/** "jane@example.com · +254 712 345678", whichever of the two the account has. */
+export declare function responderContactLine(responder: Pick<ResponseUnitResponder, 'user'>): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarion-shared-types",
-  "version": "1.0.117",
+  "version": "1.0.119",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",