grm-shared-library 1.1.201 → 1.1.203

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

@@ -0,0 +1,180 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { IncidentAppId } from '../../incident/enums/incident-app-id.enum';
+import { SupportProviderCode } from '../enums/support-provider-code.enum';
+import { SupportRelatedEntityType } from '../enums/support-related-entity-type.enum';
+import { SupportSlaState, SupportSlaTarget } from '../enums/support-sla.enum';
+import { SupportTicketChannel, SupportTicketSource } from '../enums/support-ticket-channel.enum';
+import { SupportTicketPriority } from '../enums/support-ticket-priority.enum';
+import { SupportTicketStatus } from '../enums/support-ticket-status.enum';
+/**
+ * A pointer to a record owned by another Clarion service.
+ *
+ * Type plus id, never a copy. `label` is a display string resolved at read time
+ * when the reader is allowed to see it, and is absent otherwise - so a ticket
+ * list never leaks the subject of an incident to somebody who could not open
+ * that incident directly.
+ */
+export interface SupportRelatedEntityRef {
+    type: SupportRelatedEntityType;
+    /** Text because the owning services disagree on integer versus uuid. */
+    id: string;
+    /** Resolved for display; absent when it could not be resolved or may not be shown. */
+    label?: string | null;
+}
+/** Where one SLA clock stands, as shown on a ticket. */
+export interface SupportSlaClockSnapshot {
+    target: SupportSlaTarget;
+    state: SupportSlaState;
+    /** When the target elapses. Null when no policy applies. */
+    dueAt?: string | null;
+    /** When it was actually met. Null while outstanding. */
+    metAt?: string | null;
+    /**
+     * Minutes left, negative once breached. Computed at read time from `dueAt`,
+     * so a client that caches a ticket does not have to recompute a deadline
+     * itself and get the paused case wrong.
+     */
+    remainingMinutes?: number | null;
+    /** Total minutes the clock has spent paused, so an agent can see why a deadline moved. */
+    pausedMinutes: number;
+}
+/**
+ * A support ticket as the API returns it.
+ *
+ * Clarion is authoritative for identity, tenancy and the local conversation
+ * record; a configured helpdesk is authoritative for agent workflow. The
+ * `external*` fields are the join between the two and are the only place a
+ * vendor's identifiers appear in a client-facing contract - never its payloads,
+ * never its URLs, never its credentials.
+ */
+export interface SupportTicket {
+    /** Internal identifier. A uuid, so a ticket id is never guessable. */
+    id: string;
+    /** Human-readable and safe to quote: SUP-KE-2026-000123. */
+    ticketNumber: string;
+    organizationId: number;
+    controlCentreId?: number | null;
+    countryCode: CountryCode;
+    /** The client application the ticket came from, when it came from one. */
+    appId?: IncidentAppId | null;
+    /** Who raised it. An agent raising a ticket for a customer is not the customer. */
+    createdByUserId: number;
+    /** Whose ticket it is. The only user a customer-facing read path will match on. */
+    customerUserId: number;
+    assignedAgentId?: number | null;
+    assignedTeamId?: string | null;
+    queueId?: string | null;
+    categoryId?: string | null;
+    subject: string;
+    description: string;
+    status: SupportTicketStatus;
+    priority: SupportTicketPriority;
+    channel: SupportTicketChannel;
+    source: SupportTicketSource;
+    /** Free-text labels. Lower-cased and de-duplicated on write. */
+    tags: string[];
+    firstResponseDueAt?: string | null;
+    resolutionDueAt?: string | null;
+    firstRespondedAt?: string | null;
+    resolvedAt?: string | null;
+    closedAt?: string | null;
+    reopenedAt?: string | null;
+    firstResponseSlaState: SupportSlaState;
+    resolutionSlaState: SupportSlaState;
+    /** The policy in force. Null when none matched. */
+    slaPolicyId?: string | null;
+    lastCustomerMessageAt?: string | null;
+    lastAgentMessageAt?: string | null;
+    /** Count of customer-visible messages, so a list can show unread-ish state cheaply. */
+    messageCount: number;
+    /** How many times it has come back from CLOSED. */
+    reopenCount: number;
+    /** Which helpdesk holds the mirror, if any. */
+    externalProvider?: SupportProviderCode | null;
+    /** The helpdesk's own id. Opaque here - only its adapter knows the shape. */
+    externalTicketId?: string | null;
+    /** The helpdesk's human-readable number, when it publishes one. */
+    externalTicketNumber?: string | null;
+    /** Whether the mirror is currently in step. Derived from outstanding sync rows. */
+    externalSyncPending: boolean;
+    /** Set when at least one synchronization row for this ticket is dead-lettered. */
+    externalSyncFailed: boolean;
+    externalLastSyncedAt?: string | null;
+    /** What the ticket is about, when it is about something. */
+    relatedEntities: SupportRelatedEntityRef[];
+    /** Set only when the ticket was promoted from feedback. */
+    sourceFeedbackId?: string | null;
+    /** Non-sensitive diagnostic context captured at creation. Never credentials. */
+    metadata?: Record<string, unknown> | null;
+    /** Optimistic concurrency. A stale update is rejected rather than silently applied. */
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * The shape a list returns.
+ *
+ * A deliberate subset: `description`, `metadata` and the related entities are
+ * left out so a five-hundred-row page does not carry half a megabyte of prose,
+ * and so a queue view cannot become a way to bulk-read ticket bodies.
+ */
+export interface SupportTicketSummary {
+    id: string;
+    ticketNumber: string;
+    organizationId: number;
+    controlCentreId?: number | null;
+    countryCode: CountryCode;
+    customerUserId: number;
+    /** Resolved for display in the admin. Absent on customer-facing lists. */
+    customerName?: string | null;
+    assignedAgentId?: number | null;
+    assignedAgentName?: string | null;
+    queueId?: string | null;
+    queueName?: string | null;
+    categoryId?: string | null;
+    categoryName?: string | null;
+    subject: string;
+    status: SupportTicketStatus;
+    priority: SupportTicketPriority;
+    channel: SupportTicketChannel;
+    firstResponseSlaState: SupportSlaState;
+    resolutionSlaState: SupportSlaState;
+    firstResponseDueAt?: string | null;
+    resolutionDueAt?: string | null;
+    lastCustomerMessageAt?: string | null;
+    lastAgentMessageAt?: string | null;
+    messageCount: number;
+    externalProvider?: SupportProviderCode | null;
+    externalSyncPending: boolean;
+    externalSyncFailed: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/** One recorded status change, as shown on the ticket timeline. */
+export interface SupportTicketStatusHistoryEntry {
+    id: string;
+    ticketId: string;
+    fromStatus?: SupportTicketStatus | null;
+    toStatus: SupportTicketStatus;
+    changedByUserId?: number | null;
+    changedByName?: string | null;
+    /** True when the change arrived from the helpdesk rather than from Clarion. */
+    fromProvider: boolean;
+    reason?: string | null;
+    createdAt: string;
+}
+/** One recorded assignment change. */
+export interface SupportTicketAssignmentHistoryEntry {
+    id: string;
+    ticketId: string;
+    fromAgentId?: number | null;
+    toAgentId?: number | null;
+    fromTeamId?: string | null;
+    toTeamId?: string | null;
+    fromQueueId?: string | null;
+    toQueueId?: string | null;
+    changedByUserId?: number | null;
+    changedByName?: string | null;
+    reason?: string | null;
+    createdAt: string;
+}

package/dist/types/modules/support/utils/support-feedback.util.d.ts

@@ -0,0 +1,23 @@
+import { CustomerFeedbackSentiment, CustomerFeedbackType } from '../enums/support-feedback.enum';
+/** Whether this kind of feedback carries a star rating. */
+export declare function feedbackTypeRequiresRating(type: CustomerFeedbackType): boolean;
+/**
+ * Derive sentiment from the feedback TYPE and rating.
+ *
+ * Never from the message text. An automated reading of "the guard never came"
+ * that lands on POSITIVE is worse than no reading at all, and a support desk
+ * that starts distrusting one column stops trusting the dashboard. When a real
+ * classifier is added it writes this same field, and the rule below becomes its
+ * fallback rather than being replaced.
+ */
+export declare function deriveFeedbackSentiment(type: CustomerFeedbackType, rating?: number | null): CustomerFeedbackSentiment;
+/** Whether a rating is inside the allowed range. */
+export declare function isValidFeedbackRating(rating: unknown): boolean;
+/**
+ * Whether a piece of feedback is the kind an agent should probably act on.
+ *
+ * Advisory only - it drives a hint in the admin, never an automatic conversion.
+ * Promoting somebody's complaint into a ticket without a human deciding is how a
+ * queue fills with work nobody chose to take on.
+ */
+export declare function feedbackWarrantsTicket(type: CustomerFeedbackType, rating?: number | null): boolean;

package/dist/types/modules/support/utils/support-redaction.util.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Mask an identifier for logging: enough to correlate, never enough to reuse.
+ * `+254712345678` becomes `+254***5678`.
+ */
+export declare function maskSupportIdentifier(value: string | null | undefined): string;
+/**
+ * Reduce a URL to scheme and host.
+ *
+ * A helpdesk URL routinely carries an API token in its query string, and a URL
+ * is the single most-logged value in an HTTP client.
+ */
+export declare function maskSupportUrl(value: string | null | undefined): string;
+/**
+ * Replace anything credential- or PII-shaped in free text.
+ *
+ * Applied to every provider message before it is stored or logged. It is a
+ * belt-and-braces pass on top of key-based redaction: a helpdesk that puts a
+ * token in a prose error defeats key matching, and that message still ends up
+ * in a table an operator can read.
+ */
+export declare function scrubSupportText(input: string | null | undefined): string;
+/**
+ * Redact a payload by key before it is persisted on a synchronization row or an
+ * audit entry.
+ *
+ * Depth-bounded, because a provider can return an arbitrarily nested object and
+ * an audit writer must not be a place a stack overflow can happen. Anything
+ * past the bound is replaced with a marker rather than dropped silently.
+ */
+export declare function sanitizeSupportPayload(value: unknown, depth?: number): unknown;
+/**
+ * Trim a value to a limit without ever throwing.
+ *
+ * A support message that runs long is truncated and still sent. Refusing to
+ * record what a customer said because it exceeded a column width would lose the
+ * thing the whole domain exists to capture.
+ */
+export declare function truncateForSupport(value: string | null | undefined, maxLength: number): string | undefined;
+/**
+ * A one-line preview of a longer body, for list rows.
+ *
+ * Newlines collapse to spaces so a multi-line message cannot break a table row,
+ * and the result is ellipsised rather than hard-cut so a reader can tell there
+ * is more.
+ */
+export declare function previewSupportText(value: string | null | undefined, maxLength?: number): string;
+/** A provider response body reduced to something safe and small enough to keep. */
+export declare function snapshotSupportPayload(body: unknown): Record<string, unknown> | null;

package/dist/types/modules/support/utils/support-routing.util.d.ts

@@ -0,0 +1,50 @@
+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 { SupportTicketChannel } from '../enums/support-ticket-channel.enum';
+import { SupportTicketPriority } from '../enums/support-ticket-priority.enum';
+import { SupportRoutingRule } from '../interfaces/support-configuration';
+/** The facts a routing decision is made from. */
+export interface SupportRoutingSubject {
+    organizationId: number;
+    controlCentreId?: number | null;
+    countryCode: CountryCode;
+    categoryId?: string | null;
+    priority: SupportTicketPriority;
+    channel: SupportTicketChannel;
+    appId?: IncidentAppId | null;
+    relatedEntityTypes: SupportRelatedEntityType[];
+}
+/** What a routing decision produced, and why. */
+export interface SupportRoutingDecision {
+    queueId: string | null;
+    /** The rule that matched, so an operator can be shown why. */
+    ruleId: string | null;
+    ruleName: string | null;
+    /** A priority the rule forced, when it forced one. */
+    forcedPriority?: SupportTicketPriority | null;
+}
+/** Whether one rule matches one ticket. */
+export declare function supportRoutingRuleMatches(rule: SupportRoutingRule, subject: SupportRoutingSubject): boolean;
+/**
+ * Pick a queue.
+ *
+ * Rules are sorted by ascending `priority` and the FIRST match wins. No
+ * scoring, no weighting, no learning: an operator has to be able to answer "why
+ * did this land here?" by reading the table, and a routing decision nobody can
+ * explain is one nobody can fix at 2am.
+ *
+ * Ties on `priority` are broken by rule id, so the same inputs always produce
+ * the same answer - a routing engine whose output depends on row order is a
+ * routing engine that cannot be tested.
+ */
+export declare function decideSupportQueue(rules: SupportRoutingRule[], subject: SupportRoutingSubject, fallbackQueueId?: string | null): SupportRoutingDecision;
+/**
+ * The priority a new ticket should start at.
+ *
+ * A rule may raise a priority and never lower one. A customer who says their
+ * panic button is broken has told us something a routing table cannot know
+ * better than they do, and quietly downgrading them is the failure mode this
+ * rule exists to prevent.
+ */
+export declare function applyForcedPriority(requested: SupportTicketPriority, forced: SupportTicketPriority | null | undefined, rank: Readonly<Record<SupportTicketPriority, number>>): SupportTicketPriority;

package/dist/types/modules/support/utils/support-sla.util.d.ts

@@ -0,0 +1,69 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { SupportSlaTargetDefaults } from '../constants/support-defaults.const';
+import { SupportSlaClock, SupportSlaState } from '../enums/support-sla.enum';
+import { SupportTicketPriority } from '../enums/support-ticket-priority.enum';
+import { SupportBusinessCalendar, SupportSlaPolicy } from '../interfaces/support-configuration';
+/**
+ * The timezone a country's working hours are measured in.
+ *
+ * Read from the country configuration rather than from the server clock. Every
+ * supported country happens to sit at UTC+3 today; writing it this way is what
+ * stops that being an assumption baked into a deadline.
+ */
+export declare function timezoneForCountry(countryCode: CountryCode | null | undefined): string;
+/**
+ * A calendar with every field settled.
+ *
+ * Distinct from {@link SupportBusinessCalendar} because the stored shape allows
+ * a null timezone (meaning "take it from the country") and the arithmetic below
+ * cannot. Resolving once, here, is what keeps every caller from having to guess
+ * a fallback zone of its own.
+ */
+export interface ResolvedSupportBusinessCalendar {
+    workingDays: number[];
+    startMinuteOfDay: number;
+    endMinuteOfDay: number;
+    timezone: string;
+    holidays: string[];
+}
+/** The calendar in force, falling back to the platform default. */
+export declare function resolveBusinessCalendar(calendar: SupportBusinessCalendar | null | undefined, countryCode: CountryCode | null | undefined): ResolvedSupportBusinessCalendar;
+/**
+ * Add working minutes to an instant.
+ *
+ * Walks day by day rather than doing arithmetic on a whole-week average,
+ * because holidays and a partial first day make the average wrong exactly when
+ * it matters - the ticket raised at 16:55 on the day before a public holiday.
+ *
+ * A calendar with no working days, or a zero-length window, degrades to
+ * calendar time rather than looping: a misconfigured calendar must not be able
+ * to hang the request that creates a ticket.
+ */
+export declare function addBusinessMinutes(start: Date, minutes: number, calendar: ResolvedSupportBusinessCalendar): Date;
+/** Working minutes between two instants. Used to account for paused time. */
+export declare function businessMinutesBetween(from: Date, to: Date, calendar: ResolvedSupportBusinessCalendar): number;
+/** The targets in force for a priority: queue policy, then organization policy, then defaults. */
+export declare function resolveSlaTargets(priority: SupportTicketPriority, policies: (SupportSlaPolicy | null | undefined)[]): SupportSlaTargetDefaults;
+/** When a target elapses, measured on the right clock. */
+export declare function computeSlaDueAt(start: Date, minutes: number, clock: SupportSlaClock, calendar: ResolvedSupportBusinessCalendar): Date;
+/**
+ * Where a clock stands right now.
+ *
+ * Pure, and takes `now` as an argument rather than reading the clock, so the
+ * scheduler and the read path can never disagree about what time it is and so
+ * the whole thing is testable without freezing time.
+ */
+export declare function evaluateSlaState(input: {
+    now: Date;
+    dueAt?: Date | null;
+    metAt?: Date | null;
+    /** True while the ticket is waiting on the customer. */
+    paused: boolean;
+    /** True once the clocks have stopped for good without being met. */
+    stopped: boolean;
+    /** Total minutes the target allows, used to place the warning threshold. */
+    targetMinutes?: number | null;
+    warningRatio?: number;
+}): SupportSlaState;
+/** Minutes left before a deadline; negative once it has passed. */
+export declare function minutesUntil(now: Date, dueAt: Date | null | undefined): number | null;

package/dist/types/modules/support/utils/support-status.util.d.ts

@@ -0,0 +1,44 @@
+import { CustomerFeedbackStatus } from '../enums/support-feedback.enum';
+import { SupportTicketStatus } from '../enums/support-ticket-status.enum';
+/**
+ * Whether a ticket may move from one state to another.
+ *
+ * The single authority. Controllers, services, webhook handlers and the
+ * reconciliation job all ask this rather than each carrying their own idea of
+ * what is legal - which is what stops a provider webhook quietly doing
+ * something no Clarion user could do.
+ *
+ * A move to the SAME state is allowed and is a no-op, because a provider that
+ * re-sends its current status should not be an error.
+ */
+export declare function canTransitionSupportTicket(from: SupportTicketStatus, to: SupportTicketStatus): boolean;
+/** The states a ticket may legally move to right now. Drives the admin's buttons. */
+export declare function allowedSupportTicketTransitions(from: SupportTicketStatus): readonly SupportTicketStatus[];
+export declare function isTerminalSupportTicketStatus(status: SupportTicketStatus): boolean;
+export declare function isActiveSupportTicketStatus(status: SupportTicketStatus): boolean;
+/** True while an SLA clock should be stopped but may still resume. */
+export declare function isSlaPausedStatus(status: SupportTicketStatus): boolean;
+/** True once the clocks stop for good. */
+export declare function isSlaStoppedStatus(status: SupportTicketStatus): boolean;
+/**
+ * Whether a customer may reply on a ticket in this state.
+ *
+ * A CANCELLED ticket is closed to further conversation; everything else, CLOSED
+ * included, accepts a reply - and a reply to a closed ticket reopens it, which
+ * is what a customer expects and what stops them raising a duplicate.
+ */
+export declare function customerMayReply(status: SupportTicketStatus): boolean;
+/**
+ * The state a customer reply should move a ticket into, or null to leave it.
+ *
+ * CLOSED becomes REOPENED, which is counted. RESOLVED goes back to IN_PROGRESS,
+ * which is not - the ticket was never finished from the customer's point of
+ * view, and calling that a reopen would inflate the reopen rate with tickets
+ * that simply were not fixed yet. WAITING_ON_CUSTOMER becomes IN_PROGRESS,
+ * because the wait is over.
+ */
+export declare function statusAfterCustomerReply(status: SupportTicketStatus): SupportTicketStatus | null;
+/** Whether a piece of feedback may move from one state to another. */
+export declare function canTransitionCustomerFeedback(from: CustomerFeedbackStatus, to: CustomerFeedbackStatus): boolean;
+/** The states a piece of feedback may legally move to right now. */
+export declare function allowedCustomerFeedbackTransitions(from: CustomerFeedbackStatus): readonly CustomerFeedbackStatus[];

package/dist/types/modules/support/utils/support-sync.util.d.ts

@@ -0,0 +1,76 @@
+import { SupportSyncFailureReason } from '../enums/support-sync.enum';
+/**
+ * Translate a helpdesk HTTP status into the shared failure taxonomy.
+ *
+ * The single place the retry policy is decided, because "should we call the
+ * helpdesk again?" must not be answered differently by the Zammad adapter and
+ * the Freshdesk one. Anything unrecognised is TRANSIENT: a support message that
+ * arrives late is recoverable, one dropped because an unfamiliar status looked
+ * fatal is not.
+ *
+ * The one place that reasoning inverts is a 2xx nobody could parse. The
+ * provider accepted the request, so re-sending would create a second ticket or
+ * show the customer the same reply twice - see UNREADABLE_SUCCESS, which the
+ * adapter raises directly rather than through this function.
+ */
+export declare function classifySupportHttpStatus(status: number | undefined): SupportSyncFailureReason;
+/**
+ * Whether a failure can ever succeed on a retry.
+ *
+ * AUTHENTICATION_FAILED is deliberately NOT permanent: a rotated credential
+ * that has not propagated to every pod yet fails this way, and refusing to try
+ * again would strand every queued reply until somebody noticed. It is capped by
+ * `maxAttempts` like anything else.
+ */
+export declare function isPermanentSupportSyncFailure(reason: SupportSyncFailureReason): boolean;
+/**
+ * When to try again, with exponential backoff and jitter.
+ *
+ * The jitter matters more than it looks: when a helpdesk comes back after an
+ * outage, every queued row is due at once, and a synchronized stampede is how a
+ * recovering server is knocked over a second time.
+ *
+ * `randomFraction` is injected rather than read from Math.random so the
+ * function stays pure and its tests stay deterministic.
+ */
+export declare function computeSupportRetryDelaySeconds(attempts: number, options?: {
+    baseSeconds?: number;
+    maxSeconds?: number;
+    jitterRatio?: number;
+    /** A value in [0,1). Defaults to no jitter. */
+    randomFraction?: number;
+    /** Honour a provider's Retry-After, when it sends one. */
+    retryAfterSeconds?: number | null;
+}): number;
+/** The instant of the next attempt. */
+export declare function computeSupportNextAttemptAt(now: Date, attempts: number, options?: Parameters<typeof computeSupportRetryDelaySeconds>[1]): Date;
+/**
+ * A stable fingerprint of an outbound payload.
+ *
+ * Deliberately not cryptographic. It exists to answer "is this the same request
+ * we already sent?" and to let a reconciliation job tell "never sent" from
+ * "sent and did not take" - neither of which is a security decision. Using a
+ * real digest here would pull a Node-only dependency into a package the
+ * frontend build also consumes.
+ */
+export declare function fingerprintSupportPayload(payload: unknown): string;
+/** State of the per-provider circuit breaker, kept small enough to live in Redis. */
+export interface SupportCircuitState {
+    consecutiveFailures: number;
+    /** ISO instant the breaker may next allow a probe. Null when closed. */
+    openUntil?: string | null;
+}
+/**
+ * Whether an outbound call may proceed.
+ *
+ * The breaker protects the helpdesk and this service's own worker from
+ * hammering a dead endpoint; it never causes data loss, because a call refused
+ * by an open breaker leaves its row PENDING with a CIRCUIT_OPEN reason and is
+ * retried when the breaker closes.
+ */
+export declare function isSupportCircuitOpen(state: SupportCircuitState | null | undefined, now: Date): boolean;
+/** The breaker state after one outcome. */
+export declare function nextSupportCircuitState(state: SupportCircuitState | null | undefined, outcome: 'success' | 'failure', now: Date, options?: {
+    failureThreshold?: number;
+    openSeconds?: number;
+}): SupportCircuitState;

package/dist/types/modules/support/utils/support-ticket-number.util.d.ts

@@ -0,0 +1,39 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+/** The parts of a ticket number, once parsed. */
+export interface ParsedSupportTicketNumber {
+    prefix: string;
+    countryCode: CountryCode;
+    year: number;
+    sequence: number;
+}
+/**
+ * Render a ticket number: SUP-KE-2026-000123.
+ *
+ * Human-readable and safe to read out over the phone, which is the whole point
+ * of it existing alongside the uuid primary key. It is never the primary key:
+ * it embeds a country and a year, and anything that embeds business meaning
+ * will eventually need changing.
+ *
+ * The sequence is allocated per (country, year) by the database, so this
+ * function only formats - it never decides what the next number is.
+ */
+export declare function formatSupportTicketNumber(countryCode: CountryCode, year: number, sequence: number): string;
+/**
+ * Read a ticket number back, for search.
+ *
+ * Returns null rather than throwing on anything unrecognised: this runs on a
+ * search box, where the input is whatever somebody pasted, and a 500 from a bad
+ * paste is a worse answer than no results.
+ *
+ * A sequence longer than the configured width still parses - the width is a
+ * display minimum, and refusing to find ticket 1,000,000 because it has seven
+ * digits would be a bug that only appears once it is too late.
+ */
+export declare function parseSupportTicketNumber(value: string | null | undefined): ParsedSupportTicketNumber | null;
+/**
+ * Whether a search term looks like somebody typing a ticket number.
+ *
+ * Used to route a search straight at the ticket-number index instead of running
+ * a full-text scan for a string that can only ever match one row.
+ */
+export declare function looksLikeSupportTicketNumber(value: string | null | undefined): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grm-shared-library",
-  "version": "1.1.201",
+  "version": "1.1.203",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",