netender-web-sdk 0.0.1 → 1.0.1

package/dist/meeting-kit-lite/src/config.d.ts

@@ -0,0 +1,29 @@
+export declare const errorCodeMap: {
+    '10461': string;
+    '10001': string;
+    '10119': string;
+    '10229': string;
+    '10212': string;
+    beOccupied: string;
+};
+export declare const LOCAL_STORAGE_KEY = "ne-meeting-recent-meeting-list";
+export declare const LOCALSTORAGE_USER_INFO = "userinfoV2";
+export declare const NOT_FIRST_LOGIN = "nemeeting-notFirstLogin";
+export declare const ACCOUNT_INFO_KEY = "__ne_meeting_account_info__";
+export declare const LOCALSTORAGE_MEETING_SETTING = "ne-meeting-setting";
+export declare const LOCALSTORAGE_LOGIN_BACK = "ne-meeting-loginBackUrl";
+export declare const LOCALSTORAGE_CUSTOM_LANGS = "ne-meeting-custom-langs";
+export declare const LOCALSTORAGE_MEETING_DEBUG = "ne-meeting-debug";
+export declare const LOCALSTORAGE_MEETING_SERVER_CONFIG = "ne-meeting-server-config";
+export declare const LOCALSTORAGE_LOCAL_RECORD_INFO = "ne-meeting-local-record-info";
+export declare const LANGUAGE_KEY = "ne-meeting-language";
+export declare const MAJOR_AUDIO = "$majorAudio";
+export declare const MAJOR_DEFAULT_VOLUME = 25;
+export declare const PLAYOUT_DEFAULT_VOLUME = 70;
+export declare const RECORD_DEFAULT_VOLUME = 100;
+export declare const IM_VERSION: string;
+export declare const RTC_VERSION: string;
+export declare const NE_MEETING_JOIN_RTC_PARAMS = "NE_MEETING_JOIN_RTC_PARAMS";
+export declare const NE_MEETING_REQUEST_TIMEOUT = 45000;
+export declare const APP_USER_ACCOUNT_INFO_KEY = "NetEase-Rooms-User-Account-Info";
+export declare const BREAKOUT_ROOM_IN_LOCAL_STORAGE_KEY = "ne_breakout_room";

package/dist/meeting-kit-lite/src/kit/impl/account_manager.d.ts

@@ -0,0 +1,45 @@
+import { NEMeetingLoginByPasswordOptions, NEMeetingLoginByTokenOptions } from '../../types/type';
+import AccountManager from '../interface/account_manager';
+import { AxiosInstance } from 'axios';
+import { NEAccountInfo } from '../../types/innerType';
+import { LogDebug } from '../../utils/logDebug';
+import NEMeetingKitLite from './meeting_kit';
+import { IntervalEvent } from '../../utils/report';
+export default class AccountManagerImpl implements AccountManager {
+    private _logger;
+    private _request;
+    private meetingKit;
+    private highAvailableRequest;
+    constructor(params: {
+        request: AxiosInstance;
+        debugLog: LogDebug;
+        highAvailableRequest: <T>(request: (traceId: string, domain?: string) => Promise<T>) => Promise<T>;
+        appKey: string;
+        meetingKit: NEMeetingKitLite;
+    });
+    loginBySmsCode(options: {
+        phoneNumber: string;
+        smsCode: string;
+    }): Promise<NEAccountInfo>;
+    loginByToken(options: {
+        accountId: string;
+        accountToken: string;
+        authType?: string;
+        isTemporary?: boolean;
+        loginReport?: IntervalEvent;
+    }): Promise<NEAccountInfo>;
+    loginByPassword(options: {
+        username: string;
+        password: string;
+        loginReport?: IntervalEvent;
+    }): Promise<NEAccountInfo>;
+    logout(): Promise<void>;
+    getAccountInfo(): Promise<NEAccountInfo>;
+    updateNickname(nickname: string): Promise<void>;
+    resetPassword(params: {
+        userUuid: string;
+        newPassword: string;
+        oldPassword: string;
+    }): Promise<void>;
+    login(options: NEMeetingLoginByPasswordOptions | NEMeetingLoginByTokenOptions): Promise<NEAccountInfo>;
+}

package/dist/meeting-kit-lite/src/kit/impl/annotation_manager.d.ts

@@ -0,0 +1,22 @@
+import { NEResult } from 'neroom-types';
+import AnnotationManager, { AnnotationManagerListener } from '../interface/annotation_manager';
+import NEMeetingKit from './meeting_kit';
+export default class AnnotationManagerImpl implements AnnotationManager {
+    private _logger;
+    private _meetingKit;
+    private _listeners;
+    private get _annotationController();
+    constructor(params: {
+        meetingKit: NEMeetingKit;
+    });
+    addListener(listener: AnnotationManagerListener): void;
+    removeListener(listener: AnnotationManagerListener): void;
+    getWhiteboardUrl(): Promise<NEResult<string>>;
+    login(): Promise<NEResult<void>>;
+    logout(): Promise<NEResult<void>>;
+    auth(): Promise<NEResult<void>>;
+    startAnnotation(): Promise<NEResult<void>>;
+    stopAnnotation(): Promise<NEResult<void>>;
+    setEnableDraw(enable: boolean): Promise<NEResult<void>>;
+    private _setupWhiteboardCanvas;
+}

package/dist/meeting-kit-lite/src/kit/impl/audio_manager.d.ts

@@ -0,0 +1,44 @@
+import { NEDeviceBaseInfo, NEResult } from 'neroom-types';
+import AudioManager, { ReverbConfig } from '../interface/audio_manager';
+import NEMeetingKitLite from './meeting_kit';
+export default class AudioManagerImpl implements AudioManager {
+    private _logger;
+    private _meetingKit;
+    private get _previewController();
+    private get _rtcController();
+    constructor(params: {
+        meetingKit: NEMeetingKitLite;
+    });
+    getSpeakerDeviceList(): Promise<NEResult<NEDeviceBaseInfo[]>>;
+    getSpeakerDeviceId(): Promise<NEResult<string>>;
+    getSpeakerMute(): Promise<NEResult<boolean>>;
+    setSpeakerMute(mute: boolean): Promise<NEResult<void>>;
+    setSpeakerDevicePreview(deviceId: string): Promise<NEResult<void>>;
+    setSpeakerDevice(deviceId: string): Promise<NEResult<void>>;
+    getSpeakerVolume(): Promise<NEResult<number>>;
+    setSpeakerVolume(volume: number): Promise<NEResult<void>>;
+    startSpeakerDeviceTest(audioResource: string): Promise<NEResult<void>>;
+    stopSpeakerDeviceTest(): Promise<NEResult<void>>;
+    getMicrophoneDeviceList(): Promise<NEResult<NEDeviceBaseInfo[]>>;
+    getMicrophoneDeviceId(): Promise<NEResult<string>>;
+    setMicrophoneDevice(deviceId: string): Promise<NEResult<void>>;
+    setMicrophoneDevicePreview(deviceId: string): Promise<NEResult<void>>;
+    getMicrophoneVolume(): number;
+    getMicrophoneVolumePreview(): number;
+    setMicrophoneVolume(volume: number): Promise<NEResult<void>>;
+    startMicrophoneDeviceTest(): Promise<NEResult<void>>;
+    stopMicrophoneDeviceTest(): Promise<NEResult<void>>;
+    enableAudioVolumeAutoAdjust(enable: boolean): Promise<NEResult<void>>;
+    setAdvancedAudioMode(mode: 'normal' | 'music'): Promise<NEResult<void>>;
+    setAudioNoise(level: 'normal' | 'enhanced'): Promise<NEResult<void>>;
+    setAudioMusic(enable: boolean): Promise<NEResult<void>>;
+    unmuteMyAudio(enableMediaPub: boolean): Promise<NEResult<void>>;
+    muteMyAudio(): Promise<NEResult<void>>;
+    setMixAudioStream(need: boolean): void;
+    enableAudioEffect(): Promise<void>;
+    setAudioEffect(type: number, value: number | Array<number> | ReverbConfig): void;
+    disableAudioEffect(): Promise<void>;
+    enableAIDenoise(): Promise<void>;
+    setVoiceGate(level: number): void;
+    disableAIDenoise(): Promise<void>;
+}

package/dist/meeting-kit-lite/src/kit/impl/breakout_manager.d.ts

@@ -0,0 +1,22 @@
+import { AxiosInstance } from 'axios';
+import { NEResult } from 'neroom-types';
+import BreakoutManager, { AddOrDeleteBreakoutRoomMembersConfig, BreakoutRoomsConfig, CreateBreakoutRoomsConfig } from '../interface/breakout_manager';
+import NEMeetingKit from './meeting_kit';
+export default class BreakoutManagerImpl implements BreakoutManager {
+    private _logger;
+    private _request;
+    private _meetingKit;
+    private get _meetingId();
+    constructor(params: {
+        meetingKit: NEMeetingKit;
+        request: AxiosInstance;
+    });
+    getBreakoutRooms(): Promise<NEResult<BreakoutRoomsConfig>>;
+    getBreakoutRoomsSimple(): Promise<NEResult<BreakoutRoomsConfig>>;
+    createBreakoutRooms(config: CreateBreakoutRoomsConfig): Promise<NEResult<BreakoutRoomsConfig>>;
+    addBreakoutRoom(name: string, roomUuid?: string): Promise<NEResult<BreakoutRoomsConfig>>;
+    deleteBreakoutRoom(roomUuid: string): Promise<NEResult<BreakoutRoomsConfig>>;
+    addOrDeleteBreakoutRoomMembers(config: AddOrDeleteBreakoutRoomMembersConfig): Promise<NEResult<BreakoutRoomsConfig>>;
+    startBreakoutRooms(): Promise<NEResult<BreakoutRoomsConfig>>;
+    stopBreakoutRooms(): Promise<NEResult<BreakoutRoomsConfig>>;
+}

package/dist/meeting-kit-lite/src/kit/impl/chatroom_manager.d.ts

@@ -0,0 +1,25 @@
+import { NEResult } from 'neroom-types';
+import ChatroomManager, { FileEx, NERoomChatMessage } from '../interface/chatroom_manager';
+import NEMeetingKitLite from './meeting_kit';
+export declare const uuid: () => string;
+export default class ChatroomManagerImpl implements ChatroomManager {
+    private _logger;
+    private _messageList;
+    private _meetingKit;
+    private get _chatController();
+    private get _roomService();
+    private get _localMember();
+    constructor(params: {
+        meetingKit: NEMeetingKitLite;
+    });
+    getMessageList(): Promise<NEResult<NERoomChatMessage[]>>;
+    fetchHistoryMessageList(meetingId?: number): Promise<NEResult<NERoomChatMessage[]>>;
+    sendTextMessage(idClient: string, content: string, isWaitingRoom?: boolean, toUserUuids?: string[]): Promise<NEResult<NERoomChatMessage>>;
+    sendFileMessage(idClient: string, type: 'image' | 'file', file: FileEx, isWaitingRoom?: boolean, toUserUuids?: string[]): Promise<NEResult<NERoomChatMessage>>;
+    recallMessage(msg: NERoomChatMessage): Promise<NEResult<void>>;
+    cancelSendFileMessage(msg: NERoomChatMessage): Promise<NEResult<void>>;
+    downloadAttachment(msg: NERoomChatMessage, path: string): Promise<NEResult<void>>;
+    cancelDownloadAttachment(msg: NERoomChatMessage): Promise<NEResult<void>>;
+    exportChatroomHistoryMessageList(meetingId: string): Promise<NEResult<string>>;
+    private _formatMessage;
+}

package/dist/meeting-kit-lite/src/kit/impl/interpretation_manager.d.ts

@@ -0,0 +1,26 @@
+import { NEResult } from 'neroom-types';
+import InterpretationManager, { NEInterpretationInfo } from '../interface/interpretation_manager';
+import NEMeetingKitLite from './meeting_kit';
+import { NEMeetingInterpreter } from '../../types';
+import { AxiosInstance } from 'axios';
+import { LogDebug } from '../../utils/logDebug';
+export default class InterpretationManagerImpl implements InterpretationManager {
+    private _logger;
+    private _meetingKit;
+    private _request;
+    constructor(params: {
+        meetingKit: NEMeetingKitLite;
+        request: AxiosInstance;
+        debugLog: LogDebug;
+    });
+    startInterpretation(data: {
+        interpreters?: NEMeetingInterpreter[];
+    }): Promise<NEResult<void>>;
+    stopInterpretation(): Promise<void>;
+    getInterpretation(): NEInterpretationInfo | undefined;
+    isInterpretationStarted(): boolean;
+    isMySelfInterpreter(): boolean;
+    adjustChannelPlaybackSignalVolume(volume: number): Promise<void | undefined>;
+    muteMajorAudio(mute: boolean, volume?: number): Promise<void | undefined>;
+    listenToOriginalAudio(enable: boolean, majorVolume?: number): Promise<void>;
+}

package/dist/meeting-kit-lite/src/kit/impl/invite_manager.d.ts

@@ -0,0 +1,28 @@
+import { NEResult, NERoomSipCallResponse, NERoomSystemDevice } from 'neroom-types';
+import InviteManager from '../interface/invite_manager';
+import NEMeetingKitLite, { NEMember, NEESearchAccountInfo, NEAccountInfoListResponse } from '..';
+import { LogDebug } from '../../utils/logDebug';
+import { AxiosInstance } from 'axios';
+export default class InviteManagerImpl implements InviteManager {
+    private _logger;
+    private _meetingKit;
+    private _request;
+    constructor(params: {
+        meetingKit: NEMeetingKitLite;
+        debugLog: LogDebug;
+        request: AxiosInstance;
+    });
+    getInInvitingMemberList(): NEMember[];
+    searchContactListByName(name: string): Promise<NEESearchAccountInfo[]>;
+    inviteByUserUuids(userUuids: string[]): Promise<NEResult<null>>;
+    searchAccountInfoByPhone(phone: string): Promise<NEESearchAccountInfo[]>;
+    callByPhoneNumber(phoneNumber: string, countryCode: string, name?: string): Promise<NEResult<NERoomSipCallResponse>>;
+    callByUserUuids(userUuids: string[]): Promise<NEResult<null>>;
+    callByUserUuid(userUuid: string): Promise<NEResult<null>>;
+    callOutRoomSystem(device: NERoomSystemDevice): Promise<NEResult<NERoomSipCallResponse>>;
+    removeCall(userUuid: string): Promise<NEResult<null>>;
+    cancelCall(userUuid: string): Promise<NEResult<null>>;
+    hangUpCall(userUuid: string): Promise<NEResult<null>>;
+    private searchAccount;
+    getAccountInfoList(userUuids: string[]): Promise<NEAccountInfoListResponse>;
+}

package/dist/meeting-kit-lite/src/kit/impl/meeting_kit.d.ts

@@ -0,0 +1,138 @@
+import { NEResult, Roomkit, NERoomRtcController, NERoomContext, NERoomChatController, NEWaitingRoomController, NERoomWhiteboardController, NERoomAnnotationController, NERoomLiveController, NEPreviewController, NERoomSIPController, NERoomAppInviteController, NERoomService, NENosService, NEAuthService, NEMessageChannelService, NEExtensionService, NERoomMember, NERoomSeatController } from 'neroom-types';
+import { NEMeetingInfo, NEMeetingAppNoticeTips } from '../../types/type';
+import NEMeetingKitInterface, { ExceptionHandler, NEMeetingKitConfig, NEMeetingKitInitConfig } from '../interface/meeting_kit';
+import AccountManager from '../interface/account_manager';
+import MeetingManager from '../interface/meeting_manager';
+import AudioManager from '../interface/audio_manager';
+import VideoManager from '../interface/video_manager';
+import SecurityManager from '../interface/security_manager';
+import InviteManager from '../interface/invite_manager';
+import MemberManager from '../interface/member_manager';
+import ChatroomManager from '../interface/chatroom_manager';
+import ScreenShareManager from '../interface/screen_share_manager';
+import WhiteboardManager from '../interface/whiteboard_manager';
+import AnnotationManager from '../interface/annotation_manager';
+import RecordManager from '../interface/record_manager';
+import PluginManager from '../interface/plugin_manager';
+import NotificationManager from '../interface/notification_manager';
+import TranscriptionManager from '../interface/transcription_manager';
+import InterpretationManager from '../interface/interpretation_manager';
+import BreakoutManager from '../interface/breakout_manager';
+import QualityMonitorManager from '../interface/quality_monitor_manager';
+import { AxiosInstance } from 'axios';
+import EventEmitter from 'eventemitter3';
+import { LogDebug } from '../../utils/logDebug';
+import { XKitReporter } from '@xkit-yx/utils';
+import { InnerAccountInfo, NEAccountInfo } from '../../types';
+import WaitingRoomManager from './waitingRoom_manager';
+import { PreMeetingManager } from '../interface/pre_meeting_manager';
+export default class NEMeetingKitLite extends EventEmitter implements NEMeetingKitInterface {
+    _meetingServerDomain: string;
+    roomkit: Roomkit;
+    appKey: string;
+    authService: NEAuthService | null;
+    messageService: NEMessageChannelService | null;
+    extensionService?: NEExtensionService;
+    previewController: NEPreviewController | null;
+    roomService: NERoomService | null;
+    nosService: NENosService | null;
+    _userUuid: string;
+    _token: string;
+    _authType: string;
+    accountInfo: (NEAccountInfo & InnerAccountInfo) | null;
+    privateMeetingNum: string;
+    xkitReport: XKitReporter;
+    highAvailableDomain: string;
+    noChat: boolean;
+    isLoginByAccount: boolean;
+    isAnonymous: boolean;
+    meetingType: number;
+    meetingInfo: Partial<NEMeetingInfo>;
+    meetingStartTime: number;
+    meetingStatus: string;
+    waitingRoomChangedName: string;
+    alreadyJoin: boolean;
+    request: AxiosInstance;
+    private _debugLog;
+    private _isReuseIM;
+    private _appKey;
+    private _isInitialized;
+    private _exceptionHandlers;
+    private _serverConfig;
+    private _useAssetServerConfig;
+    private _language;
+    private _framework;
+    private _accountManager;
+    private _meetingManager;
+    private _preMeetingManager;
+    private _audioManager;
+    private _videoManager;
+    private _securityManager;
+    private _inviteManager;
+    private _memberManager;
+    private _chatroomManager;
+    private _screenShareManager;
+    private _whiteboardManager;
+    private _annotationManager;
+    private _recordManager;
+    private _pluginManager;
+    private _notificationManager;
+    private _transcriptionManager;
+    private _interpretationManager;
+    private _waitingRoomManager;
+    private _breakoutManager;
+    private _qualityMonitorManager;
+    private _appLogsPath;
+    private _highAvailableDomain;
+    static KIT_MODULE_NAME: string;
+    static _logger: LogDebug;
+    static _instance: NEMeetingKitLite | null;
+    static getInstance(params?: NEMeetingKitConfig): NEMeetingKitLite;
+    static checkSystemRequirements(): boolean | undefined;
+    constructor(params: NEMeetingKitConfig);
+    get localMember(): NERoomMember | null;
+    get isInitialized(): boolean;
+    get rtcController(): NERoomRtcController | undefined;
+    get whiteboardController(): NERoomWhiteboardController | undefined;
+    get annotationController(): NERoomAnnotationController | undefined;
+    get liveController(): NERoomLiveController | undefined;
+    get waitingRoomController(): NEWaitingRoomController | undefined;
+    get sipController(): NERoomSIPController | undefined;
+    get seatController(): NERoomSeatController | undefined;
+    get appInviteController(): NERoomAppInviteController | undefined;
+    get chatController(): NERoomChatController | undefined;
+    get inviteController(): NERoomAppInviteController | undefined;
+    initialize(config: NEMeetingKitInitConfig): Promise<NEResult<void>>;
+    unInitialize(): Promise<NEResult<void>>;
+    getAccountManager(): AccountManager | undefined;
+    getMeetingManager(): MeetingManager | undefined;
+    getPreMeetingManager(): PreMeetingManager | undefined;
+    getAudioManager(): AudioManager | undefined;
+    getVideoManager(): VideoManager | undefined;
+    getSecurityManager(): SecurityManager | undefined;
+    getInviteManager(): InviteManager | undefined;
+    getMemberManager(): MemberManager | undefined;
+    getChatroomManager(): ChatroomManager | undefined;
+    getScreenShareManager(): ScreenShareManager | undefined;
+    getWhiteboardManager(): WhiteboardManager | undefined;
+    getAnnotationManager(): AnnotationManager | undefined;
+    getRecordManager(): RecordManager | undefined;
+    getPluginManager(): PluginManager | undefined;
+    getNotificationManager(): NotificationManager | undefined;
+    getTranscriptionManager(): TranscriptionManager | undefined;
+    getInterpretationManager(): InterpretationManager | undefined;
+    getBreakoutManager(): BreakoutManager | undefined;
+    getQualityMonitorManager(): QualityMonitorManager | undefined;
+    getWaitingRoomManager(): WaitingRoomManager | undefined;
+    get roomContext(): NERoomContext | null;
+    addGlobalEventListener: () => void;
+    removeGlobalEventListener: () => void;
+    getSDKLogPath(): Promise<NEResult<string>>;
+    getAppNoticeTips(): Promise<NEResult<NEMeetingAppNoticeTips>>;
+    setExceptionHandler(handler: ExceptionHandler): void;
+    startMarvel(): Promise<NEResult<void>>;
+    checkSystemRequirements(): boolean | undefined;
+    private _initHandler;
+    private createRequest;
+    highAvailableRequest<T>(request: (traceId: string, domain?: string) => Promise<T>): Promise<T>;
+}

package/dist/meeting-kit-lite/src/kit/impl/meeting_manager.d.ts

@@ -0,0 +1,61 @@
+import { NEMessageChannelListener, NEResult, NERoomContext, NERoomListener, NERoomRtcController, NEStatsListener, Roomkit } from 'neroom-types';
+import { NEMeetingCreateOptions, NEMeetingJoinOptions, NEMeetingInfo, NEMeetingConfig, NEMeetingGetListBySizeParams } from '../../types/type';
+import MeetingManager from '../interface/meeting_manager';
+import { LogDebug } from '../../utils/logDebug';
+import NEMeetingKitLite from './meeting_kit';
+import { NEMeetingSDKInfo, VideoFrameRate, VideoResolution } from '../../types/innerType';
+import { AxiosInstance } from 'axios';
+export default class MeetingManagerImpl implements MeetingManager {
+    roomContext: NERoomContext | null;
+    rtcController: NERoomRtcController | undefined;
+    globalConfig: NEMeetingConfig | null;
+    meetingListeners: NERoomListener[];
+    rtcStatsListeners: NEStatsListener[];
+    messageChannelListeners: NEMessageChannelListener[];
+    private _logger;
+    private _roomkit;
+    private _meetingKit;
+    private _request;
+    private _joinTimeoutTimer;
+    private _joinRoomkitOptions;
+    constructor(params: {
+        roomkit: Roomkit;
+        meetingKit: NEMeetingKitLite;
+        request: AxiosInstance;
+        debugLog: LogDebug;
+    });
+    get isHostOrCohost(): boolean;
+    getGlobalConfig(): Promise<NEMeetingConfig>;
+    createMeeting(options: NEMeetingCreateOptions): Promise<void>;
+    joinMeeting(options: NEMeetingJoinOptions): Promise<void>;
+    anonymousJoinMeeting(options: NEMeetingJoinOptions): Promise<NEResult<void>>;
+    rejoinAfterAdmittedToRoom(): Promise<void>;
+    joinMeetingByAInvite(options: NEMeetingJoinOptions): Promise<void>;
+    leaveMeeting(): Promise<void>;
+    endMeeting(): Promise<void>;
+    getAppInfo(): Promise<{
+        appName: string;
+    }>;
+    getMeetingListBySize(options: NEMeetingGetListBySizeParams): Promise<NEMeetingInfo[]>;
+    getMeetingInfo(): NEMeetingSDKInfo | null;
+    getCloudRecordConfig(): {
+        rtcRecordType: number;
+        modeList: Array<{
+            mode: number;
+        }>;
+    };
+    setVideoProfile(resolution: VideoResolution, frameRate?: VideoFrameRate): void | undefined;
+    addMeetingListener(listener: NERoomListener): void;
+    addMessageChannelListener(listener: NEMessageChannelListener): void;
+    removeMessageChannelListener(listener: NEMessageChannelListener): void;
+    removeMeetingListener(listener?: NERoomListener): void;
+    addRtcStatsListener(listener: NEStatsListener): void;
+    removeRtcStatsListener(listener: NEStatsListener): void;
+    getIsAllowParticipantsEnableCaption(): boolean;
+    releaseMeeting(): void;
+    private _joinHandler;
+    private _joinRoomkit;
+    private _joinController;
+    private anonymousLogin;
+    private _reset;
+}

package/dist/meeting-kit-lite/src/kit/impl/member_manager.d.ts

@@ -0,0 +1,41 @@
+import { NEResult } from 'neroom-types';
+import MemberManager from '../interface/member_manager';
+import NEMeetingKitLite from './meeting_kit';
+import { NEMember, Role } from '../../types';
+import { LogDebug } from '../../utils/logDebug';
+import { AxiosInstance } from 'axios';
+export default class MemberManagerImpl implements MemberManager {
+    private _logger;
+    private _meetingKit;
+    private _request;
+    constructor(params: {
+        meetingKit: NEMeetingKitLite;
+        debugLog: LogDebug;
+        request: AxiosInstance;
+    });
+    getMemberList(): NEMember[];
+    changeMemberName(options: {
+        userUuid?: string;
+        nickName: string;
+    }): Promise<NEResult<null>>;
+    muteMemberAudio(userUuid: string): Promise<NEResult<void>>;
+    muteMemberVideo(userUuid: string): Promise<NEResult<void>>;
+    unmuteMemberAudio(userUuid: string): Promise<NEResult<void>>;
+    unmuteMemberVideo(userUuid: string): Promise<NEResult<void>>;
+    muteVideoAndAudio(userUuid: string): Promise<NEResult<void>>;
+    unmuteVideoAndAudio(userUuid: string): Promise<NEResult<void>>;
+    setFocus(userUuid: string): Promise<NEResult<void>>;
+    unsetFocus(): Promise<NEResult<void>>;
+    handOverMyRole(userUuid: string, resign?: boolean): Promise<NEResult<void>>;
+    changeMemberRole(userUuid: string, role: Role): Promise<NEResult<void>>;
+    kickMemberOut(userUuid: string, toBlacklist?: boolean): Promise<NEResult<void>>;
+    muteAllAudio(): Promise<NEResult<void>>;
+    unmuteAllAudio(): Promise<NEResult<void>>;
+    unmuteAllVideo(): Promise<NEResult<void>>;
+    muteAllVideo(): Promise<NEResult<void>>;
+    stopMemberScreenShare(userUuid: string): Promise<NEResult<void>>;
+    closeWhiteShare(userUuid: string): Promise<NEResult<void>>;
+    handsDownAll(): Promise<void>;
+    handsDown(userUuid?: string): Promise<NEResult<null>>;
+    handsUp(): Promise<NEResult<null>>;
+}

package/dist/meeting-kit-lite/src/kit/impl/notification_manager.d.ts

@@ -0,0 +1,22 @@
+import { NEResult } from 'neroom-types';
+import NotificationManager, { NotificationMessage } from '../interface/notification_manager';
+import NEMeetingKit from './meeting_kit';
+export default class NotificationManagerImpl implements NotificationManager {
+    private _logger;
+    private _meetingKit;
+    private _notificationMessageList;
+    private _listeners;
+    constructor(params: {
+        meetingKit: NEMeetingKit;
+    });
+    getNotificationMessageList(): Promise<NEResult<NotificationMessage[]>>;
+    removeNotificationMessage(messageId: string): Promise<NEResult<void>>;
+    markAsRead(messageId: string): Promise<NEResult<void>>;
+    markAllAsRead(): Promise<NEResult<void>>;
+    addListener(listener: {
+        onNotificationMessageReceived?: (message: NotificationMessage) => void;
+    }): void;
+    removeListener(listener: {
+        onNotificationMessageReceived?: (message: NotificationMessage) => void;
+    }): void;
+}

package/dist/meeting-kit-lite/src/kit/impl/plugin_manager.d.ts

@@ -0,0 +1,19 @@
+import { AxiosInstance } from 'axios';
+import { NEResult } from 'neroom-types';
+import PluginManager, { PluginInfo } from '../interface/plugin_manager';
+import NEMeetingKitLite from './meeting_kit';
+export default class PluginManagerImpl implements PluginManager {
+    private _logger;
+    private _request;
+    private _meetingKit;
+    private get _meetingId();
+    constructor(params: {
+        request: AxiosInstance;
+        meetingKit: NEMeetingKitLite;
+    });
+    getPluginList(): Promise<NEResult<PluginInfo[]>>;
+    getPluginAuthCode(pluginId: string): Promise<NEResult<{
+        authCode: string;
+    }>>;
+    getAIAssistantToken(): Promise<NEResult<string>>;
+}

package/dist/meeting-kit-lite/src/kit/impl/pre_meeting_manager.d.ts

@@ -0,0 +1,35 @@
+import { NEMeetingInfo, MeetingListItem, NEHistoryMeetingDetail, NEMeetingAppNoticeTip, NEMeetingCreateOptions, NEMeetingGetListBySizeParams, NEMeetingGetListOptions, NEScheduledMember } from '..';
+import { PreMeetingManager } from '../interface/pre_meeting_manager';
+import NEMeetingKitLite from './meeting_kit';
+import { AxiosInstance } from 'axios';
+import { LogDebug } from '../../utils/logDebug';
+export declare class PreMeetingManagerImpl implements PreMeetingManager {
+    private _meetingKit;
+    private _request;
+    private _logger;
+    constructor(params: {
+        meetingKit: NEMeetingKitLite;
+        request: AxiosInstance;
+        debugLog: LogDebug;
+    });
+    getMeetingList(options: NEMeetingGetListOptions): Promise<NEMeetingInfo[]>;
+    getMeetingListBySize(options: NEMeetingGetListBySizeParams): Promise<NEMeetingInfo[]>;
+    getAppTips(): Promise<{
+        tips: NEMeetingAppNoticeTip[];
+        curTime: number;
+        appKey: string;
+    }>;
+    scheduleMeeting(options: NEMeetingCreateOptions): Promise<NEMeetingInfo>;
+    editMeeting(meetingId: number | string, options: NEMeetingCreateOptions): Promise<void>;
+    cancelMeeting(meetingId: number, cancelRecurringMeeting?: boolean): Promise<void>;
+    getScheduledMembers(meetingNum: string): Promise<NEScheduledMember[]>;
+    getMeetingInfoByMeetingId(meetingId: string | number): Promise<NEMeetingInfo>;
+    getMeetingInfoByMeetingNum(meetingNum: string): Promise<NEMeetingInfo>;
+    getHistoryMeetingList(params?: {
+        startId?: number;
+        limit?: number;
+    }): Promise<{
+        meetingList: MeetingListItem[];
+    }>;
+    getHistoryMeetingDetail(roomArchiveId: number): Promise<NEHistoryMeetingDetail>;
+}

package/dist/meeting-kit-lite/src/kit/impl/quality_monitor_manager.d.ts

@@ -0,0 +1,23 @@
+import { NEResult } from 'neroom-types';
+import QualityMonitorManager, { QualityStats } from '../interface/quality_monitor_manager';
+export default class QualityMonitorManagerImpl implements QualityMonitorManager {
+    private _logger;
+    private _listeners;
+    constructor();
+    addListener(listener: {
+        onQualityStatsChanged?: (stats: QualityStats) => void;
+        onNetworkQualityChanged?: (quality: 'excellent' | 'good' | 'poor' | 'bad') => void;
+        onAudioQualityChanged?: (quality: 'excellent' | 'good' | 'poor' | 'bad') => void;
+        onVideoQualityChanged?: (quality: 'excellent' | 'good' | 'poor' | 'bad') => void;
+    }): void;
+    removeListener(listener: {
+        onQualityStatsChanged?: (stats: QualityStats) => void;
+        onNetworkQualityChanged?: (quality: 'excellent' | 'good' | 'poor' | 'bad') => void;
+        onAudioQualityChanged?: (quality: 'excellent' | 'good' | 'poor' | 'bad') => void;
+        onVideoQualityChanged?: (quality: 'excellent' | 'good' | 'poor' | 'bad') => void;
+    }): void;
+    startQualityMonitor(interval?: number): Promise<NEResult<void>>;
+    stopQualityMonitor(): Promise<NEResult<void>>;
+    getCurrentQualityStats(): Promise<NEResult<QualityStats>>;
+    getHistoricalQualityStats(duration: number): Promise<NEResult<QualityStats[]>>;
+}

package/dist/meeting-kit-lite/src/kit/impl/record_manager.d.ts

@@ -0,0 +1,18 @@
+import { NEResult, NERoomRecordConfig, NERoomStartLocalRecordOptions, NERoomStreamLayer, NERoomUpdateLocalRecordLayoutsOptions, NERoomVideoFrame } from 'neroom-types';
+import RecordManager from '../interface/record_manager';
+import NEMeetingKitLite from './meeting_kit';
+import { LogDebug } from '../../utils/logDebug';
+export default class RecordManagerImpl implements RecordManager {
+    private _logger;
+    private _meetingKit;
+    constructor(params: {
+        meetingKit: NEMeetingKitLite;
+        debugLog: LogDebug;
+    });
+    startCloudRecord(config?: NERoomRecordConfig): Promise<NEResult<void>>;
+    stopCloudRecord(): Promise<NEResult<void>>;
+    startLocalRecord(options: NERoomStartLocalRecordOptions): number | undefined;
+    stopLocalRecord(): number | undefined;
+    updateLocalRecordLayouts(options: NERoomUpdateLocalRecordLayoutsOptions[]): number | undefined;
+    pushLocalRecorderVideoFrame(uid: string, streamLayer: NERoomStreamLayer, frame: NERoomVideoFrame): number | undefined;
+}

package/dist/meeting-kit-lite/src/kit/impl/screen_share_manager.d.ts

@@ -0,0 +1,18 @@
+import { NEResult, NERoomRtcScreenCaptureSource, NERoomStopScreenConfig } from 'neroom-types';
+import ScreenShareManager, { NERoomStartScreenConfigEnhanced } from '../interface/screen_share_manager';
+import NEMeetingKitLite from './meeting_kit';
+export default class ScreenShareManagerImpl implements ScreenShareManager {
+    private _logger;
+    private _meetingKit;
+    private get _rtcController();
+    private get _previewController();
+    constructor(params: {
+        meetingKit: NEMeetingKitLite;
+    });
+    getScreenShareMessage(): Promise<NEResult<string>>;
+    getScreenCaptureSourceList(): Promise<NEResult<NERoomRtcScreenCaptureSource[]>>;
+    startScreenShare(config?: NERoomStartScreenConfigEnhanced): Promise<NEResult<void>>;
+    stopScreenShare(config?: NERoomStopScreenConfig): Promise<NEResult<void>>;
+    startShareSystemAudio(enable: boolean): Promise<NEResult<void>>;
+    installAudioCaptureDriver(): Promise<NEResult<void>>;
+}