next-flow-interface 0.19.12 → 0.19.13

package/dist/index.d.ts

@@ -1,3 +1,657 @@
+import { AbstractMesh } from '@babylonjs/core';
+import { Animation as Animation_2 } from '@babylonjs/core';
+import { AnimationGroup } from '@babylonjs/core/Animations/animationGroup';
+import { AnimationGroup as AnimationGroup_2 } from '@babylonjs/core';
+import { ArcRotateCamera } from '@babylonjs/core';
+import { Attributes } from 'react';
+import { BaseTexture } from '@babylonjs/core';
+import { Color } from 'antd/es/color-picker';
+import { Color3 } from '@babylonjs/core';
+import { Color4 } from '@babylonjs/core';
+import { ColorPickerProps } from 'antd/es/color-picker';
+import { CubeTexture } from '@babylonjs/core';
+import { default as default_2 } from 'react';
+import { DefaultOptionType } from 'antd/es/select';
+import { DetailedHTMLProps } from 'react';
+import { DynamicTexture } from '@babylonjs/core';
+import { EmptyProps } from 'antd';
+import { Engine } from '@babylonjs/core';
+import { FunctionComponent } from 'react';
+import { HTMLAttributes } from 'react';
+import { InputNumberProps } from 'antd';
+import { Light } from '@babylonjs/core';
+import { Material } from '@babylonjs/core';
+import { MouseEvent as MouseEvent_2 } from 'react';
+import { MouseEventHandler } from 'react';
+import { Node as Node_2 } from '@babylonjs/core';
+import { NodeMaterial } from '@babylonjs/core';
+import { NodeMaterialBlock } from '@babylonjs/core';
+import { NodeMaterialBlockConnectionPointTypes } from '@babylonjs/core';
+import { PBRMaterial } from '@babylonjs/core';
+import { ReactNode } from 'react';
+import { RecursiveArray } from 'rhine-var';
+import { RecursiveMap } from 'rhine-var';
+import { RecursiveObject } from 'rhine-var';
+import { RhineVarArray } from 'rhine-var';
+import { RhineVarMap } from 'rhine-var';
+import { Root } from 'react-dom/client';
+import { RvPath } from 'rhine-var';
+import { Scene } from '@babylonjs/core';
+import { SelectProps } from 'antd';
+import { ShadowGenerator } from '@babylonjs/core';
+import { StoredRhineVar } from 'rhine-var';
+import { SwitchProps } from 'antd';
+import { Texture } from '@babylonjs/core';
+import { TransformNode } from '@babylonjs/core';
+import { TransformNode as TransformNode_2 } from '@babylonjs/core/Meshes/transformNode';
+import { Vector3 } from '@babylonjs/core';
+import { WebGPUEngine } from '@babylonjs/core';
+import { WebXRDefaultExperience } from '@babylonjs/core';
+
+declare interface AddLocalDataOptionInterface extends Omit<LocalData, 'status' | 'progress'> {
+    status?: LocalDataStatus;
+    progress?: number;
+}
+
+export declare let Anchor: FunctionComponent<AnchorProps>;
+
+declare interface AnchorProps extends DivProps {
+    list: string[];
+    value: number;
+    onSelectChange: (value: number) => void;
+    middle?: boolean;
+}
+
+export declare let AntCheckbox: FunctionComponent<AntCheckboxProps>;
+
+declare interface AntCheckboxProps extends SwitchProps {
+    value: boolean;
+    onChange: (value: boolean) => void;
+    className?: string | undefined;
+    label?: string;
+}
+
+export declare let AntColor: FunctionComponent<AntColorProps>;
+
+declare interface AntColorProps extends ColorPickerProps {
+    value: Color | string | null;
+    onColorChange: (value: string) => void;
+    className?: string;
+    classNameInner?: string;
+    theme?: string;
+}
+
+export declare let AntEmpty: FunctionComponent<AntEmptyProps>;
+
+declare interface AntEmptyProps extends EmptyProps {
+    className?: string;
+    classNameInner?: string;
+    image?: ReactNode;
+    description?: ReactNode;
+    children?: ReactNode;
+}
+
+export declare let AntNumber: FunctionComponent<AntNumberProps>;
+
+declare interface AntNumberProps extends Omit<InputNumberProps, 'onChange'> {
+    value: number | null;
+    onChange: (value: number | null) => void;
+    placeholder?: string;
+    className?: string;
+    classNameInner?: string;
+    theme?: string;
+}
+
+export declare let AntSelect: FunctionComponent<AntSelectProps<unknown>>;
+
+declare interface AntSelectProps<ValueType> extends SelectProps<ValueType> {
+    value?: ValueType;
+    onChange?: (value: ValueType, option?: DefaultOptionType | DefaultOptionType[]) => void;
+    showSearch?: boolean;
+    onClick?: MouseEventHandler<HTMLDivElement>;
+    className?: string;
+    classNameInner?: string;
+    placeholder?: string;
+    optionFilterProp?: string;
+    size?: 'small' | 'middle' | 'large' | undefined;
+    options?: DefaultOptionType[];
+}
+
+export declare let AntSwitch: FunctionComponent<AntSwitchProps>;
+
+declare interface AntSwitchProps extends SwitchProps {
+    value: boolean;
+    onChange: (value: boolean) => void;
+    className?: string | undefined;
+}
+
+declare interface AwarenessChanges {
+    added: number[];
+    updated: number[];
+    removed: number[];
+}
+
+declare type AwarenessChangeSubscriber = (changeStates: Map<number, RvAwareness>, changes: AwarenessChanges) => void;
+
+export declare let awarenessService: AwarenessServiceApi;
+
+declare interface AwarenessServiceApi {
+    subscribeChange: (subscriber: AwarenessChangeSubscriber) => () => void;
+    unsubscribeChange: (subscriber: AwarenessChangeSubscriber) => void;
+    states: Map<number, RvAwareness>;
+    getCurrentRvAwareness(): RvAwareness;
+}
+
+declare interface BasePlugin {
+    id: string;
+    version: string;
+    namespace: string;
+    name: string;
+    description: string;
+    type: PluginType;
+    theme: ThemeColor;
+    data?: Record<string, unknown>;
+    messages?: Record<Locale, Record<string, any>> | string;
+    onInstall?: () => Promise<void>;
+    onEnable?: () => Promise<void>;
+    onDisable?: () => Promise<void>;
+    onUninstall?: () => Promise<void>;
+}
+
+export declare let cameraConfigurationAnimation: CameraConfigurationAnimationApi;
+
+declare interface CameraConfigurationAnimationApi {
+    play(data: {
+        distanceMin?: number;
+        distanceMax?: number;
+        fov?: number;
+    }, duration?: number, quickMode?: boolean): void;
+    distanceMin(value: number, duration?: number, quickMode?: boolean): void;
+    distanceMax(value: number, duration?: number, quickMode?: boolean): void;
+    fov(value: number, duration?: number, quickMode?: boolean): void;
+}
+
+export declare let cameraLocationAnimation: CameraLocationAnimationApi;
+
+declare interface CameraLocationAnimationApi {
+    cameraAnimation: AnimationGroup | null;
+    play(data: RvCameraLocation, duration?: number, enableNear?: boolean): void;
+    playEasy(data: RvCameraLocation, duration?: number): void;
+    makeCameraAnimationsEase(data: RvCameraLocation, duration?: number): Animation_2[];
+}
+
+declare class ContextMenu {
+    options: ContextMenuCreateOptions;
+    id: string;
+    lines: MenuLine[];
+    showIcon: boolean;
+    x: number;
+    y: number;
+    closeOnOutsideClick: boolean;
+    theme?: ThemeColor | undefined;
+    controller: ContextMenuController | null;
+    createTime: Date;
+    constructor(options: ContextMenuCreateOptions, id: string, lines?: MenuLine[], showIcon?: boolean, x?: number, y?: number, closeOnOutsideClick?: boolean, theme?: ThemeColor | undefined, controller?: ContextMenuController | null, createTime?: Date);
+    static fromOptions(id: string, options: ContextMenuCreateOptions, menuLines?: MenuLine[]): ContextMenu;
+}
+
+declare interface ContextMenuController {
+    contextMenu: ContextMenu;
+    show(): void;
+    destroy(): void;
+}
+
+declare interface ContextMenuCreateOptions {
+    id?: string;
+    lines?: MenuLineCreateOptions[];
+    showIcon?: boolean;
+    x?: number;
+    y?: number;
+    closeOnOutsideClick?: boolean;
+    theme?: ThemeColor;
+    onClose?: () => void;
+}
+
+export declare let contextMenuService: ContextMenuServiceApi;
+
+declare interface ContextMenuServiceApi {
+    /**
+     * 当前所有右键菜单
+     */
+    contextMenus: ContextMenu[];
+    /**
+     * 创建右键菜单
+     *
+     * @param options 创建右键菜单的选项对象 具体选项见 ContextMenuCreateOptions
+     *
+     * @returns 返回所创建的右键菜单的控制器
+     */
+    create(options: ContextMenuCreateOptions): ContextMenuController;
+    /**
+     * 获取右键菜单
+     *
+     * @param id 右键菜单的 id
+     *
+     * @returns 返回对应 id 的右键菜单 如果没有则返回 undefined
+     */
+    get(id: string): ContextMenu | undefined;
+    /**
+     * 关闭右键菜单
+     *
+     * @param contextMenu 右键菜单控制器
+     */
+    close(contextMenu: string | ContextMenu): Promise<boolean>;
+    /**
+     * 关闭所有右键菜单
+     */
+    closeAll(): Promise<number>;
+}
+
+declare class Dialog {
+    options: DialogCreateOptions;
+    id: string;
+    title: string;
+    titleIcon: FunctionComponent | string | undefined;
+    content: string;
+    contentAlign: DialogContentAlign;
+    contentView: FunctionComponent | string | undefined;
+    icon: FunctionComponent | string | undefined;
+    view: FunctionComponent | string | undefined;
+    theme: ThemeColor;
+    leftMode: boolean;
+    className: string;
+    style: object;
+    confirmText: string;
+    cancelText: string;
+    enableInput: boolean;
+    defaultValue: string;
+    inputPlaceholder: string;
+    autoFocus: boolean;
+    allowEmpty: boolean;
+    onChange: (value: string) => void;
+    onCheck: (value: string) => boolean;
+    enableCloseButton: boolean;
+    onConfirm: (value: string) => void;
+    onCancel: () => void;
+    onClose: () => void;
+    onConfirmButtonClick: () => void;
+    onCancelButtonClick: () => void;
+    onOutsideClick: () => void;
+    onCloseButtonClick: () => void;
+    onRender: () => void;
+    onEffect: () => () => void;
+    closeOnConfirm: boolean;
+    closeOnCancel: boolean;
+    closeOnOutsideClick: boolean;
+    closeOnCloseButtonClick: boolean;
+    alignButton: boolean;
+    inputValue: string;
+    createTime: Date;
+    focusInput: () => void;
+    elements: Map<string, HTMLElement>;
+    constructor(options: DialogCreateOptions, id: string, title?: string, titleIcon?: FunctionComponent | string | undefined, content?: string, contentAlign?: DialogContentAlign, contentView?: FunctionComponent | string | undefined, icon?: FunctionComponent | string | undefined, view?: FunctionComponent | string | undefined, theme?: ThemeColor, leftMode?: boolean, className?: string, style?: object, confirmText?: string, cancelText?: string, enableInput?: boolean, defaultValue?: string, inputPlaceholder?: string, autoFocus?: boolean, allowEmpty?: boolean, onChange?: (value: string) => void, onCheck?: (value: string) => boolean, enableCloseButton?: boolean, onConfirm?: (value: string) => void, onCancel?: () => void, onClose?: () => void, onConfirmButtonClick?: () => void, onCancelButtonClick?: () => void, onOutsideClick?: () => void, onCloseButtonClick?: () => void, onRender?: () => void, onEffect?: () => () => void, closeOnConfirm?: boolean, closeOnCancel?: boolean, closeOnOutsideClick?: boolean, closeOnCloseButtonClick?: boolean, alignButton?: boolean, inputValue?: string, createTime?: Date, focusInput?: () => void, elements?: Map<string, HTMLElement>);
+    static fromOptions(id: string, options: DialogCreateOptions): Dialog;
+    setHide: (value: boolean) => void;
+}
+
+declare enum DialogContentAlign {
+    LEFT = "LEFT",
+    CENTER = "CENTER",
+    RIGHT = "RIGHT"
+}
+
+declare interface DialogCreateOptions {
+    id?: string;
+    title?: string;
+    titleIcon?: FunctionComponent | string;
+    content?: string;
+    contentAlign?: DialogContentAlign;
+    contentView?: FunctionComponent | string;
+    icon?: FunctionComponent | string;
+    view?: FunctionComponent | string;
+    theme?: ThemeColor;
+    leftMode?: boolean;
+    className?: string;
+    style?: object;
+    confirmText?: string;
+    cancelText?: string;
+    enableCloseButton?: boolean;
+    enableInput?: boolean;
+    defaultValue?: string;
+    inputPlaceholder?: string;
+    autoFocus?: boolean;
+    allowEmpty?: boolean;
+    onChange?: (value: string) => void;
+    onCheck?: (value: string) => boolean;
+    onConfirm?: (value: string) => void;
+    onCancel?: () => void;
+    onClose?: () => void;
+    onConfirmButtonClick?: () => void;
+    onCancelButtonClick?: () => void;
+    onOutsideClick?: () => void;
+    onCloseButtonClick?: () => void;
+    onRender?: () => void;
+    onEffect?: () => () => void;
+    closeOnConfirm?: boolean;
+    closeOnCancel?: boolean;
+    closeOnOutsideClick?: boolean;
+    closeOnCloseButtonClick?: boolean;
+    alignButton?: boolean;
+}
+
+export declare let dialogService: DialogServiceApi;
+
+declare interface DialogServiceApi {
+    dialogs: Dialog[];
+    /**
+     * 创建对话框 最全面的对话框创建方法
+     *
+     * @param options 创建对话框的选项对象 具体选项见 DialogCreateOptions
+     * @param show 是否直接展示弹窗
+     *
+     * @returns 返回所创建的对话框的控制器
+     */
+    create(options: DialogCreateOptions, show?: boolean): Promise<Dialog>;
+    /**
+     * 弹出提示信息或询问是或否的对话框
+     *
+     * @param options 创建对话框的选项对象 具体选项如下
+     * @param show 是否直接展示弹窗
+     *
+     * @returns 关闭后返回用户是否点击了确认按钮
+     */
+    confirm(options: {
+        title: string;
+        titleIcon: FunctionComponent;
+        content?: string;
+        contentView?: FunctionComponent;
+        icon?: FunctionComponent;
+        confirmText?: string;
+        cancelText?: string;
+        theme?: ThemeColor;
+        background?: ThemeBackground;
+        leftMode?: boolean;
+        className?: string;
+        style?: object;
+        onConfirm?: () => void;
+        onCancel?: () => void;
+        onClose?: () => void;
+        closeOnOutsideClick?: boolean;
+    }, show?: boolean): Promise<boolean>;
+    /**
+     * 弹出获取用户文本输入的对话框
+     *
+     * @param options 创建对话框的选项对象 具体选项如下
+     * @param show 是否直接展示弹窗
+     *
+     * @returns 关闭后返回用户输入的文本 如果用户不是点击确认按钮关闭的对话框 则返回 undefined
+     */
+    input(options: {
+        title: string;
+        titleIcon: FunctionComponent;
+        content?: string;
+        contentView?: FunctionComponent;
+        icon?: FunctionComponent;
+        theme?: ThemeColor;
+        leftMode?: boolean;
+        className?: string;
+        style?: object;
+        confirmText?: string;
+        cancelText?: string;
+        defaultValue?: string;
+        inputPlaceholder?: string;
+        autoFocus?: boolean;
+        allowEmpty?: boolean;
+        onChange?: (value: string) => void;
+        onCheck?: (value: string) => boolean;
+        onConfirm?: (value: string) => void;
+        onCancel?: () => void;
+        onClose?: () => void;
+        closeOnOutsideClick?: boolean;
+    }, show?: boolean): Promise<string | undefined>;
+    /**
+     * 获取对话框
+     *
+     * @param id 对话框的 id
+     *
+     * @returns 返回对应 id 的对话框 如果没有则返回 undefined
+     */
+    get(id: string): Dialog | undefined;
+    /**
+     * 打开对话框
+     *
+     * @param dialog 对话框实例或对话框ID
+     */
+    open(dialog: string | Dialog): Promise<boolean>;
+    /**
+     * 关闭对话框
+     *
+     * @param dialog 对话框实例或对话框ID
+     */
+    close(dialog: string | Dialog): Promise<boolean>;
+    /**
+     * 关闭所有对话框
+     */
+    closeAll(): Promise<number>;
+}
+
+declare type DivProps = DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+
+declare type DivPropsSimple = Omit<DivProps, 'onChange' | 'defaultValue'>;
+
+export declare let DrawerLoading: FunctionComponent<SpanProps>;
+
+export declare let easyPropertyAnimation: EasyPropertyAnimationApi;
+
+declare interface EasyPropertyAnimationApi {
+    animationMap: Map<string, {
+        animationGroup?: AnimationGroup_2;
+        timeout?: ReturnType<typeof setTimeout>;
+    }>;
+    play(id: string, type: number, node: SupportAnimationTarget, keys: string[], to: unknown, duration?: number, quickMode?: boolean, from?: unknown, ease?: boolean): void;
+    playSplit(id: string, callback: () => void, duration?: number): void;
+    stop(id: string): void;
+}
+
+declare enum EnableLevel {
+    NONE = "NONE",
+    INSTALL = "INSTALL",
+    ENABLE = "ENABLE",
+    OPEN = "OPEN"
+}
+
+declare interface FileData {
+    fid: string;
+    status: LocalDataStatus;
+    name: string;
+    progress: number;
+    mime: string;
+    filename?: string;
+    extension?: string;
+    description?: string;
+    size?: string;
+    preview?: string;
+}
+
+export declare let FileProgressBar: FunctionComponent<FileProgressBarProps>;
+
+declare interface FileProgressBarProps extends DivProps {
+    size: string;
+    value: number;
+    className?: string;
+    theme?: string;
+}
+
+export declare let firstLoadModelService: FirstLoadModelServiceApi;
+
+declare interface FirstLoadModelServiceApi {
+    status: FirstLoadModelServiceStatus;
+    rsModelList: RsModel[];
+    loadingNumber: number;
+    loadedNumber: number;
+    errorNumber: number;
+    canceledNumber: number;
+    totalSize: number;
+    loadedSize: number;
+    startTime: number;
+    start(): void;
+    subscribe(subscriber: FirstLoadModelServiceSubscriber): () => void;
+    unsubscribe(subscriber: FirstLoadModelServiceSubscriber): void;
+}
+
+declare enum FirstLoadModelServiceEventType {
+    START = "START",
+    PROGRESS = "PROGRESS",
+    LOADED = "LOADED",
+    ERROR = "ERROR",
+    CANCELED = "CANCELED"
+}
+
+declare enum FirstLoadModelServiceStatus {
+    WAITING = "WAITING",
+    LOADING = "LOADING",
+    LOADED = "LOADED",
+    ERROR = "ERROR",
+    CANCELED = "CANCELED"
+}
+
+declare type FirstLoadModelServiceSubscriber = (type: FirstLoadModelServiceEventType) => void;
+
+export declare let firstLoadService: FirstLoadServiceApi;
+
+declare interface FirstLoadServiceApi {
+    status: FirstLoadServiceStatus;
+    localDataList: LocalData[];
+    loadingNumber: number;
+    loadedNumber: number;
+    errorNumber: number;
+    canceledNumber: number;
+    totalSize: number;
+    loadedSize: number;
+    startTime: number;
+    start(): void;
+    subscribe(subscriber: FirstLoadServiceSubscriber): () => void;
+    unsubscribe(subscriber: FirstLoadServiceSubscriber): void;
+}
+
+declare enum FirstLoadServiceEventType {
+    START = "START",
+    PROGRESS = "PROGRESS",
+    LOADED = "LOADED",
+    ERROR = "ERROR",
+    CANCELED = "CANCELED"
+}
+
+declare enum FirstLoadServiceStatus {
+    WAITING = "WAITING",
+    LOADING = "LOADING",
+    LOADED = "LOADED",
+    ERROR = "ERROR",
+    CANCELED = "CANCELED"
+}
+
+declare type FirstLoadServiceSubscriber = (type: FirstLoadServiceEventType) => void;
+
+export declare let FlexGrow: FunctionComponent<FlexGrowProps>;
+
+declare interface FlexGrowProps {
+    value?: number;
+}
+
+declare enum FocusMode {
+    DEFAULT = "DEFAULT",
+    DESCRIPTION = "DESCRIPTION"
+}
+
+export declare let fogAnimation: FogAnimationApi;
+
+declare interface FogAnimationApi {
+    play(data: RvEnvironment['fog'], duration?: number, quickMode?: boolean): void;
+    enableAndDensity(enable: boolean, value: number, duration?: number, quickMode?: boolean): void;
+    color(color: Color3 | string, duration?: number, quickMode?: boolean): void;
+}
+
+export declare let groundAnimation: GroundAnimationApi;
+
+declare interface GroundAnimationApi {
+    play(data: RvEnvironment['ground'], duration?: number, quickMode?: boolean): void;
+    opacityRate(value: number, duration?: number, quickMode?: boolean): void;
+    baseColor(color: Color3 | string, duration?: number, quickMode?: boolean): void;
+    enableOnViewerMode(value: boolean, duration: number, quickMode: boolean): void;
+    enableOnEditorMode(value: boolean, duration: number, quickMode: boolean): void;
+}
+
+declare interface HighLightInfo {
+    uid: number;
+    color: string;
+}
+
+export declare let historyService: HistoryServiceApi;
+
+declare interface HistoryServiceApi {
+    operate: string;
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    pushState(state: unknown): void;
+    check(operate: string, forceStop?: boolean): void;
+    stop(): void;
+    clear(): void;
+    clearUndoStack(): void;
+    clearRedoStack(): void;
+    removeFirst(operate?: string): boolean;
+    removeLast(operate?: string): boolean;
+    subscribe(subscriber: HistoryServiceSubscriber): () => void;
+    unsubscribe(subscriber: HistoryServiceSubscriber): void;
+    subscribeState(subscriber: HistoryServiceStateSubscriber): () => void;
+    unsubscribeState(subscriber: HistoryServiceStateSubscriber): void;
+}
+
+declare enum HistoryServiceEventType {
+    'UNDO' = "UNDO",
+    'REDO' = "REDO"
+}
+
+declare type HistoryServiceStateSubscriber = (state: unknown) => void;
+
+declare type HistoryServiceSubscriber = (type: HistoryServiceEventType, operate: string) => void;
+
+declare interface IconPlugin extends BasePlugin {
+    position: IconPluginPosition;
+    group: string;
+    label: string;
+    color: ThemeColor;
+    open: boolean;
+    icon: MixView<IconViewProps>;
+    onEnabledChange?: (value: boolean, e: MouseEvent) => void;
+    onIconClick?: (e: MouseEvent) => void;
+    onIconClickRouter?: (e: MouseEvent) => string;
+    onIconContextMenu?: (e: MouseEvent) => void;
+}
+
+declare enum IconPluginPosition {
+    TOP = 0,
+    RIGHT = 1,
+    BOTTOM = 2,
+    LEFT = 3,
+    TOP_LEFT = 4,
+    BOTTOM_LEFT = 5,
+    TOP_RIGHT = 6,
+    BOTTOM_RIGHT = 7,
+    UNKNOWN = 8
+}
+
+declare interface IconViewProps extends DivProps {
+    plugin: IconPlugin;
+}
+
+export declare let InternationalizationProvider: FunctionComponent<InternationalizationProviderProps>;
+
+declare interface InternationalizationProviderProps {
+    children?: ReactNode;
+}
+
 export declare let internationalizationService: InternationalizationServiceApi;
 
 declare interface InternationalizationServiceApi {
@@ -13,19 +667,2183 @@ declare interface InternationalizationServiceApi {
     wait(namespace: string | string[]): Promise<void>;
 }
 
+declare class LabelInfo {
+    nid: string;
+    node: TransformNode_2 | null;
+    text: string;
+    theme: LabelTheme;
+    x: number;
+    y: number;
+    parentElement: HTMLDivElement | null;
+    pointElement: HTMLDivElement | null;
+    lineElement: HTMLDivElement | null;
+    blockElement: HTMLDivElement | null;
+    textElement: HTMLDivElement | null;
+    validate: boolean;
+    always: boolean;
+    show: boolean;
+    lastClickTime: number;
+    lastSp: Vector3 | null;
+    constructor(nid: string, node?: TransformNode_2 | null, text?: string, theme?: LabelTheme, x?: number, y?: number);
+}
+
+declare enum LabelTheme {
+    Default = "Default"
+}
+
+declare type LastSubscriber = (value: RsSelectionNodeInfo | null) => void;
+
+export declare let lightAnimation: LightAnimationApi;
+
+declare interface LightAnimationApi {
+    play(data: {
+        intensity?: number;
+        diffuseColor?: string;
+        specularColor?: string;
+    }, duration?: number, quickMode?: boolean): void;
+    intensity(value: number, duration?: number, quickMode?: boolean): void;
+    diffuseColor(color: Color3 | string, duration?: number, quickMode?: boolean): void;
+    specularColor(color: Color3 | string, duration?: number, quickMode?: boolean): void;
+}
+
+declare interface LocalData {
+    fid: string;
+    type: LocalDataType;
+    mime: string;
+    status: LocalDataStatus;
+    progress: number;
+    url?: string;
+    blob?: Blob;
+    text?: string;
+    json?: unknown;
+    texture?: BaseTexture;
+    material?: Material;
+    uv?: unknown;
+    object?: unknown;
+}
+
+export declare let localDataService: LocalDataServiceApi;
+
+declare interface LocalDataServiceApi {
+    files: Map<string, LocalData>;
+    get(fid: string): LocalData | undefined;
+    has(fid: string): boolean;
+    remove(fid: string): boolean;
+    add(localData: AddLocalDataOptionInterface): LocalData;
+    load(fid: string, url: string, mime?: string): Promise<LocalData>;
+    loadByFile(fid: string, file: File, mime?: string): Promise<LocalData>;
+    processAfterLoad(localData: LocalData): Promise<boolean>;
+    pause(fid: string): boolean;
+    resume(fid: string): boolean;
+    cancel(fid: string): boolean;
+    getLocalUrl(fid: string): string;
+    releaseLocalUrl(fid: string): boolean;
+    subscribe(subscriber: LocalDataServiceSubscriber): () => void;
+    unsubscribe(subscriber: LocalDataServiceSubscriber): void;
+    subscribeSingle(fid: string, subscriber: LocalDataServiceSubscriber): () => void;
+    unsubscribeSingle(fid: string, subscriber: LocalDataServiceSubscriber): void;
+    publish(fid: string, type: LocalDataServiceEventType, localData: LocalData): void;
+    afterLoaded(fid: string, subscriber: (localData: LocalData) => void): void;
+    waitLoaded(fid: string): Promise<LocalData>;
+    /**
+     * 是否已经载入完成
+     *
+     * @param fid  文件 fid
+     *
+     * @returns  返回文件是否载入完成 文件不存在则返回 undefined
+     */
+    isLoaded(fid: string): boolean | undefined;
+}
+
+declare enum LocalDataServiceEventType {
+    ADD = "ADD",
+    REMOVE = "REMOVE",
+    START = "START",
+    PROGRESS = "PROGRESS",
+    PAUSE = "PAUSE",
+    RESUME = "RESUME",
+    LOADED = "LOADED",
+    ERROR = "ERROR",
+    CANCELED = "CANCELED"
+}
+
+declare type LocalDataServiceSubscriber = (type: LocalDataServiceEventType, LocalData: LocalData) => void;
+
+declare enum LocalDataStatus {
+    WAITING = "WAITING",
+    LOADING = "LOADING",
+    PAUSED = "PAUSED",
+    LOADED = "LOADED",
+    FAILED = "FAILED",
+    CANCELED = "CANCELED"
+}
+
+declare enum LocalDataType {
+    BLOB = "BLOB",
+    OBJECT = "OBJECT"
+}
+
 declare enum Locale {
     ZH = "zh",
     EN = "en"
 }
 
+export declare let MainPortal: FunctionComponent<MainPortalProps>;
+
+declare interface MainPortalProps {
+    children: ReactNode;
+}
+
+export declare let MaterialSymbol: FunctionComponent<MaterialSymbolProps>;
+
+export declare let materialSymbol: (icon: string, options?: MaterialSymbolOptions) => FunctionComponent;
+
+declare interface MaterialSymbolOptions {
+    fill?: boolean;
+    size?: string;
+    color?: string;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+declare interface MaterialSymbolProps extends SpanProps {
+    size?: string;
+    color?: string;
+    className?: string;
+    fill?: boolean;
+}
+
+export declare let meetingService: MeetingServiceApi;
+
+declare interface MeetingServiceApi {
+    state: MeetingState;
+    inMeeting(): boolean;
+    isPresenter(): boolean;
+    isVisitor(): boolean;
+    isFollowingVisitor(): boolean;
+    isUnfollowingVisitor(): boolean;
+    getInvitationLink(): string;
+}
+
+declare interface MeetingState {
+    meetingId: string;
+    presenterId: number;
+    status: MeetingStatus;
+    startTime: number;
+    peopleCount: number;
+    forceFollow: boolean;
+    clickShareMode: ShareMode;
+    cursorShareMode: ShareMode;
+    selfFollow: boolean;
+}
+
+declare enum MeetingStatus {
+    PENDING = "PENDING",
+    PROGRESSING = "PROGRESSING",
+    ENDED = "ENDED",
+    CANCELED = "CANCELED",
+    BANNED = "BANNED"
+}
+
+declare class MenuLine {
+    options: MenuLineCreateOptions;
+    id: string;
+    type: MenuLineType;
+    text: string;
+    tip: string;
+    icon: FunctionComponent | undefined;
+    view: FunctionComponent | undefined;
+    color: string;
+    disabled: boolean;
+    shortcut: string;
+    onClick: (e: MouseEvent_2) => void;
+    onMouseOver: (e: MouseEvent_2) => void;
+    onMouseOut: (e: MouseEvent_2) => void;
+    closeAllOnClick: boolean;
+    checkboxDefaultValue: boolean;
+    onCheckboxChange: (value: boolean) => void;
+    sub: ContextMenuCreateOptions | undefined;
+    createTime: Date;
+    constructor(options: MenuLineCreateOptions, id: string, type?: MenuLineType, text?: string, tip?: string, icon?: FunctionComponent | undefined, view?: FunctionComponent | undefined, color?: string, disabled?: boolean, shortcut?: string, onClick?: (e: MouseEvent_2) => void, onMouseOver?: (e: MouseEvent_2) => void, onMouseOut?: (e: MouseEvent_2) => void, closeAllOnClick?: boolean, checkboxDefaultValue?: boolean, onCheckboxChange?: (value: boolean) => void, sub?: ContextMenuCreateOptions | undefined, // 子菜单项
+    createTime?: Date);
+    static fromOptions(id: string, options: MenuLineCreateOptions): MenuLine;
+}
+
+declare interface MenuLineCreateOptions {
+    id?: string;
+    type?: MenuLineType;
+    text?: string;
+    tip?: string;
+    icon?: FunctionComponent;
+    view?: FunctionComponent;
+    color?: string;
+    disabled?: boolean;
+    shortcut?: string;
+    onClick?: (e: MouseEvent_2) => void;
+    onMouseOver?: (e: MouseEvent_2) => void;
+    onMouseOut?: (e: MouseEvent_2) => void;
+    closeAllOnClick?: boolean;
+    checkboxDefaultValue?: boolean;
+    onCheckboxChange?: (value: boolean) => void;
+    sub?: ContextMenuCreateOptions;
+}
+
+declare enum MenuLineType {
+    BUTTON = "BUTTON",// 单个点击用按钮
+    DIVIDER = "DIVIDER",// 分割线
+    CHECKBOX = "CHECKBOX",// 单个可选中复选框
+    SUB = "SUB",// 二级菜单
+    VIEW = "VIEW"
+}
+
+declare class Message {
+    text: string;
+    type: MessageType;
+    duration: number;
+    id: number;
+    show: boolean;
+    height: number;
+    opacity: number;
+    constructor(text: string, type: MessageType, duration: number, id: number);
+}
+
 declare type MessageLeaf = string;
 
+export declare let messageService: MessageServiceApi;
+
+declare interface MessageServiceApi {
+    messages: Message[];
+    info: (text: string, translateNamespace?: string, duration?: number) => void;
+    success: (text: string, translateNamespace?: string, duration?: number) => void;
+    warning: (text: string, translateNamespace?: string, duration?: number) => void;
+    error: (text: string, translateNamespace?: string, duration?: number) => void;
+    showWithTranslate: (text: string, type: MessageType, translateNamespace: string, duration: number) => void;
+    show: (text: string, type: MessageType, duration?: number) => void;
+}
+
 declare interface MessageTree {
     [key: string]: MessageTree | MessageLeaf;
 }
 
+declare type MessageType = 'info' | 'warning' | 'error' | 'success';
+
+declare type MixView<T extends Attributes | null = null> = string | FunctionComponent<T>;
+
 declare type NamespaceSubscriber = (namespaces: string[]) => void;
 
-declare type Translator = (strings: TemplateStringsArray, ...values: unknown[]) => string;
+declare type NativeAnyEventSubscriber = (e: Event | null) => void;
+
+declare type NativeDragEventSubscriber = (e: DragEvent) => void;
+
+export declare let nativeEventService: NativeEventServiceApi;
+
+declare interface NativeEventServiceApi {
+    subscribeClick(subscriber: NativeMouseEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeClick(subscriber: NativeMouseEventSubscriber): void;
+    subscribeContextMenu(subscriber: NativeMouseEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeContextMenu(subscriber: NativeMouseEventSubscriber): void;
+    subscribeDoubleClick(subscriber: NativeMouseEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeDoubleClick(subscriber: NativeMouseEventSubscriber): void;
+    subscribeDrag(subscriber: NativeDragEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeDrag(subscriber: NativeDragEventSubscriber): void;
+    subscribeDrop(subscriber: NativeDragEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeDrop(subscriber: NativeDragEventSubscriber): void;
+    subscribeWheel(subscriber: NativeWheelEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeWheel(subscriber: NativeWheelEventSubscriber): void;
+    subscribePointerDown(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribePointerDown(subscriber: NativePointerEventSubscriber): void;
+    subscribePointerMove(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribePointerMove(subscriber: NativePointerEventSubscriber): void;
+    subscribePointerUp(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribePointerUp(subscriber: NativePointerEventSubscriber): void;
+    subscribePointerCancel(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribePointerCancel(subscriber: NativePointerEventSubscriber): void;
+    subscribePointerEnter(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribePointerEnter(subscriber: NativePointerEventSubscriber): void;
+    subscribePointerLeave(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribePointerLeave(subscriber: NativePointerEventSubscriber): void;
+    subscribeKeyDown(subscriber: NativeKeyboardEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeKeyDown(subscriber: NativeKeyboardEventSubscriber): void;
+    subscribeKeyUp(subscriber: NativeKeyboardEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeKeyUp(subscriber: NativeKeyboardEventSubscriber): void;
+    subscribeKeyDownExceptInput(subscriber: NativeKeyboardEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeKeyDownExceptInput(subscriber: NativeKeyboardEventSubscriber): void;
+    subscribeKeyUpExceptInput(subscriber: NativeKeyboardEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeKeyUpExceptInput(subscriber: NativeKeyboardEventSubscriber): void;
+    subscribeFocus(subscriber: NativeFocusEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeFocus(subscriber: NativeFocusEventSubscriber): void;
+    subscribeBlur(subscriber: NativeFocusEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeBlur(subscriber: NativeFocusEventSubscriber): void;
+    subscribeScroll(subscriber: NativeUIEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeScroll(subscriber: NativeUIEventSubscriber): void;
+    subscribeResize(subscriber: NativeAnyEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeResize(subscriber: NativeAnyEventSubscriber): void;
+}
+
+declare interface NativeEventSubscribeOption {
+    self?: boolean;
+    once?: boolean;
+    capture?: boolean;
+}
+
+declare type NativeFocusEventSubscriber = (e: FocusEvent) => void;
+
+declare type NativeKeyboardEventSubscriber = (e: KeyboardEvent) => void;
+
+declare type NativeMouseEventSubscriber = (e: MouseEvent) => void;
+
+declare type NativePointerEventSubscriber = (e: PointerEvent) => void;
+
+declare type NativeUIEventSubscriber = (e: UIEvent) => void;
+
+declare type NativeWheelEventSubscriber = (e: WheelEvent) => void;
+
+declare interface NodeMaterialInfo {
+    nid: string;
+    fid: string;
+    material: NodeMaterial;
+}
+
+declare interface NodePair {
+    nid: string;
+    uniqueId: number;
+    node: Node_2;
+}
+
+declare interface OssUploadInstance {
+    fid: string;
+    file: File;
+    status: OssUploadInstanceStatus;
+    progress: number;
+    data?: unknown;
+}
+
+declare enum OssUploadInstanceStatus {
+    WAITING = "WAITING",
+    UPLOADING = "UPLOADING",
+    PAUSED = "PAUSED",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    CANCELED = "CANCELED"
+}
+
+export declare let ossUploadService: OssUploadServiceApi;
+
+declare interface OssUploadServiceApi {
+    instances: Map<string, OssUploadInstance>;
+    upload(file: File, fid?: string, mime?: string, hash?: string): Promise<void>;
+    pause(fid: string): boolean;
+    resume(fid: string): boolean;
+    cancel(fid: string): boolean;
+    get(fid: string): OssUploadInstance | undefined;
+    has(fid: string): boolean;
+    hasFile(file: File): boolean;
+    subscribe(subscriber: OssUploadServiceSubscriber): () => void;
+    unsubscribe(subscriber: OssUploadServiceSubscriber): void;
+    subscribeSingle(fid: string, subscriber: OssUploadServiceSubscriber): () => void;
+    unsubscribeSingle(fid: string, subscriber: OssUploadServiceSubscriber): void;
+}
+
+declare enum OssUploadServiceEventType {
+    START = "START",
+    PROGRESS = "PROGRESS",
+    PAUSE = "PAUSE",
+    RESUME = "RESUME",
+    UPLOADED = "UPLOADED",
+    FAILED = "FAILED",
+    CANCELED = "CANCELED"
+}
+
+declare type OssUploadServiceSubscriber = (type: OssUploadServiceEventType, ossUploadInstance: OssUploadInstance) => void;
+
+declare interface Page {
+    type: PageType;
+    mode: PageMode;
+    viewing: boolean;
+    pid: string;
+    sid: string;
+}
+
+declare enum PageMode {
+    DISPLAY = "DISPLAY",// 正常显示
+    FULL = "FULL",// 3D 场景全屏 - 隐藏所有 UI 元素
+    HP_BOX = "HP_BOX",// 全息投影盒 - 隐藏所有 UI 元素 - 且四摄像头渲染
+    VR = "VR",// VR 模式
+    MR = "MR"
+}
+
+declare enum PageType {
+    EDITOR = "EDITOR",
+    VIEWER = "VIEWER",
+    VISITOR = "VISITOR"
+}
+
+declare interface PluginConfig {
+    id: string;
+    url: string;
+    official?: boolean;
+    necessary?: boolean;
+    private?: boolean;
+    css?: boolean;
+    information: {
+        name: string;
+        icon?: FunctionComponent | string;
+        version?: string;
+        description?: string;
+    };
+}
+
+export declare let pluginContainerService: PluginContainerServiceApi;
+
+declare interface PluginContainerServiceApi {
+    plugins: Map<string, PluginInformation>;
+    addPlugin(plugin: BasePlugin): void;
+    removePlugin(plugin: BasePlugin): void;
+    openPlugin(plugin: IconPlugin): Promise<boolean>;
+    closePlugin(plugin: IconPlugin): Promise<boolean>;
+    closeDrawerPluginByPosition(position: IconPluginPosition): Promise<boolean>;
+}
+
+declare enum PluginEventType {
+    ADD = "ADD",
+    INSTALL = "INSTALL",
+    ENABLE = "ENABLE",
+    OPEN = "OPEN",
+    CLOSE = "CLOSE",
+    DISABLE = "DISABLE",
+    UNINSTALL = "UNINSTALL",
+    DEBUG = "DEBUG"
+}
+
+declare interface PluginInformation {
+    plugin: BasePlugin;
+    root?: Root;
+    iconButton?: HTMLSpanElement;
+}
+
+export declare let pluginService: PluginServiceApi;
+
+declare interface PluginServiceApi {
+    /**
+     * 是否为精简输出模式 不会针对每一个插件输出详细信息 （默认为 true）
+     */
+    DETAILED_LOG_MODE: boolean;
+    /**
+     * 所有已添加的插件状态
+     */
+    plugins: Map<string, PluginState>;
+    createPreLoadedHook(id: string): void;
+    completePreLoadedHook(id: string): void;
+    createPreRenderedHook(id: string): void;
+    completePreRenderedHook(id: string): void;
+    /**
+     * 获取插件状态
+     *
+     * @param id  插件 ID
+     *
+     * @returns  插件状态 没有找到则返回 undefined
+     */
+    get(id: string): PluginState | undefined;
+    /**
+     * 订阅插件服务事件 详情请见 {@link PluginServiceSubscriber}
+     *
+     * @param subscriber  订阅者
+     *
+     * @returns 取消订阅函数
+     */
+    subscribe(subscriber: PluginServiceSubscriber): () => void;
+    /**
+     * 取消订阅插件服务事件
+     *
+     * @param subscriber  订阅者
+     */
+    unsubscribe(subscriber: PluginServiceSubscriber): void;
+    /**
+     * 添加插件
+     *
+     * @param config  插件配置
+     */
+    add(config: PluginConfig): Promise<boolean>;
+    /**
+     * 安装插件
+     *
+     * @param plugin  插件实例
+     */
+    install(plugin: BasePlugin): Promise<void>;
+    /**
+     * 启用插件
+     *
+     * @param id  插件 ID
+     */
+    enable(id: string): Promise<void>;
+    /**
+     * 打开插件 (侧栏中的可开启项)
+     *
+     * @param id  插件 ID
+     */
+    open(id: string): Promise<void>;
+    /**
+     * 关闭插件
+     *
+     * @param id  插件 ID
+     */
+    close(id: string): Promise<void>;
+    /**
+     * 禁用插件
+     *
+     * @param id  插件 ID
+     */
+    disable(id: string): Promise<void>;
+    /**
+     * 卸载插件
+     *
+     * @param id  插件 ID
+     */
+    uninstall(id: string): Promise<void>;
+    waitInstall(id: string): Promise<void>;
+    waitEnable(id: string): Promise<void>;
+    isOpenablePlugin(type: PluginType): boolean;
+    isSideBarPlugin(type: PluginType): boolean;
+    isViewPlugin(type: PluginType): boolean;
+}
+
+/**
+ * 插件服务订阅者
+ *
+ * @param id 插件id
+ * @param type 事件类型
+ */
+declare type PluginServiceSubscriber = (id: string, type: PluginEventType) => void;
+
+declare interface PluginState {
+    instance?: BasePlugin;
+    element?: HTMLScriptElement;
+    styleElement?: HTMLLinkElement;
+    installed: boolean;
+    enabled: boolean;
+    debug?: boolean;
+}
+
+declare enum PluginType {
+    BUTTON = "BUTTON",
+    SWITCH = "SWITCH",
+    DRAWER = "DRAWER",
+    DIALOG = "DIALOG",
+    CONTENT = "CONTENT",
+    WINDOW = "WINDOW",
+    SERVICE = "SERVICE"
+}
+
+export declare let ProgressBar: FunctionComponent<ProgressBarProps>;
+
+declare interface ProgressBarProps extends default_2.HTMLAttributes<HTMLDivElement> {
+    value?: number;
+    indeterminate?: boolean;
+    slowTransition?: boolean;
+    innerClassName?: string;
+}
+
+export declare let ResourcePreview: FunctionComponent<ResourcePreviewProps>;
+
+declare interface ResourcePreviewProps extends DivProps {
+    className?: string;
+    mime?: string;
+    preview?: string;
+}
+
+export declare let resourceService: ResourceServiceApi;
+
+declare interface ResourceServiceApi {
+    PREVIEW_IMAGE_WIDTH: number;
+    PREVIEW_IMAGE_HEIGHT: number;
+    dragState: {
+        fid: string;
+        data: FileData | null;
+        x: number;
+        y: number;
+        offsetX: number;
+        offsetY: number;
+    };
+    upload(file: File, fid?: string): void;
+    uploadMulti(fileList: FileList | File[] | File | null | undefined, check?: boolean, fidList?: string[]): void;
+    addByOssUrl(ossUrl: string, name?: string, fid?: string, check?: boolean): Promise<string>;
+    generateDescribeAndPreview(file: File): Promise<[string, File | null]>;
+    generatePreviewFile(img: HTMLImageElement | HTMLVideoElement, name: string): Promise<File>;
+    generateId(): string;
+}
+
+export declare let rsAudioService: RsAudioServiceApi;
+
+declare interface RsAudioServiceApi {
+    processStepAudioMap(step: StoredRhineVar<RvStep>): void;
+    fadeOutAndPauseAllAudio(): void;
+    processAudioMap(audioMap: RvAudio | undefined, idKey: string): void;
+}
+
+export declare let rsClick: RsClickApi;
+
+declare interface RsClickApi {
+    simplifyDoneList(delay: number): void;
+    show(position: V3, color: string, timestamp: number, duration?: number, id?: string): void;
+}
+
+export declare let RsdButton: FunctionComponent<RsdButtonProps>;
+
+declare interface RsdButtonProps extends DivProps {
+    onClick: MouseEventHandler<HTMLDivElement>;
+    dashed?: boolean;
+    text: string;
+    tip?: string;
+    icon?: string;
+    iconSize?: number;
+    single?: boolean;
+}
+
+export declare let RsdCheckableButton: FunctionComponent<RsdCheckableButtonProps>;
+
+declare interface RsdCheckableButtonProps extends DivPropsSimple {
+    value: boolean;
+    onChange: (value: boolean) => void;
+    label: string;
+    className?: string;
+    theme?: string;
+    children?: ReactNode;
+}
+
+export declare let RsdCheckbox: FunctionComponent<RsdCheckboxProps>;
+
+declare interface RsdCheckboxProps extends DivPropsSimple {
+    value: boolean;
+    onChange: (value: boolean) => void;
+    label: string;
+    className?: string;
+    theme?: string;
+}
+
+export declare let RsdColor: FunctionComponent<RsdColorProps>;
+
+declare interface RsdColorProps extends DivPropsSimple {
+    value: string;
+    onChange: (value: string) => void;
+    label: string;
+    disableAlpha?: boolean;
+    className?: string;
+    theme?: string;
+}
+
+export declare let RsdFileSelect: FunctionComponent<RsdFileSelectProps>;
+
+export declare let RsdFileSelectButton: FunctionComponent<RsdFileSelectProps>;
+
+declare interface RsdFileSelectProps extends DivPropsSimple {
+    label: string;
+    value: string;
+    onChange: (value: string) => void;
+    accept: string[];
+    tip?: string;
+    className?: string;
+    theme?: ThemeColor;
+}
+
+export declare let RsdInput: FunctionComponent<RsdInputProps>;
+
+declare interface RsdInputProps extends DivPropsSimple {
+    value: string;
+    onChange: (value: string) => void;
+    type?: 'text' | 'number' | 'password';
+    placeholder?: string;
+    className?: string;
+    theme?: string;
+    rows?: number;
+    maxLength?: number;
+}
+
+export declare let RsdMentions: FunctionComponent<RsdMentionsProps>;
+
+declare interface RsdMentionsProps extends DivPropsSimple {
+    value: string;
+    onChange: (value: string) => void;
+    type?: 'text' | 'number' | 'password';
+    placeholder?: string;
+    className?: string;
+    theme?: string;
+    rows?: number;
+}
+
+export declare let RsdNone: FunctionComponent<RsdNoneProps>;
+
+declare interface RsdNoneProps extends DivProps {
+    label: string;
+    className?: string;
+    theme?: string;
+}
+
+export declare let RsdNumber: FunctionComponent<RsdNumberProps>;
+
+export declare let RsdNumberList: FunctionComponent<RsdNumberListProps>;
+
+declare interface RsdNumberListProps extends DivProps {
+    style?: React.CSSProperties;
+    value: number[];
+    keys: string[];
+    onChangeIndex: (index: number, value: number | null) => void;
+    min?: number;
+    className?: string;
+    theme?: string;
+    shrink?: boolean;
+}
+
+declare interface RsdNumberProps extends DivPropsSimple {
+    value: number | null;
+    onChange: (value: number | null) => void;
+    label: string;
+    placeholder?: string;
+    className?: string;
+    theme?: string;
+    unit?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+
+export declare let RsdSelect: FunctionComponent<RsdSelectProps>;
+
+declare interface RsdSelectProps<ValueType = string> extends DivPropsSimple {
+    value: ValueType;
+    defaultValue?: ValueType;
+    options: {
+        value: ValueType;
+        label: string;
+    }[];
+    onChange: (value: ValueType) => void;
+    label: string;
+    className?: string;
+    theme?: string;
+    smallWidth?: boolean;
+}
+
+export declare let RsdSwitch: FunctionComponent<RsdSwitchProps>;
+
+declare interface RsdSwitchProps extends DivPropsSimple {
+    value: boolean;
+    onChange: (value: boolean) => void;
+    label: string;
+    className?: string;
+    theme?: string;
+}
+
+export declare let RsdTextarea: FunctionComponent<RsdInputProps>;
+
+export declare let RsdTitle: FunctionComponent<RsdTitleProps>;
+
+declare interface RsdTitleProps extends DivProps {
+    title: string;
+    className?: string;
+    tip?: string;
+    detail?: string;
+    mt?: boolean;
+}
+
+export declare let rsEnvironment: RsEnvironmentApi;
+
+declare interface RsEnvironmentApi {
+    mainCamera: ArcRotateCamera;
+    rightCamera: ArcRotateCamera;
+    backCamera: ArcRotateCamera;
+    leftCamera: ArcRotateCamera;
+    lights: Light[];
+    shadow: ShadowGenerator;
+    environmentTexture: CubeTexture;
+    STANDARD_MODE: boolean;
+    adjustCamera(models: AbstractMesh[] | AbstractMesh): void;
+    getCameraInfo(): {
+        target: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        alpha: number;
+        beta: number;
+        radius: number;
+    };
+    addShadows(meshes: AbstractMesh[] | AbstractMesh): void;
+    initLight(): void;
+    initFourCamera(camerasNode: TransformNode): void;
+    setActiveCamera(isFour: boolean): void;
+    normalizeCameraAngle(): void;
+    setCameraDistance(distance: number): void;
+    setBackgroundColor(color: Color3): void;
+    getPositionToCameraDistance(p: V3 | Vector3): number;
+}
+
+export declare let rsEnvironmentService: RsEnvironmentServiceApi;
+
+declare interface RsEnvironmentServiceApi {
+    updateEnvironment(path: RvPath, step: StoredRhineVar<RvStep>): void;
+    getCurrentCameraLocation(): RvCameraLocation;
+}
+
+export declare let rsLabelService: RsLabelServiceApi;
+
+declare interface RsLabelServiceApi {
+    labels: LabelInfo[];
+    updateClick(nid: string | null | undefined): void;
+    getLabel(nid: string): LabelInfo | null;
+    ensureLabel(nid: string, node: TransformNode_2 | null): LabelInfo;
+    removeLabel(nid: string): void;
+    updateLabelWithNid(nid: string, rvLabel: RvLabel): void;
+}
+
+export declare let rsLoopAnimationManager: RsLoopAnimationManagerApi;
+
+declare interface RsLoopAnimationManagerApi {
+    state: {
+        enableInEditorMode: boolean;
+    };
+    restartAnimation(nid: string, resetLocation: boolean): void;
+    startAllLoopAnimations(): void;
+    startAnimationLoop(nid: string, node: TransformNode, data: RvLoop, locationData: RvLocation): void;
+    stopAllLoopAnimations(resetLocation: boolean): void;
+    stopAnimation(nid: string): void;
+    makeTripAnimation(dis: number, speed: number, start: number, name: string, axis: string, fr: number): void;
+    makeSpinAnimation(value: number, start: number, name: string, axis: string, fr: number): void;
+    makeQuaternionAnimation(value: number, start: Vector3, name: string, axis: 'x' | 'y' | 'z', fr: number): void;
+}
+
+export declare let rsMaterialService: RsMaterialServiceApi;
+
+declare interface RsMaterialServiceApi {
+    updateMaterial(nid: string, mesh: AbstractMesh, path: string[] | RvPath, value: unknown, rvMaterial: RvMaterial): void;
+    updateGeneralMaterialSingle(mesh: AbstractMesh, path: RvPath, value: unknown): void;
+    updatePBRMaterialSingle(mesh: AbstractMesh, material: PBRMaterial, path: RvPath, value: unknown): void;
+    updateNodeMaterialSingle(material: NodeMaterial, path: RvPath, value: unknown, inputs: RvMaterialNodeInput[]): void;
+}
+
+declare interface RsModel {
+    mid: string;
+    progress: number;
+    status: RsModelStatus;
+    node?: Node_2;
+}
+
+export declare let rsModelService: RsModelServiceApi;
+
+declare interface RsModelServiceApi {
+    models: Map<string, RsModel>;
+    get(mid: string): RsModel | undefined;
+    has(mid: string): boolean;
+    remove(mid: string): boolean;
+    add(rsModel: RsModel): boolean;
+    load(mid: string): Promise<void>;
+    pause(mid: string): boolean;
+    resume(mid: string): boolean;
+    cancel(mid: string): boolean;
+    subscribe(subscriber: RsModelServiceSubscriber): () => void;
+    unsubscribe(subscriber: RsModelServiceSubscriber): void;
+    subscribeSingle(mid: string, subscriber: RsModelServiceSubscriber): () => void;
+    unsubscribeSingle(mid: string, subscriber: RsModelServiceSubscriber): void;
+    publish(mid: string, type: RsModelServiceEventType, rsModel: RsModel): void;
+    afterLoaded(mid: string, subscriber: (rsModel: RsModel) => void): void;
+    waitLoaded(mid: string): Promise<RsModel>;
+    /**
+     * 是否已经载入完成
+     *
+     * @param mid  模型 mid
+     *
+     * @returns  返回模型是否载入完成 模型不存在则返回 undefined
+     */
+    isLoaded(mid: string): boolean | undefined;
+}
+
+declare enum RsModelServiceEventType {
+    ADD = "ADD",
+    REMOVE = "REMOVE",
+    START = "START",
+    PROGRESS = "PROGRESS",
+    PAUSE = "PAUSE",
+    RESUME = "RESUME",
+    LOADED = "LOADED",
+    ERROR = "ERROR",
+    CANCELED = "CANCELED"
+}
+
+declare type RsModelServiceSubscriber = (type: RsModelServiceEventType, rsModel: RsModel) => void;
+
+declare enum RsModelStatus {
+    WAITING = "WAITING",
+    LOADING = "LOADING",
+    LOADED = "LOADED",
+    ERROR = "ERROR",
+    CANCELED = "CANCELED"
+}
+
+export declare let rsNodeMaterialManager: RsNodeMaterialManagerApi;
+
+declare interface RsNodeMaterialManagerApi {
+    materials: NodeMaterialInfo[];
+    has(nid: string): boolean;
+    add(nid: string, fid: string, material: NodeMaterial): void;
+    get(nid: string): NodeMaterialInfo | null;
+    set(nid: string, fid: string, material: NodeMaterial): void;
+    remove(nid: string): void;
+    waitFid(nid: string, fid: string): Promise<void>;
+    updateNodeMaterialTemplate(nid: string, fid: string, syncStateWhenCreate: boolean): Promise<boolean>;
+    uploadNodeMaterialTemplate(nid: string, fid: string, material: NodeMaterial): void;
+    nodeMaterialToFile(material: NodeMaterial): File;
+}
+
+export declare let rsNodeService: RsNodeServiceApi;
+
+declare interface RsNodeServiceApi {
+    nodePairs: NodePair[];
+    getInfoMapByNid(nid: string): NodePair | null;
+    getInfoMapByUniqueId(uniqueId: number): NodePair | null;
+    getNodeByNid(nid: string): Node_2 | null;
+    getMidByNid(nid: string): string | null;
+    getNidByUniqueId(uniqueId: number): string | null;
+    getFidByMid(mid: string): string | null;
+    getFidByNid(nid: string): string | null;
+    subscribeNodePairs(subscriber: (pairs: NodePair[]) => void): () => void;
+    unsubscribeNodePairs(subscriber: (pairs: NodePair[]) => void): void;
+}
+
+export declare let rss: Record<string, string>;
+
+export declare let rsSelection: RsSelectionApi;
+
+declare interface RsSelectionApi {
+    set(nid: string): void;
+    add(nid: string): void;
+    remove(nid: string): void;
+    clear(): void;
+    has(nid: string): boolean;
+    get(nid: string): RsSelectionNodeInfo | null;
+}
+
+declare interface RsSelectionMaterialInfo {
+    allNumber: number;
+    supportEditMaterialNumber: number;
+    hasGeometryNumber: number;
+    hasOtherMaterialNumber: number;
+    hasChildrenNumber: number;
+    isAbstractMeshNumber: number;
+}
+
+declare interface RsSelectionNodeInfo {
+    nid: string;
+    nodeName: string;
+    babylonNode: Node_2;
+    uniqueId: number;
+    mid: string;
+    modelLoadName: string;
+    rvModel: RvModel;
+    isTransformNode: boolean;
+    isAbstractMesh: boolean;
+    isMesh: boolean;
+    isCoordinateFlip: boolean;
+    isCoordinateRotation: boolean;
+    hasGeometry: boolean;
+    isRoot: boolean;
+    childrenNumber: number;
+    supportQuaternion: boolean;
+    animationNumber: number;
+    skeletonNumber: number;
+    hasMaterial: boolean;
+    isSupportMaterial: boolean;
+    supportEditMaterial: boolean;
+}
+
+export declare let rsSelectionService: RsSelectionServiceApi;
+
+declare interface RsSelectionServiceApi {
+    state: RsSelectionState;
+    changeBranchMode(value?: boolean, message?: boolean): void;
+    click: (nid?: string, ctrl?: boolean) => void;
+    set: (nid: string) => void;
+    add: (nid: string) => void;
+    remove: (nid: string) => void;
+    clear: () => void;
+    subscribe(subscriber: SelectedSubscriber): () => void;
+    unsubscribe(subscriber: SelectedSubscriber): void;
+    subscribeLast(subscriber: LastSubscriber): () => void;
+    unsubscribeLast(subscriber: LastSubscriber): void;
+}
+
+declare interface RsSelectionState {
+    highlight: HighLightInfo[];
+    selected: RsSelectionNodeInfo[];
+    last: RsSelectionNodeInfo | null;
+    branchMode: boolean;
+    materialInfo: RsSelectionMaterialInfo;
+}
+
+export declare let rsSeparateService: RsSeparateServiceApi;
+
+declare interface RsSeparateServiceApi {
+    get(nid: string, node?: Node_2): Promise<Material | null>;
+    getWithEnsureType(nid: string, rvMaterial: RvMaterial, node?: Node_2): Promise<Material | null>;
+}
+
+export declare let rsService: RsServiceApi;
+
+declare interface RsServiceApi {
+    canvas: HTMLCanvasElement | undefined;
+    scene: Scene | undefined;
+    engine: Engine | WebGPUEngine | undefined;
+    experience: WebXRDefaultExperience | null;
+    rendering: boolean;
+    isSupportWebXR(): boolean;
+    isWebXRInitialized(): boolean;
+    enterVR(onInitialize: () => void): Promise<void>;
+}
+
+export declare let rsTextureService: RsTextureServiceApi;
+
+declare interface RsTextureServiceApi {
+    get(fid: string): TextureInfo | null;
+    getWhiteTexture(): DynamicTexture;
+    getBlackTexture(): DynamicTexture;
+    add(fid: string): Promise<TextureInfo | null>;
+    getTexture(fid: string, without: number): Promise<Texture | null>;
+    pushTexture(fid: string, texture: Texture, url: string): TextureInfo;
+    remove(fid: string): void;
+}
+
+declare interface RvAnimation {
+    loop?: RvLoop;
+    embedded?: RvNative;
+}
+
+declare enum RvAttachType {
+    TEXTURE = "TEXTURE",
+    MATERIAL = "MATERIAL",
+    UV = "UV"
+}
+
+declare interface RvAttributes {
+    location?: RvLocation;
+    material?: RvMaterial;
+    label?: RvLabel;
+    animation?: RvAnimation;
+    code?: RvCode;
+}
+
+export declare let rvAttributesService: RvAttributesServiceApi;
+
+declare interface RvAttributesServiceApi {
+    forEach(callback: (attributes: RhineVarMap, sid: string) => void): void;
+    forEachNode(nid: string, callback: (attributes: RhineVarMap, sid: string) => void): void;
+    setToAllStep(nid: string, key: string, value: unknown): void;
+    get(sid: string): RecursiveMap<RvAttributes> | undefined;
+    getNode(sid: string, nid: string): StoredRhineVar<RvAttributes> | undefined;
+}
+
+declare interface RvAudio {
+    autoPlay: boolean;
+    fid: string;
+    loop: boolean;
+    speed: number;
+    volume: number;
+}
+
+declare interface RvAwareness {
+    clientId: number;
+    user: RvAwarenessUser;
+    device: RvAwarenessDevice;
+    sid: string;
+    meetingId: string;
+    selected: string[];
+    camera: RvCameraLocation;
+    clicks: RvAwarenessClick[];
+    window: RvAwarenessWindow;
+    cursor: V3;
+    openedDrawers: string[];
+}
+
+declare interface RvAwarenessClick {
+    position: V3;
+    timestamp: number;
+}
+
+declare interface RvAwarenessDevice {
+    platform: string;
+}
+
+declare interface RvAwarenessUser {
+    name: string;
+    color: string;
+    avatar: string;
+    uuid: string;
+}
+
+declare interface RvAwarenessWindow {
+    innerWidth: number;
+    innerHeight: number;
+}
+
+declare interface RvBase {
+    global: RvGlobal;
+    order: RhineVarArray<string>;
+    steps: RhineVarMap<RvStep>;
+    plugin: RvPlugin;
+    files: RhineVarMap<RvFile>;
+    resources: RhineVarMap<RvResource>;
+    scene: RvSceneNode;
+    models: RhineVarMap<RvModel>;
+    separate: RvSeparate;
+    history: RvHistory;
+    meetings: RhineVarMap<RvMeeting>;
+    version: RvVersion;
+}
+
+declare interface RvBasicConfig {
+    type: RvBasicType;
+    args?: Record<string, number>;
+    text?: string;
+}
+
+declare enum RvBasicType {
+    TEXT = "TEXT",
+    CUBE = "CUBE",
+    SPHERE = "SPHERE",
+    CONE = "CONE",
+    PRISM = "PRISM",
+    POLYHEDRON = "POLYHEDRON",
+    TORUS = "TORUS",
+    CYLINDER = "CYLINDER",
+    ICO_SPHERE = "ICO_SPHERE",
+    CAPSULE = "CAPSULE",
+    PLANE = "PLANE"
+}
+
+declare interface RvCamera {
+    enable: boolean;
+    location: RvCameraLocation;
+    config: {
+        easy: boolean;
+        distanceMin: number;
+        distanceMax: number;
+        fov: number;
+    };
+}
+
+declare interface RvCameraLocation {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target: V3;
+}
+
+declare interface RvCode {
+    jumpTargetOnClick: string;
+}
+
+export declare let rvCodeAttribute: RvCodeAttributeApi;
+
+declare interface RvCodeAttributeApi {
+    key: string;
+    defaultValue: RvCode;
+    generate(): RvCode;
+    ensure(nid: string): boolean;
+}
+
+declare interface RvConfiguration {
+    information: {
+        collapseDescription: boolean;
+        description: string;
+        favorite: boolean;
+        group: string;
+    };
+    interval: {
+        enable: boolean;
+        enter: number;
+        exit: number;
+    };
+    jump: {
+        delay: number;
+        onlyOnce: boolean;
+        target: string;
+    };
+    ui: {
+        theme: ThemeBackground;
+        enableStepChangeButton: boolean;
+        enableTopbar: boolean;
+        hideStep: boolean;
+        importantStep: boolean;
+    };
+    audio: RvAudio;
+    secondAudio: RvAudio;
+}
+
+declare interface RvEnvironment {
+    skybox: {
+        background: string;
+    };
+    light: {
+        intensity: number;
+        diffuseColor: string;
+        specularColor: string;
+    };
+    ground: {
+        opacityRate: number;
+        baseColor: string;
+        enableOnViewerMode: boolean;
+        enableOnEditorMode: boolean;
+    };
+    shadow: {
+        enable: boolean;
+        darkness: number;
+        blurOffset: number;
+        blurScale: number;
+        onlyOnGround: boolean;
+        normalBias: number;
+    };
+    camera: RvCamera;
+    fog: {
+        enable: boolean;
+        density: number;
+        color: string;
+    };
+}
+
+declare interface RvFile {
+    fid: string;
+    type: RvFileType;
+    name: string;
+    size: number;
+    mime: string;
+    hash?: string;
+    url: string;
+    createdAt: number;
+    updatedAt: number;
+    uploading?: boolean;
+    extra?: Record<string, unknown>;
+}
+
+export declare let rvFileService: RvFileServiceApi;
+
+declare interface RvFileServiceApi {
+    /**
+     * 存储所有文件的 RhineVar 对象
+     */
+    files: RecursiveMap<RvFile>;
+    /**
+     * 获取文件 不存在则返回 undefined
+     *
+     * @param fid  文件的 fid
+     */
+    get(fid: string): StoredRhineVar<RvFile> | undefined;
+    /**
+     * 通过 url 获取文件 不存在则返回 undefined
+     *
+     * @param url  文件的 url
+     */
+    getByUrl(url: string): StoredRhineVar<RvFile> | undefined;
+    /**
+     * 是否存在某个文件
+     *
+     * @param fid
+     */
+    has(fid: string): boolean;
+    /**
+     * 是否存在某个URL的文件
+     *
+     * @param url
+     */
+    hasUrl(url: string): boolean;
+    /**
+     * 添加一个文件
+     *
+     * @param file  文件内容
+     */
+    add(file: RvFile): Promise<StoredRhineVar<RvFile> | null>;
+    /**
+     * 通过url添加一个文件。
+     *
+     * 若该地址对应的文件已存在，则直接返回已存在的文件。
+     *
+     * @param url  URL
+     */
+    addByUrl(url: string): Promise<StoredRhineVar<RvFile> | null>;
+    /**
+     * 移除一个文件
+     *
+     * @param fid  文件的 fid
+     */
+    remove(fid: string): boolean;
+    /**
+     * 订阅文件服务相关事件
+     *
+     * @param subscriber
+     *
+     * @returns 取消订阅函数
+     */
+    subscribe(subscriber: RvFileServiceSubscriber): () => void;
+    /**
+     * 移除订阅
+     *
+     * @param subscriber  订阅者
+     */
+    unsubscribe(subscriber: RvFileServiceSubscriber): void;
+    /**
+     * 订阅文件服务相关事件
+     *
+     * @param fid  文件的 fid
+     * @param subscriber  订阅者
+     *
+     * @returns 取消订阅函数
+     */
+    subscribeSingle(fid: string, subscriber: RvFileServiceSubscriber): () => void;
+    /**
+     * 移除订阅
+     *
+     * @param fid  文件的 fid
+     * @param subscriber  订阅者
+     */
+    unsubscribeSingle(fid: string, subscriber: RvFileServiceSubscriber): void;
+    /**
+     * 生成 Id
+     */
+    generateId(): string;
+    /**
+     * 查找相同文件
+     *
+     * @param file  文件
+     *
+     * @returns 返回相同文件的 fid 如果没有则返回 null
+     */
+    findSame(file: File): Promise<string | null>;
+}
+
+declare enum RvFileServiceEventType {
+    ADD = "ADD",
+    REMOVE = "REMOVE"
+}
+
+declare type RvFileServiceSubscriber = (type: RvFileServiceEventType, fid: string, rvFile?: RecursiveObject<RvFile>) => void;
+
+declare enum RvFileType {
+    OSS = "OSS",
+    URL = "URL"
+}
+
+declare interface RvGlobal {
+    information: {
+        title: string;
+        description: string;
+        tags: string;
+    };
+    ui: {
+        theme: ThemeBackground;
+    };
+    playing: {
+        auto: boolean;
+        loop: boolean;
+        interval: number;
+    };
+    support: {
+        VR: boolean;
+        AR: boolean;
+        MR: boolean;
+        HP: boolean;
+    };
+}
+
+export declare let rvGlobalService: RvGlobalServiceApi;
+
+declare interface RvGlobalServiceApi {
+    state: StoredRhineVar<RvGlobal>;
+}
+
+declare interface RvHistory {
+    white: number;
+}
+
+declare interface RvLabel {
+    enable: boolean;
+    text: string;
+    alwaysShow: boolean;
+}
+
+export declare let rvLabelAttribute: RvLabelAttributeApi;
+
+declare interface RvLabelAttributeApi {
+    key: string;
+    defaultValue: RvLabel;
+    generate(): RvLabel;
+    ensure(nid: string): boolean;
+    get(sid: string, nid: string): RvLabel | undefined;
+}
+
+declare interface RvLocation {
+    position: V3;
+    rotation?: V3;
+    nearMode: boolean;
+    scale: V3;
+    rotationQuaternion?: V4;
+}
+
+export declare let rvLocationAttribute: RvLocationAttributeApi;
+
+declare interface RvLocationAttributeApi {
+    key: string;
+    defaultValue: RvLocation;
+    generate(node: Node_2 | undefined | null): RvLocation;
+    ensure(nid: string): boolean;
+}
+
+declare interface RvLoop {
+    rotationSpeed: V3;
+    rotationPivot: V3;
+    slideSpeed: V3;
+    slideDistance: V3;
+}
+
+export declare let rvLoopAttribute: RvLoopAttributeApi;
+
+declare interface RvLoopAttributeApi {
+    key: string;
+    defaultValue: RvLoop;
+    generate(): RvLoop;
+    ensure(nid: string): boolean;
+}
+
+declare interface RvMaterial {
+    general: RvMaterialGeneral;
+    preset: RvPresetType;
+    pbr?: RvMaterialPBR;
+    node?: RvMaterialNode;
+    texture: RvMaterialTexture;
+}
+
+export declare let rvMaterialAttribute: RvMaterialAttributeApi;
+
+declare interface RvMaterialAttributeApi {
+    key: string;
+    defaultPBRValue: RvMaterialPBR;
+    defaultNodeValue: RvMaterialNode;
+    defaultTextureValue: RvMaterialTexture;
+    defaultValue: RvMaterial;
+    generateTexture(textureMap?: Map<string, BaseTexture>, material?: PBRMaterial | NodeMaterial): RvMaterialTexture;
+    generatePBR(material?: PBRMaterial): RvMaterialPBR;
+    generateNode(material?: NodeMaterial): RvMaterialNode;
+    generate(nid: string): RvMaterial;
+    ensure(nid: string): boolean;
+}
+
+declare interface RvMaterialGeneral {
+    type: RvMaterialType;
+    isPickable: boolean;
+    visibility: number;
+    receiveShadows: boolean;
+    isExtracted: boolean;
+}
+
+declare interface RvMaterialNode {
+    fid: string;
+    inputs: RvMaterialNodeInput[];
+}
+
+declare interface RvMaterialNodeInput {
+    type: NodeMaterialBlockConnectionPointTypes;
+    key: string;
+    value: string | number;
+    range?: [number, number];
+}
+
+declare interface RvMaterialPBR {
+    basic: {
+        albedoColor: string;
+        metallic: number;
+        roughness: number;
+        emissiveColor: string;
+        alpha: number;
+    };
+    advance: {
+        reflectivityColor: string;
+        ambientColor: string;
+        indexOfRefraction: number;
+        metallicF0Factor: number;
+        reflectionColor: string;
+    };
+    coat: {
+        enable: boolean;
+        intensity: number;
+        roughness: number;
+        indexOfRefraction: number;
+        useRoughnessFromMainTexture: boolean;
+        clearCoatTexture: string;
+        roughnessTexture: string;
+        bumpTexture: string;
+        enableTint: boolean;
+        tintColor: string;
+        atDistance: number;
+        tintThickness: number;
+    };
+}
+
+declare interface RvMaterialTexture {
+    basic: {
+        albedoTexture: string;
+        metallicRoughnessTexture: string;
+        bumpTexture: string;
+        emissiveTexture: string;
+        opacityTexture: string;
+        ambientTexture: string;
+        reflectionTexture: string;
+        metallicReflectanceTexture: string;
+        refractionTexture: string;
+        reflectivityTexture: string;
+        microSurfaceTexture: string;
+        lightMapTexture: string;
+        detailMapTexture: string;
+        reflectanceTexture: string;
+        tintTexture: string;
+    };
+    extra: {
+        texture1: string;
+        texture2: string;
+        texture3: string;
+        texture4: string;
+    };
+}
+
+declare enum RvMaterialType {
+    NONE = "NONE",
+    PBR = "PBR",
+    STANDARD = "STANDARD",
+    NODE = "NODE",
+    OTHER = "OTHER",
+    TERRAIN = "TERRAIN",
+    FUR = "FUR",
+    WATER = "WATER",
+    LAVA = "LAVA",
+    SKY = "SKY",
+    BACKGROUND = "BACKGROUND",
+    MULTI = "MULTI",
+    SHADER = "SHADER"
+}
+
+declare interface RvMeeting {
+    meetingId: string;
+    status: MeetingStatus;
+    startTime: number;
+    current: RvMeetingCurrent;
+    statistic: RvMeetingStatistic;
+    endTime?: number;
+}
+
+declare interface RvMeetingCurrent {
+    presenterId: number;
+    state: {
+        peopleCount: number;
+    };
+    config: {
+        forceFollow: boolean;
+        clickShareMode: ShareMode;
+        cursorShareMode: ShareMode;
+    };
+    visitors: number[];
+}
+
+declare interface RvMeetingStatistic {
+    people: {
+        total: number;
+    };
+}
+
+declare interface RvModel {
+    mid: string;
+    name: string;
+    origin: RvModelOrigin;
+    fid?: string;
+    config?: RvBasicConfig | Record<string, unknown>;
+    node?: string;
+}
+
+declare enum RvModelOrigin {
+    BASIC = "BASIC",
+    PROVIDE = "PROVIDE",
+    UPLOAD = "UPLOAD"
+}
+
+export declare let rvModelService: RvModelServiceApi;
+
+declare interface RvModelServiceApi {
+    models: RecursiveMap<RvModel>;
+    uploadMulti(fileList: FileList | File[] | File | null | undefined, check?: boolean): Promise<void>;
+    addByFid(fid: string): string;
+    get(mid: string): RecursiveObject<RvModel> | undefined;
+    has(mid: string): boolean;
+    hasFid(fid: string): boolean;
+    add(model: RvModel): string;
+    remove(mid: string): boolean;
+    hasNode(mid: string): boolean;
+    setNode(mid: string, node: string): boolean;
+    generateId(): string;
+}
+
+declare interface RvNative {
+    enableAnimation: boolean;
+    playTime: number;
+    startFrame: number;
+    endFrame: number;
+    enableLoop: boolean;
+    speedRatio: number;
+}
+
+export declare let rvNativeAttribute: RvNativeAttributeApi;
+
+declare interface RvNativeAttributeApi {
+    key: string;
+    defaultValue: RvNative;
+    generate(nid: string): RvNative;
+    ensure(nid: string): boolean;
+}
+
+export declare let rvNodeMaterialAnalyzer: RvNodeMaterialAnalyzerApi;
+
+declare interface RvNodeMaterialAnalyzerApi {
+    /**
+     * 确保当前材质的 RhineVar 对象包含节点材质信息 若没有则添加
+     *
+     * @param material {StoredRhineVar<RvMaterial>} 需操作的 RhineVar 材质数据对象
+     * @Param nid {string}
+     * @returns {Promise<boolean>} 是否添加了材质
+     */
+    ensure(material: StoredRhineVar<RvMaterial>, nid: string): Promise<boolean>;
+}
+
+declare interface RvPlugin {
+    config: RhineVarMap<RvPluginConfig>;
+    debug: RhineVarMap<RvPluginDebug>;
+    order: string[];
+}
+
+declare interface RvPluginConfig {
+    id: string;
+    version: string | VersionPoint;
+    enable: {
+        viewer: EnableLevel;
+        editor: EnableLevel;
+    };
+}
+
+declare interface RvPluginDebug {
+    id: string;
+    name: string;
+    enable: boolean;
+    url: string;
+    hmr: string;
+    css: boolean;
+}
+
+declare enum RvPresetType {
+    NONE = "NONE",
+    METAL = "METAL",
+    PLASTIC = "PLASTIC",
+    GLASS = "GLASS",
+    WOOD = "WOOD",
+    MIRROR = "MIRROR",
+    CRYSTAL = "CRYSTAL",
+    PAINT = "PAINT",
+    CLOTH = "CLOTH"
+}
+
+declare interface RvResource {
+    fid: string;
+    name: string;
+    type: RvResourceType;
+    mime: string;
+    preview?: string;
+    description?: string;
+    from?: {
+        fid: string;
+        type: RvAttachType;
+        path: string;
+    };
+    createdAt: number;
+    updatedAt: number;
+    extra?: Record<string, unknown>;
+}
+
+export declare let rvResourceService: RvResourceServiceApi;
+
+declare interface RvResourceServiceApi {
+    /**
+     * 存储所有文件的 RhineVar 对象
+     */
+    resources: RecursiveMap<RvResource>;
+    /**
+     * 获取文件 不存在则返回 undefined
+     *
+     * @param fid  文件的 fid
+     */
+    get(fid: string): RecursiveObject<RvResource> | undefined;
+    /**
+     * 是否存在某个文件
+     *
+     * @param fid
+     */
+    has(fid: string): boolean;
+    /**
+     * 添加一个文件
+     *
+     * @param file  文件内容
+     */
+    add(file: RvResource): void;
+    /**
+     * 移除一个文件
+     *
+     * @param fid  文件的 fid
+     */
+    remove(fid: string): boolean;
+    /**
+     * 订阅文件服务相关事件
+     *
+     * @param subscriber
+     *
+     * @returns 取消订阅函数
+     */
+    subscribe(subscriber: RvResourceServiceSubscriber): () => void;
+    /**
+     * 移除订阅
+     *
+     * @param subscriber  订阅者
+     */
+    unsubscribe(subscriber: RvResourceServiceSubscriber): void;
+    /**
+     * 订阅文件服务相关事件
+     *
+     * @param fid  文件的 fid
+     * @param subscriber  订阅者
+     *
+     * @returns 取消订阅函数
+     */
+    subscribeSingle(fid: string, subscriber: RvResourceServiceSubscriber): () => void;
+    /**
+     * 移除订阅
+     *
+     * @param fid  文件的 fid
+     * @param subscriber  订阅者
+     */
+    unsubscribeSingle(fid: string, subscriber: RvResourceServiceSubscriber): void;
+    /**
+     * 生成 Id
+     */
+    generateId(): string;
+    /**
+     * 查找相同文件
+     *
+     * @param file  文件
+     *
+     * @returns 返回相同文件的 fid 如果没有则返回 null
+     */
+    findSame(file: File): Promise<string | null>;
+}
+
+declare enum RvResourceServiceEventType {
+    ADD = "ADD",
+    REMOVE = "REMOVE"
+}
+
+declare type RvResourceServiceSubscriber = (type: RvResourceServiceEventType, fid: string, rvResource?: RecursiveObject<RvResource>) => void;
+
+declare enum RvResourceType {
+    FILE = "FILE",
+    ATTACH = "ATTACH"
+}
+
+declare interface RvSceneNode {
+    nid: string;
+    children?: RvSceneNode[];
+}
+
+declare interface RvSeparate {
+    groups: RhineVarArray<RhineVarArray>;
+}
+
+declare interface RvStep {
+    name: string;
+    sid: string;
+    attributes: RhineVarMap;
+    configuration: RvConfiguration;
+    environment: RvEnvironment;
+}
+
+export declare let rvStepService: RvStepServiceApi;
+
+declare interface RvStepServiceApi {
+    order: RecursiveArray<string>;
+    steps: RecursiveMap<RvStep>;
+    get(sid: string): RecursiveObject<RvStep> | undefined;
+    add(from?: string, index?: number): string;
+    move(sid: string, to: number): boolean;
+    remove(sid: string): boolean;
+    getStepOptions(withDisable?: boolean): StepOptions;
+    getStepIndex(sid: string): number;
+    getStepByIndex(index: number): StoredRhineVar<RvStep> | undefined;
+    getCurrentStep(): StoredRhineVar<RvStep> | undefined;
+    generateId(): string;
+}
+
+declare interface RvVersion {
+    code: number;
+    label: string;
+}
+
+export declare let sceneService: SceneServiceApi;
+
+declare interface SceneServiceApi {
+    dragState: {
+        nid: string;
+        x: number;
+        y: number;
+        offsetX: number;
+        offsetY: number;
+    };
+}
+
+declare interface Screen_2 {
+    size: ScreenSize;
+    scale: number;
+    shadowAround: boolean;
+    focusMode: FocusMode;
+    showBabylonConsole: boolean;
+}
+
+declare enum ScreenSize {
+    XS = "XS",
+    SM = "SM",
+    MD = "MD",
+    LG = "LG",
+    XL = "XL"
+}
+
+export declare let ScrollBar: FunctionComponent<ScrollBarProps>;
+
+declare interface ScrollBarProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode | undefined;
+    className?: string;
+    innerClassName?: string;
+    barPaddingStart?: string;
+    barPaddingEnd?: string;
+}
+
+declare type SelectedSubscriber = (value: RsSelectionNodeInfo[]) => void;
+
+export declare let shadowAnimation: ShadowAnimationApi;
+
+declare interface ShadowAnimationApi {
+    play(data: {
+        enable?: boolean;
+        darkness?: number;
+        blurOffset?: number;
+        blurScale?: number;
+        onlyOnGround?: boolean;
+        normalBias?: number;
+    }, duration?: number, quickMode?: boolean): void;
+    enable(value: boolean, duration?: number, quickMode?: boolean): void;
+    darkness(value: number, duration?: number, quickMode?: boolean): void;
+    blurOffset(value: number, duration?: number, quickMode?: boolean): void;
+    blurScale(value: number, duration?: number, quickMode?: boolean): void;
+    onlyOnGround(value: boolean, duration?: number, quickMode?: boolean): void;
+    normalBias(value: number, duration?: number, quickMode?: boolean): void;
+}
+
+declare enum ShareMode {
+    NONE = "NONE",
+    SELF = "SELF",
+    ALL = "ALL"
+}
+
+export declare let skyboxAnimation: SkyboxAnimationApi;
+
+declare interface SkyboxAnimationApi {
+    play(data: {
+        background?: string;
+    }, duration?: number, quickMode?: boolean): void;
+    background(color: Color4 | Color3 | string, duration?: number, quickMode?: boolean): void;
+}
+
+export declare let sleep: (time: number) => Promise<void>;
+
+export declare let spaceService: SpaceServiceApi;
+
+declare interface SpaceServiceApi {
+    page: Page;
+    screen: Screen_2;
+    subscribeStepChange(subscriber: StepChangeSubscriber): void;
+    unsubscribeStepChange(subscriber: StepChangeSubscriber): void;
+    setScreenSize(size: ScreenSize): void;
+    isEditorPage(type?: PageType): boolean;
+    isBoxMode(mode?: PageMode): boolean;
+    isFullMode(mode?: PageMode): boolean;
+}
+
+declare type SpanProps = DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>;
+
+declare interface Status {
+    Authenticated: boolean;
+    DataSynchronized: boolean;
+    SyncInitialized: boolean;
+    RsInitialized: boolean;
+    AllInitialized: boolean;
+    PluginEnabled: boolean;
+    PluginPreLoaded: boolean;
+    FileLoaded: boolean;
+    ModelLoaded: boolean;
+    PluginPreRendered: boolean;
+    Rendered: boolean;
+    Shown: boolean;
+}
+
+declare type StatusChangeSubscriber = (value: boolean) => void;
+
+export declare let statusService: StatusServiceApi;
+
+declare interface StatusServiceApi {
+    status: Status;
+    subscribeAuthenticated(subscriber: StatusChangeSubscriber): () => void;
+    unsubscribeAuthenticated(subscriber: StatusChangeSubscriber): void;
+    afterAuthenticated(subscriber: StatusChangeSubscriber): void;
+    waitAuthenticated(): Promise<boolean>;
+    subscribeDataSynchronized(subscriber: StatusChangeSubscriber): () => void;
+    unsubscribeDataSynchronized(subscriber: StatusChangeSubscriber): void;
+    afterDataSynchronized(subscriber: StatusChangeSubscriber): void;
+    waitDataSynchronized(): Promise<boolean>;
+    subscribeSyncInitialized(subscriber: StatusChangeSubscriber): () => void;
+    unsubscribeSyncInitialized(subscriber: StatusChangeSubscriber): void;
+    afterSyncInitialized(subscriber: StatusChangeSubscriber): void;
+    waitSyncInitialized(): Promise<boolean>;
+    subscribeRsInitialized(subscriber: StatusChangeSubscriber): () => void;
+    unsubscribeRsInitialized(subscriber: StatusChangeSubscriber): void;
+    afterRsInitialized(subscriber: StatusChangeSubscriber): void;
+    waitRsInitialized(): Promise<boolean>;
+    subscribeAllInitialized(subscriber: StatusChangeSubscriber): () => void;
+    unsubscribeAllInitialized(subscriber: StatusChangeSubscriber): void;
+    afterAllInitialized(subscriber: StatusChangeSubscriber): void;
+    waitAllInitialized(): Promise<boolean>;
+    subscribePluginEnabled(subscriber: StatusChangeSubscriber): () => void;
+    unsubscribePluginEnabled(subscriber: StatusChangeSubscriber): void;
+    afterPluginEnabled(subscriber: StatusChangeSubscriber): void;
+    waitPluginEnabled(): Promise<boolean>;
+    subscribePluginPreLoaded(subscriber: StatusChangeSubscriber): () => void;
+    unsubscribePluginPreLoaded(subscriber: StatusChangeSubscriber): void;
+    afterPluginPreLoaded(subscriber: StatusChangeSubscriber): void;
+    waitPluginPreLoaded(): Promise<boolean>;
+    subscribeFileLoaded(subscriber: StatusChangeSubscriber): () => void;
+    unsubscribeFileLoaded(subscriber: StatusChangeSubscriber): void;
+    afterFileLoaded(subscriber: StatusChangeSubscriber): void;
+    waitFileLoaded(): Promise<boolean>;
+    subscribeModelLoaded(subscriber: StatusChangeSubscriber): () => void;
+    unsubscribeModelLoaded(subscriber: StatusChangeSubscriber): void;
+    afterModelLoaded(subscriber: StatusChangeSubscriber): void;
+    waitModelLoaded(): Promise<boolean>;
+    subscribePluginPreRendered(subscriber: StatusChangeSubscriber): () => void;
+    unsubscribePluginPreRendered(subscriber: StatusChangeSubscriber): void;
+    afterPluginPreRendered(subscriber: StatusChangeSubscriber): void;
+    waitPluginPreRendered(): Promise<boolean>;
+    subscribeRendered(subscriber: StatusChangeSubscriber): () => void;
+    unsubscribeRendered(subscriber: StatusChangeSubscriber): void;
+    afterRendered(subscriber: StatusChangeSubscriber): void;
+    waitRendered(): Promise<boolean>;
+    subscribeShown(subscriber: StatusChangeSubscriber): () => void;
+    unsubscribeShown(subscriber: StatusChangeSubscriber): void;
+    afterShown(subscriber: StatusChangeSubscriber): void;
+    waitShown(): Promise<boolean>;
+}
+
+declare type StepChangeSubscriber = (sid: string, step: StoredRhineVar<RvStep>, lastSid: string, lastStep: RvStep | undefined) => void;
+
+declare type StepOptions = {
+    label: string;
+    value: string;
+}[];
+
+declare type SupportAnimationTarget = Node_2 | Scene | Material | NodeMaterialBlock | ShadowGenerator;
+
+export declare let syncService: SyncServiceApi;
+
+declare interface SyncServiceApi {
+    state: StoredRhineVar<RvBase>;
+    clientId: number;
+    generateId(prefix: string): string;
+    reset(): boolean;
+}
+
+export declare let tAttributesService: TAttributesServiceApi;
+
+declare interface TAttributesServiceApi {
+    sid: string;
+    nid: string;
+    state: StoredRhineVar<RvAttributes> | null;
+    subscribe(subscriber: TAttributesSubscriber): () => void;
+    unsubscribe(subscriber: TAttributesSubscriber): void;
+    set<T>(path: string | RvPath, value: T): void;
+    get<T>(path: string | RvPath): T | null;
+}
+
+declare type TAttributesSubscriber = (type: TChangeType, path: RvPath, value: unknown, oldValue: unknown, sid: string, nid: string, nodeAttributes: StoredRhineVar<RvAttributes> | null) => void;
+
+declare enum TChangeType {
+    SYNC = "SYNC",
+    STEP = "STEP",
+    SELECT = "SELECT",
+    ADD = "ADD",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE"
+}
+
+declare interface TextureInfo {
+    fid: string;
+    localUrl: string;
+    texture: Texture;
+}
+
+declare enum ThemeBackground {
+    DEFAULT = "DEFAULT",
+    BACKGROUND = "BACKGROUND",
+    LIGHT = "LIGHT",
+    DARK = "DARK"
+}
+
+declare enum ThemeColor {
+    GREEN = "GREEN",
+    PURPLE = "PURPLE",
+    BLUE = "BLUE",
+    PINK = "PINK"
+}
+
+export declare let ThemeProvider: FunctionComponent<ThemeProviderProps>;
+
+declare interface ThemeProviderProps {
+    children?: React.ReactNode;
+    color?: ThemeColor;
+    background?: ThemeBackground;
+}
+
+export declare let themeService: ThemeServiceApi;
+
+declare interface ThemeServiceApi {
+    state: ThemeState;
+    isDarkTheme(): boolean;
+    updateBackground(): void;
+    updateBackgroundByColor(color: string): void;
+}
+
+declare enum ThemeShape {
+    GENERAL = "GENERAL",
+    RHINE = "RHINE"
+}
+
+declare interface ThemeState {
+    background: ThemeBackground;
+    color: ThemeColor;
+    shape: ThemeShape;
+}
+
+declare type Translator = (strings: TemplateStringsArray, ...values: unknown[]) => string;
+
+export declare let tStepService: TStepServiceApi;
+
+declare interface TStepServiceApi {
+    sid: string;
+    state: StoredRhineVar<RvStep>;
+    subscribe(subscriber: TSubscriber): () => void;
+    unsubscribe(subscriber: TSubscriber): void;
+    set(path: string | RvPath, value: unknown): void;
+    get(path: string | RvPath): unknown;
+    subscribeAttributes(subscriber: TAttributesSubscriber): () => void;
+    unsubscribeAttributes(subscriber: TAttributesSubscriber): void;
+}
+
+declare type TSubscriber = (type: TChangeType, path: RvPath, value: unknown, oldValue: unknown, sid: string) => void;
+
+export declare let UploadButtonAndList: FunctionComponent<UploadButtonAndListProps>;
+
+declare interface UploadButtonAndListProps {
+    uploadText: string;
+    accept: string[];
+    modelMode?: boolean;
+}
+
+declare type UseBase = <T = unknown>(path?: string) => {
+    state: T;
+    set: (key: string | RvPath, value: unknown) => void;
+    check: (key: string | RvPath) => void;
+};
+
+export declare let useBase: UseBase;
+
+declare interface UserAuth {
+    token: string;
+    refreshToken: string;
+    ip: string;
+    timestamp: number;
+}
+
+declare interface UserInfo {
+    uid: string;
+    name: string;
+    phone: string;
+    description: string;
+    headIcon: string;
+    permission: string;
+}
+
+export declare let userService: UserServiceApi;
+
+declare interface UserServiceApi {
+    auth: UserAuth;
+    info: UserInfo;
+    clear(): void;
+}
+
+declare type UseStepOptions = () => StepOptions;
+
+export declare let useStepOptions: UseStepOptions;
+
+declare type UseTAttributes = <T = unknown>(path?: string) => {
+    sid: string;
+    nid: string;
+    state: T | null;
+    set: (key: string | RvPath, value: unknown) => void;
+    check: (key: string | RvPath) => void;
+};
+
+export declare let useTAttributes: UseTAttributes;
+
+declare type UseTranslations = (namespace: string) => (key: string) => string;
+
+export declare let useTranslations: UseTranslations;
+
+declare type UseTStep = <T = unknown>(path?: string) => {
+    sid: string;
+    state: T;
+    set: (key: string | RvPath, value: unknown) => void;
+    check: (key: string | RvPath) => void;
+};
+
+export declare let useTStep: UseTStep;
+
+declare interface V3 {
+    x: number;
+    y: number;
+    z: number;
+}
+
+declare interface V4 {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+
+declare enum VersionPoint {
+    LATEST_STABLE = "LATEST_STABLE",
+    LATEST_NIGHTLY = "LATEST_NIGHTLY",
+    LATEST_CANARY = "LATEST_CANARY"
+}
 
 export { }