@ethora/chat-component 26.10.7 → 26.10.8

package/dist/calls/scheduledCall.d.ts

@@ -0,0 +1,101 @@
+import { ScheduledCall, ScheduledCallKind } from '../types/models/scheduledCall.model';
+/** Join opens this many minutes before the start (contract: 15). */
+export declare const JOIN_LEAD_MINUTES = 15;
+/** Server bounds (contract: duration 5..480, title 1..200, description 0..2000). */
+export declare const MIN_DURATION_MINUTES = 5;
+export declare const MAX_DURATION_MINUTES = 480;
+export declare const DEFAULT_DURATION_MINUTES = 30;
+export declare const MAX_TITLE_LENGTH = 200;
+export declare const MAX_DESCRIPTION_LENGTH = 2000;
+/** The server accepts a start up to 2 minutes in the past (clock skew). */
+export declare const START_SKEW_MS: number;
+/** Durations offered by the schedule form. */
+export declare const DURATION_PRESETS: readonly [15, 30, 45, 60, 90, 120];
+export type ScheduledCallPhase = 'upcoming' | 'joinable' | 'ended' | 'cancelled';
+type PhaseInput = Pick<ScheduledCall, 'startAt' | 'durationMinutes'> & {
+    status: 'scheduled' | 'updated' | 'cancelled';
+};
+/** Epoch ms of an ISO string; NaN when it does not parse. */
+export declare const toEpochMs: (iso: string | undefined | null) => number;
+export declare const getScheduledCallEndMs: (call: Pick<ScheduledCall, "startAt" | "durationMinutes">) => number;
+/** When the Join button becomes available (epoch ms). */
+export declare const getJoinOpensAtMs: (call: Pick<ScheduledCall, "startAt">) => number;
+/**
+ * Where a call is in its life. A call whose start does not parse is treated as
+ * ended, never joinable: the Join button must not guess.
+ */
+export declare const getScheduledCallPhase: (call: PhaseInput, now?: number) => ScheduledCallPhase;
+/** Minutes until the join window opens, rounded up; 0 once it is open. */
+export declare const minutesUntilJoinOpens: (call: Pick<ScheduledCall, "startAt">, now?: number) => number;
+/** `YYYY-MM-DD` in the local time zone, the value of an <input type="date">. */
+export declare const toLocalDateInput: (date: Date) => string;
+/** `HH:mm` in the local time zone, the value of an <input type="time">. */
+export declare const toLocalTimeInput: (date: Date) => string;
+/**
+ * Local `YYYY-MM-DD` + `HH:mm` -> Date. Null when either part is malformed or
+ * names a date that does not exist (Feb 30 would otherwise roll into March).
+ */
+export declare const combineLocalDateTime: (dateValue: string, timeValue: string) => Date | null;
+/** The default start of a new call: the next quarter hour, at least 15 min ahead. */
+export declare const defaultScheduleStart: (now?: Date) => Date;
+export interface ScheduleFormValues {
+    title: string;
+    description: string;
+    /** `YYYY-MM-DD`, local. */
+    date: string;
+    /** `HH:mm`, local. */
+    time: string;
+    durationMinutes: number;
+    kind: ScheduledCallKind;
+}
+export type ScheduleFormErrorKey = 'title' | 'description' | 'start' | 'startPast' | 'duration';
+export type ScheduleFormErrors = Partial<Record<ScheduleFormErrorKey, true>>;
+/**
+ * Client-side mirror of the server rules, so the form can say what is wrong
+ * before a round trip. `skipPastCheck` is for editing a call that already
+ * started or whose time is left unchanged.
+ */
+export declare const validateScheduleForm: (values: ScheduleFormValues, now?: number, options?: {
+    skipPastCheck?: boolean;
+}) => ScheduleFormErrors;
+/** Presets plus the call's own duration when it is not one of them (edit). */
+export declare const durationOptions: (current?: number) => number[];
+export declare const localTimeZone: () => string | undefined;
+export interface ScheduledCallLinkOptions {
+    /** Hosts accepted for `https://<host>/call/<slug>`. Empty or unset: any host. */
+    hosts?: string[];
+    /** Schemes accepted for `<scheme>://call/<slug>`. Empty or unset: any scheme. */
+    schemes?: string[];
+}
+export declare const isValidScheduledCallSlug: (value: unknown) => value is string;
+/**
+ * The slug of a scheduled-call join link, or null when `url` is not one.
+ * Accepts the canonical `https://<host>/call/<slug>` and the app-scheme form
+ * `<scheme>://call/<slug>`. `options.hosts` / `options.schemes` narrow what is
+ * accepted (plain http and script-like schemes never are). Same name and
+ * contract as the React Native SDK.
+ */
+export declare const parseScheduledCallLink: (url: unknown, options?: ScheduledCallLinkOptions) => string | null;
+/**
+ * Link attributes ride on a room message any member could forge, so a button
+ * only gets a link that is plausible for what it says it is: http(s) only
+ * (never `javascript:`), the calendar buttons only on the calendar providers'
+ * own hosts, and the .ics link only on the API host the chat already talks to
+ * (when that is known) and for this call's slug.
+ */
+export declare const safeCalendarLink: (kind: "google" | "outlook" | "ics", value: unknown, context: {
+    slug: string;
+    apiBaseUrl?: string | null;
+}) => string | null;
+/**
+ * A link from the authenticated API (the pre-join panel). Trusted as far as
+ * the origin goes, but still http(s) only.
+ */
+export declare const httpLinkOrNull: (value: unknown) => string | null;
+/**
+ * The title to show. The backend defaults an omitted title to the English
+ * word `Call`, so that exact value (and an empty one) is shown in the viewer's
+ * language instead.
+ */
+export declare const displayCallTitle: (title: string | undefined | null, defaultTitle: string) => string;
+export {};

package/dist/calls/scheduledCallActions.d.ts

@@ -0,0 +1,12 @@
+import { Dispatch } from '@reduxjs/toolkit';
+import { RootState } from '../roomStore';
+import { ScheduledCallDetails } from '../types/models/scheduledCall.model';
+/**
+ * Fetches one scheduled call into the slice's details cache. Cards call this
+ * when they appear, so it is deduped: a call already loading or loaded (and
+ * not `force`d) is left alone. Never throws; a failure is recorded on the
+ * entry and the card falls back to what the room message carried.
+ */
+export declare function loadScheduledCallDetails(dispatch: Dispatch, getState: () => RootState, slug: string, options?: {
+    force?: boolean;
+}): Promise<ScheduledCallDetails | null>;

package/dist/calls/scheduledCallFormat.d.ts

@@ -0,0 +1,13 @@
+type Translate = (key: string, vars?: Record<string, string | number>) => string;
+/** "Wed, Oct 22" in the viewer's local time zone and the UI locale. */
+export declare const formatScheduledDay: (startAt: string, locale?: string) => string;
+/** "3:00 PM - 3:30 PM" (end time only when it can be computed). */
+export declare const formatScheduledTimeRange: (call: {
+    startAt: string;
+    durationMinutes: number;
+}, locale?: string) => string;
+/** Clock time of an instant, e.g. when the join window opens. */
+export declare const formatClockTime: (ms: number, locale?: string) => string;
+/** "30 min", "2 h", "1 h 30 min". */
+export declare const formatScheduledDuration: (minutes: number, t: Translate) => string;
+export {};

package/dist/calls/scheduledCallsConfig.d.ts

@@ -0,0 +1,27 @@
+import { IConfig } from '../types/types';
+/**
+ * Scheduled calls are on whenever video calls are on, unless the host sets
+ * `config.scheduledCalls.enabled: false`. Never on without calls: a booked
+ * call has to be joinable through the same call path.
+ */
+export declare const isScheduledCallsEnabled: (config: Pick<IConfig, "videoCalls" | "scheduledCalls"> | null | undefined) => boolean;
+/**
+ * Whether a call can be placed in a room of this type under this config: the
+ * same gate the chat header uses for its call buttons (master switch, room
+ * type, LiveKit URL). Join on a scheduled call is offered only when true.
+ */
+export declare const canPlaceCallsInRoom: (config: Pick<IConfig, "videoCalls"> | null | undefined, roomType: string | undefined | null) => boolean;
+/**
+ * Edit and Cancel are for the person who scheduled the call and for the room
+ * owner. The server enforces the same rule (403); this only decides whether
+ * to offer the buttons. `callCreatedBy` is unknown until the call has been
+ * fetched, and an unknown creator never grants anything.
+ */
+export declare const canManageScheduledCall: (params: {
+    userId?: string | null;
+    callCreatedBy?: string | null;
+    room?: {
+        createdBy?: string;
+        role?: string;
+    } | null;
+}) => boolean;

package/dist/calls/senderTrust.d.ts

@@ -0,0 +1,7 @@
+/**
+ * True when `fromJid` is the app's system account. The resource is ignored.
+ * When `expectedDomain` is given the sender must also be on that XMPP domain,
+ * so a same-looking account on a federated server is not accepted. A missing
+ * or malformed JID is never trusted.
+ */
+export declare const isSystemAccountSender: (fromJid: unknown, expectedDomain?: string | null) => boolean;

package/dist/calls/startCall.d.ts

@@ -0,0 +1,16 @@
+import { CallKindName } from './callMode';
+/**
+ * Second half of placing a call, shared by every dial entry point (chat
+ * header, profile modal): POST /v1/chats/call/create and record how the server
+ * decided to carry the call in the call slice. The caller has already
+ * dispatched startOutgoingCall.
+ *
+ * Throws when the request fails (the entry point shows the message). A p2p
+ * answer that lands after the user already cancelled is cleaned up here: the
+ * server has already rung the callee, and nothing else knows its callId.
+ */
+export declare function requestOutgoingCall(params: {
+    chatName: string;
+    kind: CallKindName;
+    peerXmppUsername?: string | null;
+}): Promise<void>;

package/dist/components/MainComponents/ChatWrapper.d.ts

@@ -11,6 +11,7 @@ interface ChatWrapperProps {
     MainComponentStyles?: React.CSSProperties;
     config?: IConfig;
     roomJID?: string;
+    scheduledCallSlug?: string;
 }
 declare const ChatWrapper: FC<ChatWrapperProps>;
 export { ChatWrapper };

package/dist/components/MainComponents/LoginWrapper.d.ts

@@ -9,6 +9,7 @@ interface LoginWrapperProps extends Partial<Pick<CustomComponentsContextValue, '
     MainComponentStyles?: React.CSSProperties;
     config?: IConfig;
     roomJID?: string;
+    scheduledCallSlug?: string;
 }
 declare const LoginWrapper: React.FC<LoginWrapperProps>;
 export default LoginWrapper;

package/dist/components/MainComponents/ProfileImagePlaceholder.d.ts

@@ -16,6 +16,7 @@ interface ProfileImagePlaceholderProps {
     active?: boolean;
     placeholderIcon?: React.ReactNode;
     disableOverlay?: boolean;
+    fileInputId?: string;
     /** Show a green online-status dot on the avatar. */
     online?: boolean;
 }

package/dist/components/MainComponents/ReduxWrapper.d.ts

@@ -4,6 +4,12 @@ import { CustomComponentsContextValue } from '../../types/models/customComponent
 export interface ChatWrapperProps extends Pick<CustomComponentsContextValue, 'CustomMessageComponent' | 'CustomInputComponent' | 'CustomScrollableArea' | 'CustomDaySeparator' | 'CustomNewMessageLabel'> {
     token?: string;
     roomJID?: string;
+    /**
+     * Open a scheduled call: once signed in, select its room and show the
+     * pre-join panel. The slug is the last part of a `/call/<slug>` join link
+     * (see `parseScheduledCallLink`). Nothing starts until the user taps Join.
+     */
+    scheduledCallSlug?: string;
     user?: ConfigUser;
     loginData?: {
         email: string;

package/dist/components/MenuRoom/MenuRoom.d.ts

@@ -3,6 +3,7 @@ interface RoomMenuProps {
     roomJid?: string;
     handleLeaveClick: () => void;
     handleReportClick: () => void;
+    isModerator?: boolean;
     handleBlockClick?: () => void;
     canBlock?: boolean;
 }

package/dist/components/Modals/NewChatModal/styledNewChatComponents.d.ts

@@ -1,3 +1,30 @@
+export declare const AvatarPicker: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "style"> & {
+    style?: import('react').CSSProperties | import('styled-components/dist/types').CSSPropertiesWithVars;
+}> & string;
+export declare const AvatarPickerActions: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "style"> & {
+    style?: import('react').CSSProperties | import('styled-components/dist/types').CSSPropertiesWithVars;
+}> & string;
+export declare const TextAction: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "style"> & {
+    style?: import('react').CSSProperties | import('styled-components/dist/types').CSSPropertiesWithVars;
+}> & string;
+export declare const MemberPickerHeader: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "style"> & {
+    style?: import('react').CSSProperties | import('styled-components/dist/types').CSSPropertiesWithVars;
+}> & string;
+export declare const MemberPickerAction: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<any, "style"> & {
+    style?: any;
+}> & string;
+export declare const MemberCount: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "style"> & {
+    style?: import('react').CSSProperties | import('styled-components/dist/types').CSSPropertiesWithVars;
+}> & string;
+export declare const MemberPickerSection: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "style"> & {
+    style?: import('react').CSSProperties | import('styled-components/dist/types').CSSPropertiesWithVars;
+}> & string;
+export declare const ModalHint: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "style"> & {
+    style?: import('react').CSSProperties | import('styled-components/dist/types').CSSPropertiesWithVars;
+}> & string;
+export declare const HiddenFileInput: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<import('react').DetailedHTMLProps<import('react').InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "style"> & {
+    style?: import('react').CSSProperties | import('styled-components/dist/types').CSSPropertiesWithVars;
+}> & string;
 export declare const ChatTypeGroup: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "style"> & {
     style?: import('react').CSSProperties | import('styled-components/dist/types').CSSPropertiesWithVars;
 }> & string;

package/dist/components/Modals/styledModalComponents.d.ts

@@ -15,6 +15,27 @@ export declare const ModalContainer: import('styled-components/dist/types').ISty
 export declare const ModalTitle: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "style"> & {
     style?: import('react').CSSProperties | import('styled-components/dist/types').CSSPropertiesWithVars;
 }> & string;
+/** New-chat dialog keeps its chrome and actions visible while a long member
+ * picker scrolls independently in the middle. */
+export declare const NewChatDialog: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Merged<Omit<any, "style"> & {
+    style?: any;
+}, {
+    $closing?: boolean;
+}>> & string;
+export declare const NewChatBackdrop: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Merged<Omit<any, "style"> & {
+    style?: any;
+}, {
+    $closing?: boolean;
+}>> & string;
+export declare const NewChatDialogHeader: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLElement>, HTMLElement>, "style"> & {
+    style?: import('react').CSSProperties | import('styled-components/dist/types').CSSPropertiesWithVars;
+}> & string;
+export declare const NewChatDialogBody: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "style"> & {
+    style?: import('react').CSSProperties | import('styled-components/dist/types').CSSPropertiesWithVars;
+}> & string;
+export declare const NewChatDialogFooter: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLElement>, HTMLElement>, "style"> & {
+    style?: import('react').CSSProperties | import('styled-components/dist/types').CSSPropertiesWithVars;
+}> & string;
 /** Small uppercase-weight label above a field/list inside a modal - e.g. "Select Users (max 20)". */
 export declare const ModalSectionLabel: import('styled-components/dist/types').IStyledComponentBase<"web", Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "style"> & {
     style?: import('react').CSSProperties | import('styled-components/dist/types').CSSPropertiesWithVars;

package/dist/components/ScheduledCalls/ScheduleCallModal.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+export declare const ScheduleCallModal: React.FC;
+export default ScheduleCallModal;

package/dist/components/ScheduledCalls/ScheduledCallCancelConfirm.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+/**
+ * "Cancel this call?" confirmation. Mounted by ScheduledCallLayer, not by the
+ * card: a fixed overlay rendered inside the message list is bounded by the
+ * list's ancestors and came out clipped on the left.
+ */
+export declare const ScheduledCallCancelConfirm: React.FC;
+export default ScheduledCallCancelConfirm;

package/dist/components/ScheduledCalls/ScheduledCallCard.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { IMessage } from '../../types/types';
+interface Props {
+    message: IMessage;
+}
+export declare const ScheduledCallCard: React.FC<Props>;
+export default ScheduledCallCard;

package/dist/components/ScheduledCalls/ScheduledCallLayer.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+interface Props {
+    /** `<Chat scheduledCallSlug>`: open this call's room and pre-join panel. */
+    scheduledCallSlug?: string;
+    /** Narrow screens show the room list first; this brings the room forward. */
+    onRevealRoom?: () => void;
+}
+/**
+ * Everything scheduled calls need inside a mounted chat: the schedule form,
+ * the pre-join panel, and the opener that turns a slug (host prop or
+ * `openScheduledCall(slug)`) into "room selected, pre-join panel up". Mounted
+ * once the chat shell is up, so the room list is already there to select from.
+ */
+export declare const ScheduledCallLayer: React.FC<Props>;
+export default ScheduledCallLayer;

package/dist/components/ScheduledCalls/ScheduledCallPreJoin.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+export declare const ScheduledCallPreJoin: React.FC;
+export default ScheduledCallPreJoin;

package/dist/components/VideoCalls/P2PCallRunner.d.ts

@@ -0,0 +1 @@
+export declare const P2PCallRunner: React.FC;

package/dist/components/VideoCalls/P2PCallSession.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { VideoCallIcons } from '../../types/models/config.model';
+import { P2PCallController } from '../../calls/p2p/P2PCallController';
+/** The controller of the call on screen, re-rendering when it is swapped. */
+export declare const useActiveP2PController: () => P2PCallController | null;
+export interface P2PCallSessionProps {
+    kind?: 'audio' | 'video';
+    primaryColor?: string;
+    icons?: VideoCallIcons;
+    minimized?: boolean;
+    onToggleMinimize?: () => void;
+    onHangup: () => void;
+}
+export declare const P2PCallSession: React.FC<P2PCallSessionProps>;

package/dist/components/VideoCalls/VideoCallSession.d.ts

@@ -33,8 +33,45 @@ interface VideoCallSessionProps {
      * receives it. See VideoCallOverlay.
      */
     onParticipantJoined?: () => void;
+    /**
+     * Group room call: render every participant in a grid and keep the call
+     * alive while other people remain. A 1:1 call (default) ends locally as
+     * soon as the single remote peer leaves.
+     */
+    isGroup?: boolean;
     onNoAnswer?: () => void;
     noAnswerTimeoutMs?: number;
 }
+export declare const TEXT_PRIMARY = "var(--ethora-color-text, #141414)";
+export declare const TEXT_MUTED = "var(--ethora-call-text-muted, #8c8c8c)";
+export declare const SURFACE = "var(--ethora-color-bg, #fff)";
+export declare const SURFACE_MUTED = "var(--ethora-color-chat-bg, #f3f6fc)";
+export declare const DIVIDER = "var(--ethora-color-bg-hover, #f0f0f0)";
+export declare const DANGER = "#E53935";
+export declare const MicOnIcon: React.FC<{
+    color?: string;
+}>;
+export declare const MicOffIcon: React.FC<{
+    color?: string;
+    cutColor?: string;
+}>;
+export declare const CamOnIcon: React.FC<{
+    color?: string;
+}>;
+export declare const CamOffIcon: React.FC<{
+    color?: string;
+    cutColor?: string;
+}>;
+export declare const MinimizeIcon: React.FC<{
+    color?: string;
+}>;
+export declare const ExpandIcon: React.FC<{
+    color?: string;
+}>;
+export declare const hexToRgba: (hex: string, alpha: number) => string;
+export declare const formatDuration: (totalSeconds: number) => string;
+type ToneVariant = 'neutral' | 'active' | 'danger';
+export declare const toneStyle: (tone: ToneVariant, primary: string, background?: string) => React.CSSProperties;
+export declare const controlButtonBase: React.CSSProperties;
 export declare const VideoCallSession: React.FC<VideoCallSessionProps>;
 export {};

package/dist/{handleCopyClick-BUbVvd2G.js → handleCopyClick-BX1fcFGN.js}

@@ -1,4 +1,4 @@
-import { U as e, X as t } from "./main-CpHMnydn.js";
+import { a4 as e, a6 as t } from "./main-B25iFKAC.js";
 const i = e.div`
   display: flex;
   flex-direction: column;

package/dist/helpers/callPush.d.ts

@@ -11,6 +11,8 @@ export interface ParsedCallPush {
     callerName: string | null;
     /** Caller's xmpp localpart, when provided. */
     callerXmppUsername: string | null;
+    /** The call is for a group room (always LiveKit). */
+    isGroup: boolean;
 }
 /**
  * True when a push `data` payload represents an incoming call. Matches on an

package/dist/helpers/canLeaveRoom.d.ts

@@ -0,0 +1,3 @@
+import { ConfigRoom } from '../types/models/room.model';
+/** Ordinary rooms are leaveable; configured app rooms require an explicit opt-in. */
+export declare const canLeaveRoom: (jid: string | undefined, defaultRooms: ConfigRoom[] | undefined) => boolean;

package/dist/helpers/chatComponentConfigEvents.d.ts

@@ -0,0 +1,16 @@
+/**
+ * In-process bus for the `chat-component-config-updated` server event, so the
+ * XMPP stanza handler (networking/ethoraEvents.ts) and whoever acts on it
+ * (`config.remoteAppearance`, see hooks/useRemoteAppearance.ts) do not import
+ * each other.
+ */
+export interface ChatComponentConfigUpdatedEvent {
+    appId: string;
+    /** Opaque state id from the server, pass it to the config endpoint as `v`. */
+    version: string;
+}
+type Listener = (event: ChatComponentConfigUpdatedEvent) => void;
+export declare const subscribeChatComponentConfigUpdated: (listener: Listener) => (() => void);
+export declare const publishChatComponentConfigUpdated: (event: ChatComponentConfigUpdatedEvent) => void;
+export declare const resetChatComponentConfigListeners: () => void;
+export {};

package/dist/helpers/liveConfig.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Which `config` keys the chat applies LIVE, and how an operator-saved record
+ * is laid over the host's config.
+ *
+ * Live means: changing the key on a mounted chat re-renders the affected
+ * pieces from the store and the CSS variables, with the XMPP connection, the
+ * rooms, the messages and every draft left alone. The list is exactly the
+ * visual and layout switches; everything else (identity, endpoints, login,
+ * history, e2ee, receipts, ...) is read when the chat starts and a new value
+ * is picked up by the next mount.
+ *
+ * The keys below also form the allowlist for `config.remoteAppearance`: a
+ * record fetched from the server can set these keys and no others, each with
+ * a strict validator, because the record comes over the network and ends up
+ * in CSS variables and a stylesheet.
+ */
+type Parse = (value: unknown) => string | boolean | number | null;
+/** Live keys and their validators. Mirrors ethora-backend modules/apps/chatComponentConfig.js. */
+export declare const LIVE_CONFIG_KEYS: Readonly<Record<string, Parse>>;
+export declare const isLiveConfigPath: (path: string) => boolean;
+/** Flattens to dotted leaf paths. Functions, nodes and class instances are leaves compared by identity. */
+export declare const flattenConfig: (input: unknown, out?: Map<string, unknown>, prefix?: string, depth?: number) => Map<string, unknown>;
+export interface ConfigChange {
+    /** Changed paths the chat applies live. */
+    live: string[];
+    /** Changed paths read when the chat starts: applied by the next mount. */
+    restart: string[];
+}
+/**
+ * Splits what differs between two host configs into live and start-time
+ * paths. A function that is a new closure on every render counts as changed
+ * (it is compared by identity) and lands in `restart`; that only affects the
+ * log line, the chat applies the whole new config either way.
+ */
+export declare function classifyConfigChange(prev: unknown, next: unknown): ConfigChange;
+export type RemoteConfigRecord = Record<string, string | boolean | number>;
+/**
+ * Keeps only allowlisted keys with a valid value. Anything else (an unknown
+ * key, a wrong type, markup, a URL, an out of range number) is dropped, so a
+ * wrong or hostile answer cannot do more than restyle the chat within the
+ * validators' limits.
+ */
+export declare function parseRemoteConfigRecord(raw: unknown): RemoteConfigRecord;
+/** The config with the record laid over it, copying only the objects on the way. Siblings stay. */
+export declare function applyRemoteConfigRecord<T extends object | undefined>(base: T, record: RemoteConfigRecord | null | undefined): T;
+export {};

package/dist/helpers/reportRoom.d.ts

@@ -0,0 +1,18 @@
+import { PostReportRoom } from '../types/models/room.model';
+export interface ReportCategory {
+    id: string;
+    labelKey: string;
+    apiCategory: string;
+    /** English name, used in `text` (the report e-mail is not localized). */
+    name: string;
+}
+export declare const REPORT_CATEGORIES: ReportCategory[];
+export declare const OTHER_REPORT_CATEGORY: ReportCategory;
+export declare const findReportCategory: (id: string) => ReportCategory | undefined;
+/**
+ * The request body for a room report. `roomJid` may be the full room JID or
+ * the bare room name: the route takes the bare name (JID localpart), like
+ * every other /v1/chats/... route. Returns null for an unknown category or
+ * an empty room.
+ */
+export declare const buildReportRoomPayload: (roomJid: string, categoryId: string, details?: string) => PostReportRoom | null;

package/dist/helpers/scheduledCallMessage.d.ts

@@ -0,0 +1,23 @@
+import { IMessage } from '../types/types';
+import { ScheduledCallMeta } from '../types/models/scheduledCall.model';
+export declare const SCHEDULED_CALL_MESSAGE_TYPE = "scheduledCall";
+/**
+ * Reads the scheduled-call fields off a message. Null when the message is not
+ * one, or when it lacks what a card cannot do without (a valid slug and a
+ * parseable start); such a message falls back to its plain body.
+ *
+ * `apiBaseUrl` is the API the chat talks to, used to vet the .ics link.
+ */
+export declare const parseScheduledCallMeta: (message: unknown, apiBaseUrl?: string | null) => ScheduledCallMeta | null;
+/**
+ * createMessageFromXml hook: attaches `scheduledCall` meta to a message that
+ * is one. Everything else comes back untouched (same object).
+ */
+export declare const attachScheduledCallMeta: (message: IMessage, apiBaseUrl?: string | null) => IMessage;
+/**
+ * One card per slug: of all messages that announce the same scheduled call
+ * only the newest stays, so an `updated` or `cancelled` message replaces the
+ * card instead of stacking under it. Order of everything else is kept, and the
+ * input is returned as is when no call is announced twice.
+ */
+export declare const collapseScheduledCallMessages: (messages: IMessage[]) => IMessage[];

package/dist/helpers/storeConsole.d.ts

@@ -3,4 +3,5 @@ export declare const useStoreConsole: () => {
     rooms: Record<string, any> & import('redux-persist/es/persistReducer').PersistPartial;
     roomHeapSlice: import('../roomStore/roomHeapSlice').roomHeapSliceState;
     call: import('immer').WritableDraft<import('../roomStore/callSlice').CallState>;
+    scheduledCall: import('immer').WritableDraft<import('../roomStore/scheduledCallSlice').ScheduledCallState>;
 };

package/dist/hooks/useNow.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `Date.now()` that re-renders its component every `intervalMs` while
+ * `enabled`. For things that change with the clock (a Join button that opens
+ * 15 minutes before the start) without each caller owning a timer.
+ */
+export declare const useNow: (intervalMs: number, enabled?: boolean) => number;

package/dist/hooks/useRemoteAppearance.d.ts

@@ -0,0 +1,21 @@
+import { IConfig } from '../types/types';
+import { RemoteConfigRecord } from '../helpers/liveConfig';
+export declare const DEFAULT_REMOTE_APPEARANCE_WAIT_MS = 2500;
+export interface RemoteAppearanceState {
+    /** The record to lay over the host config; null until the first read settles. */
+    record: RemoteConfigRecord | null;
+    /** True while the chat should hold its first paint for the first read. */
+    waiting: boolean;
+}
+/**
+ * `config.remoteAppearance`: reads the App's chat component config from the
+ * server and keeps it current. Reads once on mount (the chat waits for it, at
+ * most `initialWaitMs`, so it starts once with its final look), then again
+ * every time the server announces a new version with a
+ * `chat-component-config-updated` event. The newest read wins, a failed read
+ * keeps what is shown, and a version that is already shown is not fetched
+ * again.
+ *
+ * Does nothing (and never waits) when the host did not opt in.
+ */
+export declare function useRemoteAppearance(config?: IConfig): RemoteAppearanceState;

package/dist/hooks/useTypography.d.ts

@@ -4,5 +4,9 @@ import { TypographyConfig } from '../types/models/config.model';
  * Wired into the chat root (ReduxWrapper) so the font is in place before the
  * UI paints. No-op when `typography` is undefined - the default system font
  * stack is kept, so existing integrations are unaffected.
+ *
+ * When `typography` goes away on a mounted chat (the operator cleared the
+ * font in the admin tab), what this hook applied is removed again and the
+ * default stack is back, with no reload.
  */
 export declare function useTypography(typography?: TypographyConfig): void;