next-flow-interface 0.23.28 → 0.24.2

package/index.d.ts

@@ -0,0 +1,3041 @@
+import { AbstractMesh } from '@babylonjs/core';
+import { AddLocalDataOption } from 'next-flow-interface';
+import { AnchorProps } from 'next-flow-interface';
+import { Animation as Animation_2 } from '@babylonjs/core';
+import { AnimationEventHandler } from 'react';
+import { AnimationGroup } from '@babylonjs/core/Animations/animationGroup';
+import { AnimationGroup as AnimationGroup_2 } from '@babylonjs/core';
+import { AntCheckboxProps } from 'next-flow-interface';
+import { AntColorProps } from 'next-flow-interface';
+import { AntEmptyProps } from 'next-flow-interface';
+import { AntNumberProps } from 'next-flow-interface';
+import { AntSelectProps } from 'next-flow-interface';
+import { AntSwitchProps } from 'next-flow-interface';
+import { ArcRotateCamera } from '@babylonjs/core';
+import { AriaRole } from 'react';
+import { Attributes } from 'react';
+import { AttributeServiceApi } from 'next-flow-interface';
+import { AttributeType } from 'next-flow-interface';
+import { Awareness } from 'rhine-var';
+import { AwarenessChangeSubscriber } from 'next-flow-interface';
+import { AwarenessServiceApi } from 'next-flow-interface';
+import { BasePlugin } from 'next-flow-interface';
+import { BaseTexture } from '@babylonjs/core';
+import { BaseTexture as BaseTexture_2 } from '@babylonjs/core/Materials/Textures/baseTexture';
+import { BatchApplyProps } from 'next-flow-interface';
+import { BatchApplyServiceApi } from 'next-flow-interface';
+import { BatchApplySubscriber } from 'next-flow-interface';
+import { CameraConfigurationAnimationApi } from 'next-flow-interface';
+import { CameraLocationAnimationApi } from 'next-flow-interface';
+import { ClipboardEventHandler } from 'react';
+import { Color3 } from '@babylonjs/core';
+import { Color3 as Color3_2 } from '@babylonjs/core/Maths/math.color';
+import { Color4 } from '@babylonjs/core';
+import { CompositionEventHandler } from 'react';
+import { ContextMenu } from 'next-flow-interface';
+import { ContextMenuController } from 'next-flow-interface';
+import { ContextMenuCreateOptions } from 'next-flow-interface';
+import { ContextMenuServiceApi } from 'next-flow-interface';
+import { CSSProperties } from 'react';
+import { CSSResult } from 'lit';
+import { CubeTexture } from '@babylonjs/core';
+import { Dialog } from 'next-flow-interface';
+import { DialogCreateOptions } from 'next-flow-interface';
+import { DialogServiceApi } from 'next-flow-interface';
+import { DivProps } from 'next-flow-interface';
+import { DivPropsSimple } from 'next-flow-interface';
+import { DragEventHandler } from 'react';
+import { DynamicTexture } from '@babylonjs/core';
+import { EasyPropertyAnimationApi } from 'next-flow-interface';
+import { Engine } from '@babylonjs/core';
+import { EventName } from '@lit/react';
+import { FileProgressBarProps } from 'next-flow-interface';
+import { FirstLoadModelServiceApi } from 'next-flow-interface';
+import { FirstLoadModelServiceStatus } from 'next-flow-interface';
+import { FirstLoadModelServiceSubscriber } from 'next-flow-interface';
+import { FirstLoadServiceApi } from 'next-flow-interface';
+import { FirstLoadServiceStatus } from 'next-flow-interface';
+import { FirstLoadServiceSubscriber } from 'next-flow-interface';
+import { FocusEventHandler } from 'react';
+import { FogAnimationApi } from 'next-flow-interface';
+import { FormEventHandler } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { FunctionComponent } from 'react';
+import { Geometry } from '@babylonjs/core';
+import { GlobalAttributeSubscriber } from 'next-flow-interface';
+import { GroundAnimationApi } from 'next-flow-interface';
+import { HighLightInfo } from 'next-flow-interface';
+import { HistoryServiceApi } from 'next-flow-interface';
+import { HistoryServiceStateSubscriber } from 'next-flow-interface';
+import { HistoryServiceSubscriber } from 'next-flow-interface';
+import { HTMLAttributeAnchorTarget } from 'react';
+import { HTMLAttributeReferrerPolicy } from 'react';
+import { IAttribute } from 'next-flow-interface';
+import { IBaseAttribute } from 'next-flow-interface';
+import { IconPlugin } from 'next-flow-interface';
+import { IconPluginPosition } from 'next-flow-interface';
+import { IGlobalAttribute } from 'next-flow-interface';
+import { INodeAttribute } from 'next-flow-interface';
+import { InputBlock } from '@babylonjs/core';
+import { InternationalizationProviderProps } from 'next-flow-interface';
+import { InternationalizationServiceApi } from 'next-flow-interface';
+import { Intl as Intl_2 } from 'next-flow-interface';
+import { IParticleSystem } from '@babylonjs/core';
+import { IStepAttribute } from 'next-flow-interface';
+import { JSX } from 'react';
+import { Key } from 'react';
+import { KeyboardEventHandler } from 'react';
+import { LabelInfo } from 'next-flow-interface';
+import { LastSubscriber } from 'next-flow-interface';
+import { Light } from '@babylonjs/core';
+import { LightAnimationApi } from 'next-flow-interface';
+import { LitElement } from 'lit';
+import { LocalData } from 'next-flow-interface';
+import { LocalDataServiceApi } from 'next-flow-interface';
+import { LocalDataServiceEventType } from 'next-flow-interface';
+import { LocalDataServiceSubscriber } from 'next-flow-interface';
+import { Locale } from 'next-flow-interface';
+import { Locale as Locale_2 } from 'use-intl';
+import { LocalePrefix } from 'next-intl/routing';
+import { MainPortalProps } from 'next-flow-interface';
+import { Material } from '@babylonjs/core';
+import { MaterialSymbolOptions } from 'next-flow-interface';
+import { MaterialSymbolProps } from 'next-flow-interface';
+import { MeetingServiceApi } from 'next-flow-interface';
+import { MeetingState } from 'next-flow-interface';
+import { MeetingStatus } from 'next-flow-interface';
+import { Mesh } from '@babylonjs/core';
+import { Message } from 'next-flow-interface';
+import { MessageServiceApi } from 'next-flow-interface';
+import { MessageTree } from 'next-flow-interface';
+import { MessageType } from 'next-flow-interface';
+import { MixView } from 'next-flow-interface';
+import { MouseEventHandler } from 'react';
+import { MultipartUploadResult } from 'ali-oss';
+import { NamespaceSubscriber } from 'next-flow-interface';
+import { NativeAnyEventSubscriber } from 'next-flow-interface';
+import { NativeDragEventSubscriber } from 'next-flow-interface';
+import { NativeEventServiceApi } from 'next-flow-interface';
+import { NativeEventSubscribeOption } from 'next-flow-interface';
+import { NativeFocusEventSubscriber } from 'next-flow-interface';
+import { NativeKeyboardEventSubscriber } from 'next-flow-interface';
+import { NativeMouseEventSubscriber } from 'next-flow-interface';
+import { NativePointerEventSubscriber } from 'next-flow-interface';
+import { NativeUIEventSubscriber } from 'next-flow-interface';
+import { NativeWheelEventSubscriber } from 'next-flow-interface';
+import { NavigateOptions } from 'next/dist/shared/lib/app-router-context.shared-runtime';
+import { Node as Node_2 } from '@babylonjs/core';
+import { NodeAttributeTargetSubscriber } from 'next-flow-interface';
+import { NodeMaterial } from '@babylonjs/core';
+import { NodeMaterialBlockConnectionPointTypes } from '@babylonjs/core';
+import { NodeMaterialInfo } from 'next-flow-interface';
+import { NodePair } from 'next-flow-interface';
+import { Observable } from '@babylonjs/core/Misc/observable';
+import OSS from 'ali-oss';
+import { OssUploadInstance } from 'next-flow-interface';
+import { OssUploadServiceApi } from 'next-flow-interface';
+import { OssUploadServiceEventType } from 'next-flow-interface';
+import { OssUploadServiceSubscriber } from 'next-flow-interface';
+import { Page } from 'next-flow-interface';
+import { PageMode } from 'next-flow-interface';
+import { PageType } from 'next-flow-interface';
+import { PBRMaterial } from '@babylonjs/core';
+import { PluginConfig } from 'next-flow-interface';
+import { PluginConnectorApi } from 'next-flow-interface';
+import { PluginContainerServiceApi } from 'next-flow-interface';
+import { PluginInformation } from 'next-flow-interface';
+import { PluginServiceApi } from 'next-flow-interface';
+import { PluginServiceSubscriber } from 'next-flow-interface';
+import { PluginState } from 'next-flow-interface';
+import { PluginType } from 'next-flow-interface';
+import { PointerEventHandler } from 'react';
+import { PrefetchOptions } from 'next/dist/shared/lib/app-router-context.shared-runtime';
+import { ProgressBarProps } from 'next-flow-interface';
+import { Quaternion } from '@babylonjs/core';
+import { QueryParams } from 'next-intl/navigation';
+import { default as React_2 } from 'react';
+import { ReactEventHandler } from 'react';
+import { ReactNode } from 'react';
+import { ReactPortal } from 'react';
+import { ReactWebComponent } from '@lit/react';
+import { RecursiveArray } from 'rhine-var';
+import { RecursiveCrossRhineVar } from 'rhine-var';
+import { RecursiveMap } from 'rhine-var';
+import { RecursiveObject } from 'rhine-var';
+import { RedirectType } from 'next/navigation';
+import { Ref } from 'react';
+import { RefAttributes } from 'react';
+import { ResourcePreviewProps } from 'next-flow-interface';
+import { RsAudioServiceApi } from 'next-flow-interface';
+import { RsClickApi } from 'next-flow-interface';
+import { RsdButtonProps } from 'next-flow-interface';
+import { RsdCheckableButtonProps } from 'next-flow-interface';
+import { RsdCheckboxProps } from 'next-flow-interface';
+import { RsdColorProps } from 'next-flow-interface';
+import { RsdFileSelectProps } from 'next-flow-interface';
+import { RsdInputProps } from 'next-flow-interface';
+import { RsdMentionsProps } from 'next-flow-interface';
+import { RsdNoneProps } from 'next-flow-interface';
+import { RsdNumberListProps } from 'next-flow-interface';
+import { RsdNumberProps } from 'next-flow-interface';
+import { RsdSelectProps } from 'next-flow-interface';
+import { RsdSwitchProps } from 'next-flow-interface';
+import { RsdTargetInfoProps } from 'next-flow-interface';
+import { RsdTitleProps } from 'next-flow-interface';
+import { RsEnvironmentApi } from 'next-flow-interface';
+import { RsEnvironmentServiceApi } from 'next-flow-interface';
+import { RsLabelServiceApi } from 'next-flow-interface';
+import { RsLoopAnimationManagerApi } from 'next-flow-interface';
+import { RsMaterialServiceApi } from 'next-flow-interface';
+import { RsModel } from 'next-flow-interface';
+import { RsModelServiceApi } from 'next-flow-interface';
+import { RsModelServiceEventType } from 'next-flow-interface';
+import { RsModelServiceSubscriber } from 'next-flow-interface';
+import { RsNodeMaterialManagerApi } from 'next-flow-interface';
+import { RsNodeServiceApi } from 'next-flow-interface';
+import { RsSelectionMaterialInfo } from 'next-flow-interface';
+import { RsSelectionNodeInfo } from 'next-flow-interface';
+import { RsSelectionServiceApi } from 'next-flow-interface';
+import { RsSeparateServiceApi } from 'next-flow-interface';
+import { RsTextureServiceApi } from 'next-flow-interface';
+import { RvAudio } from 'next-flow-interface';
+import { RvAwareness } from 'next-flow-interface';
+import { RvBase } from 'next-flow-interface';
+import { RvBasic } from 'next-flow-interface';
+import { RvBasicAttributeApi } from 'next-flow-interface';
+import { RvBasicConfig } from 'next-flow-interface';
+import { RvCameraLocation } from 'next-flow-interface';
+import { RvCode } from 'next-flow-interface';
+import { RvCodeAttributeApi } from 'next-flow-interface';
+import { RvConfiguration } from 'next-flow-interface';
+import { RvEnvironment } from 'next-flow-interface';
+import { RvFile } from 'next-flow-interface';
+import { RvFileServiceApi } from 'next-flow-interface';
+import { RvFileServiceSubscriber } from 'next-flow-interface';
+import { RvGlobal } from 'next-flow-interface';
+import { RvGlobalServiceApi } from 'next-flow-interface';
+import { RvLabel } from 'next-flow-interface';
+import { RvLabelAttributeApi } from 'next-flow-interface';
+import { RvLocation } from 'next-flow-interface';
+import { RvLocationAttributeApi } from 'next-flow-interface';
+import { RvLoop } from 'next-flow-interface';
+import { RvLoopAttributeApi } from 'next-flow-interface';
+import { RvMaterial } from 'next-flow-interface';
+import { RvMaterialAttributeApi } from 'next-flow-interface';
+import { RvMaterialNode } from 'next-flow-interface';
+import { RvMaterialNodeInput } from 'next-flow-interface';
+import { RvMaterialPBR } from 'next-flow-interface';
+import { RvMaterialTexture } from 'next-flow-interface';
+import { RvMaterialType } from 'next-flow-interface';
+import { RvMeeting } from 'next-flow-interface';
+import { RvMeetingServiceApi } from 'next-flow-interface';
+import { RvModel } from 'next-flow-interface';
+import { RvModelServiceApi } from 'next-flow-interface';
+import { RvNative } from 'next-flow-interface';
+import { RvNativeAttributeApi } from 'next-flow-interface';
+import { RvNode } from 'next-flow-interface';
+import { RvNodeMaterialAnalyzerApi } from 'next-flow-interface';
+import { RvNodeServiceApi } from 'next-flow-interface';
+import { RvPath } from 'rhine-var';
+import { RvPlugin } from 'next-flow-interface';
+import { RvPluginConfig } from 'next-flow-interface';
+import { RvPluginDebug } from 'next-flow-interface';
+import { RvPresetType } from 'next-flow-interface';
+import { RvResource } from 'next-flow-interface';
+import { RvResourceServiceApi } from 'next-flow-interface';
+import { RvResourceServiceSubscriber } from 'next-flow-interface';
+import { RvSceneNode } from 'next-flow-interface';
+import { RvSceneNodeWithRelatedInfo } from 'next-flow-interface';
+import { RvSceneServiceApi } from 'next-flow-interface';
+import { RvSeparate } from 'next-flow-interface';
+import { RvStep } from 'next-flow-interface';
+import { RvStepServiceApi } from 'next-flow-interface';
+import { Scene } from '@babylonjs/core';
+import { SceneServiceApi } from 'next-flow-interface';
+import { Screen as Screen_2 } from 'next-flow-interface';
+import { ScreenSize } from 'next-flow-interface';
+import { ScrollBarProps } from 'next-flow-interface';
+import { SelectedSubscriber } from 'next-flow-interface';
+import { ShadowAnimationApi } from 'next-flow-interface';
+import { ShadowGenerator } from '@babylonjs/core';
+import { ShowAttributeContextMenuOptions } from 'next-flow-interface';
+import { SixDofDragBehavior } from '@babylonjs/core/Behaviors/Meshes/sixDofDragBehavior';
+import { Skeleton } from '@babylonjs/core';
+import { SpaceServiceApi } from 'next-flow-interface';
+import { SpanProps } from 'next-flow-interface';
+import { StandardMaterial } from '@babylonjs/core';
+import { Status } from 'next-flow-interface';
+import { StatusChangeSubscriber } from 'next-flow-interface';
+import { StatusServiceApi } from 'next-flow-interface';
+import { StepAttributeTargetSubscriber } from 'next-flow-interface';
+import { StepBlockSelectProps } from 'next-flow-interface';
+import { StepChangeSubscriber } from 'next-flow-interface';
+import { StepOptions } from 'next-flow-interface';
+import { StoredRhineVar } from 'rhine-var';
+import { SupportAnimationTarget } from 'next-flow-interface';
+import { SyncServiceApi } from 'next-flow-interface';
+import { TargetMultiNodeServiceApi } from 'next-flow-interface';
+import { TargetMultiNodeSubscriber } from 'next-flow-interface';
+import { TargetNodeServiceApi } from 'next-flow-interface';
+import { TargetNodeSubscriber } from 'next-flow-interface';
+import { TargetStepServiceApi } from 'next-flow-interface';
+import { TargetStepSubscriber } from 'next-flow-interface';
+import { TChangeType } from 'next-flow-interface';
+import { TemplateResult } from 'lit-html';
+import { Texture } from '@babylonjs/core';
+import { TextureBlock } from '@babylonjs/core';
+import { TextureInfo } from 'next-flow-interface';
+import { ThemeBackground } from 'next-flow-interface';
+import { ThemeColor } from 'next-flow-interface';
+import type { ThemeConfig } from 'antd';
+import { ThemeProviderProps } from 'next-flow-interface';
+import { ThemeServiceApi } from 'next-flow-interface';
+import { ThemeState } from 'next-flow-interface';
+import { ToggleEventHandler } from 'react';
+import { TouchEventHandler } from 'react';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { TransformNode as TransformNode_2 } from '@babylonjs/core';
+import { TransitionEventHandler } from 'react';
+import { TransparencyMode } from 'next-flow-interface';
+import { UIEventHandler } from 'react';
+import { UndoManager } from 'yjs';
+import { UploadButtonAndListProps } from 'next-flow-interface';
+import { UrlObject } from 'url';
+import { UserAuth } from 'next-flow-interface';
+import { UserInfo } from 'next-flow-interface';
+import { UserServiceApi } from 'next-flow-interface';
+import { UtilityLayerRenderer } from '@babylonjs/core/Rendering/utilityLayerRenderer';
+import { V3 } from 'next-flow-interface';
+import { Vector2 } from '@babylonjs/core';
+import { Vector3 } from '@babylonjs/core';
+import { ViewPlugin } from 'next-flow-interface';
+import { WebGPUEngine } from '@babylonjs/core';
+import type { WebXRDefaultExperience } from '@babylonjs/core/XR/webXRDefaultExperience';
+import { WheelEventHandler } from 'react';
+
+/* Excluded from this release type: add */
+
+/**
+ * @public
+ */
+export declare function Anchor(props: AnchorProps): JSX.Element;
+
+/**
+ * @public
+ */
+export declare class AnimationDuration {
+    constructor();
+    static BETWEEN: number;
+    static OPERATE: number;
+    static FIRST: number;
+    static IMMEDIATELY: number;
+    static RESET: number;
+}
+
+/* Excluded from this release type: AnimationLoopAttribute */
+
+/* Excluded from this release type: AnimationNativeAttribute */
+
+/**
+ * @public
+ */
+export declare function AntCheckbox(props: AntCheckboxProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function AntColor(props: AntColorProps): React_2.JSX.Element;
+
+/* Excluded from this release type: antdThemeBlue */
+
+/* Excluded from this release type: antdThemeBlueLight */
+
+/* Excluded from this release type: antdThemeGreen */
+
+/* Excluded from this release type: antdThemeGreenLight */
+
+/* Excluded from this release type: antdThemePink */
+
+/* Excluded from this release type: antdThemePinkLight */
+
+/* Excluded from this release type: antdThemePurple */
+
+/* Excluded from this release type: antdThemePurpleLight */
+
+/**
+ * @public
+ */
+export declare function AntEmpty(props: AntEmptyProps): JSX.Element;
+
+/**
+ * @public
+ */
+export declare function AntNumber(props: AntNumberProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function AntSelect<ValueType>(props: AntSelectProps<ValueType>): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function AntSwitch(props: AntSwitchProps): React_2.JSX.Element;
+
+/* Excluded from this release type: Api */
+
+/* Excluded from this release type: AskDontAskAgainState */
+
+/* Excluded from this release type: askUserDeleteModelFromAllStep */
+
+/* Excluded from this release type: AttachFileService */
+
+/**
+ * @public
+ */
+export declare class AttributeService implements AttributeServiceApi {
+    private static _instance;
+    static get instance(): AttributeService;
+    private constructor();
+    /** 黑名单 */
+    commonBlacklist: RvPath[];
+    nodeBlacklist: RvPath[];
+    stepBlacklist: RvPath[];
+    globalBlacklist: RvPath[];
+    /** 属性存储 */
+    nodeAttributes: NodeAttribute<any>[];
+    stepAttributes: StepAttribute<any>[];
+    globalAttributes: GlobalAttribute<any>[];
+    /** 注册属性 */
+    register<T extends object = never>(attribute: IAttribute<T>): void;
+    /** 通过路径精确匹配获取属性 */
+    get<T extends object = never>(type: AttributeType, path: RvPath | string): IAttribute<T> | undefined;
+    /** 通过路径获取 NodeAttribute */
+    getNodeAttribute<T extends object = never>(path: RvPath | string): INodeAttribute<T> | undefined;
+    /** 通过路径获取 StepAttribute */
+    getStepAttribute<T extends object = never>(path: RvPath | string): IStepAttribute<T> | undefined;
+    /** 通过路径获取 GlobalAttribute */
+    getGlobalAttribute<T extends object = never>(path: RvPath | string): IGlobalAttribute<T> | undefined;
+    private getBlacklistByType;
+    /** 检查路径是否在黑名单中 */
+    private isPathInBlacklist;
+    /** 根据类型获取属性列表，不传入类型的时候返回所有 */
+    getList(type?: AttributeType): IAttribute<any>[];
+    isPathConflict(type: AttributeType, path: RvPath): boolean;
+    createContainer(source: StoredRhineVar, path: RvPath): RecursiveMap<unknown>;
+}
+
+/**
+ * @public
+ */
+export declare class AutoPlayService {
+    private static _instance;
+    private currentTimeoutId;
+    static get instance(): AutoPlayService;
+    private constructor();
+    private initialize;
+    private fresh;
+    next(interval: number, loop: boolean): void;
+    private stopAutoPlay;
+    hasNextStep(loop: boolean): boolean;
+    tryNextStep(loop: boolean): true | undefined;
+}
+
+/**
+ * @public
+ */
+export declare class AwarenessService implements AwarenessServiceApi {
+    DEFAULT_UPDATE_INTERVAL: number;
+    private static _instance;
+    private heartbeatIntervalId;
+    private currentHeartbeatInterval;
+    static get instance(): AwarenessService;
+    private constructor();
+    name: string;
+    color: string;
+    static COLORS: string[];
+    awareness: Awareness | undefined;
+    states: Map<number, RvAwareness>;
+    private initialize;
+    private initializeInfo;
+    setLocalState(state?: RvAwareness): void;
+    setLocalStateCamera(state?: RvCameraLocation): void;
+    setLocalStateField(field: string, state: unknown): void;
+    getLocalState(): {
+        [x: string]: any;
+    } | null;
+    startUpdate(): void;
+    stopUpdate(): void;
+    setUpdateInterval(interval: number): void;
+    resetUpdateInterval(): void;
+    private changeSubscribers;
+    private publishChange;
+    subscribeChange(subscriber: AwarenessChangeSubscriber): () => void;
+    unsubscribeChange(subscriber: AwarenessChangeSubscriber): void;
+    getCurrentRvAwareness(): RvAwareness;
+    CLICK_RETENTION_PERIOD: number;
+    CLICK_MAX_COUNT: number;
+    addClick(position: V3): void;
+}
+
+/* Excluded from this release type: AxisGroup */
+
+/**
+ * @public
+ */
+export declare abstract class BaseAttribute<T extends object = never> implements IBaseAttribute<T> {
+    abstract type: AttributeType;
+    abstract path: RvPath;
+    defaultValue: T;
+    getPathString(): string;
+    isMyPath(path: string | RvPath): boolean;
+}
+
+/* Excluded from this release type: BaseGlobalAttribute */
+
+/* Excluded from this release type: BasicAnimation */
+
+/**
+ * @public
+ */
+export declare function BatchApply(props: BatchApplyProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare class BatchApplyService implements BatchApplyServiceApi {
+    private static _instance;
+    static get instance(): BatchApplyService;
+    _selected: string[];
+    private constructor();
+    get selected(): string[];
+    set selected(selected: string[]);
+    selectAll(): void;
+    unselectAll(): void;
+    isAllSelected(): boolean;
+    private subscribers;
+    private publish;
+    subscribe(subscriber: BatchApplySubscriber): () => void;
+    unsubscribe(subscriber: BatchApplySubscriber): void;
+    forEach(f: (rvStep: StoredRhineVar<RvStep>) => void): void;
+    forEachAttributes(f: (rvNode: StoredRhineVar<RvNode>) => void): void;
+}
+
+/* Excluded from this release type: builtInPluginFactory */
+
+/* Excluded from this release type: ButtonRadio */
+
+/* Excluded from this release type: ButtonRadioProps */
+
+/**
+ * @public
+ */
+export declare class CameraConfigurationAnimation implements CameraConfigurationAnimationApi {
+    private static _instance;
+    static get instance(): CameraConfigurationAnimation;
+    private constructor();
+    play(data: CameraConfigurationData, 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;
+}
+
+/* Excluded from this release type: CameraConfigurationData */
+
+/**
+ * @public
+ */
+export declare class CameraLocationAnimation implements CameraLocationAnimationApi {
+    private static _instance;
+    static get instance(): CameraLocationAnimation;
+    private constructor();
+    cameraAnimation: AnimationGroup | null;
+    play(data: RvCameraLocation, duration?: number, enableNear?: boolean): void;
+    playEasy(data: RvCameraLocation, duration: number): void;
+    makeCameraAnimationsEase(data: RvCameraLocation, duration?: number): Animation_2[];
+}
+
+/* Excluded from this release type: Canvas */
+
+/**
+ * @public
+ */
+export declare function CheckboxLine(): JSX.Element;
+
+/* Excluded from this release type: Client */
+
+/* Excluded from this release type: CodeAttribute */
+
+/* Excluded from this release type: ConfigurationAttribute */
+
+/* Excluded from this release type: ContextMenuProps */
+
+/**
+ * @public
+ */
+export declare class ContextMenuService implements ContextMenuServiceApi {
+    private static _instance;
+    static get instance(): ContextMenuService;
+    private constructor();
+    private initialize;
+    private contextMenuId;
+    private menuLineId;
+    contextMenus: ContextMenu[];
+    create(options: ContextMenuCreateOptions): ContextMenuController;
+    private createMenuLine;
+    private newContextMenuId;
+    private newMenuLineId;
+    private createContextMenuController;
+    get(id: string): ContextMenu | undefined;
+    close(contextMenu: string | ContextMenu): Promise<boolean>;
+    closeAll(): Promise<number>;
+}
+
+/* Excluded from this release type: ContextMenuView */
+
+/* Excluded from this release type: CoordinateFlipFix */
+
+/* Excluded from this release type: Cover */
+
+/* Excluded from this release type: DEFAULT_NODE_MATERIAL_INPUTS */
+
+/* Excluded from this release type: DEFAULT_NODE_MATERIAL_JSON_FILE_URL */
+
+/* Excluded from this release type: defaultBase */
+
+/* Excluded from this release type: defaultPluginConfig */
+
+/* Excluded from this release type: defaultPluginOrder */
+
+/* Excluded from this release type: defaultStep */
+
+/* Excluded from this release type: DialogHolder */
+
+/**
+ * @public
+ */
+export declare class DialogService implements DialogServiceApi {
+    private static _instance;
+    static get instance(): DialogService;
+    private constructor();
+    create(options: DialogCreateOptions, show?: boolean): Promise<Dialog>;
+    private dialogId;
+    private newDialogId;
+    dialogs: Dialog[];
+    renderer: DialogViewRenderer;
+    confirm(options: {
+        title: string;
+        titleIcon?: FunctionComponent | string;
+        content?: string;
+        contentView?: FunctionComponent | string;
+        icon?: FunctionComponent | string;
+        theme?: ThemeColor;
+        confirmText?: string;
+        cancelText?: string;
+        leftMode?: boolean;
+        className?: string;
+        style?: object;
+        onConfirm?: () => void;
+        onCancel?: () => void;
+        onClose?: () => void;
+        closeOnOutsideClick?: boolean;
+        enableCloseButton?: boolean;
+    }, show?: boolean): Promise<boolean>;
+    input(options: {
+        title: string;
+        titleIcon?: FunctionComponent | string;
+        content?: string;
+        contentView?: FunctionComponent | string;
+        icon?: FunctionComponent | string;
+        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;
+        enableCloseButton?: boolean;
+    }, show?: boolean): Promise<string | undefined>;
+    get(id: string): Dialog | undefined;
+    open(dialog: Dialog | string): Promise<boolean>;
+    close(dialog: Dialog | string): Promise<boolean>;
+    closeAll(): Promise<number>;
+}
+
+/* Excluded from this release type: DialogViewRenderer */
+
+/**
+ * @public
+ */
+export declare function DrawerLoading(props: SpanProps): JSX.Element;
+
+/* Excluded from this release type: dummy3AnimationInit */
+
+/* Excluded from this release type: EasyPropertyAnimation */
+
+/* Excluded from this release type: EngineLoading */
+
+/**
+ * @public
+ */
+export declare function FileProgressBar(props: FileProgressBarProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare class FirstLoadModelService implements FirstLoadModelServiceApi {
+    private static _instance;
+    static get instance(): FirstLoadModelService;
+    private constructor();
+    status: FirstLoadModelServiceStatus;
+    rsModelList: RsModel[];
+    loadingNumber: number;
+    loadedNumber: number;
+    errorNumber: number;
+    canceledNumber: number;
+    totalSize: number;
+    loadedSize: number;
+    startTime: number;
+    start(): void;
+    private updateInfo;
+    private sizeMap;
+    private getLoadedSize;
+    private isLoading;
+    private subscribers;
+    subscribe(subscriber: FirstLoadModelServiceSubscriber): () => void;
+    unsubscribe(subscriber: FirstLoadModelServiceSubscriber): void;
+    private publish;
+}
+
+/**
+ * @public
+ */
+export declare class FirstLoadService implements FirstLoadServiceApi {
+    private static _instance;
+    static get instance(): FirstLoadService;
+    private constructor();
+    status: FirstLoadServiceStatus;
+    localDataList: LocalData[];
+    loadingNumber: number;
+    loadedNumber: number;
+    errorNumber: number;
+    canceledNumber: number;
+    totalSize: number;
+    loadedSize: number;
+    startTime: number;
+    start(): void;
+    private updateInfo;
+    private sizeMap;
+    private getLoadedSize;
+    private isLoading;
+    private subscribers;
+    subscribe(subscriber: FirstLoadServiceSubscriber): () => void;
+    unsubscribe(subscriber: FirstLoadServiceSubscriber): void;
+    private publish;
+}
+
+/**
+ * @public
+ */
+export declare function FlexGrow(props: {
+    value?: number;
+}): JSX.Element;
+
+/**
+ * @public
+ */
+export declare class FogAnimation implements FogAnimationApi {
+    private static _instance;
+    static get instance(): FogAnimation;
+    private constructor();
+    play(data: FogData, duration?: number, quickMode?: boolean): void;
+    enableAndDensity(enable: boolean, value: number, duration?: number, quickMode?: boolean): void;
+    color(color: Color3 | string, duration?: number, quickMode?: boolean): void;
+}
+
+/* Excluded from this release type: FogData */
+
+/* Excluded from this release type: fullDefaultNodeMaterial */
+
+/* Excluded from this release type: getAntdThemeConfig */
+
+/**
+ * @public
+ */
+export declare function getBlockDiagonalLength(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number;
+
+/**
+ * @public
+ */
+export declare function getNearestAngle(source: number, target: number): number;
+
+/**
+ * @public
+ */
+export declare function getNearestAngleVector3(source: Vector3, target: Vector3): Vector3;
+
+/* Excluded from this release type: getPlayingVideoDomByFid */
+
+/**
+ * @public
+ */
+export declare function getPointDistance(p1: Vector3, p2: Vector3): number;
+
+/* Excluded from this release type: GizmoManager */
+
+/**
+ * @public
+ */
+export declare abstract class GlobalAttribute<T extends object = never> extends BaseAttribute<T> implements IGlobalAttribute<T> {
+    type: AttributeType;
+    generate(): T;
+    initialize(): void;
+    isInitialized(): boolean;
+    mark(path: string | RvPath): void;
+    get(): RecursiveCrossRhineVar<T> | undefined;
+    set(path: string | RvPath, value: unknown): void;
+    read(): T | RecursiveCrossRhineVar<T>;
+    edit(path: string | RvPath, value: unknown): void;
+    editMany(list: [string | RvPath, unknown][]): void;
+    private unsubscribeMap;
+    subscribe(subscriber: GlobalAttributeSubscriber<T>): () => void;
+    unsubscribe(subscriber: GlobalAttributeSubscriber<T>): void;
+}
+
+/**
+ * @public
+ */
+export declare class GroundAnimation implements GroundAnimationApi {
+    private static _instance;
+    static get instance(): GroundAnimation;
+    private constructor();
+    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;
+}
+
+/**
+ * @public
+ */
+export declare function hasGeometry(mesh: AbstractMesh): boolean;
+
+/**
+ * @public
+ */
+export declare class HistoryService implements HistoryServiceApi {
+    private static ENABLE_LOG;
+    private static _instance;
+    static get instance(): HistoryService;
+    private constructor();
+    manager: UndoManager | null;
+    operate: string;
+    stateList: unknown[];
+    undo(from?: string): void;
+    redo(from?: string): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    pushState(state: unknown): void;
+    mark(operate: string, forceStop?: boolean): void;
+    markAttribute(attributePath: string | RvPath, path: string | RvPath, sidList?: string[], nidList?: string[]): void;
+    stop(): void;
+    clear(): void;
+    removeLast(operate?: string): boolean;
+    removeFirst(operate?: string): boolean;
+    clearUndoStack(): void;
+    clearRedoStack(): void;
+    private subscribers;
+    subscribe(subscriber: HistoryServiceSubscriber): () => void;
+    unsubscribe(subscriber: HistoryServiceSubscriber): void;
+    private publish;
+    private stateSubscribers;
+    subscribeState(subscriber: HistoryServiceStateSubscriber): () => void;
+    unsubscribeState(subscriber: HistoryServiceStateSubscriber): void;
+    private publishState;
+    white(): void;
+}
+
+/* Excluded from this release type: HoverManager */
+
+/* Excluded from this release type: IconButton */
+
+/* Excluded from this release type: IconButtonManager */
+
+/* Excluded from this release type: IconButtonProps */
+
+/**
+ * @public
+ */
+export declare const IMMEDIATELY_MODE_THRESHOLD_INTERVAL = 67;
+
+/* Excluded from this release type: initializeNodes */
+
+/**
+ * @public
+ */
+export declare function InternationalizationProvider(props: InternationalizationProviderProps): JSX.Element;
+
+/**
+ * @public
+ */
+export declare class InternationalizationService implements InternationalizationServiceApi {
+    private static _instance;
+    static get instance(): InternationalizationService;
+    private constructor();
+    ALL_SUPPORT: Locale[];
+    DEFAULT_SUPPORT: Locale;
+    locale: Locale;
+    messages: MessageTree;
+    load(messages: MessageTree, namespace?: string): boolean;
+    private intlCacheMap;
+    createIntl(namespace?: string): Intl_2;
+    hasIntlCached(namespace?: string): boolean;
+    deleteIntlCached(namespace?: string): boolean;
+    clearIntlCached(namespace?: string): void;
+    createIntlWithWait(namespace?: string): Promise<Intl_2>;
+    private subscribers;
+    subscribe(subscriber: NamespaceSubscriber): () => void;
+    unsubscribe(subscriber: NamespaceSubscriber): void;
+    private publish;
+    private hasNamespace;
+    wait(namespace: string): Promise<void>;
+}
+
+/**
+ * @public
+ */
+export declare function isAbstractMesh(node: Node_2): node is Mesh | AbstractMesh;
+
+/**
+ * @public
+ */
+export declare function isEqualColor3(c1: Color3, c2: Color3): boolean;
+
+/**
+ * @public
+ */
+export declare function isEqualColor3AndHex(c: Color3, hex: string): boolean;
+
+/**
+ * @public
+ */
+export declare function isEqualColor4(c1: Color4, c2: Color4): boolean;
+
+/**
+ * @public
+ */
+export declare function isMesh(node: Node_2): node is Mesh;
+
+/* Excluded from this release type: joinPath */
+
+/* Excluded from this release type: JoinPathOptions */
+
+/* Excluded from this release type: LabelAnimation */
+
+/* Excluded from this release type: LabelAttribute */
+
+/**
+ * @public
+ */
+export declare class LightAnimation implements LightAnimationApi {
+    private static _instance;
+    static get instance(): LightAnimation;
+    private constructor();
+    play(data: LightAnimationData, 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;
+}
+
+/**
+ * 定义光照动画数据接口
+ * @public
+ */
+declare interface LightAnimationData {
+    intensity?: number;
+    diffuseColor?: Color3 | string;
+    specularColor?: Color3 | string;
+}
+
+/* Excluded from this release type: Link */
+
+/* Excluded from this release type: loadBasic */
+
+/* Excluded from this release type: LoadedNodes */
+
+/* Excluded from this release type: loadImage */
+
+/* Excluded from this release type: LoadingProgress */
+
+/* Excluded from this release type: loadModel */
+
+/* Excluded from this release type: loadText */
+
+/* Excluded from this release type: loadTextFile */
+
+/* Excluded from this release type: loadVideo */
+
+/**
+ * @public
+ */
+export declare class LocalDataService implements LocalDataServiceApi {
+    private static _instance;
+    static get instance(): LocalDataService;
+    private constructor();
+    private initialize;
+    files: Map<string, LocalData>;
+    get(fid: string): LocalData | undefined;
+    has(fid: string): boolean;
+    add(option: AddLocalDataOption): LocalData;
+    /**
+     * 加载一个文件到本地
+     *
+     * @param fid - 文件在rv中的fid
+     * @param url - 文件的直接下载链接或者oss链接
+     * @Param mime - 文件类型
+     */
+    load(fid: string, url: string, mime?: string): Promise<LocalData>;
+    loadByFile(fid: string, file: File, mime?: string): Promise<LocalData>;
+    processAfterLoad(localData: LocalData): Promise<boolean>;
+    remove(fid: string): boolean;
+    pause(fid: string): boolean;
+    resume(fid: string): boolean;
+    cancel(fid: string): boolean;
+    getLocalUrl(fid: string): string;
+    releaseLocalUrl(fid: string): boolean;
+    private subscribers;
+    private singleSubscribers;
+    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>;
+    isLoaded(fid: string): boolean | undefined;
+}
+
+/* Excluded from this release type: LocationAnimation */
+
+/* Excluded from this release type: LocationAttribute */
+
+/**
+ * @public
+ */
+export declare function MainPortal(props: MainPortalProps): ReactPortal;
+
+/* Excluded from this release type: MaterialAnimation */
+
+/**
+ * @public
+ */
+export declare function MaterialSymbol(props: MaterialSymbolProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function materialSymbol(icon: string, options?: MaterialSymbolOptions): FunctionComponent<Record<string, never>>;
+
+/* Excluded from this release type: MeetingPresenter */
+
+/**
+ * @public
+ */
+export declare class MeetingService implements MeetingServiceApi {
+    private static _instance;
+    static get instance(): MeetingService;
+    private constructor();
+    private initialize;
+    static PRESENTER_UPDATE_INTERVAL: number;
+    static VISITOR_ANIMATION_DURATION: number;
+    static CLICK_STORAGE_TIME: number;
+    static CLICK_STORAGE_NUMBER: number;
+    static CLICK_ANIMATION_DURATION: number;
+    static CLICK_ALLOW_DELAY: number;
+    state: MeetingState;
+    setActiveMeeting(meetingId?: string): void;
+    getActiveRvMeeting(): StoredRhineVar<RvMeeting> | null;
+    private unsubscribeRvMeeting;
+    private unsubscribeAwarenessState;
+    IN_MEETING_STATUS: MeetingStatus[];
+    inMeeting(): boolean;
+    isPresenter(): boolean;
+    isVisitor(): boolean;
+    isFollowingVisitor(): boolean;
+    isUnfollowingVisitor(): boolean;
+    private setStateByData;
+    private subscribers;
+    subscribe(subscriber: MeetingStateSubscriber): () => void;
+    unsubscribe(subscriber: MeetingStateSubscriber): void;
+    private publish;
+    getInvitationLink(): string;
+}
+
+/**
+ * @public
+ */
+export declare type MeetingStateSubscriber = (state: MeetingState) => void;
+
+/* Excluded from this release type: MeetingVisitor */
+
+/**
+ * @public
+ */
+export declare class MessageService implements MessageServiceApi {
+    private static _instance;
+    static get instance(): MessageService;
+    private constructor();
+    messages: Message[];
+    private ids;
+    private lastShowTime;
+    private BASE_HEIGHT;
+    private MIN_INTERVAL;
+    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): Promise<void>;
+    show(text: string, type: MessageType, duration?: number): Promise<void>;
+}
+
+/**
+ * @public
+ */
+export declare class NativeEventService implements NativeEventServiceApi {
+    private static _instance;
+    static get instance(): NativeEventService;
+    PLAYER_ID: string;
+    CANVAS_ID: string;
+    private isNotInputElement;
+    private constructor();
+    private publish;
+    private clickSubscribers;
+    subscribeClick(subscriber: NativeMouseEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeClick(subscriber: NativeMouseEventSubscriber): void;
+    private publishClick;
+    private contextMenuSubscribers;
+    subscribeContextMenu(subscriber: NativeMouseEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeContextMenu(subscriber: NativeMouseEventSubscriber): void;
+    private publishContextMenu;
+    private doubleClickSubscribers;
+    subscribeDoubleClick(subscriber: NativeMouseEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeDoubleClick(subscriber: NativeMouseEventSubscriber): void;
+    private publishDoubleClick;
+    private dragSubscribers;
+    subscribeDrag(subscriber: NativeDragEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeDrag(subscriber: NativeDragEventSubscriber): void;
+    private publishDrag;
+    private dropSubscribers;
+    subscribeDrop(subscriber: NativeDragEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeDrop(subscriber: NativeDragEventSubscriber): void;
+    private publishDrop;
+    private wheelSubscribers;
+    subscribeWheel(subscriber: NativeWheelEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeWheel(subscriber: NativeWheelEventSubscriber): void;
+    private publishWheel;
+    private pointerDownSubscribers;
+    subscribePointerDown(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribePointerDown(subscriber: NativePointerEventSubscriber): void;
+    private publishPointerDown;
+    private pointerMoveSubscribers;
+    subscribePointerMove(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribePointerMove(subscriber: NativePointerEventSubscriber): void;
+    private publishPointerMove;
+    private pointerUpSubscribers;
+    subscribePointerUp(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribePointerUp(subscriber: NativePointerEventSubscriber): void;
+    private publishPointerUp;
+    private pointerCancelSubscribers;
+    subscribePointerCancel(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribePointerCancel(subscriber: NativePointerEventSubscriber): void;
+    private publishPointerCancel;
+    private pointerEnterSubscribers;
+    subscribePointerEnter(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribePointerEnter(subscriber: NativePointerEventSubscriber): void;
+    private publishPointerEnter;
+    private pointerLeaveSubscribers;
+    subscribePointerLeave(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribePointerLeave(subscriber: NativePointerEventSubscriber): void;
+    private publishPointerLeave;
+    private keyDownSubscribers;
+    subscribeKeyDown(subscriber: NativeKeyboardEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeKeyDown(subscriber: NativeKeyboardEventSubscriber): void;
+    private publishKeyDown;
+    private keyUpSubscribers;
+    subscribeKeyUp(subscriber: NativeKeyboardEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeKeyUp(subscriber: NativeKeyboardEventSubscriber): void;
+    private publishKeyUp;
+    private keyDownExceptInputSubscribers;
+    subscribeKeyDownExceptInput(subscriber: NativeKeyboardEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeKeyDownExceptInput(subscriber: NativeKeyboardEventSubscriber): void;
+    private publishKeyDownExceptInput;
+    private keyUpExceptInputSubscribers;
+    subscribeKeyUpExceptInput(subscriber: NativeKeyboardEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeKeyUpExceptInput(subscriber: NativeKeyboardEventSubscriber): void;
+    private publishKeyUpExceptInput;
+    private focusSubscribers;
+    subscribeFocus(subscriber: NativeFocusEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeFocus(subscriber: NativeFocusEventSubscriber): void;
+    private publishFocus;
+    private blurSubscribers;
+    subscribeBlur(subscriber: NativeFocusEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeBlur(subscriber: NativeFocusEventSubscriber): void;
+    private publishBlur;
+    private scrollSubscribers;
+    subscribeScroll(subscriber: NativeUIEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeScroll(subscriber: NativeUIEventSubscriber): void;
+    private publishScroll;
+    private resizeSubscribers;
+    subscribeResize(subscriber: NativeAnyEventSubscriber, option?: NativeEventSubscribeOption): () => void;
+    unsubscribeResize(subscriber: NativeAnyEventSubscriber): void;
+    private publishResize;
+}
+
+/* Excluded from this release type: nfBlockCssText */
+
+/* Excluded from this release type: nfBlockStyleSheet */
+
+/* Excluded from this release type: NfInput */
+
+/* Excluded from this release type: NfInputLit */
+
+/* Excluded from this release type: NfInputStyle */
+
+/* Excluded from this release type: NfSelect */
+
+/* Excluded from this release type: NfSelectLit */
+
+/* Excluded from this release type: NfSelectStyle */
+
+/**
+ * @public
+ */
+export declare abstract class NodeAttribute<T extends object = never> extends BaseAttribute<T> implements INodeAttribute<T> {
+    type: AttributeType;
+    private targetMultiNodeService;
+    get targetSid(): string;
+    get targetSidList(): string[];
+    get targetNid(): string;
+    get targetNidList(): string[];
+    generate(sid?: string, nid?: string): T;
+    multiGenerate(sidList?: string[], nidList?: string[]): Map<string, Map<string, T>>;
+    initialize(nid?: string): void;
+    isInitialized(nid?: string): boolean;
+    multiInitialize(nidList?: string[]): void;
+    isAllInitialized(nidList?: string[]): boolean;
+    private initializeOneStep;
+    mark(path: string | RvPath, sid?: string, nid?: string): void;
+    multiMark(path: string | RvPath, sidList?: string[], nidList?: string[]): void;
+    get(sid?: string, nid?: string): StoredRhineVar<T> | undefined;
+    multiGet(sidList?: string[], nidList?: string[]): Map<string, Map<string, StoredRhineVar<T>>>;
+    set(path: string | RvPath, value: unknown, sid?: string, nid?: string): void;
+    multiSet(path: string | RvPath, value: unknown, sidList?: string[], nidList?: string[]): void;
+    read(sid?: string, nid?: string): StoredRhineVar<T> | T;
+    multiRead(sidList?: string[], nidList?: string[]): Map<string, Map<string, StoredRhineVar<T> | T>>;
+    edit(path: string | RvPath, value: unknown, sid?: string, nid?: string): void;
+    multiEdit(path: string | RvPath, value: unknown, sidList?: string[], nidList?: string[]): void;
+    editMany(list: [string | RvPath, unknown][], sid?: string, nid?: string): void;
+    multiEditMany(list: [string | RvPath, unknown][], sidList?: string[], nidList?: string[]): void;
+    private unsubscribeMap;
+    subscribeTarget(subscriber: NodeAttributeTargetSubscriber<T>): () => void;
+    unsubscribeTarget(subscriber: NodeAttributeTargetSubscriber<T>): void;
+}
+
+/* Excluded from this release type: NodeMaterialAnimation */
+
+/**
+ * To [-PI, PI)
+ * @public
+ */
+export declare function normalizeAngle(angle: number): number;
+
+/**
+ * @public
+ */
+export declare function normalizeVector3Angle(vector: Vector3): Vector3;
+
+/* Excluded from this release type: OssController */
+
+/* Excluded from this release type: OssTask */
+
+/**
+ * @public
+ */
+export declare class OssUploadService implements OssUploadServiceApi {
+    private static _instance;
+    static get instance(): OssUploadService;
+    private constructor();
+    instances: Map<string, OssUploadInstance>;
+    get(fid: string): OssUploadInstance | undefined;
+    has(fid: string): boolean;
+    hasFile(file: File): boolean;
+    REMOVE_INTERVAL_AFTER_COMPLETED: number;
+    upload(file: File, fid?: string, mime?: string, hash?: string): Promise<void>;
+    pause(fid: string): boolean;
+    resume(fid: string): boolean;
+    cancel(fid: string): boolean;
+    private subscribers;
+    private singleSubscribers;
+    subscribe(subscriber: OssUploadServiceSubscriber): () => void;
+    unsubscribe(subscriber: OssUploadServiceSubscriber): void;
+    subscribeSingle(fid: string, subscriber: OssUploadServiceSubscriber): () => void;
+    unsubscribeSingle(fid: string, subscriber: OssUploadServiceSubscriber): void;
+    publish(fid: string, type: OssUploadServiceEventType, uploadInstance: OssUploadInstance): void;
+}
+
+/* Excluded from this release type: PbrMaterialAnimation */
+
+/* Excluded from this release type: play */
+
+/* Excluded from this release type: PlayConfig */
+
+/* Excluded from this release type: Player */
+
+/* Excluded from this release type: PlayerConfig */
+
+/* Excluded from this release type: PlayerService */
+
+/* Excluded from this release type: PluginApiProvider */
+
+/**
+ * @public
+ */
+export declare class PluginConnector implements PluginConnectorApi {
+    static _instance: PluginConnector;
+    static get instance(): PluginConnector;
+    private constructor();
+    install(plugin: BasePlugin): Promise<void>;
+}
+
+/* Excluded from this release type: PluginContainer */
+
+/**
+ * @public
+ */
+export declare class PluginContainerService implements PluginContainerServiceApi {
+    private static _instance;
+    private hoverManager;
+    private iconButtonManager;
+    private orderingManager;
+    plugins: Map<string, PluginInformation>;
+    private pluginContainer;
+    private leftButtonsHolder;
+    private leftTopButtonsHolder;
+    private leftBottomButtonsHolder;
+    private leftPluginsHolder;
+    private leftTopPluginHolder;
+    private leftBottomPluginHolder;
+    private contentPluginsHolder;
+    private rightPluginsHolder;
+    private rightTopPluginHolder;
+    private rightBottomPluginHolder;
+    private rightButtonsHolder;
+    private rightTopButtonsHolder;
+    private rightBottomButtonsHolder;
+    private windowPluginsHolder;
+    static get instance(): PluginContainerService;
+    private constructor();
+    private initialize;
+    private listenCloseDrawerPluginButton;
+    get pluginList(): BasePlugin[];
+    /**
+     * 一次性获取所有插件容器中的元素
+     */
+    private getAllElements;
+    addPlugin(plugin: BasePlugin): void;
+    removePlugin(plugin: BasePlugin): void;
+    private updateDrawersHolderClassName;
+    /**
+     * 更新 DrawerHolder 的内容，设置 weight，标题和描述信息
+     */
+    private updateDrawerHolderContent;
+    private updateDrawersHeight;
+    private closeDrawerHolder;
+    /**
+     * 根据位置获取 DrawerHolder
+     */
+    private getDrawerHolderByPosition;
+    openPlugin(plugin: IconPlugin): Promise<boolean>;
+    closePlugin(plugin: IconPlugin): Promise<boolean>;
+    closeDrawerPluginByPosition(position: IconPluginPosition): Promise<boolean>;
+    /**
+     * 创建图标按钮的私有方法
+     */
+    private createIconButton;
+    /**
+     * 创建视图插件
+     */
+    private createViewPlugin;
+    /**
+     * 移除视图插件
+     */
+    private removeViewPlugin;
+}
+
+/* Excluded from this release type: PluginDrawerProps */
+
+/* Excluded from this release type: PluginDrawerView */
+
+/* Excluded from this release type: pluginList */
+
+/* Excluded from this release type: PluginOrderingManager */
+
+/**
+ * @public
+ */
+export declare class PluginService implements PluginServiceApi {
+    private static _instance;
+    static get instance(): PluginService;
+    private constructor();
+    private initialize;
+    plugins: Map<string, PluginState>;
+    DETAILED_LOG_MODE: boolean;
+    INSTALL_TIMEOUT: number;
+    DEBUG_INSTALL_TIMEOUT: number;
+    private preLoadedMap;
+    private preRenderedMap;
+    private debugWebSocketMap;
+    createPreLoadedHook(id: string): void;
+    completePreLoadedHook(id: string): void;
+    createPreRenderedHook(id: string): void;
+    completePreRenderedHook(id: string): void;
+    protected checkPreLoaded(): void;
+    protected checkPreRendered(): void;
+    private subscribers;
+    subscribe(subscriber: PluginServiceSubscriber): () => void;
+    unsubscribe(subscriber: PluginServiceSubscriber): void;
+    private publish;
+    get(id: string): PluginState | undefined;
+    add(config: PluginConfig): Promise<boolean>;
+    private addExternal;
+    private addBuiltIn;
+    debug(debug: StoredRhineVar<RvPluginDebug>): Promise<void>;
+    stopDebug(id: string): Promise<void>;
+    loadPluginMessages(plugin: BasePlugin): Promise<void>;
+    install(plugin: BasePlugin): Promise<void>;
+    enable(id: string): Promise<void>;
+    open(id: string): Promise<void>;
+    close(id: string): Promise<void>;
+    disable(id: string): Promise<void>;
+    uninstall(id: string): Promise<void>;
+    waitInstall(id: string, timeoutMs?: number): Promise<void>;
+    waitEnable(id: string, timeoutMs?: number): Promise<void>;
+    private waitEvent;
+    isOpenablePlugin(type: PluginType): boolean;
+    isSideBarPlugin(type: PluginType): boolean;
+    isViewPlugin(type: PluginType): boolean;
+}
+
+/* Excluded from this release type: PluginView */
+
+/**
+ * @public
+ */
+export declare function ProgressBar(props: ProgressBarProps): React_2.JSX.Element;
+
+/* Excluded from this release type: PropertyAnimationFactory */
+
+/**
+ * @public
+ */
+export declare function recursNode(node: Node_2, fun: (node: Node_2) => void): void;
+
+/* Excluded from this release type: redirect */
+
+/* Excluded from this release type: removeMixView */
+
+/* Excluded from this release type: renderLoadingProgress */
+
+/* Excluded from this release type: renderMixView */
+
+/**
+ * @public
+ */
+export declare function ResourcePreview(props: ResourcePreviewProps): React_2.JSX.Element;
+
+/**
+ * ResourceService
+ * @public
+ */
+export declare class ResourceService {
+    private static _instance;
+    static get instance(): ResourceService;
+    private constructor();
+    dragState: {
+        fid: string;
+        data: null;
+        x: number;
+        y: number;
+        offsetX: number;
+        offsetY: number;
+    };
+    upload(file: File, fid?: string, check?: boolean): Promise<string>;
+    uploadMulti(fileList: FileList | File[] | File | null | undefined, check?: boolean, fidList?: string[]): Promise<void>;
+    addByOssUrl(ossUrl: string, name?: string, fid?: string, check?: boolean): Promise<string>;
+    PREVIEW_IMAGE_WIDTH: number;
+    PREVIEW_IMAGE_HEIGHT: number;
+    generateDescribeAndPreview(file: File): Promise<[string, File | null]>;
+    generatePreviewFile(img: HTMLImageElement | HTMLVideoElement, name: string): Promise<File>;
+    generateDescribeForTexture(texture: BaseTexture, fromFid: string): string;
+    generatePreviewForTexture(texture: BaseTexture, filename?: string): Promise<File | null>;
+    generateId(): string;
+}
+
+/**
+ * @public
+ */
+export declare function rootParent(node: Node_2): Node_2;
+
+/* Excluded from this release type: routing */
+
+/**
+ * 动画管理器对象
+ * @public
+ */
+export declare class RsAnimationManager {
+    constructor();
+    static initialize(): Promise<void>;
+    static analysisAnimationDuration(step: StoredRhineVar<RvStep>, lastStep?: RvStep): number;
+    static specialAnimation(): void;
+}
+
+/* Excluded from this release type: RsAnimationNativeManager */
+
+/* Excluded from this release type: RsAudioManager */
+
+/**
+ * @public
+ */
+export declare class RsAudioService implements RsAudioServiceApi {
+    private static _instance;
+    static get instance(): RsAudioService;
+    private constructor();
+    private audioIds;
+    private initialize;
+    private MAIN_AUDIO_ID_KEY;
+    private SECOND_AUDIO_ID_KEY;
+    processStepAudioMap(step: StoredRhineVar<RvStep>): void;
+    fadeOutAndPauseAllAudio(): void;
+    processAudioMap(audioMap: RvAudio | undefined, idKey: string): void;
+}
+
+/* Excluded from this release type: RsBasicService */
+
+/* Excluded from this release type: RsBetweenAnimationManager */
+
+/* Excluded from this release type: RsClick */
+
+/**
+ * @public
+ */
+export declare function RsdButton(props: RsdButtonProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function RsdCheckableButton(props: RsdCheckableButtonProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function RsdCheckbox(props: RsdCheckboxProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function RsdColor(props: RsdColorProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function RsdFileSelect(props: RsdFileSelectProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function RsdFileSelectButton(props: RsdFileSelectProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function RsdInput(props: RsdInputProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function RsdMentions(props: RsdMentionsProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function RsdNone(props: RsdNoneProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function RsdNumber(props: RsdNumberProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function RsdNumberList(props: RsdNumberListProps): React_2.JSX.Element;
+
+/* Excluded from this release type: RsdRadios */
+
+/**
+ * @public
+ */
+export declare function RsdSelect(props: RsdSelectProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function RsdSwitch(props: RsdSwitchProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function RsdTargetInfo(props: RsdTargetInfoProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function RsdTextarea(props: RsdInputProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function RsdTitle(props: RsdTitleProps): React_2.JSX.Element;
+
+/* Excluded from this release type: RsEnableService */
+
+/* Excluded from this release type: RsEngine */
+
+/**
+ * @public
+ */
+export declare class RsEnvironment implements RsEnvironmentApi {
+    private static _instance;
+    static get instance(): RsEnvironment;
+    private constructor();
+    mainCamera: ArcRotateCamera;
+    rightCamera: ArcRotateCamera;
+    backCamera: ArcRotateCamera;
+    leftCamera: ArcRotateCamera;
+    lights: Light[];
+    shadow: ShadowGenerator;
+    environmentTexture: CubeTexture;
+    STANDARD_MODE: boolean;
+    private INERTIA;
+    private initialize;
+    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;
+}
+
+/**
+ * @public
+ */
+export declare class RsEnvironmentService implements RsEnvironmentServiceApi {
+    private static _instance;
+    static get instance(): RsEnvironmentService;
+    private constructor();
+    private initialize;
+    updateEnvironment(path: RvPath, step: StoredRhineVar<RvStep>): void;
+    getCurrentCameraLocation(): RvCameraLocation;
+}
+
+/* Excluded from this release type: RsLabelRender */
+
+/* Excluded from this release type: RsLabelService */
+
+/* Excluded from this release type: RsLoader */
+
+/* Excluded from this release type: RsLocationService */
+
+/**
+ * @public
+ */
+export declare class RsLoopAnimationManager implements RsLoopAnimationManagerApi {
+    private static _instance;
+    static get instance(): RsLoopAnimationManager;
+    private constructor();
+    private animationMap;
+    private USE_RS_SPIN;
+    state: {
+        enableInEditorMode: boolean;
+    };
+    private initialize;
+    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): Animation_2;
+    makeSpinAnimation(value: number, start: number, name: string, axis: string, fr: number): Animation_2;
+    makeQuaternionAnimation(value: number, start: Vector3, name: string, axis: 'x' | 'y' | 'z', fr: number): Animation_2;
+}
+
+/* Excluded from this release type: RsMaterialFactory */
+
+/**
+ * @public
+ */
+export declare class RsMaterialService implements RsMaterialServiceApi {
+    private static _instance;
+    static get instance(): RsMaterialService;
+    private constructor();
+    private initialize;
+    updateMaterial(nid: string, mesh: AbstractMesh, path: string[] | RvPath, value: unknown, rvMaterial: StoredRhineVar<RvMaterial>): Promise<void>;
+    updateGeneralMaterialSingle(material: Material, path: RvPath, value: unknown): void;
+    updatePBRMaterialSingle(material: PBRMaterial, path: RvPath, value: unknown): void;
+    updateNodeMaterialSingle(material: NodeMaterial, path: RvPath, value: unknown, inputs?: RvMaterialNodeInput[]): void;
+}
+
+/**
+ * @public
+ */
+export declare class RsModelService implements RsModelServiceApi {
+    private static _instance;
+    static get instance(): RsModelService;
+    private constructor();
+    DETAILED_LOG_MODE: boolean;
+    private initialize;
+    models: Map<string, RsModel>;
+    get(mid: string): RsModel | undefined;
+    has(mid: string): boolean;
+    add(rsModel: RsModel): boolean;
+    remove(mid: string): boolean;
+    load(mid: string): Promise<void>;
+    pause(mid: string): boolean;
+    resume(mid: string): boolean;
+    cancel(mid: string): boolean;
+    private subscribers;
+    private singleSubscribers;
+    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>;
+    isLoaded(mid: string): boolean | undefined;
+}
+
+/* Excluded from this release type: RsMultipartUploadResult */
+
+/* Excluded from this release type: RsNodeMaterialAnalyzer */
+
+/**
+ * @public
+ */
+export declare class RsNodeMaterialManager implements RsNodeMaterialManagerApi {
+    private static _instance;
+    static get instance(): RsNodeMaterialManager;
+    private constructor();
+    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>;
+    private changeListeners;
+    private addChangeListener;
+    private removeChangeListener;
+    private notifyChangeListeners;
+    updateNodeMaterialTemplate(nid: string, fid: string, syncStateWhenCreate?: boolean): Promise<boolean>;
+    uploadNodeMaterialTemplate(nid: string, fid: string, material: NodeMaterial): void;
+    nodeMaterialToFile(material: NodeMaterial): File;
+}
+
+/**
+ * RsNodeService - 渲染节点服务
+ *
+ * 负责管理 Babylon.js 3D 场景节点与 RhineVar 同步数据之间的映射关系。
+ * 主要功能包括：
+ * - 生成节点映射表（NodePair）：将 3D 场景中的节点树结构映射到唯一的 nid（节点ID）
+ * - 解析压缩的节点数据：从 RvModel 中读取压缩后的节点结构并还原成 NodePair
+ * - 节点查询：通过 nid、uniqueId、mid、fid 等标识符快速查找节点
+ * - 发布订阅机制：当节点映射关系更新时通知订阅者
+ *
+ * @remarks
+ * nid 格式：`${mid}--L${level}-N${index}`
+ * - mid: model id，模型ID
+ * - level: 节点在树中的层级（从0开始）
+ * - index: 节点在当前生成过程中的序号（深度优先遍历顺序）
+ *
+ * @example
+ * ```typescript
+ * const service = RsNodeService.instance
+ * service.generateNodePairs('model-123', rootNode)
+ * const node = service.getNodeByNid('model-123--L0-N0')
+ * ```
+ *
+ * @public
+ */
+export declare class RsNodeService implements RsNodeServiceApi {
+    private static _instance;
+    /**
+     * 获取 RsNodeService 单例实例
+     *
+     * @returns RsNodeService 单例对象
+     */
+    static get instance(): RsNodeService;
+    private constructor();
+    /**
+     * 节点映射索引
+     *
+     * - nodePairsByNid: 通过 nid 快速定位 NodePair
+     * - nodePairsByUniqueId: 通过 Babylon.js uniqueId 快速定位 NodePair
+     *
+     * 注意：对外仍通过 NodePair[] 暴露（如 subscribeNodePairs），
+     * 内部统一以 Map 为真实存储结构。
+     */
+    private nodePairsByNid;
+    private nodePairsByUniqueId;
+    /**
+     * 临时索引计数器
+     *
+     * 在生成节点映射时，用于为每个节点分配唯一的序号（深度优先遍历顺序）
+     */
+    private tempId;
+    /* Excluded from this release type: addNodePair */
+    /**
+     * 解析节点映射关系
+     *
+     * 从 RvModelService 中读取压缩的节点结构数据，解压并重建 nodePairs 映射表。
+     * 使用场景：当模型从服务器加载或从 RhineVar 同步时，需要恢复节点映射关系。
+     *
+     * @param mid - 模型ID
+     * @param root - 模型的根节点对象
+     *
+     * @remarks
+     * 数据压缩格式：将 `":[]"},{"` 替换为 `\x11` 以减少存储空间
+     *
+     * @example
+     * ```typescript
+     * // 模型加载完成后，解析节点映射
+     * const rootNode = container.meshes[0]
+     * RsNodeService.instance.analysisNodePairs('model-123', rootNode)
+     * ```
+     */
+    analysisNodePairs(mid: string, root: Node_2): void;
+    /* Excluded from this release type: rescueAnalysisNodePairs */
+    /* Excluded from this release type: getDataFromRvNodeStored */
+    /**
+     * 生成节点映射对并保存到 RvModel
+     *
+     * 遍历 Babylon.js 节点树，为每个节点生成 nid 并创建 NodePair 映射。
+     * 将节点结构序列化、压缩后存储到 RvModelService 中。
+     *
+     * 使用场景：首次加载模型时，或者模型节点结构发生变化时调用。
+     *
+     * @param mid - 模型ID
+     * @param root - 模型的根节点对象
+     *
+     * @remarks
+     * - 采用深度优先遍历生成节点序号
+     * - 压缩算法：将重复的 `":[]"},{"` 字符串替换为 `\x11` 以节省空间
+     * - 生成完成后会通过发布订阅机制通知所有订阅者
+     *
+     * @example
+     * ```typescript
+     * // 首次加载模型后生成映射
+     * const container = await SceneLoader.ImportMeshAsync(...)
+     * const root = container.meshes[0]
+     * RsNodeService.instance.generateNodePairs('model-123', root)
+     * ```
+     */
+    generateNodePairs(mid: string, root: Node_2): void;
+    /* Excluded from this release type: rescueGenerateNodePairs */
+    /**
+     * 生成场景节点结构并添加到 RvScene
+     *
+     * 遍历 Babylon.js 节点树，生成 RvSceneNode 结构并添加到 RvSceneService。
+     * RvSceneNode 是 RhineVar 同步数据中的场景节点表示，支持多人协同编辑场景结构。
+     *
+     * 使用场景：首次创建场景或添加新模型到场景时调用。
+     *
+     * @param mid - 模型ID
+     * @param root - 模型的根节点对象
+     *
+     * @remarks
+     * 与 generateNodePairs 的区别：
+     * - generateNodePairs: 生成压缩的节点结构存储到 RvModel（用于节点查询）
+     * - generateSceneNode: 生成完整的场景节点树存储到 RvScene（用于场景编辑和同步）
+     *
+     * @example
+     * ```typescript
+     * // 添加模型到场景
+     * const container = await SceneLoader.ImportMeshAsync(...)
+     * const root = container.meshes[0]
+     * RsNodeService.instance.generateSceneNode('model-123', root)
+     * ```
+     */
+    generateSceneNode(mid: string, root: Node_2): void;
+    /* Excluded from this release type: rescueGenerateRvSceneNode */
+    /* Excluded from this release type: getChildNodeByName */
+    /**
+     * 根据 nid 获取节点映射信息
+     *
+     * @param nid - 节点唯一标识符
+     * @returns NodePair 对象，未找到则返回 null
+     *
+     * @example
+     * ```typescript
+     * const pair = RsNodeService.instance.getNodePairByNid('model-123--L0-N0')
+     * if (pair) {
+     *   console.log(pair.node.name)
+     *   console.log(pair.uniqueId)
+     * }
+     * ```
+     */
+    getNodePairByNid(nid: string): NodePair | null;
+    /**
+     * 根据 Babylon.js uniqueId 获取节点映射信息
+     *
+     * @param uniqueId - Babylon.js 节点的内部唯一ID
+     * @returns NodePair 对象，未找到则返回 null
+     *
+     * @example
+     * ```typescript
+     * const pickedMesh = scene.pick(event.x, event.y)
+     * if (pickedMesh.hit) {
+     *   const pair = RsNodeService.instance.getNodePairByUniqueId(pickedMesh.pickedMesh.uniqueId)
+     *   console.log('Clicked node nid:', pair?.nid)
+     * }
+     * ```
+     */
+    getNodePairByUniqueId(uniqueId: number): NodePair | null;
+    /**
+     * 根据 nid 获取 Babylon.js 节点对象
+     *
+     * @param nid - 节点唯一标识符
+     * @returns Babylon.js Node 对象，未找到则返回 null
+     *
+     * @example
+     * ```typescript
+     * const node = RsNodeService.instance.getNodeByNid('model-123--L1-N5')
+     * if (node) {
+     *   node.setEnabled(false)
+     * }
+     * ```
+     */
+    getNodeByNid(nid: string): Node_2 | null;
+    /**
+     * 根据 Babylon.js uniqueId 获取 nid
+     *
+     * @param uniqueId - Babylon.js 节点的内部唯一ID
+     * @returns nid 字符串，未找到则返回 null
+     *
+     * @example
+     * ```typescript
+     * const pickedMesh = scene.pick(event.x, event.y)
+     * if (pickedMesh.hit) {
+     *   const nid = RsNodeService.instance.getNidByUniqueId(pickedMesh.pickedMesh.uniqueId)
+     *   // Use nid to update RhineVar sync data
+     * }
+     * ```
+     */
+    getNidByUniqueId(uniqueId: number): string | null;
+    /**
+     * 从 nid 中提取模型ID (mid)
+     *
+     * @param nid - 节点唯一标识符，格式：`${mid}--L${level}-N${index}`
+     * @returns mid 字符串，格式不正确则返回 null
+     *
+     * @example
+     * ```typescript
+     * const mid = RsNodeService.instance.getMidByNid('model-123--L1-N5')
+     * // mid = 'model-123'
+     * ```
+     */
+    getMidByNid(nid: string): string | null;
+    /**
+     * 根据模型ID获取文件ID (fid)
+     *
+     * 从 RvModelService 中查询模型的关联文件ID。
+     *
+     * @param mid - 模型ID
+     * @returns fid 字符串，未找到则返回 null
+     *
+     * @example
+     * ```typescript
+     * const fid = RsNodeService.instance.getFidByMid('model-123')
+     * // fid 指向模型文件在文件系统中的ID
+     * ```
+     */
+    getFidByMid(mid: string): string | null;
+    /**
+     * 根据节点ID获取文件ID (fid)
+     *
+     * 组合 getMidByNid 和 getFidByMid 功能。
+     *
+     * @param nid - 节点唯一标识符
+     * @returns fid 字符串，未找到则返回 null
+     *
+     * @example
+     * ```typescript
+     * const fid = RsNodeService.instance.getFidByNid('model-123--L1-N5')
+     * // fid = 模型文件ID
+     * ```
+     */
+    getFidByNid(nid: string): string | null;
+    private nodePairsSubscribers;
+    /**
+     * 节点映射订阅者列表
+     *
+     * 存储所有订阅 nodePairs 变化的回调函数*
+     private nodePairsSubscribers: ((pairs: NodePair[]) =\> void)[] = []
+
+     /**
+     * 订阅节点映射变化
+     *
+     * 当 nodePairs 更新时（如加载新模型、解析节点等），订阅者会收到通知。
+     *
+     * @param subscriber - 订阅回调函数，参数为最新的 NodePair 数组
+     * @returns 取消订阅函数
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = RsNodeService.instance.subscribeNodePairs((pairs) => {
+     *   console.log('NodePairs updated, total nodes:', pairs.length)
+     *   // Update UI or perform other actions
+     * })
+     *
+     * // Later, unsubscribe
+     * unsubscribe()
+     * ```
+     */
+    subscribeNodePairs(subscriber: (pairs: NodePair[]) => void): () => void;
+    /**
+     * 取消订阅节点映射变化
+     *
+     * @param subscriber - 要取消的订阅回调函数
+     *
+     * @example
+     * ```typescript
+     * const callback = (pairs: NodePair[]) => { ... }
+     * RsNodeService.instance.subscribeNodePairs(callback)
+     * // Later
+     * RsNodeService.instance.unsubscribeNodePairs(callback)
+     * ```
+     */
+    unsubscribeNodePairs(subscriber: (pairs: NodePair[]) => void): void;
+    /* Excluded from this release type: publishNodePairs */
+}
+
+/* Excluded from this release type: RsPlayTimeRecordService */
+
+/* Excluded from this release type: RsPreFirstEnvironment */
+
+/**
+ * RsSceneService 管理所有场景节点的嵌套关系变动
+ * @public
+ */
+export declare class RsSceneService {
+    private static _instance;
+    static get instance(): RsSceneService;
+    private constructor();
+    initialize(): void;
+    syncAll(): void;
+    sync(nid: string, sceneNode?: RvSceneNode | null, targetNode?: Node_2 | null, parentNode?: Node_2 | null): boolean;
+}
+
+/* Excluded from this release type: RsSelection */
+
+/**
+ * @public
+ */
+export declare class RsSelectionService implements RsSelectionServiceApi {
+    private static _instance;
+    static get instance(): RsSelectionService;
+    private constructor();
+    private initialize;
+    click(nid?: string, ctrl?: boolean): void;
+    set(nidList: string[]): void;
+    add(nid: string): void;
+    remove(nid: string): void;
+    clear(): void;
+    has(nid: string): boolean;
+    get(nid: string): RsSelectionNodeInfo | null;
+    selected: RsSelectionNodeInfo[];
+    last: RsSelectionNodeInfo | null;
+    branchMode: boolean;
+    materialInfo: RsSelectionMaterialInfo;
+    highlight: HighLightInfo[];
+    private updateMaterialInfo;
+    changeBranchMode(value?: boolean, message?: boolean): void;
+    toAllChildren(log?: boolean): boolean;
+    private subscribers;
+    subscribe(subscriber: SelectedSubscriber): () => void;
+    unsubscribe(subscriber: SelectedSubscriber): void;
+    private publish;
+    private lastSubscribers;
+    subscribeLast(subscriber: LastSubscriber): () => void;
+    unsubscribeLast(subscriber: LastSubscriber): void;
+    private publishLast;
+}
+
+/**
+ * @public
+ */
+export declare class RsSeparateService implements RsSeparateServiceApi {
+    private static _instance;
+    static get instance(): RsSeparateService;
+    private constructor();
+    private initialize;
+    separated: string[];
+    has(nid: string): boolean;
+    add(nid: string, mesh?: AbstractMesh, material?: Material | null): void;
+    private getAbstractMesh;
+    /**
+     * 获取节点分离后的材质
+     *
+     * 如果材质已经分离，则返回分离后的材质，为分离则先复制并分离再返回新材质。
+     *
+     * @param nid -
+     * @param node -
+     */
+    get(nid: string, node?: Node_2): Promise<Material | null>;
+    /**
+     * 获取节点分离后的材质
+     *
+     * 会确保材质的类型符合数据，不符合则创建。
+     *
+     * 如果材质已经分离，则返回分离后的材质，未分离则先复制并分离再返回新材质。
+     *
+     * @param nid -
+     * @param rvMaterial -
+     * @param node -
+     */
+    getWithEnsureType(nid: string, rvMaterial: RvMaterial, node?: Node_2): Promise<Material | null>;
+    checkMaterialType(material: Material, type: RvMaterialType): boolean;
+    /**
+     * 分析所有模型，找到其中所有有使用相同材质的模型，分组他们的id
+     * @param meshes -
+     */
+    analysisByMeshes(meshes: AbstractMesh[]): void;
+}
+
+/* Excluded from this release type: RsService */
+
+/* Excluded from this release type: RsSpinAnimationManager */
+
+/**
+ * @public
+ */
+export declare class RsTextureService implements RsTextureServiceApi {
+    private static _instance;
+    static get instance(): RsTextureService;
+    private constructor();
+    private textures;
+    private DEFAULT_TEXTURE_SIZE;
+    private WHITE_TEXTURE;
+    private BLACK_TEXTURE;
+    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;
+}
+
+/* Excluded from this release type: RsTransformGround */
+
+/* Excluded from this release type: RsTransformNode */
+
+/**
+ * @public
+ */
+export declare class RvBasicAttribute implements RvBasicAttributeApi {
+    private static _instance;
+    static get instance(): RvBasicAttribute;
+    key: keyof RvNode;
+    defaultValue: RvBasic;
+    private getMeshByNid;
+    generate(nid: string): RvBasic;
+    ensure(nid: string, easyCheck?: boolean): boolean;
+}
+
+/**
+ * @public
+ */
+export declare class RvCodeAttribute implements RvCodeAttributeApi {
+    private static _instance;
+    static get instance(): RvCodeAttribute;
+    private constructor();
+    key: keyof RvNode;
+    defaultValue: {
+        jumpTargetOnClick: string;
+    };
+    generate(): RvCode;
+    ensure(nid: string, easyCheck?: boolean): boolean;
+}
+
+/**
+ * @public
+ */
+export declare class RvFileService implements RvFileServiceApi {
+    static _instance: RvFileService;
+    static get instance(): RvFileService;
+    private constructor();
+    private initialize;
+    files: RecursiveMap<RvFile>;
+    get(fid: string): RecursiveObject<RvFile> | undefined;
+    getByUrl(url: string): RecursiveObject<RvFile> | undefined;
+    has(fid: string): boolean;
+    hasUrl(url: string): boolean;
+    add(fileData: RvFile): Promise<StoredRhineVar<RvFile> | null>;
+    addByUrl(url: string): Promise<StoredRhineVar<RvFile> | null>;
+    remove(fid: string): boolean;
+    private subscribers;
+    private singleSubscribers;
+    subscribe(subscriber: RvFileServiceSubscriber): () => void;
+    unsubscribe(subscriber: RvFileServiceSubscriber): void;
+    subscribeSingle(fid: string, subscriber: RvFileServiceSubscriber): () => void;
+    unsubscribeSingle(fid: string, subscriber: RvFileServiceSubscriber): void;
+    private publish;
+    generateId(): string;
+    findSame(file: File): Promise<string | null>;
+}
+
+/**
+ * @public
+ */
+export declare class RvGlobalService implements RvGlobalServiceApi {
+    static _instance: RvGlobalService;
+    static get instance(): RvGlobalService;
+    private constructor();
+    state: StoredRhineVar<RvGlobal>;
+}
+
+/**
+ * @public
+ */
+export declare class RvLabelAttribute implements RvLabelAttributeApi {
+    private static _instance;
+    static get instance(): RvLabelAttribute;
+    private constructor();
+    key: keyof RvNode;
+    defaultValue: RvLabel;
+    generate(): RvLabel;
+    ensure(nid: string, easyCheck?: boolean): boolean;
+    get(sid: string, nid: string): RvLabel | undefined;
+}
+
+/**
+ * @public
+ */
+export declare class RvLocationAttribute implements RvLocationAttributeApi {
+    private static _instance;
+    static get instance(): RvLocationAttribute;
+    private constructor();
+    key: keyof RvNode;
+    defaultValue: {
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        rotation: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        scale: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        nearMode: boolean;
+    };
+    generate(node: Node_2 | undefined | null): RvLocation;
+    ensure(nid: string, easyCheck?: boolean): boolean;
+}
+
+/**
+ * @public
+ */
+export declare class RvLoopAttribute implements RvLoopAttributeApi {
+    private static _instance;
+    static get instance(): RvLoopAttribute;
+    private constructor();
+    key: string;
+    defaultValue: RvLoop;
+    generate(): RvLoop;
+    ensure(nid: string, easyCheck?: boolean): boolean;
+}
+
+/**
+ * @public
+ */
+export declare class RvMaterialAttribute implements RvMaterialAttributeApi {
+    private static _instance;
+    static get instance(): RvMaterialAttribute;
+    private constructor();
+    key: keyof RvNode;
+    defaultPBRValue: RvMaterialPBR;
+    defaultNodeValue: RvMaterialNode;
+    defaultTextureValue: RvMaterialTexture;
+    defaultValue: RvMaterial;
+    generate(nid: string): RvMaterial;
+    ensure(nid: string, easyCheck?: boolean): boolean;
+    private getMeshByNid;
+    private getTextureMap;
+    generateTexture(textureMap?: Map<string, BaseTexture_2>, material?: PBRMaterial | NodeMaterial): RvMaterialTexture;
+    generatePBR(material?: PBRMaterial): RvMaterialPBR;
+    generatePreset(rvMaterial?: RvMaterial): RvPresetType;
+    generateNode(material?: NodeMaterial): RvMaterialNode;
+}
+
+/* Excluded from this release type: RvMeetingService */
+
+/**
+ * @public
+ */
+export declare class RvModelService implements RvModelServiceApi {
+    static _instance: RvModelService;
+    static get instance(): RvModelService;
+    private constructor();
+    private initialize;
+    uploadMulti(fileList: FileList | File[] | File | null | undefined, check?: boolean): Promise<void>;
+    addByFid(fid: string, provide?: boolean): string;
+    models: RecursiveMap<RvModel>;
+    hadAddList: string[];
+    get(mid: string): RecursiveObject<RvModel> | undefined;
+    has(mid: string): boolean;
+    hasFid(fid: string): boolean;
+    add(rvModel: RvModel): string;
+    remove(mid: string): boolean;
+    hasNode(mid: string): boolean;
+    setNode(mid: string, node: string): boolean;
+    getNode(mid: string): string | undefined;
+    generateId(): string;
+}
+
+/**
+ * @public
+ */
+export declare class RvNativeAttribute implements RvNativeAttributeApi {
+    private static _instance;
+    static get instance(): RvNativeAttribute;
+    private constructor();
+    key: string;
+    defaultValue: RvNative;
+    generate(nid: string): RvNative;
+    ensure(nid: string, easyCheck?: boolean): boolean;
+}
+
+/**
+ * @public
+ */
+export declare class RvNodeMaterialAnalyzer implements RvNodeMaterialAnalyzerApi {
+    private static _instance;
+    static get instance(): RvNodeMaterialAnalyzer;
+    ensure(material: StoredRhineVar<RvMaterial>, nid: string): Promise<boolean>;
+}
+
+/**
+ * @public
+ */
+export declare class RvNodeService implements RvNodeServiceApi {
+    private static _instance;
+    static get instance(): RvNodeService;
+    private constructor();
+    initialize(nid: string): void;
+    isInitialized(nid: string): boolean;
+    multiInitialize(nidList: string[]): void;
+    isAllInitialized(nidList: string[]): boolean;
+    forEachAny(callback: (node: StoredRhineVar<RvNode>, sid: string, nid: string) => void, nidList?: string[], sidList?: string[]): void;
+    forEach(callback: (node: StoredRhineVar<RvNode>, sid: string) => void, nid: string): void;
+    forEachMulti(callback: (nodes: Map<string, StoredRhineVar<RvNode>>, sid: string) => void, nidList?: string[]): void;
+    forEachMap(callback: (nodes: RecursiveMap<RvNode>, sid: string) => void): void;
+    getCurrentMap(): RecursiveMap<RvNode>;
+    getMap(sid?: string): RecursiveMap<RvNode> | undefined;
+    get(nid: string, sid?: string): StoredRhineVar<RvNode> | undefined;
+    multiGet(sidList?: string[], nidList?: string[]): Map<string, Map<string, StoredRhineVar<RvNode>>>;
+    resetAll(): void;
+}
+
+/* Excluded from this release type: RvNodeStored */
+
+/* Excluded from this release type: RvPluginService */
+
+/**
+ * @public
+ */
+export declare class RvResourceService implements RvResourceServiceApi {
+    private static _instance;
+    static get instance(): RvResourceService;
+    private constructor();
+    private initialize;
+    resources: RecursiveMap<RvResource>;
+    get(fid: string): RecursiveObject<RvResource> | undefined;
+    has(fid: string): boolean;
+    add(file: RvResource): void;
+    remove(fid: string): boolean;
+    private subscribers;
+    private singleSubscribers;
+    subscribe(subscriber: RvResourceServiceSubscriber): () => void;
+    unsubscribe(subscriber: RvResourceServiceSubscriber): void;
+    subscribeSingle(fid: string, subscriber: RvResourceServiceSubscriber): () => void;
+    unsubscribeSingle(fid: string, subscriber: RvResourceServiceSubscriber): void;
+    private publish;
+    generateId(): string;
+    findSame(file: File): Promise<string | null>;
+}
+
+/**
+ * @public
+ */
+export declare class RvSceneService implements RvSceneServiceApi {
+    private static _instance;
+    static get instance(): RvSceneService;
+    private constructor();
+    private initialize;
+    scene: RecursiveMap<RvSceneNode>;
+    isDescendant(nid: string, of: string): boolean;
+    isAncestor(nid: string, of: string): boolean;
+    isParent(nid: string, of: string): boolean;
+    isChild(nid: string, of: string): boolean;
+    move(nid: string, newParent?: string): void;
+    getSortedRvSceneNodeWithRelatedInfoList(): RvSceneNodeWithRelatedInfo[];
+}
+
+/* Excluded from this release type: RvSeparateService */
+
+/**
+ * @public
+ */
+export declare class RvStepService implements RvStepServiceApi {
+    static _instance: RvStepService;
+    static get instance(): RvStepService;
+    private constructor();
+    order: RecursiveArray<string>;
+    steps: RecursiveMap<RvStep>;
+    get(sid: string): RecursiveObject<RvStep> | undefined;
+    multiGet(sidList?: string[]): Map<string, StoredRhineVar<RvStep>>;
+    /**
+     * Add a new step
+     *
+     * @param from - Copy all step data from another step
+     * @param index - Insert the new step at this index, default to the end
+     */
+    add(from?: string, index?: number): string;
+    move(sid: string, to: number): boolean;
+    remove(sid: string): boolean;
+    forEach(callback: (rvStep: StoredRhineVar<RvStep>, sid: string) => void): void;
+    getStepOptions(withDisable?: boolean): StepOptions;
+    getStepIndex(sid: string): number;
+    getStepByIndex(index: number): StoredRhineVar<RvStep> | undefined;
+    getCurrentStep(): StoredRhineVar<RvStep>;
+    generateId(): string;
+}
+
+/* Excluded from this release type: scene */
+
+/**
+ * @public
+ */
+export declare class SceneService implements SceneServiceApi {
+    private static _instance;
+    static get instance(): SceneService;
+    private constructor();
+    dragState: {
+        nid: string;
+        x: number;
+        y: number;
+        offsetX: number;
+        offsetY: number;
+    };
+}
+
+declare enum ScriptStatus {
+    Idle = "idle",
+    Loading = "loading",
+    Ready = "ready",
+    Error = "error"
+}
+
+/**
+ * @public
+ */
+export declare function ScrollBar(props: ScrollBarProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare class ShadowAnimation implements ShadowAnimationApi {
+    private static _instance;
+    static get instance(): ShadowAnimation;
+    private constructor();
+    play(data: ShadowAnimationData, 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;
+}
+
+/**
+ * @public
+ * 定义阴影动画数据接口
+ */
+declare interface ShadowAnimationData {
+    enable?: boolean;
+    darkness?: number;
+    blurOffset?: number;
+    blurScale?: number;
+    onlyOnGround?: boolean;
+    normalBias?: number;
+}
+
+/**
+ * @public
+ */
+export declare function showAttributeContextMenu<T = unknown>(options: ShowAttributeContextMenuOptions<T>): void;
+
+/**
+ * @public
+ */
+export declare class SkyboxAnimation {
+    private static _instance;
+    static get instance(): SkyboxAnimation;
+    private constructor();
+    play(data: {
+        background?: Color4 | Color3 | string;
+    }, duration?: number, quickMode?: boolean): void;
+    background(color: Color4 | Color3 | string, duration?: number, quickMode?: boolean): void;
+}
+
+/* Excluded from this release type: sleep */
+
+/**
+ * @public
+ */
+export declare class SpaceService implements SpaceServiceApi {
+    private static _instance;
+    static get instance(): SpaceService;
+    page: Page;
+    screen: Screen_2;
+    private constructor();
+    private stepChangeSubscribers;
+    private publishStepChange;
+    subscribeStepChange(subscriber: StepChangeSubscriber): void;
+    unsubscribeStepChange(subscriber: StepChangeSubscriber): void;
+    setSid(sid: string): void;
+    setScreenSize(size: ScreenSize): void;
+    isEditorPage(type?: PageType): boolean;
+    isBoxMode(mode?: PageMode): boolean;
+    isFullMode(mode?: PageMode): boolean;
+}
+
+/* Excluded from this release type: SpinAnimation */
+
+/* Excluded from this release type: SplitTask */
+
+/**
+ * @public
+ */
+export declare class StatusService implements StatusServiceApi {
+    private static _instance;
+    static get instance(): StatusService;
+    private constructor();
+    private checkAllInitialized;
+    private checkRendered;
+    status: Status;
+    private authenticatedSubscribers;
+    private subscribeDataSynchronizedList;
+    private subscribeSyncInitializedList;
+    private subscribeRsInitializedList;
+    private subscribeAllInitializedList;
+    private subscribePluginEnabledList;
+    private subscribePluginPreLoadedList;
+    private subscribeFileLoadedList;
+    private subscribeModelLoadedList;
+    private subscribePluginPreRenderedList;
+    private subscribeRenderedList;
+    private subscribeShownList;
+    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>;
+}
+
+/**
+ * @public
+ */
+export declare abstract class StepAttribute<T extends object = never> extends BaseAttribute<T> implements IStepAttribute<T> {
+    type: AttributeType;
+    private targetStepService;
+    get targetSid(): string;
+    get targetSidList(): string[];
+    generate(sid?: string): T;
+    multiGenerate(sidList?: string[]): Map<string, T>;
+    initialize(): void;
+    isInitialized(): boolean;
+    mark(path: string | RvPath, sid?: string): void;
+    multiMark(path: string | RvPath, sidList?: string[]): void;
+    get(sid?: string): StoredRhineVar<T> | undefined;
+    multiGet(sidList?: string[]): Map<string, StoredRhineVar<T>>;
+    set(path: string | RvPath, value: unknown, sid?: string): void;
+    multiSet(path: string | RvPath, value: unknown, sidList?: string[]): void;
+    read(sid?: string): T | StoredRhineVar<T>;
+    multiRead(sidList?: string[]): Map<string, T | StoredRhineVar<T>>;
+    edit(path: string | RvPath, value: unknown, sid?: string): void;
+    multiEdit(path: string | RvPath, value: unknown, sidList?: string[]): void;
+    editMany(list: [string | RvPath, unknown][], sid?: string): void;
+    multiEditMany(list: [string | RvPath, unknown][], sidList?: string[]): void;
+    private unsubscribeMap;
+    subscribeTarget(subscriber: StepAttributeTargetSubscriber<T>): () => void;
+    unsubscribeTarget(subscriber: StepAttributeTargetSubscriber<T>): void;
+}
+
+/**
+ * @public
+ */
+export declare function StepBlockSelect(props: StepBlockSelectProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare class SyncService implements SyncServiceApi {
+    OVERWRITE_MODE: boolean;
+    ENABLE_RHINE_VAR_LOG: boolean;
+    private static _instance;
+    static get instance(): SyncService;
+    private constructor();
+    private initialize;
+    url: string;
+    state: RecursiveObject<RvBase>;
+    clientId: number;
+    private ids;
+    generateId(prefix: string): string;
+    reset(): boolean;
+}
+
+/**
+ * @public
+ */
+export declare class TargetMultiNodeService implements TargetMultiNodeServiceApi {
+    static _instance: TargetMultiNodeService;
+    static get instance(): TargetMultiNodeService;
+    private constructor();
+    sid: string;
+    nid: string;
+    nidList: string[];
+    private nodes;
+    private initialize;
+    private unsubscribeAttribute;
+    private updateStep;
+    private subscribers;
+    subscribe(subscriber: TargetMultiNodeSubscriber): () => void;
+    unsubscribe(subscriber: TargetMultiNodeSubscriber): void;
+    private publish;
+}
+
+/**
+ * @public
+ */
+export declare class TargetNodeService implements TargetNodeServiceApi {
+    static _instance: TargetNodeService;
+    static get instance(): TargetNodeService;
+    private constructor();
+    state: StoredRhineVar<RvNode> | null;
+    sid: string;
+    nid: string;
+    private nodes;
+    private initialize;
+    private unsubscribeAttribute;
+    private updateStep;
+    private updateNode;
+    private subscribers;
+    subscribe(subscriber: TargetNodeSubscriber): () => void;
+    unsubscribe(subscriber: TargetNodeSubscriber): void;
+    private publish;
+}
+
+/**
+ * @public
+ */
+export declare class TargetStepService implements TargetStepServiceApi {
+    static _instance: TargetStepService;
+    static get instance(): TargetStepService;
+    private constructor();
+    /**
+     * Target step state
+     */
+    sid: string;
+    state: StoredRhineVar<RvStep>;
+    private subscribers;
+    private nodeSubscribers;
+    subscribe(subscriber: TargetStepSubscriber): () => void;
+    unsubscribe(subscriber: TargetStepSubscriber): void;
+    subscribeNode(subscriber: TargetNodeSubscriber): () => void;
+    unsubscribeNode(subscriber: TargetNodeSubscriber): void;
+    private publish;
+    /**
+     * Set value by path
+     *
+     * @param path -
+     * @param value -
+     */
+    set<T>(path: string | RvPath, value: T): void;
+    /**
+     * Get value by path
+     *
+     * @param path -
+     */
+    get<T>(path: string | RvPath): T;
+    isValueChange(type: TChangeType): boolean;
+}
+
+/* Excluded from this release type: themeClass */
+
+/**
+ * @public
+ */
+export declare function ThemeProvider(props: ThemeProviderProps): JSX.Element;
+
+/**
+ * @public
+ */
+export declare class ThemeService implements ThemeServiceApi {
+    private static _instance;
+    static get instance(): ThemeService;
+    private constructor();
+    state: ThemeState;
+    private initialize;
+    updateBackground(): void;
+    updateBackgroundByColor(color: string): void;
+    isDarkTheme(): boolean;
+}
+
+/**
+ * @public
+ */
+export declare function toEuler(quaternion: Quaternion): Vector3;
+
+/* Excluded from this release type: TokenData */
+
+/**
+ * 360度制欧拉角转四元数
+ * @public
+ */
+export declare function toQuaternion(x: number, y: number, z: number): Quaternion;
+
+/* Excluded from this release type: UpgradeService */
+
+/**
+ * @public
+ */
+export declare function UploadButtonAndList(props: UploadButtonAndListProps): React_2.JSX.Element;
+
+/**
+ * @public
+ */
+export declare function useAllSelectedInfo(): {
+    selected: RsSelectionNodeInfo[];
+    materialInfo: RsSelectionMaterialInfo;
+    last: RsSelectionNodeInfo | null;
+};
+
+/**
+ * @public
+ */
+export declare function useGlobal<T = unknown>(path?: string | RvPath): {
+    state: T;
+    set: (key: string | RvPath, value: unknown) => void;
+    mark: (key: string | RvPath) => void;
+};
+
+/**
+ * @public
+ */
+export declare function useGlobalAttribute<T extends object = never>(path?: string | RvPath): {
+    state: T | StoredRhineVar<T>;
+    path: string | RvPath;
+    targetGlobalAttribute: IGlobalAttribute<T>;
+    initialize: () => void;
+    isInitialized: () => boolean;
+    mark: (path: string | RvPath) => void;
+    get: () => RecursiveCrossRhineVar<T> | undefined;
+    set: (path: string | RvPath, value: unknown) => void;
+    read: () => T | RecursiveCrossRhineVar<T>;
+    edit: (path: string | RvPath, value: unknown) => void;
+    editMany: (list: [string | RvPath, unknown][]) => void;
+};
+
+/**
+ * @public
+ */
+export declare function useLastSelectedInfo(): RsSelectionNodeInfo | null;
+
+/* Excluded from this release type: usePathname */
+
+/* Excluded from this release type: useRouter */
+
+/**
+ * @public
+ */
+export declare class UserService implements UserServiceApi {
+    private static _instance;
+    static get instance(): UserService;
+    private constructor();
+    auth: UserAuth;
+    info: UserInfo;
+    clear(): void;
+}
+
+/**
+ * @public
+ */
+export declare function useScript(src: string): ScriptStatus;
+
+/**
+ * @public
+ */
+export declare function useSelectedInfo(): RsSelectionNodeInfo[];
+
+/**
+ * @public
+ */
+export declare function useSelectedMaterialInfo(): RsSelectionMaterialInfo;
+
+/**
+ * @public
+ */
+export declare function useStepOptions(withDisable?: boolean): StepOptions;
+
+/**
+ * @public
+ */
+export declare function useTargetNode<T = unknown>(path?: string | RvPath): {
+    sid: string;
+    nid: string;
+    state: T | null;
+    multiSet: (key: string | RvPath, value: unknown) => void;
+    set: (key: string | RvPath, value: unknown) => void;
+    mark: (key: string | RvPath) => void;
+    multiMark: (key: string | RvPath) => void;
+};
+
+/**
+ * @public
+ */
+export declare function useTargetNodeAttribute<T extends object = never>(path?: string | RvPath): {
+    state: T | StoredRhineVar<T>;
+    path: string | RvPath;
+    sid: string;
+    nid: string;
+    nidList: string[];
+    targetNodeAttribute: INodeAttribute<T>;
+    initialize: (nid?: string) => void;
+    isInitialized: (nid?: string) => boolean;
+    multiInitialize: (nidList?: string[]) => void;
+    isAllInitialized: (nidList?: string[]) => boolean;
+    mark: (path: string | RvPath, sid?: string, nid?: string) => void;
+    multiMark: (path: string | RvPath, sidList?: string[], nidList?: string[]) => void;
+    get: (sid?: string, nid?: string) => RecursiveCrossRhineVar<T> | undefined;
+    multiGet: (sidList?: string[], nidList?: string[]) => Map<string, Map<string, RecursiveCrossRhineVar<T>>>;
+    set: (path: string | RvPath, value: unknown, sid?: string, nid?: string) => void;
+    multiSet: (path: string | RvPath, value: unknown, sidList?: string[], nidList?: string[]) => void;
+    read: (sid?: string, nid?: string) => T | RecursiveCrossRhineVar<T>;
+    multiRead: (sidList?: string[], nidList?: string[]) => Map<string, Map<string, T | RecursiveCrossRhineVar<T>>>;
+    edit: (path: string | RvPath, value: unknown, sid?: string, nid?: string) => void;
+    multiEdit: (path: string | RvPath, value: unknown, sidList?: string[], nidList?: string[]) => void;
+    subscribe: (subscriber: NodeAttributeTargetSubscriber<T>) => () => void;
+    unsubscribe: (subscriber: NodeAttributeTargetSubscriber<T>) => void;
+};
+
+/**
+ * @public
+ */
+export declare function useTargetStep<T = unknown>(path?: string | RvPath): {
+    sid: string;
+    state: T;
+    set: (key: string | RvPath, value: unknown) => void;
+    mark: (key: string | RvPath) => void;
+};
+
+/**
+ * @public
+ */
+export declare function useTargetStepAttribute<T extends object = never>(path?: string | RvPath): {
+    state: T | StoredRhineVar<T>;
+    path: string | RvPath;
+    sid: string;
+    targetStepAttribute: IStepAttribute<T>;
+    initialize: () => void;
+    isInitialized: () => boolean;
+    mark: (path: string | RvPath, sid?: string) => void;
+    multiMark: (path: string | RvPath, sidList?: string[]) => void;
+    get: (sid?: string) => RecursiveCrossRhineVar<T> | undefined;
+    multiGet: (sidList?: string[]) => Map<string, RecursiveCrossRhineVar<T>>;
+    set: (path: string | RvPath, value: unknown, sid?: string) => void;
+    multiSet: (path: string | RvPath, value: unknown, sidList?: string[]) => void;
+    read: (sid?: string) => T | RecursiveCrossRhineVar<T>;
+    multiRead: (sidList?: string[]) => Map<string, T | RecursiveCrossRhineVar<T>>;
+    edit: (path: string | RvPath, value: unknown, sid?: string) => void;
+    multiEdit: (path: string | RvPath, value: unknown, sidList?: string[]) => void;
+    subscribe: (subscriber: StepAttributeTargetSubscriber<T>) => () => void;
+    unsubscribe: (subscriber: StepAttributeTargetSubscriber<T>) => void;
+};
+
+/* Excluded from this release type: ViewerButton */
+
+/* Excluded from this release type: ViewerButtonProps */
+
+/**
+ * @public
+ */
+export declare function WebVitals(): JSX.Element;
+
+/**
+ * @public
+ */
+export declare interface WithOption<T> {
+    subscriber: T;
+    option?: NativeEventSubscribeOption;
+}
+
+
+export declare const rvLocationAttribute: RvLocationAttribute
+export declare const rvLabelAttribute: RvLabelAttribute
+export declare const rvLoopAttribute: RvLoopAttribute
+export declare const rvNativeAttribute: RvNativeAttribute
+export declare const rvCodeAttribute: RvCodeAttribute
+export declare const rvMaterialAttribute: RvMaterialAttribute
+export declare const rvBasicAttribute: RvBasicAttribute
+export declare const spaceService: SpaceService
+export declare const statusService: StatusService
+export declare const pluginService: PluginService
+export declare const themeService: ThemeService
+export declare const internationalizationService: InternationalizationService
+export declare const meetingService: MeetingService
+export declare const userService: UserService
+export declare const messageService: MessageService
+export declare const localDataService: LocalDataService
+export declare const ossUploadService: OssUploadService
+export declare const resourceService: ResourceService
+export declare const firstLoadService: FirstLoadService
+export declare const firstLoadModelService: FirstLoadModelService
+export declare const dialogService: DialogService
+export declare const nativeEventService: NativeEventService
+export declare const pluginContainerService: PluginContainerService
+export declare const sceneService: SceneService
+export declare const contextMenuService: ContextMenuService
+export declare const batchApplyService: BatchApplyService
+export declare const cameraConfigurationAnimation: CameraConfigurationAnimation
+export declare const cameraLocationAnimation: CameraLocationAnimation
+export declare const fogAnimation: FogAnimation
+export declare const groundAnimation: GroundAnimation
+export declare const lightAnimation: LightAnimation
+export declare const shadowAnimation: ShadowAnimation
+export declare const skyboxAnimation: SkyboxAnimation
+export declare const easyPropertyAnimation: EasyPropertyAnimation
+export declare const rsLoopAnimationManager: RsLoopAnimationManager
+export declare const rsAudioService: RsAudioService
+export declare const rsSelectionService: RsSelectionService
+export declare const rsSelection: RsSelection
+export declare const rsNodeService: RsNodeService
+export declare const rsModelService: RsModelService
+export declare const rsEnvironment: RsEnvironment
+export declare const rsEnvironmentService: RsEnvironmentService
+export declare const rsTextureService: RsTextureService
+export declare const rsClick: RsClick
+export declare const rsLabelService: RsLabelService
+export declare const rsNodeMaterialManager: RsNodeMaterialManager
+export declare const rsMaterialService: RsMaterialService
+export declare const rsSeparateService: RsSeparateService
+export declare const rsService: RsService
+export declare const syncService: SyncService
+export declare const attributeService: AttributeService
+export declare const awarenessService: AwarenessService
+export declare const historyService: HistoryService
+export declare const rvGlobalService: RvGlobalService
+export declare const rvStepService: RvStepService
+export declare const rvFileService: RvFileService
+export declare const rvResourceService: RvResourceService
+export declare const rvSceneService: RvSceneService
+export declare const rvModelService: RvModelService
+export declare const rvNodeService: RvNodeService
+export declare const rvNodeMaterialAnalyzer: RvNodeMaterialAnalyzer
+export declare const targetMultiNodeService: TargetMultiNodeService
+export declare const targetNodeService: TargetNodeService
+export declare const targetStepService: TargetStepService
+export declare const rss: Record<string, string>