grm-shared-library 1.1.241 → 1.1.243

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

@@ -0,0 +1,158 @@
+import { UnitsAnalyticsCount, UnitsAnalyticsDuration, UnitsAnalyticsRange, UnitsAnalyticsScope } from '../../tracking/interfaces/tracking-analytics';
+/**
+ * Units & Tracking analytics, the dispatch half: the response units sent to emergencies
+ * and what became of each - computed by clarion-incident, for the same query as
+ * TrackingAnalytics.
+ *
+ * Dispatches are counted by when they were made (`dispatchedAt`) and shown as they stand
+ * now: a dispatch made in the period and completed after it counts as completed. Times
+ * are measured between the timestamps a dispatch records. Emergencies are the period's
+ * incidents (not grievances) that reached the control room. Counts, rates and durations
+ * only - never a dispatcher, a crew's phone number, a reason someone typed or a note.
+ */
+export interface DispatchAnalyticsTotals {
+    dispatches: number;
+    /** The previous period of the same length; null for "forever". */
+    previousDispatches: number | null;
+    /** Emergencies a unit was sent to in the period. */
+    incidentsDispatched: number;
+    /** Emergencies raised in the period (reaching the control room), and those a unit was ever sent to. */
+    emergencies: number;
+    emergenciesDispatched: number;
+    /** emergenciesDispatched / emergencies, as a percentage. */
+    dispatchRate: number | null;
+    unitsDispatched: number;
+    dispatchers: number;
+    /** Dispatches per emergency dispatched in the period. */
+    unitsPerIncident: number | null;
+}
+export interface DispatchAnalyticsOutcomes {
+    /** Still out: dispatched, acknowledged, en route or on scene. */
+    active: number;
+    completed: number;
+    /** Stood down (CANCELLED) - and of those, refused by the responder. */
+    cancelled: number;
+    rejected: number;
+    /** Reached the scene. */
+    reachedScene: number;
+    /** Completed, as a percentage of the dispatches no longer out. */
+    completionRate: number | null;
+    /** Every status, in the order a dispatch lives through them, zero counts included. */
+    byStatus: UnitsAnalyticsCount[];
+    /** How the arrival was recorded (responder, control centre, inferred from tracking). */
+    arrivalBySource: UnitsAnalyticsCount[];
+    /** Who recorded each dispatch's latest status. */
+    statusBySource: UnitsAnalyticsCount[];
+}
+export interface DispatchAnalyticsTimes {
+    /** From an emergency being raised to its first unit being sent (the period's emergencies). */
+    toFirstDispatch: UnitsAnalyticsDuration;
+    /** From the unit being sent to it acknowledging, setting off, arriving and being done. */
+    toAcknowledge: UnitsAnalyticsDuration;
+    toEnRoute: UnitsAnalyticsDuration;
+    toOnScene: UnitsAnalyticsDuration;
+    /** From arriving to being done. */
+    onScene: UnitsAnalyticsDuration;
+    toComplete: UnitsAnalyticsDuration;
+}
+export interface DispatchAnalyticsRecommendation {
+    /** Dispatches made with a recommendation on screen. */
+    recommended: number;
+    /** ...that sent the recommended unit. */
+    followed: number;
+    /** ...that sent another unit, and of those, with a reason given. */
+    overridden: number;
+    overriddenWithReason: number;
+    /** Dispatches made when no unit was recommended. */
+    withoutRecommendation: number;
+    /** followed / recommended, as a percentage. */
+    followRate: number | null;
+    /** The sent unit as the recommendation saw it: how its capabilities matched, its availability, how fresh its position was. */
+    capabilityMatch: UnitsAnalyticsCount[];
+    availability: UnitsAnalyticsCount[];
+    locationFreshness: UnitsAnalyticsCount[];
+    /** Straight-line distance from the unit to the emergency when it was sent. */
+    distance: {
+        samples: number;
+        medianMetres: number | null;
+        p90Metres: number | null;
+    };
+}
+/** The dispatch message (SMS) to the crew. */
+export interface DispatchAnalyticsNotification {
+    sent: number;
+    failed: number;
+    /** Could not be sent at all: no phone number, not configured, ... */
+    notPossible: number;
+    pending: number;
+    failures: UnitsAnalyticsCount[];
+    /** sent / (sent + failed), as a percentage. */
+    deliveryRate: number | null;
+    /** From the message being requested to the provider's answer. */
+    toResult: UnitsAnalyticsDuration;
+    /** Dispatches whose message was sent more than once. */
+    resent: number;
+}
+export interface DispatchAnalyticsTimelinePoint {
+    /** Start of the bucket, ISO 8601. */
+    at: string;
+    dispatches: number;
+    completed: number;
+    cancelled: number;
+}
+export interface DispatchAnalyticsUnitRow {
+    responseUnitId: number;
+    organizationId: number;
+    /** As it was named when last sent. */
+    name: string;
+    responseUnitType: string | null;
+    dispatches: number;
+    completed: number;
+    cancelled: number;
+    rejected: number;
+    medianSecondsToAcknowledge: number | null;
+    medianSecondsToOnScene: number | null;
+    lastDispatchedAt: string;
+}
+export interface DispatchAnalyticsTypeRow {
+    responseUnitType: string;
+    dispatches: number;
+    completed: number;
+    medianSecondsToOnScene: number | null;
+}
+export interface DispatchAnalyticsHourOfWeek {
+    /** 0 = Monday ... 6 = Sunday, in the period's time zone. */
+    day: number;
+    hour: number;
+    dispatches: number;
+}
+/** Platform view only: one row per organization. */
+export interface DispatchAnalyticsOrganizationRow {
+    organizationId: number;
+    dispatches: number;
+    emergencies: number;
+    emergenciesDispatched: number;
+    completed: number;
+    medianSecondsToOnScene: number | null;
+}
+export interface DispatchAnalytics {
+    generatedAt: string;
+    range: UnitsAnalyticsRange;
+    scope: UnitsAnalyticsScope;
+    totals: DispatchAnalyticsTotals;
+    outcomes: DispatchAnalyticsOutcomes;
+    times: DispatchAnalyticsTimes;
+    recommendation: DispatchAnalyticsRecommendation;
+    notification: DispatchAnalyticsNotification;
+    timeline: DispatchAnalyticsTimelinePoint[];
+    byUnitType: DispatchAnalyticsTypeRow[];
+    /** The dispatched emergencies by their emergency type. */
+    byEmergencyType: UnitsAnalyticsCount[];
+    /** Dispatches by weekday and hour; only cells with dispatches. */
+    hourOfWeek: DispatchAnalyticsHourOfWeek[];
+    /** Units sent in the period, most dispatches first; capped (see `unitsTruncated`). */
+    units: DispatchAnalyticsUnitRow[];
+    unitsTruncated: boolean;
+    /** Platform view only; null otherwise. */
+    byOrganization: DispatchAnalyticsOrganizationRow[] | null;
+}

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

@@ -94,6 +94,7 @@ export declare enum PermissionActions {
     READ_TRACKING_POSITION = "read:tracking-position",
     READ_TRACKING_HISTORY = "read:tracking-history",
     READ_TRACKING_OPERATIONS = "read:tracking-operations",
+    READ_TRACKING_ANALYTICS = "read:tracking-analytics",
     MANAGE_TRACKING_OPERATIONS = "manage:tracking-operations",
     READ_RESPONSE_UNIT_DISPATCH = "read:response-unit-dispatch",
     CREATE_RESPONSE_UNIT_DISPATCH = "create:response-unit-dispatch",
@@ -215,6 +216,9 @@ export declare enum PermissionActions {
     READ_INCIDENT_SLA_POLICY = "read:incident-sla-policy",
     MANAGE_INCIDENT_SLA_POLICY = "manage:incident-sla-policy",
     READ_INCIDENT_SLA_ANALYTICS = "read:incident-sla-analytics",
+    USE_RESPONDER_APP = "use:responder-app",
+    RESPOND_RESPONSE_UNIT_DISPATCH = "respond:response-unit-dispatch",
+    REPORT_RESPONDER_POSITION = "report:responder-position",
     /**
      * @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

@@ -16,5 +16,6 @@ export declare enum PermissionsModule {
     ALERT_INTAKE = "Alert Intake",
     SAFETY = "Safety",
     PLACES = "Places",
-    INCIDENT_SLA = "Incident SLA"
+    INCIDENT_SLA = "Incident SLA",
+    RESPONDER = "Responder"
 }

package/dist/types/modules/responder/constants/responder.const.d.ts

@@ -0,0 +1,67 @@
+import { ResponseUnitDispatchStatus } from '../../dispatch/enums/response-unit-dispatch-status.enum';
+import { ResponderPolicy } from '../interfaces/responder-policy';
+/**
+ * The moves a responder may make on their own unit's dispatch - a strict
+ * subset of RESPONSE_UNIT_DISPATCH_TRANSITIONS.
+ *
+ * - Standing a unit down (CANCELLED) stays the control room's decision.
+ * - Declining (REJECTED) is only possible before the unit is moving, as for
+ *   the control room.
+ * - COMPLETED only from ON_SCENE: a responder who never arrived did not
+ *   complete anything; the control room stands the unit down instead.
+ * - EN_ROUTE straight from DISPATCHED is allowed: "I'm on my way" is an
+ *   acknowledgement too, and making the responder tap twice while driving off
+ *   helps nobody.
+ */
+export declare const RESPONDER_DISPATCH_TRANSITIONS: Readonly<Record<ResponseUnitDispatchStatus, readonly ResponseUnitDispatchStatus[]>>;
+/** Every status a responder may ever set. */
+export declare const RESPONDER_SETTABLE_DISPATCH_STATUSES: readonly ResponseUnitDispatchStatus[];
+export declare const RESPONDER_FIELD_LIMITS: {
+    readonly statusReason: 500;
+    readonly dutyEndReason: 300;
+    readonly reportSummary: 4000;
+    readonly reportActionsTaken: 4000;
+    readonly reportPersonsContacted: 2000;
+    readonly reportHandoverTo: 500;
+    readonly reportFollowUpNotes: 2000;
+    readonly reportRemarks: 2000;
+    readonly reportChecklistItems: 50;
+    readonly reportChecklistItemId: 64;
+    readonly reportChecklistItemLabel: 200;
+    readonly reportAttachments: 50;
+    /** Positions per POST /responder/positions. The app sends smaller batches; this bounds a backlog. */
+    readonly positionBatchSize: 100;
+    readonly dispatchPageSize: 50;
+};
+/**
+ * A position older than this is still stored in the history but never moves
+ * the unit's current position (the projector's out-of-order rule) - and the
+ * ingestion refuses anything older than the backlog window outright.
+ */
+export declare const RESPONDER_POSITION_LIMITS: {
+    /** Samples older than this are refused (an offline backlog is kept this long). */
+    readonly maxSampleAgeSeconds: number;
+    /** Samples further in the future than this (clock skew) are refused. */
+    readonly maxFutureSkewSeconds: 120;
+    /** Worse than this is refused: it would put the unit in the wrong street. */
+    readonly maxAccuracyMetres: 1000;
+};
+/**
+ * The defaults every organization starts from. An organization may override any
+ * part through `organizations.responderPolicy` (validated by ResponderPolicyDto);
+ * clarion-organization merges the override over these and serves the result in
+ * the responder profile, and clarion-incident enforces the dispatch and report
+ * parts server-side. The app only ever READS the policy - a client cannot relax
+ * it.
+ */
+export declare const DEFAULT_RESPONDER_POLICY: ResponderPolicy;
+/**
+ * Cluster-internal routes. Not proxied by the gateway; callers carry the
+ * internal service token and no user context.
+ */
+export declare const RESPONDER_INTERNAL_PATHS: {
+    /** clarion-organization: a user's units, active duty and effective policy. */
+    readonly userUnits: (userId: number) => string;
+    /** clarion-organization: who is on duty with a unit right now. */
+    readonly unitOnDuty: (responseUnitId: number) => string;
+};

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;
+}