@ermis-network/ermis-chat-sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1469 @@
+import { AxiosRequestConfig, AxiosResponse, AxiosInstance } from 'axios';
+import WebSocket from 'isomorphic-ws';
+
+/**
+ * StableWSConnection - A WS connection that reconnects upon failure.
+ * - the browser will sometimes report that you're online or offline
+ * - the WS connection can break and fail (there is a 30s health check)
+ * - sometimes your WS connection will seem to work while the user is in fact offline
+ * - to speed up online/offline detection you can use the window.addEventListener('offline');
+ *
+ * There are 4 ways in which a connection can become unhealthy:
+ * - websocket.onerror is called
+ * - websocket.onclose is called
+ * - the health check fails and no event is received for ~40 seconds
+ * - the browser indicates the connection is now offline
+ *
+ * There are 2 assumptions we make about the server:
+ * - state can be recovered by querying the channel again
+ * - if the servers fails to publish a message to the client, the WS connection is destroyed
+ */
+declare class StableWSConnection<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> {
+    client: ErmisChat<ErmisChatGenerics>;
+    connectionOpen?: ConnectAPIResponse<ErmisChatGenerics>;
+    consecutiveFailures: number;
+    pingInterval: number;
+    healthCheckTimeoutRef?: NodeJS.Timeout;
+    isConnecting: boolean;
+    isDisconnected: boolean;
+    isHealthy: boolean;
+    isResolved?: boolean;
+    lastEvent: Date | null;
+    connectionCheckTimeout: number;
+    connectionCheckTimeoutRef?: NodeJS.Timeout;
+    rejectPromise?: (reason?: Error & {
+        code?: string | number;
+        isWSFailure?: boolean;
+        StatusCode?: string | number;
+    }) => void;
+    requestID: string | undefined;
+    resolvePromise?: (value: ConnectionOpen<ErmisChatGenerics>) => void;
+    totalFailures: number;
+    ws?: WebSocket;
+    wsID: number;
+    constructor({ client }: {
+        client: ErmisChat<ErmisChatGenerics>;
+    });
+    _log(msg: string, extra?: UR, level?: LogLevel): void;
+    setClient(client: ErmisChat<ErmisChatGenerics>): void;
+    connect(timeout?: number): Promise<void | ConnectionOpen<ErmisChatGenerics>>;
+    /**
+     * _waitForHealthy polls the promise connection to see if its resolved until it times out
+     * the default 15s timeout allows between 2~3 tries
+     * @param timeout duration(ms)
+     */
+    _waitForHealthy(timeout?: number): Promise<void | ConnectionOpen<ErmisChatGenerics>>;
+    /**
+     * Builds and returns the url for websocket.
+     * @private
+     * @returns url string
+     */
+    _buildUrl: () => string;
+    /**
+     * disconnect - Disconnect the connection and doesn't recover...
+     *
+     */
+    disconnect(timeout?: number): Promise<void>;
+    _connect(): Promise<ConnectionOpen<ErmisChatGenerics> | undefined>;
+    /**
+     * _reconnect - Retry the connection to WS endpoint
+     *
+     * @param {{ interval?: number; refreshToken?: boolean }} options Following options are available
+     *
+     * - `interval`	{int}			number of ms that function should wait before reconnecting
+     * - `refreshToken` {boolean}	reload/refresh user token be refreshed before attempting reconnection.
+     */
+    _reconnect(options?: {
+        interval?: number;
+        refreshToken?: boolean;
+    }): Promise<void>;
+    /**
+     * onlineStatusChanged - this function is called when the browser connects or disconnects from the internet.
+     *
+     * @param {Event} event Event with type online or offline
+     *
+     */
+    onlineStatusChanged: (event: Event) => void;
+    onopen: (wsID: number) => void;
+    onmessage: (wsID: number, event: WebSocket.MessageEvent) => void;
+    onclose: (wsID: number, event: WebSocket.CloseEvent) => void;
+    onerror: (wsID: number, event: WebSocket.ErrorEvent) => void;
+    /**
+     * _setHealth - Sets the connection to healthy or unhealthy.
+     * Broadcasts an event in case the connection status changed.
+     *
+     * @param {boolean} healthy boolean indicating if the connection is healthy or not
+     *
+     */
+    _setHealth: (healthy: boolean) => void;
+    /**
+     * _errorFromWSEvent - Creates an error object for the WS event
+     *
+     */
+    _errorFromWSEvent: (event: WebSocket.CloseEvent | WebSocket.Data | WebSocket.ErrorEvent, isWSFailure?: boolean) => Error & {
+        code?: string | number;
+        isWSFailure?: boolean;
+        StatusCode?: string | number;
+    };
+    /**
+     * _destroyCurrentWSConnection - Removes the current WS connection
+     *
+     */
+    _destroyCurrentWSConnection(): void;
+    /**
+     * _setupPromise - sets up the this.connectOpen promise
+     */
+    _setupConnectionPromise: () => void;
+    /**
+     * Schedules a next health check ping for websocket.
+     */
+    scheduleNextPing: () => void;
+    /**
+     * scheduleConnectionCheck - schedules a check for time difference between last received event and now.
+     * If the difference is more than 35 seconds, it means our health check logic has failed and websocket needs
+     * to be reconnected.
+     */
+    scheduleConnectionCheck: () => void;
+}
+
+declare const EVENT_MAP: {
+    'channel.created': boolean;
+    'channel.deleted': boolean;
+    'channel.truncate': boolean;
+    'channel.updated': boolean;
+    'channel.pinned': boolean;
+    'channel.unpinned': boolean;
+    'health.check': boolean;
+    'member.added': boolean;
+    'member.removed': boolean;
+    'member.updated': boolean;
+    'member.joined': boolean;
+    'member.promoted': boolean;
+    'member.demoted': boolean;
+    'member.banned': boolean;
+    'member.unbanned': boolean;
+    'member.blocked': boolean;
+    'member.unblocked': boolean;
+    'message.deleted': boolean;
+    'message.deleted_for_me': boolean;
+    'message.new': boolean;
+    'message.read': boolean;
+    'message.updated': boolean;
+    'message.pinned': boolean;
+    'message.unpinned': boolean;
+    'notification.channel_deleted': boolean;
+    'notification.invite_accepted': boolean;
+    'notification.invite_rejected': boolean;
+    'notification.invite_messaging_skipped': boolean;
+    'pollchoice.new': boolean;
+    'reaction.deleted': boolean;
+    'reaction.new': boolean;
+    'typing.start': boolean;
+    'typing.stop': boolean;
+    'user.watching.start': boolean;
+    'user.watching.stop': boolean;
+    'connection.changed': boolean;
+    'connection.recovered': boolean;
+    'capabilities.changed': boolean;
+    'channel.topic.disabled': boolean;
+    'channel.topic.enabled': boolean;
+    'channel.topic.created': boolean;
+    'channel.topic.closed': boolean;
+    'channel.topic.reopen': boolean;
+    'channel.topic.updated': boolean;
+};
+
+type Role = 'owner' | 'moder' | 'member' | 'pending' | 'skipped' | string;
+type UR = Record<string, unknown>;
+type DefaultGenerics = {
+    attachmentType: UR;
+    channelType: UR;
+    commandType: LiteralStringForUnion;
+    eventType: UR;
+    messageType: UR;
+    pollOptionType: UR;
+    pollType: UR;
+    reactionType: UR;
+    userType: UR;
+};
+type ExtendableGenerics = {
+    attachmentType: UR;
+    channelType: UR;
+    commandType: string;
+    eventType: UR;
+    messageType: UR;
+    pollOptionType: UR;
+    pollType: UR;
+    reactionType: UR;
+    userType: UR;
+};
+/**
+ * Response Types
+ */
+type APIResponse = {
+    duration?: string;
+};
+type ChannelResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = ErmisChatGenerics['channelType'] & {
+    cid: string;
+    id: string;
+    type: string;
+    created_at?: string;
+    created_by?: UserResponse<ErmisChatGenerics> | null;
+    deleted_at?: string;
+    last_message_at?: string;
+    member_count?: number;
+    members: ChannelMemberResponse<ErmisChatGenerics>[];
+    name?: string;
+    own_capabilities?: string[];
+    updated_at?: string;
+    image?: string;
+    description?: string;
+    member_message_cooldown?: number;
+    member_capabilities?: string[];
+    is_pinned?: boolean;
+    topics_enabled?: boolean;
+    is_closed_topic?: boolean;
+};
+type QueryChannelsAPIResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = APIResponse & {
+    channels: Omit<ChannelAPIResponse<ErmisChatGenerics>, keyof APIResponse>[];
+};
+type QueryChannelAPIResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = APIResponse & ChannelAPIResponse<ErmisChatGenerics>;
+type ChannelAPIResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+    channel: ChannelResponse<ErmisChatGenerics>;
+    members: ChannelMemberResponse<ErmisChatGenerics>[];
+    messages: MessageResponse<ErmisChatGenerics>[];
+    pinned_messages: MessageResponse<ErmisChatGenerics>[];
+    membership?: ChannelMembership<ErmisChatGenerics> | null;
+    read?: ReadResponse<ErmisChatGenerics>[];
+    topics?: QueryChannelAPIResponse<ErmisChatGenerics>[];
+    watcher_count?: number;
+    watchers?: UserResponse<ErmisChatGenerics>[];
+    is_pinned?: boolean;
+};
+type ChannelMemberResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+    banned?: boolean;
+    blocked?: boolean;
+    channel_role?: Role;
+    created_at?: string;
+    updated_at?: string;
+    user?: UserResponse<ErmisChatGenerics>;
+    user_id?: string;
+};
+type ConnectAPIResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = Promise<void | ConnectionOpen<ErmisChatGenerics>>;
+type FormatMessageResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = Omit<MessageResponse<{
+    attachmentType: ErmisChatGenerics['attachmentType'];
+    channelType: ErmisChatGenerics['channelType'];
+    commandType: ErmisChatGenerics['commandType'];
+    eventType: ErmisChatGenerics['eventType'];
+    messageType: {};
+    pollOptionType: ErmisChatGenerics['pollOptionType'];
+    pollType: ErmisChatGenerics['pollType'];
+    reactionType: ErmisChatGenerics['reactionType'];
+    userType: ErmisChatGenerics['userType'];
+}>, 'created_at' | 'pinned_at' | 'updated_at' | 'status'> & ErmisChatGenerics['messageType'] & {
+    created_at: Date;
+    pinned_at: Date | null;
+    status: string;
+    updated_at: Date;
+};
+type MessageResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = MessageResponseBase<ErmisChatGenerics> & {
+    quoted_message?: MessageResponseBase<ErmisChatGenerics>;
+};
+type MessageResponseBase<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = MessageBase<ErmisChatGenerics> & {
+    type: MessageLabel;
+    channel?: ChannelResponse<ErmisChatGenerics>;
+    cid?: string;
+    created_at?: string;
+    deleted_at?: string;
+    latest_reactions?: ReactionResponse<ErmisChatGenerics>[];
+    mentioned_users?: string[];
+    own_reactions?: ReactionResponse<ErmisChatGenerics>[] | null;
+    pinned_at?: string | null;
+    pinned_by?: UserResponse<ErmisChatGenerics> | null;
+    reaction_counts?: {
+        [key: string]: number;
+    } | null;
+    reaction_scores?: {
+        [key: string]: number;
+    } | null;
+    reply_count?: number;
+    status?: string;
+    updated_at?: string;
+};
+type ReactionAPIResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = APIResponse & {
+    message: MessageResponse<ErmisChatGenerics>;
+    reaction: ReactionResponse<ErmisChatGenerics>;
+};
+type ReactionResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = Reaction<ErmisChatGenerics> & {
+    created_at: string;
+    message_id: string;
+    updated_at: string;
+};
+type ReadResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+    last_read: string;
+    user: UserResponse<ErmisChatGenerics>;
+    last_read_message_id?: string;
+    unread_messages?: number;
+    last_send?: string;
+};
+type SendFileAPIResponse = APIResponse & {
+    file: string;
+    thumb_url?: string;
+};
+type SendMessageAPIResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = APIResponse & {
+    message: MessageResponse<ErmisChatGenerics>;
+};
+type UpdateChannelAPIResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = APIResponse & {
+    channel: ChannelResponse<ErmisChatGenerics>;
+    members: ChannelMemberResponse<ErmisChatGenerics>[];
+    message?: MessageResponse<ErmisChatGenerics>;
+};
+type UserResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = ErmisChatGenerics['userType'] & {
+    id: string;
+    name?: string;
+    avatar?: string;
+    about_me?: string;
+    project_id?: string;
+    email?: string;
+    phone?: string;
+};
+type Contact = {
+    project_id: string;
+    user_id: string;
+    other_id: string;
+    relation_status: string;
+    created_at: string;
+    updated_at: string;
+};
+type ContactResponse = APIResponse & {
+    project_id_user_ids: {
+        [key: string]: Contact[];
+    };
+};
+type ContactResult<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = APIResponse & {
+    contact_users: UserResponse<ErmisChatGenerics>[];
+    block_users: UserResponse<ErmisChatGenerics>[];
+};
+type ChannelQueryOptions = {
+    messages?: {
+        limit?: number;
+        id_lt?: string;
+        id_gt?: string;
+        id_around?: string;
+    };
+};
+type ChannelStateOptions = {
+    offlineMode?: boolean;
+    skipInitialization?: string[];
+};
+type ErmisChatOptions = AxiosRequestConfig & {
+    /**
+     * Used to disable warnings that are triggered by using connectUser or connectAnonymousUser server-side.
+     */
+    allowServerSideConnect?: boolean;
+    axiosRequestConfig?: AxiosRequestConfig;
+    /**
+     * Base url for User BE API (uss/v1). Defaults to baseURL + '/uss/v1' if not provided.
+     */
+    userBaseURL?: string;
+    browser?: boolean;
+    enableInsights?: boolean;
+    /** experimental feature, please contact support if you want this feature enabled for you */
+    logger?: Logger;
+    /**
+     * When network is recovered, we re-query the active channels on client. But in single query, you can recover
+     * only 30 channels. So its not guaranteed that all the channels in activeChannels object have updated state.
+     * Thus in UI sdks, state recovery is managed by components themselves, they don't rely on js client for this.
+     *
+     * `recoverStateOnReconnect` parameter can be used in such cases, to disable state recovery within js client.
+     * When false, user/consumer of this client will need to make sure all the channels present on UI by
+     * manually calling queryChannels endpoint.
+     */
+    recoverStateOnReconnect?: boolean;
+    warmUp?: boolean;
+    wsConnection?: StableWSConnection;
+};
+/**
+ * Event Types
+ */
+type Event$1<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = ErmisChatGenerics['eventType'] & {
+    type: EventTypes;
+    channel?: ChannelResponse<ErmisChatGenerics>;
+    channel_id?: string;
+    channel_type?: string;
+    cid?: string;
+    created_at?: string;
+    hard_delete?: boolean;
+    last_read_at?: string;
+    last_read_message_id?: string;
+    me?: UserResponse<ErmisChatGenerics>;
+    member?: ChannelMemberResponse<ErmisChatGenerics>;
+    message?: MessageResponse<ErmisChatGenerics>;
+    online?: boolean;
+    parent_id?: string;
+    reaction?: ReactionResponse<ErmisChatGenerics>;
+    received_at?: string | Date;
+    unread_messages?: number;
+    user?: UserResponse<ErmisChatGenerics>;
+    user_id?: string;
+    watcher_count?: number;
+};
+type EventHandler<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = (event: Event$1<ErmisChatGenerics>) => void;
+type EventTypes = 'all' | keyof typeof EVENT_MAP;
+/**
+ * Filter Types
+ */
+type AscDesc = 1 | -1;
+type ChannelFilters = {
+    project_id?: string;
+    type: ('messaging' | 'team' | 'topic')[];
+    limit?: number;
+    offset?: number;
+    roles?: string[];
+    other_roles?: string[];
+    banned?: boolean;
+    blocked?: boolean;
+    include_pinned_messages?: boolean;
+    parent_cid?: string;
+    parent_id?: string;
+    include_parent?: boolean;
+};
+type ChannelSort = {
+    field: string;
+    direction: -1 | 1;
+}[];
+type Attachment<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = ErmisChatGenerics['attachmentType'] & {
+    id?: string;
+    thumb_url?: string;
+    content_disposition?: string;
+    content_length?: number;
+    content_type?: string;
+    updated_at?: string;
+    created_at?: string;
+    message_id?: string;
+    file_name?: string;
+    url?: string;
+    cid?: string;
+    user_id?: string;
+    asset_url?: string;
+    author_icon?: string;
+    author_link?: string;
+    author_name?: string;
+    color?: string;
+    duration?: number;
+    fallback?: string;
+    file_size?: number | string;
+    footer?: string;
+    footer_icon?: string;
+    image_url?: string;
+    mime_type?: string;
+    og_scrape_url?: string;
+    original_height?: number;
+    original_width?: number;
+    pretext?: string;
+    text?: string;
+    title?: string;
+    title_link?: string;
+    type?: string;
+    waveform_data?: Array<number>;
+    link_url?: string;
+};
+type ChannelData<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = ErmisChatGenerics['channelType'] & {
+    members?: string[];
+    name?: string;
+    is_pinned?: boolean;
+};
+type ChannelMembership<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+    banned?: boolean;
+    blocked?: boolean;
+    channel_role?: Role;
+    created_at?: string;
+    updated_at?: string;
+    user?: UserResponse<ErmisChatGenerics>;
+};
+type ConnectionOpen<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+    cid?: string;
+    created_at?: string;
+    me?: UserResponse<ErmisChatGenerics>;
+    type?: string;
+};
+type LiteralStringForUnion = string & {};
+type LogLevel = 'info' | 'error' | 'warn';
+type Logger = (logLevel: LogLevel, message: string, extraData?: Record<string, unknown>) => void;
+type Message<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = Partial<MessageBase<ErmisChatGenerics>> & {
+    id?: string;
+    mentioned_all?: boolean;
+    mentioned_users?: string[];
+    cid?: string;
+    forward_cid?: string;
+    forward_message_id?: string;
+    poll_type?: string;
+    poll_choices?: string[];
+    sticker_url?: string;
+};
+type EditMessage = {
+    text: string;
+    mentioned_all?: boolean;
+    mentioned_users?: string[];
+};
+type ForwardMessage<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+    cid: string;
+    forward_cid: string;
+    forward_message_id: string;
+    id?: string;
+    text?: string;
+    attachments?: Attachment<ErmisChatGenerics>[];
+    sticker_url?: string;
+};
+type PollMessage = {
+    id?: string;
+    text: string;
+    poll_type: string;
+    poll_choices: string[];
+};
+type MessageBase<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = ErmisChatGenerics['messageType'] & {
+    id: string;
+    attachments?: Attachment[];
+    html?: string;
+    mml?: string;
+    parent_id?: string;
+    pinned?: boolean;
+    pinned_at?: string | null;
+    quoted_message_id?: string;
+    text?: string;
+    user?: UserResponse | null;
+    user_id?: string;
+};
+type MessageLabel = 'regular' | 'system' | 'signal' | 'poll' | 'sticker' | 'error';
+type Reaction<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = ErmisChatGenerics['reactionType'] & {
+    type: string;
+    message_id?: string;
+    score?: number;
+    user?: UserResponse | null;
+    user_id?: string;
+};
+type MessageSetType = 'latest' | 'current' | 'new';
+type APIErrorResponse = {
+    code: number;
+    duration: string;
+    message: string;
+    more_info: string;
+    StatusCode: number;
+};
+declare class ErrorFromResponse<T> extends Error {
+    code?: number;
+    response?: AxiosResponse<T>;
+    status?: number;
+}
+type UsersResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+    data: Array<UserResponse<ErmisChatGenerics>>;
+    count: number;
+    total: number;
+    page: number;
+    page_count: number;
+};
+type AttachmentResponse<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = APIResponse & {
+    attachments: Attachment<ErmisChatGenerics>[];
+};
+type SignalData = {
+    cid?: string;
+    is_video?: boolean;
+    action?: string;
+    signal?: Object;
+    metadata?: Object;
+};
+declare enum CallAction {
+    CREATE_CALL = "create-call",
+    ACCEPT_CALL = "accept-call",
+    SIGNAL_CALL = "signal-call",
+    CONNECT_CALL = "connect-call",
+    HEALTH_CALL = "health-call",
+    END_CALL = "end-call",
+    REJECT_CALL = "reject-call",
+    MISS_CALL = "miss-call",
+    UPGRADE_CALL = "upgrade-call"
+}
+declare enum CallStatus {
+    RINGING = "ringing",
+    ENDED = "ended",
+    CONNECTED = "connected",
+    ERROR = "error"
+}
+type CallEventType = 'incoming' | 'outgoing';
+type CallEventData = {
+    type: CallEventType;
+    callType: string;
+    cid: string;
+    callerInfo: UserCallInfo | undefined;
+    receiverInfo: UserCallInfo | undefined;
+    metadata?: Object;
+};
+type UserCallInfo = {
+    id: string;
+    name?: string;
+    avatar?: string;
+};
+type Metadata = {
+    address?: string;
+};
+type INodeCall = {
+    connect: (address: string) => Promise<void>;
+    acceptConnection: () => Promise<void>;
+    sendControlFrame: (packet: Uint8Array) => Promise<void>;
+    sendAudioFrame: (packet: Uint8Array) => Promise<void>;
+    sendFrame: (packet: Uint8Array) => Promise<void>;
+    beginWithGop: (packet: Uint8Array) => Promise<void>;
+    asyncRecv: () => Promise<Uint8Array>;
+};
+type VideoConfig = {
+    codec: string;
+    codedWidth: number;
+    codedHeight: number;
+    frameRate?: number;
+    orientation?: number;
+    rotation?: number;
+    description?: any;
+};
+type AudioConfig = {
+    codec: string;
+    sampleRate: number;
+    numberOfChannels: number;
+    description?: string;
+};
+type TransceiverState = {
+    audio_enable: boolean;
+    video_enable: boolean;
+};
+interface IMediaReceiverEvents {
+    onConnected?: () => void;
+    onTransceiverState?: (state: any) => void;
+    onRequestConfig?: () => void;
+    onRequestKeyFrame?: () => void;
+    onEndCall?: () => void;
+}
+declare enum FRAME_TYPE {
+    VIDEO_CONFIG = 0,
+    AUDIO_CONFIG = 1,
+    VIDEO_KEY = 2,
+    VIDEO_DELTA = 3,
+    AUDIO = 4,
+    ORIENTATION = 5,
+    CONNECTED = 6,
+    TRANSCEIVER_STATE = 7,
+    REQUEST_CONFIG = 8,
+    REQUEST_KEY_FRAME = 9,
+    END_CALL = 10
+}
+
+type ChannelReadStatus<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> = Record<string, {
+    last_read: Date;
+    unread_messages: number;
+    user: UserResponse<ErmisChatGenerics>;
+    last_read_message_id?: string;
+    last_send?: string;
+}>;
+/**
+ * ChannelState - A container class for the channel state.
+ */
+declare class ChannelState<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> {
+    _channel: Channel<ErmisChatGenerics>;
+    watcher_count: number;
+    typing: Record<string, Event$1<ErmisChatGenerics>>;
+    read: ChannelReadStatus<ErmisChatGenerics>;
+    pinnedMessages: Array<ReturnType<ChannelState<ErmisChatGenerics>['formatMessage']>>;
+    watchers: Record<string, UserResponse<ErmisChatGenerics>>;
+    members: Record<string, ChannelMemberResponse<ErmisChatGenerics>>;
+    unreadCount: number;
+    membership: ChannelMembership<ErmisChatGenerics>;
+    last_message_at: Date | null;
+    isUpToDate: boolean;
+    messageSets: {
+        isCurrent: boolean;
+        isLatest: boolean;
+        messages: Array<ReturnType<ChannelState<ErmisChatGenerics>['formatMessage']>>;
+    }[];
+    topics?: Channel<ErmisChatGenerics>[];
+    constructor(channel: Channel<ErmisChatGenerics>);
+    get messages(): Array<ReturnType<ChannelState<ErmisChatGenerics>["formatMessage"]>>;
+    set messages(messages: Array<ReturnType<ChannelState<ErmisChatGenerics>['formatMessage']>>);
+    get latestMessages(): Array<ReturnType<ChannelState<ErmisChatGenerics>["formatMessage"]>>;
+    set latestMessages(messages: Array<ReturnType<ChannelState<ErmisChatGenerics>['formatMessage']>>);
+    addMessageSorted(newMessage: MessageResponse<ErmisChatGenerics>, timestampChanged?: boolean, addIfDoesNotExist?: boolean, messageSetToAddToIfDoesNotExist?: MessageSetType): {
+        messageSet: {
+            isCurrent: boolean;
+            isLatest: boolean;
+            messages: Array<ReturnType<ChannelState<ErmisChatGenerics>["formatMessage"]>>;
+        };
+    };
+    formatMessage(message: MessageResponse<ErmisChatGenerics>): FormatMessageResponse<ErmisChatGenerics>;
+    addMessagesSorted(newMessages: MessageResponse<ErmisChatGenerics>[], timestampChanged?: boolean, initializing?: boolean, addIfDoesNotExist?: boolean, messageSetToAddToIfDoesNotExist?: MessageSetType): {
+        messageSet: {
+            isCurrent: boolean;
+            isLatest: boolean;
+            messages: Array<ReturnType<ChannelState<ErmisChatGenerics>["formatMessage"]>>;
+        };
+    };
+    addPinnedMessages(pinnedMessages: MessageResponse<ErmisChatGenerics>[]): void;
+    addPinnedMessage(pinnedMessage: MessageResponse<ErmisChatGenerics>): void;
+    removePinnedMessage(message: MessageResponse<ErmisChatGenerics>): void;
+    addReaction(reaction: ReactionResponse<ErmisChatGenerics>, message?: MessageResponse<ErmisChatGenerics>, enforce_unique?: boolean): MessageResponse<ErmisChatGenerics> | undefined;
+    _addOwnReactionToMessage(ownReactions: ReactionResponse<ErmisChatGenerics>[] | null | undefined, reaction: ReactionResponse<ErmisChatGenerics>, enforce_unique?: boolean): ReactionResponse<ErmisChatGenerics>[];
+    _removeOwnReactionFromMessage(ownReactions: ReactionResponse<ErmisChatGenerics>[] | null | undefined, reaction: ReactionResponse<ErmisChatGenerics>): ReactionResponse<ErmisChatGenerics>[] | null | undefined;
+    removeReaction(reaction: ReactionResponse<ErmisChatGenerics>, message?: MessageResponse<ErmisChatGenerics>): MessageResponse<ErmisChatGenerics> | undefined;
+    removeQuotedMessageReferences(message: MessageResponse<ErmisChatGenerics>): void;
+    _updateMessage(message: {
+        id?: string;
+        parent_id?: string;
+        pinned?: boolean;
+    }, updateFunc: (msg: ReturnType<ChannelState<ErmisChatGenerics>['formatMessage']>) => ReturnType<ChannelState<ErmisChatGenerics>['formatMessage']>): void;
+    setIsUpToDate: (isUpToDate: boolean) => void;
+    /**
+     * Update the status of a message by ID (used for optimistic UI).
+     */
+    updateMessageStatus(messageId: string, status: string): void;
+    _addToMessageList(messages: Array<ReturnType<ChannelState<ErmisChatGenerics>['formatMessage']>>, message: ReturnType<ChannelState<ErmisChatGenerics>['formatMessage']>, timestampChanged?: boolean, sortBy?: 'pinned_at' | 'created_at', addIfDoesNotExist?: boolean): FormatMessageResponse<ErmisChatGenerics>[];
+    removeMessage(messageToRemove: {
+        id: string;
+        messageSetIndex?: number;
+        parent_id?: string;
+    }): boolean;
+    removeMessageFromArray: (msgArray: Array<ReturnType<ChannelState<ErmisChatGenerics>["formatMessage"]>>, msg: {
+        id: string;
+        parent_id?: string;
+    }) => {
+        removed: boolean;
+        result: FormatMessageResponse<ErmisChatGenerics>[];
+    };
+    updateUserMessages: (user: UserResponse<ErmisChatGenerics>) => void;
+    deleteUserMessages: (user: UserResponse<ErmisChatGenerics>, hardDelete?: boolean) => void;
+    filterErrorMessages(): void;
+    clean(): void;
+    clearMessages(): void;
+    initMessages(): void;
+    loadMessageIntoState(messageId: string | 'latest', parentMessageId?: string, limit?: number): Promise<void>;
+    findMessage(messageId: string, parentMessageId?: string): FormatMessageResponse<ErmisChatGenerics> | undefined;
+    private switchToMessageSet;
+    private areMessageSetsOverlap;
+    private findMessageSetIndex;
+    private findTargetMessageSet;
+}
+
+/**
+ * Normalize a file name for upload:
+ * - Remove Vietnamese diacritics
+ * - Replace đ/Đ with d/D
+ * - Replace spaces with underscores
+ * - Preserve extension
+ */
+declare function normalizeFileName(name: string): string;
+/**
+ * Check if a MIME type or file extension is HEIC/HEIF.
+ */
+declare function isHeicFile(file: File): boolean;
+/**
+ * Categorize a file by MIME type.
+ * HEIC/HEIF files are treated as 'file' (not 'image') since browsers can't render them.
+ */
+declare function getAttachmentCategory(mimeType: string, fileName?: string): 'image' | 'video' | 'audio' | 'file';
+/**
+ * Check if a file is a video type that supports thumbnail extraction.
+ */
+declare function isVideoFile(file: File): boolean;
+/**
+ * Metadata for voice recording attachments.
+ */
+type VoiceRecordingMeta = {
+    waveform_data: number[];
+    duration: number;
+};
+/**
+ * Build a normalized attachment payload from an uploaded file.
+ *
+ * @param file        - Original file object
+ * @param uploadedUrl - URL returned by the upload API
+ * @param thumbUrl    - Optional thumbnail URL (for video)
+ * @param voiceMeta   - Optional voice recording metadata
+ */
+declare function buildAttachmentPayload(file: File, uploadedUrl: string, thumbUrl?: string, voiceMeta?: VoiceRecordingMeta): Attachment;
+
+declare class Channel<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> {
+    _client: ErmisChat<ErmisChatGenerics>;
+    type: string;
+    id: string | undefined;
+    data: ChannelData<ErmisChatGenerics> | ChannelResponse<ErmisChatGenerics> | undefined;
+    _data: ChannelData<ErmisChatGenerics> | ChannelResponse<ErmisChatGenerics>;
+    cid: string;
+    listeners: {
+        [key: string]: (string | EventHandler<ErmisChatGenerics>)[];
+    };
+    state: ChannelState<ErmisChatGenerics>;
+    initialized: boolean;
+    offlineMode: boolean;
+    lastKeyStroke?: Date;
+    lastTypingEvent: Date | null;
+    isTyping: boolean;
+    disconnected: boolean;
+    constructor(client: ErmisChat<ErmisChatGenerics>, type: string, id: string | undefined, data: ChannelData<ErmisChatGenerics>);
+    getClient(): ErmisChat<ErmisChatGenerics>;
+    sendMessage(message: Message<ErmisChatGenerics>): Promise<SendMessageAPIResponse<ErmisChatGenerics>>;
+    retryMessage(messageId: string): Promise<SendMessageAPIResponse<ErmisChatGenerics>>;
+    createPoll(pollMessage: PollMessage): Promise<SendMessageAPIResponse<ErmisChatGenerics>>;
+    votePoll(messageID: string, pollChoice: string): Promise<APIResponse>;
+    forwardMessage(message: ForwardMessage<ErmisChatGenerics>, channel: {
+        type: string;
+        channelID: string;
+    }): Promise<SendMessageAPIResponse<ErmisChatGenerics>>;
+    pinMessage(messageID: string): Promise<unknown>;
+    unpinMessage(messageID: string): Promise<unknown>;
+    editMessage(oldMessageID: string, message: EditMessage): Promise<unknown>;
+    sendFile(uri: string | NodeJS.ReadableStream | Buffer | File, name?: string, contentType?: string, user?: UserResponse<ErmisChatGenerics>): Promise<SendFileAPIResponse>;
+    /**
+     * Pre-process files (normalize names), upload them in parallel,
+     * generate video thumbnails, and build attachment payloads.
+     *
+     * @param files     - Array of File objects to upload
+     * @param options   - Optional voice recording metadata
+     * @returns `attachments` ready for sendMessage, and `failedFiles` for error display
+     */
+    uploadAndPrepareAttachments(files: File[], options?: {
+        /** Map from file index → voice recording metadata */
+        voiceMetadata?: Map<number, VoiceRecordingMeta>;
+    }): Promise<{
+        attachments: Attachment[];
+        failedFiles: Array<{
+            file: File;
+            error: Error;
+        }>;
+    }>;
+    sendEvent(event: Event$1<ErmisChatGenerics>): Promise<unknown>;
+    sendReaction(messageID: string, reactionType: string): Promise<ReactionAPIResponse<ErmisChatGenerics>>;
+    deleteReaction(messageID: string, reactionType: string): Promise<ReactionAPIResponse<ErmisChatGenerics>>;
+    update(channelData?: Partial<ChannelData<ErmisChatGenerics>> | Partial<ChannelResponse<ErmisChatGenerics>>, updateMessage?: Message<ErmisChatGenerics>): Promise<UpdateChannelAPIResponse<ErmisChatGenerics>>;
+    delete(): Promise<unknown>;
+    truncate(): Promise<unknown>;
+    blockUser(): Promise<unknown>;
+    unblockUser(): Promise<unknown>;
+    acceptInvite(action: string): Promise<APIResponse>;
+    rejectInvite(): Promise<APIResponse>;
+    skipInvite(): Promise<APIResponse>;
+    addMembers(members: string[]): Promise<UpdateChannelAPIResponse<ErmisChatGenerics>>;
+    addModerators(members: string[]): Promise<UpdateChannelAPIResponse<ErmisChatGenerics>>;
+    banMembers(members: string[]): Promise<UpdateChannelAPIResponse<ErmisChatGenerics>>;
+    unbanMembers(members: string[]): Promise<UpdateChannelAPIResponse<ErmisChatGenerics>>;
+    updateCapabilities(capabilities: string[]): Promise<UpdateChannelAPIResponse<ErmisChatGenerics>>;
+    /**
+     * Set slow mode (message cooldown) for the channel.
+     * Only applicable to team channels. Prevents members from sending
+     * messages faster than the specified cooldown interval.
+     *
+     * @param cooldown - Cooldown duration in milliseconds.
+     *   Allowed values: 0 (off), 10000 (10s), 30000 (30s),
+     *   60000 (1min), 300000 (5min), 900000 (15min), 3600000 (1h).
+     */
+    setSlowMode(cooldown: 0 | 10000 | 30000 | 60000 | 300000 | 900000 | 3600000): Promise<UpdateChannelAPIResponse<ErmisChatGenerics>>;
+    queryAttachmentMessages(): Promise<AttachmentResponse<ErmisChatGenerics>>;
+    searchMessage(search_term: string, offset: number): Promise<any>;
+    removeMembers(members: string[]): Promise<UpdateChannelAPIResponse<ErmisChatGenerics>>;
+    demoteModerators(members: string[]): Promise<UpdateChannelAPIResponse<ErmisChatGenerics>>;
+    _update(payload: Object): Promise<UpdateChannelAPIResponse<ErmisChatGenerics>>;
+    _processTopics(topicsFromApi: any, users: any[]): void;
+    muteNotification(duration: number | null): Promise<AttachmentResponse<ErmisChatGenerics>>;
+    unMuteNotification(): Promise<AttachmentResponse<ErmisChatGenerics>>;
+    keystroke(parent_id?: string, options?: {
+        user_id: string;
+    }): Promise<void>;
+    stopTyping(parent_id?: string, options?: {
+        user_id: string;
+    }): Promise<void>;
+    _isTypingIndicatorsEnabled(): boolean;
+    lastMessage(): FormatMessageResponse<ErmisChatGenerics>;
+    markRead(): Promise<unknown>;
+    clean(): void;
+    watch(options?: ChannelQueryOptions): Promise<QueryChannelAPIResponse<ErmisChatGenerics>>;
+    lastRead(): Date | null | undefined;
+    _countMessageAsUnread(message: FormatMessageResponse<ErmisChatGenerics> | MessageResponse<ErmisChatGenerics>): boolean;
+    countUnread(lastRead?: Date | null): number;
+    getUnreadMemberCount(): {
+        last_read: Date;
+        unread_messages: number;
+        user: UserResponse<ErmisChatGenerics>;
+        last_read_message_id?: string;
+        last_send?: string;
+    }[];
+    getCapabilitiesMember(): unknown;
+    create: () => Promise<QueryChannelAPIResponse<ErmisChatGenerics>>;
+    createTopic(data: any): Promise<QueryChannelAPIResponse<ErmisChatGenerics>>;
+    query(options: ChannelQueryOptions, messageSetToAddToIfDoesNotExist?: MessageSetType): Promise<QueryChannelAPIResponse<ErmisChatGenerics>>;
+    createDirectChannel(messageSetToAddToIfDoesNotExist?: MessageSetType): Promise<QueryChannelAPIResponse<ErmisChatGenerics>>;
+    queryMessagesLessThanId(message_id: string, limit?: number): Promise<MessageResponse<ErmisChatGenerics>[]>;
+    queryMessagesGreaterThanId(message_id: string, limit?: number): Promise<MessageResponse<ErmisChatGenerics>[]>;
+    queryMessagesAroundId(message_id: string, limit?: number): Promise<MessageResponse<ErmisChatGenerics>[]>;
+    deleteMessage(messageId: string): Promise<APIResponse & {
+        message: MessageResponse<ErmisChatGenerics>;
+    }>;
+    deleteMessageForMe(messageId: string): Promise<APIResponse & {
+        message: MessageResponse<ErmisChatGenerics>;
+    }>;
+    getThumbBlobVideo(file: File): Promise<Blob | null>;
+    enableTopics(): Promise<unknown>;
+    disableTopics(): Promise<unknown>;
+    closeTopic(topicCID: string): Promise<unknown>;
+    reopenTopic(topicCID: string): Promise<unknown>;
+    editTopic(topicCID: string, data: any): Promise<any>;
+    on(eventType: EventTypes, callback: EventHandler<ErmisChatGenerics>): {
+        unsubscribe: () => void;
+    };
+    on(callback: EventHandler<ErmisChatGenerics>): {
+        unsubscribe: () => void;
+    };
+    off(eventType: EventTypes, callback: EventHandler<ErmisChatGenerics>): void;
+    off(callback: EventHandler<ErmisChatGenerics>): void;
+    _handleChannelEvent(event: Event$1<ErmisChatGenerics>): Promise<void>;
+    _callChannelListeners: (event: Event$1<ErmisChatGenerics>) => void;
+    _channelURL: () => string;
+    _checkInitialized(): void;
+    _initializeState(state: ChannelAPIResponse<ErmisChatGenerics>, messageSetToAddToIfDoesNotExist?: MessageSetType, updateUserIds?: (id: string) => void): {
+        messageSet: {
+            isCurrent: boolean;
+            isLatest: boolean;
+            messages: FormatMessageResponse<ErmisChatGenerics>[];
+        };
+    };
+    _extendEventWithOwnReactions(event: Event$1<ErmisChatGenerics>): void;
+    _disconnect(): void;
+}
+
+/**
+ * ClientState - A container class for the client state.
+ */
+declare class ClientState<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> {
+    users: {
+        [key: string]: UserResponse<ErmisChatGenerics>;
+    };
+    userChannelReferences: {
+        [key: string]: {
+            [key: string]: boolean;
+        };
+    };
+    constructor();
+    updateUsers(users: UserResponse<ErmisChatGenerics>[]): void;
+    updateUser(user?: UserResponse<ErmisChatGenerics>): void;
+    updateUserReference(user: UserResponse<ErmisChatGenerics>, channelID: string): void;
+    deleteAllChannelReference(channelID: string): void;
+}
+
+/**
+ * TokenManager
+ *
+ * Manages token storage and retrieval for the chat client.
+ */
+declare class TokenManager<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> {
+    loadTokenPromise: Promise<string> | null;
+    token?: string;
+    user?: UserResponse<ErmisChatGenerics>;
+    constructor();
+    /**
+     * Set the static string token.
+     */
+    setTokenOrProvider: (tokenOrProvider: string | null, user: UserResponse<ErmisChatGenerics>) => Promise<void>;
+    /**
+     * Resets the token manager.
+     */
+    reset: () => void;
+    /**
+     * Resolves when token is ready.
+     */
+    tokenReady: () => Promise<string> | null;
+    /** Returns the current token */
+    getToken: () => string | undefined;
+}
+
+declare class ErmisChat<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> {
+    private static _instance?;
+    activeChannels: {
+        [key: string]: Channel<ErmisChatGenerics>;
+    };
+    axiosInstance: AxiosInstance;
+    baseURL?: string;
+    userBaseURL?: string;
+    browser: boolean;
+    cleaningIntervalRef?: NodeJS.Timeout;
+    clientID?: string;
+    apiKey: string;
+    projectId: string;
+    listeners: Record<string, Array<(event: Event$1<ErmisChatGenerics>) => void>>;
+    logger: Logger;
+    recoverStateOnReconnect?: boolean;
+    node: boolean;
+    options: ErmisChatOptions;
+    setUserPromise: ConnectAPIResponse<ErmisChatGenerics> | null;
+    state: ClientState<ErmisChatGenerics>;
+    tokenManager: TokenManager<ErmisChatGenerics>;
+    user?: UserResponse<ErmisChatGenerics>;
+    userAgent?: string;
+    userID?: string;
+    wsBaseURL?: string;
+    wsConnection: StableWSConnection<ErmisChatGenerics> | null;
+    wsPromise: ConnectAPIResponse<ErmisChatGenerics> | null;
+    consecutiveFailures: number;
+    defaultWSTimeout: number;
+    private eventSource;
+    constructor(apiKey: string, projectId: string, baseURL: string, options?: ErmisChatOptions);
+    static getInstance<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics>(key: string, projectId: string, baseURL: string, options?: ErmisChatOptions): ErmisChat<ErmisChatGenerics>;
+    refreshNewToken(refresh_token: string): Promise<APIResponse>;
+    getAuthType(): string;
+    setBaseURL(baseURL: string): void;
+    getExternalAuthToken(user: UserResponse<ErmisChatGenerics>, token: string | null): Promise<any>;
+    connectUser: (user: UserResponse<ErmisChatGenerics>, userTokenOrProvider: string | null, extenal_auth?: boolean) => Promise<void | ConnectionOpen<ErmisChatGenerics>>;
+    setUser: (user: UserResponse<ErmisChatGenerics>, userTokenOrProvider: string | null, extenal_auth?: boolean) => Promise<void | ConnectionOpen<ErmisChatGenerics>>;
+    _setToken: (user: UserResponse<ErmisChatGenerics>, userTokenOrProvider: string | null) => Promise<void>;
+    _setUser(user: UserResponse<ErmisChatGenerics>): void;
+    closeConnection: (timeout?: number) => Promise<void>;
+    openConnection: () => Promise<void | ConnectionOpen<ErmisChatGenerics>>;
+    _setupConnection: () => Promise<void | ConnectionOpen<ErmisChatGenerics>>;
+    disconnectUser: (timeout?: number) => Promise<void>;
+    disconnect: (timeout?: number) => Promise<void>;
+    on(callback: EventHandler<ErmisChatGenerics>): {
+        unsubscribe: () => void;
+    };
+    on(eventType: string, callback: EventHandler<ErmisChatGenerics>): {
+        unsubscribe: () => void;
+    };
+    off(callback: EventHandler<ErmisChatGenerics>): void;
+    off(eventType: string, callback: EventHandler<ErmisChatGenerics>): void;
+    _logApiRequest(type: string, url: string, data: unknown, config: AxiosRequestConfig & {
+        config?: AxiosRequestConfig & {
+            maxBodyLength?: number;
+        };
+    }): void;
+    _logApiResponse<T>(type: string, url: string, response: AxiosResponse<T>): void;
+    _logApiError(type: string, url: string, error: unknown, options: unknown): void;
+    doAxiosRequest: <T>(type: string, url: string, data?: unknown, options?: AxiosRequestConfig & {
+        config?: AxiosRequestConfig & {
+            maxBodyLength?: number;
+        };
+    }) => Promise<T>;
+    get<T>(url: string, params?: AxiosRequestConfig['params']): Promise<T>;
+    put<T>(url: string, data?: unknown): Promise<T>;
+    post<T>(url: string, data?: unknown, params?: AxiosRequestConfig['params']): Promise<T>;
+    patch<T>(url: string, data?: unknown): Promise<T>;
+    delete<T>(url: string, params?: AxiosRequestConfig['params']): Promise<T>;
+    sendFile(url: string, uri: string | NodeJS.ReadableStream | Buffer | File, name?: string, contentType?: string, user?: UserResponse<ErmisChatGenerics>): Promise<SendFileAPIResponse>;
+    errorFromResponse(response: AxiosResponse<APIErrorResponse>): ErrorFromResponse<APIErrorResponse>;
+    handleResponse<T>(response: AxiosResponse<T>): T;
+    dispatchEvent: (event: Event$1<ErmisChatGenerics>) => void;
+    _afterDispatchEvent(event: Event$1<ErmisChatGenerics>): void;
+    private _handleChannelCreatedEvent;
+    handleEvent: (messageEvent: WebSocket.MessageEvent) => void;
+    _updateMemberWatcherReferences: (user: UserResponse<ErmisChatGenerics>) => void;
+    _updateUserReferences: (user: UserResponse<ErmisChatGenerics>) => void;
+    _updateUserMessageReferences: (user: UserResponse<ErmisChatGenerics>) => void;
+    _deleteUserMessageReference: (user: UserResponse<ErmisChatGenerics>, hardDelete?: boolean) => void;
+    _handleClientEvent(event: Event$1<ErmisChatGenerics>): (() => void)[];
+    _callClientListeners: (event: Event$1<ErmisChatGenerics>) => void;
+    recoverState: () => Promise<void>;
+    connect(): Promise<void | ConnectionOpen<ErmisChatGenerics>>;
+    connectToSSE(onCallBack?: (data: any) => void): Promise<void>;
+    disconnectFromSSE(): Promise<void>;
+    queryUsers(page_size?: string, page?: number): Promise<UsersResponse>;
+    queryUser(user_id: string): Promise<UserResponse<ErmisChatGenerics>>;
+    getBatchUsers(users: string[], page?: number, page_size?: number): Promise<UserResponse<DefaultGenerics>[]>;
+    searchUsers(page: number, page_size: number, name?: string): Promise<UsersResponse>;
+    queryContacts(): Promise<ContactResult>;
+    _updateProjectID(project_id: string): void;
+    uploadFile(file: File): Promise<{
+        avatar: string;
+    }>;
+    updateProfile(name: string, about_me: string): Promise<UserResponse<ErmisChatGenerics>>;
+    queryChannels(filterConditions: ChannelFilters, sort?: ChannelSort, options?: {
+        message_limit?: number;
+    }, stateOptions?: ChannelStateOptions): Promise<Channel<ErmisChatGenerics>[]>;
+    hydrateChannels(channelsFromApi?: ChannelAPIResponse<ErmisChatGenerics>[], stateOptions?: ChannelStateOptions): {
+        channels: Channel<ErmisChatGenerics>[];
+        userIds: string[];
+    };
+    searchPublicChannel(search_term: string, offset?: number, limit?: number): Promise<APIResponse>;
+    pinChannel(channelType: string, channelId: string): Promise<APIResponse>;
+    unpinChannel(channelType: string, channelId: string): Promise<APIResponse>;
+    channel(channelType: string, channelID: string, custom?: ChannelData<ErmisChatGenerics>): Channel<ErmisChatGenerics>;
+    getChannelById: (channelType: string, channelID: string, custom: ChannelData<ErmisChatGenerics>) => Channel<ErmisChatGenerics>;
+    getChannel: (channelType: string, custom: ChannelData<ErmisChatGenerics>) => Channel<ErmisChatGenerics>;
+    _normalizeExpiration(timeoutOrExpirationDate?: null | number | string | Date): string | null;
+    getUserAgent(): string;
+    setUserAgent(userAgent: string): void;
+    _enrichAxiosOptions(options?: AxiosRequestConfig & {
+        config?: AxiosRequestConfig;
+    }): AxiosRequestConfig;
+    _getToken(): string | null | undefined;
+    _startCleaning(): void;
+    _buildWSPayload: (client_request_id?: string) => string;
+}
+
+declare class ErmisCall {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor();
+  spawn(relay_urls: any, secret_key?: Uint8Array | null): Promise<void>;
+  getLocalEndpointAddr(): Promise<string>;
+  connect(addr: string): Promise<void>;
+  closeEndpoint(): Promise<void>;
+  closeConnection(): void;
+  acceptConnection(): Promise<void>;
+  sendControlFrame(data: Uint8Array): void;
+  sendAudioFrame(data: Uint8Array): void;
+  sendFrame(data: Uint8Array): void;
+  notifyNewGop(): void;
+  recv(): Uint8Array;
+  asyncRecv(): Promise<Uint8Array>;
+  beginWithGop(data: Uint8Array): void;
+  connectionType(): string | undefined;
+  roundTripTime(): number | undefined;
+  currentPacketLoss(): number | undefined;
+  networkChange(): void;
+  getStats(): any;
+}
+
+declare class MediaStreamSender {
+    private videoEncoder;
+    private audioEncoder;
+    private videoReader;
+    private localStream;
+    private videoConfig;
+    private audioConfig;
+    private videoConfigSent;
+    private audioConfigSent;
+    private hasVideo;
+    private hasAudio;
+    private forceKeyFrame;
+    private nodeCall;
+    constructor(nodeCall: INodeCall);
+    /**
+     * Bắt đầu xử lý MediaStream
+     */
+    connect(address: string): Promise<void>;
+    sendConfigs(): Promise<void>;
+    /**
+     * Dừng và reset encoders
+     */
+    stop: () => void;
+    initAudioEncoder: (audioTrack: MediaStreamTrack) => void;
+    initVideoEncoder(videoTrack: MediaStreamTrack): void;
+    initEncoders: (stream: MediaStream) => void;
+    sendTransceiverState: (audioEnable: boolean, videoEnable: boolean) => Promise<void>;
+    replaceVideoTrack(track: MediaStreamTrack): Promise<void>;
+    replaceAudioTrack(track: MediaStreamTrack): Promise<void>;
+    /**
+     * Yêu cầu gửi keyframe ngay lập tức (được gọi khi nhận REQUEST_KEY_FRAME từ receiver)
+     */
+    requestKeyFrame: () => void;
+    private processVideoFrames;
+    private processAudioFrames;
+    private isReadyToSendData;
+    private sendVideoConfig;
+    private sendAudioConfig;
+    sendConnected: () => Promise<void>;
+    private sendPacketOrQueue;
+}
+
+declare class MediaStreamReceiver {
+    private videoDecoder;
+    private audioDecoder;
+    private videoWriter;
+    private audioContext;
+    private mediaDestination;
+    private isWaitingForKeyFrame;
+    private nextStartTime;
+    private lastVideoConfig;
+    private nodeCall;
+    private events;
+    private generatedStream;
+    constructor(nodeCall: INodeCall, events?: IMediaReceiverEvents);
+    acceptConnection(): Promise<void>;
+    getRemoteStream: () => MediaStream | null;
+    /**
+     * Dừng toàn bộ quá trình và giải phóng tài nguyên
+     */
+    stop: () => void;
+    private initAudioContext;
+    initDecoders: (callType: string) => void;
+    setupVideoDecoder: () => void;
+    private playDecodedAudio;
+    private newCodecFromDescription;
+    receiveLoop: () => Promise<void>;
+    private resetDecoders;
+}
+
+declare class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> {
+    wasmPath: string;
+    relayUrl: string;
+    /** Reference to the Ermis Chat client instance */
+    _client: ErmisChat<ErmisChatGenerics>;
+    /** Unique identifier for the current call session */
+    sessionID: string;
+    /** Channel ID for communication between users */
+    cid?: string;
+    /** Type of call: 'audio' or 'video' */
+    callType?: string;
+    /** ID of the current user */
+    userID?: string | undefined;
+    /** Current status of the call */
+    callStatus?: string | undefined;
+    metadata?: Metadata;
+    callNode: ErmisCall | null;
+    /** Local media stream from user's camera/microphone */
+    localStream?: MediaStream | null;
+    /** Remote media stream from the other participant */
+    remoteStream?: MediaStream | null;
+    /** Information about the caller */
+    callerInfo?: UserCallInfo;
+    /** Information about the call receiver */
+    receiverInfo?: UserCallInfo;
+    /** Callback triggered when call events occur (incoming/outgoing) */
+    onCallEvent?: (data: CallEventData) => void;
+    /** Callback triggered when local stream is available */
+    onLocalStream?: (stream: MediaStream) => void;
+    /** Callback triggered when remote stream is available */
+    onRemoteStream?: (stream: MediaStream) => void;
+    /** Callback for connection status message changes */
+    onConnectionMessageChange?: (message: string | null) => void;
+    /** Callback for call status changes */
+    onCallStatus?: (status: string | null) => void;
+    /** Callback for messages received through WebRTC data channel */
+    onDataChannelMessage?: (data: any) => void;
+    /** Callback for when a call is upgraded (e.g., audio to video) */
+    onUpgradeCall?: (upgraderInfo: UserCallInfo) => void;
+    /** Callback for screen sharing status changes */
+    onScreenShareChange?: (isSharing: boolean) => void;
+    /** Callback for error handling */
+    onError?: (error: string) => void;
+    /** Callback for device list changes */
+    onDeviceChange?: (audioDevices: MediaDeviceInfo[], videoDevices: MediaDeviceInfo[]) => void;
+    /** Available audio input devices */
+    private availableAudioDevices;
+    /** Available video input devices */
+    private availableVideoDevices;
+    /** Currently selected audio device ID */
+    private selectedAudioDeviceId?;
+    /** Currently selected video device ID */
+    private selectedVideoDeviceId?;
+    /** Timeout for ending call if not answered after a period */
+    private missCallTimeout;
+    /** Interval for sending health check via WebRTC */
+    private healthCallInterval;
+    /** Interval for sending health check via server */
+    private healthCallServerInterval;
+    /** Timeout for detecting if remote peer has disconnected */
+    private healthCallTimeout;
+    /** Timeout for showing warning when connection becomes unstable */
+    private healthCallWarningTimeout;
+    /** Handler for signal events */
+    private signalHandler;
+    /** Handler for connection change events */
+    private connectionChangedHandler;
+    /** Handler for message updated events */
+    private messageUpdatedHandler;
+    /** Flag indicating if the user is offline */
+    private isOffline;
+    /**
+     * True if this call instance is destroyed (e.g., when another device accepts the call).
+     * When true, SIGNAL_CALL events will be ignored.
+     */
+    private isDestroyed;
+    mediaSender: MediaStreamSender | null;
+    mediaReceiver: MediaStreamReceiver | null;
+    constructor(client: ErmisChat<ErmisChatGenerics>, sessionID: string, wasmPath: string, relayUrl: string);
+    private loadWasm;
+    private initialize;
+    getLocalEndpointAddr(): Promise<string | null>;
+    private getClient;
+    private _sendSignal;
+    private getAvailableDevices;
+    private getMediaConstraints;
+    startLocalStream(): Promise<MediaStream | null | undefined>;
+    private setConnectionMessage;
+    private setCallStatus;
+    private setUserInfo;
+    private listenSocketEvents;
+    private cleanupCall;
+    private destroy;
+    getDevices(): Promise<{
+        audioDevices: MediaDeviceInfo[];
+        videoDevices: MediaDeviceInfo[];
+    }>;
+    getSelectedDevices(): {
+        audioDevice?: MediaDeviceInfo;
+        videoDevice?: MediaDeviceInfo;
+    };
+    getDefaultDevices(): {
+        audioDevice?: MediaDeviceInfo;
+        videoDevice?: MediaDeviceInfo;
+    };
+    createCall(callType: string, cid: string): Promise<void>;
+    acceptCall(): Promise<void>;
+    endCall(): Promise<void>;
+    rejectCall(): Promise<void>;
+    private missCall;
+    private connectCall;
+    private healthCall;
+    private addVideoTrackToLocalStream;
+    upgradeCall(): Promise<void>;
+    requestUpgradeCall(enabled: boolean): Promise<void>;
+    startScreenShare(): Promise<void>;
+    stopScreenShare(): Promise<void>;
+    toggleMic(enabled: boolean): Promise<void>;
+    toggleCamera(enabled: boolean): Promise<void>;
+    switchAudioDevice(deviceId: string): Promise<boolean>;
+    switchVideoDevice(deviceId: string): Promise<boolean>;
+    private setupDeviceChangeListener;
+}
+
+declare class ErmisAuthProvider {
+    apiKey: string;
+    baseURL?: string;
+    options?: ErmisChatOptions;
+    axiosInstance: AxiosInstance;
+    disconnected: boolean;
+    browser: boolean;
+    node: boolean;
+    logger: Logger;
+    consecutiveFailures: number;
+    userAgent?: string;
+    /** Last identifier (phone or email) used for OTP */
+    lastIdentifier?: string;
+    /**
+     * The last OTP method used ('Sms', 'Voice', or 'Email').
+     * Used to verify OTP for the correct method.
+     */
+    lastMethod?: 'Sms' | 'Voice' | 'Email';
+    /** Wallet address used for wallet authentication */
+    address?: string;
+    constructor(apiKey: string, baseURL: string, options?: ErmisChatOptions);
+    _logApiRequest(type: string, url: string, data: unknown, config: AxiosRequestConfig & {
+        config?: AxiosRequestConfig & {
+            maxBodyLength?: number;
+        };
+    }): void;
+    _logApiResponse<T>(type: string, url: string, response: AxiosResponse<T>): void;
+    _logApiError(type: string, url: string, error: unknown, options: unknown): void;
+    doAxiosRequest: <T>(type: string, url: string, data?: unknown, options?: AxiosRequestConfig & {
+        config?: AxiosRequestConfig & {
+            maxBodyLength?: number;
+        };
+    }) => Promise<T>;
+    get<T>(url: string, params?: AxiosRequestConfig['params']): Promise<T>;
+    put<T>(url: string, data?: unknown): Promise<T>;
+    post<T>(url: string, data?: unknown, params?: AxiosRequestConfig['params']): Promise<T>;
+    patch<T>(url: string, data?: unknown): Promise<T>;
+    delete<T>(url: string, params?: AxiosRequestConfig['params']): Promise<T>;
+    errorFromResponse(response: AxiosResponse<APIErrorResponse>): ErrorFromResponse<APIErrorResponse>;
+    handleResponse<T>(response: AxiosResponse<T>): T;
+    getUserAgent(): string;
+    setUserAgent(userAgent: string): void;
+    _enrichAxiosOptions(options?: AxiosRequestConfig & {
+        config?: AxiosRequestConfig;
+    }): AxiosRequestConfig;
+    /**
+     * Send OTP to a phone number.
+     * @param identifier Phone number
+     * @param language Language code (e.g. 'En', 'Vi')
+     * @param method Method type (e.g. 'Sms', 'Voice')
+     */
+    sendOtpToPhone(identifier: string, method: 'Sms' | 'Voice'): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * Send OTP to a email.
+     * @param identifier Email address
+     * @param language Language code (e.g. 'En', 'Vi')
+     * @param method Method type (e.g. 'Email')
+     */
+    sendOtpToEmail(identifier: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * Verify OTP for phone or email.
+     * @param otp OTP code
+     */
+    verifyOtp(otp: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * Login with Google.
+     * @param token Google OAuth token
+     * @param apikey API key
+     */
+    loginWithGoogle(token: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * Get challenge for wallet login.
+     * @param address Wallet address
+     * @param apiKey API key
+     */
+    getWalletChallenge(address: string): Promise<any>;
+    private createNonce;
+    /**
+     * Verify wallet signature after receiving the challenge.
+     * @param address Wallet address
+     * @param signature Signature generated by the wallet
+     * @param nonce Nonce used in the challenge
+     * @returns Verification result and token if successful
+     */
+    verifyWalletSignature(signature: string): Promise<{
+        success: boolean;
+        token?: string;
+        message?: string;
+    }>;
+}
+
+/**
+ * logChatPromiseExecution - utility function for logging the execution of a promise..
+ *  use this when you want to run the promise and handle errors by logging a warning
+ *
+ * @param {Promise<T>} promise The promise you want to run and log
+ * @param {string} name    A descriptive name of what the promise does for log output
+ *
+ */
+declare function logChatPromiseExecution<T>(promise: Promise<T>, name: string): void;
+declare const chatCodes: {
+    TOKEN_EXPIRED: number;
+    WS_CLOSED_SUCCESS: number;
+};
+/**
+ * formatMessage - Takes the message object. Parses the dates, sets __html
+ * and sets the status to received if missing. Returns a message object
+ *
+ * @param {MessageResponse<ErmisChatGenerics>} message a message object
+ *
+ */
+declare function formatMessage<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics>(message: MessageResponse<ErmisChatGenerics>): FormatMessageResponse<ErmisChatGenerics>;
+declare const createForwardMessagePayload: <ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics>(message: FormatMessageResponse<ErmisChatGenerics>, targetCid: string, activeCid: string) => ForwardMessage<ErmisChatGenerics>;
+
+/**
+ * Parse a raw system message string into a human-readable English sentence.
+ *
+ * The raw format is: `"<formatId> <userID> [<param1> <param2> ...]"`
+ *
+ * @param value   - Raw system message string from the server
+ * @param userMap - Mapping of user IDs → display names
+ * @returns         Parsed English text, or the original string if the format is unknown
+ */
+declare function parseSystemMessage(value: string, userMap: Record<string, string>): string;
+
+/**
+ * Parse a raw signal message string into a human-readable English sentence.
+ *
+ * Signal messages represent call events. The raw format is:
+ * `"<formatId> <userID> [<param1> <param2> ...]"`
+ *
+ * @param value   - Raw signal message string from the server
+ * @param userMap - Mapping of user IDs → display names
+ * @returns         Parsed English text, or the original string if unknown
+ */
+declare function parseSignalMessage(value: string, userMap: Record<string, string>): string;
+
+export { type APIErrorResponse, type APIResponse, type AscDesc, type Attachment, type AttachmentResponse, type AudioConfig, CallAction, type CallEventData, type CallEventType, CallStatus, Channel, type ChannelAPIResponse, type ChannelData, type ChannelFilters, type ChannelMemberResponse, type ChannelMembership, type ChannelQueryOptions, type ChannelResponse, type ChannelSort, ChannelState, type ChannelStateOptions, ClientState, type ConnectAPIResponse, type ConnectionOpen, type Contact, type ContactResponse, type ContactResult, type DefaultGenerics, EVENT_MAP, type EditMessage, ErmisAuthProvider, ErmisCallNode, ErmisChat, type ErmisChatOptions, ErrorFromResponse, type Event$1 as Event, type EventHandler, type EventTypes, type ExtendableGenerics, FRAME_TYPE, type FormatMessageResponse, type ForwardMessage, type IMediaReceiverEvents, type INodeCall, type LiteralStringForUnion, type LogLevel, type Logger, type Message, type MessageBase, type MessageLabel, type MessageResponse, type MessageResponseBase, type MessageSetType, type Metadata, type PollMessage, type QueryChannelAPIResponse, type QueryChannelsAPIResponse, type Reaction, type ReactionAPIResponse, type ReactionResponse, type ReadResponse, type Role, type SendFileAPIResponse, type SendMessageAPIResponse, type SignalData, StableWSConnection, TokenManager, type TransceiverState, type UR, type UpdateChannelAPIResponse, type UserCallInfo, type UserResponse, type UsersResponse, type VideoConfig, type VoiceRecordingMeta, buildAttachmentPayload, chatCodes, createForwardMessagePayload, formatMessage, getAttachmentCategory, isHeicFile, isVideoFile, logChatPromiseExecution, normalizeFileName, parseSignalMessage, parseSystemMessage };