grm-shared-library 1.1.220 → 1.1.222

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

@@ -4,5 +4,15 @@ export interface IncidentCategory {
     name: string;
     description?: string;
     organizationId: number;
+    /**
+     * Stable code of a platform-managed row (e.g. SAFETY_CHECK_SOS); null for
+     * everything an organization created itself.
+     */
+    code?: string | null;
+    /**
+     * Platform-managed: provisioned for every organization, hidden from the SOS
+     * sheet and from package configuration, and not editable or deletable.
+     */
+    isSystem?: boolean;
     types?: IncidentType[];
 }

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

@@ -5,5 +5,15 @@ export interface IncidentType {
     description?: string;
     categoryId?: number;
     organizationId: number;
+    /**
+     * Stable code of a platform-managed row (e.g. SAFETY_CHECK_SOS); null for
+     * everything an organization created itself.
+     */
+    code?: string | null;
+    /**
+     * Platform-managed: provisioned for every organization, hidden from the SOS
+     * sheet and from package configuration, and not editable or deletable.
+     */
+    isSystem?: boolean;
     category?: IncidentCategory;
 }

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

@@ -5,6 +5,8 @@ import { IncidentClass } from "../enums/incident-class.enum";
 import { IncidentPriority } from "../enums/incident-priority.enum";
 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 { IncidentAction } from "./incident-action";
 import { IncidentAssignment } from "./incident-assignment";
 import { IncidentCategory } from "./incident-category";
@@ -88,6 +90,18 @@ export interface Incident {
      * billing withheld is not an alert somebody chose to withhold.
      */
     notifyServiceProviderRequested?: boolean;
+    /**
+     * Set when a safety feature raised the incident (see IncidentOriginType).
+     * Absent for everything a person raised.
+     */
+    originType?: IncidentOriginType | null;
+    originReferenceId?: string | 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
+     * selected. Honoured by clarion-notification and by the incident chat.
+     */
+    guardianAudience?: GuardianAudience | null;
     createdAt?: string;
     updatedAt?: string;
     category?: IncidentCategory;

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

@@ -3,5 +3,6 @@ export * from './dtos/update-organization.dto';
 export * from './dtos/organization-sla.dto';
 export * from './interfaces/organization';
 export * from './interfaces/organization-sla';
+export * from './interfaces/organization-created-event';
 export * from './enums/org-status.enum';
 export * from './enums/org-type.enum';

package/dist/types/modules/organization/interfaces/organization-created-event.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Payload of KAFKA_TOPICS.ORG_CREATED, published by clarion-organization after
+ * the organization (and its HQ control centre) has been committed. Consumers
+ * provision their per-organization defaults from it - clarion-incident creates
+ * the Safety Alerts category - and must be idempotent: the event is delivered at
+ * least once, and every consumer also reconciles on its own schedule, so a lost
+ * event delays provisioning rather than skipping it.
+ */
+export interface OrganizationCreatedEvent {
+    eventId: string;
+    occurredAt: string;
+    organizationId: number;
+    name: string;
+    countryCode: string | null;
+    incidentClass: string | null;
+    appId: string | null;
+    hqControlCentreId: number | null;
+}

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

@@ -155,6 +155,9 @@ export declare enum PermissionActions {
     PUBLISH_NEWSFEED_POST = "publish:newsfeed-post",
     ARCHIVE_NEWSFEED_POST = "archive:newsfeed-post",
     DELETE_NEWSFEED_POST = "delete:newsfeed-post",
+    READ_NEWSFEED_FEED = "read:newsfeed-feed",
+    ENGAGE_NEWSFEED_POST = "engage:newsfeed-post",
+    MODERATE_NEWSFEED_COMMENT = "moderate:newsfeed-comment",
     READ_NOTIFICATION_BRANDING = "read:notification-branding",
     UPDATE_NOTIFICATION_BRANDING = "update:notification-branding",
     CREATE_NOTIFICATION_EMAIL_SENDER = "create:notification-email-sender",
@@ -188,6 +191,9 @@ export declare enum PermissionActions {
     REVIEW_ALERT_INTAKE_SCREENED_MESSAGE = "review:alert-intake-screened-message",
     READ_ALERT_INTAKE_ANALYTICS = "read:alert-intake-analytics",
     MANAGE_ALERT_INTAKE_PLATFORM = "manage:alert-intake-platform",
+    USE_SAFETY_CHECK = "use:safety-check",
+    READ_SAFETY_CHECK = "read:safety-check",
+    MANAGE_SAFETY_CHECK_REASON = "manage:safety-check-reason",
     /**
      * @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

@@ -12,5 +12,6 @@ export declare enum PermissionsModule {
     NEWSFEED = "Newsfeed",
     SUPPORT = "Support",
     NOTIFICATION = "Notification",
-    ALERT_INTAKE = "Alert Intake"
+    ALERT_INTAKE = "Alert Intake",
+    SAFETY = "Safety"
 }

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

@@ -0,0 +1,16 @@
+/**
+ * The organization roles that RUN its newsfeed - write, publish, archive and
+ * delete posts, and moderate comments. Each holds every Newsfeed action
+ * (roles.spec.ts asserts it).
+ *
+ * For the places that decide by role NAME: clarion-newsfeed's own check on who
+ * may manage and moderate (it sees role names and scope, not permissions), and
+ * the admin deciding whether to offer a change at all.
+ */
+export declare const NEWSFEED_MANAGER_ROLES: string[];
+/**
+ * The organization roles that may SEE its newsfeed as staff do - drafts and
+ * archived posts included: the managers, plus Organization:User, which reads and
+ * changes nothing.
+ */
+export declare const NEWSFEED_VIEWER_ROLES: string[];

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

@@ -0,0 +1,14 @@
+/**
+ * The organization roles that curate the Safety Check reasons their app offers.
+ * Each holds manage:safety-check-reason (roles.spec.ts asserts it). Platform-wide
+ * reasons are Super-Admin's alone.
+ *
+ * For the places that decide by role NAME: clarion-safety's own scoping and the
+ * admin deciding whether to offer an edit at all.
+ */
+export declare const SAFETY_MANAGER_ROLES: string[];
+/**
+ * The staff roles that may read Safety Checks: the managers across the whole
+ * organization, and a control-centre admin within their control centre.
+ */
+export declare const SAFETY_VIEWER_ROLES: string[];

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

@@ -5,3 +5,5 @@ export * from './enums/role.enum';
 export * from './interfaces/role';
 export * from './constants/roles-by-scope';
 export * from './constants/billing-roles';
+export * from './constants/newsfeed-roles';
+export * from './constants/safety-roles';

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

@@ -0,0 +1,47 @@
+/**
+ * The Safety Check limits. The mobile app, the gateway-facing DTOs and the
+ * clarion-safety domain all read THESE numbers, so client-side and server-side
+ * validation cannot drift apart. The app additionally receives them from
+ * GET /safety/checks/start-options rather than hard-coding its own copy.
+ */
+export declare const SAFETY_CHECK_LIMITS: {
+    /** Shortest check the platform accepts. */
+    readonly minDurationMinutes: 1;
+    /** Longest check - including every extension - measured from startedAt. */
+    readonly maxDurationMinutes: number;
+    readonly defaultDurationMinutes: 15;
+    /** The quick picks offered on the setup screen ("Other" is a custom value). */
+    readonly presetDurationsMinutes: readonly number[];
+    /** How long the user has to confirm once prompted. */
+    readonly minPromptCountdownSeconds: 15;
+    readonly maxPromptCountdownSeconds: number;
+    readonly defaultPromptCountdownSeconds: 60;
+    /**
+     * Server-side grace after the visible countdown reaches zero before the SOS is
+     * raised. Covers an "I'm OK" that was sent at the last second and is still in
+     * flight. The app never shows it - the countdown it shows ends at
+     * promptDeadlineAt.
+     */
+    readonly checkInGraceSeconds: 10;
+    /**
+     * A check whose check-in window closed longer ago than this - only possible
+     * after a platform outage - is EXPIRED instead of raising an SOS hours late.
+     */
+    readonly staleSosWindowMinutes: number;
+    /** Free-text reason for "Write my own". */
+    readonly customReasonMaxLength: 120;
+    /** One track-point upload. */
+    readonly maxTrackPointsPerBatch: 200;
+};
+/** Where the setup screen starts. */
+export declare const SAFETY_CHECK_DEFAULTS: {
+    readonly durationMinutes: 15;
+    readonly promptCountdownSeconds: 60;
+    /** Every eligible guardian starts selected. */
+    readonly allGuardiansSelected: true;
+    /** Premium/Trial only - Free users are never offered the option. */
+    readonly notifyServiceProvider: true;
+    readonly notifyGuardiansOnStartEnd: true;
+    readonly vibrate: true;
+    readonly alarmSound: true;
+};

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

@@ -0,0 +1,64 @@
+/**
+ * Cross-service contracts for the Safety domain. Each value is read by more than
+ * one repository - change both sides together.
+ */
+/**
+ * Header carrying the shared internal service token on the calls that can raise
+ * or steer an SOS: workflow-manager -> clarion-safety (advance), clarion-safety
+ * -> workflow-manager (start/signal) and clarion-safety -> clarion-incident
+ * (create the Safety SOS incident). Same header workflow-manager already
+ * requires on its API.
+ */
+export declare const SAFETY_INTERNAL_TOKEN_HEADER = "x-internal-service-token";
+/**
+ * Env vars the token is read from, in order. `SAFETY_INTERNAL_API_TOKEN` may hold
+ * a comma-separated list (rotation); when it is unset every party falls back to
+ * `WORKFLOW_MANAGER_API_TOKEN`, which every pod already receives from
+ * runtime-secrets. Senders use the FIRST value; receivers accept ANY.
+ */
+export declare const SAFETY_INTERNAL_TOKEN_ENV_KEYS: readonly ["SAFETY_INTERNAL_API_TOKEN", "WORKFLOW_MANAGER_API_TOKEN"];
+/** Temporal: the durable Safety Check timer. */
+export declare const SAFETY_CHECK_WORKFLOW: {
+    /** Registered workflow function name in clarion-workflow-manager. */
+    readonly workflowType: "safetyCheckWorkflow";
+    /** Default task queue; overridable with TEMPORAL_SAFETY_TASK_QUEUE. */
+    readonly taskQueue: "safety-check-task-queue";
+    /** Signal that wakes the workflow early (extension, check-in, stop, SOS). */
+    readonly changedSignal: "safetyCheckChanged";
+    /** Query returning the workflow's view of the next wake time. */
+    readonly stateQuery: "safetyCheckWorkflowState";
+};
+/** Workflow id for a Safety Check. One per check, ever - the id IS the idempotency key. */
+export declare function safetyCheckWorkflowId(safetyCheckId: string): string;
+/** Internal HTTP paths (not proxied by the gateway). */
+export declare const SAFETY_INTERNAL_PATHS: {
+    /** clarion-safety: the one domain step the durable timer drives. */
+    readonly advanceCheck: (safetyCheckId: string) => string;
+    /** clarion-workflow-manager: start the timer for a check. */
+    readonly startWorkflow: "/safety-checks/workflows";
+    /** clarion-workflow-manager: wake the timer early. */
+    readonly signalWorkflow: (safetyCheckId: string) => string;
+    /** clarion-incident: raise the Safety SOS incident (idempotent per origin). */
+    readonly createSafetyAlertIncident: "/incidents/safety-alerts";
+    /** clarion-incident: which of these incident type ids are platform-managed system types. */
+    readonly classifyIncidentTypes: "/incident-types/classify";
+    /** clarion-gis private trips (tracked privately until an SOS shares them). */
+    readonly createPrivateTrip: "/trips/private";
+    readonly tripTrackPoints: (tripId: string) => string;
+    readonly shareTrip: (tripId: string) => string;
+    readonly stopPrivateTrip: (tripId: string) => string;
+    readonly tripSummary: (tripId: string) => string;
+};
+/**
+ * go_router locations in clarion_mobile that pushes deep-link to. A push route
+ * is an APP location, never an API path.
+ */
+export declare const SAFETY_MOBILE_ROUTES: {
+    readonly active: "/safety-check/active";
+    readonly prompt: "/safety-check/prompt";
+};
+/** Redis keys clarion-safety owns. */
+export declare const SAFETY_REDIS_KEYS: {
+    readonly sweeperLock: "safety:lock:sweeper";
+    readonly rateLimit: (userId: number, bucket: string) => string;
+};

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

@@ -0,0 +1,31 @@
+import { SafetyFeature, SafetyIncidentCategoryCode, SafetyIncidentTypeCode } from '../enums/safety-enums';
+export interface SafetyIncidentTypeDefinition {
+    code: SafetyIncidentTypeCode;
+    name: string;
+    description: string;
+    feature: SafetyFeature;
+}
+export interface SafetyIncidentCategoryDefinition {
+    code: SafetyIncidentCategoryCode;
+    name: string;
+    description: string;
+    types: readonly SafetyIncidentTypeDefinition[];
+}
+/**
+ * The incident category and types EVERY organization receives - existing ones by
+ * migration and reconciliation, new ones on `org.created`. There is no
+ * per-organization exception (NAVCDP included).
+ *
+ * They are SYSTEM rows in clarion-incident (`isSystem = true`, matched by
+ * `code`, never by name): hidden from the SOS bottom sheet and from package
+ * configuration, immutable through the admin API, and raised only by the
+ * safety features themselves.
+ *
+ * Names are stored once at provisioning; renaming here does not rename existing
+ * rows.
+ */
+export declare const SAFETY_ALERTS_TAXONOMY: SafetyIncidentCategoryDefinition;
+/** The incident type a safety feature raises its SOS as. */
+export declare function safetyIncidentTypeCodeFor(feature: SafetyFeature): SafetyIncidentTypeCode;
+/** True for a code clarion-incident treats as a platform-managed safety type. */
+export declare function isSafetyIncidentTypeCode(code: string | null | undefined): code is SafetyIncidentTypeCode;

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

@@ -0,0 +1,39 @@
+import { SafetyCheckStatus } from '../enums/safety-check-status.enum';
+/**
+ * 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
+ * else is scoped from their trusted context regardless of what arrives here.
+ */
+export declare class SafetyCheckAdminQueryDto {
+    page?: number;
+    limit?: number;
+    status?: SafetyCheckStatus;
+    organizationId?: number;
+    userId?: number;
+    sosOnly?: boolean;
+    from?: string;
+    to?: string;
+    id?: string;
+}
+export declare class CreateSafetyCheckReasonDto {
+    code: string;
+    label: string;
+    description?: string;
+    organizationId?: number;
+    countryCode?: string;
+    isCustom?: boolean;
+    active?: boolean;
+    displayOrder?: number;
+}
+/** Code, organization and custom-ness are fixed once created; everything shown to users can change. */
+export declare class UpdateSafetyCheckReasonDto {
+    label?: string;
+    description?: string | null;
+    countryCode?: string | null;
+    active?: boolean;
+    displayOrder?: number;
+}
+export declare class SafetyCheckReasonAdminQueryDto {
+    organizationId?: number;
+    includeInactive?: boolean;
+}

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

@@ -0,0 +1,38 @@
+import { GuardianAudienceDto } from '../../alert-dispatch/dtos/guardian-audience.dto';
+/** A device-reported position. Never logged by any Safety service. */
+export declare class SafetyCheckLocationDto {
+    lat: number;
+    lng: number;
+    accuracy?: number;
+}
+/**
+ * Starting a Safety Check.
+ *
+ * Nothing here is trusted beyond its shape: clarion-safety re-checks the reason
+ * against the database, every guardian against clarion-authentication, and the
+ * provider option against clarion-billing. The duration is bounded here AND in
+ * the domain.
+ */
+export declare class StartSafetyCheckDto {
+    reasonId: string;
+    customReason?: string;
+    durationMinutes: number;
+    promptCountdownSeconds?: number;
+    guardians: GuardianAudienceDto;
+    notifyServiceProvider: boolean;
+    notifyGuardiansOnStartEnd: boolean;
+    startLocation?: SafetyCheckLocationDto;
+}
+export declare class ExtendSafetyCheckDto {
+    additionalMinutes: number;
+}
+/** Body of check-in, stop and manual SOS. The location is optional context. */
+export declare class SafetyCheckActionDto {
+    location?: SafetyCheckLocationDto;
+}
+export declare class SafetyCheckTrackPointDto extends SafetyCheckLocationDto {
+    timestamp: string;
+}
+export declare class SafetyCheckTrackPointsDto {
+    points: SafetyCheckTrackPointDto[];
+}

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

@@ -0,0 +1,51 @@
+import { GuardianAudienceDto } from '../../alert-dispatch/dtos/guardian-audience.dto';
+import { SafetyCheckSosTrigger, SafetyFeature } from '../enums/safety-enums';
+import { SafetyCheckLocationDto } from './safety-check.dto';
+/**
+ * clarion-safety -> clarion-incident: raise the SOS for a safety feature.
+ *
+ * Internal only (never proxied by the gateway) and token-protected. Idempotent on
+ * (feature, originReferenceId): a retry - from a workflow, the sweeper, or a user
+ * pressing twice - returns the incident the first call created.
+ *
+ * clarion-incident builds the incident itself: the reporter from the user's
+ * account, the Safety Alerts category and type from the organization's system
+ * rows, and entitlement/dispatch through the same pipeline as every SOS. The
+ * caller cannot choose a type, a class or an entitlement tier.
+ */
+export declare class CreateSafetyAlertIncidentDto {
+    feature: SafetyFeature;
+    originReferenceId: string;
+    trigger: SafetyCheckSosTrigger;
+    organizationId: number;
+    userId: number;
+    appId: string;
+    controlCentreId?: number;
+    location?: SafetyCheckLocationDto;
+    notifyServiceProvider: boolean;
+    guardianAudience: GuardianAudienceDto;
+    tripId?: string;
+    description?: string;
+}
+/** clarion-safety -> clarion-workflow-manager: start the durable timer. Idempotent per check. */
+export declare class StartSafetyCheckWorkflowDto {
+    safetyCheckId: string;
+    firstWakeAt: string;
+}
+/**
+ * clarion-safety -> clarion-workflow-manager: something changed. Purely an
+ * optimisation - a lost signal only means the workflow wakes at its previous
+ * time and asks clarion-safety, which answers with the truth.
+ */
+export declare class SignalSafetyCheckWorkflowDto {
+    done?: boolean;
+    nextWakeAt?: string;
+}
+/**
+ * clarion-billing -> clarion-incident: which of these incident type ids are
+ * platform-managed system types (the Safety SOS types). Billing refuses to put
+ * those in a package, whatever the admin UI shows.
+ */
+export declare class ClassifyIncidentTypesDto {
+    ids: number[];
+}

package/dist/types/modules/safety/enums/safety-check-status.enum.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Lifecycle of one Safety Check. clarion-safety is the only writer; every
+ * transition is validated against SAFETY_CHECK_TRANSITIONS
+ * (utils/safety-check-state-machine.ts) and applied as a conditional update, so
+ * two racing writers can never both win.
+ *
+ *   CREATED        accepted and persisted; tracking and the durable timer are
+ *                  still being set up. The user already counts as being in a
+ *                  check (the clock started when it was accepted).
+ *   ACTIVE         running; the user is expected to check in at
+ *                  scheduledCheckInAt.
+ *   PROMPTING      the check-in time has passed and the user is being asked to
+ *                  confirm they are safe. SOS is raised at promptDeadlineAt.
+ *   CHECKED_IN     the user confirmed they are safe. Terminal, successful.
+ *   SOS_TRIGGERED  an SOS was raised - the user missed the check-in or asked for
+ *                  one. Terminal for the check; the incident lives on in
+ *                  clarion-incident. `incidentId` is null until the incident
+ *                  has been created (clarion-safety keeps retrying).
+ *   STOPPED        the user ended the check before it completed. Terminal.
+ *   EXPIRED        the check-in window closed so long ago (a platform outage
+ *                  longer than SAFETY_CHECK_LIMITS.staleSosWindowMinutes) that
+ *                  raising an SOS now would be noise rather than help. Terminal;
+ *                  always an operational alarm.
+ *   CANCELLED      ended by the platform rather than the user (e.g. the account
+ *                  was signed out and the user chose to end it). Terminal.
+ *   FAILED         the SOS could not be raised because clarion-incident refused
+ *                  it outright (a non-retryable error). Terminal; the user is
+ *                  told to call for help and operators are alerted.
+ */
+export declare enum SafetyCheckStatus {
+    CREATED = "CREATED",
+    ACTIVE = "ACTIVE",
+    PROMPTING = "PROMPTING",
+    CHECKED_IN = "CHECKED_IN",
+    SOS_TRIGGERED = "SOS_TRIGGERED",
+    STOPPED = "STOPPED",
+    EXPIRED = "EXPIRED",
+    CANCELLED = "CANCELLED",
+    FAILED = "FAILED"
+}

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

@@ -0,0 +1,81 @@
+/** Why a Safety Check raised an SOS. */
+export declare enum SafetyCheckSosTrigger {
+    /** 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"
+}
+/** Who caused a Safety Check transition - recorded on every audit entry. */
+export declare enum SafetyCheckActorType {
+    USER = "USER",
+    /** The durable timer in clarion-workflow-manager. */
+    WORKFLOW = "WORKFLOW",
+    /** clarion-safety's backstop sweeper, acting on an overdue check. */
+    RECONCILER = "RECONCILER",
+    SYSTEM = "SYSTEM"
+}
+/** Audit trail entries (safety_check_events.eventType). Never carries a location. */
+export declare enum SafetyCheckAuditEventType {
+    CREATED = "CREATED",
+    ACTIVATED = "ACTIVATED",
+    TRACKING_STARTED = "TRACKING_STARTED",
+    TRACKING_UNAVAILABLE = "TRACKING_UNAVAILABLE",
+    WORKFLOW_STARTED = "WORKFLOW_STARTED",
+    WORKFLOW_START_FAILED = "WORKFLOW_START_FAILED",
+    EXTENDED = "EXTENDED",
+    PROMPT_STARTED = "PROMPT_STARTED",
+    CHECKED_IN = "CHECKED_IN",
+    STOPPED = "STOPPED",
+    CANCELLED = "CANCELLED",
+    SOS_TRIGGERED = "SOS_TRIGGERED",
+    SOS_INCIDENT_CREATED = "SOS_INCIDENT_CREATED",
+    SOS_INCIDENT_RETRY = "SOS_INCIDENT_RETRY",
+    SOS_FAILED = "SOS_FAILED",
+    EXPIRED = "EXPIRED"
+}
+/**
+ * The safety features that can raise an incident. Phase 1 raises only
+ * SAFETY_CHECK; FOLLOW_ME exists because its incident type is provisioned for
+ * every organization from day one.
+ */
+export declare enum SafetyFeature {
+    SAFETY_CHECK = "SAFETY_CHECK",
+    FOLLOW_ME = "FOLLOW_ME"
+}
+/** Stable code of the incident category every organization receives. */
+export declare enum SafetyIncidentCategoryCode {
+    SAFETY_ALERTS = "SAFETY_ALERTS"
+}
+/** Stable codes of the incident types inside the Safety Alerts category. */
+export declare enum SafetyIncidentTypeCode {
+    SAFETY_CHECK_SOS = "SAFETY_CHECK_SOS",
+    FOLLOW_ME_SOS = "FOLLOW_ME_SOS"
+}
+/**
+ * Kafka event types published by clarion-safety (the `eventType` field of
+ * SafetyCheckEvent). One topic per type, see KAFKA_TOPICS.SAFETY_CHECK_*.
+ */
+export declare enum SafetyCheckEventType {
+    STARTED = "SAFETY_CHECK_STARTED",
+    PROMPTING = "SAFETY_CHECK_PROMPTING",
+    ENDED = "SAFETY_CHECK_ENDED",
+    SOS_TRIGGERED = "SAFETY_CHECK_SOS_TRIGGERED"
+}
+/**
+ * Push `data.action` / `data.type` values the mobile app routes on. Sent by
+ * clarion-notification; the app allow-lists them in
+ * notification_deep_link_coordinator.dart. Changing a value is a breaking
+ * change to installed apps.
+ */
+export declare enum SafetyPushAction {
+    /** To the user: it is time to confirm you are safe. */
+    SAFETY_CHECK_PROMPT = "SAFETY_CHECK_PROMPT",
+    /** To the user: an SOS was raised for your Safety Check. */
+    SAFETY_CHECK_SOS_TRIGGERED = "SAFETY_CHECK_SOS_TRIGGERED",
+    /** To the user: the Safety Check ended without them (FAILED/EXPIRED/CANCELLED). */
+    SAFETY_CHECK_ENDED = "SAFETY_CHECK_ENDED",
+    /** To a guardian: somebody who chose you started a Safety Check. */
+    SAFETY_CHECK_GUARDIAN_STARTED = "SAFETY_CHECK_GUARDIAN_STARTED",
+    /** To a guardian: that Safety Check ended safely. */
+    SAFETY_CHECK_GUARDIAN_ENDED = "SAFETY_CHECK_GUARDIAN_ENDED"
+}

package/dist/types/modules/safety/enums/safety-error-code.enum.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Machine-readable `code` on every error clarion-safety returns, so the app can
+ * react (e.g. adopt the check a duplicate start collided with) without parsing
+ * the human message.
+ */
+export declare enum SafetyCheckErrorCode {
+    NOT_FOUND = "SAFETY_CHECK_NOT_FOUND",
+    ALREADY_ACTIVE = "SAFETY_CHECK_ALREADY_ACTIVE",
+    ALREADY_ENDED = "SAFETY_CHECK_ENDED",
+    SOS_ALREADY_TRIGGERED = "SAFETY_CHECK_SOS_ALREADY_TRIGGERED",
+    INVALID_TRANSITION = "SAFETY_CHECK_INVALID_TRANSITION",
+    INVALID_DURATION = "SAFETY_CHECK_INVALID_DURATION",
+    MAX_DURATION_EXCEEDED = "SAFETY_CHECK_MAX_DURATION_EXCEEDED",
+    INVALID_REASON = "SAFETY_CHECK_INVALID_REASON",
+    CUSTOM_REASON_REQUIRED = "SAFETY_CHECK_CUSTOM_REASON_REQUIRED",
+    GUARDIAN_NOT_FOUND = "SAFETY_CHECK_GUARDIAN_NOT_FOUND",
+    GUARDIANS_UNAVAILABLE = "SAFETY_CHECK_GUARDIANS_UNAVAILABLE",
+    NO_SOS_RECIPIENTS = "SAFETY_CHECK_NO_SOS_RECIPIENTS",
+    SERVICE_PROVIDER_NOT_ENTITLED = "SAFETY_CHECK_SERVICE_PROVIDER_NOT_ENTITLED",
+    TRACKING_CLOSED = "SAFETY_CHECK_TRACKING_CLOSED",
+    RATE_LIMITED = "SAFETY_CHECK_RATE_LIMITED"
+}

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

@@ -0,0 +1,13 @@
+export * from './enums/safety-check-status.enum';
+export * from './enums/safety-enums';
+export * from './enums/safety-error-code.enum';
+export * from './constants/safety-check-limits.const';
+export * from './constants/safety-taxonomy.const';
+export * from './constants/safety-integration.const';
+export * from './interfaces/safety-check';
+export * from './interfaces/safety-check-event';
+export * from './dtos/safety-check.dto';
+export * from './dtos/safety-admin.dto';
+export * from './dtos/safety-internal.dto';
+export * from './utils/safety-check-state-machine';
+export * from './utils/safety-check-timing.util';

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

@@ -0,0 +1,36 @@
+import { GuardianAudience } from '../../alert-dispatch/interfaces/guardian-audience';
+import { SafetyCheckStatus } from '../enums/safety-check-status.enum';
+import { SafetyCheckEventType, SafetyCheckSosTrigger } from '../enums/safety-enums';
+/**
+ * The Kafka payload for every KAFKA_TOPICS.SAFETY_CHECK_* topic. Published by
+ * clarion-safety through its transactional outbox (at-least-once, keyed by the
+ * check id so one check's events stay in order); consumers dedupe on `eventId`.
+ *
+ * Carries NO location. `guardianAudience` holds guardian identifiers because
+ * clarion-notification needs them to reach exactly the chosen guardians.
+ */
+export interface SafetyCheckEvent {
+    eventId: string;
+    eventType: SafetyCheckEventType;
+    version: 1;
+    occurredAt: string;
+    correlationId: string | null;
+    safetyCheckId: string;
+    userId: number;
+    organizationId: number;
+    controlCentreId: number | null;
+    appId: string | null;
+    countryCode: string | null;
+    status: SafetyCheckStatus;
+    reasonLabel: string;
+    durationMinutes: number;
+    startedAt: string;
+    scheduledCheckInAt: string;
+    promptStartedAt: string | null;
+    promptDeadlineAt: string | null;
+    endedAt: string | null;
+    notifyGuardiansOnStartEnd: boolean;
+    guardianAudience: GuardianAudience;
+    sosTrigger: SafetyCheckSosTrigger | null;
+    incidentId: number | null;
+}