tuikit-atomicx-vue3 4.4.0 → 4.5.0

package/dist/types/participant.d.ts

@@ -0,0 +1,243 @@
+import { Ref } from 'vue';
+import { DeviceType, DeviceStatus, NetworkInfo } from './device';
+import { RoomUser } from './room';
+
+export declare enum RoomParticipantRole {
+    Owner = 0,
+    Admin = 1,
+    GeneralUser = 2
+}
+export declare enum RoomParticipantStatus {
+    None = "None",// 未定义
+    Scheduled = "Scheduled",
+    InCalling = "InCalling",
+    CallTimeout = "CallTimeout",
+    CallRejected = "CallRejected",
+    InRoom = "InRoom"
+}
+export interface RoomParticipant extends RoomUser {
+    nameCard: string;
+    role: RoomParticipantRole;
+    roomStatus: RoomParticipantStatus;
+    microphoneStatus: DeviceStatus;
+    cameraStatus: DeviceStatus;
+    screenShareStatus: DeviceStatus;
+    isMessageDisabled: boolean;
+    metaData: Record<string, string>;
+}
+export declare enum KickedOutOfRoomReason {
+    KickedByAdmin = "KickedByAdmin",
+    ReplacedByAnotherDevice = "ReplacedByAnotherDevice",
+    KickedByServer = "KickedByServer",
+    ConnectionTimeout = "ConnectionTimeout",
+    InvalidStatusOnReconnect = "InvalidStatusOnReconnect",
+    RoomLimitExceeded = "RoomLimitExceeded"
+}
+export interface DeviceRequestInfo {
+    timestamp: number;
+    senderUserId: string;
+    senderUserName: string;
+    senderNameCard: string;
+    senderAvatarUrl: string;
+    content: string;
+    deviceType: DeviceType;
+}
+export declare enum VideoStreamType {
+    Screen = "screen",
+    Camera = "camera"
+}
+export declare enum FillMode {
+    Fill = "fill",// 图像铺满屏幕
+    Fit = "fit"
+}
+export declare enum RoomLayoutTemplate {
+    GridLayout = "gridLayout",
+    CinemaLayout = "cinemaLayout",// 顶部栏
+    SidebarLayout = "sidebarLayout"
+}
+export interface IRoomParticipantState {
+    participantList: Ref<RoomParticipant[]>;
+    participantListCursor: Ref<string>;
+    participantListWithVideo: Ref<RoomParticipant[]>;
+    participantWithScreen: Ref<RoomParticipant | null>;
+    pendingDeviceApplications: Ref<DeviceRequestInfo[]>;
+    pendingDeviceInvitations: Ref<DeviceRequestInfo[]>;
+    speakingUsers: Ref<Map<string, number>>;
+    networkQualities: Ref<Map<string, NetworkInfo>>;
+    pendingParticipantList: Ref<RoomParticipant[]>;
+    readonly localParticipant: Ref<RoomParticipant | null>;
+    getParticipantList(options: {
+        cursor?: string;
+    }): Promise<{
+        participantList: RoomParticipant[];
+        cursor: string;
+    }>;
+    transferOwner(options: {
+        userId: string;
+    }): Promise<void>;
+    setAdmin(options: {
+        userId: string;
+    }): Promise<void>;
+    revokeAdmin(options: {
+        userId: string;
+    }): Promise<void>;
+    kickParticipant(options: {
+        userId: string;
+    }): Promise<void>;
+    updateParticipantNameCard(options: {
+        userId: string;
+        nameCard: string;
+    }): Promise<void>;
+    updateParticipantMetaData(options: {
+        userId: string;
+        metaData: Record<string, string>;
+    }): Promise<void>;
+    closeParticipantDevice(options: {
+        userId: string;
+        deviceType: DeviceType;
+    }): Promise<void>;
+    muteParticipantMessage(options: {
+        userId: string;
+        mute: boolean;
+    }): Promise<void>;
+    disableAllDevices(options: {
+        deviceType: DeviceType;
+        disable: boolean;
+    }): Promise<void>;
+    disableAllMessages(options: {
+        disable: boolean;
+    }): Promise<void>;
+    requestToOpenDevice(options: {
+        device: DeviceType;
+        timeout?: number;
+    }): Promise<void>;
+    cancelOpenDeviceRequest(options: {
+        device: DeviceType;
+    }): Promise<void>;
+    approveOpenDeviceRequest(options: {
+        device: DeviceType;
+        userId: string;
+    }): Promise<void>;
+    rejectOpenDeviceRequest(options: {
+        device: DeviceType;
+        userId: string;
+    }): Promise<void>;
+    inviteToOpenDevice(options: {
+        userId: string;
+        device: DeviceType;
+        timeout?: number;
+    }): Promise<void>;
+    cancelOpenDeviceInvitation(options: {
+        userId: string;
+        device: DeviceType;
+    }): Promise<void>;
+    acceptOpenDeviceInvitation(options: {
+        userId: string;
+        device: DeviceType;
+    }): Promise<void>;
+    declineOpenDeviceInvitation(options: {
+        userId: string;
+        device: DeviceType;
+    }): Promise<void>;
+    subscribeEvent(event: RoomParticipantEvent, callback: RoomParticipantEventPayloads[keyof RoomParticipantEventPayloads]): void;
+    unsubscribeEvent(event: RoomParticipantEvent, callback: RoomParticipantEventPayloads[keyof RoomParticipantEventPayloads]): void;
+}
+export declare enum RoomParticipantEvent {
+    onParticipantJoined = "onParticipantJoined",
+    onParticipantLeft = "onParticipantLeft",
+    onOwnerChanged = "onOwnerChanged",
+    onAdminSet = "onAdminSet",
+    onAdminRevoked = "onAdminRevoked",
+    onKickedFromRoom = "onKickedFromRoom",
+    onParticipantDeviceClosed = "onParticipantDeviceClosed",
+    onParticipantMessageMuted = "onParticipantMessageMuted",
+    onAllDevicesDisabled = "onAllDevicesDisabled",
+    onAllMessagesDisabled = "onAllMessagesDisabled",
+    onDeviceRequestReceived = "onDeviceRequestReceived",
+    onDeviceRequestCancelled = "onDeviceRequestCancelled",
+    onDeviceRequestTimeout = "onDeviceRequestTimeout",
+    onDeviceRequestApproved = "onDeviceRequestApproved",
+    onDeviceRequestRejected = "onDeviceRequestRejected",
+    onDeviceRequestProcessed = "onDeviceRequestProcessed",
+    onDeviceInvitationReceived = "onDeviceInvitationReceived",
+    onDeviceInvitationCancelled = "onDeviceInvitationCancelled",
+    onDeviceInvitationTimeout = "onDeviceInvitationTimeout",
+    onDeviceInvitationAccepted = "onDeviceInvitationAccepted",
+    onDeviceInvitationDeclined = "onDeviceInvitationDeclined"
+}
+export interface RoomParticipantEventPayloads {
+    onParticipantJoined: (options: {
+        userInfo: RoomUser;
+    }) => void;
+    onParticipantLeft: (options: {
+        userInfo: RoomUser;
+    }) => void;
+    onOwnerChanged: (options: {
+        newOwner: RoomUser;
+    }) => void;
+    onAdminSet: (options: {
+        userInfo: RoomUser;
+    }) => void;
+    onAdminRevoked: (options: {
+        userInfo: RoomUser;
+    }) => void;
+    onKickedFromRoom: (options: {
+        reason: KickedOutOfRoomReason;
+        message: string;
+    }) => void;
+    onParticipantDeviceClosed: (options: {
+        device: DeviceType;
+        operator: RoomUser;
+    }) => void;
+    onParticipantMessageMuted: (options: {
+        muted: boolean;
+        operator: RoomUser;
+    }) => void;
+    onAllDevicesDisabled: (options: {
+        device: DeviceType;
+        disable: boolean;
+        operator: RoomUser;
+    }) => void;
+    onAllMessagesDisabled: (options: {
+        disable: boolean;
+        operator: RoomUser;
+    }) => void;
+    onDeviceRequestReceived: (options: {
+        request: DeviceRequestInfo;
+    }) => void;
+    onDeviceRequestCancelled: (options: {
+        request: DeviceRequestInfo;
+    }) => void;
+    onDeviceRequestTimeout: (options: {
+        request: DeviceRequestInfo;
+    }) => void;
+    onDeviceRequestApproved: (options: {
+        request: DeviceRequestInfo;
+        operator: RoomUser;
+    }) => void;
+    onDeviceRequestRejected: (options: {
+        request: DeviceRequestInfo;
+        operator: RoomUser;
+    }) => void;
+    onDeviceRequestProcessed: (options: {
+        request: DeviceRequestInfo;
+        operator: RoomUser;
+    }) => void;
+    onDeviceInvitationReceived: (options: {
+        invitation: DeviceRequestInfo;
+    }) => void;
+    onDeviceInvitationCancelled: (options: {
+        invitation: DeviceRequestInfo;
+    }) => void;
+    onDeviceInvitationTimeout: (options: {
+        invitation: DeviceRequestInfo;
+    }) => void;
+    onDeviceInvitationAccepted: (options: {
+        invitation: DeviceRequestInfo;
+        operator: RoomUser;
+    }) => void;
+    onDeviceInvitationDeclined: (options: {
+        invitation: DeviceRequestInfo;
+        operator: RoomUser;
+    }) => void;
+}

package/dist/types/participant.js

@@ -0,0 +1,10 @@
+var n = /* @__PURE__ */ ((e) => (e[e.Owner = 0] = "Owner", e[e.Admin = 1] = "Admin", e[e.GeneralUser = 2] = "GeneralUser", e))(n || {}), d = /* @__PURE__ */ ((e) => (e.None = "None", e.Scheduled = "Scheduled", e.InCalling = "InCalling", e.CallTimeout = "CallTimeout", e.CallRejected = "CallRejected", e.InRoom = "InRoom", e))(d || {}), i = /* @__PURE__ */ ((e) => (e.KickedByAdmin = "KickedByAdmin", e.ReplacedByAnotherDevice = "ReplacedByAnotherDevice", e.KickedByServer = "KickedByServer", e.ConnectionTimeout = "ConnectionTimeout", e.InvalidStatusOnReconnect = "InvalidStatusOnReconnect", e.RoomLimitExceeded = "RoomLimitExceeded", e))(i || {}), c = /* @__PURE__ */ ((e) => (e.Screen = "screen", e.Camera = "camera", e))(c || {}), l = /* @__PURE__ */ ((e) => (e.Fill = "fill", e.Fit = "fit", e))(l || {}), v = /* @__PURE__ */ ((e) => (e.GridLayout = "gridLayout", e.CinemaLayout = "cinemaLayout", e.SidebarLayout = "sidebarLayout", e))(v || {}), D = /* @__PURE__ */ ((e) => (e.onParticipantJoined = "onParticipantJoined", e.onParticipantLeft = "onParticipantLeft", e.onOwnerChanged = "onOwnerChanged", e.onAdminSet = "onAdminSet", e.onAdminRevoked = "onAdminRevoked", e.onKickedFromRoom = "onKickedFromRoom", e.onParticipantDeviceClosed = "onParticipantDeviceClosed", e.onParticipantMessageMuted = "onParticipantMessageMuted", e.onAllDevicesDisabled = "onAllDevicesDisabled", e.onAllMessagesDisabled = "onAllMessagesDisabled", e.onDeviceRequestReceived = "onDeviceRequestReceived", e.onDeviceRequestCancelled = "onDeviceRequestCancelled", e.onDeviceRequestTimeout = "onDeviceRequestTimeout", e.onDeviceRequestApproved = "onDeviceRequestApproved", e.onDeviceRequestRejected = "onDeviceRequestRejected", e.onDeviceRequestProcessed = "onDeviceRequestProcessed", e.onDeviceInvitationReceived = "onDeviceInvitationReceived", e.onDeviceInvitationCancelled = "onDeviceInvitationCancelled", e.onDeviceInvitationTimeout = "onDeviceInvitationTimeout", e.onDeviceInvitationAccepted = "onDeviceInvitationAccepted", e.onDeviceInvitationDeclined = "onDeviceInvitationDeclined", e))(D || {});
+export {
+  l as FillMode,
+  i as KickedOutOfRoomReason,
+  v as RoomLayoutTemplate,
+  D as RoomParticipantEvent,
+  n as RoomParticipantRole,
+  d as RoomParticipantStatus,
+  c as VideoStreamType
+};

package/dist/types/room.d.ts

@@ -1,66 +1,213 @@
-import { TUIConferenceStatus, TUIUserInfo } from '@tencentcloud/tuiroom-engine-js';
-import { TUIRoomType, TUISeatMode, TUILoginUserInfo } from './types';
+import { Ref } from 'vue';
 
-export type RoomInfo = {
-    roomId: string;
-    roomName: string;
-    roomOwner: TUILoginUserInfo;
-    memberCount: number;
-    createTime: number;
-    roomStatus: TUIConferenceStatus;
-    scheduleStartTime: number;
-    scheduleEndTime: number;
-    reminderSecondsBeforeStart: number;
-    scheduleAttendees: TUIUserInfo[];
-    password: string;
-    isSeatEnabled: boolean;
-    seatMode: TUISeatMode;
-    maxSeatCount: number;
-    isMicrophoneDisableForAllUser: boolean;
-    isScreenShareDisableForAllUser: boolean;
-    isCameraDisableForAllUser: boolean;
-    isMessageDisableForAllUser: boolean;
-    customInfo: Record<string, any>;
-};
-export interface StartRoomParams {
-    roomId: string;
-    roomName?: string;
-    seatMode?: TUISeatMode;
-    maxSeatCount?: number;
-    isMicrophoneDisableForAllUser?: boolean;
-    isScreenShareDisableForAllUser?: boolean;
-    isCameraDisableForAllUser?: boolean;
-    isMessageDisableForAllUser?: boolean;
+export declare enum RoomStatus {
+    Scheduled = 1,
+    Running = 2
 }
-export interface EnterRoomParams {
-    roomId: string;
+export interface RoomUser {
+    userId: string;
+    userName: string;
+    avatarUrl: string;
 }
-export interface ScheduleRoomParams {
+export interface RoomInfo {
+    readonly roomId: string;
+    roomName: string;
+    roomOwner: RoomUser;
+    readonly participantCount?: number;
+    readonly createTime?: number;
+    readonly roomStatus?: RoomStatus;
+    scheduledStartTime?: number;
+    scheduledEndTime?: number;
+    startReminderInSeconds?: number;
+    scheduleAttendees?: RoomUser[];
+    password?: string;
+    isAllMicrophoneDisabled?: boolean;
+    isAllCameraDisabled?: boolean;
+    isAllScreenShareDisabled?: boolean;
+    isAllMessageDisabled?: boolean;
+}
+export type ScheduleRoomOptions = {
+    roomName?: string;
+    password?: string;
     scheduleStartTime: number;
     scheduleEndTime: number;
-    scheduleAttendees?: string[];
     reminderSecondsBeforeStart?: number;
-    roomId: string;
+    scheduleAttendees?: string[];
+    isAllMicrophoneDisabled?: boolean;
+    isAllCameraDisabled?: boolean;
+    isAllScreenShareDisabled?: boolean;
+    isAllMessageDisabled?: boolean;
+};
+export type CreateRoomOptions = {
+    roomName?: string;
+    password?: string;
+    isAllMicrophoneDisabled?: boolean;
+    isAllCameraDisabled?: boolean;
+    isAllScreenShareDisabled?: boolean;
+    isAllMessageDisabled?: boolean;
+};
+export type UpdateRoomOptions = {
     roomName?: string;
-    roomType?: TUIRoomType;
-    isSeatEnabled?: boolean;
-    seatMode?: TUISeatMode;
-    isMicrophoneDisableForAllUser?: boolean;
-    isScreenShareDisableForAllUser?: boolean;
-    isCameraDisableForAllUser?: boolean;
-    isMessageDisableForAllUser?: boolean;
-    maxSeatCount?: number;
     password?: string;
+};
+export declare enum RoomCallStatus {
+    None = 0,
+    Calling = 1,
+    Timeout = 2,
+    Rejected = 3
+}
+export declare enum RoomCallResult {
+    Success = 0,
+    AlreadyInCalling = 1,
+    AlreadyInRoom = 2
+}
+export interface RoomCall {
+    caller: RoomUser;
+    callee: RoomUser;
+    status?: RoomCallStatus;
+}
+export interface IRoomState {
+    scheduledRoomList: Ref<RoomInfo[]>;
+    scheduledRoomListCursor: Ref<string>;
+    currentRoom: Ref<RoomInfo | null>;
+    getScheduledRoomList(options: {
+        cursor: string;
+    }): Promise<{
+        scheduledRoomList: RoomInfo[];
+        cursor: string;
+    }>;
+    getScheduledAttendees(options: {
+        roomId: string;
+        cursor: string;
+    }): Promise<{
+        attendees: RoomUser[];
+        cursor: string;
+        totalAttendeesCount: number;
+    }>;
+    scheduleRoom(options: {
+        roomId: string;
+        options: ScheduleRoomOptions;
+    }): Promise<void>;
+    updateScheduledRoom(options: {
+        roomId: string;
+        options: ScheduleRoomOptions;
+    }): Promise<void>;
+    addScheduledAttendees(options: {
+        roomId: string;
+        userIdList: string[];
+    }): Promise<void>;
+    removeScheduledAttendees(options: {
+        roomId: string;
+        userIdList: string[];
+    }): Promise<void>;
+    cancelScheduledRoom(options: {
+        roomId: string;
+    }): Promise<void>;
+    createAndJoinRoom(options: {
+        roomId: string;
+        options: CreateRoomOptions;
+    }): Promise<void>;
+    joinRoom(options: {
+        roomId: string;
+        password?: string;
+    }): Promise<void>;
+    leaveRoom(): Promise<void>;
+    endRoom(): Promise<void>;
+    updateRoomInfo(options: {
+        roomId: string;
+        options: UpdateRoomOptions;
+    }): Promise<void>;
+    getRoomInfo(options: {
+        roomId: string;
+    }): Promise<RoomInfo>;
+    getPendingCalls(options: {
+        roomId: string;
+        cursor: string;
+    }): Promise<{
+        calls: RoomCall[];
+        cursor: string;
+    }>;
+    callUserToRoom(options: {
+        roomId: string;
+        userIdList: string[];
+        timeout?: number;
+        extensionInfo?: string;
+    }): Promise<Map<string, RoomCallResult>>;
+    cancelCall(options: {
+        roomId: string;
+        userIdList: string[];
+    }): Promise<void>;
+    acceptCall(options: {
+        roomId: string;
+    }): Promise<void>;
+    rejectCall(options: {
+        roomId: string;
+        extensionInfo?: string;
+    }): Promise<void>;
+    subscribeEvent<T extends RoomEvent>(event: T | `${T}`, handler: RoomEventHandlers[T]): void;
+    unsubscribeEvent<T extends RoomEvent>(event: T | `${T}`, handler: RoomEventHandlers[T]): void;
 }
-export declare enum RoomAction {
-    AudioAction = "RoomAudioAction",
-    VideoAction = "RoomVideoAction",
-    ScreenAction = "RoomScreenAction"
+export declare enum RoomEvent {
+    onAddedToScheduledRoom = "onAddedToScheduledRoom",
+    onRemovedFromScheduledRoom = "onRemovedFromScheduledRoom",
+    onScheduledRoomCancelled = "onScheduledRoomCancelled",
+    onScheduledRoomStartingSoon = "onScheduledRoomStartingSoon",
+    onRoomEnded = "onRoomEnded",
+    onCallReceived = "onCallReceived",
+    onCallCancelled = "onCallCancelled",
+    onCallTimeout = "onCallTimeout",
+    onCallAccepted = "onCallAccepted",
+    onCallRejected = "onCallRejected",
+    onCallHandledByOtherDevice = "onCallHandledByOtherDevice",
+    onCallRevokedByAdmin = "onCallRevokedByAdmin"
 }
-export declare enum LocalRoomStatus {
-    IDLE = "IDLE",// 未加入会议
-    JOINING = "JOINING",// 正在加入会议
-    JOINED = "JOINED",// 已加入会议
-    EXITING = "EXITING",// 正在退出会议
-    EXITED = "EXITED"
+export interface RoomEventHandlers {
+    onAddedToScheduledRoom: (options: {
+        roomInfo: RoomInfo;
+    }) => void;
+    onRemovedFromScheduledRoom: (options: {
+        roomInfo: RoomInfo;
+        operator: RoomUser;
+    }) => void;
+    onScheduledRoomCancelled: (options: {
+        roomInfo: RoomInfo;
+        operator: RoomUser;
+    }) => void;
+    onScheduledRoomStartingSoon: (options: {
+        roomInfo: RoomInfo;
+    }) => void;
+    onRoomEnded: (options: {
+        roomInfo: RoomInfo;
+    }) => void;
+    onCallReceived: (options: {
+        roomInfo: RoomInfo;
+        call: RoomCall;
+        extensionInfo: string;
+    }) => void;
+    onCallCancelled: (options: {
+        roomInfo: RoomInfo;
+        call: RoomCall;
+    }) => void;
+    onCallTimeout: (options: {
+        roomInfo: RoomInfo;
+        call: RoomCall;
+    }) => void;
+    onCallAccepted: (options: {
+        roomInfo: RoomInfo;
+        call: RoomCall;
+    }) => void;
+    onCallRejected: (options: {
+        roomInfo: RoomInfo;
+        call: RoomCall;
+        extensionInfo: string;
+    }) => void;
+    onCallHandledByOtherDevice: (options: {
+        roomInfo: RoomInfo;
+        isAccepted: boolean;
+    }) => void;
+    onCallRevokedByAdmin: (options: {
+        roomInfo: RoomInfo;
+        call: RoomCall;
+        operator: RoomUser;
+    }) => void;
 }

package/dist/types/room.js

@@ -1,5 +1,7 @@
-var E = /* @__PURE__ */ ((I) => (I.AudioAction = "RoomAudioAction", I.VideoAction = "RoomVideoAction", I.ScreenAction = "RoomScreenAction", I))(E || {}), e = /* @__PURE__ */ ((I) => (I.IDLE = "IDLE", I.JOINING = "JOINING", I.JOINED = "JOINED", I.EXITING = "EXITING", I.EXITED = "EXITED", I))(e || {});
+var d = /* @__PURE__ */ ((e) => (e[e.Scheduled = 1] = "Scheduled", e[e.Running = 2] = "Running", e))(d || {}), n = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Calling = 1] = "Calling", e[e.Timeout = 2] = "Timeout", e[e.Rejected = 3] = "Rejected", e))(n || {}), l = /* @__PURE__ */ ((e) => (e[e.Success = 0] = "Success", e[e.AlreadyInCalling = 1] = "AlreadyInCalling", e[e.AlreadyInRoom = 2] = "AlreadyInRoom", e))(l || {}), c = /* @__PURE__ */ ((e) => (e.onAddedToScheduledRoom = "onAddedToScheduledRoom", e.onRemovedFromScheduledRoom = "onRemovedFromScheduledRoom", e.onScheduledRoomCancelled = "onScheduledRoomCancelled", e.onScheduledRoomStartingSoon = "onScheduledRoomStartingSoon", e.onRoomEnded = "onRoomEnded", e.onCallReceived = "onCallReceived", e.onCallCancelled = "onCallCancelled", e.onCallTimeout = "onCallTimeout", e.onCallAccepted = "onCallAccepted", e.onCallRejected = "onCallRejected", e.onCallHandledByOtherDevice = "onCallHandledByOtherDevice", e.onCallRevokedByAdmin = "onCallRevokedByAdmin", e))(c || {});
 export {
-  e as LocalRoomStatus,
-  E as RoomAction
+  l as RoomCallResult,
+  n as RoomCallStatus,
+  c as RoomEvent,
+  d as RoomStatus
 };

package/dist/types/virtualBackground.d.ts

@@ -0,0 +1,14 @@
+export interface VirtualBackgroundConfig {
+    enable?: boolean;
+    type?: VirtualBackgroundType;
+    blurLevel?: number;
+    imagePath?: string;
+}
+export declare enum VirtualBackgroundType {
+    blur = "blur",
+    image = "image"
+}
+export declare enum VirtualBackgroundEvent {
+    onAbort = "onAbort"
+}
+export type VirtualBackgroundEventCallback = () => void;

package/dist/types/virtualBackground.js

@@ -0,0 +1,5 @@
+var b = /* @__PURE__ */ ((r) => (r.blur = "blur", r.image = "image", r))(b || {}), e = /* @__PURE__ */ ((r) => (r.onAbort = "onAbort", r))(e || {});
+export {
+  e as VirtualBackgroundEvent,
+  b as VirtualBackgroundType
+};

package/dist/utils/call.d.ts

@@ -4,5 +4,5 @@ import { MessageModel } from '../types/engine';
 declare function isCallMessage(message: MessageModel): boolean;
 declare function startCall(params: StartCallParams): void;
 declare function parseCallMessage(message: MessageModel): CallMessagePayload | undefined;
-declare function parseCallMessageText(message: MessageModel): string;
+declare function parseCallMessageText(message: MessageModel, t: any): string;
 export { startCall, isCallMessage, parseCallMessage, parseCallMessageText };