agora-rte-sdk 1.1.5 → 2.0.0-beta

package/lib/configs/index.d.ts

@@ -0,0 +1,67 @@
+import { AREAS } from 'agora-rtc-sdk-ng';
+import { RtmStatusCode } from 'agora-rtm-sdk';
+import { AGRtcConfig } from '../core/rtc/adapter';
+declare global {
+    interface Window {
+        isElectron: boolean;
+    }
+}
+export declare enum AgoraRteLogLevel {
+    OFF = 0,
+    ERROR = 1,
+    WARN = 2,
+    INFO = 3,
+    DEBUG = 4,
+    VERBOSE = 5
+}
+export declare enum AgoraRteRuntimePlatform {
+    Electron = 0,
+    Web = 1
+}
+export interface AgoraRteServiceConfig {
+    host?: string;
+    pathPrefix?: string;
+    headers?: Record<string, string | number>;
+}
+export declare enum RteLanguage {
+    zh = "zh",
+    en = "en"
+}
+export declare enum AgoraRegion {
+    CN = "CN",
+    AP = "AP",
+    EU = "EU",
+    NA = "NA"
+}
+export declare type AgoraComponentRegion = 'AREA_GLOBAL' | 'AREA_AS' | 'AREA_EUR' | 'AREA_NA';
+export interface AgoraRteOptions {
+    language?: RteLanguage;
+    region?: AgoraRegion;
+    rtcConfigs?: Partial<AGRtcConfig>;
+}
+export declare class AgoraRteEngineConfig {
+    private static _config?;
+    static get shared(): AgoraRteEngineConfig;
+    static setConfig(config: AgoraRteEngineConfig): void;
+    appId: string;
+    service: AgoraRteServiceConfig;
+    rtcConfigs: AGRtcConfig;
+    logFilePath?: string;
+    static logLevel: AgoraRteLogLevel;
+    static readonly platform: AgoraRteRuntimePlatform;
+    userId: string;
+    token: string;
+    ignoreUrlRegionPrefix: boolean;
+    language: RteLanguage;
+    debugI18n: boolean;
+    region: AgoraRegion;
+    private _rtcRegion?;
+    private _rtmRegion?;
+    SCENE_JOIN_RETRY_ATTEMPTS: number;
+    constructor(appId: string, opts?: AgoraRteOptions);
+    get rtcRegion(): AREAS;
+    get rtmRegion(): RtmStatusCode.AreaCode;
+    setRtcRegion(area: AgoraComponentRegion): void;
+    setRtmRegion(area: AgoraComponentRegion): void;
+    static get version(): string;
+}

package/lib/core/decorator/bound/index.d.ts

@@ -0,0 +1,11 @@
+declare const bound: (proto: any, propertyName: string, descriptor: PropertyDescriptor) => {
+    configurable: boolean;
+    enumerable: boolean;
+    get(this: {
+        __cacheMap: WeakMap<Object, any>;
+    }): any;
+    set(this: {
+        __cacheMap: WeakMap<Object, any>;
+    }, v: any): void;
+};
+export { bound };

package/lib/core/decorator/handlers/log-handler.d.ts

@@ -0,0 +1,2 @@
+import { InvocationEvent } from '../type';
+export declare const createLogHandler: (level: 'info' | 'warn' | 'error') => (evt: InvocationEvent) => void;

package/lib/core/decorator/index.d.ts

@@ -0,0 +1,4 @@
+export * from './log';
+export * from './bound';
+export * from './lodash';
+export type { Injectable } from './type';

package/lib/core/decorator/lodash/index.d.ts

@@ -0,0 +1,13 @@
+import { DebounceSettings, ThrottleSettings } from 'lodash';
+export declare const Lodash: {
+    debounced: (wait?: number | undefined, options?: DebounceSettings | undefined) => (proto: any, propertyName: string, descriptor: PropertyDescriptor) => {
+        configurable: boolean;
+        enumerable: boolean;
+        get(): import("lodash").DebouncedFunc<any>;
+    };
+    throttled: (wait?: number | undefined, options?: ThrottleSettings | undefined) => (proto: any, propertyName: string, descriptor: PropertyDescriptor) => {
+        configurable: boolean;
+        enumerable: boolean;
+        get(): import("lodash").DebouncedFunc<any>;
+    };
+};

package/lib/core/decorator/log/index.d.ts

@@ -0,0 +1,23 @@
+import { AgoraRteLogLevel } from '../../../configs';
+export declare const Log: {
+    info: (proto: any, propertyName: string, descriptor: PropertyDescriptor) => {
+        configurable: boolean;
+        enumerable: boolean;
+        get(): (this: any, ...args: any[]) => any;
+    };
+    warn: (proto: any, propertyName: string, descriptor: PropertyDescriptor) => {
+        configurable: boolean;
+        enumerable: boolean;
+        get(): (this: any, ...args: any[]) => any;
+    };
+    error: (proto: any, propertyName: string, descriptor: PropertyDescriptor) => {
+        configurable: boolean;
+        enumerable: boolean;
+        get(): (this: any, ...args: any[]) => any;
+    };
+    attach: ({ level, proxyMethods, }: {
+        level?: AgoraRteLogLevel | undefined;
+        proxyMethods?: boolean | undefined;
+    }) => <T extends new (...args: any[]) => {}>(constructor: T) => T;
+    silence: (proto: any, propertyName: string) => void;
+};

package/lib/core/decorator/log/log-serializer.d.ts

@@ -0,0 +1,7 @@
+interface Serializer {
+    match(obj: any): boolean;
+    serialize(obj: any): string;
+}
+export declare const addSerializer: (serializer: Serializer) => void;
+export declare const serialize: (data: unknown) => unknown;
+export {};

package/lib/core/decorator/log/logger.d.ts

@@ -0,0 +1,2 @@
+import { Injectable } from '../type';
+export declare const createLogger: (constructor: any) => Injectable.Logger;

package/lib/core/decorator/proxy.d.ts

@@ -0,0 +1,8 @@
+import { InvocationEvent, InvocationHandler } from './type';
+export declare const proxyMethod: (method: Function, proto: any, propertyName: string, handler: InvocationHandler, context: InvocationEvent['context']) => (this: any, ...args: any[]) => any;
+export declare const extendConstructor: (constructor: any, handler: InvocationHandler, context: InvocationEvent['context'], extendProps?: any, proxyMethods?: boolean | undefined) => {
+    new (...args: any[]): {
+        [x: string]: any;
+    };
+    [x: string]: any;
+};

package/lib/core/decorator/type.d.ts

@@ -0,0 +1,18 @@
+export declare enum InvocationEventType {
+    pre = 0,
+    post = 1
+}
+export declare type InvocationEvent = {
+    type: InvocationEventType;
+    context: Record<string, any>;
+    class: string;
+    method: string;
+    arguments?: any[];
+    return?: any;
+    error?: Error;
+};
+export declare type InvocationHandler = (event: InvocationEvent) => void;
+export declare type AnyFunction = (...args: any) => any;
+export declare namespace Injectable {
+    type Logger = Pick<Console, 'info' | 'warn' | 'error' | 'debug'>;
+}

package/lib/core/decorator/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const addIgnoredMethodsToPrototype: (prototype: any, ignoredMethods: string[]) => void;
+export declare const isIgnoredMethod: (prototype: any, method: string) => any;

package/lib/core/engine/index.d.ts

@@ -0,0 +1,25 @@
+import { AGEventEmitter } from '../utils/events';
+import { AgoraRteEngineConfig } from '../../configs';
+import { AgoraRteScene } from '../../scene';
+import { AgoraMediaControl } from '../media/control';
+import { AgoraRteService } from '../services/api';
+export declare class AgoraRteEngine extends AGEventEmitter {
+    private _mediaControl;
+    private _apiService;
+    private _logService;
+    private _rtmManager;
+    private _rtcManager;
+    private static _engine?;
+    static get engine(): AgoraRteEngine;
+    constructor(config: AgoraRteEngineConfig);
+    static createWithConfig(config: AgoraRteEngineConfig): AgoraRteEngine;
+    static destroy(): void;
+    login(rtmToken: string, userId: string): Promise<void>;
+    logout(): void;
+    static getVersion(): string;
+    static getRtcVersion(): string;
+    createAgoraRteScene(sceneId: string): AgoraRteScene;
+    getAgoraMediaControl(): AgoraMediaControl;
+    getApiService(): AgoraRteService;
+    uploadSDKLogToAgoraService(roomId: string): Promise<void>;
+}

package/lib/core/logger/db.d.ts

@@ -1,3 +1,14 @@
-import { EduSDKLogger } from './edu-sdk-logger';
-export declare const openDB: () => EduSDKLogger;
-export declare const db: EduSDKLogger;
+import Dexie, { Table } from 'dexie';
+declare type Timestamp = number;
+declare type LogSchema = {
+    content: string;
+    created_at: Timestamp;
+    timestamp: string;
+};
+export declare class LoggerDB extends Dexie {
+    logs: Table<LogSchema, number>;
+    constructor();
+    openDatabase(): void;
+}
+export declare const db: LoggerDB;
+export {};

package/lib/core/logger/index.d.ts

@@ -1,23 +1,18 @@
-import LogWorker from 'worker-loader?inline=true&fallback=false!./log.worker';
-import { EduLogLevel } from './interfaces';
-import { LogUpload } from '../services/log-upload';
-export declare class EduLogger {
-    static logLevel: EduLogLevel;
-    private static get currentTime();
-    static setLogLevel(level: EduLogLevel): void;
+export interface LogFileCollection {
+    electron?: File;
+    web?: File;
+    clean: () => void;
+}
+export declare class Logger {
+    thread: any;
+    constructor();
+    static logger: Logger;
     static warn(...args: any[]): void;
     static debug(...args: any[]): void;
     static info(...args: any[]): void;
     static error(...args: any[]): void;
     private static log;
     static originConsole: Console;
-    static thread: LogWorker | null;
-    static logUploader: LogUpload;
-    static init(appId: string): void;
-    private static debugLog;
-    static uploadElectronLog(roomId: any): Promise<any>;
-    static get ts(): number;
-    static enableUpload(roomUuid: string, isElectron: boolean): Promise<string>;
-    private uploadCefLog;
-    static uploadLog(roomId: string): Promise<any>;
+    static setupConsoleHijack(): void;
+    collectLogs(): Promise<LogFileCollection>;
 }

package/lib/core/logger/log.worker.d.ts

@@ -1,2 +1 @@
-declare const _default: any;
-export default _default;
+export {};

package/lib/core/logger/mutex.d.ts

@@ -0,0 +1,5 @@
+export declare class Mutex {
+    private mutex;
+    lock(): PromiseLike<() => void>;
+    dispatch<T>(fn: (() => T) | (() => PromiseLike<T>)): Promise<T>;
+}

package/lib/core/media/control.d.ts

@@ -0,0 +1,39 @@
+import { AGEventEmitter } from '../utils/events';
+import { AGRtcManager } from '../rtc';
+import { AgoraRteCameraVideoTrack, AgoraRteMicrophoneAudioTrack, AgoraRteScreenShareTrack } from './track';
+import { AGRtcDeviceInfo, AGScreenShareDevice, BeautyEffect } from '../../';
+export declare enum AgoraMediaControlEventType {
+    cameraListChanged = "camera-list-changed",
+    localAudioVolume = "local-audio-volume",
+    localAudioRecordingListChanged = "local-audio-recording-list-changed",
+    localVideoTrackChanged = "local-video-track-changed",
+    localAudioTrackChanged = "local-audio-track-changed",
+    trackStateChanged = "track-state-changed",
+    playbackDeviceListChanged = "playback-device-list-changed",
+    recordingDeviceListChanged = "recording-device-list-changed",
+    localAudioPlaybackVolumeIndicator = "start-test-audio-playback-volume-indicator",
+    audioPlaybackStateChanged = "audio-playback-state-changed"
+}
+export declare class AgoraMediaControl extends AGEventEmitter {
+    camera?: AgoraRteCameraVideoTrack;
+    microphone?: AgoraRteMicrophoneAudioTrack;
+    screen?: AgoraRteScreenShareTrack;
+    private _rtc;
+    constructor(rtc: AGRtcManager);
+    private _addEventListener;
+    createCameraVideoTrack(): AgoraRteCameraVideoTrack;
+    createMicrophoneAudioTrack(): AgoraRteMicrophoneAudioTrack;
+    createScreenShareTrack(): AgoraRteScreenShareTrack;
+    getVideoCameraList(): AGRtcDeviceInfo[];
+    getAudioRecordingList(): AGRtcDeviceInfo[];
+    getAudioPlaybackList(): AGRtcDeviceInfo[];
+    isScreenDeviceEnumerateSupported(): boolean;
+    hasScreenSharePermission(): boolean;
+    getWindowDevices(): AGScreenShareDevice[];
+    getDisplayDevices(): AGScreenShareDevice[];
+    startAudioRecordingDeviceTest(indicateInterval: number): number;
+    stopAudioRecordingDeviceTest(): number;
+    startAudioPlaybackDeviceTest(url: string): number;
+    stopAudioPlaybackDeviceTest(): number;
+    setBeautyEffectOptions(enable: boolean, options: BeautyEffect): number;
+}

package/lib/core/media/track.d.ts

@@ -0,0 +1,52 @@
+import { AgoraRteMediaSourceState, AGScreenShareType } from '../..';
+import { AGRtcManager } from '../rtc';
+import { AgoraRtcVideoCanvas } from '../rtc/canvas';
+export declare enum AgoraRteVideoSourceType {
+    None = 0,
+    Camera = 1,
+    ScreenShare = 2
+}
+export declare enum AgoraRteAudioSourceType {
+    None = 0,
+    Mic = 1,
+    Mix = 2
+}
+export declare enum AgoraRteMediaPublishState {
+    Unpublished = 0,
+    Published = 1
+}
+export declare abstract class AgoraRteMediaTrack {
+    videoSourceType: AgoraRteVideoSourceType;
+    audioSourceType: AgoraRteAudioSourceType;
+    protected rtc: AGRtcManager;
+    constructor(rtc: AGRtcManager, { videoSourceType, audioSourceType, }: {
+        videoSourceType?: AgoraRteVideoSourceType;
+        audioSourceType?: AgoraRteAudioSourceType;
+    });
+    abstract start(): number;
+    abstract stop(): number;
+}
+export declare class AgoraRteCameraVideoTrack extends AgoraRteMediaTrack {
+    state: AgoraRteMediaSourceState;
+    constructor(rtc: AGRtcManager);
+    setView(canvas: AgoraRtcVideoCanvas): void;
+    setDeviceId(deviceid: string): void;
+    setVideoEncoderConfiguration(): void;
+    start(): number;
+    stop(): number;
+}
+export declare class AgoraRteMicrophoneAudioTrack extends AgoraRteMediaTrack {
+    state: AgoraRteMediaSourceState;
+    constructor(rtc: AGRtcManager);
+    setRecordingDevice(deviceId: string): number;
+    setPlaybackDevice(deviceId: string): number;
+    start(): number;
+    stop(): number;
+}
+export declare class AgoraRteScreenShareTrack extends AgoraRteMediaTrack {
+    constructor(rtc: AGRtcManager);
+    setView(canvas: AgoraRtcVideoCanvas): void;
+    start(): number;
+    startWithParams(id?: string, type?: AGScreenShareType): number;
+    stop(): number;
+}

package/lib/core/processor/channel-msg/data.d.ts

@@ -0,0 +1,26 @@
+import { AgoraChatMessage, AgoraRoom, AgoraStream, AgoraUser } from './struct';
+import Immutable from 'immutable';
+export declare class AgoraRteSyncDataStore {
+    private _users;
+    get users(): Immutable.Map<string, AgoraUser>;
+    setUsers(users: Map<string, AgoraUser>): void;
+    setUser(key: string, user: AgoraUser): void;
+    deleteUser(key: string): void;
+    findUser(userUuid: string): AgoraUser | undefined;
+    private _roomProperties;
+    get roomProperties(): Immutable.Map<string, unknown>;
+    setRoomProperties(roomProperties: any): void;
+    private _streams;
+    get streams(): Immutable.Map<string, AgoraStream>;
+    setStreams(streams: Map<string, AgoraStream>): void;
+    findUserStreams(userUuid: string): AgoraStream[];
+    setStream(key: string, stream: AgoraStream): void;
+    deleteStream(key: string): void;
+    findStream(streamUuid: string): AgoraStream | undefined;
+    private _roomInfo;
+    get roomInfo(): Immutable.Map<unknown, unknown>;
+    setRoomInfo(roomInfo: AgoraRoom): void;
+    private readonly _messages;
+    get messages(): Immutable.List<AgoraChatMessage>;
+    addMessage(message: AgoraChatMessage): void;
+}

package/lib/core/processor/channel-msg/handler.d.ts

@@ -0,0 +1,78 @@
+import { AgoraRteMessageHandleTask, AgoraRtePeerMessageHandleTask, AgoraRteSyncSnapshotData } from './struct';
+import { AgoraRteSyncDataStore } from './data';
+import { AGEventEmitter } from '../../utils/events';
+import { Injectable } from '../../decorator/type';
+export declare enum AgoraRteChannelMessageCmd {
+    Chat = 3,
+    RoomProperty = 4,
+    RoomProperties = 5,
+    UserInOut = 20,
+    UserInfo = 21,
+    UserProperty = 22,
+    UserProperties = 23,
+    StreamInOut = 40,
+    StreamsInOut = 41,
+    MessageExtension = 99
+}
+export declare enum AgoraRtePeerMessageCmd {
+    PeerChat = 1
+}
+export declare enum AgoraRteEventType {
+    SnapshotUpdated = "snapshot-updated",
+    ChatReceived = "chat-received",
+    UserAdded = "user-added",
+    UserUpdated = "user-updated",
+    UserRemoved = "user-removed",
+    RoomPropertyUpdated = "room-property-updated",
+    UserPropertyUpdated = "user-property-updated",
+    LocalStreamAdded = "local-stream-added",
+    LocalStreamUpdate = "local-stream-update",
+    LocalStreamRemove = "local-stream-removed",
+    RemoteStreamAdded = "remote-stream-added",
+    RemoteStreamUpdate = "remote-stream-update",
+    RemoteStreamRemove = "remote-stream-removed",
+    ChatUserMessage = "user-chat-message",
+    ChatRoomMessage = "room-chat-message",
+    NetworkStats = "network-stats",
+    LocalAudioVolume = "local-audio-volume",
+    AudioVolumes = "audio-volumes",
+    LocalVideoCameraListChanged = "local-video-camera-list-changed",
+    LocalAudioRecordingListChanged = "local-audio-recording-list-changed",
+    LocalAudioPlaybackListChanged = "local-audio-playback-list-changed",
+    LocalVideoTrackStateChanged = "local-video-track-state-changed",
+    LocalAudioTrackStateChanged = "local-audio-track-state-changed",
+    RtcConnectionStateChanged = "rtc-connection-state-changed",
+    RtmConnectionStateChanged = "rtm-connection-state-changed",
+    RteConnectionStateChanged = "rte-connection-state-changed"
+}
+export interface AgoraRteChannelMessageHandle {
+    on(evt: AgoraRteEventType, ...args: any[]): this;
+    off(evt: AgoraRteEventType, ...args: any[]): this;
+}
+export declare class AgoraRteChannelMessageHandle extends AGEventEmitter {
+    protected logger: Injectable.Logger;
+    private _dataStore;
+    sceneId: string;
+    userUuid: string;
+    streamUuid: string;
+    constructor(dataStore: AgoraRteSyncDataStore, { sceneId, userUuid, streamUuid, }: {
+        sceneId: string;
+        userUuid: string;
+        streamUuid: string;
+    });
+    handleSnapshot(snapshot: AgoraRteSyncSnapshotData): void;
+    handleMessage(task: AgoraRteMessageHandleTask): void;
+    handlePeerMessage(task: AgoraRtePeerMessageHandleTask): void;
+    private _handlePeerChat;
+    private _handleChat;
+    private _mergeProperties;
+    private _handleRoomProperties;
+    private _handleUserInOut;
+    private _handleUserInfo;
+    private _handleUserProperty;
+    private _handleUserProperties;
+    private _processStreamEvent;
+    private _handleStreamInOut;
+    private _handleStreamsInOut;
+    private _handleMessageExtension;
+}

package/lib/core/processor/channel-msg/struct.d.ts

@@ -0,0 +1,108 @@
+import Immutable from 'immutable';
+import { AgoraRteMediaSourceState } from '../../..';
+import { AgoraRteAudioSourceType, AgoraRteMediaPublishState, AgoraRteVideoSourceType } from '../../media/track';
+export declare type AgoraFromUser = {
+    userUuid: string;
+    userName: string;
+    role: string;
+};
+export declare class AgoraRteSyncSnapshotData {
+    static fromData(data: any): AgoraRteSyncSnapshotData;
+    sequence: number;
+    users: Map<string, AgoraUser>;
+    streams: Map<string, AgoraStream>;
+    roomProperties: Immutable.Map<unknown, unknown>;
+    room: AgoraRoom;
+    constructor(data: any);
+}
+export interface AgoraRteOperator {
+    userUuid: string;
+    userName: string;
+    role: string;
+}
+export interface AgoraRteMessageHandleTask {
+    sequence: {
+        cmd: number;
+        operator: AgoraRteOperator;
+        sequence: number;
+        data: any;
+    };
+}
+export interface AgoraRtePeerMessageHandleTask {
+    cmd: number;
+    data: any;
+}
+export interface IAgoraUserData {
+    userName: string;
+    role: string;
+    userUuid: string;
+    userProperties: any;
+}
+export declare class AgoraUser {
+    static fromData(data: any): AgoraUser;
+    userUuid: string;
+    userName: string;
+    userRole: string;
+    userProperties: Immutable.Map<any, any>;
+    constructor(data: IAgoraUserData);
+    setUserProperties(userProperties: any): void;
+    toString(): string;
+}
+export interface IAgoraStreamData {
+    streamUuid: string;
+    streamName: string;
+    fromUser: AgoraFromUser;
+    videoSourceType: AgoraRteVideoSourceType;
+    audioSourceType: AgoraRteAudioSourceType;
+    videoState: AgoraRteMediaPublishState;
+    audioState: AgoraRteMediaPublishState;
+    videoSourceState: AgoraRteMediaSourceState;
+    audioSourceState: AgoraRteMediaSourceState;
+}
+export declare class AgoraStream {
+    static fromData(data: IAgoraStreamData): AgoraStream;
+    streamUuid: string;
+    streamName: string;
+    fromUser: AgoraFromUser;
+    videoSourceType: AgoraRteVideoSourceType;
+    audioSourceType: AgoraRteAudioSourceType;
+    videoState: AgoraRteMediaPublishState;
+    audioState: AgoraRteMediaPublishState;
+    videoSourceState: AgoraRteMediaSourceState;
+    audioSourceState: AgoraRteMediaSourceState;
+    previous?: AgoraStream;
+    constructor(data: IAgoraStreamData);
+    toString(): string;
+}
+export interface IAgoraRoomData {
+    roomName: string;
+    roomUuid: string;
+    roomScenario: string;
+}
+export declare class AgoraRoom {
+    static fromData(data: any): AgoraRoom;
+    roomName: string;
+    roomUuid: string;
+    roomScenario: string;
+    constructor(data: IAgoraRoomData);
+}
+export interface IAgoraChatMessage {
+    fromUser: AgoraFromUser;
+    message: string;
+    type: number;
+    sendTime: number;
+    sensitiveWords: string[];
+    messageId?: string;
+    peerMessageId?: string;
+}
+export declare class AgoraChatMessage {
+    static fromData(data: IAgoraChatMessage): AgoraChatMessage;
+    fromUser: AgoraFromUser;
+    message: string;
+    type: number;
+    sendTime: number;
+    sensitiveWords: string[];
+    messageId?: string;
+    constructor(data: IAgoraChatMessage);
+    toString(): string;
+}

package/lib/core/processor/channel-msg/synchronizer.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Injectable } from '../../decorator/type';
+import { AGRtmManager } from '../../rtm';
+import { AgoraRteSyncDataStore } from './data';
+import { AgoraRteChannelMessageHandle } from './handler';
+import { AgoraRteMessageHandleTask, AgoraRteSyncSnapshotData } from './struct';
+export declare class AgoraRteSynchronizer {
+    protected logger: Injectable.Logger;
+    sceneId: string;
+    userUuid: string;
+    streamUuid: string;
+    private _channelObserver;
+    private _snapshot?;
+    private _queueTasks;
+    private _currentTask?;
+    private _lastSeq;
+    private _requestingGap;
+    private _handleChannelMessage;
+    private _handlePeerMessage;
+    handle: AgoraRteChannelMessageHandle;
+    constructor(dataStore: AgoraRteSyncDataStore, { sceneId, userUuid, streamUuid, channelObserver, rtm, }: {
+        sceneId: string;
+        userUuid: string;
+        streamUuid: string;
+        channelObserver: EventEmitter;
+        rtm: AGRtmManager;
+    });
+    handlePeerMessage({ message, peerId }: {
+        message: string;
+        peerId: string;
+    }): void;
+    handleChannelMessage({ message, memberId, }: {
+        message: {
+            text: string;
+        };
+        memberId: string;
+    }): void;
+    syncSnapshot(snapshot: AgoraRteSyncSnapshotData): void;
+    findSequenceGap(): {
+        seq: number;
+        count: number;
+        queueHeadSeq: number;
+    } | null;
+    sortTasks(): void;
+    addTask(task: AgoraRteMessageHandleTask): void;
+    prependTasks(tasks: AgoraRteMessageHandleTask[]): void;
+    notifyTaskQueueUpdate(): void;
+    runNextTask: () => void;
+    dequeueTask(): AgoraRteMessageHandleTask | null | undefined;
+    processTask(task: AgoraRteMessageHandleTask): Promise<void>;
+    syncSequenceUntilSuccess(lastSeq: number, count: number): Promise<void>;
+    reset(): void;
+}