@ethora/chat-component 26.9.8 → 26.10.3

package/dist/main.js

@@ -1,4 +1,4 @@
-import { bh as a, bi as r, bj as b, bk as o, bl as t, bm as u, bn as i, bo as p, bp as h, bq as n, br as l, bs as d, bt as m, L as y, bu as T, bv as f, bw as I, bx as R, by as g, bz as c, bA as C, bB as A, bC as E, al as k, am as Q, bD as v, bE as F } from "./main-BnLtessp.js";
+import { br as a, bs as r, bt as b, bu as o, bv as t, bw as u, bx as i, by as p, bz as h, bA as n, bB as d, i as l, bC as y, S as I, bD as T, bE as f, bF as m, bG as R, bH as g, bI as c, bJ as C, bK as A, bL as E, aq as F, ar as M, bM as Q, bN as k } from "./main-CghdNDlB.js";
 export {
   a as AuthTestIds,
   r as Chat,
@@ -10,21 +10,21 @@ export {
   p as applyTypography,
   h as clearTypography,
   n as formatFingerprint,
-  l as handleQRChatId,
-  d as isE2eeEnabled,
-  m as isRefreshFatalError,
-  y as logoutService,
+  d as handleQRChatId,
+  l as isE2eeEnabled,
+  y as isRefreshFatalError,
+  I as logoutService,
   T as omemo,
   f as parseQuickReplies,
-  I as refreshAuthTokens,
+  m as refreshAuthTokens,
   R as refreshAuthTokensQuietly,
   g as resendMessage,
   c as useInAppNotifications,
   C as useIsUserOnline,
   A as usePushNotifications,
   E as useQRCodeChat,
-  k as useRoomMute,
-  Q as useRoomPresence,
-  v as useTypography,
-  F as useUnread
+  F as useRoomMute,
+  M as useRoomPresence,
+  Q as useTypography,
+  k as useUnread
 };

package/dist/networking/api-requests/auth.api.d.ts

@@ -5,10 +5,16 @@ export declare function loginEmail(email: string, password: string): Promise<imp
     refreshToken: string;
     token: string;
     fileToken?: string;
-}, any, {}>>;
-export declare function loginSocial(idToken: string, accessToken: string, loginType: string, authToken?: string): Promise<import('axios').AxiosResponse<any, any, {}>>;
-export declare function registerSocial(idToken: string, accessToken: string, authToken: string, loginType: string, signUpPlan?: string): Promise<import('axios').AxiosResponse<any, any, {}>>;
-export declare function checkEmailExist(email: string): Promise<import('axios').AxiosResponse<any, any, {}>>;
+}, any, {}, any>>;
+export declare function loginSocial(idToken: string, accessToken: string, loginType: string, authToken?: string): Promise<import('axios').AxiosResponse<any, any, {}, any>>;
+export declare function registerSocial(idToken: string, accessToken: string, authToken: string, loginType: string, signUpPlan?: string): Promise<import('axios').AxiosResponse<any, {
+    idToken: string;
+    accessToken: string;
+    loginType: string;
+    authToken: string;
+    signupPlan: string;
+}, {}, any>>;
+export declare function checkEmailExist(email: string): Promise<import('axios').AxiosResponse<any, any, {}, any>>;
 export declare function loginViaJwt(clientToken: string): Promise<User>;
 export declare const signInWithGoogle: () => Promise<{
     user?: undefined;
@@ -27,6 +33,8 @@ export interface UploadFileOptions {
      * BEFORE the secure/legacy split so both routes carry it.
      */
     clientEncrypted?: boolean;
+    /** Upload progress for this request, 0 to 100. */
+    onProgress?: (percent: number) => void;
 }
-export declare function uploadFile(formData: FormData, activeRoomJID: string, options?: UploadFileOptions): Promise<import('axios').AxiosResponse<any, any, {}>>;
+export declare function uploadFile(formData: FormData, activeRoomJID: string, options?: UploadFileOptions): Promise<import('axios').AxiosResponse<any, FormData, {}, any>>;
 export declare function ensureUserFromMy(user: User | null | undefined): Promise<User | null>;

package/dist/networking/api-requests/user.api.d.ts

@@ -4,10 +4,10 @@ interface GetMyUserOptions {
     endpoint?: string;
     signal?: AbortSignal;
 }
-export declare function getDocuments(walletAddress: string): Promise<import('axios').AxiosResponse<any, any, {}>>;
-export declare function getExportMyData(): Promise<import('axios').AxiosResponse<any, any, {}>>;
-export declare function deleteMe(): Promise<import('axios').AxiosResponse<any, any, {}>>;
-export declare function updateMe(data: any): Promise<import('axios').AxiosResponse<any, any, {}>>;
+export declare function getDocuments(walletAddress: string): Promise<import('axios').AxiosResponse<any, any, {}, any>>;
+export declare function getExportMyData(): Promise<import('axios').AxiosResponse<any, any, {}, any>>;
+export declare function deleteMe(): Promise<import('axios').AxiosResponse<any, any, {}, any>>;
+export declare function updateMe(data: any): Promise<import('axios').AxiosResponse<any, any, {}, any>>;
 export declare function updateProfile(fd: FormData): Promise<{
     user: User;
 }>;

package/dist/networking/callKeyStanza.d.ts

@@ -0,0 +1,7 @@
+import { Element } from 'ltx';
+/**
+ * Claims a decrypted <call-key> signal, feeding the media key into the call
+ * slice. Returns true when it handled the stanza (so the caller stops
+ * dispatching it to the chat handlers).
+ */
+export declare function onCallKeyStanza(stanza: Element): boolean;

package/dist/networking/deliveryReceiptBatcher.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Coalesces XEP-0184 delivery receipts per room.
+ *
+ * Per room, the first message enqueued while no window is open is acked at
+ * once (leading edge). Everything that arrives during the following
+ * `coalesceMs` window is held, keeping only the newest message by timestamp,
+ * and that one is acked when the window closes (trailing edge). A receipt
+ * for a message implies delivery of everything before it, so one stanza can
+ * stand for a whole burst or a whole history replay.
+ */
+export interface DeliveryReceiptBatcherOptions {
+    /** Sends one `<received/>` for `messageId` in `roomJid`. */
+    send: (roomJid: string, messageId: string) => void;
+    /** Injectable timer for tests. */
+    setTimer?: (fn: () => void, ms: number) => unknown;
+    /** Injectable timer cancel for tests. */
+    clearTimer?: (handle: unknown) => void;
+    /** Injectable clock, used when `enqueue` gets no timestamp. */
+    now?: () => number;
+    /** Bound on remembered acked ids (oldest forgotten first). */
+    maxAckedIds?: number;
+}
+export declare class DeliveryReceiptBatcher {
+    private readonly options;
+    private readonly rooms;
+    private readonly acked;
+    private readonly maxAckedIds;
+    private readonly setTimer;
+    private readonly clearTimer;
+    private readonly now;
+    constructor(options: DeliveryReceiptBatcherOptions);
+    /**
+     * Queues a receipt for `messageId`. `coalesceMs` is the window length used
+     * when a window opens; 0 sends every call straight away.
+     */
+    enqueue(roomJid: string, messageId: string, coalesceMs: number, timestamp?: number): void;
+    /** Cancels the window and drops the held message for one room. */
+    clearRoom(roomJid: string): void;
+    /**
+     * Cancels every window and drops every held message (disconnect). Acked
+     * ids are kept so a reconnect replay does not ack them twice.
+     */
+    clear(): void;
+    /** Full teardown: timers, held messages and the acked-id memory. */
+    destroy(): void;
+    /** Test/inspection helper: number of rooms with an open window. */
+    openWindowCount(): number;
+    private stateFor;
+    private ack;
+    private onWindowEnd;
+    private cancel;
+    private remember;
+}

package/dist/networking/displayedMarkerThrottle.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Rate-limits XEP-0333 `<displayed/>` markers for one room. The first mark
+ * goes out at once; marks inside `minIntervalMs` of the last send are held
+ * and only the newest id is sent when the interval ends (trailing edge), so
+ * the final read watermark is never lost. `dispose()` sends a held mark
+ * immediately, then cancels the timer.
+ */
+export interface DisplayedMarkerThrottleOptions {
+    minIntervalMs: number;
+    send: (messageId: string) => void;
+    now?: () => number;
+    setTimer?: (fn: () => void, ms: number) => unknown;
+    clearTimer?: (handle: unknown) => void;
+}
+export declare class DisplayedMarkerThrottle {
+    private readonly options;
+    private lastSentAt;
+    private pendingId;
+    private timer;
+    private disposed;
+    private readonly now;
+    private readonly setTimer;
+    private readonly clearTimer;
+    constructor(options: DisplayedMarkerThrottleOptions);
+    mark(messageId: string): void;
+    dispose(): void;
+    private onTimer;
+    private fire;
+}

package/dist/networking/receiptsPolicy.d.ts

@@ -0,0 +1,32 @@
+import { ReceiptsConfig } from '../types/models/config.model';
+import { IMessage, IRoom } from '../types/types';
+export declare const RECEIPTS_DEFAULTS: {
+    mode: "auto";
+    deliveryMaxRoomSize: number;
+    readMaxRoomSize: number;
+    maxAgeDays: number;
+    coalesceMs: number;
+};
+export interface ResolvedReceiptsConfig {
+    mode: 'auto' | 'all' | 'off';
+    deliveryMaxRoomSize: number;
+    readMaxRoomSize: number;
+    maxAgeDays: number;
+    coalesceMs: number;
+}
+/** Fills every unset or invalid option with its default. */
+export declare const resolveReceiptsConfig: (cfg?: ReceiptsConfig | null) => ResolvedReceiptsConfig;
+/**
+ * Other members of the room (the sender excluded). The larger of the true
+ * `usersCnt` and the loaded `members` list wins. 0 when the size is unknown.
+ */
+export declare const roomOtherMembers: (room?: Pick<IRoom, "usersCnt" | "members"> | null) => number;
+/** Timestamp of a message in ms (date, timestamp, then id), 0 when unreadable. */
+export declare const messageTimestamp: (message: Pick<IMessage, "id" | "date" | "timestamp">) => number;
+/**
+ * Whether this client should send a XEP-0184 `<received/>` for `message`.
+ * The caller has already excluded our own messages and MAM/echo duplicates.
+ */
+export declare const shouldSendDelivery: (room: Pick<IRoom, "type" | "usersCnt" | "members"> | null | undefined, message: Pick<IMessage, "id" | "date" | "timestamp" | "isSystemMessage">, cfg: ResolvedReceiptsConfig, now: number) => boolean;
+/** Whether this client should send a XEP-0333 `<displayed/>` for the room. */
+export declare const shouldSendRead: (room: Pick<IRoom, "type" | "usersCnt" | "members"> | null | undefined, cfg: ResolvedReceiptsConfig) => boolean;

package/dist/networking/stanzaHandlers.d.ts

@@ -4,9 +4,11 @@ import { default as XmppClient } from './xmppClient';
 declare const onRealtimeMessage: (stanza: Element, xmppClient?: XmppClient) => Promise<IMessage>;
 declare const onReactionMessage: (stanza: Element) => Promise<void>;
 declare const onDeleteMessage: (stanza: Element) => Promise<void>;
+declare const onReceivedReceipt: (stanza: Element) => Promise<void>;
+declare const onDisplayedMarker: (stanza: Element) => Promise<void>;
 declare const onEditMessage: (stanza: Element) => Promise<void>;
 declare const onReactionHistory: (stanza: any) => Promise<void>;
-declare const onMessageHistory: (stanza: any) => Promise<void>;
+declare const onMessageHistory: (stanza: any, xmppClient?: XmppClient) => Promise<void>;
 declare const handleComposing: (stanza: Element, currentUser: string) => Promise<void>;
 declare const onPresenceInRoom: (stanza: Element | any) => void;
 declare const onChatInvite: (stanza: Element, client: XmppClient) => Promise<void>;
@@ -31,4 +33,4 @@ export type XMPPErrorInfo = {
 export declare const handleErrorMessageStanza: (stanza: Element) => XMPPErrorInfo | null;
 declare const onUserUpdate: (stanza: Element, xmppWs?: XmppClient) => Promise<void>;
 declare const onChatUpdate: (stanza: Element, xmppWs?: XmppClient) => Promise<void>;
-export { onRealtimeMessage, onMessageHistory, onPresenceInRoom, onReactionHistory, onGetLastMessageArchive, handleComposing, onGetChatRooms, onNewRoomCreated, onGetMembers, onGetRoomInfo, onDeleteMessage, onEditMessage, onReactionMessage, onChatInvite, onRoomKicked, onRoomMembershipChange, onMembersRefreshSignal, onMessageError, onUserUpdate, onChatUpdate, };
+export { onRealtimeMessage, onMessageHistory, onPresenceInRoom, onReactionHistory, onGetLastMessageArchive, handleComposing, onGetChatRooms, onNewRoomCreated, onGetMembers, onGetRoomInfo, onDeleteMessage, onEditMessage, onReactionMessage, onReceivedReceipt, onDisplayedMarker, onChatInvite, onRoomKicked, onRoomMembershipChange, onMembersRefreshSignal, onMessageError, onUserUpdate, onChatUpdate, };

package/dist/networking/xmpp/sendDisplayedMarker.xmpp.d.ts

@@ -0,0 +1,2 @@
+import { Client } from '@xmpp/client';
+export declare function sendDisplayedMarker(client: Client, messageId: string, roomJid: string): void;

package/dist/networking/xmpp/sendMediaMessage.xmpp.d.ts

@@ -1,4 +1,5 @@
 import { Client } from '@xmpp/client';
+import { IMentionSpan } from '../../types/types';
 /**
  * What <body> carries in an e2ee room: the key material for each sealed
  * attachment, in the same order as `attachments` / the flat fields on <data>.
@@ -9,5 +10,12 @@ import { Client } from '@xmpp/client';
 export interface E2eeMediaBody {
     v: 1;
     keys: string[];
+    /**
+     * The text typed with the files. It lives here, inside the envelope, and
+     * nowhere on <data>, so an e2ee caption is never readable in transit.
+     * Older readers only look at `keys` and ignore the rest.
+     */
+    caption?: string;
+    captionMentions?: IMentionSpan[];
 }
 export declare function sendMediaMessage(client: Client, roomJID: string, data: any, id: string): Promise<void>;

package/dist/networking/xmpp/sendReceivedReceipt.xmpp.d.ts

@@ -0,0 +1,2 @@
+import { Client } from '@xmpp/client';
+export declare function sendReceivedReceipt(client: Client, messageId: string, roomJid: string): void;

package/dist/networking/xmppClient.d.ts

@@ -64,6 +64,7 @@ export declare class XmppClient implements XmppClientInterface {
     private historyQueueWorkerScheduled;
     private historyQueueWorkerTimer;
     private roomHistoryEpoch;
+    private readonly deliveryBatcher;
     private criticalSendUntil;
     private activeRoomBoostUntil;
     private sendStartedAtById;
@@ -313,6 +314,10 @@ export declare class XmppClient implements XmppClientInterface {
     deleteMessageStanza(room: string, msgId: string): void;
     editMessageStanza(room: string, msgId: string, text: string): void;
     sendMessageReactionStanza(messageId: string, roomJid: string, reactionsList: string[], reactionSymbol?: any): void;
+    sendReceivedReceiptStanza(messageId: string, roomJid: string): void;
+    sendDisplayedMarkerStanza(messageId: string, roomJid: string): void;
+    queueDeliveryReceipt(roomJid: string, messageId: string, timestamp?: number, coalesceMs?: number): void;
+    sendHistoryReceivedReceiptStanza(roomJid: string, messageId: string, timestamp?: number, coalesceMs?: number): void;
     sendTypingRequestStanza(chatId: string, fullName: string, start: boolean): void;
     getChatsPrivateStoreRequestStanza: () => Promise<Record<string, string | number> | null>;
     actionSetTimestampToPrivateStoreStanza(chatId: string, timestamp: number, chats?: string[]): Promise<void>;

package/dist/roomStore/callSlice.d.ts

@@ -11,6 +11,8 @@ export interface CallState {
     callId: string | null;
     peerXmppUsername: string | null;
     token: string | null;
+    e2eeKey: string | null;
+    e2eeKeyCallId: string | null;
     error: string | null;
     startedAt: number | null;
     connectedAt: number | null;
@@ -33,6 +35,9 @@ export declare const startOutgoingCall: import('@reduxjs/toolkit').ActionCreator
     roomJid: string;
     token: string;
     callId?: string | null;
-}, "call/setOutgoingCallToken">, acceptIncomingCall: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"call/acceptIncomingCall">, declineIncomingCall: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"call/declineIncomingCall">, endCall: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"call/endCall">, setCallError: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<string, "call/setCallError">, setCallPhase: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<CallPhase, "call/setCallPhase">, setCallKind: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<CallKind, "call/setCallKind">, resetCall: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"call/resetCall">;
+}, "call/setOutgoingCallToken">, acceptIncomingCall: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"call/acceptIncomingCall">, declineIncomingCall: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"call/declineIncomingCall">, endCall: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"call/endCall">, setCallError: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<string, "call/setCallError">, setCallPhase: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<CallPhase, "call/setCallPhase">, setCallKind: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<CallKind, "call/setCallKind">, setCallE2eeKey: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    key: string;
+    callId: string | null;
+}, "call/setCallE2eeKey">, resetCall: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"call/resetCall">;
 declare const _default: import('redux').Reducer<import('immer').WritableDraft<CallState>>;
 export default _default;

package/dist/roomStore/index.d.ts

@@ -44,6 +44,16 @@ export declare const restoreUsersSetForRehydrate: (usersSet: Record<string, any>
  * /chats/my response re-seeds it.
  */
 export declare const resetSessionRoomState: (roomsMap: Record<string, IRoom>) => Record<string, IRoom>;
+/**
+ * A transcript cached by a build that did not persist reactions repaints every
+ * bubble without its reaction chips, and the archive will not re-deliver them
+ * for the cached middle (the latest page is merged onto the cache and the
+ * backfill resumes from the cache's oldest message). Such a cache is dropped
+ * once - the room shell stays, the transcript is refetched from MAM - exactly
+ * like the cache-budget eviction, except the paging cursors go with it: a
+ * stale first/last id would make the backfill start behind the dropped range.
+ */
+export declare const dropReactionlessCaches: (roomsMap: Record<string, IRoom>) => Record<string, IRoom>;
 export declare const limitMessagesTransform: import('redux-persist').Transform<any, any, Record<string, any>, Record<string, any>>;
 export declare const scrubSensitiveChatStateTransform: import('redux-persist').Transform<any, any, Record<string, any>, Record<string, any>>;
 export declare const sanitizeRoomsStateTransform: import('redux-persist').Transform<any, any, Record<string, any>, Record<string, any>>;

package/dist/roomStore/roomsSlice.d.ts

@@ -1,4 +1,4 @@
-import { AddRoomMessageAction, ApiRoom, EditAction, IMessage, IRoom, ReactionAction, RoomMember, Translation } from '../types/types';
+import { AddRoomMessageAction, ApiRoom, EditAction, IAttachment, 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
@@ -129,7 +129,13 @@ export declare const addRoom: import('@reduxjs/toolkit').ActionCreatorWithOption
 }, "roomMessages/setMessageSendFailed">, setMessageSendRetrying: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     roomJID: string;
     messageId: string;
-}, "roomMessages/setMessageSendRetrying">, editRoomMessage: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+}, "roomMessages/setMessageSendRetrying">, setMediaUploadState: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    roomJID: string;
+    messageId: string;
+    attachments?: IAttachment[];
+    pending?: boolean;
+    failed?: boolean;
+}, "roomMessages/setMediaUploadState">, editRoomMessage: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     roomJID: string;
     messageId: string;
     text: string;
@@ -182,7 +188,20 @@ export declare const addRoom: import('@reduxjs/toolkit').ActionCreatorWithOption
 }, "roomMessages/setMemberOffline">, setChatUiVisible: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<boolean, "roomMessages/setChatUiVisible">, setRoomRole: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     chatJID: string;
     role: string;
-}, "roomMessages/setRoomRole">, setReactions: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<ReactionAction, "roomMessages/setReactions">, setLogoutState: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"roomMessages/setLogoutState">, setActiveMessage: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+}, "roomMessages/setRoomRole">, setReactions: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<ReactionAction, "roomMessages/setReactions">, setReceivedReceipt: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    roomJID: string;
+    messageId: string;
+    fromXmppUsername: string;
+    timestamp: number;
+}, "roomMessages/setReceivedReceipt">, setReceivedWatermark: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    roomJID: string;
+    xmppUsername: string;
+    messageId: string;
+}, "roomMessages/setReceivedWatermark">, setDisplayedMarker: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    roomJID: string;
+    xmppUsername: string;
+    messageId: string;
+}, "roomMessages/setDisplayedMarker">, setLogoutState: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"roomMessages/setLogoutState">, setActiveMessage: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     id: string;
     chatJID: string;
 }, "roomMessages/setActiveMessage">, setCloseActiveMessage: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{

package/dist/styles/motion.d.ts

@@ -20,7 +20,17 @@ export declare const MOTION_BASE_MS = 220;
 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;
+/** Skeleton timing: one sweep cycle, and the delay before anything shows. */
+export declare const SHIMMER_SWEEP_MS = 2000;
+export declare const SHIMMER_DELAY_MS = 120;
+export declare const SHIMMER_FADE_IN_MS = 240;
+/**
+ * The loading band drifts left to right (reading direction). Keyframes move
+ * the band's own transform, not background-position, so the browser can run
+ * it on the compositor. The band is 60% of the host wide, so -100% parks it
+ * just off the left edge and 166.67% just off the right edge.
+ */
+export declare const shimmerSweep: 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
@@ -47,7 +57,17 @@ export declare const fadeInAnimation: import('styled-components').RuleSet<object
 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). */
+/**
+ * Loading skeleton: a calm, slightly tinted base with one soft band sweeping
+ * left to right every 2s. The band fades in with its own transparent edges,
+ * so there is no hard leading or trailing line. Nothing shows for the first
+ * 120ms, so an image that arrives quickly never flashes a placeholder.
+ *
+ * The host must be positioned (`position: relative` or `absolute`, set by the
+ * host itself so this helper cannot override it); the band is an ::after
+ * clipped by the host's `overflow: hidden`. Reduced motion keeps only the
+ * static base.
+ */
 export declare const shimmerBackground: import('styled-components').RuleSet<object>;
 export declare const fadeOut: import('styled-components/dist/models/Keyframes').default;
 export declare const scaleOut: import('styled-components/dist/models/Keyframes').default;

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

@@ -23,6 +23,9 @@ export interface IAttachment {
     /** Bytes, as a string - that is how it travels on the wire. */
     size?: string;
     duration?: string;
+    /** Natural pixel size, when the storage recorded it. Sizes the solo preview box. */
+    width?: number;
+    height?: number;
     ownerKey?: string;
     userId?: string;
     createdAt?: string;
@@ -30,4 +33,20 @@ export interface IAttachment {
     expiresAt?: string;
     isVisible?: boolean;
     isPrivate?: boolean;
+    /**
+     * Local-only state of an outgoing attachment, set by the sender while its
+     * message is still being sent. Never written to the wire.
+     *   uploading - the file is going up (or every file is up and the message
+     *               is waiting on its siblings); `uploadProgress` is 0 to 100.
+     *   failed    - this file did not upload; the message is held until it
+     *               is retried.
+     */
+    uploadStatus?: 'uploading' | 'failed';
+    uploadProgress?: number;
+    /**
+     * Local-only `blob:` URL of the sender's own picture, so an outgoing image
+     * shows at once and stays on screen while the server copy loads. Never
+     * written to the wire.
+     */
+    localUrl?: string;
 }

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

@@ -45,6 +45,32 @@ export interface VideoCallsConfig {
     showScreenShare?: boolean;
     /** Custom icons for the call control bar / ring screen. See VideoCallIcons. */
     icons?: VideoCallIcons;
+    /**
+     * End-to-end encrypt the call media (LiveKit insertable streams). The media
+     * key is exchanged over OMEMO - the same channel the chat uses - so the SFU
+     * and the server never see it, which makes the call private even from the
+     * operator. The trust model is OMEMO's (blind-trust-before-verification on
+     * device fingerprints).
+     *
+     * Requires the chat's own encryption to be on (`config.e2ee.enabled`) and a
+     * room the backend marked `e2ee`. A call that cannot set E2EE up - an
+     * unsupported browser, an insecure (non-HTTPS) context, or a peer with no
+     * published OMEMO device - falls back to a normal (transport-encrypted)
+     * call rather than failing.
+     */
+    e2ee?: {
+        enabled: boolean;
+        /**
+         * Supplies the Web Worker LiveKit needs for insertable-stream E2EE. The
+         * library stays bundler-agnostic, so the host app creates it, typically:
+         *   () => new Worker(
+         *     new URL('livekit-client/e2ee-worker', import.meta.url),
+         *     { type: 'module' }
+         *   )
+         * Without a factory, call E2EE stays off.
+         */
+        workerFactory?: () => Worker;
+    };
 }
 export interface FBConfig {
     apiKey: string;
@@ -134,6 +160,32 @@ export type ChatErrorFallbackRenderer = (context: ChatErrorInfo & {
     reset: () => void;
 }) => React.ReactNode;
 export type ChatColorScheme = 'light' | 'dark' | 'system';
+/**
+ * Delivery (XEP-0184 `<received/>`) and read (XEP-0333 `<displayed/>`)
+ * receipts. The client always DISPLAYS the receipts it receives; these
+ * options only control what this client SENDS, so large rooms do not turn
+ * every message into a broadcast to every occupant.
+ *
+ * - `mode`: `'auto'` (default) sends delivery receipts only in rooms of up to
+ *   `deliveryMaxRoomSize` other members and read markers only in rooms of up
+ *   to `readMaxRoomSize` other members; `'all'` always sends (still coalesced);
+ *   `'off'` never sends a delivery or read signal.
+ * - `deliveryMaxRoomSize` / `readMaxRoomSize`: room size (other members, the
+ *   sender excluded) above which the signal is skipped in `'auto'`. Private
+ *   1:1 rooms and rooms whose size is unknown always send.
+ * - `maxAgeDays`: in `'auto'`, messages older than this are not acknowledged
+ *   (old history replays do not generate receipts).
+ * - `coalesceMs`: delivery receipts are sent at most once per window per
+ *   room; the first one goes out at once, the rest of the window is collapsed
+ *   into one receipt for the newest message.
+ */
+export interface ReceiptsConfig {
+    mode?: 'auto' | 'all' | 'off';
+    deliveryMaxRoomSize?: number;
+    readMaxRoomSize?: number;
+    maxAgeDays?: number;
+    coalesceMs?: number;
+}
 export interface IConfig {
     appId?: string;
     /**
@@ -155,8 +207,8 @@ export interface IConfig {
     /** 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).
+         * How many files one message may carry. Defaults to 10, which is also the
+         * hard cap set by the stanza payload (MAX_ATTACHMENTS_PER_MESSAGE).
          */
         maxFiles?: number;
         /** Per-file ceiling in MB. Omit to skip the client-side size check. */
@@ -527,6 +579,8 @@ export interface IConfig {
     };
     newArch?: boolean;
     disableLastRead?: boolean;
+    /** Delivery and read receipt sending policy. See ReceiptsConfig. */
+    receipts?: ReceiptsConfig;
     qrUrl?: string;
     secondarySendButton?: {
         enabled: boolean;

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

@@ -11,6 +11,8 @@ export interface NewMessageLabelProps {
 export interface DecoratedMessage {
     message: IMessage;
     showDateLabel: boolean;
+    /** False when the next row is the same sender's message (a run continues). */
+    isLastInGroup?: boolean;
 }
 export interface ScrollControllerApi {
     scrollToBottom: () => void;

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

@@ -55,6 +55,7 @@ export interface IMessage {
     mainMessage?: string;
     reply?: IReply[];
     reaction?: Record<string, ReactionMessage>;
+    receivedBy?: Record<string, number>;
     fileName?: string;
     translations?: TranslationObject;
     langSource?: Iso639_1Codes;
@@ -71,6 +72,8 @@ export interface IMessage {
     xmppFrom?: string;
     quickReplies?: unknown;
     mentions?: IMentionSpan[];
+    caption?: string;
+    captionMentions?: IMentionSpan[];
     callLog?: {
         callId: string;
         direction: 'outgoing' | 'incoming';
@@ -95,6 +98,12 @@ export interface MessageProps {
     message: IMessage;
     isUser: boolean;
     isReply: boolean;
+    /**
+     * False when the next message comes from the same sender (a run). The last
+     * message of a run carries the bubble tail and the larger gap below it.
+     * Omitted means last.
+     */
+    isLastInGroup?: boolean;
 }
 export interface MediaMessageType {
 }

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

@@ -4,4 +4,23 @@ export interface ModalFile {
     fileName: string;
     fileURL: string;
     mimetype: string;
+    /** Optional low-resolution copy, used for viewer thumbnails. */
+    previewURL?: string;
+    /** Optional message timestamp (ISO) shown in the viewer header. */
+    date?: string;
+    /** Optional sender shown in the viewer header. */
+    sender?: {
+        id?: string;
+        username?: string;
+        name?: string;
+        firstName?: string;
+        lastName?: string;
+        photo?: string;
+    };
+    /**
+     * Optional sibling files (e.g. a whole album) the viewer can page through
+     * when the room's loaded messages do not already contain this file.
+     * Single-file callers leave it out.
+     */
+    siblings?: ModalFile[];
 }

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

@@ -62,6 +62,8 @@ export interface IRoom {
     composingList?: string[];
     lastViewedTimestamp?: number;
     unreadBaselineTimestamp?: number;
+    lastDisplayedByUser?: Record<string, string>;
+    lastReceivedByUser?: Record<string, string>;
     unreadMessages?: number;
     /**
      * Unread count the server reported for this room in `GET /v1/chats/my`
@@ -80,6 +82,8 @@ export interface IRoom {
         firstMessageTimestamp?: number;
     };
     historyComplete?: boolean;
+    /** Persisted-cache stamp: the saved transcript includes its reactions. */
+    reactionsCached?: boolean;
     historyPreloadState?: 'idle' | 'loading' | 'partial' | 'done' | 'error';
     unreadCapped?: boolean;
     /**
@@ -109,6 +113,19 @@ export interface ApiRoomLastMessage {
     isOwn?: boolean;
     senderFirstName?: string;
     senderLastName?: string;
+    /**
+     * Media fields, present when the last message is a file. Any subset may be
+     * sent: a thin payload can carry just `mimetype` and `fileName`.
+     */
+    isMediafile?: string | boolean;
+    mimetype?: string;
+    fileName?: string;
+    originalName?: string;
+    location?: string;
+    locationPreview?: string;
+    duration?: string | number;
+    attachments?: unknown;
+    clientEncrypted?: string | boolean;
 }
 export interface ApiRoom {
     name: string;

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

@@ -104,6 +104,9 @@ export interface XmppClientInterface {
     sendMessage(roomJID: string, firstName: string, lastName: string, photo: string, walletAddress: string, userMessage: string, notDisplayedValue?: string, isReply?: boolean, showInChannel?: boolean, mainMessage?: string, customId?: string): void;
     deleteMessageStanza(room: string, msgId: string): void;
     editMessageStanza(room: string, msgId: string, text: string): void;
+    sendReceivedReceiptStanza(messageId: string, roomJid: string): void;
+    sendDisplayedMarkerStanza(messageId: string, roomJid: string): void;
+    sendHistoryReceivedReceiptStanza(roomJid: string, messageId: string): void;
     sendTypingRequestStanza(chatId: string, fullName: string, start: boolean): void;
     getChatsPrivateStoreRequestStanza(): Promise<any>;
     actionSetTimestampToPrivateStoreStanza(chatId: string, timestamp: number, chats?: string[]): Promise<void>;