grm-shared-library 1.1.222 → 1.1.224

package/dist/types/modules/safety/enums/follow-me.enums.d.ts

@@ -0,0 +1,218 @@
+/**
+ * Lifecycle of one Follow Me session. clarion-safety is the only writer; every
+ * transition is validated against FOLLOW_ME_TRANSITIONS and applied as a
+ * conditional update, exactly as a Safety Check is.
+ *
+ *   CREATED        accepted and persisted; the trip, the timer and the guardian
+ *                  requests are being set up. Already counts as live.
+ *   ACTIVE         the journey is being shared and monitored.
+ *   PROMPTING      a safety prompt is open (see FollowMePromptStatus); an SOS is
+ *                  raised if it is not answered.
+ *   ARRIVED        the destination was reached. Terminal, successful.
+ *   SOS_TRIGGERED  an SOS was raised - a prompt went unanswered or the user
+ *                  asked for one. Follow Me is over; the recorded trip goes on as
+ *                  the incident's trip and followers move to the SOS view.
+ *   STOPPED        the user ended it. Terminal.
+ *   EXPIRED        the chosen duration ran out before arrival. Terminal; never
+ *                  raises an SOS by itself. Deferred while a prompt is open.
+ *   CANCELLED      ended by the platform rather than the user (e.g. sign-out).
+ *   FAILED         the SOS could not be raised because clarion-incident refused
+ *                  it outright. Terminal; the user and guardians are told to act.
+ *
+ * Deliberately NOT a status: whether live sharing is healthy. That is
+ * FollowMeTrackingHealth, derived from when the last location arrived - a
+ * session with a flat battery is still a session.
+ */
+export declare enum FollowMeStatus {
+    CREATED = "CREATED",
+    ACTIVE = "ACTIVE",
+    PROMPTING = "PROMPTING",
+    ARRIVED = "ARRIVED",
+    SOS_TRIGGERED = "SOS_TRIGGERED",
+    STOPPED = "STOPPED",
+    EXPIRED = "EXPIRED",
+    CANCELLED = "CANCELLED",
+    FAILED = "FAILED"
+}
+/**
+ * One guardian's relationship to a session - separate from the session's own
+ * state. A guardian stopping following never ends the session.
+ *
+ *   PENDING            asked, not yet answered.
+ *   ACCEPTED           following (whether they are looking right now is
+ *                      presence, not state).
+ *   DECLINED           said no. May still accept while the session is live.
+ *   STOPPED_FOLLOWING  followed, then stopped. May follow again while live.
+ *   EXPIRED            the session ended; every open participation ends with it.
+ */
+export declare enum FollowMeParticipantStatus {
+    PENDING = "PENDING",
+    ACCEPTED = "ACCEPTED",
+    DECLINED = "DECLINED",
+    STOPPED_FOLLOWING = "STOPPED_FOLLOWING",
+    EXPIRED = "EXPIRED"
+}
+/** Who a participant is. App guardians sign in; external guardians hold a link. */
+export declare enum FollowMeParticipantKind {
+    SYSTEM_GUARDIAN = "SYSTEM_GUARDIAN",
+    EXTERNAL_GUARDIAN = "EXTERNAL_GUARDIAN"
+}
+export declare enum FollowMeTransportMode {
+    WALK = "WALK",
+    DRIVE = "DRIVE",
+    TWO_WHEELER = "TWO_WHEELER",
+    PUBLIC_TRANSPORT = "PUBLIC_TRANSPORT",
+    /** A taxi or ride-hail: routed as driving, monitored as a vehicle. */
+    RIDE_SERVICE = "RIDE_SERVICE"
+}
+export declare enum FollowMeWaypointKind {
+    START = "START",
+    STOP = "STOP",
+    DESTINATION = "DESTINATION"
+}
+/** A route is never replaced silently: the plan and every recalculation are kept. */
+export declare enum FollowMeRouteKind {
+    ORIGINAL = "ORIGINAL",
+    RECALCULATED = "RECALCULATED"
+}
+/** What made Follow Me ask the user whether they are safe. */
+export declare enum FollowMeSafetyTrigger {
+    CRASH_SUSPECTED = "CRASH_SUSPECTED",
+    ROUTE_DEVIATION = "ROUTE_DEVIATION",
+    PROLONGED_STOP = "PROLONGED_STOP",
+    ETA_OVERDUE = "ETA_OVERDUE"
+}
+export declare enum FollowMePromptStatus {
+    ACTIVE = "ACTIVE",
+    CONFIRMED_OK = "CONFIRMED_OK",
+    /** Unanswered - the SOS followed. */
+    EXPIRED = "EXPIRED",
+    /** Closed without an answer for another reason: the session ended, or the user pressed SOS. */
+    CANCELLED = "CANCELLED"
+}
+/**
+ * What the monitors observed (follow_me_safety_events). Evidence, not decisions:
+ * most of these never become a prompt.
+ */
+export declare enum FollowMeSafetyEventType {
+    OFF_ROUTE_SUSPECTED = "OFF_ROUTE_SUSPECTED",
+    BACK_ON_ROUTE = "BACK_ON_ROUTE",
+    ROUTE_RECALCULATED = "ROUTE_RECALCULATED",
+    DEVIATION_CONFIRMED = "DEVIATION_CONFIRMED",
+    PROLONGED_STOP_DETECTED = "PROLONGED_STOP_DETECTED",
+    STOP_DEFERRED_FOR_TRAFFIC = "STOP_DEFERRED_FOR_TRAFFIC",
+    ETA_RECALCULATED = "ETA_RECALCULATED",
+    ETA_OVERDUE_DETECTED = "ETA_OVERDUE_DETECTED",
+    CRASH_REPORTED = "CRASH_REPORTED",
+    CRASH_REJECTED = "CRASH_REJECTED",
+    ARRIVAL_DETECTED = "ARRIVAL_DETECTED",
+    TRACKING_STALE = "TRACKING_STALE",
+    TRACKING_RESTORED = "TRACKING_RESTORED"
+}
+/** Is the session's live location actually live? Derived from lastLocationAt. */
+export declare enum FollowMeTrackingHealth {
+    LIVE = "LIVE",
+    /** Nothing for a while - show "last seen N min ago", never "live". */
+    STALE = "STALE",
+    /** No location has arrived yet. */
+    NO_SIGNAL = "NO_SIGNAL"
+}
+/** Audit trail (follow_me_audit_events). Never carries a location or a token. */
+export declare enum FollowMeAuditEventType {
+    CREATED = "CREATED",
+    ACTIVATED = "ACTIVATED",
+    TRACKING_STARTED = "TRACKING_STARTED",
+    TRACKING_UNAVAILABLE = "TRACKING_UNAVAILABLE",
+    WORKFLOW_STARTED = "WORKFLOW_STARTED",
+    WORKFLOW_START_FAILED = "WORKFLOW_START_FAILED",
+    CHAT_CREATED = "CHAT_CREATED",
+    GUARDIAN_INVITED = "GUARDIAN_INVITED",
+    GUARDIAN_ACCEPTED = "GUARDIAN_ACCEPTED",
+    GUARDIAN_DECLINED = "GUARDIAN_DECLINED",
+    GUARDIAN_STOPPED_FOLLOWING = "GUARDIAN_STOPPED_FOLLOWING",
+    EXTERNAL_LINK_ISSUED = "EXTERNAL_LINK_ISSUED",
+    EXTERNAL_LINK_USED = "EXTERNAL_LINK_USED",
+    ROUTE_RECALCULATED = "ROUTE_RECALCULATED",
+    PROMPT_STARTED = "PROMPT_STARTED",
+    PROMPT_CONFIRMED = "PROMPT_CONFIRMED",
+    PROMPT_EXPIRED = "PROMPT_EXPIRED",
+    PROMPT_CANCELLED = "PROMPT_CANCELLED",
+    SOS_TRIGGERED = "SOS_TRIGGERED",
+    SOS_INCIDENT_CREATED = "SOS_INCIDENT_CREATED",
+    SOS_INCIDENT_RETRY = "SOS_INCIDENT_RETRY",
+    SOS_FAILED = "SOS_FAILED",
+    ARRIVED = "ARRIVED",
+    STOPPED = "STOPPED",
+    EXPIRED = "EXPIRED",
+    CANCELLED = "CANCELLED"
+}
+/** Kafka event types (the `eventType` of FollowMeEvent), one topic each. */
+export declare enum FollowMeEventType {
+    STARTED = "FOLLOW_ME_STARTED",
+    GUARDIAN_RESPONDED = "FOLLOW_ME_GUARDIAN_RESPONDED",
+    PROMPTING = "FOLLOW_ME_PROMPTING",
+    SOS_TRIGGERED = "FOLLOW_ME_SOS_TRIGGERED",
+    ENDED = "FOLLOW_ME_ENDED"
+}
+/** Socket.IO `safety.event` types for Follow Me (FollowMeRealtimeEnvelope.type). */
+export declare enum FollowMeRealtimeEventType {
+    STARTED = "FOLLOW_ME_STARTED",
+    REQUEST = "FOLLOW_ME_REQUEST",
+    GUARDIAN_ACCEPTED = "FOLLOW_ME_GUARDIAN_ACCEPTED",
+    GUARDIAN_DECLINED = "FOLLOW_ME_GUARDIAN_DECLINED",
+    GUARDIAN_STOPPED_FOLLOWING = "FOLLOW_ME_GUARDIAN_STOPPED_FOLLOWING",
+    LOCATION_UPDATED = "FOLLOW_ME_LOCATION_UPDATED",
+    ROUTE_UPDATED = "FOLLOW_ME_ROUTE_UPDATED",
+    ETA_UPDATED = "FOLLOW_ME_ETA_UPDATED",
+    SAFETY_EVENT = "FOLLOW_ME_SAFETY_EVENT",
+    PROMPT_STARTED = "FOLLOW_ME_PROMPT_STARTED",
+    PROMPT_CONFIRMED = "FOLLOW_ME_PROMPT_CONFIRMED",
+    SOS_TRIGGERED = "FOLLOW_ME_SOS_TRIGGERED",
+    ARRIVED = "FOLLOW_ME_ARRIVED",
+    STOPPED = "FOLLOW_ME_STOPPED",
+    EXPIRED = "FOLLOW_ME_EXPIRED",
+    ENDED = "FOLLOW_ME_ENDED",
+    PROVIDER_UPDATED = "FOLLOW_ME_PROVIDER_UPDATED"
+}
+/**
+ * Push `data.action` / `data.type` values for Follow Me (allow-listed by the
+ * app's notification_deep_link_coordinator.dart - changing one breaks installed
+ * apps).
+ */
+export declare enum FollowMePushAction {
+    /** To a guardian: somebody asked you to follow their journey. */
+    FOLLOW_ME_REQUEST = "FOLLOW_ME_REQUEST",
+    /** To the user: a guardian accepted or declined. */
+    FOLLOW_ME_GUARDIAN_RESPONDED = "FOLLOW_ME_GUARDIAN_RESPONDED",
+    /** To the user: confirm you are safe. */
+    FOLLOW_ME_PROMPT = "FOLLOW_ME_PROMPT",
+    /** To the user and followers: an SOS was raised from Follow Me. */
+    FOLLOW_ME_SOS_TRIGGERED = "FOLLOW_ME_SOS_TRIGGERED",
+    /** To followers (and the user when it ended without them): Follow Me ended. */
+    FOLLOW_ME_ENDED = "FOLLOW_ME_ENDED"
+}
+/** Machine-readable `code` on every Follow Me error. */
+export declare enum FollowMeErrorCode {
+    NOT_FOUND = "FOLLOW_ME_NOT_FOUND",
+    ALREADY_ACTIVE = "FOLLOW_ME_ALREADY_ACTIVE",
+    ALREADY_ENDED = "FOLLOW_ME_ENDED",
+    SOS_ALREADY_TRIGGERED = "FOLLOW_ME_SOS_ALREADY_TRIGGERED",
+    INVALID_TRANSITION = "FOLLOW_ME_INVALID_TRANSITION",
+    INVALID_DURATION = "FOLLOW_ME_INVALID_DURATION",
+    ROUTE_EXCEEDS_MAX_DURATION = "FOLLOW_ME_ROUTE_EXCEEDS_MAX_DURATION",
+    ROUTE_INVALID = "FOLLOW_ME_ROUTE_INVALID",
+    ROUTE_EXPIRED = "FOLLOW_ME_ROUTE_EXPIRED",
+    ROUTING_UNAVAILABLE = "FOLLOW_ME_ROUTING_UNAVAILABLE",
+    INVALID_REASON = "FOLLOW_ME_INVALID_REASON",
+    CUSTOM_REASON_REQUIRED = "FOLLOW_ME_CUSTOM_REASON_REQUIRED",
+    GUARDIAN_NOT_FOUND = "FOLLOW_ME_GUARDIAN_NOT_FOUND",
+    GUARDIANS_UNAVAILABLE = "FOLLOW_ME_GUARDIANS_UNAVAILABLE",
+    NO_RECIPIENTS = "FOLLOW_ME_NO_RECIPIENTS",
+    SERVICE_PROVIDER_NOT_ENTITLED = "FOLLOW_ME_SERVICE_PROVIDER_NOT_ENTITLED",
+    PROMPT_NOT_ACTIVE = "FOLLOW_ME_PROMPT_NOT_ACTIVE",
+    TRACKING_CLOSED = "FOLLOW_ME_TRACKING_CLOSED",
+    NOT_A_PARTICIPANT = "FOLLOW_ME_NOT_A_PARTICIPANT",
+    ACCESS_EXPIRED = "FOLLOW_ME_ACCESS_EXPIRED",
+    LOCATION_NOT_SHARED = "FOLLOW_ME_LOCATION_NOT_SHARED",
+    RATE_LIMITED = "FOLLOW_ME_RATE_LIMITED"
+}

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

@@ -1,9 +1,14 @@
-/** Why a Safety Check raised an SOS. */
+/**
+ * Why a safety feature raised an SOS. Shared by every safety feature (the name
+ * predates Follow Me).
+ */
 export declare enum SafetyCheckSosTrigger {
-    /** The prompt countdown ran out without the user confirming they were safe. */
+    /** Safety Check: the prompt countdown ran out without the user confirming they were safe. */
     MISSED_CHECK_IN = "MISSED_CHECK_IN",
-    /** The user pressed SOS from the Safety Check screen. */
-    USER_REQUESTED = "USER_REQUESTED"
+    /** The user pressed SOS from a safety feature's screen. */
+    USER_REQUESTED = "USER_REQUESTED",
+    /** Follow Me: a safety prompt (crash, deviation, stop, overdue) went unanswered. */
+    MISSED_SAFETY_PROMPT = "MISSED_SAFETY_PROMPT"
 }
 /** Who caused a Safety Check transition - recorded on every audit entry. */
 export declare enum SafetyCheckActorType {

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

@@ -1,13 +1,20 @@
 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 './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 './interfaces/safety-check';
 export * from './interfaces/safety-check-event';
+export * from './interfaces/safety-alert-context';
+export * from './interfaces/follow-me';
 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 './utils/safety-check-state-machine';
 export * from './utils/safety-check-timing.util';
+export * from './utils/follow-me-state-machine';

package/dist/types/modules/safety/interfaces/follow-me.d.ts

@@ -0,0 +1,377 @@
+import { GuardianAudience } from '../../alert-dispatch/interfaces/guardian-audience';
+import { GisRoutingProvider } from '../../gis/enums/routing.enum';
+import { TripPoint } from '../../gis/interfaces/trip-point';
+import { FollowMeAuditEventType, FollowMeEventType, FollowMeParticipantKind, FollowMeParticipantStatus, FollowMePromptStatus, FollowMeRealtimeEventType, FollowMeRouteKind, FollowMeSafetyEventType, FollowMeSafetyTrigger, FollowMeStatus, FollowMeTrackingHealth, FollowMeTransportMode, FollowMeWaypointKind } from '../enums/follow-me.enums';
+import { SafetyCheckSosTrigger } from '../enums/safety-enums';
+import { SafetyCheckActorType } from '../enums/safety-enums';
+import { SafetyCheckTripSummary } from './safety-check';
+/**
+ * Coordinates and address are null wherever the viewer may not see location (the
+ * admin detail without track access) - the label alone says "Home" or "Work".
+ */
+export interface FollowMeWaypointView {
+    sequence: number;
+    kind: FollowMeWaypointKind;
+    label: string;
+    address: string | null;
+    lat: number | null;
+    lng: number | null;
+    savedPlaceId: string | null;
+}
+/** A computed route as the session stores it. */
+export interface FollowMeRouteView {
+    id: string;
+    kind: FollowMeRouteKind;
+    provider: GisRoutingProvider;
+    transportMode: FollowMeTransportMode;
+    /** Null wherever the viewer may not see location. */
+    polyline: string | null;
+    distanceMeters: number;
+    durationSeconds: number;
+    staticDurationSeconds: number;
+    computedAt: string;
+    /** Why it was recalculated (deviation, ETA check...). Null for the original plan. */
+    reason: string | null;
+    warnings: string[];
+}
+/** The answer to a route preview; start references it by `routeToken`. */
+export interface FollowMeRoutePreview {
+    routeToken: string;
+    expiresAt: string;
+    transportMode: FollowMeTransportMode;
+    waypoints: FollowMeWaypointView[];
+    provider: GisRoutingProvider;
+    polyline: string;
+    distanceMeters: number;
+    durationSeconds: number;
+    staticDurationSeconds: number;
+    etaAt: string;
+    /** The journey would outlast Follow Me's 24 h maximum. */
+    exceedsMaxDuration: boolean;
+    /** What the setup screen should pre-select (travel time plus a buffer, capped at 24 h). */
+    suggestedDurationMinutes: number;
+    warnings: string[];
+}
+export interface FollowMePromptView {
+    id: string;
+    trigger: FollowMeSafetyTrigger;
+    status: FollowMePromptStatus;
+    startedAt: string;
+    /** When the visible countdown ends. */
+    deadlineAt: string;
+    countdownSeconds: number;
+    respondedAt: string | null;
+    /** What the prompt screen says caused it, in plain words. */
+    message: string;
+}
+/** A participant as the SESSION OWNER sees them. */
+export interface FollowMeParticipantView {
+    id: string;
+    kind: FollowMeParticipantKind;
+    status: FollowMeParticipantStatus;
+    guardianUserId: number | null;
+    displayName: string;
+    /** External guardians only, masked (+2547******78). */
+    maskedPhoneNumber: string | null;
+    invitedAt: string;
+    respondedAt: string | null;
+    /** Looked at the journey in the last minute. */
+    watchingNow: boolean;
+}
+/** The session as its OWNER sees it. Timestamps are server time; use serverTime for skew. */
+export interface FollowMeSessionView {
+    id: string;
+    status: FollowMeStatus;
+    reasonId: string | null;
+    reasonCode: string | null;
+    reasonLabel: string;
+    customReason: string | null;
+    durationMinutes: number;
+    startedAt: string;
+    plannedEndAt: string;
+    endedAt: string | null;
+    arrivedAt: string | null;
+    promptCountdownSeconds: number;
+    notifyGuardiansOnStartEnd: boolean;
+    notifyServiceProviderRequested: boolean;
+    notifyServiceProviderAllowed: boolean;
+    transportMode: FollowMeTransportMode | null;
+    waypoints: FollowMeWaypointView[];
+    /** The route being monitored (the latest recalculation, else the plan). */
+    currentRoute: FollowMeRouteView | null;
+    /** Live estimate; null without a destination. */
+    etaAt: string | null;
+    distanceRemainingMeters: number | null;
+    trackingHealth: FollowMeTrackingHealth;
+    lastLocationAt: string | null;
+    crashDetectionEnabled: boolean;
+    activePrompt: FollowMePromptView | null;
+    participants: FollowMeParticipantView[];
+    sosTrigger: SafetyCheckSosTrigger | null;
+    sosCause: FollowMeSafetyTrigger | null;
+    sosTriggeredAt: string | null;
+    incidentId: number | null;
+    tripId: string | null;
+    conversationId: string | null;
+    serverTime: string;
+}
+export interface FollowMeCurrentResponse {
+    session: FollowMeSessionView | null;
+    serverTime: string;
+}
+/**
+ * The journey as a FOLLOWER sees it - an app guardian, an external guardian on the
+ * web page, or provider staff. Never includes guardians' contact details.
+ */
+export interface FollowMeFollowerView {
+    sessionId: string;
+    status: FollowMeStatus;
+    owner: {
+        firstName: string;
+        userId: number | null;
+    };
+    reasonLabel: string;
+    startedAt: string;
+    plannedEndAt: string;
+    endedAt: string | null;
+    arrivedAt: string | null;
+    transportMode: FollowMeTransportMode | null;
+    waypoints: FollowMeWaypointView[];
+    currentRoute: Pick<FollowMeRouteView, 'polyline' | 'distanceMeters' | 'durationSeconds' | 'provider'> | null;
+    etaAt: string | null;
+    distanceRemainingMeters: number | null;
+    trackingHealth: FollowMeTrackingHealth;
+    /** Null once live access has ended, and for a caller who has not accepted. */
+    latestLocation: TripPoint | null;
+    /** Recent path (oldest first) since the `since` the caller sent; empty without live access. */
+    path: TripPoint[];
+    /** Pass as `since` next time. */
+    pathCursor: string | null;
+    /** Other followers: names and states for app guardians, a count on the web page. */
+    otherFollowers: {
+        displayName: string;
+        status: FollowMeParticipantStatus;
+    }[] | {
+        count: number;
+    };
+    providerParticipating: boolean;
+    activePromptTrigger: FollowMeSafetyTrigger | null;
+    incidentId: number | null;
+    myParticipation: {
+        participantId: string;
+        status: FollowMeParticipantStatus;
+    } | null;
+    /** App guardians who accepted: the session chat. */
+    conversationId: string | null;
+    serverTime: string;
+}
+/** Pending requests for an app guardian (checked after sign-in, not only on a push). */
+export interface FollowMeRequestSummary {
+    sessionId: string;
+    participantId: string;
+    ownerFirstName: string;
+    reasonLabel: string;
+    status: FollowMeParticipantStatus;
+    invitedAt: string;
+    plannedEndAt: string;
+}
+/** What the setup screens need, so client and server agree. */
+export interface FollowMeStartOptions {
+    limits: {
+        minDurationMinutes: number;
+        maxDurationMinutes: number;
+        minPromptCountdownSeconds: number;
+        maxPromptCountdownSeconds: number;
+        maxIntermediateStops: number;
+        customReasonMaxLength: number;
+    };
+    defaults: {
+        durationMinutes: number;
+        promptCountdownSeconds: number;
+        notifyServiceProvider: boolean;
+        notifyGuardiansOnStartEnd: boolean;
+        transportMode: FollowMeTransportMode;
+    };
+    tracking: {
+        locationIntervalSeconds: number;
+        distanceFilterMeters: number;
+        uploadIntervalSeconds: number;
+    };
+    crashDetection: Record<string, number | string | boolean> & {
+        enabledTransportModes: FollowMeTransportMode[];
+    };
+    serviceProvider: {
+        available: boolean;
+        tier: string | null;
+        degraded: boolean;
+    };
+    serverTime: string;
+}
+export interface FollowMeSafetyEventView {
+    id: string;
+    type: FollowMeSafetyEventType;
+    occurredAt: string;
+    promptId: string | null;
+    /** Metrics (distances, durations, confidence). Coordinates only for viewers allowed location. */
+    evidence: Record<string, unknown> | null;
+}
+export interface FollowMeAuditEntry {
+    id: string;
+    eventType: FollowMeAuditEventType;
+    fromStatus: FollowMeStatus | null;
+    toStatus: FollowMeStatus | null;
+    actorType: SafetyCheckActorType;
+    actorUserId: number | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+}
+export interface FollowMeAdminListItem {
+    id: string;
+    status: FollowMeStatus;
+    userId: number;
+    userName: string | null;
+    organizationId: number;
+    controlCentreId: number | null;
+    reasonLabel: string;
+    durationMinutes: number;
+    startedAt: string;
+    plannedEndAt: string;
+    endedAt: string | null;
+    destinationLabel: string | null;
+    transportMode: FollowMeTransportMode | null;
+    providerParticipation: boolean;
+    sosTriggeredAt: string | null;
+    incidentId: number | null;
+    createdAt: string;
+}
+export interface FollowMeAdminDetail {
+    session: FollowMeSessionView & {
+        userId: number;
+        userName: string | null;
+        userPhoneNumber: string | null;
+        organizationId: number;
+        controlCentreId: number | null;
+        appId: string | null;
+        countryCode: string | null;
+        entitlementTierAtStart: string | null;
+        workflowId: string | null;
+        workflowStartedAt: string | null;
+        trackPointCount: number;
+        sosAttempts: number;
+        sosFailureReason: string | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+    routes: FollowMeRouteView[];
+    prompts: FollowMePromptView[];
+    safetyEvents: FollowMeSafetyEventView[];
+    audit: FollowMeAuditEntry[];
+    trip: SafetyCheckTripSummary | null;
+    /**
+     * Whether this viewer may see where the user was: the session was shared with
+     * the provider or became an SOS, AND the gateway vouched for track:follow-me
+     * (SAFETY_LOCATION_ACCESS_HEADER). When false every coordinate, address and
+     * polyline in this response is null and GET .../tracking answers 403.
+     */
+    locationAccess: boolean;
+}
+/** GET /safety/admin/follow-me/:id/tracking - track:follow-me, provider-shared or SOS sessions only. */
+export interface FollowMeAdminTracking {
+    sessionId: string;
+    status: FollowMeStatus;
+    waypoints: FollowMeWaypointView[];
+    routes: FollowMeRouteView[];
+    latestLocation: TripPoint | null;
+    /** Oldest first, after `since`; page with pathCursor. */
+    path: TripPoint[];
+    pathCursor: string | null;
+    /** Safety events with the coordinates they were observed at. */
+    safetyEvents: FollowMeSafetyEventView[];
+    trackingHealth: FollowMeTrackingHealth;
+    serverTime: string;
+}
+/** One active session on the staff live map (provider-shared, in the viewer's scope). */
+export interface FollowMeLiveSession {
+    sessionId: string;
+    status: FollowMeStatus;
+    userId: number;
+    userName: string | null;
+    organizationId: number;
+    controlCentreId: number | null;
+    reasonLabel: string;
+    transportMode: FollowMeTransportMode | null;
+    destinationLabel: string | null;
+    etaAt: string | null;
+    trackingHealth: FollowMeTrackingHealth;
+    latestLocation: TripPoint | null;
+    activePromptTrigger: FollowMeSafetyTrigger | null;
+    startedAt: string;
+}
+/**
+ * Kafka payload of every KAFKA_TOPICS.FOLLOW_ME_* topic (outbox, at-least-once,
+ * keyed by session id). NO location and NO access token - an external guardian's
+ * link is minted by clarion-notification at send time through the internal
+ * access-link route.
+ */
+export interface FollowMeEvent {
+    eventId: string;
+    eventType: FollowMeEventType;
+    version: 1;
+    occurredAt: string;
+    correlationId: string | null;
+    sessionId: string;
+    userId: number;
+    organizationId: number;
+    controlCentreId: number | null;
+    appId: string | null;
+    countryCode: string | null;
+    status: FollowMeStatus;
+    reasonLabel: string;
+    startedAt: string;
+    plannedEndAt: string;
+    endedAt: string | null;
+    destinationLabel: string | null;
+    etaAt: string | null;
+    notifyGuardiansOnStartEnd: boolean;
+    providerParticipation: boolean;
+    guardianAudience: GuardianAudience;
+    /** Everyone asked to follow, for invitations and endings. */
+    participants: {
+        participantId: string;
+        kind: FollowMeParticipantKind;
+        status: FollowMeParticipantStatus;
+        guardianUserId: number | null;
+        /** External guardians only (E.164), for the SMS. */
+        phoneNumber: string | null;
+        displayName: string;
+    }[];
+    /** GUARDIAN_RESPONDED: who answered, and how. */
+    respondingParticipantId: string | null;
+    promptId: string | null;
+    promptTrigger: FollowMeSafetyTrigger | null;
+    promptDeadlineAt: string | null;
+    sosTrigger: SafetyCheckSosTrigger | null;
+    sosCause: FollowMeSafetyTrigger | null;
+    incidentId: number | null;
+}
+/**
+ * What clarion-safety publishes on SAFETY_REALTIME_CHANNEL. `rooms` is decided by
+ * clarion-safety from the session's CURRENT audience each time, so a guardian who
+ * stops following or a session that ends stops receiving at once. clarion-socket
+ * validates the rooms and emits SAFETY_SOCKET_EVENT with the envelope minus rooms.
+ */
+export interface FollowMeRealtimeEnvelope {
+    eventId: string;
+    feature: 'FOLLOW_ME';
+    type: FollowMeRealtimeEventType;
+    sessionId: string;
+    organizationId: number;
+    occurredAt: string;
+    rooms: string[];
+    payload: Record<string, unknown>;
+}
+/** The internal access-link answer (clarion-safety -> clarion-notification only). */
+export interface FollowMeExternalLink {
+    url: string;
+    expiresAt: string;
+}

package/dist/types/modules/safety/interfaces/safety-alert-context.d.ts

@@ -0,0 +1,8 @@
+/** See SafetyAlertContextDto: why a safety feature raised an SOS, as labelled facts. */
+export interface SafetyAlertContext {
+    summary: string;
+    facts: {
+        label: string;
+        value: string;
+    }[];
+}

package/dist/types/modules/safety/interfaces/safety-check.d.ts

@@ -1,6 +1,6 @@
 import { GuardianAudience } from '../../alert-dispatch/interfaces/guardian-audience';
 import { SafetyCheckStatus } from '../enums/safety-check-status.enum';
-import { SafetyCheckActorType, SafetyCheckAuditEventType, SafetyCheckSosTrigger } from '../enums/safety-enums';
+import { SafetyCheckActorType, SafetyCheckAuditEventType, SafetyCheckSosTrigger, SafetyFeature } from '../enums/safety-enums';
 /** A reason as the app's dropdown shows it. */
 export interface SafetyCheckReasonView {
     id: string;
@@ -10,6 +10,8 @@ export interface SafetyCheckReasonView {
     /** The "Write my own" entry: the user types the reason. */
     isCustom: boolean;
     displayOrder: number;
+    /** Which feature offers it (absent from services older than Follow Me = SAFETY_CHECK). */
+    feature?: SafetyFeature;
 }
 /** A reason as the admin manages it. */
 export interface SafetyCheckReasonAdminView extends SafetyCheckReasonView {