clarion-shared-types 1.0.84 → 1.0.86

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

@@ -1,14 +1,25 @@
 /**
  * List filter applied to incident queries.
  *
- *   ALL       — no entitlement filter (default; preserves legacy behaviour).
- *   ENTITLED  — everything except Free-user incidents. Used by the primary admin
- *               incident list, map and kanban views.
- *   FREE      — only Free-user incidents. Backs the "Incident List - Free Users"
- *               admin view.
+ *   ALL             — no entitlement filter (default; preserves legacy behaviour).
+ *   ENTITLED        — everything except incidents the reporter was not entitled
+ *                     to send. Used by the primary admin list, map and kanban.
+ *   FREE            — reporters with no entitlement at all: never subscribed,
+ *                     lapsed, or a spent/expired trial. Backs
+ *                     "Incident List - Free Users".
+ *   UNCOVERED_TYPE  — reporters who DO pay, but whose package excludes the
+ *                     incident type they raised. Backs
+ *                     "Incident List - Uncovered Types".
+ *
+ * The last two both carry tier FREE, because that is what billing stamps in
+ * either case, but they are very different situations for an operator: one is
+ * an upsell, the other is a paying customer discovering a gap in their cover.
+ * `FREE` therefore excludes uncovered-type incidents rather than absorbing
+ * them, so the three scopes partition the data with no overlap and no gaps.
  */
 export declare enum IncidentEntitlementScope {
     ALL = "ALL",
     ENTITLED = "ENTITLED",
-    FREE = "FREE"
+    FREE = "FREE",
+    UNCOVERED_TYPE = "UNCOVERED_TYPE"
 }

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

@@ -16,6 +16,7 @@ import { IncidentReport } from "./incident-report";
 import { IncidentEmergencyType } from "../enums/incident-emergency-type.enum";
 import { IncidentEntitlementSnapshot } from "../../entitlement/interfaces/entitlement-evaluation";
 import { IncidentEntitlementTier } from "../../entitlement/enums/incident-entitlement-tier.enum";
+import { EntitlementDecisionReason } from "../../entitlement/enums/entitlement-decision-reason.enum";
 export interface Incident {
     id?: number;
     appId: IncidentAppId;
@@ -52,6 +53,14 @@ export interface Incident {
     entitlementTier?: IncidentEntitlementTier;
     /** Point-in-time audit of how `entitlementTier` was decided. */
     entitlementSnapshot?: IncidentEntitlementSnapshot | null;
+    /**
+     * Why `entitlementTier` came out the way it did, promoted out of the
+     * snapshot so it can be filtered and indexed. It is what separates a
+     * reporter with no entitlement at all from a paying one whose package
+     * excludes the incident type they raised - both carry tier FREE, but they
+     * are different conversations and get their own admin views.
+     */
+    entitlementReason?: EntitlementDecisionReason;
     /**
      * Who the reporter asked to be alerted, resolved against their entitlement
      * at creation. `false` on the provider flag withholds the incident from the
@@ -62,6 +71,12 @@ export interface Incident {
      */
     notifyServiceProvider?: boolean;
     notifyGuardians?: boolean;
+    /**
+     * What the reporter asked for before entitlement had its say. The
+     * "Marked Ignore" views read this rather than the outcome above: an alert
+     * billing withheld is not an alert somebody chose to withhold.
+     */
+    notifyServiceProviderRequested?: boolean;
     createdAt?: string;
     updatedAt?: string;
     category?: IncidentCategory;

package/dist/types/modules/partner/enums/partner-enums.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Frontend mirrors of the partner enums in grm-shared-library.
+ *
+ * Kept in ONE file rather than one per enum: the admin's partner screens import
+ * most of them together, and the set only means anything as a whole. The values
+ * are byte-identical to the backend's, because they travel over the wire as
+ * strings and any drift would show up as a silently unstyled chip rather than a
+ * compile error.
+ */
+/** The third-party partner behind a partnership. */
+export declare enum PartnerProviderCode {
+    RESCUE_CO = "RESCUE_CO",
+    AAR = "AAR",
+    ST_JOHN = "ST_JOHN",
+    GENERIC_REST = "GENERIC_REST"
+}
+/** A class of emergency service a partner can be asked to provide. */
+export declare enum PartnerServiceCapability {
+    AMBULANCE = "AMBULANCE",
+    MEDICAL_EVACUATION = "MEDICAL_EVACUATION",
+    FIRE_RESPONSE = "FIRE_RESPONSE",
+    SECURITY_RESPONSE = "SECURITY_RESPONSE",
+    ROADSIDE_ASSISTANCE = "ROADSIDE_ASSISTANCE",
+    TOWING = "TOWING",
+    OTHER = "OTHER"
+}
+/** How an incident a partnership covers reaches the partner. */
+export declare enum PartnerRoutingMode {
+    /** Sent as soon as the incident is created. */
+    AUTO = "AUTO",
+    /** Held until an operator confirms it. */
+    MANUAL = "MANUAL",
+    /** Configuration kept, nothing routed. */
+    DISABLED = "DISABLED"
+}
+/** Which of a partner's environments a partnership points at. */
+export declare enum PartnerIntegrationEnvironment {
+    SANDBOX = "SANDBOX",
+    PRODUCTION = "PRODUCTION"
+}
+/** Last known health of a partnership's connection. Advisory only. */
+export declare enum PartnerIntegrationStatus {
+    UNKNOWN = "UNKNOWN",
+    HEALTHY = "HEALTHY",
+    DEGRADED = "DEGRADED",
+    UNREACHABLE = "UNREACHABLE"
+}
+/** What a coverage rule matches an incident on. */
+export declare enum PartnerCoverageMatchType {
+    ALL = "ALL",
+    INCIDENT_TYPE = "INCIDENT_TYPE",
+    INCIDENT_CATEGORY = "INCIDENT_CATEGORY",
+    EMERGENCY_TYPE = "EMERGENCY_TYPE"
+}
+/** Lifecycle of one incident's routing to one partner. */
+export declare enum PartnerDispatchStatus {
+    PENDING_APPROVAL = "PENDING_APPROVAL",
+    QUEUED = "QUEUED",
+    SENDING = "SENDING",
+    SENT = "SENT",
+    ACKNOWLEDGED = "ACKNOWLEDGED",
+    FAILED = "FAILED",
+    REJECTED = "REJECTED",
+    CANCELLED = "CANCELLED",
+    EXPIRED = "EXPIRED"
+}
+/** Why a dispatch did not reach its partner. */
+export declare enum PartnerDispatchFailureReason {
+    INVALID_PAYLOAD = "INVALID_PAYLOAD",
+    MISSING_REQUIRED_FIELD = "MISSING_REQUIRED_FIELD",
+    AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED",
+    FEATURE_NOT_ENABLED = "FEATURE_NOT_ENABLED",
+    PROVIDER_REJECTED = "PROVIDER_REJECTED",
+    ADAPTER_NOT_SUPPORTED = "ADAPTER_NOT_SUPPORTED",
+    INTEGRATION_DISABLED = "INTEGRATION_DISABLED",
+    CREDENTIAL_UNAVAILABLE = "CREDENTIAL_UNAVAILABLE",
+    RATE_LIMITED = "RATE_LIMITED",
+    PROVIDER_UNAVAILABLE = "PROVIDER_UNAVAILABLE",
+    TIMEOUT = "TIMEOUT",
+    MAX_ATTEMPTS_EXCEEDED = "MAX_ATTEMPTS_EXCEEDED",
+    UNKNOWN = "UNKNOWN"
+}
+/** How the location attached to a dispatch was obtained. */
+export declare enum PartnerLocationProvider {
+    GPS = "GPS",
+    NETWORK = "NETWORK",
+    FUSED = "FUSED"
+}
+/** The outbound partner call an attempt record describes. */
+export declare enum PartnerAdapterOperation {
+    AUTHENTICATE = "AUTHENTICATE",
+    HEALTH_CHECK = "HEALTH_CHECK",
+    DISPATCH = "DISPATCH"
+}
+/** The incident-side summary of third-party routing, stored on the incident row. */
+export declare enum IncidentPartnerRoutingStatus {
+    NOT_ROUTED = "NOT_ROUTED",
+    PENDING = "PENDING",
+    AWAITING_APPROVAL = "AWAITING_APPROVAL",
+    ROUTED = "ROUTED",
+    PARTIALLY_ROUTED = "PARTIALLY_ROUTED",
+    FAILED = "FAILED",
+    DECLINED = "DECLINED"
+}
+/** List filter for the admin's partner-routing incident views. */
+export declare enum PartnerDispatchScope {
+    ALL = "ALL",
+    ROUTED = "ROUTED",
+    AWAITING_APPROVAL = "AWAITING_APPROVAL",
+    FAILED = "FAILED",
+    NOT_ROUTED = "NOT_ROUTED"
+}

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

@@ -0,0 +1,7 @@
+export * from './enums/partner-enums';
+export * from './interfaces/partner-provider.dto';
+export * from './interfaces/partner-integration.dto';
+export * from './interfaces/partner-coverage-rule.dto';
+export * from './interfaces/partner-dispatch.dto';
+export * from './interfaces/incident-partner-routing.dto';
+export * from './utils/partner-display.util';

package/dist/types/modules/partner/interfaces/incident-partner-routing.dto.d.ts

@@ -0,0 +1,30 @@
+import { IncidentPartnerRoutingStatus, PartnerDispatchStatus, PartnerProviderCode, PartnerRoutingMode, PartnerServiceCapability } from '../enums/partner-enums';
+/** One partner's leg of an incident's routing, as stored on the incident. */
+export interface IncidentPartnerRoutingEntryDto {
+    integrationId: number;
+    providerCode: PartnerProviderCode;
+    providerName?: string | null;
+    capability: PartnerServiceCapability;
+    routingMode: PartnerRoutingMode;
+    dispatchId: number;
+    dispatchReference: string;
+    status: PartnerDispatchStatus;
+    partnerReference?: string | null;
+    updatedAt: string;
+}
+/**
+ * The third-party routing summary carried on an incident.
+ *
+ * A read model owned by clarion-partner-services, so the incident list and
+ * detail can answer "was an ambulance called for this?" without a second
+ * request. The dispatches themselves live behind
+ * `GET /partner-services/dispatches/incidents/:incidentId`.
+ */
+export interface IncidentPartnerRoutingSnapshotDto {
+    status: IncidentPartnerRoutingStatus;
+    evaluatedAt: string;
+    consideredIntegrationCount: number;
+    entries: IncidentPartnerRoutingEntryDto[];
+    /** True when produced without a live answer from clarion-partner-services. */
+    degraded?: boolean;
+}

package/dist/types/modules/partner/interfaces/partner-coverage-rule.dto.d.ts

@@ -0,0 +1,42 @@
+import { IncidentEmergencyType } from '../../incident/enums/incident-emergency-type.enum';
+import { PartnerCoverageMatchType, PartnerRoutingMode, PartnerServiceCapability } from '../enums/partner-enums';
+/**
+ * One "this kind of incident goes to this partner" statement.
+ *
+ * The match key must agree with `matchType`: INCIDENT_TYPE needs
+ * `incidentTypeId`, INCIDENT_CATEGORY needs `incidentCategoryId`,
+ * EMERGENCY_TYPE needs `emergencyType`, ALL needs none. The backend enforces
+ * that and blanks the other two, so a form that switches match type must clear
+ * the previous key rather than leaving it in the payload.
+ */
+export interface PartnerCoverageRuleDto {
+    id: number;
+    integrationId: number;
+    organizationId: number;
+    matchType: PartnerCoverageMatchType;
+    incidentTypeId: number | null;
+    incidentCategoryId: number | null;
+    emergencyType: IncidentEmergencyType | null;
+    capability: PartnerServiceCapability;
+    routingModeOverride: PartnerRoutingMode | null;
+    priority: number;
+    enabled: boolean;
+    notes: string | null;
+    createdBy: number | null;
+    updatedBy: number | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreatePartnerCoverageRuleDto {
+    matchType: PartnerCoverageMatchType;
+    incidentTypeId?: number;
+    incidentCategoryId?: number;
+    emergencyType?: IncidentEmergencyType;
+    /** Must be a capability the partnership declares. */
+    capability: PartnerServiceCapability;
+    routingModeOverride?: PartnerRoutingMode;
+    priority?: number;
+    enabled?: boolean;
+    notes?: string;
+}
+export type UpdatePartnerCoverageRuleDto = Partial<CreatePartnerCoverageRuleDto>;

package/dist/types/modules/partner/interfaces/partner-dispatch.dto.d.ts

@@ -0,0 +1,126 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { PartnerAdapterOperation, PartnerDispatchFailureReason, PartnerDispatchStatus, PartnerLocationProvider, PartnerProviderCode, PartnerRoutingMode, PartnerServiceCapability } from '../enums/partner-enums';
+/** Where the emergency is, as sent to the partner. */
+export interface PartnerDispatchLocationDto {
+    latitude: number;
+    longitude: number;
+    measuredAt: string;
+    provider: PartnerLocationProvider;
+    address?: string | null;
+}
+/** Who the partner should call about the person in trouble. */
+export interface PartnerEmergencyContactDto {
+    emergencyContactName: string;
+    /** E.164 numbers, primary guardian first. */
+    phoneNumbers: string[];
+    relationship?: string;
+}
+/** The incident facts a dispatch was built from, frozen at routing time. */
+export interface PartnerDispatchIncidentSnapshotDto {
+    incidentId: number;
+    organizationId: number;
+    controlCentreId?: number | null;
+    incidentTypeId?: number | null;
+    incidentTypeName?: string | null;
+    incidentCategoryId?: number | null;
+    incidentCategoryName?: string | null;
+    emergencyType?: string | null;
+    incidentClass?: string | null;
+    channel?: string | null;
+    priority?: string | null;
+    description?: string | null;
+    createdAt: string;
+    reporterName?: string | null;
+    reporterPhoneNumber?: string | null;
+    reporterUserId?: number | null;
+    location?: PartnerDispatchLocationDto | null;
+    address?: string | null;
+}
+/** One outbound call made on a dispatch's behalf, success or failure. */
+export interface PartnerDispatchAttemptDto {
+    id: number;
+    dispatchId: number;
+    attemptNumber: number;
+    operation: PartnerAdapterOperation;
+    /** Query string already masked by the backend. */
+    requestUrl: string;
+    httpStatus: number | null;
+    success: boolean;
+    failureReason: PartnerDispatchFailureReason | null;
+    errorCode: string | null;
+    errorMessage: string | null;
+    durationMs: number;
+    responseSnapshot: Record<string, unknown> | null;
+    createdAt: string;
+}
+/**
+ * One incident's routing to one partnership.
+ *
+ * `requestPayload` and `responsePayload` are sanitized by the backend before
+ * they are stored, so they are safe to render verbatim in a support view.
+ */
+export interface PartnerDispatchDto {
+    id: number;
+    /** Stable reference, safe to quote to the partner or in a support ticket. */
+    dispatchReference: string;
+    organizationId: number;
+    controlCentreId: number | null;
+    integrationId: number;
+    providerCode: PartnerProviderCode;
+    capability: PartnerServiceCapability;
+    coverageRuleId: number | null;
+    incidentId: number;
+    incidentTypeId: number | null;
+    incidentCategoryId: number | null;
+    routingMode: PartnerRoutingMode;
+    status: PartnerDispatchStatus;
+    countryCode: CountryCode;
+    attemptCount: number;
+    maxAttempts: number;
+    nextAttemptAt: string | null;
+    approvalExpiresAt: string | null;
+    approvedByUserId: number | null;
+    approvedAt: string | null;
+    rejectedByUserId: number | null;
+    rejectedAt: string | null;
+    cancelledByUserId: number | null;
+    cancelledAt: string | null;
+    decisionReason: string | null;
+    /** The partner's own identifier, e.g. a Rescue.co SOS request id. */
+    partnerReference: string | null;
+    partnerNumber: string | null;
+    partnerStatus: string | null;
+    requestPayload: Record<string, unknown> | null;
+    responsePayload: Record<string, unknown> | null;
+    failureReason: PartnerDispatchFailureReason | null;
+    lastErrorCode: string | null;
+    lastErrorMessage: string | null;
+    incidentSnapshot: PartnerDispatchIncidentSnapshotDto;
+    emergencyContact: PartnerEmergencyContactDto | null;
+    sentAt: string | null;
+    completedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    /** Present on the detail endpoint. */
+    attempts?: PartnerDispatchAttemptDto[];
+}
+/** Body for approve / reject / cancel. The acting user comes from the session. */
+export interface PartnerDispatchDecisionDto {
+    reason?: string;
+}
+/** List filters for the dispatches table. */
+export interface PartnerDispatchQueryParams {
+    page?: number;
+    limit?: number;
+    sortBy?: string;
+    sortOrder?: 'ASC' | 'DESC';
+    /** Super-Admin only. */
+    organizationId?: number;
+    incidentId?: number;
+    integrationId?: number;
+    status?: PartnerDispatchStatus;
+    providerCode?: PartnerProviderCode;
+    capability?: PartnerServiceCapability;
+    routingMode?: PartnerRoutingMode;
+    countryCode?: CountryCode;
+}

package/dist/types/modules/partner/interfaces/partner-integration.dto.d.ts

@@ -0,0 +1,86 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { PartnerIntegrationEnvironment, PartnerIntegrationStatus, PartnerProviderCode, PartnerRoutingMode, PartnerServiceCapability } from '../enums/partner-enums';
+import { PartnerCoverageRuleDto } from './partner-coverage-rule.dto';
+/**
+ * Frontend view of an organization's partnership with a third-party service
+ * partner.
+ *
+ * NEVER carries the credential value, and never even the reference: the backend
+ * returns `credentialConfigured` instead, so the admin can show "configured" or
+ * "not configured" without any part of the secret reaching the browser.
+ */
+export interface PartnerIntegrationDto {
+    id: number;
+    organizationId: number;
+    controlCentreId: number | null;
+    providerCode: PartnerProviderCode;
+    name: string;
+    environment: PartnerIntegrationEnvironment;
+    baseUrl: string;
+    credentialConfigured: boolean;
+    configuration: Record<string, unknown>;
+    capabilities: PartnerServiceCapability[];
+    routingMode: PartnerRoutingMode;
+    approvalWindowMinutes: number | null;
+    enabled: boolean;
+    priority: number;
+    countryCode: CountryCode;
+    status: PartnerIntegrationStatus;
+    partnerContactName: string | null;
+    partnerContactPhone: string | null;
+    partnerContactEmail: string | null;
+    lastHealthCheckAt: string | null;
+    lastSuccessAt: string | null;
+    lastErrorAt: string | null;
+    lastErrorCode: string | null;
+    lastErrorMessage: string | null;
+    createdBy: number | null;
+    updatedBy: number | null;
+    createdAt: string;
+    updatedAt: string;
+    /** Present on the detail endpoint. */
+    coverageRules?: PartnerCoverageRuleDto[];
+}
+export interface CreatePartnerIntegrationDto {
+    /** Super-Admin only: which tenant the partnership belongs to. */
+    organizationId?: number;
+    controlCentreId?: number;
+    providerCode: PartnerProviderCode;
+    name: string;
+    environment?: PartnerIntegrationEnvironment;
+    /** Defaults to the adapter's base URL for the chosen environment. */
+    baseUrl?: string;
+    /** A secret NAME/reference - never the credential value. */
+    credentialReference: string;
+    configuration?: Record<string, unknown>;
+    capabilities: PartnerServiceCapability[];
+    /** Defaults to MANUAL, so a new partnership never dispatches unattended. */
+    routingMode?: PartnerRoutingMode;
+    approvalWindowMinutes?: number;
+    enabled?: boolean;
+    priority?: number;
+    countryCode?: CountryCode;
+    partnerContactName?: string;
+    partnerContactPhone?: string;
+    partnerContactEmail?: string;
+}
+/**
+ * `providerCode` and `organizationId` are deliberately absent: changing either
+ * would repoint an existing dispatch history at a different partner or tenant,
+ * so a move is a delete and a create.
+ */
+export type UpdatePartnerIntegrationDto = Partial<Omit<CreatePartnerIntegrationDto, 'providerCode' | 'organizationId'>>;
+/** List filters for the partnerships table. */
+export interface PartnerIntegrationQueryParams {
+    page?: number;
+    limit?: number;
+    sortBy?: string;
+    sortOrder?: 'ASC' | 'DESC';
+    /** Super-Admin only. */
+    organizationId?: number;
+    providerCode?: PartnerProviderCode;
+    environment?: PartnerIntegrationEnvironment;
+    routingMode?: PartnerRoutingMode;
+    countryCode?: CountryCode;
+    enabled?: boolean;
+}

package/dist/types/modules/partner/interfaces/partner-provider.dto.d.ts

@@ -0,0 +1,53 @@
+import { PartnerIntegrationEnvironment, PartnerProviderCode, PartnerServiceCapability } from '../enums/partner-enums';
+/** A credential a partnership must supply, described by the backend adapter. */
+export interface PartnerProviderCredentialFieldDto {
+    key: string;
+    label: string;
+    description?: string;
+    required: boolean;
+    /** Always true: a credential is supplied as a secret REFERENCE, never a value. */
+    secret: boolean;
+}
+/** A non-secret setting a partnership must (or may) supply for a provider. */
+export interface PartnerProviderConfigFieldDto {
+    key: string;
+    label: string;
+    description?: string;
+    required: boolean;
+    type: 'string' | 'number' | 'boolean' | 'enum';
+    allowedValues?: string[];
+    defaultValue?: string | number | boolean;
+    maxLength?: number;
+}
+/**
+ * What one partner adapter can do, served by `GET /partner-services/providers`.
+ *
+ * The "add a partner" form is BUILT from these descriptors rather than
+ * hard-coded, so the fields the admin asks for can never drift from what the
+ * backend adapter actually needs. `available: false` marks a reserved partner
+ * that has no adapter yet - show it, but do not let anyone configure it.
+ */
+export interface PartnerProviderDescriptorDto {
+    providerCode: PartnerProviderCode;
+    name: string;
+    description: string;
+    capabilities: PartnerServiceCapability[];
+    defaultBaseUrls: Partial<Record<PartnerIntegrationEnvironment, string>>;
+    configFields: PartnerProviderConfigFieldDto[];
+    credentialFields: PartnerProviderCredentialFieldDto[];
+    supportsHealthCheck: boolean;
+    available: boolean;
+}
+/** Result of the admin's "test connection" button. Never creates an emergency. */
+export interface PartnerConnectionTestResultDto {
+    integrationId: number;
+    status: string;
+    success: boolean;
+    /** True when the stored credential was accepted, even if health then failed. */
+    authenticated: boolean;
+    partnerServiceVersion?: string | null;
+    latencyMs: number;
+    checkedAt: string;
+    errorCode?: string | null;
+    errorMessage?: string | null;
+}

package/dist/types/modules/partner/utils/partner-display.util.d.ts

@@ -0,0 +1,37 @@
+import { IncidentPartnerRoutingStatus, PartnerCoverageMatchType, PartnerDispatchStatus, PartnerIntegrationStatus, PartnerRoutingMode, PartnerServiceCapability } from '../enums/partner-enums';
+/**
+ * Human labels for the partner enums.
+ *
+ * Kept in the shared package rather than in the admin app so every screen that
+ * shows a dispatch - the list, the detail drawer, the incident view - names the
+ * same state the same way. An operator reading "Waiting for confirmation" in one
+ * place and "Pending approval" in another would reasonably assume they were
+ * different things.
+ */
+export declare const PARTNER_DISPATCH_STATUS_LABELS: Readonly<Record<PartnerDispatchStatus, string>>;
+export declare const INCIDENT_PARTNER_ROUTING_STATUS_LABELS: Readonly<Record<IncidentPartnerRoutingStatus, string>>;
+export declare const PARTNER_ROUTING_MODE_LABELS: Readonly<Record<PartnerRoutingMode, string>>;
+export declare const PARTNER_INTEGRATION_STATUS_LABELS: Readonly<Record<PartnerIntegrationStatus, string>>;
+export declare const PARTNER_CAPABILITY_LABELS: Readonly<Record<PartnerServiceCapability, string>>;
+export declare const PARTNER_COVERAGE_MATCH_TYPE_LABELS: Readonly<Record<PartnerCoverageMatchType, string>>;
+/**
+ * Chip family for a dispatch status, matching the admin's existing chip
+ * vocabulary: `success` for anything the partner has, `warn` for anything still
+ * needing a human, `danger` for a failure, `neutral` for a settled non-event.
+ */
+export declare function partnerDispatchStatusTone(status: PartnerDispatchStatus): 'success' | 'warn' | 'danger' | 'neutral';
+/** The same tone mapping for the incident-level rolled-up status. */
+export declare function incidentPartnerRoutingTone(status: IncidentPartnerRoutingStatus): 'success' | 'warn' | 'danger' | 'neutral';
+/**
+ * Whether an operator can act on a dispatch, so a table can enable or hide its
+ * buttons without duplicating the backend's transition rules.
+ *
+ * Withdrawing is deliberately impossible once the partner has the emergency:
+ * standing an ambulance down is a phone call to the partner, not a button here.
+ */
+export declare function partnerDispatchActions(status: PartnerDispatchStatus): {
+    canApprove: boolean;
+    canReject: boolean;
+    canCancel: boolean;
+    canResend: boolean;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarion-shared-types",
-  "version": "1.0.84",
+  "version": "1.0.86",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",