nexus-shared 1.1.21 → 3.0.0

package/dist/Helpers/ApiRoutes.d.ts

@@ -0,0 +1,140 @@
+import type { ApiEndpoint, ApiModuleValue, ApiQuery, HttpMethod } from "../Interfaces/ApiInterfaces.ts";
+import type { CrudMode } from "../Interfaces/CrudInterfaces.ts";
+/**
+ * The standard actions of a Nexus controller, as the backend names them. `apiController` builds its endpoints from
+ * these; use them for an endpoint of your own too: `apiEndpoint.get(module, "Room/" + API_ACTIONS.activeListing)`.
+ */
+export declare const API_ACTIONS: {
+    readonly details: "Detail";
+    /** Every active record: the `normal` list. */
+    readonly listing: "NormalListing";
+    readonly activeListing: "ActiveListing";
+    readonly findListing: "FindListing";
+    /** One page of the `normal` list. */
+    readonly pagination: "NormalPagination";
+    /** Every record of each list a CRUD shows. */
+    readonly listings: {
+        readonly normal: "NormalListing";
+        readonly flag: "FlagListing";
+        readonly trash: "TrashListing";
+        readonly deleted: "DeleteListing";
+    };
+    /** One page of each list a CRUD shows. */
+    readonly paginations: {
+        readonly normal: "NormalPagination";
+        readonly flag: "FlagPagination";
+        readonly trash: "TrashPagination";
+        readonly deleted: "DeletePagination";
+    };
+    /** The records the user pinned, which a CRUD shows above its list. */
+    readonly pinListing: "PinListing";
+    readonly create: "Create";
+    readonly update: "Update";
+    readonly delete: "Delete";
+    readonly trash: "Trash";
+    readonly trashFromDelete: "TrashFromDelete";
+    readonly recover: "Recover";
+    readonly flag: "Flag";
+    readonly pin: "Pin";
+    readonly audit: "AuditListing";
+    readonly accessActions: "AccessActions";
+    readonly massDescription: "MassDescription";
+    readonly massTrash: "MassTrash";
+    readonly massFlag: "MassFlag";
+    readonly massPin: "MassPin";
+    readonly massDelete: "MassDelete";
+    readonly massRecover: "MassRecover";
+    readonly massTrashFromDelete: "MassTrashFromDelete";
+};
+/** An endpoint's optional parts: `bodyType`, `query`, `action`, `subject`. */
+export type ApiEndpointExtras = Partial<Omit<ApiEndpoint, "module" | "path" | "method">>;
+type EndpointExtras = ApiEndpointExtras;
+/**
+ * Builds an endpoint: `apiEndpoint.get(NexusModule.Message, "EmailProvider/ActiveListing")`. The path is under the
+ * module's root; `{name}` in it is filled from the call's `params`, then its body.
+ */
+export declare const apiEndpoint: {
+    get: <TModule extends ApiModuleValue>(module: TModule, path: string, extras?: EndpointExtras) => ApiEndpoint<TModule>;
+    post: <TModule extends ApiModuleValue>(module: TModule, path: string, extras?: EndpointExtras) => ApiEndpoint<TModule>;
+    put: <TModule extends ApiModuleValue>(module: TModule, path: string, extras?: EndpointExtras) => ApiEndpoint<TModule>;
+    patch: <TModule extends ApiModuleValue>(module: TModule, path: string, extras?: EndpointExtras) => ApiEndpoint<TModule>;
+    delete: <TModule extends ApiModuleValue>(module: TModule, path: string, extras?: EndpointExtras) => ApiEndpoint<TModule>;
+};
+/**
+ * The endpoints of a Nexus controller, named as the backend names them. `subject` is what the controller keeps, for
+ * messages ("room" → "Room saved.", "3 rooms deleted."); a call can name the record instead (`subject: "Room 204"`).
+ *
+ * @example
+ * export const ROOMS = apiController(NexusModule.Reservation, "Room", "room");
+ * api.get(ROOMS.details, { params: { id: 5 } });      // GET  /api/app/reservation/Room/Detail/5
+ * api.put(ROOMS.update, values);                      // PUT  /api/app/reservation/Room/Update   → "Room saved."
+ * api.delete(ROOMS.delete, { params: { id: 5 } });    // DELETE .../Room/Delete/5               → "Room deleted."
+ */
+export declare function apiController<TModule extends ApiModuleValue>(module: TModule, controller: string, subject?: string): {
+    module: TModule;
+    controller: string;
+    /** Every active row: GET `Room/NormalListing`. */
+    listing: ApiEndpoint<TModule>;
+    /** Active rows for dropdowns: GET `Room/ActiveListing`. */
+    activeListing: ApiEndpoint<TModule>;
+    /** Rows by id, for saved values a list no longer shows: POST `Room/FindListing` with the ids. */
+    findListing: ApiEndpoint<TModule>;
+    /** One page of active rows: POST `Room/NormalPagination` with `{ searchKeyword, skipCount, maxCount, sorting, sortType }`. */
+    pagination: ApiEndpoint<TModule>;
+    /** Every row of each list, for a CRUD that pages in the browser: GET `Room/NormalListing`, `Room/TrashListing`, … */
+    lists: Record<CrudMode, ApiEndpoint<TModule>>;
+    /** One page of each list, for a CRUD that pages on the server: POST `Room/NormalPagination`, `Room/TrashPagination`, … */
+    pages: Record<CrudMode, ApiEndpoint<TModule>>;
+    /** The records the user pinned, shown above the list: GET `Room/PinListing`. */
+    pins: ApiEndpoint<TModule>;
+    /** One record: GET `Room/Detail/{id}`. */
+    details: ApiEndpoint<TModule>;
+    create: ApiEndpoint<TModule>;
+    update: ApiEndpoint<TModule>;
+    delete: ApiEndpoint<TModule>;
+    trash: ApiEndpoint<TModule>;
+    trashFromDelete: ApiEndpoint<TModule>;
+    recover: ApiEndpoint<TModule>;
+    flag: ApiEndpoint<TModule>;
+    pin: ApiEndpoint<TModule>;
+    /** A record's history: GET `Room/AuditListing/{ownerId}/{skipCount}`. */
+    audit: ApiEndpoint<TModule>;
+    /** What the user may do here: GET `Room/AccessActions`. */
+    accessActions: ApiEndpoint<TModule>;
+    /** Actions on many rows at once: POST `Room/MassDelete` and the rest, with the ids. */
+    mass: {
+        description: ApiEndpoint<TModule>;
+        trash: ApiEndpoint<TModule>;
+        trashFromDelete: ApiEndpoint<TModule>;
+        flag: ApiEndpoint<TModule>;
+        pin: ApiEndpoint<TModule>;
+        delete: ApiEndpoint<TModule>;
+        recover: ApiEndpoint<TModule>;
+    };
+    /** Any other action of the controller: `ROOMS.action("PUT", "Block/{id}", { action: "update" })`. */
+    action: (method: HttpMethod, action: string, extras?: EndpointExtras) => ApiEndpoint<TModule>;
+};
+export type ApiControllerEndpoints = ReturnType<typeof apiController>;
+/** Whether a value is an endpoint (not a URL or a request of another shape). */
+export declare function isApiEndpoint(value: unknown): value is ApiEndpoint;
+/** Thrown when a path names a value the call did not give, so a request never goes to ".../Detail/undefined". */
+export declare class ApiPathError extends Error {
+    readonly path: string;
+    readonly missing: string;
+    constructor(path: string, missing: string);
+}
+/**
+ * Fills `{name}` in a path from `params`, then from the body's fields (names without case), and encodes each value.
+ * Leading and trailing slashes go.
+ */
+export declare function fillApiPath(path: string, params?: Record<string, unknown> | null, body?: unknown): string;
+/** Adds query values to a URL: lists repeat their name, dates go as ISO text, `null` and `undefined` are left out. */
+export declare function appendQuery(url: string, ...queries: (ApiQuery | null | undefined)[]): string;
+/** Joins a root URL and a path with one slash between them. */
+export declare function joinUrl(root: string, path: string): string;
+export interface ApiUrlParts {
+    params?: Record<string, unknown> | null;
+    query?: ApiQuery;
+    body?: unknown;
+}
+export {};

package/dist/Helpers/ApiRoutes.js

@@ -0,0 +1,183 @@
+/*
+ * Endpoints and their URLs. An endpoint is a path under a module's root; which roots exist, and where, is the app's
+ * `ApiModules` class (ApiModules.ts). Define endpoints once, with `apiEndpoint` or `apiController` (or the same
+ * methods of the app's modules), and call them from anywhere.
+ */
+/**
+ * The standard actions of a Nexus controller, as the backend names them. `apiController` builds its endpoints from
+ * these; use them for an endpoint of your own too: `apiEndpoint.get(module, "Room/" + API_ACTIONS.activeListing)`.
+ */
+export const API_ACTIONS = {
+    details: "Detail",
+    /** Every active record: the `normal` list. */
+    listing: "NormalListing",
+    activeListing: "ActiveListing",
+    findListing: "FindListing",
+    /** One page of the `normal` list. */
+    pagination: "NormalPagination",
+    /** Every record of each list a CRUD shows. */
+    listings: { normal: "NormalListing", flag: "FlagListing", trash: "TrashListing", deleted: "DeleteListing" },
+    /** One page of each list a CRUD shows. */
+    paginations: { normal: "NormalPagination", flag: "FlagPagination", trash: "TrashPagination", deleted: "DeletePagination" },
+    /** The records the user pinned, which a CRUD shows above its list. */
+    pinListing: "PinListing",
+    create: "Create",
+    update: "Update",
+    delete: "Delete",
+    trash: "Trash",
+    trashFromDelete: "TrashFromDelete",
+    recover: "Recover",
+    flag: "Flag",
+    pin: "Pin",
+    audit: "AuditListing",
+    accessActions: "AccessActions",
+    massDescription: "MassDescription",
+    massTrash: "MassTrash",
+    massFlag: "MassFlag",
+    massPin: "MassPin",
+    massDelete: "MassDelete",
+    massRecover: "MassRecover",
+    massTrashFromDelete: "MassTrashFromDelete",
+};
+const define = (method) => (module, path, extras) => ({ ...extras, module, path, method });
+/**
+ * Builds an endpoint: `apiEndpoint.get(NexusModule.Message, "EmailProvider/ActiveListing")`. The path is under the
+ * module's root; `{name}` in it is filled from the call's `params`, then its body.
+ */
+export const apiEndpoint = {
+    get: define("GET"),
+    post: define("POST"),
+    put: define("PUT"),
+    patch: define("PATCH"),
+    delete: define("DELETE"),
+};
+/**
+ * The endpoints of a Nexus controller, named as the backend names them. `subject` is what the controller keeps, for
+ * messages ("room" → "Room saved.", "3 rooms deleted."); a call can name the record instead (`subject: "Room 204"`).
+ *
+ * @example
+ * export const ROOMS = apiController(NexusModule.Reservation, "Room", "room");
+ * api.get(ROOMS.details, { params: { id: 5 } });      // GET  /api/app/reservation/Room/Detail/5
+ * api.put(ROOMS.update, values);                      // PUT  /api/app/reservation/Room/Update   → "Room saved."
+ * api.delete(ROOMS.delete, { params: { id: 5 } });    // DELETE .../Room/Delete/5               → "Room deleted."
+ */
+export function apiController(module, controller, subject) {
+    const at = (action) => `${controller}/${action}`;
+    const endpoint = (method, path, extras) => ({ module, path, method, ...(subject && { subject }), ...extras });
+    const A = API_ACTIONS;
+    const modes = Object.keys(A.listings);
+    const byMode = (method, actions) => Object.fromEntries(modes.map(mode => [mode, endpoint(method, at(actions[mode]), { action: "load" })]));
+    return {
+        module,
+        controller,
+        /** Every active row: GET `Room/NormalListing`. */
+        listing: endpoint("GET", at(A.listing), { action: "load" }),
+        /** Active rows for dropdowns: GET `Room/ActiveListing`. */
+        activeListing: endpoint("GET", at(A.activeListing), { action: "load" }),
+        /** Rows by id, for saved values a list no longer shows: POST `Room/FindListing` with the ids. */
+        findListing: endpoint("POST", at(A.findListing), { action: "load" }),
+        /** One page of active rows: POST `Room/NormalPagination` with `{ searchKeyword, skipCount, maxCount, sorting, sortType }`. */
+        pagination: endpoint("POST", at(A.pagination), { action: "load" }),
+        /** Every row of each list, for a CRUD that pages in the browser: GET `Room/NormalListing`, `Room/TrashListing`, … */
+        lists: byMode("GET", A.listings),
+        /** One page of each list, for a CRUD that pages on the server: POST `Room/NormalPagination`, `Room/TrashPagination`, … */
+        pages: byMode("POST", A.paginations),
+        /** The records the user pinned, shown above the list: GET `Room/PinListing`. */
+        pins: endpoint("GET", at(A.pinListing), { action: "load" }),
+        /** One record: GET `Room/Detail/{id}`. */
+        details: endpoint("GET", at(`${A.details}/{id}`), { action: "load" }),
+        create: endpoint("POST", at(A.create), { action: "create" }),
+        update: endpoint("PUT", at(A.update), { action: "save" }),
+        delete: endpoint("DELETE", at(`${A.delete}/{id}`), { action: "delete" }),
+        trash: endpoint("DELETE", at(`${A.trash}/{id}`), { action: "trash" }),
+        trashFromDelete: endpoint("PUT", at(`${A.trashFromDelete}/{id}`), { action: "trash" }),
+        recover: endpoint("PUT", at(`${A.recover}/{id}`), { action: "recover" }),
+        flag: endpoint("PUT", at(`${A.flag}/{id}`), { action: "flag" }),
+        pin: endpoint("PUT", at(`${A.pin}/{id}`), { action: "pin" }),
+        /** A record's history: GET `Room/AuditListing/{ownerId}/{skipCount}`. */
+        audit: endpoint("GET", at(`${A.audit}/{ownerId}/{skipCount}`), { action: "load" }),
+        /** What the user may do here: GET `Room/AccessActions`. */
+        accessActions: endpoint("GET", at(A.accessActions), { action: "load" }),
+        /** Actions on many rows at once: POST `Room/MassDelete` and the rest, with the ids. */
+        mass: {
+            description: endpoint("POST", at(A.massDescription), { action: "update" }),
+            trash: endpoint("POST", at(A.massTrash), { action: "trash" }),
+            trashFromDelete: endpoint("POST", at(A.massTrashFromDelete), { action: "trash" }),
+            flag: endpoint("POST", at(A.massFlag), { action: "flag" }),
+            pin: endpoint("POST", at(A.massPin), { action: "pin" }),
+            delete: endpoint("POST", at(A.massDelete), { action: "delete" }),
+            recover: endpoint("POST", at(A.massRecover), { action: "recover" }),
+        },
+        /** Any other action of the controller: `ROOMS.action("PUT", "Block/{id}", { action: "update" })`. */
+        action: (method, action, extras) => endpoint(method, at(action), extras),
+    };
+}
+/** Whether a value is an endpoint (not a URL or a request of another shape). */
+export function isApiEndpoint(value) {
+    const endpoint = value;
+    return typeof endpoint === "object" && endpoint !== null && (typeof endpoint.module === "number" || typeof endpoint.module === "string") && typeof endpoint.path === "string" && typeof endpoint.method === "string";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Blob) && !(typeof FormData !== "undefined" && value instanceof FormData);
+}
+/** Thrown when a path names a value the call did not give, so a request never goes to ".../Detail/undefined". */
+export class ApiPathError extends Error {
+    path;
+    missing;
+    constructor(path, missing) {
+        super(`The API path "${path}" needs "${missing}", which the call did not give.`);
+        this.name = "ApiPathError";
+        this.path = path;
+        this.missing = missing;
+    }
+}
+/**
+ * Fills `{name}` in a path from `params`, then from the body's fields (names without case), and encodes each value.
+ * Leading and trailing slashes go.
+ */
+export function fillApiPath(path, params, body) {
+    const fields = isRecord(body) ? body : undefined;
+    const filled = path.replace(/\{(\w+)\}/g, (_whole, name) => {
+        let value = params?.[name];
+        if ((value === undefined || value === null) && fields) {
+            const lower = name.toLowerCase();
+            const key = name in fields ? name : Object.keys(fields).find(candidate => candidate.toLowerCase() === lower);
+            if (key !== undefined)
+                value = fields[key];
+        }
+        if (value === undefined || value === null || value === "")
+            throw new ApiPathError(path, name);
+        return encodeURIComponent(String(value));
+    });
+    return filled.replace(/^\/+|\/+$/g, "");
+}
+function queryText(value) {
+    return value instanceof Date ? value.toISOString() : String(value);
+}
+/** Adds query values to a URL: lists repeat their name, dates go as ISO text, `null` and `undefined` are left out. */
+export function appendQuery(url, ...queries) {
+    const search = new URLSearchParams();
+    for (const query of queries) {
+        for (const [key, value] of Object.entries(query ?? {})) {
+            if (value === undefined || value === null)
+                continue;
+            if (Array.isArray(value))
+                for (const item of value)
+                    search.append(key, queryText(item));
+            else
+                search.append(key, queryText(value));
+        }
+    }
+    const text = search.toString();
+    if (!text)
+        return url;
+    const hash = url.indexOf("#");
+    const [base, fragment] = hash === -1 ? [url, ""] : [url.slice(0, hash), url.slice(hash)];
+    return `${base}${base.includes("?") ? "&" : "?"}${text}${fragment}`;
+}
+/** Joins a root URL and a path with one slash between them. */
+export function joinUrl(root, path) {
+    if (!path)
+        return root.replace(/\/+$/, "");
+    return `${root.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}

package/dist/Helpers/ApiToasts.d.ts

@@ -0,0 +1,21 @@
+import type { ApiResult, HttpMethod } from "../Interfaces/ApiInterfaces.ts";
+import type { BuiltMessage, MessageContext } from "../Interfaces/MessageInterfaces.ts";
+/**
+ * Toasts for one call. `true` shows both, `false` none; or each on its own, with `true`, `false`, or a title of its own:
+ * `{ success: "Booking confirmed.", error: false, loading: true }`. `loading` shows a spinner toast while the call runs,
+ * which then turns into the success or error toast (or closes).
+ */
+export type ApiToastOption = boolean | {
+    success?: boolean | string;
+    error?: boolean | string;
+    loading?: boolean | string;
+};
+/** The app's defaults: an error toast for every failed call, a success toast for POST, PUT, PATCH, and DELETE. */
+export interface ApiToastDefaults {
+    success?: boolean;
+    error?: boolean;
+}
+/** The toast for a call's answer, or `null` for none. */
+export declare function planApiToast(result: ApiResult, method: HttpMethod, context: MessageContext, option?: ApiToastOption, defaults?: ApiToastDefaults): BuiltMessage | null;
+/** The loading toast's text for a call, or `null` for none. */
+export declare function planLoadingToast(context: MessageContext, option?: ApiToastOption): string | null;

package/dist/Helpers/ApiToasts.js

@@ -0,0 +1,22 @@
+import { buildMessage, describeResult } from "./MessageBuilder.js";
+/** The toast for a call's answer, or `null` for none. */
+export function planApiToast(result, method, context, option, defaults = {}) {
+    if (result.aborted)
+        return null;
+    const choice = typeof option === "object" ? (result.ok ? option.success : option.error) : option;
+    const wanted = choice ?? (result.ok ? (defaults.success ?? true) && method !== "GET" : (defaults.error ?? true));
+    if (!wanted)
+        return null;
+    const built = describeResult(result, context);
+    if (!built || typeof choice !== "string")
+        return built;
+    // A title of the call's own; a failure keeps the reason under it.
+    return result.ok ? { tone: "success", title: choice } : { ...built, title: choice };
+}
+/** The loading toast's text for a call, or `null` for none. */
+export function planLoadingToast(context, option) {
+    const loading = typeof option === "object" ? option.loading : undefined;
+    if (!loading)
+        return null;
+    return typeof loading === "string" ? loading : buildMessage("loading", context);
+}

package/dist/Helpers/ChatBackend.d.ts

@@ -0,0 +1,134 @@
+import { type ApiEndpoint, type ApiModuleValue } from "../Interfaces/ApiInterfaces.ts";
+import type { AppChatDomain, ChatConversation, ChatDomainInfo, ChatDomainValue, ChatDraft, ChatHistory, ChatHistoryRequest, ChatId, ChatMessage, ChatParticipant, ChatParticipantPage, ChatParticipantQuery, ChatScope, ChatSummary, NewChatRequest } from "../Interfaces/ChatInterfaces.ts";
+/** The actions a chat needs from a backend. A backend that does not serve one takes that feature off the panel. */
+export declare const CHAT_ACTIONS: {
+    /** The conversations a record holds, for this reader. */
+    readonly conversations: "ConversationListing";
+    /** Starts one. */
+    readonly createConversation: "CreateConversation";
+    /** One page of messages. */
+    readonly history: "History";
+    /** Writes one message. */
+    readonly send: "Create";
+    /** The counts of many records at once, for the trigger icons in a list. */
+    readonly summaries: "Summaries";
+    /** The people in a conversation, and the ones who could join, searched. */
+    readonly participants: "ParticipantPagination";
+    /** How far this user has read. */
+    readonly read: "Read";
+    /** Removes one message. */
+    readonly remove: "Delete";
+    /** Adds people to a conversation. */
+    readonly addParticipants: "AddParticipants";
+};
+export type ChatAction = keyof typeof CHAT_ACTIONS;
+type Row = Record<string, unknown>;
+/**
+ * What a chat needs from a backend. Extend it for an app whose chat API differs from the Nexus one, and register it
+ * once beside the app's API modules:
+ *
+ * @example
+ * class HrChatBackend extends NexusChatBackend {
+ *   override endpoint(action: ChatAction) {
+ *     return action === "history" ? apiEndpoint.post(HrModule.Staff, "LeaveChat/Page") : super.endpoint(action);
+ *   }
+ * }
+ * defineChatBackend(new HrChatBackend());
+ */
+export declare abstract class ChatBackend<TDomain extends ChatDomainValue = AppChatDomain> {
+    /**
+     * Which endpoint serves an action. The module is one of the app's own (`AppModule`), as everywhere else in the API
+     * layer: an app on another backend registers a backend of its own and names its own modules here.
+     */
+    abstract endpoint(action: ChatAction): ApiEndpoint;
+    /** Whether the backend serves an action. Default true; `false` takes the feature off the panel. */
+    supports(action: ChatAction): boolean;
+    /** What asking for a record's conversations sends. */
+    abstract conversationsRequest(scope: ChatScope<TDomain>): unknown;
+    /** Reads them. */
+    abstract readConversations(result: unknown): readonly ChatConversation[];
+    /** What starting a conversation sends. */
+    abstract createConversationRequest(scope: ChatScope<TDomain>, request: NewChatRequest): unknown;
+    /** Reads the conversation that was started, or the one that already existed. */
+    abstract readConversation(result: unknown): ChatConversation;
+    /** What a history request sends: which conversation, and which page of it. */
+    abstract historyRequest(scope: ChatScope<TDomain>, request: ChatHistoryRequest, conversationId?: ChatId): unknown;
+    /** Reads a page of history. */
+    abstract readHistory(result: unknown): ChatHistory;
+    /** What sending a message sends. */
+    abstract sendRequest(scope: ChatScope<TDomain>, draft: ChatDraft, conversationId?: ChatId): unknown;
+    /** Reads the saved message. The draft is there for a backend that answers with an id alone. */
+    abstract readMessage(result: unknown, scope: ChatScope<TDomain>, draft: ChatDraft): ChatMessage;
+    /** What asking for many records' counts sends. One call carries one domain and many parent ids. */
+    abstract summariesRequest(domain: TDomain, parentIds: readonly ChatId[], userId: ChatId): unknown;
+    /** Reads those counts, by parent id as text (`String(parentId)`). Records the answer leaves out have no messages. */
+    abstract readSummaries(result: unknown): Map<string, ChatSummary>;
+    /** What a participant search sends. Without a conversation it asks who could be put in a new one. */
+    abstract participantsRequest(scope: ChatScope<TDomain>, query: ChatParticipantQuery, conversationId?: ChatId): unknown;
+    /** Reads a page of participants. */
+    abstract readParticipants(result: unknown): ChatParticipantPage;
+    /** What the read mark sends. */
+    abstract readMarkRequest(scope: ChatScope<TDomain>, upTo: ChatId, conversationId?: ChatId): unknown;
+    /** What adding people sends. */
+    abstract addParticipantsRequest(scope: ChatScope<TDomain>, userIds: readonly ChatId[], conversationId?: ChatId): unknown;
+    /** What removing a message sends, as the call's `params`: the id in the path. */
+    removeParams(scope: ChatScope<TDomain>, messageId: ChatId): Record<string, string | number>;
+}
+/**
+ * The Nexus Chat module: one controller, `Chat`, whose actions take the domain, the parent id and the reader, and
+ * answer as the other Nexus endpoints do (`{ results, totalCount, filterCount }` for pages). See the note at the top
+ * of this file: these are the shape the module is expected to take.
+ */
+export declare class NexusChatBackend<TDomain extends ChatDomainValue = AppChatDomain> extends ChatBackend<TDomain> {
+    /** The module the chat endpoints live in. `NexusModule.Chat` (bit 6). */
+    readonly module: ApiModuleValue;
+    /** The controller the actions hang off. */
+    readonly controller: string;
+    endpoint(action: ChatAction): ApiEndpoint;
+    conversationsRequest(scope: ChatScope<TDomain>): unknown;
+    readConversations(result: unknown): readonly ChatConversation[];
+    createConversationRequest(scope: ChatScope<TDomain>, request: NewChatRequest): unknown;
+    readConversation(result: unknown): ChatConversation;
+    historyRequest(scope: ChatScope<TDomain>, request: ChatHistoryRequest, conversationId?: ChatId): unknown;
+    readHistory(result: unknown): ChatHistory;
+    sendRequest(scope: ChatScope<TDomain>, draft: ChatDraft, conversationId?: ChatId): unknown;
+    readMessage(result: unknown, scope: ChatScope<TDomain>, draft: ChatDraft): ChatMessage;
+    summariesRequest(domain: TDomain, parentIds: readonly ChatId[], userId: ChatId): unknown;
+    readSummaries(result: unknown): Map<string, ChatSummary>;
+    participantsRequest(scope: ChatScope<TDomain>, query: ChatParticipantQuery, conversationId?: ChatId): unknown;
+    readParticipants(result: unknown): ChatParticipantPage;
+    readMarkRequest(scope: ChatScope<TDomain>, upTo: ChatId, conversationId?: ChatId): unknown;
+    addParticipantsRequest(scope: ChatScope<TDomain>, userIds: readonly ChatId[], conversationId?: ChatId): unknown;
+    /**
+     * One conversation row. The type comes back as the backend's `EChatTypes` number (0 one-to-one, 1 group) or as a
+     * name; both are read, because which it will be is not settled.
+     */
+    protected toConversation(row: Row): ChatConversation;
+    /** One message row. The names are the ones a Nexus contract uses; override this alone for a backend that differs. */
+    protected toMessage(row: Row): ChatMessage;
+    /** One set of counts. */
+    protected toSummary(row: Row): ChatSummary;
+    /** One participant row. */
+    protected toParticipant(row: Row): ChatParticipant;
+}
+/** Makes an app's chat backend the one every chat uses, and returns it. Call it once, beside `defineApiModules`. */
+export declare function defineChatBackend<T extends ChatBackend<any>>(backend: T): T;
+/** The app's chat backend: the one given to `defineChatBackend`, else the Nexus one. */
+export declare function getChatBackend(): ChatBackend<any>;
+/**
+ * Names the app's domains, for the panel's heading and its messages. The values are the app's own enum, so this
+ * package never holds a number of its own: the owner's list is Leave, Procurement, Applicants, Students, Companies,
+ * Tenders and the account kinds, and which number each one is belongs to the backend's `EDomainTypes`.
+ *
+ * @example
+ * defineChatDomains([
+ *   { domain: EDomainTypes.Leave, key: "leave", label: "Leave request" },
+ *   { domain: EDomainTypes.Procurement, key: "procurement", label: "Purchase order" },
+ * ]);
+ */
+export declare function defineChatDomains<TDomain extends ChatDomainValue>(list: readonly ChatDomainInfo<TDomain>[]): readonly ChatDomainInfo<TDomain>[];
+/** The registered domains. Empty until an app calls `defineChatDomains`. */
+export declare function getChatDomains(): readonly ChatDomainInfo<any>[];
+/** A domain's name on screen, or `undefined` when the app has not named it. */
+export declare function chatDomainLabel(domain: ChatDomainValue): string | undefined;
+export {};