grm-shared-library 1.1.236 → 1.1.237

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

@@ -0,0 +1,45 @@
+import { TrackingUnitOnlineStatus } from '../../tracking/enums/tracking-unit-online-status.enum';
+/**
+ * One live-tracked unit near a point, as clarion-response-tracking answers
+ * `GET /tracking/response-units/nearby`.
+ *
+ * Found through the tracking service's Redis GEO index (maintained on every
+ * GPS fix), so the answer never involves reading every unit's state. The
+ * distance is great-circle, computed by Redis from the same position the live
+ * map shows.
+ */
+export interface ResponseUnitLivePosition {
+    responseUnitId: number;
+    organizationId: number;
+    controlCentreId: number | null;
+    latitude: number;
+    longitude: number;
+    /** Straight-line distance from the query point. */
+    distanceMetres: number;
+    /** The tracking service's own ONLINE / STALE / OFFLINE classification. */
+    status: TrackingUnitOnlineStatus;
+    /** When the fix was taken (provider time). */
+    eventTime: string;
+    /** Seconds between `eventTime` and the moment the answer was produced. */
+    ageSeconds: number;
+    accuracyMetres: number | null;
+}
+export interface ResponseUnitNearbyResult {
+    organizationId: number;
+    /** Set when the answer was confined to one control centre. */
+    controlCentreId: number | null;
+    latitude: number;
+    longitude: number;
+    radiusMetres: number;
+    limit: number;
+    generatedAt: string;
+    /** Nearest first. */
+    units: ResponseUnitLivePosition[];
+    /**
+     * Units in scope that ARE live-tracked but were not returned - beyond the
+     * radius or past the limit. Lets a consumer say "outside the search area"
+     * instead of falling back to a base location that would put a moving vehicle
+     * back in its depot.
+     */
+    outsideSearchUnitIds: number[];
+}

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

@@ -0,0 +1,130 @@
+import { ResponseCapability } from '../../response-unit/enums/response-unit/response-capability.enum';
+import { ResponseUnitAvailability } from '../../response-unit/enums/response-unit/response-unit-availability.enum';
+import { IncidentDispatchBlocker } from '../enums/incident-dispatch-blocker.enum';
+import { ResponseCapabilityRequirementSource } from '../enums/response-capability-requirement-source.enum';
+import { ResponseUnitCapabilityMatch } from '../enums/response-unit-capability-match.enum';
+import { ResponseUnitDispatchConstraint } from '../enums/response-unit-dispatch-constraint.enum';
+import { ResponseUnitDistanceBasis } from '../enums/response-unit-distance-basis.enum';
+import { ResponseUnitLocationFreshness } from '../enums/response-unit-location-freshness.enum';
+import { ResponseUnitLocationSource } from '../enums/response-unit-location-source.enum';
+import { ResponseUnitRecommendationReason } from '../enums/response-unit-recommendation-reason.enum';
+import { ResponseUnitRecommendationStatus } from '../enums/response-unit-recommendation-status.enum';
+import { IncidentResponseUnitDispatch } from './incident-response-unit-dispatch';
+/** What the incident needs, and where that came from. */
+export interface ResponseCapabilityRequirement {
+    /** A unit with ANY of these is suitable. Empty = no requirement. */
+    capabilities: ResponseCapability[];
+    source: ResponseCapabilityRequirementSource;
+}
+/** Where a candidate is, and how far that can be trusted. */
+export interface ResponseUnitCandidateLocation {
+    source: ResponseUnitLocationSource;
+    freshness: ResponseUnitLocationFreshness;
+    latitude: number | null;
+    longitude: number | null;
+    /** When the position was recorded. Null for a base location. */
+    recordedAt: string | null;
+    /** Age of the position when the recommendation was produced. */
+    ageSeconds: number | null;
+    accuracyMetres: number | null;
+}
+/** How far, and - when road routing is on - how long. */
+export interface ResponseUnitTravelEstimate {
+    distanceMetres: number;
+    /** Only for a road route; a straight line has no honest duration. */
+    durationSeconds: number | null;
+    basis: ResponseUnitDistanceBasis;
+    trafficAware: boolean;
+}
+/**
+ * One unit, as the dispatcher sees it. The scoring that ordered the list is
+ * internal; what is exposed is the facts behind it (`reasons`, distance,
+ * freshness, match) - enough for the admin to say why, nothing to reverse-
+ * engineer weights from.
+ */
+export interface ResponseUnitCandidate {
+    responseUnitId: number;
+    name: string;
+    responseUnitType: string;
+    vehicleType: string | null;
+    registrationNumber: string | null;
+    controlCentreId: number | null;
+    /** The unit belongs to the incident's control centre. */
+    sameControlCentre: boolean;
+    operationalStatus: string | null;
+    availability: ResponseUnitAvailability;
+    /** The other incident this unit is out on, when it is ENGAGED by a dispatch. */
+    engagedIncidentId: number | null;
+    capabilities: ResponseCapability[];
+    capabilityMatch: ResponseUnitCapabilityMatch;
+    /** The required capabilities this unit has. */
+    matchedCapabilities: ResponseCapability[];
+    location: ResponseUnitCandidateLocation;
+    /** Straight-line distance to the incident; null without a usable position. */
+    distanceMetres: number | null;
+    /** A road estimate, for the top candidates when routing is enabled. */
+    travel: ResponseUnitTravelEstimate | null;
+    /** Whether a dispatch SMS could be sent. */
+    hasPhoneNumber: boolean;
+    /** The server would accept a dispatch of this unit now. */
+    dispatchable: boolean;
+    /** Dispatchable AND good enough to be suggested. */
+    recommendable: boolean;
+    /** Why it cannot be dispatched (blockers) and why it is not recommended (cautions). */
+    constraints: ResponseUnitDispatchConstraint[];
+    /** Why it ranks where it does. Empty for a unit that is not recommendable. */
+    reasons: ResponseUnitRecommendationReason[];
+    /** 1 = recommended. Null for units outside the recommendable ranking. */
+    rank: number | null;
+}
+export interface ResponseUnitRecommendationSummary {
+    /** Units in the caller's scope for this incident's organization. */
+    configuredUnits: number;
+    dispatchableUnits: number;
+    recommendableUnits: number;
+    engagedUnits: number;
+    /** Inactive or operationally unavailable. */
+    unavailableUnits: number;
+    /** Units with no usable position (offline, never tracked and no base). */
+    unitsWithoutLocation: number;
+    /** The unit list was capped; some units were not considered. */
+    truncated: boolean;
+}
+/**
+ * `GET /incidents/:id/response-unit-recommendation`.
+ *
+ * Advisory and side-effect free: generating one assigns nothing and reserves
+ * nothing. The dispatch command re-evaluates everything when it arrives.
+ */
+export interface ResponseUnitRecommendation {
+    incidentId: number;
+    organizationId: number;
+    controlCentreId: number | null;
+    generatedAt: string;
+    status: ResponseUnitRecommendationStatus;
+    /** Why the incident cannot take a dispatch; empty unless NOT_DISPATCHABLE. */
+    incidentBlockers: IncidentDispatchBlocker[];
+    requirement: ResponseCapabilityRequirement;
+    recommended: ResponseUnitCandidate | null;
+    /** Further recommendable units, best first. */
+    alternatives: ResponseUnitCandidate[];
+    /** Everything else in scope: dispatchable-by-hand first, then blocked. Capped. */
+    otherUnits: ResponseUnitCandidate[];
+    /** Units already out on THIS incident. */
+    activeDispatches: IncidentResponseUnitDispatch[];
+    summary: ResponseUnitRecommendationSummary;
+    /**
+     * False when the incident has no usable location. Nothing can be "nearest"
+     * then, so nothing is recommended - every dispatchable unit is listed for the
+     * dispatcher to choose from.
+     */
+    incidentLocationAvailable: boolean;
+    /**
+     * False when clarion-response-tracking could not be asked. Live positions are
+     * then unknown, so nothing is recommended (a depot location would put moving
+     * vehicles back at base); units are listed by base location, labelled as such.
+     */
+    liveTrackingAvailable: boolean;
+    /** True when road travel times were requested for the top candidates. */
+    travelTimeEnabled: boolean;
+}

package/dist/types/modules/dispatch/utils/dispatch-geo.util.d.ts

@@ -0,0 +1,16 @@
+/** Great-circle distance in metres. */
+export declare function haversineMetres(lat1: number, lng1: number, lat2: number, lng2: number): number;
+/**
+ * A coordinate worth computing a distance from: finite, in range, and not the
+ * (0,0) a form leaves behind when nobody picked a point (Null Island, in the
+ * Gulf of Guinea, is where every unset location in the world quietly sits).
+ */
+export declare function isUsableCoordinate(latitude: unknown, longitude: unknown): boolean;
+/**
+ * Read a {lat,lng} / {latitude,longitude} / {lat,lon} shaped location - the
+ * platform stores all three - as a usable coordinate, or null.
+ */
+export declare function readCoordinate(location: unknown): {
+    latitude: number;
+    longitude: number;
+} | null;

package/dist/types/modules/dispatch/utils/incident-dispatchability.util.d.ts

@@ -0,0 +1,18 @@
+import { IncidentStatus } from '../../incident/enums/incident-status.enum';
+import { IncidentDispatchBlocker } from '../enums/incident-dispatch-blocker.enum';
+/** Incident statuses after which nothing is sent to it. */
+export declare const INCIDENT_STATUSES_ENDING_DISPATCH: readonly IncidentStatus[];
+/** The incident facts dispatchability reads. */
+export interface DispatchableIncidentFacts {
+    class?: string | null;
+    status?: string | null;
+    notifyServiceProvider?: boolean | null;
+    entitlementTier?: string | null;
+}
+/**
+ * Why this incident cannot take a dispatch - empty when it can. Every reason is
+ * returned, not just the first, so the admin can say all of it at once.
+ */
+export declare function resolveIncidentDispatchBlockers(incident: DispatchableIncidentFacts): IncidentDispatchBlocker[];
+/** Whether an incident status ends every dispatch still active on it. */
+export declare function incidentStatusEndsDispatch(status: string | null | undefined): boolean;

package/dist/types/modules/dispatch/utils/response-capability-match.util.d.ts

@@ -0,0 +1,26 @@
+import { ResponseCapability } from '../../response-unit/enums/response-unit/response-capability.enum';
+import { ResponseUnitCapabilityMatch } from '../enums/response-unit-capability-match.enum';
+import { ResponseCapabilityRequirement } from '../interfaces/response-unit-recommendation';
+/**
+ * What an incident needs: its TYPE's list when the type names one, otherwise
+ * its CATEGORY's, otherwise nothing. A type's list replaces the category's
+ * rather than adding to it - "Road accident with casualties" under a "Traffic"
+ * category that asks for roadside assistance must be able to ask for an
+ * ambulance instead.
+ */
+export declare function resolveResponseCapabilityRequirement(type: {
+    responseCapabilities?: unknown;
+} | null | undefined, category: {
+    responseCapabilities?: unknown;
+} | null | undefined): ResponseCapabilityRequirement;
+export interface ResponseCapabilityMatchResult {
+    match: ResponseUnitCapabilityMatch;
+    /** The required capabilities the unit has. */
+    matched: ResponseCapability[];
+}
+/**
+ * Compare a unit with a requirement. A unit qualifies with ANY required
+ * capability - a requirement is the set of services that would do, not a
+ * checklist one vehicle must tick.
+ */
+export declare function matchResponseCapabilities(required: readonly ResponseCapability[], unitCapabilities: readonly ResponseCapability[]): ResponseCapabilityMatchResult;

package/dist/types/modules/dispatch/utils/response-unit-dispatch-event.util.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Deterministic event id: the same change always produces the same id, so a
+ * consumer that sees one twice (an outbox re-publish, a Kafka redelivery) knows
+ * it already handled it. `discriminator` separates changes of the same kind on
+ * one dispatch (the target status, the notification attempt number).
+ */
+export declare function buildResponseUnitDispatchEventId(kind: 'created' | 'status-changed' | 'notification-requested' | 'notification-result', dispatchId: number, discriminator?: string | number): string;
+/** An incident as a control room quotes it: `#1234`. */
+export declare function formatIncidentReference(incidentId: number): string;

package/dist/types/modules/dispatch/utils/response-unit-dispatch-status.util.d.ts

@@ -0,0 +1,16 @@
+import { ResponseUnitDispatchStatus } from '../enums/response-unit-dispatch-status.enum';
+/**
+ * Where a dispatch may go next. Forward only, and steps may be skipped: a crew
+ * that radios in "on scene" never said "en route", and refusing to record the
+ * truth because a step was missed would leave the record wrong. Nothing leaves
+ * COMPLETED or CANCELLED - a unit sent again is a new dispatch, with its own
+ * audit trail, not a resurrected one.
+ */
+export declare const RESPONSE_UNIT_DISPATCH_TRANSITIONS: Readonly<Record<ResponseUnitDispatchStatus, readonly ResponseUnitDispatchStatus[]>>;
+export declare function isActiveResponseUnitDispatchStatus(status: string | null | undefined): boolean;
+export declare function isTerminalResponseUnitDispatchStatus(status: string | null | undefined): boolean;
+export declare function canTransitionResponseUnitDispatch(from: ResponseUnitDispatchStatus, to: ResponseUnitDispatchStatus): boolean;
+/** The statuses a dispatch in `from` may be moved to. */
+export declare function nextResponseUnitDispatchStatuses(from: ResponseUnitDispatchStatus): ResponseUnitDispatchStatus[];
+/** The milestone column each status stamps, for the statuses that have one. */
+export declare const RESPONSE_UNIT_DISPATCH_MILESTONE_FIELD: Readonly<Partial<Record<ResponseUnitDispatchStatus, 'acknowledgedAt' | 'enRouteAt' | 'onSceneAt' | 'completedAt' | 'cancelledAt'>>>;

package/dist/types/modules/incident/dtos/category/create-incident-category.dto.d.ts

@@ -1,5 +1,11 @@
+import { ResponseCapability } from "../../../response-unit/enums/response-unit/response-capability.enum";
 export declare class CreateIncidentCategoryDto {
     name: string;
     description?: string;
     organizationId: number;
+    /**
+     * Response capabilities an incident in this category needs, unless its type names its own; a unit with ANY of them is suitable.
+     * Empty or absent = no requirement, so every available unit is suitable.
+     */
+    responseCapabilities?: ResponseCapability[];
 }

package/dist/types/modules/incident/dtos/type/create-incident-type.dto.d.ts

@@ -1,6 +1,12 @@
+import { ResponseCapability } from "../../../response-unit/enums/response-unit/response-capability.enum";
 export declare class CreateIncidentTypeDto {
     name: string;
     description?: string;
     categoryId?: number;
     organizationId: number;
+    /**
+     * Response capabilities an incident of this type needs; a unit with ANY of them is suitable. Overrides the category's requirement.
+     * Empty or absent = no requirement, so every available unit is suitable.
+     */
+    responseCapabilities?: ResponseCapability[];
 }

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

@@ -8,6 +8,10 @@ export declare enum IncidentActions {
     AUTO_STOPPED = "Auto-Stopped",
     ASSIGNED = "Assigned",
     RESPONSE_UNIT_ASSIGNED = "Response Unit Assigned",
+    /** A unit was dispatched through the dispatch command (recommend + dispatch). */
+    RESPONSE_UNIT_DISPATCHED = "Response Unit Dispatched",
+    /** A dispatch moved on (acknowledged, en route, on scene, completed, stood down) or its message was reported on. */
+    RESPONSE_UNIT_DISPATCH_UPDATED = "Response Unit Dispatch Updated",
     REOPENED = "Reopened",
     REPORT_CREATED = "Report Created",
     COMMENTED = "Commented",

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

@@ -1,3 +1,4 @@
+import { ResponseCapability } from "../../response-unit/enums/response-unit/response-capability.enum";
 import { IncidentType } from "./incident-type";
 export interface IncidentCategory {
     id?: number;
@@ -14,5 +15,10 @@ export interface IncidentCategory {
      * sheet and from package configuration, and not editable or deletable.
      */
     isSystem?: boolean;
+    /**
+     * Response capabilities this kind of incident needs (a unit with ANY of them
+     * is suitable). A type's list overrides its category's; empty = no requirement.
+     */
+    responseCapabilities?: ResponseCapability[];
     types?: IncidentType[];
 }

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

@@ -1,3 +1,4 @@
+import { ResponseCapability } from "../../response-unit/enums/response-unit/response-capability.enum";
 import { IncidentCategory } from "./incident-category";
 export interface IncidentType {
     id?: number;
@@ -15,5 +16,10 @@ export interface IncidentType {
      * sheet and from package configuration, and not editable or deletable.
      */
     isSystem?: boolean;
+    /**
+     * Response capabilities this kind of incident needs (a unit with ANY of them
+     * is suitable). A type's list overrides its category's; empty = no requirement.
+     */
+    responseCapabilities?: ResponseCapability[];
     category?: IncidentCategory;
 }

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

@@ -95,6 +95,9 @@ export declare enum PermissionActions {
     READ_TRACKING_HISTORY = "read:tracking-history",
     READ_TRACKING_OPERATIONS = "read:tracking-operations",
     MANAGE_TRACKING_OPERATIONS = "manage:tracking-operations",
+    READ_RESPONSE_UNIT_DISPATCH = "read:response-unit-dispatch",
+    CREATE_RESPONSE_UNIT_DISPATCH = "create:response-unit-dispatch",
+    UPDATE_RESPONSE_UNIT_DISPATCH = "update:response-unit-dispatch",
     CREATE_BENEFICIARY = "create:beneficiary",
     READ_BENEFICIARY = "read:beneficiary",
     UPDATE_BENEFICIARY = "update:beneficiary",

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

@@ -8,6 +8,7 @@ export declare enum PermissionsModule {
     INCIDENT = "Grievance",
     RESPONSE_UNIT = "Response Unit",
     TRACKING = "Tracking",
+    RESPONSE_UNIT_DISPATCH = "Response Unit Dispatch",
     BILLING = "Billing",
     NEWSFEED = "Newsfeed",
     SUPPORT = "Support",

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

@@ -1,4 +1,5 @@
 import { ResponseUnitType } from "../../enums/response-unit/response-unit-type.enum";
+import { ResponseCapability } from "../../enums/response-unit/response-capability.enum";
 import { MapLocationDto } from "../../../common";
 import { StationDto } from "./station.dto";
 export declare class BaseResponseUnitDto {
@@ -9,6 +10,12 @@ export declare class BaseResponseUnitDto {
     isActive: boolean;
     location: MapLocationDto;
     station: StationDto;
+    /**
+     * What this unit can respond to. Optional: empty means "whatever the unit's
+     * type implies" (an ambulance is MEDICAL_RESPONSE), so a unit only needs
+     * this when it differs from its type - see effectiveResponseCapabilities.
+     */
+    capabilities?: ResponseCapability[];
     controlCentreId: number;
     organizationId: number;
     createdAt?: Date;

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

@@ -0,0 +1,24 @@
+/**
+ * What kind of emergency a response unit can answer.
+ *
+ * Deliberately the platform's existing vocabulary and nothing more: each value
+ * is what one {@link VehicleUnitType} already says about a vehicle (Ambulance,
+ * Security, Fire, Road Rescue), named the way {@link PartnerServiceCapability}
+ * names the same services for third-party responders. A unit with no explicit
+ * capabilities gets these derived from its vehicle type (or a person unit from
+ * its category) - see `deriveResponseCapabilities` - so every existing unit is
+ * classified on day one without anybody configuring anything.
+ *
+ * Stored as plain strings (varchar[]) wherever it is persisted, so adding a
+ * value here never needs a database migration.
+ */
+export declare enum ResponseCapability {
+    /** Ambulances and medical officers. */
+    MEDICAL_RESPONSE = "MEDICAL_RESPONSE",
+    /** Security response vehicles, patrols and police officers. */
+    SECURITY_RESPONSE = "SECURITY_RESPONSE",
+    /** Fire and rescue appliances. */
+    FIRE_RESPONSE = "FIRE_RESPONSE",
+    /** Breakdown, recovery and towing. */
+    ROADSIDE_ASSISTANCE = "ROADSIDE_ASSISTANCE"
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Can this unit be sent to an incident right now?
+ *
+ * Two sources decide it and neither is enough alone:
+ *
+ *  - clarion-organization's MANUAL statuses (`isActive`, `vehicleStatus`,
+ *    `personStatus`, `teamStatus`) - what somebody set on the unit. Read by
+ *    `resolveResponseUnitAvailability`.
+ *  - clarion-incident's ACTIVE DISPATCHES - the authoritative record of a unit
+ *    being out on a job. A unit with one is ENGAGED whatever its manual status
+ *    says, and that is enforced by a unique index, not by this enum.
+ */
+export declare enum ResponseUnitAvailability {
+    /** On duty / operational, enabled, and not out on a job. */
+    AVAILABLE = "AVAILABLE",
+    /** Out on a job: an active dispatch, or a manual Engaged / On Mission status. */
+    ENGAGED = "ENGAGED",
+    /** Enabled but not able to respond: non-operational, off duty, on leave, training. */
+    UNAVAILABLE = "UNAVAILABLE",
+    /** Switched off in the organization (`isActive = false`). */
+    INACTIVE = "INACTIVE"
+}

package/dist/types/modules/response-unit/index.d.ts

@@ -65,3 +65,7 @@ export * from './enums/vehicle-unit/vehicle-type/fire-vehicle-type.enum';
 export * from './enums/vehicle-unit/vehicle-crew/fire-vehicle-role.enum';
 export * from './enums/vehicle-unit/vehicle-type/road-rescue-vehicle-type.enum';
 export * from './enums/vehicle-unit/vehicle-crew/road-rescue-vehicle-role.enum';
+export * from './enums/response-unit/response-capability.enum';
+export * from './enums/response-unit/response-unit-availability.enum';
+export * from './utils/response-capability.util';
+export * from './utils/response-unit-availability.util';

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

@@ -1,5 +1,6 @@
 import { MapAddressDto, MapLocation } from "../../../common";
 import { ResponseUnitType } from "../../enums/response-unit/response-unit-type.enum";
+import { ResponseCapability } from "../../enums/response-unit/response-capability.enum";
 export interface ResponseUnit {
     id: number;
     name: string;
@@ -11,6 +12,8 @@ export interface ResponseUnit {
         name: string;
         address: MapAddressDto;
     };
+    /** Configured capabilities; empty means "derived from the unit's type". */
+    capabilities?: ResponseCapability[];
     controlCentreId: number;
     organizationId: number;
     createdAt?: Date;

package/dist/types/modules/response-unit/utils/response-capability.util.d.ts

@@ -0,0 +1,31 @@
+import { ResponseCapability } from '../enums/response-unit/response-capability.enum';
+/** The most capabilities one unit or one incident type may carry. */
+export declare const MAX_RESPONSE_CAPABILITIES = 10;
+/**
+ * Keep only known capabilities, once each, in a stable order.
+ *
+ * Accepts anything because it reads values back from jsonb, varchar[] and
+ * request bodies alike; an unknown value is dropped rather than thrown, so a
+ * capability retired from the enum can never make a stored unit unreadable.
+ */
+export declare function normalizeResponseCapabilities(values: unknown): ResponseCapability[];
+/** The parts of a response unit that say what it is. */
+export interface ResponseCapabilitySource {
+    /** Configured on the unit. When non-empty it is the whole answer. */
+    capabilities?: unknown;
+    vehicleType?: string | null;
+    /** A person unit's category. */
+    category?: string | null;
+}
+/**
+ * What a unit's TYPE says it can do - ignoring anything configured on it.
+ * Empty when the type says nothing (a team, a volunteer).
+ */
+export declare function deriveResponseCapabilities(source: ResponseCapabilitySource): ResponseCapability[];
+/**
+ * The capabilities a unit is treated as having: what was configured on it when
+ * anything was, otherwise what its type implies. Configured capabilities
+ * REPLACE the derived ones rather than adding to them - an ambulance that has
+ * been re-equipped as a patient-transport-only vehicle must be able to say so.
+ */
+export declare function effectiveResponseCapabilities(source: ResponseCapabilitySource): ResponseCapability[];

package/dist/types/modules/response-unit/utils/response-unit-availability.util.d.ts

@@ -0,0 +1,21 @@
+import { ResponseUnitAvailability } from '../enums/response-unit/response-unit-availability.enum';
+/** The manual status fields of a response unit, whichever subtype it is. */
+export interface ResponseUnitStatusSource {
+    isActive?: boolean | null;
+    vehicleStatus?: string | null;
+    personStatus?: string | null;
+    teamStatus?: string | null;
+}
+/**
+ * Availability from the unit's own MANUAL status - not from dispatches, which
+ * clarion-incident layers on top (a unit with an active dispatch is ENGAGED
+ * whatever this returns).
+ *
+ * A missing status is AVAILABLE: a person unit's `personStatus` is nullable and
+ * every unit created before statuses existed has none, and refusing to dispatch
+ * a unit because nobody filled a field in would make the feature useless for
+ * the organizations that configured least.
+ */
+export declare function resolveResponseUnitAvailability(unit: ResponseUnitStatusSource): ResponseUnitAvailability;
+/** The unit's manual operational status as one string, whichever field holds it. */
+export declare function responseUnitOperationalStatus(unit: ResponseUnitStatusSource): string | null;

package/dist/types/modules/sms/enums/sms-template.enum.d.ts

@@ -10,6 +10,7 @@ export declare enum SmsTemplateType {
     SAFETY_CHECK_GUARDIAN_ENDED = "safety_check_guardian_ended",
     FOLLOW_ME_GUARDIAN_REQUEST = "follow_me_guardian_request",
     FOLLOW_ME_GUARDIAN_ENDED = "follow_me_guardian_ended",
+    RESPONSE_UNIT_DISPATCH = "response_unit_dispatch",
     APPOINTMENT_REMINDER = "appointment_reminder",
     GENERAL_NOTIFICATION = "general_notification"
 }

package/package.json

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