grm-shared-library 1.1.195 → 1.1.196

package/dist/types/modules/partner/enums/partner-dispatch-failure-reason.enum.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Why a dispatch did not reach its partner.
+ *
+ * Split into two families that the retry policy treats very differently:
+ * transient reasons are retried on a backoff, permanent ones fail the dispatch
+ * immediately so an operator sees the truth instead of a spinner.
+ */
+export declare enum PartnerDispatchFailureReason {
+    /** The partner rejected the request body (HTTP 400). Permanent. */
+    INVALID_PAYLOAD = "INVALID_PAYLOAD",
+    /** The incident lacks something the partner requires (phone, location). Permanent. */
+    MISSING_REQUIRED_FIELD = "MISSING_REQUIRED_FIELD",
+    /** The partner refused the credentials (HTTP 401). Permanent after one re-auth. */
+    AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED",
+    /** The partner account lacks the requested feature (HTTP 403). Permanent. */
+    FEATURE_NOT_ENABLED = "FEATURE_NOT_ENABLED",
+    /** The partner said no for a business reason (HTTP 409/422). Permanent. */
+    PROVIDER_REJECTED = "PROVIDER_REJECTED",
+    /** No adapter is registered for the partnership's provider code. Permanent. */
+    ADAPTER_NOT_SUPPORTED = "ADAPTER_NOT_SUPPORTED",
+    /** The partnership was disabled or its routing mode turned off mid-flight. Permanent. */
+    INTEGRATION_DISABLED = "INTEGRATION_DISABLED",
+    /** The configured credential could not be resolved from the secret store. Transient. */
+    CREDENTIAL_UNAVAILABLE = "CREDENTIAL_UNAVAILABLE",
+    /** The partner was rate limiting (HTTP 429). Transient. */
+    RATE_LIMITED = "RATE_LIMITED",
+    /** The partner errored (HTTP 5xx). Transient. */
+    PROVIDER_UNAVAILABLE = "PROVIDER_UNAVAILABLE",
+    /** The request timed out or the network failed. Transient. */
+    TIMEOUT = "TIMEOUT",
+    /** Every transient retry was used up. Terminal. */
+    MAX_ATTEMPTS_EXCEEDED = "MAX_ATTEMPTS_EXCEEDED",
+    /** Anything the list above does not describe. Treated as transient. */
+    UNKNOWN = "UNKNOWN"
+}
+/** Failure reasons that must NOT be retried - retrying them cannot succeed. */
+export declare const PERMANENT_PARTNER_DISPATCH_FAILURE_REASONS: readonly PartnerDispatchFailureReason[];

package/dist/types/modules/partner/enums/partner-dispatch-scope.enum.d.ts

@@ -0,0 +1,16 @@
+/**
+ * List filter for the admin "partner routing" views, in the same shape as the
+ * entitlement and alert-dispatch scopes already used by the incident list.
+ */
+export declare enum PartnerDispatchScope {
+    /** No filter. */
+    ALL = "ALL",
+    /** Incidents a partner was asked to attend (any status other than NOT_ROUTED). */
+    ROUTED = "ROUTED",
+    /** Incidents currently waiting on a manual routing decision. */
+    AWAITING_APPROVAL = "AWAITING_APPROVAL",
+    /** Incidents whose partner routing failed outright. */
+    FAILED = "FAILED",
+    /** Incidents no partnership covered. */
+    NOT_ROUTED = "NOT_ROUTED"
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Lifecycle of one incident's routing to one partner.
+ *
+ * Terminal states are SENT/ACKNOWLEDGED (the partner has the emergency),
+ * FAILED, REJECTED, CANCELLED and EXPIRED. Everything else is in flight.
+ *
+ * MANUAL routing starts at PENDING_APPROVAL and reaches QUEUED only when an
+ * operator approves; declining gives REJECTED, withdrawing gives CANCELLED and
+ * letting the approval window elapse gives EXPIRED. AUTO routing starts at
+ * QUEUED directly. QUEUED -> SENDING -> SENT on success, or back to QUEUED for a
+ * transient retry, or FAILED when the failure is permanent or the attempts run
+ * out. SENT -> ACKNOWLEDGED when the partner later reports progress.
+ */
+export declare enum PartnerDispatchStatus {
+    /** MANUAL routing: waiting for the organization to confirm or decline. */
+    PENDING_APPROVAL = "PENDING_APPROVAL",
+    /** Cleared to send - either AUTO, or approved - and waiting for a send attempt. */
+    QUEUED = "QUEUED",
+    /** A send attempt is in flight. */
+    SENDING = "SENDING",
+    /** The partner accepted the request and returned its own reference. */
+    SENT = "SENT",
+    /** The partner has since confirmed progress on the request (status callback). */
+    ACKNOWLEDGED = "ACKNOWLEDGED",
+    /** Permanently failed - rejected by the partner, or out of attempts. */
+    FAILED = "FAILED",
+    /** Declined by the organization instead of being sent. */
+    REJECTED = "REJECTED",
+    /** Withdrawn by the organization (before or after approval, never after SENT). */
+    CANCELLED = "CANCELLED",
+    /** The manual-approval window elapsed with no decision. */
+    EXPIRED = "EXPIRED"
+}
+/** Statuses from which no further transition happens. */
+export declare const TERMINAL_PARTNER_DISPATCH_STATUSES: readonly PartnerDispatchStatus[];
+/** Statuses that mean the partner is (or should shortly be) working the emergency. */
+export declare const DELIVERED_PARTNER_DISPATCH_STATUSES: readonly PartnerDispatchStatus[];

package/dist/types/modules/partner/enums/partner-integration-environment.enum.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Which of a partner's environments a partnership points at.
+ *
+ * Kept explicit — and part of the uniqueness key of a partnership — so an
+ * organization can hold a sandbox and a production integration with the same
+ * partner side by side, and so a dispatch record always says which one an
+ * emergency was actually sent to.
+ */
+export declare enum PartnerIntegrationEnvironment {
+    SANDBOX = "SANDBOX",
+    PRODUCTION = "PRODUCTION"
+}

package/dist/types/modules/partner/enums/partner-integration-status.enum.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Last known health of a partnership's connection to its partner, refreshed by
+ * explicit connection tests and by the outcome of real dispatches.
+ *
+ * Advisory only: it is never consulted to decide whether to attempt a dispatch —
+ * an emergency is always attempted against a live partner, whatever the last
+ * probe said.
+ */
+export declare enum PartnerIntegrationStatus {
+    /** Never probed, or probed before the last configuration change. */
+    UNKNOWN = "UNKNOWN",
+    /** Last probe or dispatch succeeded. */
+    HEALTHY = "HEALTHY",
+    /** Reachable but erroring — e.g. authentication succeeds, dispatches reject. */
+    DEGRADED = "DEGRADED",
+    /** Last probe or dispatch could not reach the partner at all. */
+    UNREACHABLE = "UNREACHABLE"
+}

package/dist/types/modules/partner/enums/partner-location-provider.enum.d.ts

@@ -0,0 +1,15 @@
+/**
+ * How the location attached to a partner dispatch was obtained.
+ *
+ * Mirrors the vocabulary emergency-service APIs expect (Rescue.co among them)
+ * and is derived from the incident's reporting channel rather than asked for -
+ * see `mapChannelToLocationProvider`.
+ */
+export declare enum PartnerLocationProvider {
+    /** A satellite fix. */
+    GPS = "GPS",
+    /** Derived from cell/Wi-Fi network positioning, or entered by an operator. */
+    NETWORK = "NETWORK",
+    /** A platform fused-location fix combining GPS, network and sensors. */
+    FUSED = "FUSED"
+}

package/dist/types/modules/partner/enums/partner-provider-code.enum.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Identifies the third-party service partner an organization has integrated
+ * with.
+ *
+ * Provider-neutral by design: the partnership model, coverage rules, dispatch
+ * records, audit trail and REST surface in clarion-partner-services never branch
+ * on a specific partner — only the per-provider adapter inside that service
+ * understands a partner's wire format, authentication and payload shape.
+ *
+ * Only {@link PartnerProviderCode.RESCUE_CO} has a working adapter today. The
+ * remaining values are reserved so a new partner can be added without changing
+ * the shared contracts, database columns or Kafka events.
+ */
+export declare enum PartnerProviderCode {
+    /** Rescue.co — ambulance / emergency medical response (Kenya). */
+    RESCUE_CO = "RESCUE_CO",
+    /** AAR Healthcare emergency medical response (reserved — no adapter yet). */
+    AAR = "AAR",
+    /** St John Ambulance (reserved — no adapter yet). */
+    ST_JOHN = "ST_JOHN",
+    /** Generic REST partner driven purely by configuration (reserved). */
+    GENERIC_REST = "GENERIC_REST"
+}

package/dist/types/modules/partner/enums/partner-routing-mode.enum.d.ts

@@ -0,0 +1,20 @@
+/**
+ * How an incident that a partnership covers reaches the partner.
+ *
+ * The distinction is deliberately a stored fact rather than a runtime policy:
+ * an organization that wants a human in the loop before an ambulance is
+ * requested on its behalf sets MANUAL, and every covered incident then waits in
+ * PENDING_APPROVAL until an operator confirms it.
+ */
+export declare enum PartnerRoutingMode {
+    /** Send to the partner as soon as the incident is created. */
+    AUTO = "AUTO",
+    /** Hold for explicit confirmation by the organization before sending. */
+    MANUAL = "MANUAL",
+    /**
+     * Keep the configuration but route nothing. Distinct from deleting the
+     * partnership (which loses its coverage rules and history) and from
+     * `enabled = false` (which is the operational kill switch).
+     */
+    DISABLED = "DISABLED"
+}

package/dist/types/modules/partner/enums/partner-service-capability.enum.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A class of emergency service a partner can be asked to provide.
+ *
+ * A partnership declares which capabilities it buys from a partner, and every
+ * coverage rule names the capability an incident should be routed for. This is
+ * what makes "GardaWorld sends medical incidents to Rescue.co" expressible
+ * without either side hard-coding the other.
+ */
+export declare enum PartnerServiceCapability {
+    /** Ground ambulance dispatch to a scene. */
+    AMBULANCE = "AMBULANCE",
+    /** Air or long-distance medical evacuation. */
+    MEDICAL_EVACUATION = "MEDICAL_EVACUATION",
+    /** Fire and rescue response. */
+    FIRE_RESPONSE = "FIRE_RESPONSE",
+    /** Armed or unarmed security response to a scene. */
+    SECURITY_RESPONSE = "SECURITY_RESPONSE",
+    /** Roadside/breakdown assistance. */
+    ROADSIDE_ASSISTANCE = "ROADSIDE_ASSISTANCE",
+    /** Vehicle recovery / towing. */
+    TOWING = "TOWING",
+    /** Anything the list above does not describe. */
+    OTHER = "OTHER"
+}

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

@@ -0,0 +1,33 @@
+export * from './enums/partner-provider-code.enum';
+export * from './enums/partner-service-capability.enum';
+export * from './enums/partner-routing-mode.enum';
+export * from './enums/partner-integration-environment.enum';
+export * from './enums/partner-integration-status.enum';
+export * from './enums/partner-coverage-match-type.enum';
+export * from './enums/partner-dispatch-status.enum';
+export * from './enums/partner-dispatch-failure-reason.enum';
+export * from './enums/partner-location-provider.enum';
+export * from './enums/partner-adapter-operation.enum';
+export * from './enums/incident-partner-routing-status.enum';
+export * from './enums/partner-dispatch-scope.enum';
+export * from './interfaces/partner-provider-descriptor';
+export * from './interfaces/partner-integration';
+export * from './interfaces/partner-coverage-rule';
+export * from './interfaces/partner-dispatch-location';
+export * from './interfaces/partner-emergency-contact';
+export * from './interfaces/partner-dispatch';
+export * from './interfaces/incident-partner-routing';
+export * from './interfaces/partner-routing-result';
+export * from './interfaces/partner-connection-test-result';
+export * from './interfaces/partner-dispatch-events';
+export * from './constants/partner-defaults.const';
+export * from './constants/partner-kafka.const';
+export * from './dtos/create-partner-integration.dto';
+export * from './dtos/update-partner-integration.dto';
+export * from './dtos/create-partner-coverage-rule.dto';
+export * from './dtos/update-partner-coverage-rule.dto';
+export * from './dtos/route-incident-to-partners.dto';
+export * from './dtos/partner-dispatch-decision.dto';
+export * from './dtos/update-incident-partner-routing.dto';
+export * from './utils/partner-routing.util';
+export * from './utils/partner-payload.util';

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

@@ -0,0 +1,43 @@
+import { IncidentPartnerRoutingStatus } from '../enums/incident-partner-routing-status.enum';
+import { PartnerDispatchStatus } from '../enums/partner-dispatch-status.enum';
+import { PartnerProviderCode } from '../enums/partner-provider-code.enum';
+import { PartnerRoutingMode } from '../enums/partner-routing-mode.enum';
+import { PartnerServiceCapability } from '../enums/partner-service-capability.enum';
+/** One partner's leg of an incident's routing, as recorded on the incident. */
+export interface IncidentPartnerRoutingEntry {
+    integrationId: number;
+    providerCode: PartnerProviderCode;
+    /** Operator-facing partnership name, so the control room needs no extra lookup. */
+    providerName?: string | null;
+    capability: PartnerServiceCapability;
+    routingMode: PartnerRoutingMode;
+    dispatchId: number;
+    dispatchReference: string;
+    status: PartnerDispatchStatus;
+    /** The partner's own reference once it has accepted the request. */
+    partnerReference?: string | null;
+    updatedAt: string;
+}
+/**
+ * The third-party routing summary stored on an incident in clarion-incident.
+ *
+ * A denormalized read model, owned and pushed by clarion-partner-services: it
+ * lets the control room show and filter "was an ambulance called?" from the
+ * incident row alone, while clarion-partner-services stays the source of truth
+ * for the dispatches themselves.
+ */
+export interface IncidentPartnerRoutingSnapshot {
+    status: IncidentPartnerRoutingStatus;
+    /** When the routing decision this snapshot describes was made. */
+    evaluatedAt: string;
+    /** Partnerships considered for this incident, matched or not. */
+    consideredIntegrationCount: number;
+    entries: IncidentPartnerRoutingEntry[];
+    /**
+     * True when the snapshot was produced without a live answer from
+     * clarion-partner-services (the caller's fail-open default applied). An
+     * emergency is never blocked on partner routing, so this is expected to
+     * appear during a partner-services outage and is reconciled afterwards.
+     */
+    degraded?: boolean;
+}

package/dist/types/modules/partner/interfaces/partner-connection-test-result.d.ts

@@ -0,0 +1,22 @@
+import { PartnerIntegrationStatus } from '../enums/partner-integration-status.enum';
+/**
+ * Outcome of a non-mutating probe against a partnership - the "test connection"
+ * button in the admin UI.
+ *
+ * Deliberately never creates a real emergency: an adapter's probe authenticates
+ * and calls the partner's health endpoint, nothing more.
+ */
+export interface PartnerConnectionTestResult {
+    integrationId: number;
+    status: PartnerIntegrationStatus;
+    success: boolean;
+    /** True when the stored credential was accepted by the partner. */
+    authenticated: boolean;
+    /** The partner's reported service version/name, when it publishes one. */
+    partnerServiceVersion?: string | null;
+    latencyMs: number;
+    checkedAt: string;
+    errorCode?: string | null;
+    /** Sanitized. Never contains a credential or token. */
+    errorMessage?: string | null;
+}

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

@@ -0,0 +1,36 @@
+import { IncidentEmergencyType } from '../../incident/enums/incident-emergency-type.enum';
+import { PartnerCoverageMatchType } from '../enums/partner-coverage-match-type.enum';
+import { PartnerRoutingMode } from '../enums/partner-routing-mode.enum';
+import { PartnerServiceCapability } from '../enums/partner-service-capability.enum';
+/**
+ * One "this kind of incident goes to this partner" statement.
+ *
+ * A partnership holds many rules and an incident is covered if ANY rule matches
+ * it. Rules are evaluated in `priority` order (ascending), and the first match
+ * decides the capability and routing mode used for the dispatch.
+ */
+export interface PartnerCoverageRule {
+    id: number;
+    integrationId: number;
+    /** Denormalized from the partnership so tenant scoping never needs a join. */
+    organizationId: number;
+    matchType: PartnerCoverageMatchType;
+    /** Set when `matchType` is INCIDENT_TYPE - a `types` row in clarion-incident. */
+    incidentTypeId?: number | null;
+    /** Set when `matchType` is INCIDENT_CATEGORY - a `categories` row in clarion-incident. */
+    incidentCategoryId?: number | null;
+    /** Set when `matchType` is EMERGENCY_TYPE. */
+    emergencyType?: IncidentEmergencyType | null;
+    /** The service the partner is asked for when this rule matches. */
+    capability: PartnerServiceCapability;
+    /** Overrides the partnership routing mode for incidents this rule matches. */
+    routingModeOverride?: PartnerRoutingMode | null;
+    priority: number;
+    enabled: boolean;
+    /** Free-text note for whoever configured it. */
+    notes?: string | null;
+    createdBy?: number | null;
+    updatedBy?: number | null;
+    createdAt: string;
+    updatedAt: string;
+}

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

@@ -0,0 +1,40 @@
+import { PartnerDispatchFailureReason } from '../enums/partner-dispatch-failure-reason.enum';
+import { PartnerDispatchStatus } from '../enums/partner-dispatch-status.enum';
+import { PartnerProviderCode } from '../enums/partner-provider-code.enum';
+import { PartnerRoutingMode } from '../enums/partner-routing-mode.enum';
+import { PartnerServiceCapability } from '../enums/partner-service-capability.enum';
+/**
+ * Canonical Kafka contract for partner dispatch lifecycle, produced by
+ * clarion-partner-services.
+ *
+ * Secret-free by construction: no credential, no token, no raw partner
+ * response - only the identifiers a consumer needs to notify an operator, drive
+ * a live admin view or reconcile afterwards. Versioned in the topic name so a
+ * later shape change never breaks an existing consumer.
+ */
+export interface PartnerDispatchEventV1 {
+    /** Deterministic id, so a consumer can dedupe a redelivered message. */
+    eventId: string;
+    /** ISO-8601 instant the event was produced. */
+    occurredAt: string;
+    organizationId: number;
+    controlCentreId?: number | null;
+    incidentId: number;
+    dispatchId: number;
+    dispatchReference: string;
+    integrationId: number;
+    providerCode: PartnerProviderCode;
+    /** Operator-facing partnership name. */
+    providerName?: string | null;
+    capability: PartnerServiceCapability;
+    routingMode: PartnerRoutingMode;
+    status: PartnerDispatchStatus;
+    /** The status the dispatch moved from. Absent on the created event. */
+    previousStatus?: PartnerDispatchStatus | null;
+    failureReason?: PartnerDispatchFailureReason | null;
+    /** The partner's own reference, once it has accepted the request. */
+    partnerReference?: string | null;
+    /** Set on approve / reject / cancel, so a consumer can attribute the decision. */
+    actorUserId?: number | null;
+    countryCode: string;
+}

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

@@ -0,0 +1,13 @@
+import { PartnerLocationProvider } from '../enums/partner-location-provider.enum';
+/** Where the emergency is, in the shape partner APIs expect. */
+export interface PartnerDispatchLocation {
+    /** Decimal degrees, -90..90. */
+    latitude: number;
+    /** Decimal degrees, -180..180. */
+    longitude: number;
+    /** ISO-8601 instant the fix was taken - the incident's creation time. */
+    measuredAt: string;
+    provider: PartnerLocationProvider;
+    /** Reverse-geocoded or operator-entered street address, when known. */
+    address?: string | null;
+}

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

@@ -0,0 +1,119 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { PartnerAdapterOperation } from '../enums/partner-adapter-operation.enum';
+import { PartnerDispatchFailureReason } from '../enums/partner-dispatch-failure-reason.enum';
+import { PartnerDispatchStatus } from '../enums/partner-dispatch-status.enum';
+import { PartnerProviderCode } from '../enums/partner-provider-code.enum';
+import { PartnerRoutingMode } from '../enums/partner-routing-mode.enum';
+import { PartnerServiceCapability } from '../enums/partner-service-capability.enum';
+import { PartnerDispatchLocation } from './partner-dispatch-location';
+import { PartnerEmergencyContact } from './partner-emergency-contact';
+/**
+ * The incident facts a dispatch was built from, frozen at routing time.
+ *
+ * Kept on the dispatch so an audit, a resend or a partner dispute can be settled
+ * without re-reading clarion-incident, whose row may have moved on (status
+ * changes, reassignment, redaction of an anonymous reporter).
+ */
+export interface PartnerDispatchIncidentSnapshot {
+    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;
+    /** E.164. Masked in logs, never in the stored snapshot. */
+    reporterPhoneNumber?: string | null;
+    reporterUserId?: number | null;
+    location?: PartnerDispatchLocation | null;
+    address?: string | null;
+}
+/** One outbound call made on a dispatch's behalf, success or failure. */
+export interface PartnerDispatchAttempt {
+    id: number;
+    dispatchId: number;
+    attemptNumber: number;
+    operation: PartnerAdapterOperation;
+    /** Request URL with any query string masked. Never contains a credential. */
+    requestUrl: string;
+    httpStatus?: number | null;
+    success: boolean;
+    failureReason?: PartnerDispatchFailureReason | null;
+    errorCode?: string | null;
+    /** Sanitized partner message. Never contains a credential or token. */
+    errorMessage?: string | null;
+    durationMs: number;
+    /** Sanitized excerpt of the partner response, for support and disputes. */
+    responseSnapshot?: Record<string, unknown> | null;
+    createdAt: string;
+}
+/**
+ * One incident's routing to one partnership: the decision, its approval state,
+ * the outbound result and the audit trail behind it.
+ *
+ * There is at most one dispatch per (incident, partnership) pair - enforced by a
+ * unique constraint - so a redelivered routing request, a retried HTTP call or a
+ * duplicated Kafka message can never summon two ambulances for one emergency.
+ */
+export interface PartnerDispatch {
+    id: number;
+    /** Stable external identifier, safe to quote to a partner or in a support ticket. */
+    dispatchReference: string;
+    organizationId: number;
+    controlCentreId?: number | null;
+    integrationId: number;
+    providerCode: PartnerProviderCode;
+    capability: PartnerServiceCapability;
+    /** The coverage rule that matched, when the dispatch came from automatic routing. */
+    coverageRuleId?: number | null;
+    incidentId: number;
+    incidentTypeId?: number | null;
+    incidentCategoryId?: number | null;
+    /** The mode actually applied, after any rule-level override. */
+    routingMode: PartnerRoutingMode;
+    status: PartnerDispatchStatus;
+    countryCode: CountryCode;
+    attemptCount: number;
+    maxAttempts: number;
+    /** When the retry job should next pick this dispatch up. */
+    nextAttemptAt?: string | null;
+    /** When an unapproved MANUAL dispatch expires. Null means never. */
+    approvalExpiresAt?: string | null;
+    approvedByUserId?: number | null;
+    approvedAt?: string | null;
+    rejectedByUserId?: number | null;
+    rejectedAt?: string | null;
+    cancelledByUserId?: number | null;
+    cancelledAt?: string | null;
+    /** Operator's stated reason for rejecting or cancelling. */
+    decisionReason?: string | null;
+    /** The partner's own identifier for the request, e.g. a Rescue.co SOS id. */
+    partnerReference?: string | null;
+    /** The partner's human-facing reference, e.g. an SOS number read out on a call. */
+    partnerNumber?: string | null;
+    /** The partner's own status string, passed through verbatim. */
+    partnerStatus?: string | null;
+    /** The sanitized body sent to the partner. Never contains a credential. */
+    requestPayload?: Record<string, unknown> | null;
+    /** The sanitized body the partner returned. */
+    responsePayload?: Record<string, unknown> | null;
+    failureReason?: PartnerDispatchFailureReason | null;
+    lastErrorCode?: string | null;
+    /** Sanitized. Never contains a credential or token. */
+    lastErrorMessage?: string | null;
+    incidentSnapshot: PartnerDispatchIncidentSnapshot;
+    emergencyContact?: PartnerEmergencyContact | null;
+    sentAt?: string | null;
+    completedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    /** Present on the detail endpoint. */
+    attempts?: PartnerDispatchAttempt[];
+}

package/dist/types/modules/partner/interfaces/partner-emergency-contact.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Who a partner should call about the person in trouble.
+ *
+ * Resolved from the reporter's guardians in clarion-authentication: the primary
+ * guardian names the contact and supplies the relationship, and every guardian's
+ * number is offered so a partner that cannot reach the first can try the rest.
+ * Omitted entirely when the reporter has no guardians.
+ */
+export interface PartnerEmergencyContact {
+    emergencyContactName: string;
+    /** E.164 numbers, primary guardian first. Never empty when this object is present. */
+    phoneNumbers: string[];
+    /** e.g. `Spouse`. Free text, because partners do not share a relationship vocabulary. */
+    relationship?: string;
+}

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

@@ -0,0 +1,63 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { PartnerIntegrationEnvironment } from '../enums/partner-integration-environment.enum';
+import { PartnerIntegrationStatus } from '../enums/partner-integration-status.enum';
+import { PartnerProviderCode } from '../enums/partner-provider-code.enum';
+import { PartnerRoutingMode } from '../enums/partner-routing-mode.enum';
+import { PartnerServiceCapability } from '../enums/partner-service-capability.enum';
+import { PartnerCoverageRule } from './partner-coverage-rule';
+/**
+ * One organization's configured partnership with one third-party service
+ * partner - "GardaWorld sends medical emergencies to Rescue.co".
+ *
+ * This is the client-safe projection returned by the REST API. It deliberately
+ * has NO credential value: the stored credential reference names a secret
+ * resolved at runtime, and `credentialConfigured` is all a client is told.
+ */
+export interface PartnerIntegration {
+    id: number;
+    /** The Clarion tenant that owns the partnership. */
+    organizationId: number;
+    /** Narrows the partnership to a single control centre when set. */
+    controlCentreId?: number | null;
+    providerCode: PartnerProviderCode;
+    /** Operator-facing label, e.g. "Rescue.co Ambulance (Production)". */
+    name: string;
+    environment: PartnerIntegrationEnvironment;
+    /** Partner API base URL, e.g. https://api.rescue.co */
+    baseUrl: string;
+    /** True when a credential reference is stored. The reference itself is never returned. */
+    credentialConfigured: boolean;
+    /** Provider-neutral, non-secret settings the adapter reads (e.g. the Rescue.co source). */
+    configuration: Record<string, unknown>;
+    /** Services bought from this partner. Coverage rules may only request these. */
+    capabilities: PartnerServiceCapability[];
+    /** Default routing mode; a coverage rule may override it. */
+    routingMode: PartnerRoutingMode;
+    /**
+     * Minutes a MANUAL dispatch may wait for a decision before it expires.
+     * Null means it never expires on its own.
+     */
+    approvalWindowMinutes?: number | null;
+    /** Operational kill switch, independent of `routingMode`. */
+    enabled: boolean;
+    /** Order in which partnerships are considered when several cover one incident. */
+    priority: number;
+    /** ISO 3166-1 alpha-2 country the partnership operates in. */
+    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;
+    /** Sanitized - never contains credentials or a raw partner response. */
+    lastErrorMessage?: string | null;
+    createdBy?: number | null;
+    updatedBy?: number | null;
+    createdAt: string;
+    updatedAt: string;
+    /** Present on the detail endpoint. */
+    coverageRules?: PartnerCoverageRule[];
+}