@ethora/chat-component 26.7.5 → 26.7.6

package/dist/roomStore/index.d.ts

@@ -3,6 +3,26 @@ import { IMessage, IRoom } from '../types/types';
 export declare const sanitizeRoomsMap: (roomsMap: Record<string, any>) => Record<string, IRoom>;
 export declare const MAX_MESSAGES_PER_ROOM = 100;
 export declare const MAX_PERSISTED_ROOMS = 100;
+/**
+ * Composer drafts are a NEW top-level key of the rooms slice, so they are
+ * persisted deliberately rather than by accident: they are the one piece of
+ * live composer state worth surviving a reload, and unlike `members` (see
+ * REFETCHED_ROOM_FIELDS below) nothing on the server can rebuild them.
+ *
+ * They are also kept OFF the room objects on purpose. The rooms map is what
+ * the char budget fights over, and its last-resort eviction can only drop
+ * `messages` - a draft riding on a room would compete with the message
+ * cache for that budget and could not be evicted independently. As its own
+ * key it is bounded on its own terms by the caps in roomsSlice:
+ * MAX_PERSISTED_DRAFTS (30, least recently typed dropped first, using the
+ * map's insertion order as recency) x MAX_DRAFT_LENGTH (2,000 chars) =
+ * 60,000 chars, i.e. 6% of PERSISTED_ROOMS_CHAR_BUDGET even at the worst
+ * case, and typically a few hundred bytes.
+ *
+ * Applied on the way out AND on the way back in (sanitizeRoomsSliceKey), so
+ * an older or hand-edited blob cannot rehydrate an unbounded map either.
+ */
+export declare const compactDraftsForPersist: (drafts: unknown) => Record<string, string>;
 export declare const PERSISTED_ROOMS_CHAR_BUDGET = 1000000;
 /** ~1.4x: AES + base64 overhead the encrypt transform adds on top. */
 export declare const ENCRYPTION_INFLATION_FACTOR = 1.4;

package/dist/roomStore/persistEncryption.d.ts

@@ -0,0 +1,51 @@
+import { User } from '../types/types';
+/**
+ * WHICH CLAIMS, AND WHY NOT THE WHOLE TOKEN.
+ *
+ * The obvious input, `user.token`, is the wrong one: it rotates.
+ * `authRefresh.ts` runs refresh-token rotation with reuse detection, so
+ * the access token string changes several times an hour. Key the
+ * encryption on the whole token and every rotation orphans the blob
+ * that the previous token wrote: the user would lose their entire chat
+ * cache on a schedule, silently, and each reload would start from an
+ * empty transcript until MAM caught up.
+ *
+ * So we derive from the parts of the token that are stable for the life
+ * of the ACCOUNT rather than the life of the credential: the `userId`
+ * and `appId` claims out of the JWT payload (Ethora issues
+ * `{ data: { userId, appId }, iat, exp }`). `iat` / `exp` / the
+ * signature are deliberately excluded - they are exactly the parts that
+ * change on refresh.
+ *
+ * `appToken` joins them as a build-time constant so two different apps
+ * embedding the SDK on one origin never derive the same key. It adds no
+ * secrecy on its own (it is in the bundle), which is why it is a
+ * component of the key and not the key.
+ */
+export interface PersistKeyIdentity {
+    userId: string;
+    appId: string;
+}
+/** The key used when there is no session: SSR, logged out, first paint. */
+export declare const ANONYMOUS_PERSIST_SECRET_KEY: string;
+/**
+ * Stable account identity for the key, read from the JWT payload first
+ * and from the stored user record second. The fallback matters for
+ * hosts that hand the SDK a user object without an Ethora access token
+ * (they run their own auth and supply `refreshTokens.refreshFunction`).
+ */
+export declare const readStableIdentity: (user?: Partial<User> | null) => PersistKeyIdentity | null;
+export declare const derivePersistSecretKey: (identity?: PersistKeyIdentity | null) => string;
+export declare const getPersistSecretKey: () => string;
+/** Test seam, and the hook logout could use if it ever needs to. */
+export declare const resetPersistSecretKeyCache: () => void;
+/**
+ * Drop-in replacement for the old fixed-key `encryptTransform`.
+ *
+ * It has to resolve the key lazily, per call: `encryptTransform`
+ * captures `secretKey` when it is constructed, and this module is
+ * imported at store-creation time, long before a `<Chat>` consumer has
+ * logged anybody in. Resolving on each in/out means the first write
+ * after login already uses that user's key.
+ */
+export declare const sessionEncryptTransform: import('redux-persist').Transform<any, any, any, any>;

package/dist/roomStore/roomsSlice.d.ts

@@ -1,5 +1,21 @@
-import { AddRoomMessageAction, ApiRoom, EditAction, IMessage, IRoom, ReactionAction, RoomMember } from '../types/types';
+import { AddRoomMessageAction, ApiRoom, EditAction, IMessage, IRoom, ReactionAction, RoomMember, Translation } from '../types/types';
 import { default as XmppClient } from '../networking/xmppClient';
+/**
+ * Draft caps. Drafts ride along in the persisted rooms slice, so they have
+ * to be bounded before they are written, not after:
+ *
+ *   30 rooms x 2,000 chars = 60,000 chars worst case, ~84,000 after the
+ *   encrypt transform's ~1.4x inflation (~168 KB of the origin's ~5 MB).
+ *
+ * That is small next to PERSISTED_ROOMS_CHAR_BUDGET (1,000,000 chars) and,
+ * because drafts are their own top-level slice key, it can never squeeze
+ * the message cache the way the member roster once did. 2,000 chars is far
+ * longer than any message anyone actually leaves half-typed; anything past
+ * it is truncated rather than dropped, so the user still gets most of it
+ * back.
+ */
+export declare const MAX_DRAFT_LENGTH = 2000;
+export declare const MAX_PERSISTED_DRAFTS = 30;
 interface RoomMessagesState {
     rooms: {
         [jid: string]: IRoom;
@@ -16,12 +32,13 @@ interface RoomMessagesState {
     subscribedRooms: string[];
     pushSubscriptionStatus: Record<string, 'pending' | 'subscribed' | 'error' | 'blocked'>;
     loadingText?: string;
+    drafts: Record<string, string>;
 }
 interface PreloadRoomUpdate {
     jid: string;
     messages?: IMessage[];
     unreadCapped?: boolean;
-    historyPreloadState?: 'idle' | 'loading' | 'done' | 'error';
+    historyPreloadState?: 'idle' | 'loading' | 'partial' | 'done' | 'error';
 }
 export declare const addRoomViaApi: import('@reduxjs/toolkit').AsyncThunk<void, {
     room: IRoom;
@@ -48,11 +65,26 @@ export declare const addRoom: import('@reduxjs/toolkit').ActionCreatorWithOption
 }, "roomMessages/replaceRoomMessages">, addRoomMessage: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<AddRoomMessageAction, "roomMessages/addRoomMessage">, deleteRoomMessage: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     roomJID: string;
     messageId: string;
-}, "roomMessages/deleteRoomMessage">, setEditAction: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<EditAction, "roomMessages/setEditAction">, editRoomMessage: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+}, "roomMessages/deleteRoomMessage">, removeRoomMessage: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    roomJID: string;
+    messageId: string;
+}, "roomMessages/removeRoomMessage">, setEditAction: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<EditAction, "roomMessages/setEditAction">, setMessageSendFailed: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    roomJID: string;
+    messageId: string;
+}, "roomMessages/setMessageSendFailed">, setMessageSendRetrying: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    roomJID: string;
+    messageId: string;
+}, "roomMessages/setMessageSendRetrying">, editRoomMessage: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     roomJID: string;
     messageId: string;
     text: string;
-}, "roomMessages/editRoomMessage">, setComposing: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    isEdited?: boolean;
+}, "roomMessages/editRoomMessage">, setMessageTranslation: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    roomJID: string;
+    messageId: string;
+    locale: string;
+    entry: Translation;
+}, "roomMessages/setMessageTranslation">, setComposing: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     chatJID: string;
     composing: boolean;
     composingList?: string[];
@@ -87,7 +119,10 @@ export declare const addRoom: import('@reduxjs/toolkit').ActionCreatorWithOption
 }, "roomMessages/deleteRoom">, updateRoom: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     jid: string;
     updates: Partial<IRoom>;
-}, "roomMessages/updateRoom">, updateUsersSet: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+}, "roomMessages/updateRoom">, updateRooms: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    jid: string;
+    updates: Partial<IRoom>;
+}[], "roomMessages/updateRooms">, updateUsersSet: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     rooms: ApiRoom[];
 }, "roomMessages/updateUsersSet">, setOpenReportModal: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     isOpen: boolean;
@@ -98,6 +133,14 @@ export declare const addRoom: import('@reduxjs/toolkit').ActionCreatorWithOption
     status: "pending" | "subscribed" | "error" | "blocked";
 }, "roomMessages/setPushSubscriptionStatus">, clearPushSubscriptions: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"roomMessages/clearPushSubscriptions">, applyRoomsPreloadBatch: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     rooms: PreloadRoomUpdate[];
-}, "roomMessages/applyRoomsPreloadBatch">;
+}, "roomMessages/applyRoomsPreloadBatch">, setRoomDraft: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    jid: string;
+    text: string;
+}, "roomMessages/setRoomDraft">, clearRoomDraft: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    jid: string;
+}, "roomMessages/clearRoomDraft">, setRoomMuted: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    jid: string;
+    muted: boolean | undefined;
+}, "roomMessages/setRoomMuted">;
 declare const _default: import('redux').Reducer<RoomMessagesState>;
 export default _default;

package/dist/styles/classNames.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Global CSS class names owned by this SDK.
+ *
+ * This package is embedded into host applications, so every class name it
+ * writes into the DOM shares a namespace with the host's own stylesheet.
+ * Anything declared in `src/index.css` must therefore be prefixed with
+ * `ethora-` (so it cannot collide with a host class of the same name) and,
+ * where possible, nested under {@link CHAT_ROOT_CLASS} (so it cannot leak
+ * styling onto host markup).
+ *
+ * Keep these constants as the single source of truth: `index.css` and every
+ * component that adds/removes one of these classes must agree, and a plain
+ * string literal in a `classList.add(...)` call is easy to drift.
+ */
+/**
+ * Marks a subtree as "owned by the chat".
+ *
+ * Applied to:
+ *  - the invisible (`display: contents`) wrapper `<Chat>` renders around its
+ *    whole tree, so every chat node is a descendant, and
+ *  - UI the SDK renders OUTSIDE that tree (the in-app notification container,
+ *    the portalled language modal), which would otherwise lose the chat's
+ *    scrollbar/typography defaults.
+ *
+ * Everything in `index.css` that is not itself `ethora-`-prefixed (scrollbars,
+ * base font) is scoped to this class, which is what keeps the host page's own
+ * scrollbars and body typography untouched.
+ */
+export declare const CHAT_ROOT_CLASS = "ethora-chat-root";
+/** Transient highlight flashed on a message when a notification is opened. */
+export declare const MESSAGE_HIGHLIGHT_CLASS = "ethora-message-highlight";
+/** Fixed-position container holding the in-app notification toasts. */
+export declare const NOTIFICATION_CONTAINER_CLASS = "ethora-message-notification-container";
+/** Forces the colour-emoji font on nodes that render a bare emoji glyph. */
+export declare const APPLE_EMOJI_CLASS = "ethora-apple-emoji";

package/dist/styles/motion.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Shared motion primitives for the chat UI.
+ *
+ * Keep durations/easing in sync with the tokens published by
+ * `styles/tokens.ts` (`--ethora-motion-fast` = 150ms, `--ethora-motion-base`
+ * = 220ms, `--ethora-motion-ease`). The literal values are duplicated here
+ * (rather than reading the CSS variables inside `@keyframes`, which most
+ * browsers don't support) but must stay numerically identical.
+ */
+export declare const MOTION_FAST = "150ms";
+export declare const MOTION_BASE = "220ms";
+export declare const MOTION_EASE = "cubic-bezier(.2,.8,.2,1)";
+export declare const fadeIn: import('styled-components/dist/models/Keyframes').default;
+export declare const fadeInUp: import('styled-components/dist/models/Keyframes').default;
+export declare const scaleIn: import('styled-components/dist/models/Keyframes').default;
+export declare const shimmer: import('styled-components/dist/models/Keyframes').default;
+/**
+ * Right-hand side drawer entrance. Travels further than `fadeInUp` (a panel
+ * sliding in from the screen edge reads as motion only if it actually
+ * covers some distance) but keeps the same duration/easing as everything
+ * else, so a drawer does not feel like a different app.
+ */
+export declare const slideInRight: import('styled-components/dist/models/Keyframes').default;
+/**
+ * Disables all animations/transitions when the user prefers reduced motion.
+ * Spread this LAST in a styled-components template so it wins the cascade,
+ * e.g.:
+ *
+ *   const Row = styled.div`
+ *     animation: ${fadeInUp} ${MOTION_BASE} ${MOTION_EASE};
+ *     ${reducedMotion}
+ *   `;
+ */
+export declare const reducedMotion: import('styled-components').RuleSet<object>;
+/** Convenience: fade+rise-in animation shorthand, respecting reduced motion. */
+export declare const fadeInUpAnimation: import('styled-components').RuleSet<object>;
+/** Convenience: cross-fade animation shorthand, respecting reduced motion. */
+export declare const fadeInAnimation: import('styled-components').RuleSet<object>;
+/** Convenience: scale-in animation shorthand, respecting reduced motion. */
+export declare const scaleInAnimation: import('styled-components').RuleSet<object>;
+/** Convenience: side-drawer slide-in shorthand, respecting reduced motion. */
+export declare const slideInRightAnimation: import('styled-components').RuleSet<object>;
+/** Shimmering skeleton background, respecting reduced motion (stays static). */
+export declare const shimmerBackground: import('styled-components').RuleSet<object>;

package/dist/styles/tokens.d.ts

@@ -0,0 +1,27 @@
+import { CSSProperties } from 'react';
+import { IConfig, TypographyConfig } from '../types/types';
+/** Mix `hex` toward white by `amount` (0-1). Used for soft tints. */
+export declare const tintColor: (hex: string, amount: number) => string;
+/** Mix `hex` toward black by `amount` (0-1). Used for hover/pressed shades. */
+export declare const shadeColor: (hex: string, amount: number) => string;
+export type ThemeTokenMap = Record<string, string>;
+/**
+ * Build the full `--ethora-*` CSS variable map from the host's config.
+ * Pure function - safe to call outside the browser (SSR, tests).
+ */
+export declare function buildThemeTokens(colors?: IConfig['colors'], typography?: TypographyConfig): ThemeTokenMap;
+/**
+ * The class the chat's root element carries; useful for scoping global CSS.
+ * Re-exported from `styles/classNames`, which owns every class name this
+ * SDK writes into the DOM, so the literal exists in exactly one place.
+ */
+export { CHAT_ROOT_CLASS } from './classNames';
+/**
+ * Memoized React.CSSProperties built from the token map - spread this onto
+ * the chat root element's inline `style` so the variables are scoped to the
+ * chat subtree wherever the root can carry them.
+ */
+export declare function useThemeTokenStyle(colors?: IConfig['colors'], typography?: TypographyConfig): CSSProperties;
+export declare function ThemeTokens({ config, }: {
+    config?: Pick<IConfig, 'colors' | 'typography'>;
+}): null;

package/dist/testIds.d.ts

@@ -6,7 +6,7 @@
  * Kotlin objects (in `chat-ui/src/main/.../components/*Kt`) and iOS's
  * `*AccessibilityID` Swift enums (in `XMPPChatUI/AccessibilityIdentifiers.swift`),
  * so a single Maestro YAML flow exercises the same intent on either
- * mobile platform — and Playwright tests in host apps using this
+ * mobile platform - and Playwright tests in host apps using this
  * component (e.g. `ethora-app-reactjs`) can resolve the same nodes
  * via `data-testid`.
  *

package/dist/types/models/attachment.model.d.ts

@@ -0,0 +1,33 @@
+/**
+ * One uploaded file carried by a media message.
+ *
+ * Historically a media message described exactly one file through flat
+ * `IMessage` fields (`location`, `mimetype`, `originalName`, ...). Those
+ * fields are still written (they are what every already-shipped client
+ * reads), and they now double as attachment #0 of `IMessage.attachments`.
+ * Anything past #0 only exists in the `attachments` payload, so old clients
+ * degrade to "shows the first file" instead of breaking.
+ */
+export interface IAttachment {
+    /** `_id` returned by POST /files/ - stable per upload, used as a render key. */
+    attachmentId?: string;
+    /** Canonical file URL. */
+    location: string;
+    /** Server-side generated preview (images always, other types sometimes). */
+    locationPreview?: string;
+    mimetype?: string;
+    /** Name the user picked. */
+    originalName?: string;
+    /** Name on the storage side. */
+    fileName?: string;
+    /** Bytes, as a string - that is how it travels on the wire. */
+    size?: string;
+    duration?: string;
+    ownerKey?: string;
+    userId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    expiresAt?: string;
+    isVisible?: boolean;
+    isPrivate?: boolean;
+}

package/dist/types/models/config.model.d.ts

@@ -1,7 +1,7 @@
 import { User } from './user.model';
 import { xmppSettingsInterface } from './xmpp.model';
-import { PartialRoomWithMandatoryKeys, ConfigRoom } from './room.model';
-import { MessageBubble, MessageProps, IMessage } from './message.model';
+import { ConfigRoom } from './room.model';
+import { MessageProps, IMessage } from './message.model';
 import { Iso639_1Codes } from './language.model';
 import { QuickReply } from '../../helpers/quickReplies';
 import { default as React } from 'react';
@@ -56,7 +56,7 @@ export interface FBConfig {
 }
 /**
  * A single self-hosted font file to register via an injected `@font-face`
- * rule. Use this for fonts that are not on Google Fonts — e.g. the Ukrainian
+ * rule. Use this for fonts that are not on Google Fonts - e.g. the Ukrainian
  * government "e-Ukraine" family distributed from thedigital.gov.ua. Host the
  * `.woff2`/`.ttf` somewhere reachable and point `src` at it.
  */
@@ -114,10 +114,54 @@ export interface TypographyConfig {
         bold?: number;
     };
 }
+/** Which part of the SDK an uncaught render error came from. */
+export type ChatErrorScope = 'chat' | 'call-overlay';
+/**
+ * What the SDK reports when its error boundary catches an uncaught render
+ * error: the error itself, React's component stack (when the runtime gives
+ * one) and which subtree crashed.
+ */
+export interface ChatErrorInfo {
+    error: Error;
+    componentStack?: string;
+    scope: ChatErrorScope;
+}
+/**
+ * Render-prop form of `fallbackScreens.error`. `reset()` clears the boundary
+ * and re-mounts the chat subtree, so a host can build its own "try again".
+ */
+export type ChatErrorFallbackRenderer = (context: ChatErrorInfo & {
+    reset: () => void;
+}) => React.ReactNode;
 export interface IConfig {
     appId?: string;
     disableHeader?: boolean;
     disableMedia?: boolean;
+    /** Composer attachment limits. Applies to the built-in SendInput. */
+    attachments?: {
+        /**
+         * How many files one message may carry. Defaults to 5 and is hard-capped
+         * at 10 by the stanza payload (MAX_ATTACHMENTS_PER_MESSAGE).
+         */
+        maxFiles?: number;
+        /** Per-file ceiling in MB. Omit to skip the client-side size check. */
+        maxFileSizeMb?: number;
+        /** `accept` attribute handed to the file picker. Omit to allow anything. */
+        accept?: string;
+    };
+    /** First-page PDF thumbnails inside message bubbles. */
+    pdfPreview?: {
+        /** Set false to always show the static document card. Default true. */
+        enabled?: boolean;
+        /**
+         * URL of a pdf.js worker script. Omit and pdf.js runs on the main
+         * thread, which needs no bundler-specific asset wiring - fine for
+         * thumbnails, worth overriding if your users open large documents.
+         */
+        workerSrc?: string;
+        /** Documents above this are not auto-rendered. Default 25. */
+        maxFileSizeMb?: number;
+    };
     colors?: {
         primary: string;
         secondary: string;
@@ -157,6 +201,25 @@ export interface IConfig {
         noConnection?: React.ReactNode;
         /** Shown when the user has no chat room to display. */
         noRoom?: React.ReactNode;
+        /**
+         * Shown when an uncaught render error inside the chat is caught by the
+         * SDK's error boundary (instead of white-screening the host app).
+         *
+         * Same shape as the screens above (string = centered text, React node =
+         * rendered as-is) plus a render-function form, which is what you want if
+         * the replacement screen needs its own retry control or wants to show
+         * something about the error:
+         *
+         *   fallbackScreens: {
+         *     error: ({ error, reset }) => (
+         *       <MyErrorPanel message={error.message} onRetry={reset} />
+         *     ),
+         *   }
+         *
+         * Omit it to keep the built-in calm, themed, translated screen with its
+         * own "try again" button.
+         */
+        error?: React.ReactNode | ChatErrorFallbackRenderer;
     };
     /**
      * Hide specific rooms from the room list and unread counters without
@@ -193,13 +256,35 @@ export interface IConfig {
     defaultLogin?: boolean;
     disableInteractions?: boolean;
     chatHeaderBurgerMenu?: boolean;
-    forceSetRoom?: boolean;
     roomListStyles?: React.CSSProperties;
     chatRoomStyles?: React.CSSProperties;
     noMessagesPlaceholder?: React.ComponentType;
     setRoomJidInPath?: boolean;
     disableRoomMenu?: boolean;
+    /**
+     * Hide the "Mute/Unmute notifications" toggle from the chat header menu
+     * and the room profile drawer. The toggle is only ever offered when the
+     * backend has reported a `muted` boolean for the room in the first place
+     * (see IRoom.muted) - this flag is for a host that wants to hide it
+     * outright even then, e.g. because it renders its own mute control.
+     */
+    disableRoomMute?: boolean;
     defaultRooms?: ConfigRoom[];
+    /**
+     * The "Files" tab shown in the sidebar alongside "Chats". Backed by
+     * `GET /v2/files`, which not every backend has yet, so this defaults to
+     * an auto-detecting mode rather than always-on:
+     *  - `enabled: true` always shows the tab - use this once you know your
+     *    backend has /v2/files.
+     *  - `enabled: false` always hides it.
+     *  - omitted (default): the tab shows optimistically and only hides
+     *    itself if the first files list request (when the user opens the tab)
+     *    comes back 404/501, meaning this backend doesn't have the endpoint.
+     *    No extra probe request is made just to decide this up front.
+     */
+    filesTab?: {
+        enabled?: boolean;
+    };
     refreshTokens?: {
         enabled: boolean;
         /**
@@ -227,15 +312,27 @@ export interface IConfig {
         color?: string;
         image?: string | File;
     };
-    bubleMessage?: MessageBubble;
+    /**
+     * Host logo rendered at the left of the chat header, before the back
+     * button / burger menu. A plain string is treated as an image URL and
+     * rendered as an `<img>` (32px tall, aspect preserved); any other React
+     * element is rendered as-is. Same string-or-node duality as
+     * `fallbackScreens`. Omit to render no logo (the default).
+     */
     headerLogo?: string | React.ReactElement;
+    /**
+     * Takes over the room-list burger menu. When set, the built-in
+     * Profile/Settings/Logout dropdown is not rendered at all: the same burger
+     * button just calls this handler, so the host can open its own account
+     * menu or drawer.
+     */
     headerMenu?: () => void;
+    /**
+     * Same idea for the chat header's room menu (the "more" button carrying
+     * Report and Leave). When set, that dropdown is not rendered and the
+     * button calls this handler instead.
+     */
     headerChatMenu?: () => void;
-    customRooms?: {
-        rooms: PartialRoomWithMandatoryKeys[];
-        disableGetRooms?: boolean;
-        singleRoom: boolean;
-    };
     translates?: {
         enabled: boolean;
         translations?: Iso639_1Codes;
@@ -244,11 +341,17 @@ export interface IConfig {
          * "Translate" link the reader clicks (LinkedIn-style), then renders the
          * result inline with a "Show original" toggle. Default 'auto'.
          *
-         * Neither mode calls any translation service - both only ever display
+         * 'auto' is purely a display choice: it only ever reads
          * `message.translations`, whatever arrived attached to the stanza (see
-         * `readerLocale` below for how a message gets translated in the first
-         * place). This is purely a display choice: show it immediately, or let
-         * the reader ask for it.
+         * `readerLocale` below), and never calls a translation service itself.
+         * 'manual' shows exactly the same thing on click, via the same lookup -
+         * no host function and no `endpoint` means no network request, just the
+         * translation already attached (if any). 'manual' does one thing more:
+         * on a click, if nothing is attached and the host hasn't supplied
+         * `onTranslate`, it fetches a translation from `endpoint` ONLY when the
+         * host has set that explicitly (see below) and caches the result onto
+         * `message.translations` so a second click - and 'auto' mode, if the
+         * reader switches to it - see it for free.
          */
         mode?: 'auto' | 'manual';
         /**
@@ -295,8 +398,9 @@ export interface IConfig {
         /**
          * Host-provided translation function. When set, the manual Translate
          * action calls this - wire it to your own service - instead of reading
-         * `message.translations`. Optional; omit to use only what already
-         * arrived over XMPP.
+         * `message.translations` or falling back to the built-in translate
+         * service. Optional; omit to use only what already arrived over XMPP
+         * (and, in manual mode, the fetch described on `endpoint` below).
          */
         onTranslate?: (text: string, ctx: {
             sourceLocale?: string;
@@ -306,9 +410,30 @@ export interface IConfig {
         /**
          * Host predicate deciding whether to show the Translate action for a given
          * message. When omitted, the component compares base languages (message
-         * source vs reader, region ignored) and shows the action when they differ.
+         * source vs reader, region ignored) and shows the action when they differ,
+         * AND only when something could actually answer the click (a translation
+         * is already attached, `onTranslate` is set, or `endpoint` is set below) -
+         * otherwise no Translate link is shown at all, rather than one that could
+         * only ever end in "Could not translate".
          */
         showTranslateForMessage?: (message: IMessage) => boolean;
+        /**
+         * Explicit opt-in override for the built-in translate service's URL (e.g.
+         * "https://translate.api.example.com/translate"), used by manual mode's
+         * on-demand fetch (see `mode` above) when nothing is attached to the
+         * message and the host hasn't supplied `onTranslate`.
+         *
+         * This is strictly opt-in: the built-in HTTP call is never made unless
+         * this is set explicitly - there is no default derived from
+         * `config.baseUrl`. Leave it unset to rely only on `onTranslate` and
+         * whatever translation already arrived over XMPP. The call is made
+         * directly from the browser, so a self-hosted endpoint must send
+         * `Access-Control-Allow-Origin` for this origin or the fetch is blocked
+         * with no error shown beyond the "Could not translate" retry link; if you
+         * can't set that on the endpoint, use `onTranslate` and proxy the call
+         * through your own backend instead.
+         */
+        endpoint?: string;
     };
     /**
      * Static UI i18n (interface captions like "Search...", "Type message").
@@ -322,10 +447,20 @@ export interface IConfig {
         locale?: string;
         strings?: Record<string, string>;
     };
+    /**
+     * Hide every control that mutates a room's configuration: the room avatar
+     * upload/remove overlay, the "Delete chat" entry in the chat-details menu,
+     * the add-members action and the per-member moderator menu (appoint as
+     * admin / remove member). Read-only room details stay visible.
+     */
     disableRoomConfig?: boolean;
     disableProfilesInteractions?: boolean;
+    /**
+     * Hide the member-count subtitle in the chat header ("N users", plus the
+     * online-users popover that hangs off it). The 1:1 online/offline line is
+     * a presence state, not a count, so it is unaffected.
+     */
     disableUserCount?: boolean;
-    clearStoreBeforeInit?: boolean;
     disableSentLogic?: boolean;
     initBeforeLoad?: boolean;
     initBeforeLoadAuth?: {
@@ -351,7 +486,6 @@ export interface IConfig {
         enabled: boolean;
         element: any;
     };
-    botMessageAutoScroll?: boolean;
     messageTextFilter?: {
         enabled: boolean;
         filterFunction: (text: string) => string;
@@ -394,6 +528,13 @@ export interface IConfig {
             /** `reply.questionId`, or the button's index when the bot sent none. */
             questionId: string;
         }) => void | Promise<void>;
+        /**
+         * Called when the SDK's error boundary catches an uncaught render error,
+         * i.e. the crash that would otherwise have taken the host app down with
+         * it. Wire it to your own crash reporter (Sentry, Datadog, ...). A throw
+         * inside this handler is caught and logged, never rethrown.
+         */
+        onError?: (event: ChatErrorInfo) => void;
     };
     disableTypingIndicator?: boolean;
     blockMessageSendingWhenProcessing?: boolean | {

package/dist/types/models/file.model.d.ts

@@ -0,0 +1,20 @@
+export type ApiFile = {
+    _id: string;
+    userId: string;
+    ownerKey?: string;
+    roomName?: string;
+    location: string;
+    locationPreview?: string;
+    originalname: string;
+    filename?: string;
+    mimetype?: string;
+    size?: number;
+    expiresAt?: number;
+    isPrivate?: boolean;
+    duration?: string;
+    encrypted?: boolean;
+    key?: string;
+    iv?: string;
+    createdAt?: string;
+    updatedAt?: string;
+};