import * as lodash from 'lodash';
import * as white_web_sdk from 'white-web-sdk';
import { SceneDefinition, SceneState, DisplayerState, View, ApplianceNames, ViewVisionMode, CameraState, RoomMember, Camera, Size, Event as Event$1, Scope, EventPhase, MagixEventListenerOptions as MagixEventListenerOptions$1, toJS, listenUpdated, unlistenUpdated, listenDisposed, unlistenDisposed, Room, ViewMode, Displayer, MemberState, Logger, AnimationMode, InvisiblePlugin, InvisiblePluginContext, Player, Rectangle, Point, CameraBound, ImageInformation } from 'white-web-sdk';
export { AnimationMode, Displayer, Player, Room, SceneDefinition, SceneState, View } from 'white-web-sdk';
import { TELE_BOX_STATE, TeleBoxRect, TeleBoxState, TeleBoxColorScheme, NotMinimizedBoxState, TeleBoxManager, TeleBoxCollector, ReadonlyTeleBox, TeleBoxManagerUpdateConfig, TeleBoxConfig } from '@netless/telebox-insider';
export { ReadonlyTeleBox, TeleBoxCollector, TeleBoxManager, TeleBoxRect } from '@netless/telebox-insider';
import Emittery from 'emittery';

declare enum Events {
    AppMove = "AppMove",
    AppFocus = "AppFocus",
    AppResize = "AppResize",
    AppBoxStateChange = "AppBoxStateChange",
    GetAttributes = "GetAttributes",
    UpdateWindowManagerWrapper = "UpdateWindowManagerWrapper",
    InitReplay = "InitReplay",
    WindowCreated = "WindowCreated",
    SetMainViewScenePath = "SetMainViewScenePath",
    SetMainViewSceneIndex = "SetMainViewSceneIndex",
    SetAppFocusIndex = "SetAppFocusIndex",
    SwitchViewsToFreedom = "SwitchViewsToFreedom",
    MoveCamera = "MoveCamera",
    MoveCameraToContain = "MoveCameraToContain",
    CursorMove = "CursorMove",
    RootDirRemoved = "RootDirRemoved",
    Refresh = "Refresh",
    InitMainViewCamera = "InitMainViewCamera"
}
declare enum AppAttributes {
    Size = "size",
    Position = "position",
    SceneIndex = "SceneIndex",
    ZIndex = "zIndex"
}
declare enum AppStatus {
    StartCreate = "StartCreate"
}

type StorageEventListener<T> = (event: T) => void;
declare class StorageEvent<TMessage> {
    listeners: Set<StorageEventListener<TMessage>>;
    get length(): number;
    dispatch(message: TMessage): void;
    addListener(listener: StorageEventListener<TMessage>): void;
    removeListener(listener: StorageEventListener<TMessage>): void;
}

type DiffOne<T> = {
    oldValue?: T;
    newValue?: T;
};
type Diff<T> = {
    [K in keyof T]?: DiffOne<T[K]>;
};
type StorageStateChangedEvent<TState = any> = Diff<TState>;
type StorageStateChangedListener<TState = any> = StorageEventListener<StorageStateChangedEvent<TState>>;
type StorageStateChangedListenerDisposer = () => void;

declare class Storage<TState extends Record<string, any> = any> implements Storage<TState> {
    readonly id: string | null;
    readonly maxIllusionQueueSize = 500;
    private readonly _context;
    private readonly _sideEffect;
    private _state;
    private _destroyed;
    private _refMap;
    /**
     * `setState` alters local state immediately before sending to server. This will cache the old value for onStateChanged diffing.
     */
    private _lastValue;
    constructor(context: AppContext, id?: string, defaultState?: TState);
    get state(): Readonly<TState>;
    readonly onStateChanged: StorageEvent<Diff<TState>>;
    addStateChangedListener(handler: StorageStateChangedListener<TState>): StorageStateChangedListenerDisposer;
    ensureState(state: Partial<TState>): void;
    setState(state: Partial<TState>): void;
    /**
     * Empty storage data.
     */
    emptyStorage(): void;
    /**
     * Delete storage index with all of its data and destroy the Storage instance.
     */
    deleteStorage(): void;
    get destroyed(): boolean;
    /**
     * Destroy the Storage instance. The data will be kept.
     */
    destroy(): void;
    private _getRawState;
    private _setRawState;
    private _updateProperties;
}

type BoxMovePayload = {
    appId: string;
    x: number;
    y: number;
};
type BoxFocusPayload = {
    appId: string;
};
type BoxBlurredPayload = {
    appId: string;
};
type BoxResizePayload = {
    appId: string;
    width: number;
    height: number;
    x?: number;
    y?: number;
};
type BoxClosePayload = {
    appId: string;
    error?: Error;
};
type BoxStateChangePayload = {
    appId: string;
    state: TELE_BOX_STATE;
};
type BoxEvent = {
    move: BoxMovePayload;
    focus: BoxFocusPayload;
    resize: BoxResizePayload;
    close: BoxClosePayload;
    boxStateChange: BoxStateChangePayload;
    blurred: BoxBlurredPayload;
};
type BoxEmitterType = Emittery<BoxEvent>;

type AddPageParams = {
    after?: boolean;
    scene?: SceneDefinition;
};
type PageState = {
    index: number;
    length: number;
};
interface PageController {
    nextPage: () => Promise<boolean>;
    prevPage: () => Promise<boolean>;
    jumpPage: (index: number) => Promise<boolean>;
    addPage: (params?: AddPageParams) => Promise<void>;
    removePage: (index: number) => Promise<boolean>;
    pageState: PageState;
}
interface PageRemoveService {
    removeSceneByIndex: (index: number) => Promise<boolean>;
    setSceneIndexWithoutSync: (index: number) => void;
}

declare const calculateNextIndex: (index: number, pageState: PageState) => number;

declare class AppCreateError extends Error {
    message: string;
}
declare class AppNotRegisterError extends Error {
    constructor(kind: string);
}
declare class AppManagerNotInitError extends Error {
    message: string;
}
declare class WhiteWebSDKInvalidError extends Error {
    constructor(version: string);
}
declare class ParamsInvalidError extends Error {
    message: string;
}
declare class BoxNotCreatedError extends Error {
    message: string;
}
declare class InvalidScenePath extends Error {
    message: string;
}
declare class BoxManagerNotFoundError extends Error {
    message: string;
}
declare class BindContainerRoomPhaseInvalidError extends Error {
    message: string;
}

interface NetlessApp<Attributes extends {} = any, MagixEventPayloads = any, AppOptions = any, SetupResult = any> {
    kind: string;
    config?: {
        /** Box width relative to whiteboard. 0~1. Default 0.5. */
        width?: number;
        /** Box height relative to whiteboard. 0~1. Default 0.5. */
        height?: number;
        /** Minimum box width relative to whiteboard. 0~1. Default 340 / 720. */
        minwidth?: number;
        /** Minimum box height relative to whiteboard. 0~1. Default 340 / 720. */
        minheight?: number;
        /** App only single instance. */
        singleton?: boolean;
    };
    setup: (context: AppContext<Attributes, MagixEventPayloads, AppOptions>) => SetupResult;
}
type AppEmitterEvent<T = any> = {
    /**
     *  before plugin destroyed
     */
    destroy: {
        error?: Error;
    };
    attributesUpdate: T | undefined;
    /**
     * room isWritable change or box blur
     */
    writableChange: boolean;
    sceneStateChange: SceneState;
    setBoxSize: {
        width: number;
        height: number;
    };
    setBoxMinSize: {
        minwidth: number;
        minheight: number;
    };
    setBoxTitle: {
        title: string;
    };
    containerRectUpdate: TeleBoxRect;
    roomStateChange: Partial<DisplayerState>;
    focus: boolean;
    reconnected: void;
    seek: number;
    pageStateChange: PageState;
    boxStatusChange: {
        appId: string;
        status: TeleBoxState;
    };
};
type RegisterEventData = {
    appId: string;
};
type RegisterEvents<SetupResult = any> = {
    created: RegisterEventData & {
        result: SetupResult;
    };
    destroy: RegisterEventData;
    focus: RegisterEventData;
};
type RegisterParams<AppOptions = any, SetupResult = any, Attributes extends {} = any> = {
    kind: string;
    src: NetlessApp<Attributes, SetupResult> | string | (() => Promise<NetlessApp<Attributes, SetupResult>>) | (() => Promise<{
        default: NetlessApp<Attributes, SetupResult>;
    }>);
    appOptions?: AppOptions | (() => AppOptions);
    addHooks?: (emitter: Emittery<RegisterEvents<SetupResult>>) => void;
    /** dynamic load app package name */
    name?: string;
};
type AppListenerKeys = keyof AppEmitterEvent;
type ApplianceIcons = Partial<Record<`${ApplianceNames}` | string, string>>;

type AppPayload = {
    appId: string;
    view: View;
};

type LoadAppEvent = {
    kind: string;
    status: "start" | "success" | "failed";
    reason?: string;
};

type PublicEvent = {
    mainViewModeChange: ViewVisionMode;
    boxStateChange: `${TELE_BOX_STATE}`;
    darkModeChange: boolean;
    prefersColorSchemeChange: TeleBoxColorScheme;
    cameraStateChange: CameraState;
    mainViewScenePathChange: string;
    mainViewSceneIndexChange: number;
    focusedChange: string | undefined;
    mainViewScenesLengthChange: number;
    canRedoStepsChange: number;
    canUndoStepsChange: number;
    loadApp: LoadAppEvent;
    ready: undefined;
    sceneStateChange: SceneState;
    pageStateChange: PageState;
    fullscreenChange: boolean;
    appsChange: string[];
    onBoxMove: BoxMovePayload;
    onBoxResize: BoxResizePayload;
    onBoxFocus: BoxFocusPayload;
    onBoxBlurred: BoxBlurredPayload;
    onBoxClose: BoxClosePayload;
    onBoxStateChange: BoxStateChangePayload;
    onMainViewMounted: View;
    onMainViewRebind: View;
    onAppViewMounted: AppPayload;
    onAppSetup: string;
    onAppScenePathChange: AppPayload;
    onBoxesStatusChange: Map<string, TeleBoxState>;
    onLastNotMinimizedBoxesStatusChange: Map<string, NotMinimizedBoxState>;
};
type CallbacksType = Emittery<PublicEvent>;

type RemoveSceneParams = {
    scenePath: string;
    index?: number;
};
type EmitterEvent = {
    onCreated: undefined;
    InitReplay: AppInitState;
    error: Error;
    seekStart: undefined;
    seek: number;
    mainViewMounted: undefined;
    observerIdChange: number;
    boxStateChange: string;
    playgroundSizeChange: DOMRect;
    startReconnect: undefined;
    onReconnected: undefined;
    removeScenes: RemoveSceneParams;
    cursorMove: CursorMovePayload;
    updateManagerRect: undefined;
    focusedChange: {
        focused: string | undefined;
        prev: string | undefined;
    };
    rootDirRemoved: undefined;
    rootDirSceneRemoved: string;
    setReadonly: boolean;
    changePageState: undefined;
    writableChange: boolean;
    containerSizeRatioUpdate: number;
    wrapperRectChange: {
        width: number;
        height: number;
        origin?: string;
    };
    boxesStatusChange: Map<string, TeleBoxState>;
    lastNotMinimizedBoxesStatusChange: Map<string, NotMinimizedBoxState>;
};
type EmitterType = Emittery<EmitterEvent>;

declare class CursorManager {
    private manager;
    private enableCursor;
    static readonly kind = "CursorManager";
    containerRect?: DOMRect;
    wrapperRect?: DOMRect;
    cursorInstances: Map<string, Cursor>;
    roomMembers?: readonly RoomMember[];
    userApplianceIcons: ApplianceIcons;
    private mainViewElement?;
    private sideEffectManager;
    private store;
    private leaveFlag;
    private _style;
    constructor(manager: AppManager, enableCursor: boolean, cursorOptions?: CursorOptions, applianceIcons?: ApplianceIcons);
    get applianceIcons(): ApplianceIcons;
    get style(): "default" | "custom";
    set style(value: "default" | "custom");
    private onCursorMove;
    private initCursorInstance;
    private enableCustomCursor;
    private canMoveCursor;
    setupWrapper(wrapper: HTMLElement): void;
    setMainViewDivElement(div: HTMLDivElement): void;
    get boxState(): any;
    get focusView(): View | undefined;
    private mouseMoveListener_;
    private mouseMoveTimer;
    private mouseMoveListener;
    private mouseLeaveListener;
    private showPencilEraserIfNeeded;
    private updateCursor;
    private getPoint;
    /**
     *  因为窗口内框在不同分辨率下的大小不一样，所以这里通过来鼠标事件的 target 来判断是在主白板还是在 APP 中
     */
    private getType;
    updateContainerRect(): void;
    deleteCursor(uid: string): void;
    hideCursor(uid: string): void;
    destroy(): void;
}

declare class Cursor {
    private manager;
    private memberId;
    private cursorManager;
    private wrapper?;
    private member?;
    private timer?;
    private component?;
    private style;
    constructor(manager: AppManager, memberId: string, cursorManager: CursorManager, wrapper?: HTMLElement | undefined);
    move: (position: Position) => void;
    setStyle: (style: typeof this.style) => void;
    leave: () => void;
    private moveCursor;
    get memberApplianceName(): ApplianceNames | undefined;
    get memberColor(): string;
    get memberColorHex(): string;
    private get payload();
    get memberCursorName(): any;
    private get memberTheme();
    private get memberCursorTextColor();
    private get memberCursorTagBackgroundColor();
    private get memberAvatar();
    private get memberOpacity();
    private get memberTagName();
    private autoHidden;
    private createCursor;
    private initProps;
    private getIcon;
    private isCustomIcon;
    updateMember(): RoomMember | undefined;
    private updateComponent;
    destroy(): void;
    hide(): void;
}

type Apps = {
    [key: string]: AppSyncAttributes;
};
type Position = {
    x: number;
    y: number;
    type: PositionType;
    id?: string;
};
type PositionType = "main" | "app";
type StoreContext = {
    getAttributes: () => any;
    safeUpdateAttributes: (keys: string[], value: any) => void;
    safeSetAttributes: (attributes: any) => void;
};
type ICamera = Camera & {
    id: string;
};
type ISize = Size & {
    id: string;
};
declare class AttributesDelegate {
    private context;
    static readonly kind = "AttributesDelegate";
    constructor(context: StoreContext);
    setContext(context: StoreContext): void;
    get attributes(): any;
    apps(): Apps;
    get focus(): string | undefined;
    getAppAttributes(id: string): AppSyncAttributes;
    getAppState(id: string): any;
    getMaximized(): any;
    getMinimized(): any;
    getBoxesStatus(): Record<string, TeleBoxState> | undefined;
    getBoxStatus(id: string): TeleBoxState | undefined;
    setBoxStatus(id: string, status?: TeleBoxState): void;
    getLastNotMinimizedBoxesStatus(): Record<string, NotMinimizedBoxState> | undefined;
    getLastNotMinimizedBoxStatus(id: string): NotMinimizedBoxState | undefined;
    setLastNotMinimizedBoxStatus(id: string, status?: NotMinimizedBoxState): void;
    setupAppAttributes(params: AddAppParams, id: string, isDynamicPPT: boolean): void;
    updateAppState(appId: string, stateName: AppAttributes, state: any): void;
    cleanAppAttributes(id: string): void;
    cleanFocus(): void;
    getAppSceneIndex(id: string): any;
    getAppScenePath(id: string): any;
    getMainViewScenePath(): string | undefined;
    getMainViewSceneIndex(): any;
    getBoxState(): any;
    setMainViewScenePath(scenePath: string): void;
    setMainViewSceneIndex(index: number): void;
    getMainViewCamera(): MainViewCamera;
    getMainViewSize(): MainViewSize;
    setMainViewCamera(camera: ICamera): void;
    setMainViewSize(size: ISize): void;
    setMainViewCameraAndSize(camera: ICamera, size: ISize): void;
    setAppFocus: (appId: string, focus: boolean) => void;
    updateCursor(uid: string, position: Position): void;
    updateCursorState(uid: string, cursorState: string | undefined): void;
    getCursorState(uid: string): any;
    cleanCursor(uid: string): void;
    setMainViewFocusPath(mainView: View): void;
    getIframeBridge(): any;
    setIframeBridge(data: any): void;
}
type MainViewSize = {
    id: string;
    width: number;
    height: number;
};
type MainViewCamera = {
    id: string;
    centerX: number;
    centerY: number;
    scale: number;
};

type ExtendClass$1 = {
    AppManager?: typeof AppManager;
    BoxManager?: typeof BoxManager;
    AttributesDelegate?: typeof AttributesDelegate;
    CursorManager?: typeof CursorManager;
    AppProxy?: typeof AppProxy;
    AppContext?: typeof AppContext;
    TeleBoxManager?: typeof TeleBoxManager;
    TeleBoxCollector?: typeof TeleBoxCollector;
};

type CreateBoxParams = {
    appId: string;
    app: NetlessApp;
    view?: View;
    emitter?: Emittery;
    options?: AddAppOptions;
    canOperate?: boolean;
    smartPosition?: boolean;
    boxStatus?: TeleBoxState;
    forceTop?: boolean;
    forceNormal?: boolean;
    isDragContent?: boolean;
};
type AppId = {
    appId: string;
};
type MoveBoxParams = AppId & {
    x: number;
    y: number;
};
type ResizeBoxParams = AppId & {
    width: number;
    height: number;
    skipUpdate: boolean;
};
type SetBoxMinSizeParams = AppId & {
    minWidth: number;
    minHeight: number;
};
type SetBoxTitleParams = AppId & {
    title: string;
};
type CreateTeleBoxManagerConfig = {
    collectorContainer?: HTMLElement;
    collectorStyles?: Partial<CSSStyleDeclaration>;
    prefersColorScheme?: TeleBoxColorScheme;
    useBoxesStatus?: boolean;
};
type BoxManagerContext = {
    safeSetAttributes: (attributes: any) => void;
    getMainView: () => View;
    updateAppState: (appId: string, field: AppAttributes, value: any) => void;
    setBoxStatus: (appId: string, status?: TeleBoxState) => void;
    setLastNotMinimizedBoxStatus: (appId: string, status?: NotMinimizedBoxState) => void;
    emitter: EmitterType;
    boxEmitter: BoxEmitterType;
    callbacks: CallbacksType;
    canOperate: () => boolean;
    notifyContainerRectUpdate: (rect: TeleBoxRect) => void;
    cleanFocus: () => void;
    setAppFocus: (appId: string) => void;
};
declare class BoxManager {
    private context;
    private createTeleBoxManagerConfig?;
    static readonly kind = "BoxManager";
    teleBoxManager: TeleBoxManager;
    constructor(context: BoxManagerContext, createTeleBoxManagerConfig?: CreateTeleBoxManagerConfig | undefined);
    private get mainView();
    private get canOperate();
    get boxState(): "normal" | "minimized" | "maximized";
    get maximized(): boolean;
    get minimized(): boolean;
    get darkMode(): boolean;
    get prefersColorScheme(): TeleBoxColorScheme;
    get boxSize(): number;
    createBox(params: CreateBoxParams): void;
    setBoxInitState(appId: string): void;
    setBoxesStatus(status?: Record<string, TeleBoxState>): void;
    setLastNotMinimizedBoxesStatus(status?: Record<string, NotMinimizedBoxState>): void;
    setupBoxManager(createTeleBoxManagerConfig?: CreateTeleBoxManagerConfig): TeleBoxManager;
    setCollectorContainer(container: HTMLElement): void;
    getBox(appId: string): ReadonlyTeleBox | undefined;
    closeBox(appId: string, skipUpdate?: boolean): ReadonlyTeleBox | undefined;
    boxIsFocus(appId: string): boolean | undefined;
    getFocusBox(): ReadonlyTeleBox | undefined;
    getTopBox(): ReadonlyTeleBox | undefined;
    updateBoxState(state?: AppInitState): void;
    updateManagerRect(): void;
    moveBox({ appId, x, y }: MoveBoxParams): void;
    focusBox({ appId }: AppId, skipUpdate?: boolean): void;
    resizeBox({ appId, width, height, skipUpdate }: ResizeBoxParams): void;
    setBoxMinSize(params: SetBoxMinSizeParams): void;
    setBoxTitle(params: SetBoxTitleParams): void;
    blurAllBox(): void;
    updateAll(config: TeleBoxManagerUpdateConfig): void;
    setMaximized(maximized: boolean, skipUpdate?: boolean): void;
    setMinimized(minimized: boolean, skipUpdate?: boolean): void;
    focusTopBox(): void;
    updateBox(id: string, payload: TeleBoxConfig, skipUpdate?: boolean): void;
    setReadonly(readonly: boolean): void;
    setPrefersColorScheme(colorScheme: TeleBoxColorScheme): void;
    setZIndex(id: string, zIndex: number, skipUpdate?: boolean): void;
    destroy(): void;
}

interface MagixEventListenerOptions extends MagixEventListenerOptions$1 {
    /**
     * Rapid emitted callbacks will be slowed down to this interval (in ms).
     */
    fireInterval?: number;
    /**
     * If `true`, sent events will reach self-listeners after committed to server.
     * Otherwise the events will reach self-listeners immediately.
     */
    fireSelfEventAfterCommit?: boolean;
}
interface MagixEventMessage<TPayloads = any, TEvent extends MagixEventTypes<TPayloads> = MagixEventTypes<TPayloads>> extends Omit<Event$1, "scope" | "phase"> {
    /** Event name */
    event: TEvent;
    /** Event Payload */
    payload: TPayloads[TEvent];
    /** Whiteboard ID of the client who dispatched the event. It will be AdminObserverId for system events. */
    authorId: number;
    scope: `${Scope}`;
    phase: `${EventPhase}`;
}
type MagixEventTypes<TPayloads = any> = Extract<keyof TPayloads, string>;
type MagixEventDispatcher<TPayloads = any> = <TEvent extends MagixEventTypes<TPayloads> = MagixEventTypes<TPayloads>>(event: TEvent, payload: TPayloads[TEvent]) => void;
type MagixEventHandler<TPayloads = any, TEvent extends MagixEventTypes<TPayloads> = MagixEventTypes<TPayloads>> = (message: MagixEventMessage<TPayloads, TEvent>) => void;
type MagixEventListenerDisposer = () => void;
type MagixEventAddListener<TPayloads = any> = <TEvent extends MagixEventTypes<TPayloads> = MagixEventTypes<TPayloads>>(event: TEvent, handler: MagixEventHandler<TPayloads, TEvent>, options?: MagixEventListenerOptions | undefined) => MagixEventListenerDisposer;
type MagixEventRemoveListener<TPayloads = any> = <TEvent extends MagixEventTypes<TPayloads> = MagixEventTypes<TPayloads>>(event: TEvent, handler?: MagixEventHandler<TPayloads, TEvent>) => void;

declare class AppContext<TAttributes extends {} = any, TMagixEventPayloads = any, TAppOptions = any> implements PageController {
    private manager;
    private boxManager;
    appId: string;
    private appProxy;
    private appOptions?;
    static readonly kind = "AppContext";
    readonly emitter: Emittery<AppEmitterEvent<TAttributes>>;
    readonly mobxUtils: {
        autorun: any;
        reaction: any;
        toJS: typeof toJS;
    };
    readonly objectUtils: {
        listenUpdated: typeof listenUpdated;
        unlistenUpdated: typeof unlistenUpdated;
        listenDisposed: typeof listenDisposed;
        unlistenDisposed: typeof unlistenDisposed;
    };
    private store;
    readonly isAddApp: boolean;
    readonly isReplay: boolean;
    constructor(manager: AppManager, boxManager: BoxManager, appId: string, appProxy: AppProxy, appOptions?: (TAppOptions | (() => TAppOptions)) | undefined);
    getManager: () => AppManager;
    getBoxManager: () => BoxManager;
    getWindowManager: () => WindowManager;
    getBoxStatus: () => TeleBoxState | undefined;
    getLastNotMinimizedBoxStatus: () => NotMinimizedBoxState | undefined;
    getDisplayer: () => white_web_sdk.Displayer<white_web_sdk.DisplayerCallbacks>;
    getAppProxy: () => AppProxy;
    /** @deprecated Use context.storage.state instead. */
    getAttributes: () => TAttributes | undefined;
    getScenes: () => SceneDefinition[] | undefined;
    getView: () => View | undefined;
    mountView: (dom: HTMLElement) => void;
    getInitScenePath: () => string | undefined;
    /** Get App writable status. */
    getIsWritable: () => boolean;
    /** Get the App Window UI box. */
    getBox: () => ReadonlyTeleBox;
    getRoom: () => Room | undefined;
    /** @deprecated Use context.storage.setState instead. */
    setAttributes: (attributes: TAttributes) => void;
    /** @deprecated Use context.storage.setState instead. */
    updateAttributes: (keys: string[], value: any) => void;
    setScenePath: (scenePath: string) => Promise<void>;
    /** Get the local App options. */
    getAppOptions: () => TAppOptions | undefined;
    private _storage?;
    /** Main Storage for attributes. */
    get storage(): Storage<TAttributes>;
    /**
     * Create separated storages for flexible state management.
     * @param storeId Namespace for the storage. Storages of the same namespace share the same data.
     * @param defaultState Default state for initial storage creation.
     * @returns
     */
    createStorage: <TState extends {}>(storeId: string, defaultState?: TState) => Storage<TState>;
    /** Dispatch events to other clients (and self). */
    dispatchMagixEvent: MagixEventDispatcher<TMagixEventPayloads>;
    /** Listen to events from others clients (and self messages). */
    addMagixEventListener: MagixEventAddListener<TMagixEventPayloads>;
    /** Remove a Magix event listener. */
    removeMagixEventListener: MagixEventRemoveListener<TMagixEventPayloads>;
    /** PageController  */
    nextPage: () => Promise<boolean>;
    jumpPage: (index: number) => Promise<boolean>;
    prevPage: () => Promise<boolean>;
    addPage: (params?: AddPageParams) => Promise<void>;
    removePage: (index?: number) => Promise<boolean>;
    get pageState(): PageState;
    get kind(): string;
    /** Dispatch a local event to `manager.onAppEvent()`. */
    dispatchAppEvent(type: string, value?: any): void;
}

type AppEmitter = Emittery<AppEmitterEvent>;
declare class AppProxy implements PageRemoveService {
    private params;
    private manager;
    static readonly kind = "AppProxy";
    kind: string;
    id: string;
    scenePath?: string;
    appEmitter: AppEmitter;
    scenes?: SceneDefinition[];
    private appListener;
    private boxManager;
    private appProxies;
    private viewManager;
    private store;
    isAddApp: boolean;
    private status;
    private stateKey;
    private _pageState;
    private _prevFullPath;
    appResult?: NetlessApp<any>;
    appContext?: AppContext<any, any>;
    constructor(params: BaseInsertParams, manager: AppManager, appId: string, isAddApp: boolean);
    private initScenes;
    get view(): View | undefined;
    get viewIndex(): number | undefined;
    get isWritable(): boolean;
    get attributes(): any;
    get appAttributes(): AppSyncAttributes;
    get Logger(): white_web_sdk.Logger | undefined;
    getFullScenePath(): string | undefined;
    private getFullScenePathFromScenes;
    setFullPath(path: string): void;
    baseInsertApp(skipUpdate?: boolean, boxStatus?: TeleBoxState): Promise<{
        appId: string;
        app: NetlessApp;
    }>;
    get box(): ReadonlyTeleBox | undefined;
    private setupApp;
    private fixMobileSize;
    private afterSetupApp;
    onSeek(time: number): Promise<void>;
    onReconnected(): Promise<void>;
    onRemoveScene(scenePath: string): Promise<void>;
    getAppInitState: (id: string) => AppInitState | undefined;
    emitAppSceneStateChange(sceneState: SceneState): void;
    emitAppIsWritableChange(): void;
    private makeAppEventListener;
    private appAttributesUpdateListener;
    private setFocusScenePathHandler;
    setScenePath(): void;
    setViewFocusScenePath(): string | undefined;
    private createView;
    notifyPageStateChange: lodash.DebouncedFunc<() => void>;
    notifyBoxStatusChange: (status: TeleBoxState) => void;
    get pageState(): PageState;
    removeSceneByIndex(index: number): Promise<boolean>;
    setSceneIndexWithoutSync(index: number): void;
    setSceneIndex(index: number): void;
    destroy(needCloseBox: boolean, cleanAttrs: boolean, skipUpdate: boolean, error?: Error): Promise<void>;
    close(): Promise<void>;
}

declare class MainViewProxy {
    private manager;
    /** Refresh the view's camera in an interval of 1.5s. */
    polling: boolean;
    private scale?;
    private started;
    private mainViewIsAddListener;
    private isForcingMainViewDivElement;
    private wrapperRectWorkaroundFrame;
    private pendingWrapperRectChange?;
    private mainView;
    private store;
    private viewMode;
    private sideEffectManager;
    private playgroundSizeChangeListenerLocalConsole;
    private sizeUpdatedLocalConsole;
    private cameraUpdatedLocalConsole;
    private cameraReactionLocalConsole;
    constructor(manager: AppManager);
    private syncCamera;
    private startListenWritableChange;
    ensureCameraAndSize(): void;
    private get mainViewCamera();
    private get mainViewSize();
    private get didRelease();
    private moveCameraSizeByAttributes;
    private onWrapperRectChange;
    private runWrapperRectWorkaround;
    private forceSyncMainViewDivElement;
    start(): void;
    addCameraReaction: () => void;
    setCameraAndSize(): void;
    private cameraReaction;
    sizeChangeHandler: lodash.DebouncedFunc<(size: Size) => void>;
    onUpdateContainerSizeRatio: () => void;
    get view(): View;
    get cameraState(): {
        width: number;
        height: number;
        centerX: number;
        centerY: number;
        scale: number;
    };
    createMainView(): View;
    onReconnect(): void;
    setFocusScenePath(path: string | undefined): View | undefined;
    rebind(): void;
    private onCameraUpdatedByDevice;
    addMainViewListener(): void;
    removeMainViewListener(): void;
    private mainViewClickListener;
    mainViewClickHandler(): Promise<void>;
    setMainViewSize: lodash.DebouncedFunc<(size: Size) => void>;
    private addCameraListener;
    private removeCameraListener;
    private _syncMainViewTimer;
    private handleCameraOrSizeUpdated;
    private onCameraUpdated;
    private onSizeUpdated;
    private ensureMainViewSize;
    private syncMainView;
    moveCameraToContian(size: Size): void;
    moveCamera(camera: Camera): void;
    stop(): void;
    setViewMode: (mode: ViewMode) => void;
    destroy(): void;
}

declare class ViewManager {
    private displayer;
    views: Map<string, View>;
    constructor(displayer: Displayer);
    createView(id: string): View;
    getView(id: string): View | undefined;
    destroyView(id: string): void;
    setViewScenePath(id: string, scenePath: string): void;
    destroy(): void;
}

type ReconnectRefresherContext = {
    emitter: EmitterType;
};
declare class ReconnectRefresher {
    private ctx;
    private phase?;
    private room;
    private reactors;
    private disposers;
    constructor(ctx: ReconnectRefresherContext);
    setRoom(room: Room | undefined): void;
    setContext(ctx: ReconnectRefresherContext): void;
    private onPhaseChanged;
    private onReconnected;
    private _onReconnected;
    private releaseDisposers;
    refresh(): void;
    add(id: string, func: any): void;
    remove(id: string): void;
    hasReactor(id: string): boolean;
    destroy(): void;
}

declare class AppManager {
    windowManger: WindowManager;
    static readonly kind = "AppManager";
    displayer: Displayer;
    viewManager: ViewManager;
    appProxies: Map<string, AppProxy>;
    appStatus: Map<string, AppStatus>;
    store: AttributesDelegate;
    mainViewProxy: MainViewProxy;
    refresher: ReconnectRefresher;
    isReplay: boolean;
    mainViewScenesLength: number;
    private appListeners;
    boxManager?: BoxManager;
    private _prevSceneIndex;
    private _prevFocused;
    private callbacksNode;
    private appCreateQueue;
    private _focusAppCreatedResolve?;
    private _focusAppId;
    private _resolveTimer;
    private sideEffectManager;
    sceneState: SceneState | null;
    rootDirRemoving: boolean;
    private _useBoxesStatus;
    get useBoxesStatus(): boolean;
    set useBoxesStatus(value: boolean);
    constructor(windowManger: WindowManager);
    getMemberState(): MemberState;
    private onRemoveScenes;
    /**
     * 根目录被删除时所有的 scene 都会被删除.
     * 所以需要关掉所有开启了 view 的 app
     */
    onRootDirRemoved(needClose?: boolean): Promise<void>;
    private onReadonlyChanged;
    private onPlayerSeekStart;
    private onPlayerSeekDone;
    createRootDirScenesCallback: () => void;
    removeSceneByIndex: (index: number) => Promise<boolean>;
    setSceneIndexWithoutSync: (index: number) => void;
    private onSceneChange;
    private emitMainViewScenesChange;
    private updateSceneState;
    private get eventName();
    get attributes(): WindowMangerAttributes;
    get canOperate(): boolean;
    get room(): Room | undefined;
    get mainView(): white_web_sdk.View;
    get polling(): boolean;
    set polling(b: boolean);
    get focusApp(): AppProxy | undefined;
    get uid(): string;
    get Logger(): white_web_sdk.Logger | undefined;
    getMainViewSceneDir(): string;
    private onCreated;
    private onBoxMove;
    private onBoxResize;
    private onBoxFocus;
    private onBoxBlurred;
    private onBoxClose;
    private onBoxStateChange;
    private notifyBoxesStatusChange;
    addBoxesStatusChangeListener: () => void;
    addAppsChangeListener: () => void;
    addAppCloseListener: () => void;
    private onMainViewIndexChange;
    private onFocusChange;
    attributesUpdateCallback: lodash.DebouncedFunc<(apps: any) => Promise<void>>;
    private _appIds;
    notifyAppsChange(appIds: string[]): void;
    /**
     * 插件更新 attributes 时的回调
     *
     * @param {*} attributes
     * @memberof WindowManager
     */
    _attributesUpdateCallback(apps: any): Promise<void>;
    private onRegisteredChange;
    private onMinimized;
    refresh(): void;
    setBoxManager(boxManager: BoxManager): void;
    resetMaximized(): void;
    resetMinimized(): void;
    private onAppDelete;
    private closeAll;
    bindMainView(divElement: HTMLDivElement, disableCameraTransform: boolean): void;
    private hasRoot;
    private getRectByDivElement;
    setMainViewFocusPath(scenePath?: string): boolean | undefined;
    private resetScenePath;
    addApp(params: AddAppParams, isDynamicPPT: boolean): Promise<string | undefined>;
    private beforeAddApp;
    private afterAddApp;
    closeApp(appId: string, needClose?: boolean): Promise<void>;
    private baseInsertApp;
    private displayerStateListener;
    displayerWritableListener: (isReadonly: boolean) => void;
    safeSetAttributes(attributes: any): void;
    safeUpdateAttributes(keys: string[], value: any): void;
    setMainViewScenePath(scenePath: string): Promise<void>;
    private _setMainViewScenePath;
    private updateSceneIndex;
    setMainViewSceneIndex(index: number): Promise<void>;
    private dispatchSetMainViewScenePath;
    getAppInitPath(appId: string): string | undefined;
    safeDispatchMagixEvent(event: string, payload: any): void;
    focusByAttributes(apps: any): void;
    onReconnected(): Promise<void>;
    notifyContainerRectUpdate(rect: TeleBoxRect): void;
    updateRootDirRemoving: (removing: boolean) => void;
    dispatchInternalEvent(event: Events, payload?: any): void;
    destroy(): void;
}

/**
 * 按 `[WindowManager][tagName]` 前缀输出。
 * 若传入 `debounceTime`（毫秒）：窗口内多次 `log` 不立即输出，只在连续停止调用满 `debounceTime` 后输出**最后一次**的参数（尾部 debounce）。
 */
declare class ArgusLog {
    private readonly logger;
    private readonly name;
    private readonly debounceTime?;
    private pendingArgs;
    private flushTimer;
    /** debounce 窗口内按一层 key 合并；同 key 后者覆盖；非普通对象则整段待输出被本次值替换 */
    private pendingShallowMerge;
    private shallowMergeTimer;
    /** debounce 窗口内 safeUpdateAttributes：同 keys 数组则只更新 value，否则追加一段，flush 时拼成一条 */
    private pendingUpdateSegments;
    private updateMergeTimer;
    constructor(logger: Logger, name: string, debounceTime?: number | undefined);
    private emitInfo;
    private flush;
    private flushShallowMerge;
    log(...args: unknown[]): void;
    /**
     * 带 debounce 时：窗口内多次调用会把「一层 key」合并进同一条日志（不同 key 并存，同 key 取最后一次）。
     * `payload` 为普通对象时做浅合并；否则视为原子值，覆盖当前待合并状态（丢弃此前累积的对象 key）。
     * 无 debounce 或时间为 0 时立即输出。
     */
    logDebouncedShallowMerge(label: string, payload: unknown): void;
    private flushUpdateAttributesMerge;
    /**
     * 带 debounce 时：连续调用若 `keys` 与上一段完全相同则覆盖该段的 `value`；否则追加一段。
     * flush 时输出一条日志，多段用 ` | ` 连接。
     */
    logDebouncedUpdateAttributes(keys: string[], value: unknown): void;
    /**
     * 销毁：清除所有 `setTimeout` debounce 定时器，并丢弃尚未输出的暂存日志（不补打日志）。
     * WindowManager 销毁时应调用，避免泄漏与销毁后仍触发 `logger.info`。
     */
    destroy(): void;
    /** 与 `destroy()` 相同，保留旧名以兼容 */
    dispose(): void;
}

declare class AppListeners {
    private manager;
    private displayer;
    constructor(manager: AppManager);
    private get boxManager();
    addListeners(): void;
    removeListeners(): void;
    private mainMagixEventListener;
    private appMoveHandler;
    private appResizeHandler;
    private boxStateChangeHandler;
    private setMainViewScenePathHandler;
    private cursorMoveHandler;
    private rootDirRemovedHandler;
    private refreshHandler;
    private initMainViewCameraHandler;
    private setAppFocusViewIndexHandler;
}

declare enum IframeEvents {
    Init = "Init",
    AttributesUpdate = "AttributesUpdate",
    SetAttributes = "SetAttributes",
    RegisterMagixEvent = "RegisterMagixEvent",
    RemoveMagixEvent = "RemoveMagixEvent",
    RemoveAllMagixEvent = "RemoveAllMagixEvent",
    RoomStateChanged = "RoomStateChanged",
    DispatchMagixEvent = "DispatchMagixEvent",
    ReciveMagixEvent = "ReciveMagixEvent",
    NextPage = "NextPage",
    PrevPage = "PrevPage",
    SDKCreate = "SDKCreate",
    OnCreate = "OnCreate",
    SetPage = "SetPage",
    GetAttributes = "GetAttributes",
    Ready = "Ready",
    Destory = "Destory",
    StartCreate = "StartCreate",
    WrapperDidUpdate = "WrapperDidUpdate",
    DispayIframe = "DispayIframe",
    HideIframe = "HideIframe",
    GetRootRect = "GetRootRect",
    ReplayRootRect = "ReplayRootRect",
    PageTo = "PageTo"
}
declare enum DomEvents {
    WrapperDidMount = "WrapperDidMount",
    IframeLoad = "IframeLoad"
}
type IframeBridgeAttributes = {
    readonly url: string;
    readonly width: number;
    readonly height: number;
    readonly displaySceneDir: string;
    readonly lastEvent?: {
        name: string;
        payload: any;
    };
    readonly useClicker?: boolean;
    readonly useSelector?: boolean;
};
type IframeBridgeEvents = {
    created: undefined;
    [IframeEvents.Ready]: undefined;
    [IframeEvents.StartCreate]: undefined;
    [IframeEvents.OnCreate]: IframeBridge;
    [IframeEvents.Destory]: undefined;
    [IframeEvents.GetRootRect]: undefined;
    [IframeEvents.ReplayRootRect]: DOMRect;
    [DomEvents.WrapperDidMount]: undefined;
    [IframeEvents.WrapperDidUpdate]: undefined;
    [DomEvents.IframeLoad]: Event;
    [IframeEvents.HideIframe]: undefined;
    [IframeEvents.DispayIframe]: undefined;
};
type IframeSize = {
    readonly width: number;
    readonly height: number;
};
type BaseOption = {
    readonly url: string;
    readonly width: number;
    readonly height: number;
    readonly displaySceneDir: string;
};
type InsertOptions = {
    readonly useClicker?: boolean;
    readonly useSelector?: boolean;
} & BaseOption;
/**
 * {@link https://github.com/netless-io/netless-iframe-bridge @netless/iframe-bridge}
 */
declare class IframeBridge {
    readonly manager: WindowManager;
    readonly appManager: AppManager;
    static readonly kind = "IframeBridge";
    static readonly hiddenClass = "netless-iframe-brdige-hidden";
    static emitter: Emittery<IframeBridgeEvents>;
    private static displayer;
    private static alreadyCreate;
    displayer: Displayer;
    iframe: HTMLIFrameElement;
    private readonly magixEventMap;
    private cssList;
    private allowAppliances;
    private bridgeDisposer;
    private rootRect;
    private sideEffectManager;
    constructor(manager: WindowManager, appManager: AppManager);
    static onCreate(plugin: IframeBridge): void;
    insert(options: InsertOptions): this;
    private getComputedIframeStyle;
    destroy(): void;
    private getIframe;
    setIframeSize(params: IframeSize): void;
    get attributes(): Partial<IframeBridgeAttributes>;
    setAttributes(data: Partial<IframeBridgeAttributes>): void;
    private _createIframe;
    scaleIframeToFit(animationMode?: AnimationMode): void;
    get isReplay(): boolean;
    private handleSetPage;
    private execListenIframe;
    private src_url_equal_anchor?;
    private listenIframe;
    private onPhaseChangedListener;
    private listenDisplayerState;
    private computedStyleAndIframeDisplay;
    private listenDisplayerCallbacks;
    private get callbackName();
    private stateChangeListener;
    private computedStyle;
    private computedIframeDisplay;
    computedZindex(): void;
    private updateStyle;
    private get iframeOrigin();
    private messageListener;
    private handleSDKCreate;
    private handleDispatchMagixEvent;
    private handleSetAttributes;
    private handleRegisterMagixEvent;
    private handleRemoveMagixEvent;
    private handleNextPage;
    private handlePrevPage;
    private handlePageTo;
    private handleRemoveAllMagixEvent;
    private handleGetAttributes;
    postMessage(message: any): void;
    dispatchMagixEvent(event: string, payload: any): void;
    private get currentIndex();
    private get currentPage();
    private get totalPage();
    private get readonly();
    get inDisplaySceneDir(): boolean;
    private isClicker;
    private get isDisableInput();
}

interface ExtendContext {
    readonly manager: ExtendPluginManager;
    readonly windowManager: WindowManager;
    readonly internalEmitter: EmitterType;
    windowManagerContainer?: HTMLElement;
}
declare abstract class ExtendPlugin extends Emittery {
    context: ExtendContext;
    abstract readonly kind: string;
    protected _inject(context: ExtendContext): void;
    abstract onCreate(): void;
    abstract onDestroy(): void;
}
type ExtendPluginInstance<T extends ExtendPlugin> = T;
interface ExtendManagerOptions {
    readonly windowManager: WindowManager;
    readonly internalEmitter: EmitterType;
    readonly container?: HTMLElement;
}
declare class ExtendPluginManager {
    private extends;
    private context;
    constructor(props: ExtendManagerOptions);
    refreshContainer(container: HTMLElement): void;
    hasRegister(kind: string): boolean;
    use(extend: ExtendPluginInstance<any>): void;
    destroy(): void;
}

type ExtendClassAble = typeof AppManager | typeof AppProxy | typeof AppContext | typeof BoxManager | typeof AttributesDelegate | typeof CursorManager | typeof TeleBoxManager | typeof TeleBoxCollector;
type ExtendClass = {
    AppManager?: typeof AppManager;
    BoxManager?: typeof BoxManager;
    AttributesDelegate?: typeof AttributesDelegate;
    CursorManager?: typeof CursorManager;
    AppProxy?: typeof AppProxy;
    AppContext?: typeof AppContext;
    TeleBoxManager?: typeof TeleBoxManager;
    TeleBoxCollector?: typeof TeleBoxCollector;
};
declare function getExtendClass<T extends ExtendClassAble>(baseClass: T, extendClass?: ExtendClass): T;

declare const BuiltinApps: {
    DocsViewer: string;
    MediaPlayer: string;
};

type WindowMangerAttributes = {
    modelValue?: string;
    boxState: TELE_BOX_STATE;
    maximized?: boolean;
    minimized?: boolean;
    [key: string]: any;
};
type apps = {
    [key: string]: NetlessApp;
};
type AddAppOptions = {
    scenePath?: string;
    title?: string;
    scenes?: SceneDefinition[];
};
type setAppOptions = AddAppOptions & {
    appOptions?: any;
};
type AddAppParams<TAttributes = any> = {
    kind: string;
    src?: string;
    options?: AddAppOptions;
    attributes?: TAttributes;
    forceTop?: boolean;
    forceNormal?: boolean;
    isDragContent?: boolean;
};
type BaseInsertParams = {
    kind: string;
    src?: string;
    options?: AddAppOptions;
    attributes?: any;
    isDynamicPPT?: boolean;
    forceTop?: boolean;
    forceNormal?: boolean;
    isDragContent?: boolean;
};
type AppSyncAttributes = {
    kind: string;
    src?: string;
    options: any;
    state?: any;
    isDynamicPPT?: boolean;
    fullPath?: string;
    createdAt?: number;
    forceTop?: boolean;
    forceNormal?: boolean;
    isDragContent?: boolean;
};
type AppInitState = {
    id: string;
    x?: number;
    y?: number;
    width?: number;
    height?: number;
    focus?: boolean;
    maximized?: boolean;
    minimized?: boolean;
    sceneIndex?: number;
    /** 所有box的基本状态 */
    boxState?: TeleBoxState;
    zIndex?: number;
    /** 扩展版本,单个box的状态 */
    boxStatus?: TeleBoxState;
    /** 上次非最小化窗口状态 */
    lastNotMinimizedBoxStatus?: NotMinimizedBoxState;
    forceTop?: boolean;
    forceNormal?: boolean;
    isDragContent?: boolean;
};
type CursorMovePayload = {
    uid: string;
    state?: "leave";
    position: Position;
};
type CursorOptions = {
    /**
     * If `"custom"`, it will render the pencil / eraser cursor as a circle and shapes cursor as a cross.
     *
     * @default "default"
     */
    style?: "default" | "custom";
};
type MountParams = {
    room: Room | Player;
    container?: HTMLElement;
    /** 白板高宽比例, 默认为 9 / 16 */
    containerSizeRatio?: number;
    /** @deprecated 显示 PS 透明背景，默认 true */
    chessboard?: boolean;
    collectorContainer?: HTMLElement;
    collectorStyles?: Partial<CSSStyleDeclaration>;
    overwriteStyles?: string;
    cursor?: boolean;
    cursorOptions?: CursorOptions;
    debug?: boolean;
    disableCameraTransform?: boolean;
    prefersColorScheme?: TeleBoxColorScheme;
    applianceIcons?: ApplianceIcons;
    fullscreen?: boolean;
    polling?: boolean;
    /** 是否支持 appliance plugin */
    supportAppliancePlugin?: boolean;
    /** 是否使用 boxesStatus 状态管理窗口 */
    useBoxesStatus?: boolean;
};
declare const reconnectRefresher: ReconnectRefresher;
declare class WindowManager extends InvisiblePlugin<WindowMangerAttributes, any> implements PageController {
    static readonly kind = "WindowManager";
    static displayer: Displayer;
    static wrapper?: HTMLElement;
    static sizer?: HTMLElement;
    static playground?: HTMLElement;
    static container?: HTMLElement;
    static debug: boolean;
    static containerSizeRatio: number;
    static supportAppliancePlugin?: boolean;
    private static isCreated;
    private static _resolve;
    version: string;
    dependencies: Record<string, string>;
    appListeners?: AppListeners;
    readonly?: boolean;
    emitter: Emittery<PublicEvent>;
    appManager?: AppManager;
    cursorManager?: CursorManager;
    viewMode: ViewMode;
    isReplay: boolean;
    private _pageState?;
    private _fullscreen?;
    private _cursorUIDs;
    private _cursorUIDsStyleDOM?;
    _appliancePlugin?: any;
    private boxManager?;
    private static params?;
    static extendClass?: ExtendClass$1;
    private containerResizeObserver?;
    containerSizeRatio: number;
    private extendPluginManager?;
    private _roomLogger?;
    attributesDeboundceLog?: ArgusLog;
    get Logger(): Logger | undefined;
    constructor(context: InvisiblePluginContext);
    static onCreate(manager: WindowManager): void;
    static mount(params: MountParams, extendClass?: ExtendClass$1): Promise<WindowManager>;
    onMainViewScenePathChangeHandler: (scenePath: string) => void;
    private static initManager;
    private static initContainer;
    static get registered(): Map<string, RegisterParams>;
    bindContainer(container: HTMLElement): void;
    bindCollectorContainer(container: HTMLElement): void;
    /**
     * 注册插件
     */
    static register(params: RegisterParams<any, any, any>): Promise<void>;
    /**
     * 注销插件
     */
    static unregister(kind: string): void;
    /**
     * 创建一个 app 至白板
     */
    addApp<T = any>(params: AddAppParams<T>): Promise<string | undefined>;
    private _addApp;
    private setupScenePath;
    /**
     * 设置 mainView 的 ScenePath, 并且切换白板为可写状态
     */
    setMainViewScenePath(scenePath: string): Promise<void>;
    /**
     * 设置 mainView 的 SceneIndex, 并且切换白板为可写状态
     */
    setMainViewSceneIndex(index: number): Promise<void>;
    nextPage(): Promise<boolean>;
    prevPage(): Promise<boolean>;
    jumpPage(index: number): Promise<boolean>;
    addPage(params?: AddPageParams): Promise<void>;
    /**
     * 删除一页
     * 默认删除当前页, 可以删除指定 index 页
     * 最低保留一页
     */
    removePage(index?: number): Promise<boolean>;
    /**
     * 返回 mainView 的 ScenePath
     */
    getMainViewScenePath(): string | undefined;
    /**
     * 返回 mainView 的 SceneIndex
     */
    getMainViewSceneIndex(): number;
    /**
     * 设置所有 app 的 readonly 模式
     */
    setReadonly(readonly: boolean): void;
    /**
     * 切换 mainView 为可写
     */
    switchMainViewToWriter(): Promise<void> | undefined;
    /**
     * app destroy 回调
     */
    onAppDestroy(kind: string, listener: (error: Error) => void): void;
    /**
     * app 本地自定义事件回调
     *
     * 返回一个用于撤销此监听的函数
     */
    onAppEvent(kind: string, listener: (args: {
        kind: string;
        appId: string;
        type: string;
        value: any;
    }) => void): () => void;
    /**
     * 设置 ViewMode
     */
    setViewMode(mode: ViewMode): void;
    setBoxState(boxState: TeleBoxState): void;
    setMaximized(maximized: boolean): void;
    setMinimized(minimized: boolean): void;
    /** 设置指定 box 的状态, 如果为 undefined, 则移除状态*/
    setBoxStatus(boxId: string, boxStatus?: TELE_BOX_STATE): void;
    /** 设置指定 box 的非最小化状态, 如果为 undefined, 则移除状态 */
    setLastNotMinimizedBoxStatus(boxId: string, lastNotMinimizedBoxStatus?: NotMinimizedBoxState): void;
    setFullscreen(fullscreen: boolean): void;
    get cursorUIDs(): string[];
    setCursorUIDs(cursorUIDs?: string[] | null): void;
    get mainView(): View;
    get camera(): Camera;
    get cameraState(): CameraState;
    get apps(): Apps | undefined;
    get boxState(): TeleBoxState | undefined;
    get boxStatus(): Record<string, TeleBoxState> | undefined;
    get lastNotMinimizedBoxStatus(): Record<string, NotMinimizedBoxState> | undefined;
    get darkMode(): boolean;
    get prefersColorScheme(): TeleBoxColorScheme | undefined;
    get focused(): string | undefined;
    get focusedView(): View | undefined;
    get polling(): boolean;
    set polling(b: boolean);
    get cursorStyle(): "default" | "custom";
    set cursorStyle(value: "default" | "custom");
    get mainViewSceneIndex(): number;
    get mainViewSceneDir(): string;
    get topApp(): string | undefined;
    get mainViewScenesLength(): number;
    get canRedoSteps(): number;
    get canUndoSteps(): number;
    get sceneState(): SceneState;
    get pageState(): PageState;
    get fullscreen(): boolean;
    /**
     * 查询所有的 App
     */
    queryAll(): AppProxy[];
    /**
     * 查询单个 App
     */
    queryOne(appId: string): AppProxy | undefined;
    /**
     * 关闭 APP
     */
    closeApp(appId: string): Promise<void>;
    /**
     * 切换 focus 到指定的 app, 并且把这个 app 放到最前面
     */
    focusApp(appId: string): void;
    moveCamera(camera: Partial<Camera> & {
        animationMode?: AnimationMode | undefined;
    }): void;
    moveCameraToContain(rectangle: Rectangle & Readonly<{
        animationMode?: AnimationMode;
    }>): void;
    convertToPointInWorld(point: Point): Point;
    setCameraBound(cameraBound: CameraBound): void;
    onDestroy(): void;
    destroy(): void;
    private _destroy;
    private bindMainView;
    get canOperate(): boolean;
    get room(): Room;
    safeSetAttributes(attributes: any): void;
    safeUpdateAttributes(keys: string[], value: any): void;
    setPrefersColorScheme(scheme: TeleBoxColorScheme): void;
    cleanCurrentScene(): void;
    redo(): number;
    undo(): number;
    delete(): void;
    copy(): void;
    paste(): void;
    duplicate(): void;
    insertText(x: number, y: number, text: string | undefined): string;
    insertImage(info: ImageInformation): void;
    completeImageUpload(uuid: string, url: string): void;
    lockImage(uuid: string, locked: boolean): void;
    lockImages(locked: boolean): void;
    refresh(): void;
    setContainerSizeRatio(ratio: number): void;
    private isDynamicPPT;
    private ensureAttributes;
    private _iframeBridge?;
    getIframeBridge(): IframeBridge;
    useExtendPlugin(extend: ExtendPluginInstance<any>): void;
}

export { AppContext, AppCreateError, AppManager, AppManagerNotInitError, AppNotRegisterError, AppProxy, AttributesDelegate, BindContainerRoomPhaseInvalidError, BoxManager, BoxManagerNotFoundError, BoxNotCreatedError, BuiltinApps, CursorManager, ExtendPlugin, ExtendPluginManager, InvalidScenePath, ParamsInvalidError, Storage, WhiteWebSDKInvalidError, WindowManager, calculateNextIndex, getExtendClass, reconnectRefresher };
export type { AddAppOptions, AddAppParams, AddPageParams, AppEmitterEvent, AppInitState, AppListenerKeys, AppPayload, AppSyncAttributes, ApplianceIcons, BaseInsertParams, CursorMovePayload, CursorOptions, ExtendClass, ExtendClassAble, ExtendContext, ExtendManagerOptions, ExtendPluginInstance, MountParams, NetlessApp, PageController, PageRemoveService, PageState, PublicEvent, RegisterEventData, RegisterEvents, RegisterParams, StorageStateChangedEvent, StorageStateChangedListener, WindowMangerAttributes, apps, setAppOptions };