nexus-shared 2.0.0 → 3.0.0

package/dist/Helpers/TableColumns.d.ts

@@ -1,3 +1,10 @@
+/**
+ * The cells of the header a column stands in, from left to right. The header is one row, or — when any column names a
+ * group — a band of group headings over a row holding the headings of the grouped columns only, where a column with no
+ * group keeps its heading in the band row across both (`rowSpan`). A band says how many headings it covers with its
+ * `colSpan`, so the two rows read back as one list: the table measures the columns from it, and a drag drops among them.
+ */
+export declare function headLeafCells(head: HTMLTableSectionElement | null | undefined): HTMLElement[];
 export interface ColumnDragOptions {
     /** The heading pressed. */
     heading: HTMLElement;

package/dist/Helpers/TableColumns.js

@@ -9,18 +9,46 @@ const DRAG_THRESHOLD = 4;
 /** Pixels from the edge of the scroller where a drag scrolls the columns. */
 const EDGE = 52;
 const KEY = "data-col";
+const GROUP = "data-group";
 const DROP_BEFORE = "data-drop-before";
 const DROP_AFTER = "data-drop-after";
-/** The headings a dragged one can be dropped between: the movable ones pinned to the same side. */
-function dropTargets(heading) {
-    const row = heading.parentElement;
-    if (!row)
+/**
+ * The cells of the header a column stands in, from left to right. The header is one row, or — when any column names a
+ * group — a band of group headings over a row holding the headings of the grouped columns only, where a column with no
+ * group keeps its heading in the band row across both (`rowSpan`). A band says how many headings it covers with its
+ * `colSpan`, so the two rows read back as one list: the table measures the columns from it, and a drag drops among them.
+ */
+export function headLeafCells(head) {
+    const band = head?.rows[0];
+    if (!band)
         return [];
+    const top = [...band.cells];
+    const leaves = head?.rows[1];
+    if (!leaves)
+        return top;
+    const under = [...leaves.cells];
+    const cells = [];
+    let at = 0;
+    for (const cell of top) {
+        if (!cell.hasAttribute(GROUP))
+            cells.push(cell);
+        else
+            for (let covered = 0; covered < cell.colSpan; covered++)
+                if (under[at])
+                    cells.push(under[at++]);
+    }
+    return cells;
+}
+/**
+ * The headings a dragged one can be dropped between: the ones pinned to the same side, in the order they are drawn.
+ * They are taken from the whole header, so a column under a band and one beside it are the same list.
+ */
+function dropTargets(head, heading) {
     const pin = heading.getAttribute("data-pin") ?? "";
-    return [...row.children].filter((cell) => cell instanceof HTMLElement && cell.hasAttribute(KEY) && (cell.getAttribute("data-pin") ?? "") === pin);
+    return headLeafCells(head).filter(cell => cell.hasAttribute(KEY) && (cell.getAttribute("data-pin") ?? "") === pin);
 }
-function clearDropMarks(row) {
-    for (const cell of row?.children ?? []) {
+function clearDropMarks(head) {
+    for (const cell of head?.querySelectorAll(`[${DROP_BEFORE}], [${DROP_AFTER}]`) ?? []) {
         cell.removeAttribute(DROP_BEFORE);
         cell.removeAttribute(DROP_AFTER);
     }
@@ -31,8 +59,8 @@ function clearDropMarks(row) {
  */
 export function startColumnDrag(event, { heading, scroller, root, onDrop }) {
     const key = heading.getAttribute(KEY) ?? "";
-    const row = heading.parentElement;
-    if (!key || !row)
+    const head = heading.closest("thead");
+    if (!key || !head)
         return () => undefined;
     const pointerId = event.pointerId;
     const startX = event.clientX;
@@ -42,8 +70,8 @@ export function startColumnDrag(event, { heading, scroller, root, onDrop }) {
     let scrollBy = 0;
     let frame = 0;
     function place(x) {
-        const targets = dropTargets(heading);
-        clearDropMarks(row);
+        const targets = dropTargets(head, heading);
+        clearDropMarks(head);
         target = null;
         for (let index = 0; index < targets.length; index++) {
             const cell = targets[index];
@@ -63,7 +91,7 @@ export function startColumnDrag(event, { heading, scroller, root, onDrop }) {
             }
             // A drop where the column already sits changes nothing, so no line shows there.
             if (target.before === key || cellKey === key) {
-                clearDropMarks(row);
+                clearDropMarks(head);
                 target = null;
             }
             return;
@@ -144,7 +172,7 @@ export function startColumnDrag(event, { heading, scroller, root, onDrop }) {
             cancelAnimationFrame(frame);
         if (!dragging)
             return;
-        clearDropMarks(row);
+        clearDropMarks(head);
         heading.removeAttribute("data-dragging");
         root?.removeAttribute("data-col-drag");
         if (heading.hasPointerCapture?.(pointerId))

package/dist/Helpers/TableHelpers.d.ts

@@ -1,5 +1,5 @@
 import type { DatePreferences } from "../Interfaces/DateInterfaces.ts";
-import type { TableColumn, TableColumnOption, TableKey, TablePage, TablePinSide, TableQuery, TableRow, TableSort, TableViewColumn } from "../Interfaces/TableInterfaces.ts";
+import type { TableColumn, TableColumnOption, TableHeadBand, TableKey, TablePage, TablePinSide, TableQuery, TableRow, TableSort, TableViewColumn } from "../Interfaces/TableInterfaces.ts";
 /** Rows per page when nothing says otherwise. */
 export declare const DEFAULT_PAGE_SIZE = 10;
 /** Choices of rows per page. */
@@ -100,3 +100,11 @@ export interface ViewColumnsOptions extends ColumnRights {
 export declare function viewColumns<TRow extends TableRow>(columns: readonly TableColumn<TRow>[], options?: ViewColumnsOptions): TableViewColumn<TRow>[];
 /** Whether the user may pin this column to a side. */
 export declare function canPinColumn(column: Pick<TableColumn, "pinnable">, rights: ColumnRights): boolean;
+/**
+ * The columns cut into bands: each run of columns next to each other that name the same group, and one band of its own
+ * for every column that names none. The runs come from the order on screen, so a column moved out of its run keeps its
+ * group's heading where it landed and the run it left draws that heading again.
+ *
+ * A run also ends where the pinned side changes: a heading cannot stay on the left and on the right at once.
+ */
+export declare function headBands<TRow extends TableRow>(columns: readonly TableViewColumn<TRow>[]): TableHeadBand<TRow>[];

package/dist/Helpers/TableHelpers.js

@@ -279,3 +279,23 @@ export function viewColumns(columns, options = {}) {
 export function canPinColumn(column, rights) {
     return (rights.pinnable ?? true) && column.pinnable !== false;
 }
+/* The bands above the headings: a group's heading over the columns next to each other that name it */
+/**
+ * The columns cut into bands: each run of columns next to each other that name the same group, and one band of its own
+ * for every column that names none. The runs come from the order on screen, so a column moved out of its run keeps its
+ * group's heading where it landed and the run it left draws that heading again.
+ *
+ * A run also ends where the pinned side changes: a heading cannot stay on the left and on the right at once.
+ */
+export function headBands(columns) {
+    const bands = [];
+    for (const view of columns) {
+        const group = view.column.group?.trim() || null;
+        const last = bands[bands.length - 1];
+        if (group && last && last.group === group && last.columns[0].pin === view.pin)
+            last.columns.push(view);
+        else
+            bands.push({ group, columns: [view] });
+    }
+    return bands;
+}

package/dist/Interfaces/ApiInterfaces.d.ts

@@ -4,6 +4,11 @@ export type ApiModuleValue = string | number;
 /**
  * The Nexus backend modules, the modules of `NexusApiModules`. The values are the backend's `EModules` flags, so they
  * can be combined and compared with permissions. Another backend has an enum of its own and its own `ApiModules` class.
+ *
+ * **These numbers are the backend's, not this package's.** A permission is a bitmask of them, so a value that differs
+ * from the backend by one bit does not fail loudly: it silently grants or denies the wrong module. `Chat` was added
+ * at bit 6 in the backend on 2026-09-25 and every module after it moved up one bit; this list moved with it, which
+ * changed the value of `Accounting` through `Portfolio`. See CHANGELOG.md.
  */
 export declare const NexusModule: {
     /** The app's own API routes (`/api/...`), not a backend module. */
@@ -14,6 +19,7 @@ export declare const NexusModule: {
     readonly Enterprise: number;
     readonly Drive: number;
     readonly Message: number;
+    readonly Chat: number;
     readonly Accounting: number;
     readonly Report: number;
     readonly Requisition: number;
@@ -79,6 +85,20 @@ export interface ApiEndpoint<TModule extends ApiModuleValue = AppModule> {
 }
 /** Where a call goes: an endpoint, or a URL ("/api/demo-rooms", "https://…"). */
 export type ApiTarget = ApiEndpoint | string;
+/**
+ * One problem in a failed answer, as the backend explains it: plain words for the user, the codes behind them, and the
+ * input it is about. A backend answers every wrong field at once, so a failure can carry several.
+ */
+export interface ApiErrorMessage {
+    /** What the user is shown: the server's own sentence ("This Region name already exists."). */
+    message: string;
+    /** The code of that exact refusal ("RGN_X009"), for the log and for a page to react to. Never shown to the user. */
+    messageCode?: string;
+    /** The kind of problem as a number (Nexus `errorCode`). Never shown to the user. */
+    errorCode?: number;
+    /** The input the message is about, as the server names it ("regionName"); several named with "|". */
+    inputName?: string;
+}
 /** A server's answer, read as success or failure. Every call answers with one; it never throws for a failed request. */
 export interface ApiResult<T = unknown> {
     ok: boolean;
@@ -86,12 +106,14 @@ export interface ApiResult<T = unknown> {
     status?: number;
     /** What the server sent back: the record, the list, the saved id. */
     result?: T;
-    /** The server's message, or one built for the failure. */
+    /** The server's own message (its problems joined, in its order), or one built for the failure by status. */
     message?: string;
-    /** The server's code for its message, such as "ROOM_TAKEN" (Nexus `messageCode`). */
+    /** The first problem's code for its message, such as "RGN_X009" (Nexus `messageCode`). Never shown as the sentence. */
     messageCode?: string;
-    /** The server's error number (Nexus `errorCode`, such as 2003 for an expired token). */
+    /** The first problem's error number (Nexus `errorCode`). Never shown as the sentence. */
     errorCode?: number;
+    /** Every problem the server explained, in its order. A failure it explained carries at least one. */
+    errorMessages?: ApiErrorMessage[];
     /** Messages by field name, as the server names them ("Email", "addresses[1].city"); matched to inputs without case. */
     errors?: Record<string, string>;
     /** Nothing reached the server: offline, or the server is down. */
@@ -136,7 +158,10 @@ export interface ApiCallOptions {
     /** Tries again after a network failure or a 502, 503, or 504. Default 1 for GET, 0 for the rest (a save must not run twice). */
     retries?: number;
     credentials?: RequestCredentials;
-    /** Reads the answer. Default `readApiResponse`: Nexus answers, ASP.NET Core problem details, any JSON by its status. */
+    /**
+     * Reads the answer. Default: the app's reader (`configureApi({ read })` / `configureServerApi({ read })`), else
+     * `readApiResponse`: Nexus answers, ASP.NET Core problem details, any JSON by its status.
+     */
     read?: (body: unknown, status: number | undefined) => ApiResult;
     /** What the call does, for its messages. Default: the endpoint's, or by method. */
     action?: MessageAction;

package/dist/Interfaces/ApiInterfaces.js

@@ -1,6 +1,11 @@
 /**
  * The Nexus backend modules, the modules of `NexusApiModules`. The values are the backend's `EModules` flags, so they
  * can be combined and compared with permissions. Another backend has an enum of its own and its own `ApiModules` class.
+ *
+ * **These numbers are the backend's, not this package's.** A permission is a bitmask of them, so a value that differs
+ * from the backend by one bit does not fail loudly: it silently grants or denies the wrong module. `Chat` was added
+ * at bit 6 in the backend on 2026-09-25 and every module after it moved up one bit; this list moved with it, which
+ * changed the value of `Accounting` through `Portfolio`. See CHANGELOG.md.
  */
 export const NexusModule = {
     /** The app's own API routes (`/api/...`), not a backend module. */
@@ -11,14 +16,15 @@ export const NexusModule = {
     Enterprise: 1 << 3,
     Drive: 1 << 4,
     Message: 1 << 5,
-    Accounting: 1 << 6,
-    Report: 1 << 7,
-    Requisition: 1 << 8,
-    Tenant: 1 << 9,
-    Subscription: 1 << 10,
-    Reservation: 1 << 11,
-    School: 1 << 12,
-    Pharmacy: 1 << 13,
-    Staffing: 1 << 14,
-    Portfolio: 1 << 15,
+    Chat: 1 << 6,
+    Accounting: 1 << 7,
+    Report: 1 << 8,
+    Requisition: 1 << 9,
+    Tenant: 1 << 10,
+    Subscription: 1 << 11,
+    Reservation: 1 << 12,
+    School: 1 << 13,
+    Pharmacy: 1 << 14,
+    Staffing: 1 << 15,
+    Portfolio: 1 << 16,
 };

package/dist/Interfaces/ChatInterfaces.d.ts

@@ -0,0 +1,240 @@
+import type { DropdownPage, DropdownPageRequest } from "./InputInterfaces.ts";
+/** An id, as the backend hands it out: a number, or text (a GUID, an encrypted id). */
+export type ChatId = string | number;
+/**
+ * A domain's value in an app's own enum: a number (`EDomainTypes.Leave`) or a string (`"leave"`). The backend will
+ * own the enum; until it does, a plain number is the value, and the components never read it — they only pass it on.
+ */
+export type ChatDomainValue = string | number;
+/**
+ * Where an app names its domain enum for the types, once, next to its other registrations:
+ *
+ * @example
+ * export enum EDomainTypes { Leave = 1, Procurement = 2, Applicant = 3 }
+ * declare module "nexus-shared" {
+ *   interface ChatRegister { domain: EDomainTypes }
+ * }
+ *
+ * Every chat component, scope, and store then takes only those domains. Without it, any number.
+ */
+export interface ChatRegister {
+}
+/** The app's domain type: the one named in `ChatRegister`, else any number. A component can also take one as `<Chat<EDomainTypes> …>`. */
+export type AppChatDomain = ChatRegister extends {
+    domain: infer TDomain extends ChatDomainValue;
+} ? TDomain : number;
+/**
+ * Which conversation this is: the kind of record, the record, and who is reading it. Everything else a chat needs —
+ * where its messages come from, who may write — follows from these three.
+ *
+ * @example
+ * const scope = { domain: EDomainTypes.Leave, parentId: leave.id, userId: me.id };
+ */
+export interface ChatScope<TDomain extends ChatDomainValue = AppChatDomain> {
+    /** Which kind of record the conversation hangs on: a leave request, a purchase order, an applicant, a tender. */
+    domain: TDomain;
+    /** The record's own id. The domain and the id together are the conversation. */
+    parentId: ChatId;
+    /** Who is reading and writing. Their messages sit on the right, and the unread count is theirs. */
+    userId: ChatId;
+}
+/** One domain's name, for the panel's heading and messages. An app registers its own with `defineChatDomains`. */
+export interface ChatDomainInfo<TDomain extends ChatDomainValue = AppChatDomain> {
+    domain: TDomain;
+    /** Its name in a URL or a cache key: `leave`. Letters, digits, dots, dashes, and underscores. */
+    key: string;
+    /** Its name on screen: "Leave request". */
+    label: string;
+}
+/** `sent`: the server has it. `sending`: on its way. `failed`: it did not arrive, and the text is kept to send again. */
+export type ChatMessageStatus = "sent" | "sending" | "failed";
+/** A file on a message. The chat shows and links it; uploading is the app's `ChatSource`. */
+export interface ChatAttachment {
+    id?: ChatId;
+    name: string;
+    /** Bytes, shown as "248 KB". */
+    size?: number;
+    /** Where it opens or downloads. Without one, the name shows but does not link. */
+    url?: string | null;
+    contentType?: string | null;
+}
+/** One message in a conversation. A backend maps its own rows to this in `ChatBackend.readMessage`. */
+export interface ChatMessage {
+    /** The server's id. A message still on its way carries its `clientId` here until the answer brings the real one. */
+    id: ChatId;
+    /** Who wrote it. Compared with the scope's `userId` to decide which side it sits on. */
+    authorId: ChatId;
+    /** Their name, for the avatar and the line above the message. Without one, the chat says "Unknown". */
+    authorName?: string | null;
+    /** A photo URL. Without one, the initials of the name on a tone picked from it. */
+    authorAvatar?: string | null;
+    /** What they wrote, as plain text. Newlines are kept; nothing is parsed as HTML or Markdown. */
+    body: string;
+    /** When it was written, as a UTC moment (`2026-10-01T03:21:04.000Z`). Shown in the reader's own zone. */
+    createdAt: string;
+    /** When it was last changed, as a UTC moment. Shown as "edited". */
+    editedAt?: string | null;
+    /** Default `sent`. `sending` and `failed` belong to messages this browser has not had answered yet. */
+    status?: ChatMessageStatus;
+    /** The message this one answers, quoted above it. */
+    replyToId?: ChatId | null;
+    attachments?: readonly ChatAttachment[];
+    /** Written by the system, not a person ("Sita approved the request."): a centered note, with no avatar or side. */
+    isSystem?: boolean;
+    /** Who it has reached. Two ticks once anyone has it, filled once anyone has read it. */
+    deliveredTo?: readonly ChatId[];
+    /** Who has read it. */
+    readBy?: readonly ChatId[];
+    /** The people named with @ in the body, for the backend to tell them. */
+    mentions?: readonly ChatId[];
+    /** Set while a message is on its way or failed, so Retry can send the very same draft again. */
+    clientId?: string;
+    /** Why it failed, under the message, beside Retry. */
+    error?: string | null;
+}
+/**
+ * What the trigger icon draws itself from, and the only thing a list of 500 rows needs per row. The three states are
+ * `messageCount === 0` (quiet), messages but none unread (highlighted), and `unreadCount > 0` (highlighted, badged).
+ */
+export interface ChatSummary {
+    /** Messages in the conversation. 0 leaves the icon quiet. */
+    messageCount: number;
+    /** Messages this user has not read. */
+    unreadCount: number;
+    /** When the last message was written, as a UTC moment, for the trigger's tooltip. */
+    lastMessageAt?: string | null;
+    /** The last message's text, cut to a line, for the tooltip. */
+    lastMessageText?: string | null;
+    /** Who wrote the last message, for the tooltip. */
+    lastMessageBy?: string | null;
+    /** How many take part. */
+    participantCount?: number;
+    /** How many conversations the record holds, when it holds more than one. */
+    conversationCount?: number;
+}
+/** The three looks of the trigger icon, in the order the owner described them. */
+export type ChatHighlight = "quiet" | "active" | "unread";
+/** One page of history: the newest messages first, then older ones with `before`, or only the new ones with `after`. */
+export interface ChatHistoryRequest {
+    /** Messages older than this one, for the page above. */
+    before?: ChatId | null;
+    /** Messages newer than this one, for a refresh. `before` and `after` are never both set. */
+    after?: ChatId | null;
+    /** How many to send. */
+    take: number;
+    /** Aborted when the conversation changes or the panel unmounts. */
+    signal?: AbortSignal;
+}
+/** What a history request answers with. Messages may come in any order; the store sorts them oldest first. */
+export interface ChatHistory {
+    messages: readonly ChatMessage[];
+    /** Whether older messages remain. Default: the page was full (`messages.length >= take`). */
+    hasMore?: boolean;
+    /** The conversation's counts, when the answer carries them, so one call fills the header too. */
+    summary?: ChatSummary;
+    /** Everyone taking part, when the answer carries them, so the panel needs no second call. */
+    participants?: readonly ChatParticipant[];
+    /** Whether this user may write here. Default true. */
+    canSend?: boolean;
+}
+/** What the composer sends. */
+export interface ChatDraft {
+    body: string;
+    replyToId?: ChatId | null;
+    /** The people named with @ while writing it. */
+    mentions?: readonly ChatId[];
+    /** Files picked in the composer. A source that cannot take files leaves them out of its request. */
+    files?: readonly File[];
+    /** This browser's id for the message, so the answer replaces the right one and Retry sends the same draft. */
+    clientId: string;
+}
+/** Someone in a conversation, or someone who could be added to it. */
+export interface ChatParticipant {
+    id: ChatId;
+    name: string;
+    avatar?: string | null;
+    /** What they are here: "Manager", "Co-worker", "Requested by". Shown under the name. */
+    role?: string | null;
+    /** They read but cannot write. */
+    readOnly?: boolean;
+    /** How far they have read, as a UTC moment. */
+    lastReadAt?: string | null;
+    /** Someone who has left or is no longer active: shown, never offered again. */
+    inactive?: boolean;
+}
+/** What a participant search receives: the same request a dropdown's `loadOptions` takes, so one loader serves both. */
+export type ChatParticipantQuery = DropdownPageRequest;
+/** What a participant search answers: the same page a dropdown takes. */
+export type ChatParticipantPage = DropdownPage<ChatParticipant>;
+/**
+ * Where one conversation's data comes from. The store calls only this, so it never knows about HTTP: the API source
+ * (`apiChatSource`) talks to the app's `ChatBackend`, and `localChatSource` keeps everything in memory for a demo or
+ * a test. Only `history` and `send` are required.
+ */
+export interface ChatSource {
+    /** One page of messages. */
+    history(request: ChatHistoryRequest): Promise<ChatHistory>;
+    /** Sends one message, and answers with the saved one: its real id, its server time. */
+    send(draft: ChatDraft, signal?: AbortSignal): Promise<ChatMessage>;
+    /** Everyone in the conversation, and the people who could join, searched. Without it, the panel shows no participants. */
+    participants?(query: ChatParticipantQuery): Promise<ChatParticipantPage>;
+    /** Adds people to the conversation. Without it, the panel offers no Add. */
+    addParticipants?(ids: readonly ChatId[], signal?: AbortSignal): Promise<readonly ChatParticipant[]>;
+    /** Tells the server the user has read up to a message. Without it, unread counts clear in the browser only. */
+    markRead?(upTo: ChatId, signal?: AbortSignal): Promise<void>;
+    /** Removes a message. Without it, the panel offers no Delete. */
+    remove?(id: ChatId, signal?: AbortSignal): Promise<void>;
+    /**
+     * Pushes new messages in, from a socket or an event stream, and returns the function that stops it. While a source
+     * watches, the store does not poll.
+     */
+    watch?(onMessages: (messages: readonly ChatMessage[]) => void): () => void;
+}
+/** `one-to-one`: two people, named after the other one. `group`: three or more, or any conversation with a name. */
+export type ChatConversationType = "one-to-one" | "group";
+/** One conversation at a place. One of these shows on its own; several offer a switch between them. */
+export interface ChatConversation {
+    id: ChatId;
+    type: ChatConversationType;
+    /** A group's name. A one-to-one has none: it is called after the other person. */
+    title?: string | null;
+    /** Everyone in it. Needed to name a one-to-one, and to fill the people column without a second call. */
+    participants?: readonly ChatParticipant[];
+    /** Its own counts, so the switch can show which conversation is waiting. */
+    summary?: ChatSummary;
+    /** When it was started, as a UTC moment. */
+    createdAt?: string | null;
+    createdBy?: ChatId | null;
+    /** This user may write in it. Default true. */
+    canSend?: boolean;
+    /** Nobody writes in it any more: it is read, never written to. */
+    closed?: boolean;
+}
+/** What starting a conversation sends. The backend settles the type; this is what the user asked for. */
+export interface NewChatRequest {
+    /** One other person makes a one-to-one, more make a group. */
+    type: ChatConversationType;
+    /** Everyone to put in it, the starter aside. */
+    userIds: readonly ChatId[];
+    /** A group's name. */
+    title?: string | null;
+}
+/**
+ * The conversations at one place: what there is, and how to start another. A panel without one shows the single
+ * conversation its `ChatSource` serves, which is what a page that already knows its conversation wants.
+ */
+export interface ChatPlaceSource {
+    /** Every conversation here this user may see, the one with the newest message first. */
+    conversations(signal?: AbortSignal): Promise<readonly ChatConversation[]>;
+    /** Starts one. A one-to-one that already exists comes back instead of a second one. Without it, no New chat. */
+    create?(request: NewChatRequest, signal?: AbortSignal): Promise<ChatConversation>;
+    /** Who can be put in a conversation here. Without it, New chat has nobody to pick. */
+    participants?(query: ChatParticipantQuery): Promise<ChatParticipantPage>;
+}
+/**
+ * A scope of any domain. Helpers that only pass the domain on — a cache key, the counts of a record — take this, so a
+ * component generic over the app's own enum can hand them its scope without a cast.
+ */
+export type AnyChatScope = ChatScope<ChatDomainValue>;
+/** A conversation's key in a cache: `"1:482"`, the domain and the parent id. */
+export type ChatScopeKey = string;

package/dist/Interfaces/ChatInterfaces.js

@@ -0,0 +1 @@
+export {};