@ethora/chat-component 26.9.8 → 26.10.1

package/dist/helpers/lastMessagePreview.d.ts

@@ -0,0 +1,55 @@
+import { LastMessage } from '../types/types';
+/**
+ * What the room list draws for a media last message.
+ *
+ * One derivation for every source of a last message: the live stanza that
+ * updates roomsSlice, the history loaded from MAM, and the flattened
+ * `lastMessage` the backend embeds in `GET /chats/my`. All three reach the row
+ * as the same loose message object, and since multi-attachment messages the
+ * file fields may sit in `attachments` only, with no top level `location` or
+ * `mimetype`, so the row reads through getMessageAttachments like the bubble.
+ */
+export type MediaPreviewKind = 'image' | 'video' | 'voice' | 'audio' | 'file'
+/** Media of unknown type: a thin backend payload that only says "media". */
+ | 'attachment' | 'sealed';
+export interface MediaPreview {
+    kind: MediaPreviewKind;
+    /** How many attachments the message carries (at least 1). */
+    count: number;
+    /** Thumbnail source, before the viewer's file token is appended. */
+    thumbUrl?: string;
+    /** The single file's name, for the file kind. */
+    fileName?: string;
+    /** "0:12" for a voice message or audio file, when the duration is known. */
+    durationText?: string;
+    /** The text the sender typed next to the media, if any. */
+    caption?: string;
+}
+type PreviewSource = Partial<LastMessage> & {
+    attachments?: unknown;
+    fileName?: string;
+    location?: string;
+    /** The caption the sender typed with the files, carried on the message. */
+    caption?: unknown;
+    duration?: unknown;
+    mediaDuration?: unknown;
+};
+/** True when the last message should render as media rather than text. */
+export declare const hasMediaPreview: (message?: PreviewSource | null) => boolean;
+/**
+ * `sealed` is true for an e2ee room or a message flagged `clientEncrypted`.
+ * Sealed content never gets a thumbnail: the server holds ciphertext, so the
+ * row shows the icon and the label only.
+ */
+export declare const deriveMediaPreview: (message?: PreviewSource | null, options?: {
+    sealed?: boolean;
+    senderNames?: string[];
+}) => MediaPreview | undefined;
+/**
+ * Which message the room row previews: the newest real message already in the
+ * room's `messages[]` (a live stanza or history), else the backend's
+ * `lastMessage` seed. Entries with neither text nor media (markers, receipts,
+ * state-only stanzas) are skipped.
+ */
+export declare const pickPreviewSource: <T extends PreviewSource>(messages: T[] | undefined, lastMessage?: T | null) => T | undefined;
+export {};

package/dist/helpers/mapWithConcurrency.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Runs `worker` over `items` with at most `limit` calls in flight, and
+ * resolves with the results in INPUT order, whatever order the calls finish
+ * in. Workers that throw are reported as rejected entries instead of
+ * aborting the rest of the batch, so one failed upload never stops its
+ * siblings.
+ */
+export declare function mapWithConcurrency<T, R>(items: readonly T[], limit: number, worker: (item: T, index: number) => Promise<R>): Promise<PromiseSettledResult<R>[]>;

package/dist/helpers/mediaBox.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Pure sizing helpers for in-bubble media. Kept free of React and the DOM so
+ * the rules (clamping, never upscaling, duration formatting) are testable.
+ */
+/**
+ * Reference box a solo picture is fitted into. It is the largest the
+ * responsive media width ever gets (see MEDIA_WIDTH_CSS), so a picture is
+ * never upscaled past what the widest pane could show; the real, smaller cap
+ * for the current pane is applied in CSS from the shared width variable.
+ */
+export declare const SOLO_IMAGE_MAX_WIDTH_PX = 560;
+export declare const SOLO_IMAGE_MAX_HEIGHT_PX = 784;
+/** Box used while a solo image's dimensions are still unknown: 4:3. */
+export declare const SOLO_DEFAULT_BOX: {
+    readonly width: 560;
+    readonly height: 420;
+};
+/** Box used while a solo video's dimensions are unknown: 16:9. */
+export declare const SOLO_VIDEO_DEFAULT_BOX: {
+    readonly width: 560;
+    readonly height: 315;
+};
+/**
+ * The ONE width of the media block of a message: the album grid, a solo
+ * picture or video and the file cards under them all share it.
+ *
+ * `--ethora-pane-w` is the width of the message list pane (not the
+ * viewport), written by the message list's ResizeObserver, so a chat embedded
+ * in a narrow host sizes itself to that host. A container query would do the
+ * same, but `container-type` contains layout, which turns the list into the
+ * containing block of the context menu's `position: fixed` overlay.
+ *
+ *   pane 390   -> 300 (the bubble then clips it to its own width)
+ *   pane 700   -> 340
+ *   pane 1000  -> 430
+ *   pane 1400  -> 550
+ *   pane 1600+ -> 560
+ */
+export declare const MEDIA_WIDTH_VAR = "--ethora-media-w";
+export declare const PANE_WIDTH_VAR = "--ethora-pane-w";
+export declare const MEDIA_WIDTH_RULE = "clamp(300px, calc(var(--ethora-pane-w, 800px) * 0.3 + 130px), 560px)";
+/** Use inside a stylesheet or inline style; falls back when the list did not set it. */
+export declare const MEDIA_WIDTH_CSS = "var(--ethora-media-w, 340px)";
+/** A lone file card is capped so it does not become a giant bar. */
+export declare const FILE_ONLY_MAX_WIDTH_PX = 360;
+/** Tallest a solo picture gets, relative to the media width. */
+export declare const SOLO_MAX_HEIGHT_FACTOR = 1.4;
+/** CSS length of the tallest a solo picture may be: 60vh, or 1.4 x the media width. */
+export declare const SOLO_MAX_HEIGHT_CSS = "min(60vh, calc(1.4 * var(--ethora-media-w, 340px)))";
+export interface MediaBox {
+    width: number;
+    height: number;
+}
+/**
+ * Fit a natural size inside a max box, keeping its aspect ratio. Never
+ * upscales: a picture smaller than the box keeps its natural size. Returns
+ * null when either dimension is unknown or not positive.
+ */
+export declare const fitMediaBox: (naturalWidth: number | undefined, naturalHeight: number | undefined, maxWidth?: number, maxHeight?: number) => MediaBox | null;
+/** A picture whose longest side is below this is shown at its natural size. */
+export declare const SOLO_TINY_MAX_SIDE_PX = 120;
+/** Smallest frame drawn around a tiny picture. */
+export declare const SOLO_MIN_FRAME_PX = 64;
+/** Beyond this long:short ratio a picture is cropped rather than letterboxed. */
+export declare const SOLO_EXTREME_RATIO = 3;
+/** Shorter side of the box of an extreme-ratio picture. */
+export declare const SOLO_MIN_SHORT_SIDE_PX = 96;
+/**
+ * How the picture sits in its box.
+ *   fit     - same aspect ratio as the box, fills it.
+ *   cover   - extreme ratio: fills the box and is gently cropped from the centre.
+ *   natural - smaller than its frame: drawn at its own size, centred on a tile.
+ */
+export type SoloMode = 'fit' | 'cover' | 'natural';
+export interface SoloBox {
+    /** The frame (stage) size in CSS px. */
+    width: number;
+    height: number;
+    /** The drawn picture size; equals the frame unless `mode` is natural. */
+    imageWidth: number;
+    imageHeight: number;
+    mode: SoloMode;
+}
+/**
+ * The size policy of a single picture in a bubble.
+ *
+ *  - Inside the max box (560 x 784 by default) at its own aspect ratio,
+ *    never upscaled. CSS narrows it to the pane's media width and height.
+ *  - Tiny (longest side < 120): natural size on a tile of at least 64px.
+ *  - Extreme ratio (beyond 3:1 or 1:3): the shorter side is lifted to 96px
+ *    and the picture is cover-cropped (the viewer shows all of it).
+ *
+ * `ratioOnly` is for a size read from a downscaled preview: only its aspect
+ * ratio is trusted, so the box is scaled up to the real maximum instead of
+ * staying thumbnail-sized (which would jump when the full file arrives).
+ * Returns null while a dimension is unknown.
+ */
+export declare const computeSoloBox: (naturalWidth: number | undefined, naturalHeight: number | undefined, options?: {
+    ratioOnly?: boolean;
+    maxWidth?: number;
+    maxHeight?: number;
+}) => SoloBox | null;
+/** Parses a dimension that may arrive as a number or a numeric string. */
+export declare const parseDimension: (value: unknown) => number | undefined;
+/**
+ * Formats a duration in seconds as m:ss, or h:mm:ss past one hour. Returns
+ * an empty string when the value is missing or not a positive number, so
+ * callers can skip the chip entirely.
+ */
+export declare const formatDuration: (seconds: string | number | undefined) => string;

package/dist/helpers/mediaBubble.d.ts

@@ -0,0 +1,39 @@
+import { IAttachment } from '../types/types';
+/**
+ * How a message's files share one column:
+ *  - album: two or more pictures or videos, one grid; cards stretch to it.
+ *  - solo: one picture or video; the block shrink-wraps it (at most the media
+ *    width) and any cards stretch to that.
+ *  - files: documents only; the media width, capped so a lone card is no bar.
+ *  - plain: voice notes only, which keep their own width.
+ */
+export type MediaBlockMode = 'album' | 'solo' | 'files' | 'plain';
+export interface AttachmentItem {
+    attachment: IAttachment;
+    /** Position in the message's attachments, used for retry. */
+    index: number;
+}
+export interface AttachmentPartition {
+    /** Pictures and videos rendered as one album grid (empty for a lone one). */
+    tiles: AttachmentItem[];
+    /** Everything else, rendered one after another below the grid. */
+    rows: AttachmentItem[];
+}
+export declare const attachmentKind: (attachment: IAttachment) => import('./fileKind').FileKind;
+/**
+ * Splits a message's files into the album and the rows below it. Pictures and
+ * videos always come first, in the order they were picked; the remaining files
+ * (documents, svg, pdf, audio) follow, also in their picked order. A lone
+ * picture is not an album: it stays a row, but it still leads the message.
+ */
+export declare const partitionAttachments: (attachments: IAttachment[]) => AttachmentPartition;
+/** The block mode for a message's files, from the partition it renders. */
+export declare const getMediaBlockMode: (attachments: IAttachment[]) => MediaBlockMode;
+/**
+ * Whether the time can sit as a glass pill over the media (Telegram style):
+ * only when the bubble is pictures and videos and nothing else. A caption or
+ * any card or audio row puts the time on its own line at the bottom right.
+ */
+export declare const usesMediaOverlayTime: (attachments: IAttachment[], options?: {
+    hasCaption?: boolean;
+}) => boolean;

package/dist/helpers/mediaLabel.d.ts

@@ -0,0 +1,10 @@
+import { getMessageAttachments } from './attachments';
+type Translate = (key: string, vars?: Record<string, string | number>) => string;
+/**
+ * What to call a media message's files when there is no text to show:
+ * "Photo", "Video", "Voice message", "File", "3 photos", "2 attachments".
+ * Empty when the message carries no file. The kind comes from the normalised
+ * attachment, so a file sent with no mimetype is still a photo by its name.
+ */
+export declare const getMediaLabel: (message: Parameters<typeof getMessageAttachments>[0], t: Translate) => string;
+export {};

package/dist/helpers/mediaSendRetry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Retry hooks for media messages whose uploads did not all land.
+ *
+ * The send closure lives inside useSendMessage, but the bubble that shows
+ * "Retry" is somewhere else in the tree and has no access to it. The send
+ * registers its retry runner under the message id while the message is
+ * unsent, and the bubble looks it up here. The runner is removed as soon as
+ * the message is delivered.
+ */
+export type MediaRetryRunner = (indices?: number[]) => Promise<boolean>;
+export declare const registerMediaRetry: (messageId: string, runner: MediaRetryRunner) => void;
+export declare const unregisterMediaRetry: (messageId: string) => void;
+export declare const hasMediaRetry: (messageId: string) => boolean;
+/**
+ * Re-runs the uploads still missing for `messageId` (only `index` / `indices`
+ * when given), then sends the message once every file is in. Resolves to
+ * false when nothing is registered or the attempt did not deliver.
+ */
+export declare const retryMediaSend: (messageId: string, index?: number | number[]) => Promise<boolean>;
+/**
+ * Asks for one file of `messageId` to be retried. Requests made in the same
+ * tick are merged into one run: the runner takes a single run at a time, so
+ * a separate call per tile would drop every retry after the first.
+ */
+export declare const requestMediaRetry: (messageId: string, index: number) => void;

package/dist/helpers/messageRuns.d.ts

@@ -0,0 +1,10 @@
+import { IMessage } from '../types/types';
+/**
+ * Ids of the messages that end a run of one sender: the next row is another
+ * sender, a system row, or a message on the next day. A run is a block of
+ * consecutive messages from one person, which the bubbles group visually.
+ *
+ * Pass the full list, not a window of it, so the last row of a window still
+ * knows what follows it.
+ */
+export declare const messageRunEnds: (list: IMessage[]) => Set<string>;

package/dist/helpers/repairFilenameEncoding.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Repairs file names the backend returns as UTF-8 bytes read as Latin-1
+ * (the classic multer/busboy `originalname` problem): "Список.pdf" arrives
+ * as "СпиÑок.pdf".
+ *
+ * Pure and conservative: a name is only replaced when every character fits
+ * in one byte, the bytes decode as strict UTF-8, the result differs, holds
+ * no replacement or control characters and contains at least one letter
+ * outside basic Latin. A correct name is returned untouched.
+ */
+export declare const repairFilenameEncoding: (name: string) => string;

package/dist/helpers/roomImageGallery.d.ts

@@ -7,9 +7,27 @@ import { IMessage, ModalFile } from '../types/types';
  * download action, the secure `?ft=` token treatment, the alt text - keeps
  * reading exactly the fields it read when a single file was opened by hand.
  */
+export interface GallerySender {
+    id?: string;
+    username?: string;
+    /** The message's own display name, when it has one. */
+    name?: string;
+    firstName?: string;
+    lastName?: string;
+    /** Profile photo URL, when the sender has one. */
+    photo?: string;
+}
 export interface GalleryImage extends ModalFile {
+    /** What the entry renders as. Images zoom; videos play. */
+    kind: 'image' | 'video';
     /** Stable per message+slot, so two identical URLs are still two entries. */
     key: string;
+    /** Low-resolution copy shown blurred while the full image loads. */
+    previewURL?: string;
+    /** Message timestamp (ISO), shown in the viewer's header. */
+    date?: string;
+    /** Who posted it; the viewer header shows their name and avatar. */
+    sender?: GallerySender;
 }
 /**
  * The gallery the lightbox pages through.
@@ -34,7 +52,17 @@ export interface GalleryImage extends ModalFile {
  * Non-images (video, PDF, audio, arbitrary files) are excluded, so opening a
  * PDF simply produces an empty gallery and no navigation chrome.
  */
+/** The sender fields the viewer header needs, or undefined for no sender. */
+export declare const senderFromMessage: (message?: Partial<IMessage> | null) => GallerySender | undefined;
+/** ISO date string for a message, as the viewer header wants it. */
+export declare const isoDateFromMessage: (message?: Partial<IMessage> | null) => string | undefined;
 export declare const collectRoomImages: (messages?: Partial<IMessage>[] | null) => GalleryImage[];
+/**
+ * Same walk as `collectRoomImages`, but the viewer's gallery also pages
+ * through videos, so an album of photos and clips opens as one sequence.
+ * PDFs, audio and other files are still excluded.
+ */
+export declare const collectRoomMedia: (messages?: Partial<IMessage>[] | null, kinds?: Array<"image" | "video">) => GalleryImage[];
 /**
  * Position of the open file inside the gallery, or -1 when it is not part of
  * it (a PDF, a video, a file opened from the Files panel of another room).
@@ -51,3 +79,9 @@ export declare const collectRoomImages: (messages?: Partial<IMessage>[] | null)
  * were stuck.
  */
 export declare const findGalleryIndex: (images: GalleryImage[], activeFile?: ModalFile | null) => number;
+/**
+ * Builds gallery entries from the file list a caller handed over with the
+ * open request (an album grid passes all of its tiles). Items without a
+ * location, or that are neither image nor video, are dropped.
+ */
+export declare const galleryFromFiles: (files?: ModalFile[] | null) => GalleryImage[];

package/dist/helpers/safeUrl.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Image URLs that reach the DOM (`<img src>`, CSS `url()`) can come from
+ * user-controlled data: profile photos, message stanzas, link previews,
+ * attachment locations. Anything that is not a plain web or blob image URL is
+ * dropped here so the sink never receives an active or document-bearing URL.
+ */
+/**
+ * Returns the trimmed input when it is a safe image URL, otherwise ''.
+ *
+ * Allowed: absolute or relative (resolved against the page origin) http:,
+ * https: and blob: URLs, and base64 data URLs of png, jpeg, gif, webp or
+ * avif images. Blocked: javascript:, vbscript:, data:text/html, data:image/svg+xml
+ * and anything that does not parse. Non-string input yields ''.
+ */
+export declare const safeImageUrl: (value: unknown) => string;

package/dist/helpers/secureFileUrl.d.ts

@@ -9,4 +9,7 @@ export declare const appendFileToken: (url: string | null | undefined, fileToken
  */
 export declare const withoutFileToken: (url?: string | null) => string;
 export declare const withFileToken: (url?: string | null) => string;
-export declare const requestFileTokenRecovery: () => Promise<boolean>;
+export declare const resetFileTokenRecovery: () => void;
+export declare const requestFileTokenRecovery: (options?: {
+    force?: boolean;
+}) => Promise<boolean>;

package/dist/helpers/viewerSender.d.ts

@@ -0,0 +1,47 @@
+/** What the media viewer knows about a sender, however thin. */
+export interface ViewerSenderInput {
+    id?: string;
+    username?: string;
+    /** `message.user.name`, which carries the display name for many senders. */
+    name?: string;
+    firstName?: string;
+    lastName?: string;
+    photo?: string;
+}
+interface DirectoryEntry {
+    firstName?: string;
+    lastName?: string;
+    profileImage?: string;
+}
+interface OwnProfile extends DirectoryEntry {
+    xmppUsername?: string;
+    name?: string;
+}
+export interface ResolveViewerSenderOptions {
+    sender?: ViewerSenderInput | null;
+    /** `rooms.usersSet`, keyed by the xmpp username. */
+    usersSet?: Record<string, DirectoryEntry | undefined>;
+    /** The signed-in user, for their own messages. */
+    me?: OwnProfile | null;
+    /** Only used for a 1:1 room, where the room is named after the peer. */
+    peerRoomName?: string;
+}
+export interface ResolvedViewerSender {
+    /** Empty when nobody could be named. The header then omits the name line. */
+    name: string;
+    photo?: string;
+}
+/**
+ * Resolves the sender shown in the viewer header. The order is the one the
+ * message bubble uses, with the signed-in user's own profile as the answer for
+ * their own messages (an own optimistic message often has no name on it):
+ *
+ *   first + last on the message, the message's own `name`, the profile in
+ *   `usersSet`, the signed-in user's profile (own messages), the username
+ *   before the `@`, and for a 1:1 room the room's name.
+ *
+ * Never returns a placeholder: when nothing is known `name` is '' and the
+ * caller draws a neutral glyph rather than initials.
+ */
+export declare const resolveViewerSender: ({ sender, usersSet, me, peerRoomName, }: ResolveViewerSenderOptions) => ResolvedViewerSender;
+export {};

package/dist/hooks/useAvatarImage.d.ts

@@ -0,0 +1,21 @@
+export type AvatarImageStatus = 'none' | 'loading' | 'loaded' | 'failed';
+/**
+ * Resolves an avatar URL for rendering. Never waits on the network: the
+ * caller shows initials immediately and fades the <img> in once `status` is
+ * `loaded`.
+ *
+ *  - appends the viewer's `?ft=` token for secure-files URLs synchronously
+ *    from the store (no token round trip before the request starts);
+ *  - reuses a URL that already loaded for the same file (see
+ *    avatarImageCache) so a token rotation or a second component showing the
+ *    same person does not trigger another download;
+ *  - skips URLs that just failed (no repeated failing requests);
+ *  - on a secure-file failure kicks the throttled fileToken recovery, whose
+ *    refreshed token yields a new URL and therefore a new attempt.
+ */
+export declare const useAvatarImage: (rawSrc: string | null | undefined) => {
+    src: string;
+    status: AvatarImageStatus;
+    onLoad: () => void;
+    onError: () => void;
+};

package/dist/hooks/useIsMobileViewport.d.ts

@@ -1 +1,6 @@
 export declare const useIsMobileViewport: (breakpoint?: number) => boolean;
+/**
+ * Non-hook form of the same check, for event handlers that need the answer
+ * at the moment of the event rather than as render state.
+ */
+export declare const isMobileViewportNow: (breakpoint?: number) => boolean;

package/dist/hooks/useMediaProbe.d.ts

@@ -0,0 +1,40 @@
+export type MediaProbeStatus = 'idle' | 'loading' | 'recovering' | 'loaded' | 'error';
+export interface MediaProbe {
+    status: MediaProbeStatus;
+    /**
+     * Natural size. Known once `status` is 'loaded', and usually sooner: it is
+     * read from the first decoded header while the bytes are still arriving.
+     */
+    width: number;
+    height: number;
+    /**
+     * The URL whose bytes are on screen. While a picture is shown, a rotated
+     * `?ft=` token does not swap it for a fresh request: the URL that loaded
+     * stays, so a token refresh never blanks or re-downloads what is visible.
+     */
+    url: string;
+}
+/**
+ * No byte of the file (not even its header) arrived in this long: stop
+ * waiting and show the unavailable state with a manual retry. Once the size
+ * is known the file is on its way and is never cut off by this timer.
+ */
+export declare const MEDIA_STALL_MS = 8000;
+export declare const resetMediaProbeCaches: () => void;
+/**
+ * Preloads one image off-DOM so the visible <img> only mounts once its bytes
+ * are cached.
+ *
+ * A failure never says anything about the file being deleted: a 404 from the
+ * storage host, an expired token, a CORS or DNS hiccup and a dead CDN edge all
+ * fail an <img> the same way, and the server's answer cannot be read across
+ * origins anyway. So the only outcome is the 'error' state, which the surface
+ * offers to `retry`. Deleting a message is driven by the server (a delete
+ * stanza) or by the sender's own Files panel action, never inferred here.
+ *
+ * A secure URL that fails gets at most one shared token refresh per token
+ * (see `requestFileTokenRecovery`); the refreshed URL re-runs this effect.
+ */
+export declare const useMediaProbe: (url: string | undefined) => MediaProbe & {
+    retry: () => void;
+};

package/dist/hooks/usePaneWidthVar.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from 'react';
+/**
+ * Publishes the width of an element as the `--ethora-pane-w` custom property
+ * on that element, so message media can size itself to the chat pane (which
+ * may be a narrow host) instead of the viewport. Updated on every resize.
+ *
+ * The element may mount after the first render (the list shows a loader
+ * first), so every commit checks whether the ref points at a new element
+ * and re-attaches the observer if so.
+ */
+export declare const usePaneWidthVar: (ref: RefObject<HTMLElement | null>) => void;

package/dist/hooks/usePdfThumbnail.d.ts

@@ -15,7 +15,6 @@ interface UsePdfThumbnailResult {
     status: PdfThumbnailStatus;
     /** Object URL - owned by this hook, revoked on unmount/url change. */
     thumbnailUrl?: string;
-    pageCount?: number;
     /** Re-runs a render that failed or was skipped for being too big. */
     retry: () => void;
 }

package/dist/hooks/usePrefersReducedMotion.d.ts

@@ -0,0 +1,2 @@
+/** True while the user asks the OS for reduced motion; follows live changes. */
+export declare const usePrefersReducedMotion: () => boolean;

package/dist/hooks/useSendMessage.d.ts

@@ -1,8 +1,11 @@
 import { IMentionSpan } from '../types/types';
+import { CaptionInput } from '../helpers/caption';
+/** Files of one message uploaded at the same time. */
+export declare const MEDIA_UPLOAD_CONCURRENCY = 4;
 export { shouldTagOutgoingTranslateSource } from '../utils/translateModePolicy';
 export declare const useSendMessage: () => {
     sendMessage: (message: string, activeRoomJID: string, isReply?: boolean, isChecked?: boolean, mainMessage?: string, mentions?: IMentionSpan[]) => Promise<void>;
-    sendMedia: (data: File | File[] | Blob, type: string, activeRoomJID: string, isReply?: boolean, isChecked?: boolean, mainMessage?: string) => Promise<void>;
+    sendMedia: (data: File | File[] | Blob, type: string, activeRoomJID: string, isReply?: boolean, isChecked?: boolean, mainMessage?: string, caption?: CaptionInput) => Promise<boolean>;
     sendEditMessage: (message: string) => Promise<void>;
     isLastMessageFromUserAndProcessing: (roomJID: string) => boolean;
 };