@ethora/chat-component 26.10.7 → 26.10.8

package/dist/main.d.ts

@@ -14,6 +14,7 @@ export { useRoomMute } from './hooks/useRoomMute';
 export type { UseRoomMuteResult } from './hooks/useRoomMute';
 export { parseQuickReplies } from './helpers/quickReplies';
 export type { QuickReply } from './helpers/quickReplies';
+export { openScheduledCall, parseScheduledCallLink } from './calls/openScheduledCall';
 export { applyTypography, clearTypography } from './helpers/applyTypography';
 export { useTypography } from './hooks/useTypography';
 export type { TypographyConfig, FontFaceSource, } from './types/models/config.model';
@@ -22,7 +23,8 @@ export { ChatInputTestIds, MessageBubbleTestIds, RoomListTestIds, AuthTestIds, }
 export { refreshAuthTokens, refreshAuthTokensQuietly, RefreshFatalError, isRefreshFatalError, } from './networking/authRefresh';
 export type { RefreshErrorCode, RefreshResult, RefreshOptions, } from './networking/authRefresh';
 export type { ChatWrapperProps as ChatProps } from './components/MainComponents/ReduxWrapper';
-export type { IConfig } from './types/models/config.model';
+export type { IConfig, XmppMessageEvent } from './types/models/config.model';
+export type { ScheduledCallsConfig, ScheduledCallOpenError, ScheduledCall, ScheduledCallKind, } from './types/models/scheduledCall.model';
 export type { VideoCallsConfig, VideoCallIcons, FBConfig, } from './types/models/config.model';
 export type { User, IUser, ConfigUser, StorageUser, } from './types/models/user.model';
 export type { IMessage, IReply, LastMessage, MessageProps, MediaMessageType, ReactionMessage, } from './types/models/message.model';

package/dist/main.js

@@ -1,30 +1,32 @@
-import { bG as e, bH as r, bI as o, bJ as b, bK as t, bL as i, bM as u, bN as p, bO as h, bP as n, bQ as d, i as l, bR as T, a3 as I, bS as R, bT as f, bU as m, bV as y, bW as c, bX as g, bY as C, bZ as E, b_ as Q, aE as A, aF as F, b$ as M, c0 as P } from "./main-CpHMnydn.js";
+import { bS as a, bT as r, bU as o, bV as t, bW as c, bX as u, bY as p, bZ as h, b_ as i, b$ as l, c0 as n, v as d, c1 as b, af as T, c2 as f, c3 as m, c4 as y, c5 as I, c6 as R, c7 as g, c8 as C, c9 as Q, ca as k, cb as A, cc as E, aP as P, aQ as S, cd as v, ce as F } from "./main-B25iFKAC.js";
 export {
-  e as AuthTestIds,
+  a as AuthTestIds,
   r as Chat,
   o as ChatInputTestIds,
-  b as MessageBubbleTestIds,
-  t as RefreshFatalError,
-  i as RoomListTestIds,
-  u as XmppProvider,
-  p as applyTypography,
-  h as clearTypography,
-  n as formatFingerprint,
-  d as handleQRChatId,
-  l as isE2eeEnabled,
-  T as isRefreshFatalError,
-  I as logoutService,
-  R as omemo,
-  f as parseQuickReplies,
-  m as refreshAuthTokens,
-  y as refreshAuthTokensQuietly,
-  c as resendMessage,
-  g as useInAppNotifications,
-  C as useIsUserOnline,
-  E as usePushNotifications,
-  Q as useQRCodeChat,
-  A as useRoomMute,
-  F as useRoomPresence,
-  M as useTypography,
-  P as useUnread
+  t as MessageBubbleTestIds,
+  c as RefreshFatalError,
+  u as RoomListTestIds,
+  p as XmppProvider,
+  h as applyTypography,
+  i as clearTypography,
+  l as formatFingerprint,
+  n as handleQRChatId,
+  d as isE2eeEnabled,
+  b as isRefreshFatalError,
+  T as logoutService,
+  f as omemo,
+  m as openScheduledCall,
+  y as parseQuickReplies,
+  I as parseScheduledCallLink,
+  R as refreshAuthTokens,
+  g as refreshAuthTokensQuietly,
+  C as resendMessage,
+  Q as useInAppNotifications,
+  k as useIsUserOnline,
+  A as usePushNotifications,
+  E as useQRCodeChat,
+  P as useRoomMute,
+  S as useRoomPresence,
+  v as useTypography,
+  F as useUnread
 };

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

@@ -0,0 +1,24 @@
+import { IceServerConfig } from '../../calls/callMode';
+/** Callee: the incoming UI is on screen. */
+export declare const reportCallRinging: (callId: string | null) => void;
+/** Callee: the user rejected the call. The server relays it to the caller. */
+export declare const reportCallDeclined: (callId: string | null) => void;
+/** Media is flowing (ICE connected). Starts the server-side call timer. */
+export declare const reportCallConnected: (callId: string | null) => void;
+/**
+ * A ringing or connected call ended for any reason. Idempotent on the server
+ * (a second report returns `ended:false`), so both peers may send it.
+ */
+export declare const reportCallEnded: (callId: string | null) => void;
+export interface IceServersResponse {
+    enabled: boolean;
+    iceServers: IceServerConfig[];
+    ttlSeconds: number | null;
+}
+/**
+ * GET /v1/calls/ice-servers: fresh STUN/TURN credentials. Used by a callee
+ * whose call-token carried no `ice` list, and to refresh the (ephemeral)
+ * credentials before an ICE restart. Returns null on any failure so callers
+ * can carry on with the servers they already have.
+ */
+export declare function fetchIceServers(): Promise<IceServersResponse | null>;

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

@@ -0,0 +1,20 @@
+import { RemoteConfigRecord } from '../../helpers/liveConfig';
+export interface RemoteAppearanceSnapshot {
+    record: RemoteConfigRecord;
+    /** `'0'` when the App never saved anything. */
+    version: string;
+}
+export declare const isValidRemoteAppId: (appId: unknown) => appId is string;
+export declare const remoteAppearanceUrl: (baseUrl: string | undefined, appId: string, version?: string) => string;
+/**
+ * Reads the App's public chat component config. Unauthenticated on purpose
+ * (no token, no cookies, no refresh logic): it is the same public endpoint
+ * the web app reads at load. Pass the `version` the server announced to get
+ * past the endpoint's 30 s cache. Throws on a network or HTTP failure; the
+ * caller keeps what it has.
+ */
+export declare function fetchRemoteAppearance(opts: {
+    baseUrl?: string;
+    appId: string;
+    version?: string;
+}, signal?: AbortSignal): Promise<RemoteAppearanceSnapshot>;

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

@@ -1,4 +1,5 @@
 import { ApiRoom, DeleteRoomMember, PostAddRoomMember, PostReportRoom, PostRoom, RoomMember } from '../../types/types';
+import { CallCreateResult } from '../../calls/callMode';
 export interface BlockedUserEntry {
     _id: string;
     firstName?: string;
@@ -58,4 +59,4 @@ export declare function deleteRoom(name: string): Promise<any>;
 export declare function declineChatCall(callId: string): Promise<boolean>;
 export declare function createChatCall(chatName: string, options?: {
     kind?: 'audio' | 'video';
-}): Promise<void>;
+}): Promise<CallCreateResult>;

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

@@ -0,0 +1,19 @@
+import { CreateScheduledCallInput, ScheduledCall, ScheduledCallDetails, ScheduledCallOpenError, ScheduledCallWithLinks, UpdateScheduledCallInput } from '../../types/models/scheduledCall.model';
+/** What went wrong, in the terms the UI needs. */
+export declare class ScheduledCallApiError extends Error {
+    readonly status: number | null;
+    readonly reason: ScheduledCallOpenError;
+    /** The server's own `code` (or `error`) string, when it sent one. */
+    readonly code: string | null;
+    constructor(status: number | null, reason: ScheduledCallOpenError, code: string | null);
+}
+export declare function createScheduledCall(input: CreateScheduledCallInput): Promise<ScheduledCallWithLinks>;
+export declare function listScheduledCalls(params: {
+    chatName: string;
+    from?: string;
+    to?: string;
+}): Promise<ScheduledCallWithLinks[]>;
+/** GET one call by slug. 404 -> `not-found`, 403 -> `not-a-member`. */
+export declare function getScheduledCall(slug: string): Promise<ScheduledCallDetails>;
+export declare function updateScheduledCall(slug: string, patch: UpdateScheduledCallInput): Promise<ScheduledCallWithLinks>;
+export declare function cancelScheduledCall(slug: string): Promise<ScheduledCall>;

package/dist/networking/ethoraEvents.d.ts

@@ -5,6 +5,13 @@ import { Element } from 'ltx';
  *
  *   user-profile-updated  xmppUsername="<appId>_<userId>" uuid appId
  *   chat-meta-updated     chatName="<appId>_<roomId>" appId
+ *   chat-component-config-updated  appId version
+ *
+ * The last one is how a change in the admin's Chat component tab reaches
+ * open chats. The server sends it to every online session of its XMPP host
+ * in one go (ejabberd `announce/online`), so it arrives FROM the bare server
+ * domain and for any App on the host: it is only acted on when `appId` is
+ * this session's own App.
  *
  * The payload is a pointer only. The client re-reads the user or the room
  * through the normal API, so nothing in the stanza is ever shown or stored.
@@ -13,6 +20,7 @@ import { Element } from 'ltx';
 export declare const ETHORA_EVENT_XMLNS = "urn:ethora:events:1";
 export declare const ETHORA_EVENT_USER_PROFILE = "user-profile-updated";
 export declare const ETHORA_EVENT_CHAT_META = "chat-meta-updated";
+export declare const ETHORA_EVENT_CHAT_COMPONENT_CONFIG = "chat-component-config-updated";
 type HostLike = {
     host?: string;
     client?: {
@@ -30,8 +38,13 @@ type HostLike = {
  * - when config.trustedEventSenders is set, the sender must be listed
  * The server's admin local part is deployment config (XMPP_ADMIN), so it
  * cannot be hard-coded here.
+ *
+ * `allowServerDomain` also accepts the bare server domain itself as the
+ * sender (what ejabberd stamps on a host-wide announcement). A client cannot
+ * send as the domain: the server fixes `from` on every client stanza. A
+ * pinned `trustedEventSenders` list then has to name the domain.
  */
-export declare const isTrustedEventSender: (stanza: Element, xmppWs: HostLike | undefined) => boolean;
+export declare const isTrustedEventSender: (stanza: Element, xmppWs: HostLike | undefined, allowServerDomain?: boolean) => boolean;
 /**
  * Handles `<ethora-event>` headlines. Returns true when the stanza carried
  * one (trusted or not), so the caller can stop routing it. Unknown types,

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

@@ -0,0 +1,6 @@
+import { Element } from 'ltx';
+/**
+ * Notify the host about every inbound XMPP message, including messages that
+ * are consumed by protocol handlers or routed to MAM instead of the chat UI.
+ */
+export declare function notifyXmppEvent(stanza: Element): void;

package/dist/roomStore/callSlice.d.ts

@@ -1,3 +1,4 @@
+import { CallMode, IceServerConfig } from '../calls/callMode';
 export type CallPhase = 'idle' | 'requesting' | 'ringing-incoming' | 'connecting' | 'in-call' | 'error';
 export type CallDirection = 'outgoing' | 'incoming' | null;
 export type CallKind = 'audio' | 'video';
@@ -16,6 +17,12 @@ export interface CallState {
     error: string | null;
     startedAt: number | null;
     connectedAt: number | null;
+    mode: CallMode;
+    isGroup: boolean;
+    livekitUrl: string | null;
+    iceServers: IceServerConfig[] | null;
+    callerName: string | null;
+    callerXmppUsername: string | null;
 }
 export declare const startOutgoingCall: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     roomJid: string;
@@ -23,6 +30,7 @@ export declare const startOutgoingCall: import('@reduxjs/toolkit').ActionCreator
     roomBareName?: string | null;
     kind?: CallKind;
     peerXmppUsername?: string | null;
+    isGroup?: boolean;
 }, "call/startOutgoingCall">, setIncomingCallToken: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     roomJid: string;
     roomName?: string | null;
@@ -31,11 +39,25 @@ export declare const startOutgoingCall: import('@reduxjs/toolkit').ActionCreator
     kind?: CallKind;
     callId?: string | null;
     peerXmppUsername?: string | null;
+    mode?: CallMode;
+    isGroup?: boolean;
+    iceServers?: IceServerConfig[] | null;
+    livekitUrl?: string | null;
+    callerName?: string | null;
+    callerXmppUsername?: string | null;
 }, "call/setIncomingCallToken">, setOutgoingCallToken: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     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">, setCallE2eeKey: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    livekitUrl?: string | null;
+}, "call/setOutgoingCallToken">, setOutgoingCallRoute: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    startedAt: number | null;
+    callId: string | null;
+    mode: CallMode;
+    group?: boolean | null;
+    livekitUrl?: string | null;
+    iceServers?: IceServerConfig[] | null;
+}, "call/setOutgoingCallRoute">, 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">;

package/dist/roomStore/chatSettingsSlice.d.ts

@@ -1,7 +1,15 @@
 import { DeleteModal, IConfig, Iso639_1Codes, IUser, ModalFile, ModalType, User } from '../types/types';
+import { RemoteConfigRecord } from '../helpers/liveConfig';
 interface ChatState {
     user: User;
     config?: IConfig;
+    /**
+     * The operator-saved look read for `config.remoteAppearance` (validated,
+     * live keys only). Kept next to `config` so that whoever writes `config`
+     * (the chat, the provider, the init hook) gets it laid over their value,
+     * and one writer cannot undo what another applied. Not persisted.
+     */
+    remoteConfig?: RemoteConfigRecord | null;
     appId?: string;
     activeModal?: ModalType;
     deleteModal?: DeleteModal;
@@ -34,7 +42,7 @@ interface ChatState {
     translateMode?: 'auto' | 'manual';
     blockedUserIds: string[];
 }
-export declare const setUser: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<User, "chatSettingStore/setUser">, setConfig: import('@reduxjs/toolkit').ActionCreatorWithNonInferrablePayload<"chatSettingStore/setConfig">, refreshTokens: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+export declare const setUser: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<User, "chatSettingStore/setUser">, setConfig: import('@reduxjs/toolkit').ActionCreatorWithNonInferrablePayload<"chatSettingStore/setConfig">, setRemoteConfig: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<RemoteConfigRecord, "chatSettingStore/setRemoteConfig">, refreshTokens: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     token: string;
     refreshToken: string;
     fileToken?: string;

package/dist/roomStore/index.d.ts

@@ -62,11 +62,13 @@ declare const rootReducer: Reducer<{
     rooms: Record<string, any> & import('redux-persist/es/persistReducer').PersistPartial;
     roomHeapSlice: import('./roomHeapSlice').roomHeapSliceState;
     call: import('immer').WritableDraft<import('./callSlice').CallState>;
+    scheduledCall: import('immer').WritableDraft<import('./scheduledCallSlice').ScheduledCallState>;
 }, import('redux').UnknownAction, Partial<{
     chatSettingStore: Record<string, any> & import('redux-persist/es/persistReducer').PersistPartial;
     rooms: Record<string, any> & import('redux-persist/es/persistReducer').PersistPartial;
     roomHeapSlice: import('./roomHeapSlice').roomHeapSliceState;
     call: import('immer').WritableDraft<import('./callSlice').CallState>;
+    scheduledCall: import('immer').WritableDraft<import('./scheduledCallSlice').ScheduledCallState>;
 }>>;
 export type RootState = ReturnType<typeof rootReducer>;
 export declare const getActiveRoom: (state: RootState) => IRoom | null;
@@ -75,12 +77,14 @@ export declare const store: import('@reduxjs/toolkit').EnhancedStore<{
     rooms: Record<string, any> & import('redux-persist/es/persistReducer').PersistPartial;
     roomHeapSlice: import('./roomHeapSlice').roomHeapSliceState;
     call: import('immer').WritableDraft<import('./callSlice').CallState>;
+    scheduledCall: import('immer').WritableDraft<import('./scheduledCallSlice').ScheduledCallState>;
 }, AnyAction, import('@reduxjs/toolkit').Tuple<[import('redux').StoreEnhancer<{
     dispatch: import('redux-thunk').ThunkDispatch<{
         chatSettingStore: Record<string, any> & import('redux-persist/es/persistReducer').PersistPartial;
         rooms: Record<string, any> & import('redux-persist/es/persistReducer').PersistPartial;
         roomHeapSlice: import('./roomHeapSlice').roomHeapSliceState;
         call: import('immer').WritableDraft<import('./callSlice').CallState>;
+        scheduledCall: import('immer').WritableDraft<import('./scheduledCallSlice').ScheduledCallState>;
     }, undefined, import('redux').UnknownAction>;
 }>, import('redux').StoreEnhancer]>>;
 export type AppDispatch = typeof store.dispatch;

package/dist/roomStore/scheduledCallSlice.d.ts

@@ -0,0 +1,47 @@
+import { ScheduledCallDetails, ScheduledCallOpenError } from '../types/models/scheduledCall.model';
+export interface ScheduledCallDetailsEntry {
+    status: 'loading' | 'ready' | 'error';
+    data?: ScheduledCallDetails;
+    error?: ScheduledCallOpenError;
+}
+export interface ScheduledCallState {
+    /** A slug somebody asked to open (host prop or openScheduledCall). */
+    openRequest: {
+        slug: string;
+        requestedAt: number;
+    } | null;
+    /** The call whose pre-join panel is on screen. */
+    preJoin: ScheduledCallDetails | null;
+    /** The schedule form; `editing` set means edit mode. */
+    scheduleModal: {
+        roomJid: string;
+        editing: ScheduledCallDetails | null;
+    } | null;
+    /** The "cancel this call?" confirmation (mounted by the layer, outside the message list). */
+    cancelModal: {
+        slug: string;
+        title: string;
+    } | null;
+    /** Server copy of the calls the cards show, by slug. */
+    details: Record<string, ScheduledCallDetailsEntry>;
+    /** The last open request that failed, for the in-chat error notice. */
+    openError: {
+        slug: string;
+        reason: ScheduledCallOpenError;
+    } | null;
+}
+export declare const requestOpenScheduledCall: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<string, "scheduledCall/requestOpenScheduledCall">, clearOpenRequest: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"scheduledCall/clearOpenRequest">, setOpenError: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    slug: string;
+    reason: ScheduledCallOpenError;
+}, "scheduledCall/setOpenError">, openPreJoin: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<ScheduledCallDetails, "scheduledCall/openPreJoin">, closePreJoin: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"scheduledCall/closePreJoin">, openScheduleModal: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    roomJid: string;
+    editing?: ScheduledCallDetails | null;
+}, "scheduledCall/openScheduleModal">, closeScheduleModal: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"scheduledCall/closeScheduleModal">, openCancelModal: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    slug: string;
+    title: string;
+}, "scheduledCall/openCancelModal">, closeCancelModal: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"scheduledCall/closeCancelModal">, detailsLoading: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<string, "scheduledCall/detailsLoading">, detailsLoaded: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<ScheduledCallDetails, "scheduledCall/detailsLoaded">, detailsFailed: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+    slug: string;
+    reason: ScheduledCallOpenError;
+}, "scheduledCall/detailsFailed">, forgetDetails: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<string, "scheduledCall/forgetDetails">;
+declare const _default: import('redux').Reducer<import('immer').WritableDraft<ScheduledCallState>>;
+export default _default;

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

@@ -3,6 +3,7 @@ import { xmppSettingsInterface } from './xmpp.model';
 import { ConfigRoom } from './room.model';
 import { MessageProps, IMessage } from './message.model';
 import { Iso639_1Codes } from './language.model';
+import { ScheduledCallsConfig } from './scheduledCall.model';
 import { QuickReply } from '../../helpers/quickReplies';
 import { default as React } from 'react';
 import { MessageNotificationToastProps } from '../../components/MessageNotification/MessageNotificationToast';
@@ -27,7 +28,15 @@ export interface VideoCallIcons {
 export interface VideoCallsConfig {
     enabled: boolean;
     livekitUrl: string;
-    allowedRoomTypes?: Array<'private'>;
+    /**
+     * Room types that can start and receive calls. Defaults to
+     * `['private', 'group']`: 1:1 chats plus members-only group chats (group
+     * calls always run over LiveKit and need a backend that accepts them; on an
+     * older backend the call fails with an error). Pass `['private']` to keep
+     * calls 1:1 only. The 1:1 transport (own WebRTC peer to peer, or LiveKit) is
+     * chosen by the server per call, not by this config.
+     */
+    allowedRoomTypes?: Array<'private' | 'group'>;
     /**
      * Show the audio-only call button next to the video-call button. Off by
      * default: it's a separate opt-in feature. An audio call uses the same call
@@ -152,6 +161,15 @@ export interface ChatErrorInfo {
     componentStack?: string;
     scope: ChatErrorScope;
 }
+/** An incoming XMPP `<message/>` stanza received by the SDK. */
+export interface XmppMessageEvent {
+    /** The complete stanza as XML, including its message payload. */
+    stanza: string;
+    from?: string;
+    to?: string;
+    id?: string;
+    type?: string;
+}
 /**
  * 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".
@@ -646,6 +664,13 @@ export interface IConfig {
         filterFunction: (text: string) => string;
     };
     eventHandlers?: {
+        /**
+         * Called once for every incoming XMPP `<message/>` stanza, before the
+         * SDK routes it to chat, archive, call, or protocol handlers. `stanza`
+         * contains the raw XML; on end-to-end encrypted messages it may still be
+         * encrypted. A thrown error or rejected promise is caught and logged.
+         */
+        onXmppEvent?: (event: XmppMessageEvent) => void | Promise<void>;
         onMessageSent?: (event: {
             message: string;
             roomJID: string;
@@ -690,6 +715,23 @@ export interface IConfig {
          * inside this handler is caught and logged, never rethrown.
          */
         onError?: (event: ChatErrorInfo) => void;
+        /**
+         * Called when the server announces that the App's chat component config
+         * (the admin's Chat component tab) changed: an `ethora-event` headline of
+         * type `chat-component-config-updated` from the server. The event carries
+         * no values, only the App id and an opaque `version`; read the config
+         * again (`GET /v2/chat-component/config?appId=<appId>&v=<version>`, the
+         * `v` steps around the endpoint's 30 s cache) and pass the result in
+         * `config`, or set `config.remoteAppearance` and let the chat do both.
+         *
+         * Fires once per version, for the signed-in session's own App only
+         * (`config.appId`, or `remoteAppearance.appId`), a few hundred ms after
+         * the last of a burst. A throw inside it is caught and logged.
+         */
+        onChatComponentConfigUpdated?: (event: {
+            appId: string;
+            version: string;
+        }) => void;
     };
     disableTypingIndicator?: boolean;
     blockMessageSendingWhenProcessing?: boolean | {
@@ -743,6 +785,28 @@ export interface IConfig {
      * (`admin`).
      */
     trustedEventSenders?: string[];
+    /**
+     * Let the chat read the App's look from the server and keep it current:
+     * the colours, fonts, layout switches and AI display options the admin
+     * saved in the Chat component tab. Opt in by naming the App.
+     *
+     * The chat reads `GET /v2/chat-component/config?appId=` once at start and
+     * holds its first paint for it (at most `initialWaitMs`), lays the saved
+     * values over `config` (the server wins for the keys it holds), and reads
+     * again whenever the server announces a new version, applying the result to
+     * the open chat without reconnecting or resetting anything. Only the keys
+     * the chat can change live are accepted from the server (see the README
+     * table), each validated; nothing else in `config` is ever touched. A
+     * failed read keeps the look you already have.
+     */
+    remoteAppearance?: {
+        /** The App whose config to read. Usually the same as `config.appId`. */
+        appId: string;
+        /** API origin. Default: `config.baseUrl`, then the SDK's own default. */
+        baseUrl?: string;
+        /** Longest the first paint waits for the first read, in ms. Default 2500. */
+        initialWaitMs?: number;
+    };
     /**
      * Background history preload after connect. Default `{ mode: 'staged',
      * topRooms: 8, concurrency: 3 }`.
@@ -886,4 +950,10 @@ export interface IConfig {
         }) => void | Promise<void>;
     };
     videoCalls?: VideoCallsConfig;
+    /**
+     * Scheduled calls (booking): a "Schedule call" action next to the call
+     * buttons, and invite cards with Add to calendar and Join in the room. On by
+     * default whenever `videoCalls.enabled` is on. See ScheduledCallsConfig.
+     */
+    scheduledCalls?: ScheduledCallsConfig;
 }

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

@@ -2,6 +2,7 @@ import { IUser } from './user.model';
 import { TranslationObject } from '../types';
 import { Iso639_1Codes } from './language.model';
 import { IAttachment } from './attachment.model';
+import { ScheduledCallMeta } from './scheduledCall.model';
 export interface IMessage {
     id: string;
     user: IUser;
@@ -81,6 +82,7 @@ export interface IMessage {
         missed: boolean;
         kind: 'audio' | 'video';
     };
+    scheduledCall?: ScheduledCallMeta;
 }
 export interface ReactionMessage {
     emoji: string[];

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

@@ -178,6 +178,8 @@ export interface IRoomCompressed extends Pick<IRoom, 'jid'> {
 export interface ConfigRoom {
     jid: string;
     pinned: boolean;
+    /** Whether users can leave this app-level room. Defaults to false for configured rooms. */
+    removable?: boolean;
     _id?: string;
 }
 export type ChatAccessOption = {

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

@@ -0,0 +1,116 @@
+export type ScheduledCallKind = 'video' | 'audio';
+/** Lifecycle stored on the server row. */
+export type ScheduledCallStatus = 'scheduled' | 'cancelled';
+/**
+ * Status carried by the room message. `updated` means the call was edited
+ * after the first invite; the card treats it like `scheduled`.
+ */
+export type ScheduledCallMessageStatus = 'scheduled' | 'updated' | 'cancelled';
+export interface ScheduledCall {
+    id?: string;
+    appId?: string;
+    chatName: string;
+    chatType?: 'private' | 'group' | 'public';
+    createdBy?: string;
+    title: string;
+    description?: string;
+    /** ISO 8601, UTC. */
+    startAt: string;
+    durationMinutes: number;
+    timezone?: string;
+    kind: ScheduledCallKind;
+    slug: string;
+    status: ScheduledCallStatus;
+    sequence?: number;
+    reminderSentAt?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/** Links are built by the backend only; clients never compose calendar URLs. */
+export interface ScheduledCallLinks {
+    join: string;
+    ics: string;
+    google: string;
+    outlook: string;
+    office365?: string;
+}
+export interface ScheduledCallWithLinks {
+    scheduledCall: ScheduledCall;
+    links: ScheduledCallLinks;
+}
+export interface ScheduledCallDetails extends ScheduledCallWithLinks {
+    chat: {
+        name: string;
+        title?: string;
+        type?: string;
+        jid: string;
+    };
+}
+export interface CreateScheduledCallInput {
+    chatName: string;
+    title?: string;
+    description?: string;
+    startAt: string;
+    durationMinutes?: number;
+    timezone?: string;
+    kind?: ScheduledCallKind;
+}
+export interface UpdateScheduledCallInput {
+    title?: string;
+    description?: string;
+    startAt?: string;
+    durationMinutes?: number;
+    kind?: ScheduledCallKind;
+}
+/**
+ * What a `<data type="scheduledCall">` message boils down to. Persisted on the
+ * message (like `callLog`) so a reloaded transcript repaints the card before
+ * the archive re-delivers the stanza.
+ */
+export interface ScheduledCallMeta {
+    slug: string;
+    title: string;
+    /** ISO 8601, UTC. */
+    startAt: string;
+    durationMinutes: number;
+    kind: ScheduledCallKind;
+    status: ScheduledCallMessageStatus;
+    /** Creator's user id (`scheduledCallCreatedBy`), decides who sees Edit and Cancel. */
+    createdBy?: string;
+    joinUrl?: string;
+    icsUrl?: string;
+    googleUrl?: string;
+    outlookUrl?: string;
+}
+/** Why a scheduled call could not be opened. */
+export type ScheduledCallOpenError = 'not-found' | 'not-a-member' | 'cancelled' | 'network';
+export interface ScheduledCallsConfig {
+    /**
+     * Scheduling and invite cards. Defaults to on whenever video calls are on
+     * (`config.videoCalls.enabled`). `false` hides the "Schedule call" action;
+     * invite cards still render so a room that already holds one stays readable,
+     * but without the Join button.
+     */
+    enabled?: boolean;
+    /**
+     * Called when `scheduledCallSlug` (or `openScheduledCall(slug)`) could not be
+     * opened. A host that wants its own error screen resolves the slug itself
+     * first; this is for the in-chat fallback.
+     */
+    onOpenError?: (error: {
+        slug: string;
+        reason: ScheduledCallOpenError;
+    }) => void;
+    /**
+     * Hosts whose `https://<host>/call/<slug>` links `parseScheduledCallLink`
+     * accepts on top of `app.chat.ethora.com` and the page's own host. Same option
+     * name and defaults as the React Native SDK.
+     */
+    hosts?: string[];
+    /**
+     * Custom URL schemes (without `://`) that `parseScheduledCallLink` accepts
+     * for `<scheme>://call/<slug>`. Unset accepts any scheme. Same option name
+     * as the React Native SDK.
+     */
+    schemes?: string[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethora/chat-component",
-  "version": "26.10.7",
+  "version": "26.10.8",
   "type": "module",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",