grm-shared-library 1.1.241 → 1.1.242

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

@@ -0,0 +1,144 @@
+import { ResponseUnitDispatchStatus } from '../../dispatch/enums/response-unit-dispatch-status.enum';
+import { ResponderArrivalMethod, ResponderDispatchListState, ResponderReportField, ResponderReportOutcome } from '../enums/responder.enums';
+/** `POST /responder/duty` - go on duty with one of the caller's units. */
+export declare class StartResponderDutyDto {
+    responseUnitId: number;
+}
+/** `POST /responder/duty/end` - go off duty. Idempotent: ending no duty is not an error. */
+export declare class EndResponderDutyDto {
+    reason?: string;
+}
+/** `POST /response-units/:id/responders/:userId/end-duty` - the control room ends someone's duty. */
+export declare class EndResponderDutyByControlCentreDto extends EndResponderDutyDto {
+}
+/** `POST /response-units/:id/responders` - link a Responder account to a unit. */
+export declare class AddResponseUnitResponderDto {
+    userId: number;
+}
+/** `GET /responder/dispatches`. Newest first. */
+export declare class ResponderDispatchListQueryDto {
+    state?: ResponderDispatchListState;
+    page?: number;
+    limit?: number;
+    /** `123` or `#123`: only that incident's dispatches. */
+    search?: string;
+}
+/** A position fix the phone took, sent as evidence with an action. */
+export declare class ResponderLocationFixDto {
+    latitude: number;
+    longitude: number;
+    accuracyMetres?: number;
+    /** When the phone took the fix (ISO 8601). */
+    recordedAt: string;
+}
+/**
+ * `POST /responder/dispatches/:dispatchId/status` - acknowledge, set off,
+ * arrive, complete or decline.
+ *
+ * Idempotent by target: asking for the status the dispatch already has returns
+ * it unchanged (HTTP 200) instead of a conflict, so a retry after a lost
+ * response is safe. `clientActionId` is recorded with the change for the audit.
+ */
+export declare class RespondToDispatchDto {
+    status: ResponseUnitDispatchStatus;
+    clientActionId: string;
+    /** Why - required to decline, and for a manual arrival, when policy says so. */
+    reason?: string;
+    /** The phone's position when the action was taken, when it has one. */
+    location?: ResponderLocationFixDto;
+    /** ON_SCENE only: how the arrival was established. Defaults to GPS when a location is sent. */
+    arrivalMethod?: ResponderArrivalMethod;
+}
+export declare class ResponderChecklistAnswerDto {
+    itemId: string;
+    checked: boolean;
+}
+/**
+ * `POST /responder/dispatches/:dispatchId/report` - submit, or amend, the
+ * response report. The first submission is idempotent on `clientReportId`; an
+ * amendment must name the `expectedVersion` it was edited from.
+ */
+export declare class SubmitResponderReportDto {
+    clientReportId: string;
+    /** Absent for the first submission; the version being amended otherwise. */
+    expectedVersion?: number;
+    summary: string;
+    actionsTaken?: string;
+    outcome: ResponderReportOutcome;
+    personsContacted?: string;
+    handoverTo?: string;
+    followUpRequired: boolean;
+    followUpNotes?: string;
+    remarks?: string;
+    checklist?: ResponderChecklistAnswerDto[];
+    /** DMS file ids (images, documents, videos) to attach to the incident with this report. */
+    attachmentIds?: number[];
+}
+export declare class ResponderPositionSampleDto {
+    latitude: number;
+    longitude: number;
+    accuracyMetres?: number;
+    altitudeMetres?: number;
+    /** Metres per second, as the phone reports it. */
+    speedMetresPerSecond?: number;
+    headingDegrees?: number;
+    /** When the phone took the fix (ISO 8601) - never the upload time. */
+    recordedAt: string;
+    /** The OS flagged it as a mock location. Kept and flagged, never used for arrival. */
+    isMocked?: boolean;
+}
+/**
+ * `POST /responder/positions` - positions of the unit the caller is on duty
+ * with. The server decides the unit from the caller's active duty session;
+ * the client never names one.
+ */
+export declare class ReportResponderPositionsDto {
+    samples: ResponderPositionSampleDto[];
+}
+export declare class ResponderLocationPolicyDto {
+    onDutyIntervalSeconds?: number;
+    activeIntervalSeconds?: number;
+    distanceFilterMetres?: number;
+    maxAccuracyMetres?: number;
+    staleAfterSeconds?: number;
+}
+export declare class ResponderArrivalPolicyDto {
+    radiusMetres?: number;
+    allowManualConfirmation?: boolean;
+    manualReasonRequired?: boolean;
+}
+export declare class ResponderDispatchPolicyDto {
+    allowDecline?: boolean;
+    declineReasonRequired?: boolean;
+}
+export declare class ResponderChecklistItemDto {
+    id: string;
+    label: string;
+    required: boolean;
+}
+export declare class ResponderReportPolicyDto {
+    requiredToComplete?: boolean;
+    requiredFields?: ResponderReportField[];
+    checklist?: ResponderChecklistItemDto[];
+    minPhotos?: number;
+}
+export declare class ResponderEvidencePolicyDto {
+    allowPhotos?: boolean;
+    allowDocuments?: boolean;
+    allowVideo?: boolean;
+    maxImageMegabytes?: number;
+    maxDocumentMegabytes?: number;
+    maxVideoMegabytes?: number;
+}
+export declare class ResponderReporterContactPolicyDto {
+    visible?: boolean;
+}
+/** An organization's override of DEFAULT_RESPONDER_POLICY; every part optional. */
+export declare class ResponderPolicyDto {
+    location?: ResponderLocationPolicyDto;
+    arrival?: ResponderArrivalPolicyDto;
+    dispatch?: ResponderDispatchPolicyDto;
+    report?: ResponderReportPolicyDto;
+    evidence?: ResponderEvidencePolicyDto;
+    reporterContact?: ResponderReporterContactPolicyDto;
+}

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

@@ -0,0 +1,128 @@
+/**
+ * The responder app: field personnel (role `Responder`) who staff a response
+ * unit, go on duty with it, receive its dispatches on their phone and report
+ * progress, arrival, position and the outcome back to the control room.
+ *
+ * A responder is linked to the units they may staff by an explicit membership
+ * (clarion-organization, managed by whoever holds update:response-unit). There
+ * is deliberately no implicit link by phone number: a crew phone typed into a
+ * unit form is not proof that an app account belongs to that crew.
+ */
+/** Whether a responder is currently on duty with one of their units. */
+export declare enum ResponderDutyStatus {
+    ON_DUTY = "ON_DUTY",
+    OFF_DUTY = "OFF_DUTY"
+}
+/** A duty session's own lifecycle. One session is ACTIVE per responder at most. */
+export declare enum ResponderDutySessionStatus {
+    ACTIVE = "ACTIVE",
+    ENDED = "ENDED"
+}
+/** Why a duty session ended. */
+export declare enum ResponderDutyEndReason {
+    /** The responder went off duty in the app. */
+    RESPONDER = "RESPONDER",
+    /** The control room ended it (update:response-unit). */
+    CONTROL_CENTRE = "CONTROL_CENTRE",
+    /** The responder was removed from the unit while on duty with it. */
+    MEMBERSHIP_REMOVED = "MEMBERSHIP_REMOVED",
+    /** The unit was deactivated or deleted while the responder was on duty with it. */
+    UNIT_DEACTIVATED = "UNIT_DEACTIVATED"
+}
+/** How an arrival on scene was established by the responder. */
+export declare enum ResponderArrivalMethod {
+    /** The phone's position was within the organization's arrival radius. */
+    GPS = "GPS",
+    /** The responder confirmed it by hand (with a reason, when policy asks for one). */
+    MANUAL = "MANUAL"
+}
+/** How a response ended, as the responder reports it. */
+export declare enum ResponderReportOutcome {
+    RESOLVED_ON_SCENE = "RESOLVED_ON_SCENE",
+    HANDED_OVER = "HANDED_OVER",
+    REFERRED = "REFERRED",
+    NO_ACTION_REQUIRED = "NO_ACTION_REQUIRED",
+    FALSE_ALARM = "FALSE_ALARM",
+    UNABLE_TO_LOCATE = "UNABLE_TO_LOCATE",
+    OTHER = "OTHER"
+}
+/** The free-text fields of a responder report a policy may make mandatory. */
+export declare enum ResponderReportField {
+    SUMMARY = "summary",
+    ACTIONS_TAKEN = "actionsTaken",
+    PERSONS_CONTACTED = "personsContacted",
+    HANDOVER_TO = "handoverTo",
+    REMARKS = "remarks"
+}
+/** Which dispatches `GET /responder/dispatches` lists. */
+export declare enum ResponderDispatchListState {
+    /** DISPATCHED, ACKNOWLEDGED, EN_ROUTE, ON_SCENE. */
+    ACTIVE = "ACTIVE",
+    /** COMPLETED, CANCELLED, REJECTED. */
+    HISTORY = "HISTORY",
+    ALL = "ALL"
+}
+/** How a unit's live position reaches clarion-response-tracking. */
+export declare enum ResponderTrackingMode {
+    /** The on-duty responder's phone reports the unit's position. */
+    PHONE = "PHONE",
+    /** The unit has an enabled hardware tracker binding; the phone stays quiet so the two never compete. */
+    UNIT_DEVICE = "UNIT_DEVICE",
+    /** The caller is not on duty, so no position is accepted. */
+    NOT_ON_DUTY = "NOT_ON_DUTY"
+}
+/**
+ * `data.action` of the pushes clarion-notification sends a responder's phone.
+ * Every one carries `dispatchId`, `incidentId` and `route`; none carries the
+ * reporter's name, number, address or the incident description, because a
+ * push is shown on a lock screen.
+ */
+export declare enum ResponderPushAction {
+    /** A unit the responder is on duty with was dispatched. */
+    DISPATCH_ASSIGNED = "RESPONDER_DISPATCH_ASSIGNED",
+    /** The control room stood the unit down (CANCELLED). */
+    DISPATCH_STOOD_DOWN = "RESPONDER_DISPATCH_STOOD_DOWN",
+    /** Any other status change made by somebody else (control room, lifecycle, tracking). */
+    DISPATCH_UPDATED = "RESPONDER_DISPATCH_UPDATED"
+}
+/**
+ * Machine-readable refusals of the responder endpoints, in the error body's
+ * `code` (the same `{statusCode, code, message, ...details}` envelope the
+ * dispatch endpoints use).
+ */
+export declare enum ResponderErrorCode {
+    /** The caller does not hold the Responder role. */
+    NOT_A_RESPONDER = "RESPONDER_NOT_A_RESPONDER",
+    /** The responder account has no control centre, so nothing can be scoped. */
+    NO_CONTROL_CENTRE = "RESPONDER_NO_CONTROL_CENTRE",
+    UNIT_NOT_FOUND = "RESPONDER_UNIT_NOT_FOUND",
+    /** The caller is not a member of that unit. */
+    NOT_A_UNIT_MEMBER = "RESPONDER_NOT_A_UNIT_MEMBER",
+    UNIT_INACTIVE = "RESPONDER_UNIT_INACTIVE",
+    /** Already on duty with ANOTHER unit; end that duty first. `details.activeDuty` names it. */
+    ALREADY_ON_DUTY = "RESPONDER_ALREADY_ON_DUTY",
+    NOT_ON_DUTY = "RESPONDER_NOT_ON_DUTY",
+    /** Membership: the user is not a Responder of the unit's organization and control centre. */
+    USER_NOT_ELIGIBLE = "RESPONDER_USER_NOT_ELIGIBLE",
+    ALREADY_A_MEMBER = "RESPONDER_ALREADY_A_MEMBER",
+    MEMBERSHIP_NOT_FOUND = "RESPONDER_MEMBERSHIP_NOT_FOUND",
+    /** The dispatch does not exist or is not for one of the caller's units (never says which). */
+    DISPATCH_NOT_FOUND = "RESPONDER_DISPATCH_NOT_FOUND",
+    /** The move is not one a responder may make from the current status. `details.currentStatus`. */
+    INVALID_STATUS_TRANSITION = "RESPONDER_INVALID_STATUS_TRANSITION",
+    REASON_REQUIRED = "RESPONDER_REASON_REQUIRED",
+    DECLINE_NOT_ALLOWED = "RESPONDER_DECLINE_NOT_ALLOWED",
+    MANUAL_ARRIVAL_NOT_ALLOWED = "RESPONDER_MANUAL_ARRIVAL_NOT_ALLOWED",
+    /** Completing needs the response report first (organization policy). */
+    REPORT_REQUIRED = "RESPONDER_REPORT_REQUIRED",
+    /** A report can only be written once the unit reached the scene. */
+    REPORT_NOT_ALLOWED = "RESPONDER_REPORT_NOT_ALLOWED",
+    /** The report changed since the version the client edited. `details.currentVersion`. */
+    REPORT_VERSION_CONFLICT = "RESPONDER_REPORT_VERSION_CONFLICT",
+    /** The incident is closed or archived, so its reports can no longer be amended. */
+    REPORT_LOCKED = "RESPONDER_REPORT_LOCKED",
+    /** A required report field or checklist item is missing. `details.missing`. */
+    REPORT_INCOMPLETE = "RESPONDER_REPORT_INCOMPLETE",
+    /** An attachment id is not a file the caller may link. */
+    ATTACHMENT_NOT_READABLE = "RESPONDER_ATTACHMENT_NOT_READABLE"
+}

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

@@ -0,0 +1,7 @@
+export * from './enums/responder.enums';
+export * from './interfaces/responder-policy';
+export * from './interfaces/responder';
+export * from './interfaces/responder-dispatch';
+export * from './constants/responder.const';
+export * from './dtos/responder.dto';
+export * from './utils/responder.util';

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/tracking/enums/tracking-provider-code.enum.d.ts

@@ -22,5 +22,13 @@ export declare enum TrackingProviderCode {
     /** Generic WebSocket adapter (reserved). */
     GENERIC_WEBSOCKET = "GENERIC_WEBSOCKET",
     /** Generic HTTP polling adapter (reserved). */
-    GENERIC_HTTP_POLLING = "GENERIC_HTTP_POLLING"
+    GENERIC_HTTP_POLLING = "GENERIC_HTTP_POLLING",
+    /**
+     * The responder app: the phone of the responder on duty with a unit reports
+     * the unit's position (`POST /tracking/responder/positions`). Inbound only -
+     * there is no connection to open, so the connector never runs a session
+     * for it. Used only for units with no enabled hardware tracker binding, so
+     * a vehicle's tracker and a crew member's phone never compete.
+     */
+    MOBILE_APP = "MOBILE_APP"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grm-shared-library",
-  "version": "1.1.241",
+  "version": "1.1.242",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",