grm-shared-library 1.1.201 → 1.1.203

package/dist/types/modules/support/enums/support-sync.enum.d.ts

@@ -0,0 +1,108 @@
+/** Which Clarion record a synchronization row is mirroring. */
+export declare enum SupportSyncEntityType {
+    TICKET = "TICKET",
+    MESSAGE = "MESSAGE",
+    ATTACHMENT = "ATTACHMENT",
+    /** The customer's contact record in the helpdesk. */
+    CONTACT = "CONTACT"
+}
+/** What the synchronization row is trying to do at the provider. */
+export declare enum SupportSyncOperation {
+    UPSERT_CONTACT = "UPSERT_CONTACT",
+    CREATE_TICKET = "CREATE_TICKET",
+    UPDATE_TICKET = "UPDATE_TICKET",
+    ADD_PUBLIC_REPLY = "ADD_PUBLIC_REPLY",
+    ADD_INTERNAL_NOTE = "ADD_INTERNAL_NOTE",
+    ASSIGN_TICKET = "ASSIGN_TICKET",
+    CHANGE_STATUS = "CHANGE_STATUS",
+    ADD_ATTACHMENT = "ADD_ATTACHMENT",
+    CLOSE_TICKET = "CLOSE_TICKET",
+    REOPEN_TICKET = "REOPEN_TICKET",
+    /** Re-read the provider's copy to reconcile drift. Changes nothing outward. */
+    FETCH_TICKET = "FETCH_TICKET"
+}
+/**
+ * Operations that create something at the provider and therefore must never be
+ * blindly retried once the provider has answered 2xx.
+ *
+ * The same reasoning as a partner dispatch: a reply the customer has already
+ * been sent twice is a smaller harm than a duplicate ambulance, but it is still
+ * a harm, and an un-readable success is a question for a human.
+ */
+export declare const CREATING_SUPPORT_SYNC_OPERATIONS: readonly SupportSyncOperation[];
+/** Where a synchronization row has got to. */
+export declare enum SupportSyncStatus {
+    /** Queued, waiting for the worker. */
+    PENDING = "PENDING",
+    /** Claimed by a worker and in flight. */
+    IN_PROGRESS = "IN_PROGRESS",
+    /** The provider accepted it. */
+    SUCCEEDED = "SUCCEEDED",
+    /** Failed and will be retried. */
+    FAILED = "FAILED",
+    /** Out of attempts, or permanently failed. Waiting for a human. */
+    DEAD_LETTER = "DEAD_LETTER",
+    /** Deliberately not attempted - the provider is NONE, or lacks the capability. */
+    SKIPPED = "SKIPPED",
+    /** Superseded by a later operation on the same entity before it ever ran. */
+    SUPERSEDED = "SUPERSEDED"
+}
+/** Synchronization rows that no longer represent outstanding work. */
+export declare const TERMINAL_SUPPORT_SYNC_STATUSES: readonly SupportSyncStatus[];
+/**
+ * Why a synchronization attempt failed, in a taxonomy shared by every adapter.
+ *
+ * This is the single place the retry policy is decided. An adapter classifies;
+ * it never chooses whether to retry, because "should we call the helpdesk
+ * again?" must not be answered differently by Zammad and Freshdesk.
+ */
+export declare enum SupportSyncFailureReason {
+    /** The credential was refused. Retrying with the same credential cannot help. */
+    AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED",
+    /** The account lacks the permission or the feature. */
+    AUTHORIZATION_FAILED = "AUTHORIZATION_FAILED",
+    /** The provider could not read the request. A retry sends the same bytes. */
+    INVALID_PAYLOAD = "INVALID_PAYLOAD",
+    /** The provider-side record is gone. */
+    NOT_FOUND = "NOT_FOUND",
+    /** The provider said no on the merits. */
+    PROVIDER_REJECTED = "PROVIDER_REJECTED",
+    /** Throttled. Retry after the advertised delay. */
+    RATE_LIMITED = "RATE_LIMITED",
+    /** 5xx, connection refused, DNS - the provider is down or unreachable. */
+    PROVIDER_UNAVAILABLE = "PROVIDER_UNAVAILABLE",
+    /** The request timed out with no answer, so the outcome is unknown. */
+    TIMEOUT = "TIMEOUT",
+    /** The circuit breaker is open; nothing was sent. */
+    CIRCUIT_OPEN = "CIRCUIT_OPEN",
+    /** No provider is configured, or its credential reference is missing. */
+    PROVIDER_NOT_CONFIGURED = "PROVIDER_NOT_CONFIGURED",
+    /** A 2xx whose body could not be understood. Permanent, and a human must look. */
+    UNREADABLE_SUCCESS = "UNREADABLE_SUCCESS",
+    /** Anything unrecognised. Treated as transient. */
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * Failures a retry can never fix.
+ *
+ * Everything not listed here is transient, deliberately: a support message that
+ * arrives late is recoverable, and one that is dropped because an unfamiliar
+ * error looked fatal is not.
+ *
+ * UNREADABLE_SUCCESS is permanent for the opposite reason to the rest - the
+ * provider very likely DID accept it, and repeating a create would duplicate a
+ * ticket or double-send a reply to a customer.
+ */
+export declare const PERMANENT_SUPPORT_SYNC_FAILURE_REASONS: readonly SupportSyncFailureReason[];
+/** How a provider webhook delivery was handled. */
+export declare enum SupportWebhookStatus {
+    RECEIVED = "RECEIVED",
+    PROCESSED = "PROCESSED",
+    /** A duplicate delivery of an event already applied. */
+    DUPLICATE = "DUPLICATE",
+    /** Understood, and deliberately not acted on (an echo of our own write). */
+    IGNORED = "IGNORED",
+    /** Signature verification failed. Never processed. */
+    REJECTED = "REJECTED",
+    FAILED = "FAILED"
+}

package/dist/types/modules/support/enums/support-ticket-channel.enum.d.ts

@@ -0,0 +1,30 @@
+/** How a ticket reached Clarion. */
+export declare enum SupportTicketChannel {
+    /** The Flutter customer app. */
+    MOBILE_APP = "MOBILE_APP",
+    /** The Angular admin / web application. */
+    WEB_APP = "WEB_APP",
+    /** Raised by an agent on a customer's behalf, e.g. after a phone call. */
+    AGENT_PORTAL = "AGENT_PORTAL",
+    /** Arrived at the helpdesk directly - an email to the support address - and synced in. */
+    PROVIDER = "PROVIDER",
+    EMAIL = "EMAIL",
+    PHONE = "PHONE",
+    SMS = "SMS",
+    CHAT = "CHAT",
+    /** Created by the platform itself, e.g. converted from customer feedback. */
+    SYSTEM = "SYSTEM",
+    API = "API"
+}
+/** Who or what caused the ticket to exist. Orthogonal to the channel it arrived on. */
+export declare enum SupportTicketSource {
+    CUSTOMER = "CUSTOMER",
+    AGENT = "AGENT",
+    SYSTEM = "SYSTEM",
+    /** Promoted from a piece of customer feedback; keeps `feedback.convertedTicketId`. */
+    FEEDBACK_CONVERSION = "FEEDBACK_CONVERSION",
+    /** Found in the helpdesk during a sync or reconciliation, with no Clarion origin. */
+    PROVIDER_SYNC = "PROVIDER_SYNC",
+    /** Escalated out of a chat conversation. */
+    CHAT_ESCALATION = "CHAT_ESCALATION"
+}

package/dist/types/modules/support/enums/support-ticket-message.enum.d.ts

@@ -0,0 +1,42 @@
+/**
+ * What kind of entry a ticket message is.
+ *
+ * INTERNAL_NOTE is the load-bearing member: it is the only value that must
+ * never be visible to a customer, and every customer-facing read path filters
+ * on this enum rather than on a boolean somebody might forget to set.
+ */
+export declare enum SupportTicketMessageType {
+    /** Written by the customer. */
+    CUSTOMER_MESSAGE = "CUSTOMER_MESSAGE",
+    /** Written by an agent and addressed to the customer. */
+    AGENT_REPLY = "AGENT_REPLY",
+    /** Agent to agent. NEVER returned on a customer-facing endpoint. */
+    INTERNAL_NOTE = "INTERNAL_NOTE",
+    /** Generated by Clarion, e.g. a first-response target being missed. */
+    SYSTEM_MESSAGE = "SYSTEM_MESSAGE",
+    /** A recorded state change, rendered inline in the conversation. */
+    STATUS_MESSAGE = "STATUS_MESSAGE"
+}
+/**
+ * The only message types a customer may ever be shown.
+ *
+ * Read this list rather than negating INTERNAL_NOTE: a message type added later
+ * is then invisible to customers until somebody decides otherwise, which is the
+ * safe direction for the mistake to fall.
+ */
+export declare const CUSTOMER_VISIBLE_SUPPORT_MESSAGE_TYPES: readonly SupportTicketMessageType[];
+/** Who wrote a message. Separate from the type, so a system note stays attributable. */
+export declare enum SupportMessageAuthorType {
+    CUSTOMER = "CUSTOMER",
+    AGENT = "AGENT",
+    SYSTEM = "SYSTEM",
+    /** Authored in the helpdesk by somebody with no Clarion user id. */
+    PROVIDER_AGENT = "PROVIDER_AGENT"
+}
+/** Where a message originated, which decides whether it needs mirroring outward. */
+export declare enum SupportMessageOrigin {
+    /** Written in Clarion. Must be pushed to the provider. */
+    CLARION = "CLARION",
+    /** Arrived from the provider. Must never be pushed back. */
+    PROVIDER = "PROVIDER"
+}

package/dist/types/modules/support/enums/support-ticket-priority.enum.d.ts

@@ -0,0 +1,24 @@
+/**
+ * How urgently a ticket needs answering.
+ *
+ * CRITICAL exists because this is an emergency-response platform: "the panic
+ * button does not reach the control room" is not the same class of problem as
+ * "the invoice PDF has the wrong logo", and a support desk that cannot say so
+ * will end up treating them the same.
+ */
+export declare enum SupportTicketPriority {
+    /** Emergency response is impaired for a live tenant. */
+    CRITICAL = "CRITICAL",
+    /** A core workflow is broken with no workaround. */
+    URGENT = "URGENT",
+    /** A significant problem with a workaround. */
+    HIGH = "HIGH",
+    /** The default. */
+    NORMAL = "NORMAL",
+    /** A question, or something cosmetic. */
+    LOW = "LOW"
+}
+/** Most urgent first. Used to order a queue and to order report axes. */
+export declare const SUPPORT_TICKET_PRIORITY_ORDER: readonly SupportTicketPriority[];
+/** Numeric rank for sorting in SQL and in the client. Lower is more urgent. */
+export declare const SUPPORT_TICKET_PRIORITY_RANK: Readonly<Record<SupportTicketPriority, number>>;

package/dist/types/modules/support/enums/support-ticket-status.enum.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Lifecycle of a support ticket inside Clarion.
+ *
+ * Clarion owns this state machine even when a helpdesk is the operational
+ * source of truth for agent workflow: a provider status arriving over a webhook
+ * is MAPPED onto one of these and then validated like any other transition, so
+ * a vendor can never put a Clarion ticket into a state the domain does not
+ * recognise.
+ *
+ * Nothing here is a free-text string, and no code outside
+ * {@link SUPPORT_TICKET_TRANSITIONS} decides whether a move is allowed.
+ */
+export declare enum SupportTicketStatus {
+    /** Created and not yet triaged. The only entry state. */
+    NEW = "NEW",
+    /** Triaged into a queue; nobody has picked it up. */
+    OPEN = "OPEN",
+    /** An agent owns it but has not started. */
+    ASSIGNED = "ASSIGNED",
+    /** An agent is actively working it. */
+    IN_PROGRESS = "IN_PROGRESS",
+    /** Waiting for the customer. SLA clocks pause here. */
+    WAITING_ON_CUSTOMER = "WAITING_ON_CUSTOMER",
+    /** Waiting on another Clarion team. Clocks keep running - this delay is ours. */
+    WAITING_ON_INTERNAL_TEAM = "WAITING_ON_INTERNAL_TEAM",
+    /** The agent believes it is done; the customer has not confirmed. */
+    RESOLVED = "RESOLVED",
+    /** Finished. Reopening is possible and is recorded as such. */
+    CLOSED = "CLOSED",
+    /** Reopened after being closed. Distinct from OPEN so reopen rate is measurable. */
+    REOPENED = "REOPENED",
+    /** Withdrawn before any work happened - a duplicate, or raised by mistake. */
+    CANCELLED = "CANCELLED"
+}
+/** States from which no further transition is allowed. */
+export declare const TERMINAL_SUPPORT_TICKET_STATUSES: readonly SupportTicketStatus[];
+/** States a customer still counts as open on their own ticket list. */
+export declare const ACTIVE_SUPPORT_TICKET_STATUSES: readonly SupportTicketStatus[];
+/** States in which an SLA clock is deliberately not running. */
+export declare const SLA_PAUSED_SUPPORT_TICKET_STATUSES: readonly SupportTicketStatus[];
+/** States that stop every SLA clock for good. */
+export declare const SLA_STOPPED_SUPPORT_TICKET_STATUSES: readonly SupportTicketStatus[];
+/**
+ * Every transition the domain permits, keyed by the state being left.
+ *
+ * Deliberately more permissive in a few places than a textbook happy path, and
+ * each one is a real support-desk behaviour rather than a convenience:
+ *
+ *  - Any live state may go straight to RESOLVED. An agent who fixes something
+ *    while a ticket is merely OPEN should not have to assign it to themselves
+ *    first in order to say so.
+ *  - Any live state may go to CANCELLED. Duplicates are noticed at every stage.
+ *  - RESOLVED may go back to IN_PROGRESS. A customer who says it did not work
+ *    before the ticket auto-closes has not reopened a closed ticket, and
+ *    counting that as a reopen would overstate the reopen rate.
+ *  - CLOSED may only become REOPENED, so every return from closed is counted.
+ */
+export declare const SUPPORT_TICKET_TRANSITIONS: Readonly<Record<SupportTicketStatus, readonly SupportTicketStatus[]>>;

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

@@ -0,0 +1,38 @@
+export * from './enums/support-provider-code.enum';
+export * from './enums/support-ticket-status.enum';
+export * from './enums/support-ticket-priority.enum';
+export * from './enums/support-ticket-channel.enum';
+export * from './enums/support-ticket-message.enum';
+export * from './enums/support-sla.enum';
+export * from './enums/support-feedback.enum';
+export * from './enums/support-related-entity-type.enum';
+export * from './enums/support-sync.enum';
+export * from './enums/support-audit-action.enum';
+export * from './enums/support-routing.enum';
+export * from './interfaces/support-ticket';
+export * from './interfaces/support-ticket-message';
+export * from './interfaces/support-configuration';
+export * from './interfaces/customer-feedback';
+export * from './interfaces/support-provider-descriptor';
+export * from './interfaces/support-sync';
+export * from './interfaces/support-events';
+export * from './interfaces/support-realtime';
+export * from './interfaces/support-reports';
+export * from './constants/support-defaults.const';
+export * from './constants/support-kafka.const';
+export * from './dtos/support-related-entity.dto';
+export * from './dtos/create-support-ticket.dto';
+export * from './dtos/support-ticket-actions.dto';
+export * from './dtos/create-support-ticket-message.dto';
+export * from './dtos/support-ticket-query.dto';
+export * from './dtos/customer-feedback.dto';
+export * from './dtos/support-configuration.dto';
+export * from './dtos/support-sync.dto';
+export * from './dtos/support-report-query.dto';
+export * from './utils/support-ticket-number.util';
+export * from './utils/support-status.util';
+export * from './utils/support-redaction.util';
+export * from './utils/support-sla.util';
+export * from './utils/support-sync.util';
+export * from './utils/support-feedback.util';
+export * from './utils/support-routing.util';

package/dist/types/modules/support/interfaces/customer-feedback.d.ts

@@ -0,0 +1,115 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { IncidentAppId } from '../../incident/enums/incident-app-id.enum';
+import { CustomerFeedbackChannel, CustomerFeedbackMessageAuthorType, CustomerFeedbackSentiment, CustomerFeedbackStatus, CustomerFeedbackType } from '../enums/support-feedback.enum';
+import { SupportRelatedEntityRef } from './support-ticket';
+/**
+ * Diagnostic context captured with a piece of feedback.
+ *
+ * Everything here is chosen so a bug report is actionable without being a
+ * privacy problem. There is no token, no OTP, no password, no request body and
+ * no response body - a client that tries to send one has it stripped, because
+ * "the whole failing request would be so useful" is exactly how credentials end
+ * up in a support table that a wide group of people can read.
+ */
+export interface CustomerFeedbackContext {
+    /** Client application, e.g. G4S. */
+    appId?: IncidentAppId | null;
+    appVersion?: string | null;
+    /** ios | android | web */
+    platform?: string | null;
+    osVersion?: string | null;
+    deviceModel?: string | null;
+    /** The screen or feature the customer was on. */
+    screen?: string | null;
+    locale?: string | null;
+    /** Ties the report to server-side logs without carrying any of their content. */
+    correlationId?: string | null;
+}
+/**
+ * A piece of customer feedback.
+ *
+ * A first-class Clarion domain, deliberately separate from tickets. Feedback is
+ * never owned by a helpdesk: it is how the product hears from its users, it has
+ * to stay queryable when the support provider changes, and most of it needs no
+ * agent at all. Where it does, it is CONVERTED into a ticket and the link is
+ * kept - the two records never merge.
+ */
+export interface CustomerFeedback {
+    id: string;
+    organizationId: number;
+    controlCentreId?: number | null;
+    countryCode: CountryCode;
+    submittedByUserId: number;
+    /** Resolved for display in the admin. Absent on customer-facing reads. */
+    submittedByName?: string | null;
+    type: CustomerFeedbackType;
+    channel: CustomerFeedbackChannel;
+    status: CustomerFeedbackStatus;
+    title?: string | null;
+    message: string;
+    /** 1-5, and only for the rating types. Null otherwise. */
+    rating?: number | null;
+    /** Derived from type and rating, never from the text. */
+    sentiment: CustomerFeedbackSentiment;
+    context?: CustomerFeedbackContext | null;
+    /** What the feedback is about, when it is about something specific. */
+    relatedEntities: SupportRelatedEntityRef[];
+    /** Set once the feedback has been promoted into a ticket. */
+    convertedTicketId?: string | null;
+    convertedTicketNumber?: string | null;
+    convertedAt?: string | null;
+    reviewedByUserId?: number | null;
+    reviewedByName?: string | null;
+    reviewedAt?: string | null;
+    /** When the customer was last replied to. */
+    respondedAt?: string | null;
+    /** Count of entries in the thread, so a list can show that a reply exists. */
+    messageCount: number;
+    /** Free-text labels for triage. */
+    tags: string[];
+    /** Optimistic concurrency, as on a ticket. */
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/** The shape a feedback list returns. */
+export interface CustomerFeedbackSummary {
+    id: string;
+    organizationId: number;
+    countryCode: CountryCode;
+    submittedByUserId: number;
+    submittedByName?: string | null;
+    type: CustomerFeedbackType;
+    channel: CustomerFeedbackChannel;
+    status: CustomerFeedbackStatus;
+    title?: string | null;
+    /** First line of the message, clamped, so a list is readable without the body. */
+    preview: string;
+    rating?: number | null;
+    sentiment: CustomerFeedbackSentiment;
+    appId?: IncidentAppId | null;
+    appVersion?: string | null;
+    platform?: string | null;
+    convertedTicketId?: string | null;
+    convertedTicketNumber?: string | null;
+    messageCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * One entry in a feedback thread.
+ *
+ * Feedback is two-way where a reply is appropriate. It is not a ticket
+ * conversation and deliberately has no internal notes: a reviewer who needs to
+ * discuss something privately converts the feedback into a ticket, which is the
+ * record that supports that.
+ */
+export interface CustomerFeedbackMessage {
+    id: string;
+    feedbackId: string;
+    authorType: CustomerFeedbackMessageAuthorType;
+    authorUserId?: number | null;
+    authorName?: string | null;
+    body: string;
+    createdAt: string;
+}

package/dist/types/modules/support/interfaces/support-configuration.d.ts

@@ -0,0 +1,170 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { IncidentAppId } from '../../incident/enums/incident-app-id.enum';
+import { SupportRelatedEntityType } from '../enums/support-related-entity-type.enum';
+import { SupportQueueAssignmentStrategy, SupportRoutingMatchType, SupportTeamMemberRole } from '../enums/support-routing.enum';
+import { SupportSlaClock } from '../enums/support-sla.enum';
+import { SupportTicketChannel } from '../enums/support-ticket-channel.enum';
+import { SupportTicketPriority } from '../enums/support-ticket-priority.enum';
+/**
+ * A ticket category.
+ *
+ * Two levels at most - a parent and its children - because a support taxonomy
+ * deeper than that stops being navigable in a dropdown and starts being a
+ * search problem.
+ */
+export interface SupportCategory {
+    id: string;
+    /** Null for a platform-wide category available to every tenant. */
+    organizationId?: number | null;
+    parentId?: string | null;
+    name: string;
+    /** Stable machine key, e.g. BILLING. Unique per organization. */
+    code: string;
+    description?: string | null;
+    /** Priority applied to a new ticket in this category when the client sends none. */
+    defaultPriority?: SupportTicketPriority | null;
+    /** Queue a new ticket lands in, unless a routing rule says otherwise. */
+    defaultQueueId?: string | null;
+    /** Which Clarion record this category expects tickets to be about. */
+    expectedRelatedEntityType?: SupportRelatedEntityType | null;
+    displayOrder: number;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/** A shared inbox tickets are routed into. */
+export interface SupportQueue {
+    id: string;
+    organizationId: number;
+    /** Narrows the queue to one control centre when set. */
+    controlCentreId?: number | null;
+    /** Narrows the queue to one country. A KE queue never sees a UG ticket. */
+    countryCode?: CountryCode | null;
+    name: string;
+    code: string;
+    description?: string | null;
+    /** The team that works this queue. */
+    teamId?: string | null;
+    assignmentStrategy: SupportQueueAssignmentStrategy;
+    /** Overrides the organization's SLA policy for tickets in this queue. */
+    slaPolicyId?: string | null;
+    /** Order in which queues are offered and reported. */
+    displayOrder: number;
+    active: boolean;
+    /** Live counts, filled on a list read. */
+    openTicketCount?: number;
+    unassignedTicketCount?: number;
+    breachedTicketCount?: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/** A group of support people. */
+export interface SupportTeam {
+    id: string;
+    organizationId: number;
+    name: string;
+    code: string;
+    description?: string | null;
+    /** Escalations for this team's tickets go here first. */
+    supervisorUserIds: number[];
+    active: boolean;
+    memberCount?: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/** One person's membership of a team. */
+export interface SupportTeamMember {
+    id: string;
+    teamId: string;
+    userId: number;
+    /** Resolved for display. */
+    userName?: string | null;
+    role: SupportTeamMemberRole;
+    /** An agent who is off rota keeps their membership and stops being assigned work. */
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/** The targets one SLA policy sets for one priority. */
+export interface SupportSlaPolicyTarget {
+    priority: SupportTicketPriority;
+    firstResponseMinutes: number;
+    resolutionMinutes: number;
+    clock: SupportSlaClock;
+}
+/**
+ * A set of SLA targets, applied at organization or queue level.
+ *
+ * Resolution order is queue policy, then organization policy, then the platform
+ * defaults. A policy that omits a priority falls through for that priority
+ * alone rather than for the whole ticket, so an organization can tighten
+ * CRITICAL without restating the other four rows.
+ */
+export interface SupportSlaPolicy {
+    id: string;
+    /** Null for the platform-wide policy a super-admin maintains. */
+    organizationId?: number | null;
+    name: string;
+    description?: string | null;
+    targets: SupportSlaPolicyTarget[];
+    /** Working calendar used by BUSINESS-clock targets. Null means the platform default. */
+    businessCalendar?: SupportBusinessCalendar | null;
+    /** Only one policy per organization may be the default. */
+    isDefault: boolean;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * A working calendar.
+ *
+ * Deliberately simple - weekdays, a window, a timezone and a holiday list -
+ * because the shape has to be editable by an administrator rather than a
+ * developer. Anything richer belongs in a calendar service that does not exist
+ * yet, and this model can be replaced by one without touching the ticket
+ * domain.
+ */
+export interface SupportBusinessCalendar {
+    /** ISO weekday numbers, Monday = 1. */
+    workingDays: number[];
+    /** Minutes past local midnight when the day opens. */
+    startMinuteOfDay: number;
+    /** Minutes past local midnight when it closes. */
+    endMinuteOfDay: number;
+    /** IANA zone, e.g. Africa/Nairobi. Resolved from the ticket's country when absent. */
+    timezone?: string | null;
+    /** Non-working dates as YYYY-MM-DD. */
+    holidays: string[];
+}
+/**
+ * One deterministic routing rule.
+ *
+ * Rules are evaluated in ascending `priority` and the FIRST match wins. There is
+ * no scoring and no machine learning: an operator has to be able to answer "why
+ * did this ticket land here?" by reading the table, and a routing decision they
+ * cannot explain is one they cannot fix at 2am.
+ */
+export interface SupportRoutingRule {
+    id: string;
+    organizationId: number;
+    name: string;
+    matchType: SupportRoutingMatchType;
+    /** The value matched, interpreted per `matchType`. Null for ANY. */
+    matchValue?: string | null;
+    matchCategoryId?: string | null;
+    matchPriority?: SupportTicketPriority | null;
+    matchChannel?: SupportTicketChannel | null;
+    matchCountryCode?: CountryCode | null;
+    matchControlCentreId?: number | null;
+    matchAppId?: IncidentAppId | null;
+    matchRelatedEntityType?: SupportRelatedEntityType | null;
+    /** Where a matching ticket goes. */
+    targetQueueId: string;
+    /** Optionally forces a priority, e.g. anything about an incident is at least HIGH. */
+    forcePriority?: SupportTicketPriority | null;
+    /** Lower runs first. */
+    priority: number;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+}