@netless/window-manager 1.0.0-canary.24 → 1.0.0-canary.27

package/dist/src/BoxManager.d.ts

@@ -0,0 +1,102 @@
+import { AppAttributes } from "./constants";
+import { SideEffectManager } from "side-effect-manager";
+import { TELE_BOX_STATE, TeleBoxManager } from "@netless/telebox-insider";
+import { WindowManager } from "./index";
+import type { BoxEmitterType } from "./BoxEmitter";
+import type { AddAppOptions } from "./index";
+import type { TeleBoxManagerUpdateConfig, ReadonlyTeleBox, TeleBoxColorScheme, TeleBoxRect, TeleBoxConfig } from "@netless/telebox-insider";
+import type Emittery from "emittery";
+import type { NetlessApp } from "./typings";
+import type { View } from "white-web-sdk";
+import type { CallbacksType } from "./callback";
+import type { EmitterType } from "./InternalEmitter";
+import type { AppState } from "./App/type";
+export { TELE_BOX_STATE };
+export declare type CreateBoxParams = {
+    appId: string;
+    app: NetlessApp;
+    view?: View;
+    emitter?: Emittery;
+    options?: AddAppOptions;
+    canOperate?: boolean;
+    smartPosition?: boolean;
+};
+declare type AppId = {
+    appId: string;
+};
+declare type MoveBoxParams = AppId & {
+    x: number;
+    y: number;
+};
+declare type ResizeBoxParams = AppId & {
+    width: number;
+    height: number;
+    skipUpdate: boolean;
+};
+declare type SetBoxMinSizeParams = AppId & {
+    minWidth: number;
+    minHeight: number;
+};
+declare type SetBoxTitleParams = AppId & {
+    title: string;
+};
+export declare type CreateTeleBoxManagerConfig = {
+    collectorContainer?: HTMLElement;
+    collectorStyles?: Partial<CSSStyleDeclaration>;
+    prefersColorScheme?: TeleBoxColorScheme;
+    stageRatio?: number;
+    containerStyle?: string;
+    stageStyle?: string;
+};
+export declare type BoxManagerContext = {
+    safeSetAttributes: (attributes: any) => void;
+    updateAppState: (appId: string, field: AppAttributes, value: any) => void;
+    emitter: EmitterType;
+    boxEmitter: BoxEmitterType;
+    callbacks: CallbacksType;
+    canOperate: () => boolean;
+    notifyContainerRectUpdate: (rect: TeleBoxRect) => void;
+    cleanFocus: () => void;
+    setAppFocus: (appId: string) => void;
+};
+export declare const createBoxManager: (manager: WindowManager, callbacks: CallbacksType, emitter: EmitterType, boxEmitter: BoxEmitterType, options: CreateTeleBoxManagerConfig) => BoxManager;
+export declare class BoxManager {
+    private context;
+    teleBoxManager: TeleBoxManager;
+    protected sideEffectManager: SideEffectManager;
+    constructor(context: BoxManagerContext, createTeleBoxManagerConfig?: CreateTeleBoxManagerConfig);
+    private get canOperate();
+    get boxState(): "normal" | "minimized" | "maximized";
+    get maximized(): boolean;
+    get minimized(): boolean;
+    get darkMode(): boolean;
+    get prefersColorScheme(): TeleBoxColorScheme;
+    get boxSize(): number;
+    get stageRect(): TeleBoxRect;
+    get stageRect$(): import("value-enhancer").ReadonlyVal<TeleBoxRect, any>;
+    createBox(params: CreateBoxParams): ReadonlyTeleBox | undefined;
+    setupBoxManager(createTeleBoxManagerConfig?: CreateTeleBoxManagerConfig): TeleBoxManager;
+    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?: AppState): 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;
+    setRoot(root: HTMLElement): void;
+    setCollector(collector: HTMLElement): void;
+    destroy(): void;
+}

package/dist/src/BuiltinApps.d.ts

@@ -0,0 +1,8 @@
+export declare const setupBuiltin: () => void;
+export declare const BuiltinApps: {
+    DocsViewer: string;
+    MediaPlayer: string;
+};
+export declare const BuiltinAppsMap: {
+    [x: string]: any;
+};

package/dist/src/Cursor/Cursor.d.ts

@@ -0,0 +1,39 @@
+import { ApplianceNames } from "white-web-sdk";
+import type { Position } from "../AttributesDelegate";
+import type { RoomMember } from "white-web-sdk";
+import type { CursorManager } from "./index";
+import type { AppManager } from "../AppManager";
+export declare type Payload = {
+    [key: string]: any;
+};
+export declare class Cursor {
+    private manager;
+    private memberId;
+    private cursorManager;
+    private wrapper?;
+    private member?;
+    private timer?;
+    private component?;
+    constructor(manager: AppManager, memberId: string, cursorManager: CursorManager, wrapper?: HTMLElement | undefined);
+    move: (position: Position) => void;
+    leave: () => void;
+    private moveCursor;
+    get memberApplianceName(): ApplianceNames | undefined;
+    get memberColor(): 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;
+    updateMember(): RoomMember | undefined;
+    private updateComponent;
+    destroy(): void;
+    hide(): void;
+}

package/dist/src/Cursor/icons.d.ts

@@ -0,0 +1,3 @@
+export declare const ApplianceMap: {
+    [key: string]: string;
+};

package/dist/src/Cursor/index.d.ts

@@ -0,0 +1,46 @@
+import { Cursor } from "./Cursor";
+import type { ApplianceIcons, TeleBoxRect } from "../index";
+import type { PositionType } from "../AttributesDelegate";
+import type { RoomMember, View } from "white-web-sdk";
+import type { AppManager } from "../AppManager";
+export declare type EventType = {
+    type: PositionType;
+    id?: string;
+};
+export declare type MoveCursorParams = {
+    uid: string;
+    x: number;
+    y: number;
+};
+export declare class CursorManager {
+    private manager;
+    private enableCursor;
+    wrapperRect?: TeleBoxRect;
+    playgroundRect?: DOMRect;
+    cursorInstances: Map<string, Cursor>;
+    roomMembers?: readonly RoomMember[];
+    private mainViewElement?;
+    private sideEffectManager;
+    private store;
+    applianceIcons: ApplianceIcons;
+    constructor(manager: AppManager, enableCursor: boolean, applianceIcons?: ApplianceIcons);
+    private onCursorMove;
+    private initCursorInstance;
+    private canMoveCursor;
+    setupWrapper(wrapper: HTMLElement): void;
+    setMainViewDivElement(div: HTMLDivElement): void;
+    get boxState(): any;
+    get focusView(): View | undefined;
+    private mouseMoveListener;
+    private updateCursor;
+    private getPoint;
+    /**
+     *  因为窗口内框在不同分辨率下的大小不一样，所以这里通过来鼠标事件的 target 来判断是在主白板还是在 APP 中
+     */
+    private getType;
+    private mouseLeaveListener;
+    updateContainerRect(): void;
+    deleteCursor(uid: string): void;
+    hideCursor(uid: string): void;
+    destroy(): void;
+}

package/dist/src/Helper.d.ts

@@ -0,0 +1,19 @@
+import { WindowManager } from "./index";
+import type { Room, RoomMember } from "white-web-sdk";
+export declare const setupWrapper: (root: HTMLElement, target: HTMLElement) => {
+    playground: HTMLDivElement;
+    mainViewElement: HTMLDivElement;
+};
+export declare const checkVersion: () => void;
+export declare const findMemberByUid: (room: Room | undefined, uid: string) => RoomMember | undefined;
+export declare type Member = RoomMember & {
+    uid: string;
+};
+export declare const serializeRoomMembers: (members: readonly RoomMember[]) => {
+    memberId: number;
+    memberState: import("white-web-sdk").MemberState;
+    session: string;
+    payload?: import("white-web-sdk").UserPayload | undefined;
+    uid: string;
+}[];
+export declare const createInvisiblePlugin: (room: Room) => Promise<WindowManager | undefined>;

package/dist/src/InternalEmitter.d.ts

@@ -0,0 +1,38 @@
+import Emittery from "emittery";
+import type { TeleBoxRect } from "@netless/telebox-insider";
+import type { CursorMovePayload } from "./index";
+import type { Member } from "./Helper";
+import type { MemberState } from "white-web-sdk";
+export declare type RemoveSceneParams = {
+    scenePath: string;
+    index?: number;
+};
+export declare type EmitterEvent = {
+    onCreated: undefined;
+    error: Error;
+    seekStart: undefined;
+    seek: number;
+    mainViewMounted: undefined;
+    observerIdChange: number;
+    boxStateChange: string;
+    playgroundSizeChange: TeleBoxRect;
+    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;
+    roomMembersChange: Member[];
+    memberStateChange: MemberState;
+};
+export declare type EmitterType = Emittery<EmitterEvent>;
+export declare const emitter: EmitterType;

package/dist/src/Page/PageController.d.ts

@@ -0,0 +1,21 @@
+import type { SceneDefinition } from "white-web-sdk";
+export declare type AddPageParams = {
+    after?: boolean;
+    scene?: SceneDefinition;
+};
+export declare type PageState = {
+    index: number;
+    length: number;
+};
+export 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;
+}
+export interface PageRemoveService {
+    removeSceneByIndex: (index: number) => Promise<boolean>;
+    setSceneIndexWithoutSync: (index: number) => void;
+}

package/dist/src/Page/index.d.ts

@@ -0,0 +1,3 @@
+import type { PageState } from "./PageController";
+export * from "./PageController";
+export declare const calculateNextIndex: (index: number, pageState: PageState) => number;

package/dist/src/PageState.d.ts

@@ -0,0 +1,9 @@
+import type { AppManager } from "./AppManager";
+import type { PageState } from "./Page";
+export declare class PageStateImpl {
+    private manager;
+    constructor(manager: AppManager);
+    get index(): number;
+    get length(): number;
+    toObject(): PageState;
+}

package/dist/src/ReconnectRefresher.d.ts

@@ -0,0 +1,24 @@
+import type { Room } from "white-web-sdk";
+import type { EmitterType } from "./InternalEmitter";
+export declare type ReconnectRefresherContext = {
+    emitter: EmitterType;
+};
+export 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;
+}

package/dist/src/RedoUndo.d.ts

@@ -0,0 +1,18 @@
+import type { View } from "white-web-sdk";
+import type { AppProxy } from "./App";
+export declare type RedoUndoContext = {
+    mainView: () => View;
+    focus: () => string | undefined;
+    getAppProxy: (id: string) => AppProxy | undefined;
+};
+export declare class RedoUndo {
+    private context;
+    constructor(context: RedoUndoContext);
+    private addRedoUndoListeners;
+    private addViewCallbacks;
+    private disposeViewCallbacks;
+    private onCanRedoStepsUpdate;
+    private onCanUndoStepsUpdate;
+    private disposePrevFocusViewRedoUndoListeners;
+    destroy(): void;
+}

package/dist/src/Register/index.d.ts

@@ -0,0 +1,28 @@
+import Emittery from "emittery";
+import type { NetlessApp, RegisterEvents, RegisterParams } from "../typings";
+export declare type LoadAppEvent = {
+    kind: string;
+    status: "start" | "success" | "failed";
+    reason?: string;
+};
+export declare type SyncRegisterAppPayload = {
+    kind: string;
+    src: string;
+    name: string | undefined;
+};
+export declare type SyncRegisterApp = (payload: SyncRegisterAppPayload) => void;
+declare class AppRegister {
+    kindEmitters: Map<string, Emittery<RegisterEvents>>;
+    registered: Map<string, RegisterParams>;
+    appClassesCache: Map<string, Promise<NetlessApp>>;
+    appClasses: Map<string, () => Promise<NetlessApp>>;
+    private syncRegisterApp;
+    setSyncRegisterApp(fn: SyncRegisterApp): void;
+    onSyncRegisterAppChange: (payload: SyncRegisterAppPayload) => void;
+    register(params: RegisterParams): Promise<void>;
+    unregister(kind: string): void;
+    notifyApp<T extends keyof RegisterEvents>(kind: string, event: T, payload: RegisterEvents[T]): Promise<void>;
+    private createKindEmitter;
+}
+export declare const appRegister: AppRegister;
+export {};

package/dist/src/Register/loader.d.ts

@@ -0,0 +1,4 @@
+import type { NetlessApp } from "../typings";
+export declare const getScript: (url: string) => Promise<string>;
+export declare const executeScript: (text: string, appName: string) => NetlessApp;
+export declare const loadApp: (url: string, key: string, name?: string | undefined) => Promise<NetlessApp | undefined>;

package/dist/src/Register/storage.d.ts

@@ -0,0 +1,8 @@
+export declare type Item = {
+    kind: string;
+    sourceCode: string;
+};
+export declare const initDb: () => Promise<void>;
+export declare const setItem: (key: string, val: any) => Promise<void> | undefined;
+export declare const getItem: (key: string) => Promise<Item | null>;
+export declare const removeItem: (key: string) => Promise<void> | undefined;

package/dist/src/Utils/AppCreateQueue.d.ts

@@ -0,0 +1,15 @@
+export declare type Invoker<T = any> = () => Promise<T | undefined>;
+export declare class AppCreateQueue {
+    private list;
+    private currentInvoker;
+    private timer;
+    isEmit: boolean;
+    private initInterval;
+    push<T>(item: Invoker<T>): void;
+    invoke(): void;
+    private invoked;
+    private clear;
+    emitReady(): void;
+    empty(): void;
+    destroy(): void;
+}

package/dist/src/Utils/Common.d.ts

@@ -0,0 +1,23 @@
+import type { PublicEvent } from "../callback";
+import type { Displayer, ViewVisionMode, Room, View, SceneDefinition } from "white-web-sdk";
+import type Emittery from "emittery";
+export declare const genAppId: (kind: string) => Promise<string>;
+export declare const setViewFocusScenePath: (view: View, focusScenePath: string) => View | undefined;
+export declare const setViewSceneIndex: (view: View, index: number) => View | undefined;
+export declare const releaseView: (view: View) => void;
+export declare const setScenePath: (room: Room | undefined, scenePath: string) => void;
+export declare const getScenePath: (room: Room | undefined, dir: string | undefined, index: number) => string | undefined;
+export declare const removeScenes: (room: Room | undefined, scenePath: string, index?: number | undefined) => void;
+export declare const setViewMode: (view: View, mode: ViewVisionMode) => void;
+export declare const emitError: (error: Error) => void;
+export declare const addEmitterOnceListener: (event: any, listener: any) => void;
+export declare const notifyMainViewModeChange: import("lodash").DebouncedFunc<(callbacks: Emittery<PublicEvent>, mode: ViewVisionMode) => void>;
+export declare const makeValidScenePath: (displayer: Displayer, scenePath: string, index?: number) => string | undefined;
+export declare const entireScenes: (displayer: Displayer) => import("white-web-sdk").SceneMap;
+export declare const putScenes: (room: Room | undefined, path: string, scenes: SceneDefinition[], index?: number | undefined) => void | undefined;
+export declare const isValidScenePath: (scenePath: string) => boolean;
+export declare const parseSceneDir: (scenePath: string) => string;
+export declare const ensureValidScenePath: (scenePath: string) => string;
+export declare const getVersionNumber: (version: string) => number;
+export declare const wait: (time: number) => Promise<unknown>;
+export declare const isRootDirPage: (scenePath: string) => boolean;

package/dist/src/Utils/Reactive.d.ts

@@ -0,0 +1,6 @@
+import { UpdateEventKind } from "white-web-sdk";
+import type { AkkoObjectUpdatedListener } from "white-web-sdk";
+export declare const onObjectByEvent: (event: UpdateEventKind) => (object: any, func: () => void) => (() => void) | undefined;
+export declare const safeListenPropsUpdated: <T>(getProps: () => T, callback: AkkoObjectUpdatedListener<T>, onDestroyed?: ((props: unknown) => void) | undefined) => () => void;
+export declare const onObjectRemoved: (object: any, func: () => void) => (() => void) | undefined;
+export declare const onObjectInserted: (object: any, func: () => void) => (() => void) | undefined;

package/dist/src/Utils/RoomHacker.d.ts

@@ -0,0 +1,3 @@
+import type { WindowManager } from "../index";
+import type { Room, Player } from "white-web-sdk";
+export declare const replaceRoomFunction: (room: Room | Player, manager: WindowManager) => void;

package/dist/src/Utils/error.d.ts

@@ -0,0 +1,27 @@
+export declare class AppCreateError extends Error {
+    message: string;
+}
+export declare class AppNotRegisterError extends Error {
+    constructor(kind: string);
+}
+export declare class AppManagerNotInitError extends Error {
+    message: string;
+}
+export declare class WhiteWebSDKInvalidError extends Error {
+    constructor(version: string);
+}
+export declare class ParamsInvalidError extends Error {
+    message: string;
+}
+export declare class BoxNotCreatedError extends Error {
+    message: string;
+}
+export declare class InvalidScenePath extends Error {
+    message: string;
+}
+export declare class BoxManagerNotFoundError extends Error {
+    message: string;
+}
+export declare class BindContainerRoomPhaseInvalidError extends Error {
+    message: string;
+}

package/dist/src/Utils/log.d.ts

@@ -0,0 +1 @@
+export declare const log: (...args: any[]) => void;

package/dist/src/View/CameraSynchronizer.d.ts

@@ -0,0 +1,17 @@
+import type { TeleBoxRect } from "@netless/telebox-insider";
+import type { View } from "white-web-sdk";
+import type { ICamera, ISize } from "../AttributesDelegate";
+export declare type SaveCamera = (camera: ICamera) => void;
+export declare class CameraSynchronizer {
+    protected saveCamera: SaveCamera;
+    remoteCamera?: ICamera;
+    remoteSize?: ISize;
+    protected rect?: TeleBoxRect;
+    protected view?: View;
+    constructor(saveCamera: SaveCamera);
+    setRect: (rect: TeleBoxRect) => void;
+    setView(view: View): void;
+    onRemoteUpdate: import("lodash").DebouncedFunc<(camera: ICamera, size: ISize) => void>;
+    onRemoteSizeUpdate(size: ISize): void;
+    onLocalCameraUpdate(camera: ICamera): void;
+}

package/dist/src/View/MainView.d.ts

@@ -0,0 +1,59 @@
+import { Val } from "value-enhancer";
+import { ViewSync } from "./ViewSync";
+import type { ICamera, ISize } from "../AttributesDelegate";
+import type { Size, View } from "white-web-sdk";
+import type { AppManager } from "../AppManager";
+export declare class MainViewProxy {
+    private manager;
+    private started;
+    private mainViewIsAddListener;
+    private mainView;
+    private store;
+    private sideEffectManager;
+    camera$: Val<{
+        id: string;
+        centerX: number | null;
+        centerY: number | null;
+        scale: number;
+    } | undefined, any>;
+    size$: Val<ISize | undefined, any>;
+    view$: Val<View | undefined, any>;
+    viewSync?: ViewSync;
+    constructor(manager: AppManager);
+    createViewSync: () => void;
+    private startListenWritableChange;
+    ensureCameraAndSize(): void;
+    private get mainViewCamera();
+    private get mainViewSize();
+    private get didRelease();
+    start(): void;
+    addCameraReaction: () => void;
+    storeCurrentCamera: () => void;
+    storeCurrentSize: () => void;
+    storeCamera: (camera: ICamera) => void;
+    storeSize: (size: ISize) => void;
+    private cameraReaction;
+    private sizeReaction;
+    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;
+    addMainViewListener(): void;
+    removeMainViewListener(): void;
+    private mainViewClickListener;
+    mainViewClickHandler(): Promise<void>;
+    setMainViewSize: import("lodash").DebouncedFunc<(size: Size) => void>;
+    private addCameraListener;
+    private removeCameraListener;
+    private onCameraOrSizeUpdated;
+    stop(): void;
+    destroy(): void;
+}

package/dist/src/View/ViewManager.d.ts

@@ -0,0 +1,13 @@
+import type { View, Displayer } from "white-web-sdk";
+export 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;
+}
+export declare const createView: (displayer: Displayer) => View;
+export declare const setDefaultCameraBound: (view: View) => void;

package/dist/src/View/ViewSync.d.ts

@@ -0,0 +1,24 @@
+import { ViewMode } from "white-web-sdk";
+import type { View } from "white-web-sdk";
+import type { Val, ReadonlyVal } from "value-enhancer";
+import type { ICamera, ISize } from "../AttributesDelegate";
+import type { TeleBoxRect } from "@netless/telebox-insider";
+export declare type ViewSyncContext = {
+    uid: string;
+    camera$: Val<ICamera | undefined, boolean>;
+    size$: Val<ISize | undefined>;
+    stageRect$: ReadonlyVal<TeleBoxRect>;
+    viewMode$?: Val<ViewMode>;
+    storeCamera: (camera: ICamera) => void;
+    storeSize: (size: ISize) => void;
+    view$: Val<View | undefined>;
+};
+export declare class ViewSync {
+    private context;
+    private sem;
+    private synchronizer;
+    constructor(context: ViewSyncContext);
+    bindView: (view?: View | undefined) => void;
+    private onCameraUpdatedByDevice;
+    destroy(): void;
+}

package/dist/src/callback.d.ts

@@ -0,0 +1,29 @@
+import Emittery from "emittery";
+import type { TeleBoxColorScheme, TELE_BOX_STATE } from "@netless/telebox-insider";
+import type { CameraState, SceneState, ViewVisionMode } from "white-web-sdk";
+import type { LoadAppEvent } from "./Register";
+import type { PageState } from "./Page";
+export declare 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;
+    appClose: {
+        appId: string;
+        kind: string;
+        error?: Error;
+    };
+};
+export declare type CallbacksType = Emittery<PublicEvent>;
+export declare const callbacks: CallbacksType;