grm-shared-library 1.1.240 → 1.1.242

package/dist/esm/modules/safety/enums/safety-history.enums.js

@@ -0,0 +1,27 @@
+/**
+ * Whether a session's recorded path can be drawn in its history.
+ *
+ *   RECORDED      clarion-gis holds at least one location for the session (a
+ *                 track point, or the location the device reported at start).
+ *   NOT_RECORDED  nothing was ever recorded: no trip was opened, or it holds no
+ *                 location. The map says so - it never shows where the user is now.
+ *   UNAVAILABLE   clarion-gis could not be read just now. Try again later; the
+ *                 rest of the history does not depend on it.
+ */
+export var SafetyHistoryPathStatus;
+(function (SafetyHistoryPathStatus) {
+    SafetyHistoryPathStatus["RECORDED"] = "RECORDED";
+    SafetyHistoryPathStatus["NOT_RECORDED"] = "NOT_RECORDED";
+    SafetyHistoryPathStatus["UNAVAILABLE"] = "UNAVAILABLE";
+})(SafetyHistoryPathStatus || (SafetyHistoryPathStatus = {}));
+/**
+ * Where a history timeline entry comes from: the session's lifecycle audit trail
+ * (what the user, the timer or the platform did), or - Follow Me only - what the
+ * journey monitors observed.
+ */
+export var SafetyHistoryEventSource;
+(function (SafetyHistoryEventSource) {
+    SafetyHistoryEventSource["LIFECYCLE"] = "LIFECYCLE";
+    SafetyHistoryEventSource["MONITOR"] = "MONITOR";
+})(SafetyHistoryEventSource || (SafetyHistoryEventSource = {}));
+//# sourceMappingURL=safety-history.enums.js.map

package/dist/esm/modules/safety/enums/safety-history.enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safety-history.enums.js","sourceRoot":"","sources":["../../../../../src/modules/safety/enums/safety-history.enums.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAN,IAAY,uBAIX;AAJD,WAAY,uBAAuB;IAC/B,gDAAqB,CAAA;IACrB,wDAA6B,CAAA;IAC7B,sDAA2B,CAAA;AAC/B,CAAC,EAJW,uBAAuB,KAAvB,uBAAuB,QAIlC;AAED;;;;GAIG;AACH,MAAM,CAAN,IAAY,wBAGX;AAHD,WAAY,wBAAwB;IAChC,mDAAuB,CAAA;IACvB,+CAAmB,CAAA;AACvB,CAAC,EAHW,wBAAwB,KAAxB,wBAAwB,QAGnC"}

package/dist/esm/modules/safety/index.js

@@ -3,17 +3,20 @@ export * from './enums/safety-check-status.enum';
 export * from './enums/safety-enums';
 export * from './enums/safety-error-code.enum';
 export * from './enums/follow-me.enums';
+export * from './enums/safety-history.enums';
 // Constants
 export * from './constants/safety-check-limits.const';
 export * from './constants/safety-taxonomy.const';
 export * from './constants/safety-integration.const';
 export * from './constants/follow-me.const';
+export * from './constants/safety-history.const';
 // Interfaces
 export * from './interfaces/safety-check';
 export * from './interfaces/safety-check-event';
 export * from './interfaces/safety-alert-context';
 export * from './interfaces/follow-me';
 export * from './interfaces/safety-analytics';
+export * from './interfaces/safety-history';
 // DTOs
 export * from './dtos/safety-check.dto';
 export * from './dtos/safety-admin.dto';
@@ -21,6 +24,7 @@ export * from './dtos/safety-internal.dto';
 export * from './dtos/safety-alert-context.dto';
 export * from './dtos/follow-me.dto';
 export * from './dtos/safety-analytics.dto';
+export * from './dtos/safety-history.dto';
 // Utilities
 export * from './utils/safety-check-state-machine';
 export * from './utils/safety-check-timing.util';

package/dist/esm/modules/safety/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/modules/safety/index.ts"],"names":[],"mappings":"AAAA,QAAQ;AACR,cAAc,kCAAkC,CAAC;AACjD,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC;AAExC,YAAY;AACZ,cAAc,uCAAuC,CAAC;AACtD,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,6BAA6B,CAAC;AAE5C,aAAa;AACb,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAE9C,OAAO;AACP,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAE5C,YAAY;AACZ,cAAc,oCAAoC,CAAC;AACnD,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/modules/safety/index.ts"],"names":[],"mappings":"AAAA,QAAQ;AACR,cAAc,kCAAkC,CAAC;AACjD,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAE7C,YAAY;AACZ,cAAc,uCAAuC,CAAC;AACtD,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kCAAkC,CAAC;AAEjD,aAAa;AACb,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6BAA6B,CAAC;AAE5C,OAAO;AACP,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAE1C,YAAY;AACZ,cAAc,oCAAoC,CAAC;AACnD,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC"}

package/dist/esm/modules/safety/interfaces/safety-history.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=safety-history.js.map

package/dist/esm/modules/safety/interfaces/safety-history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safety-history.js","sourceRoot":"","sources":["../../../../../src/modules/safety/interfaces/safety-history.ts"],"names":[],"mappings":""}

package/dist/esm/modules/tracking/enums/tracking-provider-code.enum.js

@@ -24,5 +24,13 @@ export var TrackingProviderCode;
     TrackingProviderCode["GENERIC_WEBSOCKET"] = "GENERIC_WEBSOCKET";
     /** Generic HTTP polling adapter (reserved). */
     TrackingProviderCode["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.
+     */
+    TrackingProviderCode["MOBILE_APP"] = "MOBILE_APP";
 })(TrackingProviderCode || (TrackingProviderCode = {}));
 //# sourceMappingURL=tracking-provider-code.enum.js.map

package/dist/esm/modules/tracking/enums/tracking-provider-code.enum.js.map

@@ -1 +1 @@
-{"version":3,"file":"tracking-provider-code.enum.js","sourceRoot":"","sources":["../../../../../src/modules/tracking/enums/tracking-provider-code.enum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAN,IAAY,oBAWX;AAXD,WAAY,oBAAoB;IAC5B,0DAA0D;IAC1D,uCAAe,CAAA;IACf,iEAAiE;IACjE,yCAAiB,CAAA;IACjB,iFAAiF;IACjF,+CAAuB,CAAA;IACvB,4CAA4C;IAC5C,+DAAuC,CAAA;IACvC,+CAA+C;IAC/C,qEAA6C,CAAA;AACjD,CAAC,EAXW,oBAAoB,KAApB,oBAAoB,QAW/B"}
+{"version":3,"file":"tracking-provider-code.enum.js","sourceRoot":"","sources":["../../../../../src/modules/tracking/enums/tracking-provider-code.enum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAN,IAAY,oBAmBX;AAnBD,WAAY,oBAAoB;IAC5B,0DAA0D;IAC1D,uCAAe,CAAA;IACf,iEAAiE;IACjE,yCAAiB,CAAA;IACjB,iFAAiF;IACjF,+CAAuB,CAAA;IACvB,4CAA4C;IAC5C,+DAAuC,CAAA;IACvC,+CAA+C;IAC/C,qEAA6C,CAAA;IAC7C;;;;;;OAMG;IACH,iDAAyB,CAAA;AAC7B,CAAC,EAnBW,oBAAoB,KAApB,oBAAoB,QAmB/B"}

package/dist/types/index.d.ts

@@ -29,6 +29,7 @@ export * from './modules/safety/index';
 export * from './modules/billing/index';
 export * from './modules/newsfeed/index';
 export * from './modules/dispatch/index';
+export * from './modules/responder/index';
 export * from './modules/incident-sla/index';
 export * from './interfaces/server-message';
 export * from './interfaces/i-request-with-user';

package/dist/types/modules/gis/dtos/trip-path-snapshot.dto.d.ts

@@ -0,0 +1,18 @@
+/** Bounds of a path snapshot - small enough for a phone to draw quickly. */
+export declare const TRIP_PATH_SNAPSHOT_LIMITS: {
+    readonly defaultMaxPoints: 500;
+    readonly minMaxPoints: 2;
+    readonly maxMaxPoints: 2000;
+};
+/**
+ * GET /trips/:tripId/path-snapshot (internal, clarion-safety only).
+ *
+ * `ownerUserId` is the user the caller has already established owns the safety
+ * record; clarion-gis refuses the read unless the trip is theirs too, so a
+ * mixed-up trip id can never draw somebody else's path.
+ */
+export declare class TripPathSnapshotQueryDto {
+    ownerUserId: number;
+    until?: string;
+    maxPoints?: number;
+}

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

@@ -16,6 +16,7 @@ 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/trip-path-snapshot.dto';
 export * from './dtos/post-gis-geometry.dto';
 export * from './dtos/route-incident.dto';
 export * from './dtos/routing-coverage-result.dto';
@@ -39,6 +40,7 @@ export * from './interfaces/point-location';
 export * from './interfaces/polygon-validation-result';
 export * from './interfaces/trip-summary';
 export * from './interfaces/trip-point';
+export * from './interfaces/trip-path-snapshot';
 export * from './interfaces/routing';
 export * from './interfaces/zone';
 export * from './interfaces/zone-for-point';

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

@@ -0,0 +1,38 @@
+import { TripPurpose } from '../enums/trip-privacy.enum';
+/** A recorded fix reduced to what a map draws. */
+export interface TripPathPoint {
+    lat: number;
+    lng: number;
+    timestamp: string;
+}
+/**
+ * A trip's recorded path, thinned for drawing on a map - what clarion-safety
+ * shows the owner of a Safety Check or Follow Me journey in their history.
+ *
+ * Everything here was recorded: the thinning only drops fixes that lie on the
+ * line between the ones kept, and the first and last fix in the window are
+ * always kept. Nothing is ever interpolated or snapped to a road.
+ */
+export interface TripPathSnapshot {
+    tripId: string;
+    purpose: TripPurpose;
+    status: string;
+    startedAt: string;
+    endedAt: string | null;
+    /**
+     * Where the device was when the trip was opened, when it reported a fix then.
+     * Not a track point, and null when the device had no fix at the start.
+     */
+    startLocation: {
+        lat: number;
+        lng: number;
+    } | null;
+    /** Fixes recorded inside the window, before thinning. */
+    totalPoints: number;
+    /** Oldest first, at most `maxPoints` of them. */
+    points: TripPathPoint[];
+    /** True when fixes were dropped to stay under `maxPoints`. */
+    simplified: boolean;
+    /** Length of the recorded path inside the window, over every fix (not the thinned ones). */
+    distanceMeters: number | null;
+}

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

@@ -215,6 +215,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';