grm-shared-library 1.1.235 → 1.1.237

package/dist/esm/modules/sms/enums/sms-template.enum.js

@@ -11,6 +11,7 @@ export var SmsTemplateType;
     SmsTemplateType["SAFETY_CHECK_GUARDIAN_ENDED"] = "safety_check_guardian_ended";
     SmsTemplateType["FOLLOW_ME_GUARDIAN_REQUEST"] = "follow_me_guardian_request";
     SmsTemplateType["FOLLOW_ME_GUARDIAN_ENDED"] = "follow_me_guardian_ended";
+    SmsTemplateType["RESPONSE_UNIT_DISPATCH"] = "response_unit_dispatch";
     SmsTemplateType["APPOINTMENT_REMINDER"] = "appointment_reminder";
     SmsTemplateType["GENERAL_NOTIFICATION"] = "general_notification";
 })(SmsTemplateType || (SmsTemplateType = {}));

package/dist/esm/modules/sms/enums/sms-template.enum.js.map

@@ -1 +1 @@
-{"version":3,"file":"sms-template.enum.js","sourceRoot":"","sources":["../../../../../src/modules/sms/enums/sms-template.enum.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,eAcX;AAdD,WAAY,eAAe;IACvB,wDAAqC,CAAA;IACrC,oDAAiC,CAAA;IACjC,sCAAmB,CAAA;IACnB,4DAAyC,CAAA;IACzC,oDAAiC,CAAA;IACjC,kEAA+C,CAAA;IAC/C,oFAAiE,CAAA;IACjE,kFAA+D,CAAA;IAC/D,8EAA2D,CAAA;IAC3D,4EAAyD,CAAA;IACzD,wEAAqD,CAAA;IACrD,gEAA6C,CAAA;IAC7C,gEAA6C,CAAA;AACjD,CAAC,EAdW,eAAe,KAAf,eAAe,QAc1B"}
+{"version":3,"file":"sms-template.enum.js","sourceRoot":"","sources":["../../../../../src/modules/sms/enums/sms-template.enum.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,eAeX;AAfD,WAAY,eAAe;IACvB,wDAAqC,CAAA;IACrC,oDAAiC,CAAA;IACjC,sCAAmB,CAAA;IACnB,4DAAyC,CAAA;IACzC,oDAAiC,CAAA;IACjC,kEAA+C,CAAA;IAC/C,oFAAiE,CAAA;IACjE,kFAA+D,CAAA;IAC/D,8EAA2D,CAAA;IAC3D,4EAAyD,CAAA;IACzD,wEAAqD,CAAA;IACrD,oEAAiD,CAAA;IACjD,gEAA6C,CAAA;IAC7C,gEAA6C,CAAA;AACjD,CAAC,EAfW,eAAe,KAAf,eAAe,QAe1B"}

package/dist/types/index.d.ts

@@ -28,6 +28,7 @@ export * from './modules/alert-intake/index';
 export * from './modules/safety/index';
 export * from './modules/billing/index';
 export * from './modules/newsfeed/index';
+export * from './modules/dispatch/index';
 export * from './interfaces/server-message';
 export * from './interfaces/i-request-with-user';
 export * from './interfaces/validated-user';

package/dist/types/kafka/topics.d.ts

@@ -24,6 +24,10 @@ export declare const KAFKA_TOPICS: {
     INCIDENT_ASSIGNED: string;
     INCIDENT_ASSIGNMENT_CREATED: string;
     INCIDENT_RESPONSE_UNIT_ASSIGNMENT_CREATED: string;
+    INCIDENT_RESPONSE_UNIT_DISPATCH_CREATED: string;
+    INCIDENT_RESPONSE_UNIT_DISPATCH_STATUS_CHANGED: string;
+    INCIDENT_RESPONSE_UNIT_DISPATCH_NOTIFICATION_REQUESTED: string;
+    RESPONSE_UNIT_DISPATCH_NOTIFICATION_RESULT: string;
     CHAT_MESSAGE_CREATED: string;
     CHAT_CONVERSATION_CREATED: string;
     CHAT_PRESENCE_UPDATED: string;

package/dist/types/modules/dispatch/constants/response-unit-dispatch-defaults.const.d.ts

@@ -0,0 +1,43 @@
+import { ResponseUnitDispatchStatus } from '../enums/response-unit-dispatch-status.enum';
+/**
+ * The statuses in which a unit is out on a job. Exactly the set the partial
+ * unique index in clarion-incident covers - a unit may hold one of these at a
+ * time, platform-wide. Change one, change the other (and write a migration).
+ */
+export declare const ACTIVE_RESPONSE_UNIT_DISPATCH_STATUSES: readonly ResponseUnitDispatchStatus[];
+export declare const TERMINAL_RESPONSE_UNIT_DISPATCH_STATUSES: readonly ResponseUnitDispatchStatus[];
+/** Free-text lengths, shared by the DTOs and the columns that store them. */
+export declare const RESPONSE_UNIT_DISPATCH_FIELD_LIMITS: {
+    readonly overrideReason: 500;
+    readonly notes: 1000;
+    readonly statusReason: 500;
+    /** The gateway drops a longer Idempotency-Key, so nothing longer ever arrives. */
+    readonly idempotencyKey: 200;
+    /** The incident description as quoted in a dispatch message. */
+    readonly messageSummary: 160;
+    readonly messageAddress: 160;
+};
+/**
+ * Defaults for the recommendation. Each is overridable by the consuming
+ * service's configuration; these are what an unconfigured deployment does.
+ */
+export declare const RESPONSE_UNIT_RECOMMENDATION_DEFAULTS: {
+    /** Recommendable units shown after the recommended one. */
+    readonly maxAlternatives: 5;
+    /** The "every other unit" list for manual selection. */
+    readonly maxOtherUnits: 50;
+    /** How far the live GEO search looks. Country-scale: a control room covers a region. */
+    readonly searchRadiusMetres: 200000;
+    /** How many live units the GEO search returns, nearest first. */
+    readonly liveCandidateLimit: 100;
+    /** How many top candidates get a road travel time, when routing is enabled. */
+    readonly travelTimeCandidates: 3;
+    /** Units in one recommendation's catalogue before it is truncated. */
+    readonly maxCatalogueUnits: 2000;
+};
+/** Bounds a nearby query accepts. */
+export declare const RESPONSE_UNIT_NEARBY_LIMITS: {
+    readonly minRadiusMetres: 100;
+    readonly maxRadiusMetres: 2000000;
+    readonly maxLimit: 500;
+};

package/dist/types/modules/dispatch/constants/response-unit-dispatch-kafka.const.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Grouped view of the response-unit dispatch topics. The strings live in
+ * {@link KAFKA_TOPICS} with every other domain's; this only references them.
+ *
+ * Producer clarion-incident (CREATED, STATUS_CHANGED, NOTIFICATION_REQUESTED),
+ * keyed by incident id so one incident's dispatch history stays in order.
+ * Producer clarion-notification (NOTIFICATION_RESULT), keyed by incident id.
+ */
+export declare const RESPONSE_UNIT_DISPATCH_KAFKA_TOPICS: {
+    readonly CREATED: string;
+    readonly STATUS_CHANGED: string;
+    readonly NOTIFICATION_REQUESTED: string;
+    readonly NOTIFICATION_RESULT: string;
+};
+/** Current schema version of every response-unit dispatch event. */
+export declare const RESPONSE_UNIT_DISPATCH_SCHEMA_VERSION: 1;

package/dist/types/modules/dispatch/dtos/dispatch-response-unit.dto.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `POST /incidents/:id/response-unit-dispatches` - send this unit.
+ *
+ * Only the unit is a decision. Organization, control centre and incident come
+ * from the server's own records, never from this body. Idempotent on the
+ * `Idempotency-Key` header: a repeated request returns the dispatch the first
+ * one created.
+ */
+export declare class DispatchResponseUnitDto {
+    responseUnitId: number;
+    /**
+     * The unit the dispatcher's screen showed as recommended. Informational - the
+     * server recomputes its own recommendation and records both - but it lets
+     * the audit say what the dispatcher actually saw.
+     */
+    recommendedResponseUnitId?: number | null;
+    /** Optional, never required: why another unit than the recommended one. */
+    overrideReason?: string;
+    notes?: string;
+}

package/dist/types/modules/dispatch/dtos/response-unit-dispatch-notification.dto.d.ts

@@ -0,0 +1,47 @@
+import { ResponseUnitDispatchNotificationFailure } from '../enums/response-unit-dispatch-notification-failure.enum';
+import { ResponseUnitDispatchNotificationStatus } from '../enums/response-unit-dispatch-notification-status.enum';
+import { ResponseUnitDispatchMessageIncident, ResponseUnitDispatchNotificationRequestedEventV1, ResponseUnitDispatchNotificationResultEventV1 } from '../interfaces/response-unit-dispatch-events';
+export declare class ResponseUnitDispatchMessageIncidentDto implements ResponseUnitDispatchMessageIncident {
+    reference: string;
+    typeName: string | null;
+    categoryName: string | null;
+    priority: string | null;
+    summary: string | null;
+    address: string | null;
+    latitude: number | null;
+    longitude: number | null;
+    reporterName: string | null;
+    reporterPhoneNumber: string | null;
+    anonymous: boolean;
+}
+export declare class ResponseUnitDispatchRecipientDto {
+    phoneNumber: string;
+    responseUnitName: string;
+}
+export declare class ResponseUnitDispatchNotificationRequestedDto implements ResponseUnitDispatchNotificationRequestedEventV1 {
+    schemaVersion: 1;
+    eventId: string;
+    occurredAt: string;
+    dispatchId: number;
+    dispatchReference: string;
+    incidentId: number;
+    organizationId: number;
+    controlCentreId: number | null;
+    responseUnitId: number;
+    attempt: number;
+    appId: string | null;
+    recipient: ResponseUnitDispatchRecipientDto;
+    incident: ResponseUnitDispatchMessageIncidentDto;
+}
+export declare class ResponseUnitDispatchNotificationResultDto implements ResponseUnitDispatchNotificationResultEventV1 {
+    schemaVersion: 1;
+    eventId: string;
+    occurredAt: string;
+    dispatchId: number;
+    incidentId: number;
+    organizationId: number;
+    attempt: number;
+    status: ResponseUnitDispatchNotificationStatus;
+    failureReason: ResponseUnitDispatchNotificationFailure | null;
+    providerCode: string | null;
+}

package/dist/types/modules/dispatch/dtos/response-unit-dispatch-profile-query.dto.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `GET /response-units/dispatch-profiles` (clarion-organization, internal).
+ *
+ * Scoped by the forwarded user context; `organizationId` is honoured for a
+ * Super-Admin only. `includeContact` adds the unit's phone number and is used by
+ * the dispatch command alone - a recommendation never carries one.
+ */
+export declare class ResponseUnitDispatchProfileQueryDto {
+    organizationId?: number;
+    controlCentreId?: number;
+    ids?: number[];
+    includeContact?: boolean;
+}

package/dist/types/modules/dispatch/dtos/response-unit-nearby-query.dto.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `GET /tracking/response-units/nearby` (clarion-response-tracking).
+ *
+ * Tenancy is NOT in the query: the tracking service takes it from the forwarded
+ * user context. `organizationId` is honoured for a Super-Admin only and a
+ * control-centre caller is pinned to their own centre whatever they pass.
+ */
+export declare class ResponseUnitNearbyQueryDto {
+    latitude: number;
+    longitude: number;
+    organizationId?: number;
+    controlCentreId?: number;
+    radiusMetres?: number;
+    limit?: number;
+}

package/dist/types/modules/dispatch/dtos/update-response-unit-dispatch-status.dto.d.ts

@@ -0,0 +1,9 @@
+import { ResponseUnitDispatchStatus } from '../enums/response-unit-dispatch-status.enum';
+/** Every status a dispatch can be MOVED to (DISPATCHED is only ever its first). */
+export declare const SETTABLE_RESPONSE_UNIT_DISPATCH_STATUSES: readonly ResponseUnitDispatchStatus[];
+/** `POST /incidents/:id/response-unit-dispatches/:dispatchId/status`. */
+export declare class UpdateResponseUnitDispatchStatusDto {
+    status: ResponseUnitDispatchStatus;
+    /** Why - e.g. why a unit was stood down. */
+    reason?: string;
+}

package/dist/types/modules/dispatch/enums/incident-dispatch-blocker.enum.d.ts

@@ -0,0 +1,16 @@
+/** Why an INCIDENT cannot take a response-unit dispatch, whatever unit is chosen. */
+export declare enum IncidentDispatchBlocker {
+    /** Resolved, closed, unresolved or archived. */
+    INCIDENT_ENDED = "INCIDENT_ENDED",
+    /** A grievance, not an emergency. */
+    NOT_AN_EMERGENCY_INCIDENT = "NOT_AN_EMERGENCY_INCIDENT",
+    /**
+     * The incident does not reach the control room: the reporter was not
+     * entitled to a provider response, or declined one. Sending a unit IS the
+     * provider response, so the rule that keeps the alert off the control room's
+     * screens also keeps it from being dispatched - see `reachesControlRoom`.
+     */
+    PROVIDER_RESPONSE_NOT_REQUESTED = "PROVIDER_RESPONSE_NOT_REQUESTED",
+    /** Response-unit dispatch is switched off platform-wide. */
+    DISPATCH_DISABLED = "DISPATCH_DISABLED"
+}

package/dist/types/modules/dispatch/enums/response-capability-requirement-source.enum.d.ts

@@ -0,0 +1,7 @@
+/** Where an incident's capability requirement came from. */
+export declare enum ResponseCapabilityRequirementSource {
+    INCIDENT_TYPE = "INCIDENT_TYPE",
+    INCIDENT_CATEGORY = "INCIDENT_CATEGORY",
+    /** Neither the type nor the category names one. */
+    NONE = "NONE"
+}

package/dist/types/modules/dispatch/enums/response-unit-capability-match.enum.d.ts

@@ -0,0 +1,19 @@
+/**
+ * How a unit's capabilities compare with what the incident needs.
+ *
+ * UNKNOWN and NOT_SUITED are deliberately different answers: UNKNOWN means
+ * nobody said what the unit does (it ranks below a match but stays
+ * recommendable), NOT_SUITED means somebody did and it is not this. Treating
+ * missing configuration as "not suitable" would hide every unit of an
+ * organization that has not configured capabilities yet.
+ */
+export declare enum ResponseUnitCapabilityMatch {
+    /** The incident needs a capability and the unit has one of them. */
+    MATCH = "MATCH",
+    /** The incident's type and category name no requirement - any unit fits. */
+    NOT_REQUIRED = "NOT_REQUIRED",
+    /** The incident needs a capability; the unit's capabilities are unknown. */
+    UNKNOWN = "UNKNOWN",
+    /** The unit's known capabilities do not include what the incident needs. */
+    NOT_SUITED = "NOT_SUITED"
+}

package/dist/types/modules/dispatch/enums/response-unit-dispatch-constraint.enum.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Why a unit cannot be dispatched (a BLOCKER) or, while it can be dispatched by
+ * hand, is not recommended (a CAUTION). One vocabulary for both so the admin
+ * explains either with the same words.
+ */
+export declare enum ResponseUnitDispatchConstraint {
+    /** Switched off in the organization. */
+    INACTIVE = "INACTIVE",
+    /** Non-operational, off duty, on leave or in training. */
+    OPERATIONALLY_UNAVAILABLE = "OPERATIONALLY_UNAVAILABLE",
+    /** Out on another job (an active dispatch, or a manual Engaged / On Mission status). */
+    ENGAGED = "ENGAGED",
+    /** Already has an active dispatch to THIS incident. */
+    ALREADY_DISPATCHED = "ALREADY_DISPATCHED",
+    /** Belongs to another control centre and cross-control-centre dispatch is off. */
+    OTHER_CONTROL_CENTRE = "OTHER_CONTROL_CENTRE",
+    /** Not suited, and the platform is configured to require a capability match. */
+    CAPABILITY_REQUIRED = "CAPABILITY_REQUIRED",
+    /** Its known capabilities do not include what the incident needs. */
+    NOT_SUITED = "NOT_SUITED",
+    /** No position at all, or the tracking service has it offline. */
+    NO_LOCATION = "NO_LOCATION",
+    /** A stale live fix, and stale positions are configured not to be recommended. */
+    LOCATION_STALE = "LOCATION_STALE",
+    /** Live-tracked, but outside the search radius. */
+    OUTSIDE_SEARCH_AREA = "OUTSIDE_SEARCH_AREA"
+}

package/dist/types/modules/dispatch/enums/response-unit-dispatch-error-code.enum.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Machine-readable codes on a refused recommend/dispatch request (the `code` of
+ * the error body), so a client can react without parsing a sentence. A 409 says
+ * "the world changed since you looked - refresh"; other 4xx say "this was never
+ * going to work".
+ */
+export declare enum ResponseUnitDispatchErrorCode {
+    INCIDENT_NOT_DISPATCHABLE = "INCIDENT_NOT_DISPATCHABLE",
+    RESPONSE_UNIT_NOT_FOUND = "RESPONSE_UNIT_NOT_FOUND",
+    RESPONSE_UNIT_NOT_DISPATCHABLE = "RESPONSE_UNIT_NOT_DISPATCHABLE",
+    /** Another dispatcher got there first - the unit is out on a job. */
+    RESPONSE_UNIT_ENGAGED = "RESPONSE_UNIT_ENGAGED",
+    RESPONSE_UNIT_ALREADY_DISPATCHED = "RESPONSE_UNIT_ALREADY_DISPATCHED",
+    /** The same Idempotency-Key was used for a different unit. */
+    IDEMPOTENCY_KEY_REUSED = "IDEMPOTENCY_KEY_REUSED",
+    DISPATCH_NOT_FOUND = "DISPATCH_NOT_FOUND",
+    INVALID_STATUS_TRANSITION = "INVALID_STATUS_TRANSITION",
+    NOTIFICATION_NOT_RESENDABLE = "NOTIFICATION_NOT_RESENDABLE",
+    /** clarion-organization could not be reached: nothing can be verified, so nothing is sent. */
+    ORGANIZATION_UNAVAILABLE = "ORGANIZATION_UNAVAILABLE"
+}

package/dist/types/modules/dispatch/enums/response-unit-dispatch-notification-failure.enum.d.ts

@@ -0,0 +1,13 @@
+/** Why a dispatch message was not sent. */
+export declare enum ResponseUnitDispatchNotificationFailure {
+    /** The unit has no phone number. */
+    NO_PHONE_NUMBER = "NO_PHONE_NUMBER",
+    /** The number on the unit is not one any provider can send to. */
+    INVALID_PHONE_NUMBER = "INVALID_PHONE_NUMBER",
+    /** Every provider in the country's chain failed. */
+    PROVIDER_FAILURE = "PROVIDER_FAILURE",
+    /** No SMS provider is configured for the number's country. */
+    NOT_CONFIGURED = "NOT_CONFIGURED",
+    /** clarion-notification never answered, so nobody knows. Sending again is the remedy. */
+    NO_RESPONSE = "NO_RESPONSE"
+}

package/dist/types/modules/dispatch/enums/response-unit-dispatch-notification-status.enum.d.ts

@@ -0,0 +1,11 @@
+/** What happened to the message telling the unit it was dispatched. */
+export declare enum ResponseUnitDispatchNotificationStatus {
+    /** Requested from clarion-notification; no answer yet. */
+    PENDING = "PENDING",
+    /** A provider accepted it. (Handset delivery is not tracked by the platform.) */
+    SENT = "SENT",
+    /** Every provider refused or failed; it can be sent again. */
+    FAILED = "FAILED",
+    /** Could never be sent - the unit has no usable phone number. The dispatch stands. */
+    NOT_POSSIBLE = "NOT_POSSIBLE"
+}

package/dist/types/modules/dispatch/enums/response-unit-dispatch-status.enum.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Where one response unit is in answering one incident.
+ *
+ * Only DISPATCHED is set by the dispatch command itself. The middle states exist
+ * so the record can be advanced by whoever learns of progress - a dispatcher
+ * relaying a radio call today, the responder app or clarion-workflow later -
+ * without a schema change. Nothing in this platform advances them on a timer:
+ * escalation, reassignment and SLA belong to the workflow layer.
+ *
+ * ACTIVE = DISPATCHED, ACKNOWLEDGED, EN_ROUTE, ON_SCENE. A unit may hold at most
+ * ONE active dispatch across every incident - a partial unique index in
+ * clarion-incident enforces it, which is what stops two dispatchers sending the
+ * same unit to two emergencies.
+ */
+export declare enum ResponseUnitDispatchStatus {
+    /** Sent: the command was accepted and the unit was asked to respond. */
+    DISPATCHED = "DISPATCHED",
+    /** The unit confirmed it received the job. */
+    ACKNOWLEDGED = "ACKNOWLEDGED",
+    /** On the way. */
+    EN_ROUTE = "EN_ROUTE",
+    /** Arrived at the incident. */
+    ON_SCENE = "ON_SCENE",
+    /** Finished - by the dispatcher, or because the incident itself ended. */
+    COMPLETED = "COMPLETED",
+    /** Stood down before finishing. Frees the unit. */
+    CANCELLED = "CANCELLED"
+}

package/dist/types/modules/dispatch/enums/response-unit-dispatch-transition-source.enum.d.ts

@@ -0,0 +1,11 @@
+/** Who moved a dispatch to its current status. Recorded for the audit trail. */
+export declare enum ResponseUnitDispatchTransitionSource {
+    /** A control-room user, through the admin or the API. */
+    DISPATCHER = "DISPATCHER",
+    /** The incident ended (resolved, closed...), so its active dispatches were completed. */
+    INCIDENT_LIFECYCLE = "INCIDENT_LIFECYCLE",
+    /** Reserved for the responder app. */
+    RESPONDER = "RESPONDER",
+    /** Reserved for clarion-workflow orchestration. */
+    WORKFLOW = "WORKFLOW"
+}

package/dist/types/modules/dispatch/enums/response-unit-distance-basis.enum.d.ts

@@ -0,0 +1,7 @@
+/** What a candidate's distance (and duration, when present) measures. */
+export declare enum ResponseUnitDistanceBasis {
+    /** Great-circle distance. Always available, never a duration. */
+    STRAIGHT_LINE = "STRAIGHT_LINE",
+    /** A road route from clarion-gis (Google Routes), with a travel time. */
+    ROAD_ROUTE = "ROAD_ROUTE"
+}

package/dist/types/modules/dispatch/enums/response-unit-location-freshness.enum.d.ts

@@ -0,0 +1,16 @@
+/**
+ * How far a candidate's position can be trusted.
+ *
+ * Not a new set of thresholds: CURRENT and STALE are clarion-response-tracking's
+ * own ONLINE / STALE status, which it evaluates against each provider
+ * connection's configured staleAfterSeconds / offlineAfterSeconds. A unit the
+ * tracking service calls OFFLINE has no usable position here (UNKNOWN).
+ */
+export declare enum ResponseUnitLocationFreshness {
+    /** A live fix within the provider's stale threshold. */
+    CURRENT = "CURRENT",
+    /** A live fix older than the stale threshold but not yet offline. */
+    STALE = "STALE",
+    /** No live fix that can be relied on: offline, never tracked, or base-only. */
+    UNKNOWN = "UNKNOWN"
+}

package/dist/types/modules/dispatch/enums/response-unit-location-source.enum.d.ts

@@ -0,0 +1,12 @@
+/** Where a candidate's position came from. */
+export declare enum ResponseUnitLocationSource {
+    /** A GPS fix from clarion-response-tracking. */
+    LIVE = "LIVE",
+    /**
+     * The unit's configured base location in clarion-organization - used only
+     * for a unit that is not live-tracked at all, and always labelled as such.
+     */
+    BASE = "BASE",
+    /** No usable position. */
+    NONE = "NONE"
+}

package/dist/types/modules/dispatch/enums/response-unit-recommendation-reason.enum.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The facts a recommendation rests on, in the order the ranking weighs them.
+ * The admin turns these into the "Recommended because:" lines; the numbers
+ * behind them (distance, age) travel on the candidate itself.
+ */
+export declare enum ResponseUnitRecommendationReason {
+    AVAILABLE = "AVAILABLE",
+    CAPABILITY_MATCH = "CAPABILITY_MATCH",
+    NO_CAPABILITY_REQUIREMENT = "NO_CAPABILITY_REQUIREMENT",
+    CAPABILITY_UNKNOWN = "CAPABILITY_UNKNOWN",
+    SAME_CONTROL_CENTRE = "SAME_CONTROL_CENTRE",
+    OTHER_CONTROL_CENTRE = "OTHER_CONTROL_CENTRE",
+    LIVE_LOCATION_CURRENT = "LIVE_LOCATION_CURRENT",
+    LIVE_LOCATION_STALE = "LIVE_LOCATION_STALE",
+    BASE_LOCATION = "BASE_LOCATION",
+    /** Closest of the units that tie on everything above. */
+    NEAREST = "NEAREST",
+    /** Quickest by road of the units that tie on everything above. */
+    QUICKEST = "QUICKEST"
+}

package/dist/types/modules/dispatch/enums/response-unit-recommendation-status.enum.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The overall answer. NO_UNITS_CONFIGURED and NO_ELIGIBLE_UNITS are different
+ * operational facts and the admin treats them differently: the first hides the
+ * whole dispatch panel (this control room simply has no units), the second is
+ * an alarm (it has units and none can go).
+ */
+export declare enum ResponseUnitRecommendationStatus {
+    /** A unit is recommended. */
+    RECOMMENDED = "RECOMMENDED",
+    /** Some units can be dispatched by hand, but none qualifies for a recommendation. */
+    NO_RECOMMENDATION = "NO_RECOMMENDATION",
+    /** Units exist and none of them can be dispatched. */
+    NO_ELIGIBLE_UNITS = "NO_ELIGIBLE_UNITS",
+    /** The caller's scope holds no response units at all. */
+    NO_UNITS_CONFIGURED = "NO_UNITS_CONFIGURED",
+    /** The incident itself cannot take a dispatch (see the blockers). */
+    NOT_DISPATCHABLE = "NOT_DISPATCHABLE"
+}

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

@@ -0,0 +1,31 @@
+export * from './enums/response-unit-dispatch-status.enum';
+export * from './enums/response-unit-dispatch-transition-source.enum';
+export * from './enums/response-unit-capability-match.enum';
+export * from './enums/response-capability-requirement-source.enum';
+export * from './enums/response-unit-location-source.enum';
+export * from './enums/response-unit-location-freshness.enum';
+export * from './enums/response-unit-distance-basis.enum';
+export * from './enums/response-unit-dispatch-constraint.enum';
+export * from './enums/response-unit-recommendation-reason.enum';
+export * from './enums/response-unit-recommendation-status.enum';
+export * from './enums/incident-dispatch-blocker.enum';
+export * from './enums/response-unit-dispatch-notification-status.enum';
+export * from './enums/response-unit-dispatch-notification-failure.enum';
+export * from './enums/response-unit-dispatch-error-code.enum';
+export * from './interfaces/response-unit-dispatch-profile';
+export * from './interfaces/response-unit-proximity';
+export * from './interfaces/response-unit-recommendation';
+export * from './interfaces/incident-response-unit-dispatch';
+export * from './interfaces/response-unit-dispatch-events';
+export * from './constants/response-unit-dispatch-kafka.const';
+export * from './constants/response-unit-dispatch-defaults.const';
+export * from './dtos/dispatch-response-unit.dto';
+export * from './dtos/update-response-unit-dispatch-status.dto';
+export * from './dtos/response-unit-nearby-query.dto';
+export * from './dtos/response-unit-dispatch-profile-query.dto';
+export * from './dtos/response-unit-dispatch-notification.dto';
+export * from './utils/response-unit-dispatch-status.util';
+export * from './utils/response-capability-match.util';
+export * from './utils/incident-dispatchability.util';
+export * from './utils/dispatch-geo.util';
+export * from './utils/response-unit-dispatch-event.util';

package/dist/types/modules/dispatch/interfaces/incident-response-unit-dispatch.d.ts

@@ -0,0 +1,121 @@
+import { ResponseCapability } from '../../response-unit/enums/response-unit/response-capability.enum';
+import { ResponseUnitAvailability } from '../../response-unit/enums/response-unit/response-unit-availability.enum';
+import { ResponseCapabilityRequirementSource } from '../enums/response-capability-requirement-source.enum';
+import { ResponseUnitCapabilityMatch } from '../enums/response-unit-capability-match.enum';
+import { ResponseUnitDispatchNotificationFailure } from '../enums/response-unit-dispatch-notification-failure.enum';
+import { ResponseUnitDispatchNotificationStatus } from '../enums/response-unit-dispatch-notification-status.enum';
+import { ResponseUnitDispatchStatus } from '../enums/response-unit-dispatch-status.enum';
+import { ResponseUnitDispatchTransitionSource } from '../enums/response-unit-dispatch-transition-source.enum';
+import { ResponseUnitLocationFreshness } from '../enums/response-unit-location-freshness.enum';
+import { ResponseUnitLocationSource } from '../enums/response-unit-location-source.enum';
+import { ResponseUnitRecommendationStatus } from '../enums/response-unit-recommendation-status.enum';
+/** The selected unit as it stood when it was dispatched - frozen for the audit. */
+export interface ResponseUnitDispatchUnitSnapshot {
+    availability: ResponseUnitAvailability;
+    operationalStatus: string | null;
+    capabilities: ResponseCapability[];
+    capabilityMatch: ResponseUnitCapabilityMatch;
+    sameControlCentre: boolean;
+    locationSource: ResponseUnitLocationSource;
+    locationFreshness: ResponseUnitLocationFreshness;
+    locationRecordedAt: string | null;
+    locationAgeSeconds: number | null;
+    distanceMetres: number | null;
+    hasPhoneNumber: boolean;
+}
+/** One ranked alternative, as it stood at dispatch time. */
+export interface ResponseUnitDispatchSnapshotCandidate {
+    responseUnitId: number;
+    rank: number;
+    distanceMetres: number | null;
+    capabilityMatch: ResponseUnitCapabilityMatch;
+    locationFreshness: ResponseUnitLocationFreshness;
+}
+/**
+ * The recommendation the SERVER computed at the moment it accepted the
+ * dispatch. Recomputed rather than taken from the client, so "was the selected
+ * unit the recommended one?" is a fact, not a claim.
+ */
+export interface ResponseUnitDispatchRecommendationSnapshot {
+    generatedAt: string;
+    status: ResponseUnitRecommendationStatus;
+    recommendedResponseUnitId: number | null;
+    /** The recommended unit first, then the alternatives, capped. */
+    ranked: ResponseUnitDispatchSnapshotCandidate[];
+    requiredCapabilities: ResponseCapability[];
+    requirementSource: ResponseCapabilityRequirementSource;
+    liveTrackingAvailable: boolean;
+}
+/** Where the dispatch message stands. */
+export interface ResponseUnitDispatchNotificationState {
+    channel: 'SMS';
+    status: ResponseUnitDispatchNotificationStatus;
+    failureReason: ResponseUnitDispatchNotificationFailure | null;
+    /** Masked (+2547******78). The full number is never stored on the dispatch. */
+    recipient: string | null;
+    /** How many times it was requested (1 + resends). */
+    attempts: number;
+    requestedAt: string | null;
+    /** When clarion-notification last reported on it. */
+    resultAt: string | null;
+    providerCode: string | null;
+}
+/**
+ * One response unit sent to one incident. The authoritative dispatch record,
+ * owned by clarion-incident - and the engagement record: a unit is out on a job
+ * exactly while it has a dispatch in an ACTIVE status.
+ *
+ * Channel-neutral on purpose: the admin reads it today, the responder app and
+ * clarion-workflow can read the same record (and the events built from it)
+ * tomorrow.
+ */
+export interface IncidentResponseUnitDispatch {
+    id: number;
+    /** Stable external identifier (uuid), safe to quote in a call or a ticket. */
+    reference: string;
+    incidentId: number;
+    organizationId: number;
+    /** The incident's control centre. */
+    controlCentreId: number | null;
+    responseUnitId: number;
+    /** Copied at dispatch time so the record survives the unit being renamed or deleted. */
+    responseUnitName: string;
+    responseUnitType: string | null;
+    responseUnitControlCentreId: number | null;
+    status: ResponseUnitDispatchStatus;
+    dispatchedByUserId: number;
+    dispatchedAt: string;
+    /** The server's recommendation at dispatch time named this unit. */
+    wasRecommended: boolean;
+    /** The unit the server would have recommended at dispatch time. */
+    recommendedResponseUnitId: number | null;
+    /** The unit the dispatcher's screen showed as recommended (as reported by the client). */
+    shownRecommendedResponseUnitId: number | null;
+    /** Optional words from a dispatcher who chose another unit. */
+    overrideReason: string | null;
+    notes: string | null;
+    distanceMetres: number | null;
+    unitSnapshot: ResponseUnitDispatchUnitSnapshot;
+    recommendationSnapshot: ResponseUnitDispatchRecommendationSnapshot | null;
+    statusChangedAt: string;
+    statusChangedByUserId: number | null;
+    statusSource: ResponseUnitDispatchTransitionSource;
+    statusReason: string | null;
+    acknowledgedAt: string | null;
+    enRouteAt: string | null;
+    onSceneAt: string | null;
+    completedAt: string | null;
+    cancelledAt: string | null;
+    notification: ResponseUnitDispatchNotificationState;
+    createdAt: string;
+    updatedAt: string;
+}
+/** `POST /incidents/:id/response-unit-dispatches`. */
+export interface DispatchResponseUnitResult {
+    dispatch: IncidentResponseUnitDispatch;
+    /**
+     * True when this request repeated an earlier one (same Idempotency-Key) and
+     * the EXISTING dispatch is returned - nothing was dispatched or sent again.
+     */
+    replayed: boolean;
+}