clarion-shared-types 1.0.97 → 1.0.99

package/dist/types/modules/alert-intake/interfaces/alert-intake.d.ts

@@ -0,0 +1,202 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { AlertIntakeChannel, AlertIntakeEmergencyPolicy, AlertIntakeProvider, AlertIntakeRouteMatch, AlertIntakeSecretSource, AlertIntakeWebhookVerification } from '../enums/alert-intake.enum';
+/**
+ * Alert intake settings.
+ *
+ * `organizationId` is the single source of truth. A CONNECTION is one
+ * organization's link to one provider on one channel (its short code, its WhatsApp
+ * number, its mailbox). A message that arrives on a connection belongs to the
+ * connection's organization, and everything the incident needs - app id, incident
+ * class, workflow queue, country - is read from that organization's record in
+ * clarion-organization rather than from a table in code.
+ *
+ * The fallback is a PLATFORM connection (no organization): a shared short code or a
+ * shared mailbox whose messages are routed to an organization by keyword, or to a
+ * default organization.
+ *
+ * Owned by clarion-alerts, proxied by the gateway, rendered by the admin. No shape
+ * here ever carries a credential: secrets are write-only.
+ *
+ * MIRRORS grm-shared-library (`modules/alert-intake/interfaces` and `dtos`). The
+ * response shapes are interfaces on both sides; the request shapes are class-validator
+ * DTOs on the backend and plain interfaces here (see the end of this file).
+ */
+export type AlertIntakeFieldType = 'text' | 'number' | 'boolean' | 'select';
+/** One value a provider needs from the operator. */
+export interface AlertIntakeProviderFieldDescriptor {
+    key: string;
+    label: string;
+    type: AlertIntakeFieldType;
+    required: boolean;
+    /** Secret fields are write-only, and are stored encrypted or as a reference. */
+    secret: boolean;
+    placeholder?: string;
+    description?: string;
+    defaultValue?: string | number | boolean;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    /** `text` fields only. */
+    maxLength?: number;
+    /** `number` fields only; inclusive. */
+    min?: number;
+    max?: number;
+    /** Only a platform operator may set this (e.g. switching off TLS verification). */
+    operatorOnly?: boolean;
+}
+/**
+ * Self-description of an intake provider, published by clarion-alerts. Same idea as
+ * the tracking and SMS provider descriptors: the service that owns the adapter is
+ * the source of truth for what it needs, so adding a provider changes no client code.
+ * Static metadata - never a credential, never anything tenant-specific.
+ */
+export interface AlertIntakeProviderDescriptor {
+    provider: AlertIntakeProvider;
+    channel: AlertIntakeChannel;
+    displayName: string;
+    description: string;
+    /** What identifies the connection to the provider: the number people text, the mailbox. */
+    address: {
+        label: string;
+        placeholder?: string;
+        description?: string;
+    };
+    fields: AlertIntakeProviderFieldDescriptor[];
+    /** Null for a provider that is polled rather than called (IMAP). */
+    webhook: {
+        verification: AlertIntakeWebhookVerification;
+        /** Steps the operator performs in the PROVIDER's console, in order. */
+        setup: string[];
+    } | null;
+    /** Whether `POST .../test` does something for this provider. */
+    testable: boolean;
+    documentationUrl?: string;
+}
+export interface AlertIntakeConnection {
+    id: string;
+    /** Null = a platform connection, shared between organizations through routes. */
+    organizationId: number | null;
+    channel: AlertIntakeChannel;
+    provider: AlertIntakeProvider;
+    name: string;
+    /** The short code / number / WhatsApp phone-number id / mailbox messages are sent TO. */
+    address: string;
+    enabled: boolean;
+    /** Non-secret provider settings, as described by the provider's descriptor. */
+    config: Record<string, string | number | boolean>;
+    secretSource: AlertIntakeSecretSource;
+    /** Which secret fields have a value. The values themselves are never returned. */
+    secretsConfigured: Record<string, boolean>;
+    emergencyPolicy: AlertIntakeEmergencyPolicy;
+    /**
+     * The URL to paste into the provider's console. Null for a polled provider.
+     * It embeds an unguessable key: treat it as a credential.
+     */
+    webhookUrl: string | null;
+    /** When the provider last completed its verification handshake (WhatsApp). */
+    webhookVerifiedAt: string | null;
+    lastReceivedAt: string | null;
+    lastError: string | null;
+    lastErrorAt: string | null;
+    /** Set on the connections created from the pre-organization, per-tenant setup. */
+    legacyKey: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Sends the messages of a PLATFORM connection to an organization. */
+export interface AlertIntakeRoute {
+    id: string;
+    connectionId: string;
+    match: AlertIntakeRouteMatch;
+    /** Upper-cased. Null for the DEFAULT route. */
+    keyword: string | null;
+    organizationId: number;
+    enabled: boolean;
+    createdAt: string;
+}
+/** What the incident will be created with, derived from the organization record. */
+export interface AlertIntakeOrganizationContext {
+    organizationId: number;
+    name: string;
+    appId: string;
+    incidentClass: string;
+    workflowTaskQueueName: string;
+    countryCode: CountryCode;
+    /** False when the organization is not ACTIVE: its messages are held, not raised. */
+    active: boolean;
+}
+/** What an organization without a connection of its own falls back to, per channel. */
+export interface AlertIntakePlatformFallback {
+    channel: AlertIntakeChannel;
+    /** The shared address to publish, e.g. the platform short code. */
+    address: string;
+    provider: AlertIntakeProvider;
+    /** The keyword that routes to this organization, when it has one. */
+    keyword: string | null;
+    /** True when this organization is the connection's DEFAULT route. */
+    isDefault: boolean;
+}
+/** Everything the settings page needs, in one read. */
+export interface OrganizationAlertIntakeSettings {
+    organizationId: number;
+    /** Null when clarion-organization could not be reached or the id is unknown. */
+    organization: AlertIntakeOrganizationContext | null;
+    connections: AlertIntakeConnection[];
+    platformFallbacks: AlertIntakePlatformFallback[];
+    /** False when the service has no key to encrypt credentials with: only secret references can be used. */
+    encryptedSecretsAvailable: boolean;
+}
+export interface AlertIntakeConnectionTestResult {
+    success: boolean;
+    /** Operator-facing. Never contains a credential. */
+    message: string;
+    latencyMs?: number;
+}
+export interface CreateAlertIntakeConnection {
+    channel: AlertIntakeChannel;
+    provider: AlertIntakeProvider;
+    /** 2-100 characters, single line. */
+    name: string;
+    /** What people send to: the short code or number, the WhatsApp phone-number id, the mailbox address. */
+    address: string;
+    enabled?: boolean;
+    /** Non-secret provider settings, as the provider descriptor declares them. */
+    config?: Record<string, string | number | boolean>;
+    /** Credentials. WRITE-ONLY: encrypted at rest and never returned. Keys are the descriptor's secret fields. */
+    secrets?: Record<string, string>;
+    /** Platform operators only. NAMES of provisioned secrets, used instead of `secrets` - never both. */
+    secretReferences?: Record<string, string>;
+    emergencyPolicy?: AlertIntakeEmergencyPolicy;
+}
+/**
+ * Channel and provider cannot change: a connection IS its provider link. `config`
+ * is merged over the stored settings and only the `secrets` sent are replaced; a key
+ * sent as "" is removed.
+ */
+export interface UpdateAlertIntakeConnection {
+    name?: string;
+    address?: string;
+    enabled?: boolean;
+    config?: Record<string, string | number | boolean>;
+    secrets?: Record<string, string>;
+    /** Platform operators only. */
+    secretReferences?: Record<string, string>;
+    emergencyPolicy?: AlertIntakeEmergencyPolicy;
+}
+/** Platform operators only: sends a PLATFORM connection's messages to an organization. */
+export interface CreateAlertIntakeRoute {
+    match: AlertIntakeRouteMatch;
+    /** Required for KEYWORD; must be absent for DEFAULT. */
+    keyword?: string;
+    organizationId: number;
+    enabled?: boolean;
+}
+export interface UpdateAlertIntakeRoute {
+    organizationId?: number;
+    enabled?: boolean;
+}
+/** A platform connection as the operator list returns it: the connection plus its routes. */
+export type AlertIntakePlatformConnection = AlertIntakeConnection & {
+    routes: AlertIntakeRoute[];
+};

package/dist/types/modules/alert-intake/utils/alert-intake.util.d.ts

@@ -0,0 +1,24 @@
+/** A routing keyword: 2-20 letters or digits, stored upper-cased. */
+export declare const ALERT_INTAKE_KEYWORD_PATTERN: RegExp;
+/** Upper bounds that keep one organization's settings a form rather than a list to page through. */
+export declare const MAX_ALERT_INTAKE_CONNECTIONS_PER_ORGANIZATION = 20;
+export declare const MAX_ALERT_INTAKE_ROUTES_PER_CONNECTION = 200;
+/** One settings value (config or secret). An access token is the longest thing that goes here. */
+export declare const MAX_ALERT_INTAKE_SETTING_LENGTH = 4096;
+/** Normalises what an operator typed into the stored form. Null when it is not a valid keyword. */
+export declare function normaliseAlertIntakeKeyword(value: string | null | undefined): string | null;
+/**
+ * The routing keyword of a message: its first word, upper-cased, punctuation
+ * stripped - `g4s, fire at the gate` and `G4S: fire` both give `G4S`.
+ * Null when the first word could not be a keyword.
+ *
+ * Deliberately only the FIRST word. Matching a keyword anywhere in the text would
+ * route "I was robbed near the G4S office" to G4S.
+ */
+export declare function extractAlertIntakeKeyword(text: string | null | undefined): string | null;
+/**
+ * The message with its routing keyword removed, so "G4S fire at the gate" is
+ * analysed as "fire at the gate". Returns the text unchanged when it does not start
+ * with that keyword.
+ */
+export declare function stripAlertIntakeKeyword(text: string, keyword: string): string;

package/dist/types/modules/notification/enums/notification-settings.enums.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Organization notification settings enums.
+ *
+ * MIRRORS grm-shared-library (`modules/notification/enums`), values included. The
+ * admin renders and submits these strings and clarion-notification validates the
+ * same ones, so any drift is a form the API refuses. `notification-settings.spec.ts`
+ * pins the values.
+ */
+/** What kind of identity an SMS is sent from. Decides how the value is validated. */
+export declare enum SmsSenderType {
+    /** A registered alphanumeric sender name, e.g. `G4S`. At most 11 characters. */
+    ALPHANUMERIC = "ALPHANUMERIC",
+    /** An E.164 long number, e.g. `+254711000000`. */
+    PHONE_NUMBER = "PHONE_NUMBER",
+    /** A telco short code, e.g. `22384`. */
+    SHORT_CODE = "SHORT_CODE",
+    /** A provider-side sender pool (Twilio Messaging Service SID, `MG...`). */
+    MESSAGING_SERVICE = "MESSAGING_SERVICE"
+}
+/**
+ * Lifecycle of an organization-owned SMS sender. An organization REQUESTS a sender
+ * (PENDING) and a platform operator ACTIVATES it once the provider and the telco
+ * have registered it. Only ACTIVE senders are ever used to send.
+ */
+export declare enum NotificationSenderStatus {
+    PENDING = "PENDING",
+    ACTIVE = "ACTIVE",
+    SUSPENDED = "SUSPENDED",
+    REJECTED = "REJECTED"
+}
+/**
+ * Whether an email provider will accept mail FROM an organization's address.
+ * Tracked per provider: an address can be verified in Twilio SendGrid while its
+ * domain is unknown to Mailgun. A provider only sends from an address it has
+ * VERIFIED; otherwise it falls back to the platform sender.
+ */
+export declare enum EmailSenderVerificationStatus {
+    /** The provider does not know this address or its domain. */
+    UNVERIFIED = "UNVERIFIED",
+    /** Verification was started and is waiting on the owner (inbox click or DNS records). */
+    PENDING = "PENDING",
+    /** The provider accepts mail from this address. */
+    VERIFIED = "VERIFIED",
+    /** The last check could not be completed (provider error). */
+    FAILED = "FAILED"
+}
+/** How the provider recognises the address. */
+export declare enum EmailSenderVerificationMethod {
+    /** The exact address was verified on its own (SendGrid Single Sender Verification). */
+    SINGLE_SENDER = "SINGLE_SENDER",
+    /** The whole domain is authenticated (SendGrid domain authentication, Mailgun domain). */
+    DOMAIN = "DOMAIN"
+}
+/** Whose identity a message actually went out under. */
+export declare enum NotificationSenderSource {
+    /** The organization's own verified email address / active SMS sender. */
+    ORGANIZATION = "ORGANIZATION",
+    /** The platform's default (country-aware) sender. */
+    PLATFORM_DEFAULT = "PLATFORM_DEFAULT"
+}
+/**
+ * Where one resolved branding value came from. Branding resolves field by field,
+ * highest precedence first, so a half-filled profile still produces a complete email.
+ */
+export declare enum NotificationBrandingSource {
+    /** The organization's notification settings. */
+    PROFILE = "PROFILE",
+    /** The organization record (clarion-organization). */
+    ORGANIZATION = "ORGANIZATION",
+    /** The legacy per-app defaults (deprecated). */
+    APP_DEFAULT = "APP_DEFAULT",
+    /** The platform's own branding. */
+    PLATFORM_DEFAULT = "PLATFORM_DEFAULT"
+}

package/dist/types/modules/notification/enums/sms-provider-name.enum.d.ts

@@ -1,9 +1,14 @@
 /**
  * Identifiers for the SMS providers the notification service can dispatch through.
  * Provider order/fallback is configuration-driven; new providers can be appended.
+ *
+ * A code here only RESERVES the name. Whether a provider can actually be used is
+ * answered by the notification service's provider catalogue
+ * (`SmsProviderDescriptor`), which lists only providers with a registered adapter.
  */
 export declare enum SmsProviderName {
     TWILIO = "twilio",
     UWAZII = "uwazii",
-    AFRICASTALKING = "africastalking"
+    AFRICASTALKING = "africastalking",
+    CELCOM = "celcom"
 }

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

@@ -3,8 +3,11 @@ export * from './enums/sms-provider-name.enum';
 export * from './enums/email-provider-name.enum';
 export * from './enums/notification-overall-status.enum';
 export * from './enums/provider-failure-reason.enum';
+export * from './enums/notification-settings.enums';
 export * from './interfaces/provider-attempt';
 export * from './interfaces/per-channel-result';
 export * from './interfaces/sms-send-result';
 export * from './interfaces/email-send-result';
 export * from './interfaces/notification-dispatch-result';
+export * from './interfaces/organization-notification-settings.dto';
+export * from './utils/notification-sender.util';

package/dist/types/modules/notification/interfaces/organization-notification-settings.dto.d.ts

@@ -0,0 +1,213 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { IncidentAppId } from '../../incident/enums/incident-app-id.enum';
+import { EmailProviderName } from '../enums/email-provider-name.enum';
+import { EmailSenderVerificationMethod, EmailSenderVerificationStatus, NotificationBrandingSource, NotificationSenderSource, NotificationSenderStatus, SmsSenderType } from '../enums/notification-settings.enums';
+import { SmsProviderName } from '../enums/sms-provider-name.enum';
+/**
+ * Organization notification settings: what a customer sees in a notification - the
+ * logo and colours of an email, the address it came from, the name an SMS arrives
+ * under. `organizationId` is the single key; the legacy `appId` survives only as an
+ * alias for events that still carry nothing but an app id.
+ *
+ * MIRRORS grm-shared-library (`modules/notification/interfaces` and `dtos`). The
+ * response shapes are interfaces on both sides; the request shapes are class-validator
+ * DTOs on the backend and plain interfaces here. Owned by clarion-notification,
+ * proxied by the gateway, rendered by the admin. Nothing here is a secret.
+ */
+export interface NotificationSocialLinks {
+    facebook?: string | null;
+    x?: string | null;
+    instagram?: string | null;
+    linkedin?: string | null;
+}
+/** The values a notification template can brand itself with. */
+export interface NotificationBrandingFields {
+    /** Legal/trading name shown in the footer, e.g. `G4S Kenya Ltd`. */
+    companyName: string;
+    /** Product name the customer knows, e.g. `G4S Kenya`. Used in subjects and sign-offs. */
+    appName: string;
+    /** HTTPS URL of the logo. Email clients will not load anything else. */
+    logoUrl: string;
+    /** `#RRGGBB`. Buttons, links and accents. */
+    primaryColour: string;
+    /** `#RRGGBB`. Hover/pressed shade; derived from the primary when not chosen. */
+    primaryColourDark: string;
+    /** `#RRGGBB`. Header banner and footer background. */
+    accentColour: string;
+    physicalAddress: string;
+    phoneNumber: string;
+    /** General contact address printed in the footer. Not the address mail is sent FROM. */
+    contactEmail: string;
+    supportEmail: string;
+    websiteUrl: string;
+    /** Base URL that links in a notification point at (the organization's web client). */
+    clientBaseUrl: string;
+    social: NotificationSocialLinks;
+}
+/** What an organization has chosen to override. Every field is optional: gaps are resolved, not rejected. */
+export interface OrganizationNotificationBranding extends Partial<NotificationBrandingFields> {
+    organizationId: number;
+    /** Legacy alias: an appId-only event resolves to the organization that claims it. */
+    appId?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+    updatedBy?: number | null;
+}
+/** Branding after resolution: complete, and honest about where each value came from. */
+export interface ResolvedNotificationBranding extends NotificationBrandingFields {
+    organizationId: number | null;
+    sources: Record<keyof NotificationBrandingFields, NotificationBrandingSource>;
+}
+/** One provider's answer to "will you send mail from this address?". */
+export interface EmailSenderProviderVerification {
+    provider: EmailProviderName;
+    status: EmailSenderVerificationStatus;
+    method?: EmailSenderVerificationMethod | null;
+    /** Operator-facing explanation, e.g. "Domain ke.g4s.com is not added to Mailgun". */
+    detail?: string | null;
+    checkedAt?: string | null;
+}
+export interface OrganizationEmailSender {
+    id: string;
+    organizationId: number;
+    /** The address mail is sent FROM, e.g. `notifications@ke.g4s.com`. */
+    fromEmail: string;
+    /** Display name. Falls back to the resolved company name. */
+    fromName?: string | null;
+    /** Falls back to `fromEmail`. */
+    replyTo?: string | null;
+    /** The sender used when a notification does not ask for a specific one. One per organization. */
+    isDefault: boolean;
+    active: boolean;
+    verifications: EmailSenderProviderVerification[];
+    /** True when at least one configured provider has VERIFIED the address. */
+    usable: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface OrganizationSmsSender {
+    id: string;
+    organizationId: number;
+    /** The provider account this sender is registered with. */
+    provider: SmsProviderName;
+    /** The destination country it is registered for. Null = every country the provider serves. */
+    countryCode?: CountryCode | null;
+    senderType: SmsSenderType;
+    senderId: string;
+    status: NotificationSenderStatus;
+    /** Registration reference, telco ticket, anything the operator needs later. */
+    notes?: string | null;
+    reviewedBy?: number | null;
+    reviewedAt?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/** A sender type a provider accepts, with everything a form needs to collect it. */
+export interface SmsProviderSenderTypeDescriptor {
+    type: SmsSenderType;
+    label: string;
+    placeholder?: string;
+    description?: string;
+}
+/**
+ * Self-description of an SMS provider, published by clarion-notification. Adding a
+ * provider (Celcom, Africa's Talking, ...) changes no client code. Only providers
+ * with a registered adapter are described.
+ */
+export interface SmsProviderDescriptor {
+    provider: SmsProviderName;
+    displayName: string;
+    description: string;
+    /** Countries the adapter can deliver to. */
+    supportedCountries: CountryCode[];
+    senderTypes: SmsProviderSenderTypeDescriptor[];
+    /** Whether the platform's account for this provider is configured and enabled right now. */
+    configured: boolean;
+    documentationUrl?: string;
+}
+/** The platform senders an organization falls back to. Display-only. */
+export interface PlatformNotificationDefaults {
+    email: {
+        fromEmail: string | null;
+        fromName: string | null;
+    };
+    /** Per-country default SMS provider chain, e.g. `{ KE: ['twilio', 'uwazii'] }`. */
+    smsProviderChains: Partial<Record<CountryCode, SmsProviderName[]>>;
+    /** Email providers currently able to send, in order. */
+    emailProviders: EmailProviderName[];
+}
+/** Everything the settings page needs, in one read. */
+export interface OrganizationNotificationSettings {
+    organizationId: number;
+    /** Null until the organization saves a profile. */
+    branding: OrganizationNotificationBranding | null;
+    effectiveBranding: ResolvedNotificationBranding;
+    emailSenders: OrganizationEmailSender[];
+    smsSenders: OrganizationSmsSender[];
+    platformDefaults: PlatformNotificationDefaults;
+}
+/**
+ * Saves an organization's branding. A field sent as null (or "") stops overriding
+ * and inherits again; a field left out is untouched.
+ */
+export interface UpsertOrganizationNotificationBranding {
+    /** Super-admin only. */
+    appId?: IncidentAppId | null;
+    companyName?: string | null;
+    appName?: string | null;
+    /** HTTPS only. */
+    logoUrl?: string | null;
+    primaryColour?: string | null;
+    primaryColourDark?: string | null;
+    accentColour?: string | null;
+    physicalAddress?: string | null;
+    phoneNumber?: string | null;
+    contactEmail?: string | null;
+    supportEmail?: string | null;
+    websiteUrl?: string | null;
+    clientBaseUrl?: string | null;
+    social?: NotificationSocialLinks | null;
+}
+export interface CreateOrganizationEmailSender {
+    fromEmail: string;
+    fromName?: string | null;
+    replyTo?: string | null;
+    isDefault?: boolean;
+}
+export interface UpdateOrganizationEmailSender {
+    fromName?: string | null;
+    replyTo?: string | null;
+    isDefault?: boolean;
+    active?: boolean;
+}
+export interface CreateOrganizationSmsSender {
+    provider: SmsProviderName;
+    countryCode?: CountryCode | null;
+    senderType: SmsSenderType;
+    senderId: string;
+    notes?: string | null;
+}
+export interface UpdateOrganizationSmsSender {
+    countryCode?: CountryCode | null;
+    senderType?: SmsSenderType;
+    /** Changing the value sends the sender back to PENDING. */
+    senderId?: string;
+    notes?: string | null;
+}
+/** Platform operators only. */
+export interface ReviewOrganizationSmsSender {
+    status: NotificationSenderStatus;
+    notes?: string | null;
+}
+export interface SendTestNotificationEmail {
+    to: string;
+}
+/** What the test-email endpoint answers with. */
+export interface TestNotificationEmailResult {
+    success: boolean;
+    provider: string | null;
+    /** The address the email actually went out from. */
+    sender: string | null;
+    senderSource: NotificationSenderSource | null;
+    errorMessage: string | null;
+}

package/dist/types/modules/notification/utils/notification-sender.util.d.ts

@@ -0,0 +1,44 @@
+import { SmsSenderType } from '../enums/notification-settings.enums';
+/**
+ * MIRRORS grm-shared-library (`modules/notification/constants` and `utils`),
+ * patterns and thresholds included. The settings form validates with these and
+ * clarion-notification validates with the originals, so they must agree to the
+ * character: a form that accepts what the API refuses is worse than no check.
+ */
+/** `#RRGGBB`. The only colour format accepted, because it is inlined into email CSS. */
+export declare const BRAND_COLOUR_PATTERN: RegExp;
+/**
+ * What a sender value must look like, per type. ALPHANUMERIC follows the GSM rule
+ * every supported provider enforces: 3-11 characters, at least one letter (an
+ * all-digit "name" is a number, and telcos reject it as spoofing).
+ */
+export declare const SMS_SENDER_ID_PATTERNS: Readonly<Record<SmsSenderType, RegExp>>;
+/** Human-readable form of {@link SMS_SENDER_ID_PATTERNS}, for validation messages and form hints. */
+export declare const SMS_SENDER_ID_HINTS: Readonly<Record<SmsSenderType, string>>;
+/** Upper bounds that keep one organization from turning its settings into a list to page through. */
+export declare const MAX_EMAIL_SENDERS_PER_ORGANIZATION = 10;
+export declare const MAX_SMS_SENDERS_PER_ORGANIZATION = 30;
+/** Large text and UI components (WCAG 1.4.11): buttons and links in the primary colour. */
+export declare const MIN_PRIMARY_COLOUR_CONTRAST = 3;
+/** Body-size white text sits on the accent colour (WCAG 1.4.3). */
+export declare const MIN_ACCENT_COLOUR_CONTRAST = 4.5;
+/**
+ * Validates an SMS sender value against its declared type.
+ * Returns null when valid, otherwise a message fit to show an operator.
+ */
+export declare function validateSmsSenderId(senderType: SmsSenderType, senderId: string): string | null;
+/** The domain part of an email address, lower-cased. Null when there is none. */
+export declare function emailDomainOf(address: string | null | undefined): string | null;
+/**
+ * WCAG contrast ratio of a `#RRGGBB` colour against white, from 1 (white) to 21
+ * (black). The email templates put WHITE text on the primary colour (buttons) and
+ * on the accent colour (header banner, footer), so a pale brand colour produces
+ * an email nobody can read. Returns 0 for anything that is not a hex colour.
+ */
+export declare function contrastRatioWithWhite(hex: string): number;
+/**
+ * Darkens a `#RRGGBB` colour by a fraction (0-1). Used to derive the hover/pressed
+ * shade of a brand colour so an organization only has to choose one.
+ * Returns the input unchanged when it is not a valid hex colour.
+ */
+export declare function darkenHexColour(hex: string, fraction?: number): string;

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

@@ -81,5 +81,11 @@ export declare enum PermissionActions {
     MANAGE_SUPPORT_CONFIGURATION = "manage:support-configuration",
     READ_SUPPORT_REPORT = "read:support-report",
     READ_SUPPORT_SYNC = "read:support-sync",
-    MANAGE_SUPPORT_SYNC = "manage:support-sync"
+    MANAGE_SUPPORT_SYNC = "manage:support-sync",
+    READ_NOTIFICATION_SETTINGS = "read:notification-settings",
+    MANAGE_NOTIFICATION_SETTINGS = "manage:notification-settings",
+    APPROVE_NOTIFICATION_SENDER = "approve:notification-sender",
+    READ_ALERT_INTAKE = "read:alert-intake",
+    MANAGE_ALERT_INTAKE = "manage:alert-intake",
+    MANAGE_ALERT_INTAKE_PLATFORM = "manage:alert-intake-platform"
 }

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

@@ -8,5 +8,7 @@ export declare enum PermissionsModule {
     INCIDENT = "Grievance",
     RESPONSE_UNIT = "Response Unit",
     TRACKING = "Tracking",
-    SUPPORT = "Support"
+    SUPPORT = "Support",
+    NOTIFICATION = "Notification",
+    ALERT_INTAKE = "Alert Intake"
 }

package/package.json

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