grm-shared-library 1.1.235 → 1.1.237

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

@@ -0,0 +1,103 @@
+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';
+/** Fields every dispatch event carries. */
+export interface ResponseUnitDispatchEventBase {
+    schemaVersion: 1;
+    /** Deterministic per (dispatch, change) so a redelivery can be recognised. */
+    eventId: string;
+    occurredAt: string;
+    dispatchId: number;
+    dispatchReference: string;
+    incidentId: number;
+    organizationId: number;
+    controlCentreId: number | null;
+    responseUnitId: number;
+}
+/**
+ * `incident.response-unit-dispatch.created.v1` - a unit was sent to an incident.
+ *
+ * Identifiers and decisions only: no names, numbers or addresses. Every future
+ * consumer (clarion-workflow, the responder app's backend, analytics, audit)
+ * reads it; the few that need the incident's details look them up by id with
+ * their own authorization.
+ */
+export interface IncidentResponseUnitDispatchedEventV1 extends ResponseUnitDispatchEventBase {
+    status: ResponseUnitDispatchStatus.DISPATCHED;
+    responseUnitControlCentreId: number | null;
+    dispatchedByUserId: number;
+    dispatchedAt: string;
+    wasRecommended: boolean;
+    recommendedResponseUnitId: number | null;
+    distanceMetres: number | null;
+    notificationStatus: ResponseUnitDispatchNotificationStatus;
+}
+/**
+ * `incident.response-unit-dispatch.status-changed.v1` - acknowledged, en route,
+ * on scene, completed or stood down. Ordered per incident (keyed by incident id).
+ */
+export interface IncidentResponseUnitDispatchStatusChangedEventV1 extends ResponseUnitDispatchEventBase {
+    previousStatus: ResponseUnitDispatchStatus;
+    status: ResponseUnitDispatchStatus;
+    source: ResponseUnitDispatchTransitionSource;
+    changedByUserId: number | null;
+    reason: string | null;
+}
+/** The incident facts a dispatch message is written from. */
+export interface ResponseUnitDispatchMessageIncident {
+    /** As the control room quotes it, e.g. `#1234`. */
+    reference: string;
+    typeName: string | null;
+    categoryName: string | null;
+    priority: string | null;
+    /** The description, clamped. */
+    summary: string | null;
+    address: string | null;
+    latitude: number | null;
+    longitude: number | null;
+    /** Null when the reporter is anonymous. */
+    reporterName: string | null;
+    /** Null when the reporter is anonymous or left none. */
+    reporterPhoneNumber: string | null;
+    anonymous: boolean;
+}
+/**
+ * `incident.response-unit-dispatch.notification-requested.v1` - a COMMAND to
+ * clarion-notification: tell this unit it has been dispatched.
+ *
+ * Kept apart from the domain event on purpose. It is the one message that needs
+ * the unit's phone number and the incident's details (an SMS cannot be written
+ * from identifiers), and it goes to one consumer; the domain event goes to
+ * everyone and carries neither. Self-contained so the message can be sent even
+ * when clarion-incident is down - an SMS that waits on a lookup is an SMS that
+ * arrives after the unit should have left.
+ */
+export interface ResponseUnitDispatchNotificationRequestedEventV1 extends ResponseUnitDispatchEventBase {
+    /** 1 for the dispatch itself, then 2, 3... for each "send again". */
+    attempt: number;
+    /** For organization branding and sender resolution. */
+    appId: string | null;
+    recipient: {
+        /** E.164. */
+        phoneNumber: string;
+        responseUnitName: string;
+    };
+    incident: ResponseUnitDispatchMessageIncident;
+}
+/**
+ * `notification.response-unit-dispatch.notification-result.v1` - what became of
+ * one request. clarion-incident records it on the dispatch.
+ */
+export interface 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/interfaces/response-unit-dispatch-profile.d.ts

@@ -0,0 +1,52 @@
+import { ResponseCapability } from '../../response-unit/enums/response-unit/response-capability.enum';
+import { ResponseUnitAvailability } from '../../response-unit/enums/response-unit/response-unit-availability.enum';
+/**
+ * A response unit as dispatch sees it: the slim, authoritative row
+ * clarion-organization serves from `GET /response-units/dispatch-profiles`.
+ *
+ * Everything the recommendation engine needs to decide "could this unit go?"
+ * and nothing it does not - no crew, no device, no address book. The phone
+ * number is present ONLY when the caller asked for contact details (the
+ * dispatch command, never a recommendation), already in E.164 for the
+ * organization's country so clarion-notification can route it without
+ * guessing.
+ */
+export interface ResponseUnitDispatchProfile {
+    responseUnitId: number;
+    organizationId: number;
+    controlCentreId: number | null;
+    name: string;
+    /** `Vehicle` / `Person` / `Team`. */
+    responseUnitType: string;
+    /** `Ambulance` / `Security` / `Fire` / `Road Rescue` for vehicles; null otherwise. */
+    vehicleType: string | null;
+    registrationNumber: string | null;
+    isActive: boolean;
+    /** The manual status, whichever subtype field holds it (`Operational`, `On Duty`...). */
+    operationalStatus: string | null;
+    /** From the manual status only - clarion-incident layers active dispatches on top. */
+    availability: ResponseUnitAvailability;
+    /** The capabilities the unit is treated as having (configured, else derived from its type). */
+    capabilities: ResponseCapability[];
+    /** True when `capabilities` was configured on the unit rather than derived. */
+    capabilitiesConfigured: boolean;
+    /** The unit's configured base position; null when unset or obviously invalid (0,0). */
+    baseLocation: {
+        latitude: number;
+        longitude: number;
+    } | null;
+    stationName: string | null;
+    /** Whether a dispatch SMS could be sent at all. */
+    hasPhoneNumber: boolean;
+    /** E.164. Present only with `includeContact=true`. */
+    phoneNumber?: string | null;
+}
+/** One page of dispatch profiles - in practice the whole scope, capped. */
+export interface ResponseUnitDispatchProfileList {
+    organizationId: number;
+    /** Every unit in the caller's scope, before the cap. */
+    total: number;
+    units: ResponseUnitDispatchProfile[];
+    /** True when `total` exceeded the cap and `units` is the first slice. */
+    truncated: boolean;
+}

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/notification/dtos/notification-analytics-query.dto.d.ts

@@ -0,0 +1,14 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+/**
+ * The period a notification analytics read covers, and optionally one country. Both
+ * ends optional: no `from` is "forever", no `to` is now.
+ */
+export declare class NotificationAnalyticsQueryDto {
+    from?: string;
+    to?: string;
+    timeZone?: string;
+    /** Super-Admin only: one organization's figures instead of every organization's. Ignored for anybody else. */
+    organizationId?: number;
+    /** Push, in-app and devices by the recipient's country, SMS by the number's. Email is never narrowed. */
+    countryCode?: CountryCode;
+}

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

@@ -23,3 +23,5 @@ export * from './enums/billing-notification.enum';
 export * from './dtos/billing-notification.dto';
 export * from './interfaces/billing-notification-result';
 export * from './dtos/alert-acknowledgement.dto';
+export * from './interfaces/notification-analytics';
+export * from './dtos/notification-analytics-query.dto';