grm-shared-library 1.1.222 → 1.1.224

package/dist/types/modules/gis/enums/trip-privacy.enum.d.ts

@@ -3,7 +3,13 @@ export declare enum TripPurpose {
     /** The trip of an SOS incident - every trip before safety features existed. */
     SOS = "SOS",
     /** Recorded during a Safety Check. */
-    SAFETY_CHECK = "SAFETY_CHECK"
+    SAFETY_CHECK = "SAFETY_CHECK",
+    /**
+     * A Follow Me journey. Stored PRIVATE in clarion-gis (it publishes nothing):
+     * clarion-safety shares the live position with the session's authorized
+     * followers itself. Its points live in trip_points, not the trackPoints array.
+     */
+    FOLLOW_ME = "FOLLOW_ME"
 }
 /**
  * Who a trip is visible to.

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

@@ -14,6 +14,8 @@ export * from './dtos/geo-json-polygon.dto';
 export * from './dtos/point-containment-result.dto';
 export * from './dtos/point-location.dto';
 export * from './dtos/private-trip.dto';
+export * from './dtos/routing.dto';
+export * from './dtos/trip-points.dto';
 export * from './dtos/post-gis-geometry.dto';
 export * from './dtos/route-incident.dto';
 export * from './dtos/routing-coverage-result.dto';
@@ -27,6 +29,7 @@ export * from './dtos/zone-with-distance-result.dto';
 export * from './enums/incident-routing-result-match-type.enum';
 export * from './enums/trip-actions.enum';
 export * from './enums/trip-privacy.enum';
+export * from './enums/routing.enum';
 export * from './enums/zone.enums';
 export * from './interfaces/client-safe-trip';
 export * from './interfaces/control-centre-routing-result';
@@ -35,6 +38,8 @@ export * from './interfaces/point-containment';
 export * from './interfaces/point-location';
 export * from './interfaces/polygon-validation-result';
 export * from './interfaces/trip-summary';
+export * from './interfaces/trip-point';
+export * from './interfaces/routing';
 export * from './interfaces/zone';
 export * from './interfaces/zone-for-point';
 export * from './interfaces/zone-match-result';

package/dist/types/modules/gis/interfaces/routing.d.ts

@@ -0,0 +1,43 @@
+import { GisRoutingProvider, SavedPlaceKind } from '../enums/routing.enum';
+export interface ComputedRouteLeg {
+    distanceMeters: number;
+    durationSeconds: number;
+}
+/** A computed route. `polyline` is Google's encoded-polyline format (precision 5). */
+export interface ComputedRoute {
+    provider: GisRoutingProvider;
+    polyline: string;
+    distanceMeters: number;
+    /** With traffic where available. */
+    durationSeconds: number;
+    /** Free-flow; equal to durationSeconds when traffic was not considered. */
+    staticDurationSeconds: number;
+    legs: ComputedRouteLeg[];
+    /** Human-readable caveats from the provider (tolls, ferries, "estimate only"...). */
+    warnings: string[];
+    computedAt: string;
+}
+export interface PlaceSuggestion {
+    placeId: string;
+    primaryText: string;
+    secondaryText: string | null;
+}
+export interface PlaceDetails {
+    placeId: string | null;
+    label: string;
+    address: string | null;
+    lat: number;
+    lng: number;
+    provider: GisRoutingProvider;
+}
+export interface SavedPlaceView {
+    id: string;
+    label: string;
+    kind: SavedPlaceKind;
+    lat: number;
+    lng: number;
+    address: string | null;
+    placeId: string | null;
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/types/modules/gis/interfaces/trip-point.d.ts

@@ -0,0 +1,16 @@
+/** One recorded fix with everything the device told us about it. */
+export interface TripPoint {
+    lat: number;
+    lng: number;
+    timestamp: string;
+    accuracy?: number | null;
+    altitude?: number | null;
+    speed?: number | null;
+    heading?: number | null;
+    source?: string | null;
+}
+export interface TripPointsPage {
+    points: TripPoint[];
+    /** Pass as `since` for the next page; null when there is nothing more. */
+    nextSince: string | null;
+}

package/dist/types/modules/gis/interfaces/trip-summary.d.ts

@@ -1,4 +1,5 @@
 import { TripPurpose, TripVisibility } from '../enums/trip-privacy.enum';
+import { TripPoint } from './trip-point';
 /**
  * A trip without its path - what clarion-safety needs to run a check and what an
  * admin may see of it. `lastPoint` is for clarion-safety alone (the SOS location);
@@ -17,10 +18,5 @@ export interface TripSummary {
     sharedAt: string | null;
     distanceMeters: number | null;
     trackPointCount: number;
-    lastPoint: {
-        lat: number;
-        lng: number;
-        accuracy?: number;
-        timestamp: string;
-    } | null;
+    lastPoint: TripPoint | null;
 }

package/dist/types/modules/incident/dtos/incident/incident.dto.d.ts

@@ -9,6 +9,7 @@ import { IncidentStatusDetailsDto } from "./incident-status-details.dto";
 import { IncidentEntitlementTier } from "../../../entitlement/enums/incident-entitlement-tier.enum";
 import { IncidentOriginType } from "../../enums/incident-origin-type.enum";
 import { GuardianAudienceDto } from "../../../alert-dispatch/dtos/guardian-audience.dto";
+import { SafetyAlertContextDto } from "../../../safety/dtos/safety-alert-context.dto";
 declare const IncidentDto_base: import("@nestjs/common").Type<Omit<CreateIncidentDto, "reporter" | "statusDetails">>;
 export declare class IncidentDto extends IncidentDto_base {
     id: number;
@@ -34,6 +35,7 @@ export declare class IncidentDto extends IncidentDto_base {
      */
     originType?: IncidentOriginType | null;
     originReferenceId?: string | null;
+    originContext?: SafetyAlertContextDto | null;
     /**
      * Which guardians the alert is for; absent means all of them. Whitelisted here
      * because clarion-notification validates this DTO with `whitelist: true` - a

package/dist/types/modules/incident/enums/incident-origin-type.enum.d.ts

@@ -8,5 +8,7 @@
  */
 export declare enum IncidentOriginType {
     /** A Safety Check the user missed or asked for help from. */
-    SAFETY_CHECK = "SAFETY_CHECK"
+    SAFETY_CHECK = "SAFETY_CHECK",
+    /** A Follow Me journey: an unanswered safety prompt, or SOS pressed during it. */
+    FOLLOW_ME = "FOLLOW_ME"
 }

package/dist/types/modules/incident/intefaces/incident.d.ts

@@ -7,6 +7,7 @@ import { IncidentStatus } from "../enums/incident-status.enum";
 import { IncidentWorkflowTaskQueueName } from "../enums/incident-workflow-queue-name.enum";
 import { IncidentOriginType } from "../enums/incident-origin-type.enum";
 import { GuardianAudience } from "../../alert-dispatch/interfaces/guardian-audience";
+import { SafetyAlertContext } from "../../safety/interfaces/safety-alert-context";
 import { IncidentAction } from "./incident-action";
 import { IncidentAssignment } from "./incident-assignment";
 import { IncidentCategory } from "./incident-category";
@@ -96,6 +97,8 @@ export interface Incident {
      */
     originType?: IncidentOriginType | null;
     originReferenceId?: string | null;
+    /** Why the safety feature raised it, for responders. Set only with originType. */
+    originContext?: SafetyAlertContext | null;
     /**
      * Which guardians the alert is for. Absent (the norm) means all of the
      * reporter's guardians; a Safety Check SOS carries exactly the ones the user

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

@@ -194,6 +194,10 @@ export declare enum PermissionActions {
     USE_SAFETY_CHECK = "use:safety-check",
     READ_SAFETY_CHECK = "read:safety-check",
     MANAGE_SAFETY_CHECK_REASON = "manage:safety-check-reason",
+    USE_FOLLOW_ME = "use:follow-me",
+    READ_FOLLOW_ME = "read:follow-me",
+    TRACK_FOLLOW_ME = "track:follow-me",
+    MANAGE_SAVED_PLACE = "manage:saved-place",
     /**
      * @deprecated Split into the connection / message / screened-message /
      * analytics actions above, which the gateway now requires instead. Still

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

@@ -13,5 +13,6 @@ export declare enum PermissionsModule {
     SUPPORT = "Support",
     NOTIFICATION = "Notification",
     ALERT_INTAKE = "Alert Intake",
-    SAFETY = "Safety"
+    SAFETY = "Safety",
+    PLACES = "Places"
 }

package/dist/types/modules/role/constants/safety-roles.d.ts

@@ -12,3 +12,13 @@ export declare const SAFETY_MANAGER_ROLES: string[];
  * organization, and a control-centre admin within their control centre.
  */
 export declare const SAFETY_VIEWER_ROLES: string[];
+/**
+ * Staff who may see an organization's Follow Me sessions (read:follow-me) and,
+ * for a session shared with the provider or turned SOS, where the user is
+ * (track:follow-me): the organization's managers and its control room.
+ */
+export declare const FOLLOW_ME_VIEWER_ROLES: string[];
+/** Admitted by clarion-socket to `followme:org:{orgId}` (their own organization). */
+export declare const FOLLOW_ME_ORG_TRACKER_ROLES: string[];
+/** Admitted by clarion-socket to `followme:cc:{orgId}:{ccId}` (their own control centre). */
+export declare const FOLLOW_ME_CC_TRACKER_ROLES: string[];

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

@@ -0,0 +1,120 @@
+import { FollowMeTransportMode } from '../enums/follow-me.enums';
+/**
+ * Follow Me limits. clarion-safety enforces every one of them; the app reads the
+ * same values from GET /safety/follow-me/start-options rather than keeping a copy.
+ */
+export declare const FOLLOW_ME_LIMITS: {
+    readonly minDurationMinutes: 5;
+    /** A session can never outlive this, whatever the route says. */
+    readonly maxDurationMinutes: number;
+    /** Used when there is no planned route. */
+    readonly defaultDurationMinutes: 60;
+    /** With a route, the default is its travel time plus this, rounded up to 15 minutes. */
+    readonly routeDurationBufferMinutes: 30;
+    readonly minPromptCountdownSeconds: 15;
+    readonly maxPromptCountdownSeconds: number;
+    readonly defaultPromptCountdownSeconds: 60;
+    /** Server grace after the visible countdown before the SOS (same idea as Safety Check). */
+    readonly promptGraceSeconds: 10;
+    /** A prompt whose deadline passed longer ago than this (platform outage) is not escalated. */
+    readonly staleSosWindowMinutes: number;
+    readonly maxIntermediateStops: 5;
+    readonly customReasonMaxLength: 120;
+    readonly maxTrackPointsPerBatch: 200;
+    /** How long a route preview can be used to start a session. */
+    readonly routePreviewTtlMinutes: 30;
+    /** Live sharing is shown as stale after this long without a location. */
+    readonly trackingStaleAfterSeconds: 120;
+    /** External guardian page: how often it may poll, and the per-link budget. */
+    readonly externalPollIntervalSeconds: 10;
+    readonly externalRequestsPerMinute: 20;
+    /** Token entropy (bytes before base64url). */
+    readonly externalTokenBytes: 32;
+};
+/** Where the setup screens start. */
+export declare const FOLLOW_ME_DEFAULTS: {
+    readonly durationMinutes: 60;
+    readonly promptCountdownSeconds: 60;
+    readonly allGuardiansSelected: true;
+    /** Premium/Trial only, as for Safety Check. */
+    readonly notifyServiceProvider: true;
+    readonly notifyGuardiansOnStartEnd: true;
+    readonly transportMode: FollowMeTransportMode.DRIVE;
+    readonly vibrate: true;
+    readonly alarmSound: true;
+};
+/** How the app should sample and upload while Follow Me runs. */
+export declare const FOLLOW_ME_TRACKING: {
+    readonly locationIntervalSeconds: 5;
+    readonly distanceFilterMeters: 10;
+    readonly uploadIntervalSeconds: 10;
+};
+/**
+ * Monitor thresholds per transport mode. The monitors are deliberately slow to
+ * alarm: every trigger needs sustained, good-quality evidence, and a prompt is
+ * only the first step - the user answers it before anything escalates.
+ */
+export interface FollowMeMonitorThresholds {
+    /** Fixes less accurate than this feed no detector (they are still recorded). */
+    maxPointAccuracyMeters: number;
+    /** Half-width of the corridor around the route; widened by the fix's own accuracy. */
+    routeCorridorMeters: number;
+    /** Consecutive good off-corridor fixes before a deviation is suspected... */
+    deviationMinSamples: number;
+    /** ...spanning at least this long. */
+    deviationMinSeconds: number;
+    /** A recalculated route adding more than max(minutes, fraction) of the remaining time is significant. */
+    deviationDetourToleranceMinutes: number;
+    deviationDetourToleranceFraction: number;
+    /** In-corridor fixes needed to call the user back on route (hysteresis). */
+    backOnRouteSamples: number;
+    /** Below this speed (m/s) a fix counts as stationary. */
+    stationarySpeedMps: number;
+    /** A stop longer than this away from any planned point is suspicious. */
+    prolongedStopMinutes: number;
+    /** At a planned stop the allowance is longer. */
+    plannedStopMinutes: number;
+    /** Heavy traffic (traffic-aware duration / free-flow duration above this) defers a stop prompt once. */
+    congestionRatio: number;
+    /** Arrival: inside this radius (widened by accuracy) for the dwell time. */
+    arrivalRadiusMeters: number;
+    arrivalDwellSeconds: number;
+    /** Overdue once past the expected arrival by max(minutes, fraction of planned duration). */
+    etaGraceMinutes: number;
+    etaGraceFraction: number;
+    /** Crash detection runs for this mode. */
+    crashDetection: boolean;
+}
+export declare const FOLLOW_ME_MONITOR_THRESHOLDS: Readonly<Record<FollowMeTransportMode, FollowMeMonitorThresholds>>;
+/** Thresholds when the user did not plan a route (no corridor, no ETA; stops and crashes only). */
+export declare const FOLLOW_ME_UNPLANNED_THRESHOLDS: FollowMeMonitorThresholds;
+/**
+ * Crash detection runs ON THE DEVICE (sensors) and is only a suspicion until the
+ * server has checked it against the recorded track and the user has failed to
+ * answer the prompt. The app receives these values from start-options.
+ *
+ * A report needs ALL of: an impact well above anything a vehicle does in normal
+ * driving, NOT preceded by free fall (a dropped phone falls before it hits), a
+ * vehicle moving at speed just before, and a sharp loss of speed plus stillness
+ * after. Rotation adds confidence (roll-over) but is never required.
+ */
+export declare const FOLLOW_ME_CRASH_DETECTION: {
+    readonly sampleRateHz: 50;
+    readonly impactThresholdG: 4;
+    /** Sustained above this for at least impactMinDurationMs. */
+    readonly impactSustainG: 2.5;
+    readonly impactMinDurationMs: 30;
+    readonly freeFallThresholdG: 0.35;
+    readonly freeFallMinDurationMs: 150;
+    readonly minSpeedBeforeKph: 25;
+    readonly maxSpeedAfterKph: 8;
+    readonly speedDropWindowSeconds: 10;
+    readonly stillnessSeconds: 10;
+    readonly rotationThresholdRadS: 3;
+    /** Reports below this confidence are not sent. */
+    readonly confidenceThreshold: 0.7;
+    /** Server: the recorded track must show at least this speed shortly before. */
+    readonly serverMinTrackSpeedKph: 20;
+    readonly serverTrackLookbackSeconds: 60;
+    readonly evidenceVersion: "crash-v1";
+};

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

@@ -62,3 +62,82 @@ export declare const SAFETY_REDIS_KEYS: {
     readonly sweeperLock: "safety:lock:sweeper";
     readonly rateLimit: (userId: number, bucket: string) => string;
 };
+/** Temporal: the durable Follow Me timer (expiry, prompt deadline, ETA checks). */
+export declare const FOLLOW_ME_WORKFLOW: {
+    readonly workflowType: "followMeWorkflow";
+    /** Shares the Safety task queue and worker with the Safety Check timer. */
+    readonly taskQueue: "safety-check-task-queue";
+    readonly changedSignal: "followMeChanged";
+    readonly stateQuery: "followMeWorkflowState";
+};
+/** One workflow per session, ever. */
+export declare function followMeWorkflowId(sessionId: string): string;
+/** Internal HTTP paths for Follow Me (never proxied by the gateway). */
+export declare const FOLLOW_ME_INTERNAL_PATHS: {
+    /** clarion-safety: the one step the durable timer drives. */
+    readonly advanceSession: (sessionId: string) => string;
+    /**
+     * clarion-safety: mint a fresh external follow link for one participant, at the
+     * moment the SMS is sent. The raw token exists only in this response and the
+     * SMS - never on a Kafka topic, never in a log.
+     */
+    readonly mintExternalLink: (participantId: string) => string;
+    /** clarion-workflow-manager. */
+    readonly startWorkflow: "/follow-me/workflows";
+    readonly signalWorkflow: (sessionId: string) => string;
+    /** clarion-gis routing and places (internal; the gateway exposes the places ones to the app). */
+    readonly computeRoute: "/gis/routes/compute";
+    readonly placesAutocomplete: "/gis/places/autocomplete";
+    readonly placeDetails: "/gis/places/details";
+    readonly reverseGeocode: "/gis/places/reverse";
+    /** clarion-gis: a page of a trip's recorded points. */
+    readonly tripPoints: (tripId: string) => string;
+};
+/** App locations for Follow Me pushes (go_router, never API paths). */
+export declare const FOLLOW_ME_MOBILE_ROUTES: {
+    readonly active: "/follow-me/active";
+    readonly prompt: "/follow-me/prompt";
+    readonly requests: "/follow-me/requests";
+    readonly follow: (sessionId: string) => string;
+};
+/**
+ * Header the external follow page sends its token in. The link carries the token
+ * in the URL FRAGMENT (`/follow#t=...`), which browsers never send to a server, so
+ * it cannot land in a proxy or access log; the page reads it and sends it here.
+ */
+export declare const FOLLOW_ME_TOKEN_HEADER = "x-follow-token";
+/**
+ * Set by clarion-api-gateway - and ONLY by it, it strips any client value - on the
+ * admin Follow Me detail when the caller holds track:follow-me. clarion-safety
+ * cannot see permissions, only roles; this is how it learns the caller may see
+ * location. It still also requires provider participation or an SOS.
+ */
+export declare const SAFETY_LOCATION_ACCESS_HEADER = "x-safety-location-access";
+/**
+ * Redis pub/sub channel clarion-safety publishes live Safety events on. The
+ * envelope DECLARES its rooms (as support does); clarion-socket validates them
+ * against SAFETY_REALTIME_ROOM_PATTERNS and never adds any.
+ */
+export declare const SAFETY_REALTIME_CHANNEL = "realtime:safety";
+/** Socket.IO event name clients listen to. */
+export declare const SAFETY_SOCKET_EVENT = "safety.event";
+/** The only rooms a Safety envelope may target. */
+export declare const SAFETY_REALTIME_ROOM_PATTERNS: readonly RegExp[];
+/**
+ * Staff rooms that receive a session's live Follow Me updates - ONLY when the user
+ * chose to include their provider. clarion-socket admits staff by role:
+ * org rooms FOLLOW_ME_ORG_TRACKER_ROLES of that organization, cc rooms
+ * FOLLOW_ME_CC_TRACKER_ROLES of that organization and control centre.
+ */
+export declare const FOLLOW_ME_ROOMS: {
+    readonly user: (userId: number) => string;
+    readonly organization: (organizationId: number) => string;
+    readonly controlCentre: (organizationId: number, controlCentreId: number) => string;
+};
+export declare const FOLLOW_ME_REDIS_KEYS: {
+    readonly lastLocation: (sessionId: string) => string;
+    readonly routePreview: (token: string) => string;
+    readonly presence: (sessionId: string, participantId: string) => string;
+    readonly realtimeThrottle: (sessionId: string) => string;
+    readonly externalRateLimit: (bucket: string) => string;
+};

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

@@ -0,0 +1,106 @@
+import { GuardianAudienceDto } from '../../alert-dispatch/dtos/guardian-audience.dto';
+import { FollowMeStatus, FollowMeTransportMode, FollowMeWaypointKind } from '../enums/follow-me.enums';
+import { SafetyCheckLocationDto } from './safety-check.dto';
+/** One point of a planned journey: where it starts, a stop, or where it ends. */
+export declare class FollowMeWaypointDto {
+    kind: FollowMeWaypointKind;
+    lat: number;
+    lng: number;
+    label: string;
+    address?: string;
+    placeId?: string;
+    savedPlaceId?: string;
+}
+/**
+ * Plan a route (POST /safety/follow-me/routes/preview). Exactly one START (the
+ * app defaults it to the current location), 0..5 STOPs in order, exactly one
+ * DESTINATION. clarion-safety validates the shape; clarion-gis computes it.
+ */
+export declare class PreviewFollowMeRouteDto {
+    transportMode: FollowMeTransportMode;
+    waypoints: FollowMeWaypointDto[];
+}
+/**
+ * The planned route a session starts with. The geometry is never taken from the
+ * client: `routeToken` names a preview clarion-safety computed and stored for
+ * this user, and the waypoints must match it.
+ */
+export declare class FollowMeRoutePlanDto {
+    routeToken: string;
+}
+/**
+ * Starting Follow Me. Every field is re-checked server-side: the reason against
+ * the database, each guardian against clarion-authentication, provider
+ * participation against clarion-billing, the duration against the 24 h cap, and
+ * the route against the stored preview.
+ */
+export declare class StartFollowMeDto {
+    reasonId: string;
+    customReason?: string;
+    durationMinutes: number;
+    promptCountdownSeconds?: number;
+    guardians: GuardianAudienceDto;
+    notifyServiceProvider: boolean;
+    notifyGuardiansOnStartEnd: boolean;
+    transportMode?: FollowMeTransportMode;
+    route?: FollowMeRoutePlanDto;
+    startLocation?: SafetyCheckLocationDto;
+    backgroundLocationGranted?: boolean;
+    crashDetectionAvailable?: boolean;
+}
+/** One recorded fix, with everything the device knows about it. */
+export declare class FollowMeTrackPointDto {
+    lat: number;
+    lng: number;
+    timestamp: string;
+    accuracy?: number;
+    altitude?: number;
+    speed?: number;
+    heading?: number;
+    source?: string;
+}
+export declare class FollowMeTrackPointsDto {
+    points: FollowMeTrackPointDto[];
+}
+/**
+ * The device's evidence for a suspected crash. Only a SUSPICION: clarion-safety
+ * checks it against the recorded track and then asks the user, it never raises an
+ * SOS from this alone.
+ */
+export declare class ReportFollowMeCrashDto {
+    detectedAt: string;
+    confidence: number;
+    peakAccelerationG: number;
+    peakRotationRadS?: number;
+    speedBeforeKph?: number;
+    speedAfterKph?: number;
+    stillnessSeconds?: number;
+    freeFallDetected: boolean;
+    evidenceVersion: string;
+    location?: SafetyCheckLocationDto;
+}
+/** Answering a prompt: names the prompt so a stale screen cannot answer a newer one. */
+export declare class ConfirmFollowMePromptDto {
+    promptId: string;
+    location?: SafetyCheckLocationDto;
+}
+/** Filters for the admin Follow Me list; narrows only (scope comes from the caller). */
+export declare class FollowMeAdminQueryDto {
+    page?: number;
+    limit?: number;
+    status?: FollowMeStatus;
+    activeOnly?: boolean;
+    organizationId?: number;
+    userId?: number;
+    sosOnly?: boolean;
+    providerParticipation?: boolean;
+    from?: string;
+    to?: string;
+    id?: string;
+    sortBy?: 'startedAt' | 'createdAt';
+}
+/** clarion-safety -> clarion-workflow-manager: start the Follow Me timer (idempotent). */
+export declare class StartFollowMeWorkflowDto {
+    sessionId: string;
+    firstWakeAt: string;
+}

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

@@ -1,4 +1,5 @@
 import { SafetyCheckStatus } from '../enums/safety-check-status.enum';
+import { SafetyFeature } from '../enums/safety-enums';
 /**
  * Filters for the admin Safety Check list. Every field NARROWS what the caller
  * may already see: `organizationId` is honoured only for a super-admin; anybody
@@ -21,6 +22,7 @@ export declare class CreateSafetyCheckReasonDto {
     description?: string;
     organizationId?: number;
     countryCode?: string;
+    feature?: SafetyFeature;
     isCustom?: boolean;
     active?: boolean;
     displayOrder?: number;
@@ -36,4 +38,5 @@ export declare class UpdateSafetyCheckReasonDto {
 export declare class SafetyCheckReasonAdminQueryDto {
     organizationId?: number;
     includeInactive?: boolean;
+    feature?: SafetyFeature;
 }

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

@@ -0,0 +1,14 @@
+export declare class SafetyAlertContextFactDto {
+    label: string;
+    value: string;
+}
+/**
+ * What a responder needs to understand an automatic SOS at a glance, stored on
+ * the incident (`originContext`). Plain labelled facts rather than a feature
+ * specific schema, so the admin renders any safety feature's context the same
+ * way. Never a location history - the incident's trip has that.
+ */
+export declare class SafetyAlertContextDto {
+    summary: string;
+    facts: SafetyAlertContextFactDto[];
+}

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

@@ -1,6 +1,7 @@
 import { GuardianAudienceDto } from '../../alert-dispatch/dtos/guardian-audience.dto';
 import { SafetyCheckSosTrigger, SafetyFeature } from '../enums/safety-enums';
 import { SafetyCheckLocationDto } from './safety-check.dto';
+import { SafetyAlertContextDto } from './safety-alert-context.dto';
 /**
  * clarion-safety -> clarion-incident: raise the SOS for a safety feature.
  *
@@ -26,6 +27,8 @@ export declare class CreateSafetyAlertIncidentDto {
     guardianAudience: GuardianAudienceDto;
     tripId?: string;
     description?: string;
+    conversationId?: string;
+    context?: SafetyAlertContextDto;
 }
 /** clarion-safety -> clarion-workflow-manager: start the durable timer. Idempotent per check. */
 export declare class StartSafetyCheckWorkflowDto {