grm-shared-library 1.1.240 → 1.1.242

package/dist/types/modules/responder/interfaces/responder-dispatch.d.ts

@@ -0,0 +1,144 @@
+import { ResponseUnitDispatchStatus } from '../../dispatch/enums/response-unit-dispatch-status.enum';
+import { ResponseUnitDispatchTransitionSource } from '../../dispatch/enums/response-unit-dispatch-transition-source.enum';
+import { ResponderArrivalMethod, ResponderReportOutcome, ResponderTrackingMode } from '../enums/responder.enums';
+/** The incident as a dispatched responder sees it. */
+export interface ResponderIncidentSummary {
+    id: number;
+    /** `#<id>` - the reference the control room quotes. */
+    reference: string;
+    class: string;
+    emergencyType: string | null;
+    status: string;
+    priority: string;
+    categoryName: string | null;
+    typeName: string | null;
+    description: string | null;
+    /** Null when the incident has no usable coordinates. */
+    location: {
+        latitude: number;
+        longitude: number;
+    } | null;
+    physicalAddress: string | null;
+    isAnonymous: boolean;
+    /** Null when anonymous, or when the organization hides reporter contact from responders. */
+    reporter: {
+        name: string | null;
+        phoneNumber: string | null;
+    } | null;
+    /** The incident chat, when it has one. */
+    conversationId: string | null;
+    organizationId: number;
+    controlCentreId: number | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Whether the responder's report exists, without its body. */
+export interface ResponderReportState {
+    submitted: boolean;
+    reportId: number | null;
+    version: number | null;
+    submittedAt: string | null;
+}
+/** One dispatch of one of the responder's units, with its incident. */
+export interface ResponderDispatch {
+    id: number;
+    reference: string;
+    incidentId: number;
+    responseUnitId: number;
+    responseUnitName: string;
+    responseUnitType: string | null;
+    status: ResponseUnitDispatchStatus;
+    statusChangedAt: string;
+    statusSource: ResponseUnitDispatchTransitionSource;
+    statusReason: string | null;
+    dispatchedAt: string;
+    acknowledgedAt: string | null;
+    enRouteAt: string | null;
+    onSceneAt: string | null;
+    completedAt: string | null;
+    cancelledAt: string | null;
+    rejectedAt: string | null;
+    arrivalSource: string | null;
+    /** What the dispatcher wrote when sending the unit. */
+    notes: string | null;
+    /** Distance from the unit to the incident at dispatch time. */
+    distanceMetres: number | null;
+    /** The statuses THIS caller may set next, already filtered by policy. */
+    allowedStatuses: ResponseUnitDispatchStatus[];
+    report: ResponderReportState;
+    incident: ResponderIncidentSummary;
+}
+/** Another unit sent to the same incident. */
+export interface ResponderCoResponder {
+    dispatchId: number;
+    responseUnitId: number;
+    responseUnitName: string;
+    responseUnitType: string | null;
+    status: ResponseUnitDispatchStatus;
+    dispatchedAt: string;
+}
+/** `GET /responder/dispatches/:dispatchId`. */
+export interface ResponderDispatchDetail extends ResponderDispatch {
+    otherUnits: ResponderCoResponder[];
+    /** What the responder recorded when arriving, if they did. */
+    arrivalEvidence: ResponderArrivalEvidence | null;
+}
+/** What a responder's arrival rested on - stored with the dispatch for the audit. */
+export interface ResponderArrivalEvidence {
+    method: ResponderArrivalMethod;
+    latitude: number | null;
+    longitude: number | null;
+    accuracyMetres: number | null;
+    /** Distance from the fix to the incident, computed by the server. */
+    distanceMetres: number | null;
+    recordedAt: string | null;
+    reason: string | null;
+}
+export interface ResponderDispatchPage {
+    data: ResponderDispatch[];
+    meta: {
+        total: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+    };
+}
+/** `GET|POST /responder/dispatches/:dispatchId/report`. */
+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: {
+        itemId: string;
+        checked: boolean;
+    }[];
+    attachmentIds: number[];
+    submittedAt: string;
+    updatedAt: string;
+    /** Whether the caller may still amend it (submitter, incident not closed). */
+    amendable: boolean;
+}
+/** `POST /responder/positions`. */
+export interface ResponderPositionBatchResult {
+    accepted: number;
+    rejected: number;
+    /** Why individual samples were refused (`TOO_OLD`, `IN_FUTURE`, `INACCURATE`, `INVALID`). */
+    rejectedReasons: Record<string, number>;
+    responseUnitId: number | null;
+    trackingMode: ResponderTrackingMode;
+}

package/dist/types/modules/responder/interfaces/responder-policy.d.ts

@@ -0,0 +1,55 @@
+import { ResponderReportField } from '../enums/responder.enums';
+/** One item of the closure checklist an organization asks its responders to confirm. */
+export interface ResponderChecklistItem {
+    /** Stable id, so an answer survives the label being reworded. */
+    id: string;
+    label: string;
+    required: boolean;
+}
+/**
+ * An organization's operational rules for its responders. Trusted configuration:
+ * served by clarion-organization, enforced by the services that own each rule.
+ */
+export interface ResponderPolicy {
+    location: {
+        onDutyIntervalSeconds: number;
+        activeIntervalSeconds: number;
+        distanceFilterMetres: number;
+        maxAccuracyMetres: number;
+        staleAfterSeconds: number;
+    };
+    arrival: {
+        /** Within this distance of the incident a GPS arrival is accepted. */
+        radiusMetres: number;
+        /** Whether a responder outside the radius (or without a fix) may confirm arrival by hand. */
+        allowManualConfirmation: boolean;
+        manualReasonRequired: boolean;
+    };
+    dispatch: {
+        allowDecline: boolean;
+        declineReasonRequired: boolean;
+    };
+    report: {
+        /** The responder cannot mark the dispatch COMPLETED before submitting a report. */
+        requiredToComplete: boolean;
+        requiredFields: ResponderReportField[];
+        checklist: ResponderChecklistItem[];
+        minPhotos: number;
+    };
+    evidence: {
+        allowPhotos: boolean;
+        allowDocuments: boolean;
+        allowVideo: boolean;
+        maxImageMegabytes: number;
+        maxDocumentMegabytes: number;
+        maxVideoMegabytes: number;
+    };
+    reporterContact: {
+        /** Whether a responder sees the (non-anonymous) reporter's name and number. */
+        visible: boolean;
+    };
+}
+/** A partial override as stored on the organization; anything absent keeps the default. */
+export type ResponderPolicyOverride = {
+    [K in keyof ResponderPolicy]?: Partial<ResponderPolicy[K]>;
+};

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

@@ -0,0 +1,113 @@
+import { ResponseUnitAvailability } from '../../response-unit/enums/response-unit/response-unit-availability.enum';
+import { ResponderDutyEndReason, ResponderDutySessionStatus } from '../enums/responder.enums';
+import { ResponderPolicy } from './responder-policy';
+/** A unit as the responder app shows it: enough to pick it and to recognise it. */
+export interface ResponderUnitSummary {
+    id: number;
+    name: string;
+    /** `Vehicle`, `Person` or `Team`. */
+    type: string;
+    /** Vehicle units: `Ambulance`, `Security`, ... */
+    vehicleType: string | null;
+    registrationNumber: string | null;
+    /** The unit's own phone (vehicle / person units); teams have none. */
+    phoneNumber: string | null;
+    capabilities: string[];
+    isActive: boolean;
+    /** The manual status the control room sets (`Operational`, `On Duty`, ...). */
+    operationalStatus: string | null;
+    /** From the manual status only; an active dispatch makes a unit ENGAGED in clarion-incident. */
+    availability: ResponseUnitAvailability;
+    organizationId: number;
+    controlCentreId: number | null;
+    station: {
+        name?: string | null;
+        address?: string | null;
+    } | null;
+}
+/** 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;
+}
+export interface ResponderOrganizationSummary {
+    id: number;
+    name: string;
+    logo: string | null;
+    phoneNumber: string | null;
+    email: string | null;
+    countryCode: string | null;
+}
+export interface ResponderControlCentreSummary {
+    id: number;
+    name: string;
+    phoneNumber: string | null;
+    email: string | null;
+    logo: string | null;
+}
+/** `GET /responder/me` - everything the app needs to know who and where the responder is. */
+export interface ResponderProfile {
+    userId: number;
+    organization: ResponderOrganizationSummary;
+    controlCentre: ResponderControlCentreSummary | null;
+    /** The units the responder may go on duty with (memberships), active ones first. */
+    units: ResponderUnitSummary[];
+    activeDuty: ResponderDutySession | null;
+    /** The organization's effective policy (defaults merged with its override). */
+    policy: ResponderPolicy;
+    /** The server's clock, so the app can tell how far off the phone's is. */
+    serverTime: string;
+}
+/** A responder linked to a unit, as the admin's unit screen lists them. */
+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;
+}
+/** Internal: a user's units, duty and policy - for clarion-incident and clarion-response-tracking. */
+export interface ResponderInternalUnits {
+    userId: number;
+    organizationId: number | null;
+    controlCentreId: number | null;
+    /** Units the user is a member of (whatever their status). */
+    responseUnitIds: number[];
+    activeDuty: {
+        sessionId: number;
+        responseUnitId: number;
+        startedAt: string;
+    } | null;
+    policy: ResponderPolicy;
+}
+/** Internal: who is on duty with a unit - for clarion-notification's dispatch pushes. */
+export interface ResponderInternalUnitOnDuty {
+    responseUnitId: number;
+    userIds: number[];
+}

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

@@ -0,0 +1,24 @@
+import { ResponseUnitDispatchStatus } from '../../dispatch/enums/response-unit-dispatch-status.enum';
+import { ResponderPolicy, ResponderPolicyOverride } from '../interfaces/responder-policy';
+/**
+ * The organization's effective policy: the defaults with its override laid over
+ * them, part by part. Unknown keys in a stored override are ignored, so an old
+ * row can never smuggle a setting the code no longer knows into the app.
+ */
+export declare function resolveResponderPolicy(override: ResponderPolicyOverride | null | undefined): ResponderPolicy;
+/** Whether a responder may move a dispatch from `from` to `to`, before policy. */
+export declare function canResponderTransitionDispatch(from: ResponseUnitDispatchStatus, to: ResponseUnitDispatchStatus): boolean;
+/** The statuses a responder may set next, with the policy applied (no decline when it is off). */
+export declare function responderAllowedDispatchStatuses(from: ResponseUnitDispatchStatus, policy: Pick<ResponderPolicy, 'dispatch'>): ResponseUnitDispatchStatus[];
+/** What a responder's report is missing under the policy - field names and `checklist:<id>`. */
+export declare function missingResponderReportItems(report: {
+    summary?: string | null;
+    actionsTaken?: string | null;
+    personsContacted?: string | null;
+    handoverTo?: string | null;
+    remarks?: string | null;
+    checklist?: {
+        itemId: string;
+        checked: boolean;
+    }[] | null;
+}, policy: Pick<ResponderPolicy, 'report'>): string[];

package/dist/types/modules/role/data/roles.data.d.ts

@@ -1,2 +1,9 @@
 import { Role } from "../interfaces/role";
+/**
+ * The responder app, for the people who staff a response unit. Each action is
+ * confined to the caller's own memberships, duty and unit by the service that
+ * owns it (clarion-organization, clarion-incident, clarion-response-tracking),
+ * so holding one says nothing about anybody else's unit.
+ */
+export declare const RESPONDER_APP_PERMISSIONS: string[];
 export declare const ROLES_DATA: Role[];

package/dist/types/modules/safety/constants/safety-history.const.d.ts

@@ -0,0 +1,31 @@
+import { FollowMeAuditEventType, FollowMeSafetyEventType } from '../enums/follow-me.enums';
+import { SafetyCheckAuditEventType } from '../enums/safety-enums';
+/** Paging and map bounds of the app's Safety History. */
+export declare const SAFETY_HISTORY_LIMITS: {
+    readonly defaultPageSize: 20;
+    readonly maxPageSize: 50;
+    /** Most fixes a history map is sent (the path is thinned to this in clarion-gis). */
+    readonly mapMaxPoints: 500;
+    /**
+     * After an SOS the session's trip carries on as the incident's trip. The
+     * session's map ends at the SOS, plus this much for a device clock running a
+     * little ahead; the rest belongs to the incident and its own history.
+     */
+    readonly pathGraceSeconds: 60;
+};
+/**
+ * The Safety Check audit entries its owner sees in their history - what they
+ * did and what happened to them. Plumbing (workflow start, activation, SOS
+ * retries) stays in the admin view.
+ */
+export declare const SAFETY_CHECK_HISTORY_EVENTS: readonly SafetyCheckAuditEventType[];
+/** The same for a Follow Me journey's audit trail. External-link and chat plumbing stay out. */
+export declare const FOLLOW_ME_HISTORY_EVENTS: readonly FollowMeAuditEventType[];
+/**
+ * What the Follow Me monitors observed that the owner sees: confirmed findings
+ * only. Suspicions that cleared themselves (off route then back on, a crash
+ * report the checks rejected, a stop explained by traffic) and pure bookkeeping
+ * (ETA and route recalculation, already in the audit trail) are left out, so a
+ * history never says something happened that the monitors did not conclude.
+ */
+export declare const FOLLOW_ME_HISTORY_MONITOR_EVENTS: readonly FollowMeSafetyEventType[];

package/dist/types/modules/safety/constants/safety-integration.const.d.ts

@@ -48,6 +48,10 @@ export declare const SAFETY_INTERNAL_PATHS: {
     readonly shareTrip: (tripId: string) => string;
     readonly stopPrivateTrip: (tripId: string) => string;
     readonly tripSummary: (tripId: string) => string;
+    /** clarion-gis: a trip's recorded path thinned for a map (Safety History). */
+    readonly tripPathSnapshot: (tripId: string) => string;
+    /** clarion-incident: one incident, read AS the caller (their user context is forwarded). */
+    readonly incident: (incidentId: number) => string;
 };
 /**
  * go_router locations in clarion_mobile that pushes deep-link to. A push route

package/dist/types/modules/safety/dtos/safety-history.dto.d.ts

@@ -0,0 +1,20 @@
+import { FollowMeStatus } from '../enums/follow-me.enums';
+import { SafetyCheckStatus } from '../enums/safety-check-status.enum';
+/**
+ * The app's Safety Check history, newest first. Only NARROWS the caller's own
+ * checks: there is deliberately no user or organization filter - both come from
+ * the trusted context.
+ */
+export declare class SafetyCheckHistoryQueryDto {
+    page?: number;
+    limit?: number;
+    status?: SafetyCheckStatus;
+    sosOnly?: boolean;
+}
+/** The app's Follow Me history, newest first - the caller's own journeys only. */
+export declare class FollowMeHistoryQueryDto {
+    page?: number;
+    limit?: number;
+    status?: FollowMeStatus;
+    sosOnly?: boolean;
+}

package/dist/types/modules/safety/enums/safety-history.enums.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Whether a session's recorded path can be drawn in its history.
+ *
+ *   RECORDED      clarion-gis holds at least one location for the session (a
+ *                 track point, or the location the device reported at start).
+ *   NOT_RECORDED  nothing was ever recorded: no trip was opened, or it holds no
+ *                 location. The map says so - it never shows where the user is now.
+ *   UNAVAILABLE   clarion-gis could not be read just now. Try again later; the
+ *                 rest of the history does not depend on it.
+ */
+export declare enum SafetyHistoryPathStatus {
+    RECORDED = "RECORDED",
+    NOT_RECORDED = "NOT_RECORDED",
+    UNAVAILABLE = "UNAVAILABLE"
+}
+/**
+ * Where a history timeline entry comes from: the session's lifecycle audit trail
+ * (what the user, the timer or the platform did), or - Follow Me only - what the
+ * journey monitors observed.
+ */
+export declare enum SafetyHistoryEventSource {
+    LIFECYCLE = "LIFECYCLE",
+    MONITOR = "MONITOR"
+}

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

@@ -2,21 +2,25 @@ export * from './enums/safety-check-status.enum';
 export * from './enums/safety-enums';
 export * from './enums/safety-error-code.enum';
 export * from './enums/follow-me.enums';
+export * from './enums/safety-history.enums';
 export * from './constants/safety-check-limits.const';
 export * from './constants/safety-taxonomy.const';
 export * from './constants/safety-integration.const';
 export * from './constants/follow-me.const';
+export * from './constants/safety-history.const';
 export * from './interfaces/safety-check';
 export * from './interfaces/safety-check-event';
 export * from './interfaces/safety-alert-context';
 export * from './interfaces/follow-me';
 export * from './interfaces/safety-analytics';
+export * from './interfaces/safety-history';
 export * from './dtos/safety-check.dto';
 export * from './dtos/safety-admin.dto';
 export * from './dtos/safety-internal.dto';
 export * from './dtos/safety-alert-context.dto';
 export * from './dtos/follow-me.dto';
 export * from './dtos/safety-analytics.dto';
+export * from './dtos/safety-history.dto';
 export * from './utils/safety-check-state-machine';
 export * from './utils/safety-check-timing.util';
 export * from './utils/follow-me-state-machine';