import {
  AnimationGroup,
  ArcRotateCamera,
  BaseTexture,
  Color3,
  Color4,
  CubeTexture,
  DynamicTexture,
  Engine,
  InputBlock,
  Light,
  Material,
  Mesh,
  Node as Node_2,
  NodeMaterial,
  NodeMaterialBlock,
  NodeMaterialBlockConnectionPointTypes,
  PBRMaterial,
  Quaternion,
  Scene,
  ShadowGenerator,
  StandardMaterial,
  Texture,
  TransformNode,
  Animation as Animation_2,
  AbstractMesh,
  Vector2,
  Vector3,
  WebGPUEngine,
} from '@babylonjs/core'
import { WebXRDefaultExperience } from '@babylonjs/core/XR/webXRDefaultExperience'
import { EmptyProps, InputNumberProps, SelectProps, SwitchProps } from 'antd'
import { Color, ColorPickerProps } from 'antd/es/color-picker'
import { DefaultOptionType } from 'antd/es/select'
import {
  Attributes,
  DetailedHTMLProps,
  FunctionComponent,
  HTMLAttributes,
  JSX,
  MouseEvent as MouseEvent_2,
  MouseEventHandler,
  default as React_2,
  ReactNode,
  ReactPortal,
} from 'react'
import { Root } from 'react-dom/client'
import {
  Awareness,
  EventType,
  RecursiveArray,
  RecursiveCrossRhineVar,
  RecursiveMap,
  RecursiveObject,
  RhineVarArray,
  RhineVarMap,
  RvPath,
  StoredRhineVar,
} from 'rhine-var'
import { AnyWebByteStream } from 'strtok3'

/**
 * @public
 */
export declare const AcceptMime: {
  ANY: string
  UNKNOWN: string
  SCENE: string
  MESH: string
  LIGHT: string
  CAMERA: string
  TEXTURE: string
  MATERIAL: string
  UV: string
  ANIMATION: string
  GLB: string
  GLTF: string
  STL: string
  OBJ: string
  MP3: string
  WAV: string
  AAC: string
  OGG: string
  FLAC: string
  OPUS: string
  JPG: string
  PNG: string
  GIF: string
  BMP: string
  WebP: string
  SVG: string
  TIFF: string
  ICO: string
  HEIF: string
  AVIF: string
  MP4: string
  WebM: string
  AVI: string
  MPEG: string
  MOV: string
  WMV: string
  FLV: string
  OGV: string
  GP3: string
  MKV: string
  JSON: string
  NF: string
  TXT: string
  MARKDOWN: string
  SUPPORT_IMAGE_LIST: string[]
  SUPPORT_MODEL_LIST: string[]
  SUPPORT_VIDEO_LIST: string[]
  SUPPORT_BABYLON_LIST: string[]
  SUPPORT_AUDIO_LIST: string[]
  SUPPORT_TEXT_LIST: string[]
  SUPPORT_JSON_LIST: string[]
  SUPPORT_NEXTFLOW_LIST: string[]
  SUPPORT_ALL_LIST: string[]
  SUPPORT_FILE_LIST: string[]
  SUPPORT_RENDER_LIST: string[]
  SUPPORT_TEXTURE_LIST: string[]
  ATTACH_LIST: string[]
  getMimeByBlob: typeof getMimeByBlob
  getMimeByPath: typeof getMimeByPath
  getMimeByUrl: typeof getMimeByUrl
  getMimeByBuffer: typeof getMimeByBuffer
  getMimeByStream: typeof getMimeByStream
  getMime: typeof getMime
  getExtension: typeof getExtension
  isSupport: typeof isSupport
  isSupportFile: typeof isSupportFile
  isSupportImage: typeof isSupportImage
  isSupportModel: typeof isSupportModel
  isSupportVideo: typeof isSupportVideo
  isSupportText: typeof isSupportText
  isSupportJson: typeof isSupportJson
  isBabylon: typeof isBabylon
  isSupportAudio: typeof isSupportAudio
  isSupportRender: typeof isSupportRender
  isSupportTexture: typeof isSupportTexture
  isTexture: typeof isTexture
  isMaterial: typeof isMaterial
  isUV: typeof isUV
  isAttach: typeof isAttach
}

/**
 * @public
 */
export declare interface AddLocalDataOption extends Omit<LocalData, 'status' | 'progress'> {
  status?: LocalDataStatus
  progress?: number
}

/**
 * @public
 */
export declare function Anchor(props: AnchorProps): JSX.Element

/**
 * @public
 */
export declare interface AnchorProps extends DivProps {
  list: string[]
  value: number
  onSelectChange: (value: number) => void
  middle?: boolean
}

/**
 * @public
 */
export declare class AnimationDuration {
  constructor()
  static BETWEEN: number
  static OPERATE: number
  static FIRST: number
  static IMMEDIATELY: number
  static RESET: number
}

/**
 * @public
 */
export declare class AnimationNativeAttribute extends NodeAttribute<RvNative> {
  path: string[]
  defaultValue: RvNative
  generate(sid: string, nid: string): RvNative
}

/**
 * @public
 */
export declare function AntCheckbox(props: AntCheckboxProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface AntCheckboxProps extends SwitchProps {
  value: boolean
  onChange: (value: boolean) => void
  className?: string | undefined
  label?: string
}

/**
 * @public
 */
export declare function AntColor(props: AntColorProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface AntColorProps extends ColorPickerProps {
  value: Color | string | null
  onColorChange: (value: string) => void
  className?: string
  classNameInner?: string
  theme?: string
}

/**
 * @public
 */
export declare function AntEmpty(props: AntEmptyProps): JSX.Element

/**
 * @public
 */
export declare interface AntEmptyProps extends EmptyProps {
  className?: string
  classNameInner?: string
  image?: ReactNode
  description?: ReactNode
  children?: ReactNode
}

/**
 * @public
 */
export declare function AntNumber(props: AntNumberProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface AntNumberProps extends Omit<InputNumberProps, 'onChange'> {
  value: number | null
  onChange: (value: number | null) => void
  placeholder?: string
  className?: string
  classNameInner?: string
  theme?: string
}

/**
 * @public
 */
export declare function AntSelect<ValueType>(props: AntSelectProps<ValueType>): React_2.JSX.Element

/**
 * @public
 */
export declare interface AntSelectProps<ValueType> extends SelectProps<ValueType> {
  value?: ValueType
  onChange?: (value: ValueType, option?: DefaultOptionType | DefaultOptionType[]) => void
  showSearch?: boolean
  onClick?: MouseEventHandler<HTMLDivElement>
  className?: string
  classNameInner?: string
  placeholder?: string
  optionFilterProp?: string
  size?: 'small' | 'middle' | 'large' | undefined
  options?: DefaultOptionType[]
}

/**
 * @public
 */
export declare function AntSwitch(props: AntSwitchProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface AntSwitchProps extends SwitchProps {
  value: boolean
  onChange: (value: boolean) => void
  className?: string | undefined
}

declare function approximatelyEqual(n1: number, n2: number, bias?: number): boolean

/**
 * @public
 */
export declare type Attribute<T extends object = never> = NodeAttribute<T> | StepAttribute<T> | GlobalAttribute<T>

/**
 * @public
 */
export declare class AttributeService {
  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: Attribute<T>): void
  /** 通过路径精确匹配获取属性 */
  get<T extends object = never>(type: AttributeType, path: RvPath | string): Attribute<T> | undefined
  /** 通过路径获取 NodeAttribute */
  getNodeAttribute<T extends object = never>(path: RvPath | string): NodeAttribute<T> | undefined
  /** 通过路径获取 StepAttribute */
  getStepAttribute<T extends object = never>(path: RvPath | string): StepAttribute<T> | undefined
  /** 通过路径获取 GlobalAttribute */
  getGlobalAttribute<T extends object = never>(path: RvPath | string): GlobalAttribute<T> | undefined
  /** 根据类型获取属性列表，不传入类型的时候返回所有 */
  getList(type?: AttributeType): Attribute<any>[]
  isPathConflict(type: AttributeType, path: RvPath): boolean
  createContainer(source: StoredRhineVar, path: RvPath): RecursiveMap<unknown>
}

/**
 * @public
 */
export declare enum AttributeType {
  Global = 'GLOBAL',
  Step = 'STEP',
  Node = 'NODE',
}

/**
 * @public
 */
export declare class AutoPlayService {
  static get instance(): AutoPlayService
  private constructor()
  next(interval: number, loop: boolean): void
  hasNextStep(loop: boolean): boolean
  tryNextStep(loop: boolean): true | undefined
}

/**
 * @public
 */
export declare interface AwarenessChanges {
  added: number[]
  updated: number[]
  removed: number[]
}

/**
 * @public
 */
export declare type AwarenessChangeSubscriber = (
  changeStates: Map<number, RvAwareness>,
  changes: AwarenessChanges,
) => void

/**
 * @public
 */
export declare class AwarenessService {
  DEFAULT_UPDATE_INTERVAL: number
  static get instance(): AwarenessService
  private constructor()
  name: string
  color: string
  static COLORS: string[]
  awareness: Awareness | undefined
  states: Map<number, RvAwareness>
  setLocalState(state?: RvAwareness): void
  setLocalStateCamera(state?: RvCameraLocation): void
  setLocalStateField(field: string, state: unknown): void
  getLocalState(): Record<string, any> | null
  startUpdate(): void
  stopUpdate(): void
  setUpdateInterval(interval: number): void
  resetUpdateInterval(): void
  subscribeChange(subscriber: AwarenessChangeSubscriber): () => void
  unsubscribeChange(subscriber: AwarenessChangeSubscriber): void
  getCurrentRvAwareness(): RvAwareness
  CLICK_RETENTION_PERIOD: number
  CLICK_MAX_COUNT: number
  addClick(position: V3): void
}

/**
 * @public
 */
export declare abstract class BaseAttribute<T extends object = never> {
  abstract type: AttributeType
  abstract path: RvPath
  defaultValue: T
  getPathString(): string
  isMyPath(path: string | RvPath): boolean
}

/**
 * @public
 */
export declare interface BasePlugin {
  id: string
  version: string
  namespace: string
  intl?: Intl_2
  createIntl: (namespace: string) => Intl_2
  name: string
  description: string
  type: PluginType
  theme: ThemeColor
  data?: Record<string, unknown>
  messages?: Record<Locale, MessageTree>
  onInstall?: () => Promise<void>
  onEnable?: () => Promise<void>
  onDisable?: () => Promise<void>
  onUninstall?: () => Promise<void>
}

/**
 * @public
 */
export declare function BatchApply(props: BatchApplyProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface BatchApplyProps extends DivProps {
  tip?: string
  onConfirm?: () => void
  onCancel?: () => void
}

/**
 * @public
 */
export declare class BatchApplyService {
  static get instance(): BatchApplyService
  _selected: string[]
  private constructor()
  get selected(): string[]
  set selected(selected: string[])
  selectAll(): void
  unselectAll(): void
  isAllSelected(): boolean
  subscribe(subscriber: BatchApplySubscriber): () => void
  unsubscribe(subscriber: BatchApplySubscriber): void
  forEach(f: (rvStep: StoredRhineVar<RvStep>) => void): void
  forEachAttributes(f: (rvNode: StoredRhineVar<RvNode>) => void): void
}

/**
 * @public
 */
export declare type BatchApplySubscriber = (selected: string[]) => void

/**
 * @public
 */
export declare interface C3 {
  r: number
  g: number
  b: number
}

/**
 * @public
 */
export declare interface C4 {
  r: number
  g: number
  b: number
  a: number
}

/**
 * @public
 */
export declare class CameraConfigurationAnimation {
  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
}

/**
 * @public
 */
export declare class CameraLocationAnimation {
  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[]
}

declare function check(str: string): boolean

/**
 * 检查路径是否与目标列表中的任意路径重叠
 * @param from - 要检查的路径
 * @param targetList - 目标路径列表
 * @returns 如果与任意目标路径重叠则返回 true
 */
declare function checkAnyRvPathOverlay(from: RvPath | string, targetList: (RvPath | string)[]): boolean

/**
 * 检查路径是否与目标列表中的任意路径完全相同
 * @param from - 要检查的路径
 * @param targetList - 目标路径列表
 * @returns 如果与任意目标路径相同则返回 true
 */
declare function checkAnyRvPathSame(from: RvPath | string, targetList: (RvPath | string)[]): boolean

/**
 * @public
 */
export declare function CheckboxLine(): JSX.Element

/**
 * 检查两段路径是否完全重叠
 * 长度可不同，从开头开始每一项比较，直到有一方结束，是否全部相同
 * @param from - 第一个路径
 * @param target - 第二个路径
 * @returns 如果路径重叠则返回 true
 * @example
 * ```ts
 * RvUtils.checkRvPathOverlay("a.b", "a.b.c") // true
 * RvUtils.checkRvPathOverlay("a.b", "a.c") // false
 * ```
 */
declare function checkRvPathOverlay(from: RvPath | string, target: RvPath | string): boolean

/**
 * 检查两段路径是否完全相同
 * @param from - 第一个路径
 * @param target - 第二个路径
 * @returns 如果路径完全相同则返回 true
 * @example
 * ```ts
 * RvUtils.checkRvPathSame("a.b", "a.b") // true
 * RvUtils.checkRvPathSame("a.b", "a.b.c") // false
 * ```
 */
declare function checkRvPathSame(from: RvPath | string, target: RvPath | string): boolean

declare function checkRvPathStartWith(from: RvPath | string, target: RvPath | string): boolean

declare function chunkHash(file: File): Promise<string>

declare function computeSHA256(buffer: BufferSource): Promise<string>

/**
 * @public
 */
export declare class ContextMenu {
  options: ContextMenuCreateOptions
  id: string
  lines: MenuLine[]
  showIcon: boolean
  x: number
  y: number
  closeOnOutsideClick: boolean
  theme?: ThemeColor | undefined
  controller: ContextMenuController | null
  createTime: Date
  constructor(
    options: ContextMenuCreateOptions,
    id: string,
    lines?: MenuLine[],
    showIcon?: boolean,
    x?: number,
    y?: number,
    closeOnOutsideClick?: boolean,
    theme?: ThemeColor | undefined,
    controller?: ContextMenuController | null,
    createTime?: Date,
  )
  static fromOptions(id: string, options: ContextMenuCreateOptions, menuLines?: MenuLine[]): ContextMenu
}

/**
 * @public
 */
export declare interface ContextMenuController {
  contextMenu: ContextMenu
  show(): void
  destroy(): void
}

/**
 * @public
 */
export declare interface ContextMenuCreateOptions {
  id?: string
  lines?: MenuLineCreateOptions[]
  showIcon?: boolean
  x?: number
  y?: number
  closeOnOutsideClick?: boolean
  theme?: ThemeColor
  onClose?: () => void
}

/**
 * @public
 */
export declare class ContextMenuService {
  static get instance(): ContextMenuService
  private constructor()
  contextMenus: ContextMenu[]
  create(options: ContextMenuCreateOptions): ContextMenuController
  get(id: string): ContextMenu | undefined
  close(contextMenu: string | ContextMenu): Promise<boolean>
  closeAll(): Promise<number>
}

declare function convertBytesToHigherUnit(bn: number): string

declare function convertTimeText(seconds: number): string

declare function copyCurrentUrlToClipboard(): Promise<boolean>

declare function copyText(text: string): Promise<boolean>

/**
 * @public
 */
export declare const CryptoUtils: {
  computeSHA256: typeof computeSHA256
}

/**
 * @public
 */
export declare const DataUtils: {
  recursPathValue: typeof recursPathValue
}

declare function degreesToQuaternion(v: V3): Quaternion

declare function degreeToRadians(v: V3): V3

/**
 * @public
 */
export declare class Dialog {
  options: DialogCreateOptions
  id: string
  title: string
  titleIcon: FunctionComponent | string | undefined
  content: string
  contentAlign: DialogContentAlign
  contentView: FunctionComponent | string | undefined
  icon: FunctionComponent | string | undefined
  view: FunctionComponent | string | undefined
  theme: ThemeColor
  leftMode: boolean
  className: string
  style: object
  confirmText: string
  cancelText: string
  enableInput: boolean
  defaultValue: string
  inputPlaceholder: string
  autoFocus: boolean
  allowEmpty: boolean
  onChange: (value: string) => void
  onCheck: (value: string) => boolean
  enableCloseButton: boolean
  onConfirm: (value: string) => void
  onCancel: () => void
  onClose: () => void
  onConfirmButtonClick: () => void
  onCancelButtonClick: () => void
  onOutsideClick: () => void
  onCloseButtonClick: () => void
  onRender: () => void
  onEffect: () => () => void
  closeOnConfirm: boolean
  closeOnCancel: boolean
  closeOnOutsideClick: boolean
  closeOnCloseButtonClick: boolean
  alignButton: boolean
  inputValue: string
  createTime: Date
  focusInput: () => void
  elements: Map<string, HTMLElement>
  constructor(
    options: DialogCreateOptions,
    id: string,
    title?: string,
    titleIcon?: FunctionComponent | string | undefined,
    content?: string,
    contentAlign?: DialogContentAlign,
    contentView?: FunctionComponent | string | undefined,
    icon?: FunctionComponent | string | undefined,
    view?: FunctionComponent | string | undefined,
    theme?: ThemeColor,
    leftMode?: boolean,
    className?: string,
    style?: object,
    confirmText?: string,
    cancelText?: string,
    enableInput?: boolean,
    defaultValue?: string,
    inputPlaceholder?: string,
    autoFocus?: boolean,
    allowEmpty?: boolean,
    onChange?: (value: string) => void,
    onCheck?: (value: string) => boolean,
    enableCloseButton?: boolean,
    onConfirm?: (value: string) => void,
    onCancel?: () => void,
    onClose?: () => void,
    onConfirmButtonClick?: () => void,
    onCancelButtonClick?: () => void,
    onOutsideClick?: () => void,
    onCloseButtonClick?: () => void,
    onRender?: () => void,
    onEffect?: () => () => void,
    closeOnConfirm?: boolean,
    closeOnCancel?: boolean,
    closeOnOutsideClick?: boolean,
    closeOnCloseButtonClick?: boolean,
    alignButton?: boolean,
    inputValue?: string,
    createTime?: Date,
    focusInput?: () => void,
    elements?: Map<string, HTMLElement>,
  )
  static fromOptions(id: string, options: DialogCreateOptions): Dialog
  setHide: (value: boolean) => void
}

/**
 * @public
 */
export declare enum DialogContentAlign {
  LEFT = 'LEFT',
  CENTER = 'CENTER',
  RIGHT = 'RIGHT',
}

/**
 * @public
 */
export declare interface DialogCreateOptions {
  id?: string
  title?: string
  titleIcon?: FunctionComponent | string
  content?: string
  contentAlign?: DialogContentAlign
  contentView?: FunctionComponent | string
  icon?: FunctionComponent | string
  view?: FunctionComponent | string
  theme?: ThemeColor
  leftMode?: boolean
  className?: string
  style?: object
  confirmText?: string
  cancelText?: string
  enableCloseButton?: boolean
  enableInput?: boolean
  defaultValue?: string
  inputPlaceholder?: string
  autoFocus?: boolean
  allowEmpty?: boolean
  onChange?: (value: string) => void
  onCheck?: (value: string) => boolean
  onConfirm?: (value: string) => void
  onCancel?: () => void
  onClose?: () => void
  onConfirmButtonClick?: () => void
  onCancelButtonClick?: () => void
  onOutsideClick?: () => void
  onCloseButtonClick?: () => void
  onRender?: () => void
  onEffect?: () => () => void
  closeOnConfirm?: boolean
  closeOnCancel?: boolean
  closeOnOutsideClick?: boolean
  closeOnCloseButtonClick?: boolean
  alignButton?: boolean
}

/**
 * @public
 */
export declare interface DialogPlugin extends IconPlugin {
  options: DialogCreateOptions
  view: MixView<PluginViewProps>
  onRender?: () => void
}

/**
 * @public
 */
export declare class DialogService {
  static get instance(): DialogService
  private constructor()
  create(options: DialogCreateOptions, show?: boolean): Promise<Dialog>
  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>
}

/**
 * @public
 */
export declare type DivProps = DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>

/**
 * @public
 */
export declare type DivPropsSimple = Omit<DivProps, 'onChange' | 'defaultValue'>

/**
 * @public
 */
export declare class DomNotFoundError extends NotFoundError {
  constructor(message: string)
}

/**
 * @public
 */
export declare interface DrawerPlugin extends IconPlugin {
  title: string
  tip: string
  weight: number
  drawer: MixView<PluginViewProps>
  onRender?: () => void
  onTitleClick?: () => void
  onTitleContextMenu?: () => void
}

/**
 * @public
 */
export declare class EasyPropertyAnimation {
  static get instance(): EasyPropertyAnimation
  private constructor()
  animationMap: Map<
    string,
    {
      animationGroup?: AnimationGroup
      timeout?: ReturnType<typeof setTimeout>
    }
  >
  play(
    id: string,
    type: number,
    node: SupportAnimationTarget,
    keys: string[],
    to: number | Quaternion | Color3 | Color4 | Vector2 | Vector3,
    duration?: number,
    quickMode?: boolean,
    from?: number | Quaternion | Color3 | Color4 | Vector2 | Vector3 | undefined,
    ease?: boolean,
  ): void
  playSplit(id: string, callback: () => void, duration?: number, quickMode?: boolean): void
  stop(id: string): boolean
}

/**
 * @public
 */
export declare enum EnableLevel {
  NONE = 'NONE',
  INSTALL = 'INSTALL',
  ENABLE = 'ENABLE',
  OPEN = 'OPEN',
}

declare function ensureFileArray(files: File | File[] | FileList | null | undefined): File[]

/**
 * 确保路径为 RvPath 数组格式
 * @param path - 字符串路径或 RvPath 数组
 * @returns RvPath 数组
 */
declare function ensureRvPath(path: string | RvPath): RvPath

/**
 * 确保路径为字符串格式
 * @param path - 字符串路径或 RvPath 数组
 * @returns 字符串路径
 */
declare function ensureRvPathString(path: string | RvPath): string

declare function extractFilenameFromUrl(url: string, includeExtension?: boolean): string

declare function fetchBlobWithRetry(url: string, retries?: number): Promise<Blob>

declare function fetchJsonWithRetry(url: string, retries?: number): Promise<unknown>

/**
 * @public
 */
export declare interface FileData {
  fid: string
  status: LocalDataStatus
  name: string
  progress: number
  mime: string
  filename?: string
  extension?: string
  description?: string
  size?: string
  preview?: string
}

/**
 * @public
 */
export declare function FileProgressBar(props: FileProgressBarProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface FileProgressBarProps extends DivProps {
  size: string
  value: number
  className?: string
  theme?: string
}

/**
 * @public
 */
export declare const FileUtils: {
  to3n: typeof to3n
  convertBytesToHigherUnit: typeof convertBytesToHigherUnit
  splitName: typeof splitName
  ensureFileArray: typeof ensureFileArray
  chunkHash: typeof chunkHash
  isSameFile: typeof isSameFile
  getFileInfo: typeof getFileInfo
}

/**
 * @public
 */
export declare class FirstLoadModelService {
  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
  subscribe(subscriber: FirstLoadModelServiceSubscriber): () => void
  unsubscribe(subscriber: FirstLoadModelServiceSubscriber): void
}

/**
 * @public
 */
export declare enum FirstLoadModelServiceEventType {
  START = 'START',
  PROGRESS = 'PROGRESS',
  LOADED = 'LOADED',
  ERROR = 'ERROR',
  CANCELED = 'CANCELED',
}

/**
 * @public
 */
export declare enum FirstLoadModelServiceStatus {
  WAITING = 'WAITING',
  LOADING = 'LOADING',
  LOADED = 'LOADED',
  ERROR = 'ERROR',
  CANCELED = 'CANCELED',
}

/**
 * @public
 */
export declare type FirstLoadModelServiceSubscriber = (type: FirstLoadModelServiceEventType) => void

/**
 * @public
 */
export declare class FirstLoadService {
  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
  subscribe(subscriber: FirstLoadServiceSubscriber): () => void
  unsubscribe(subscriber: FirstLoadServiceSubscriber): void
}

/**
 * @public
 */
export declare enum FirstLoadServiceEventType {
  START = 'START',
  PROGRESS = 'PROGRESS',
  LOADED = 'LOADED',
  ERROR = 'ERROR',
  CANCELED = 'CANCELED',
}

/**
 * @public
 */
export declare enum FirstLoadServiceStatus {
  WAITING = 'WAITING',
  LOADING = 'LOADING',
  LOADED = 'LOADED',
  ERROR = 'ERROR',
  CANCELED = 'CANCELED',
}

/**
 * @public
 */
export declare type FirstLoadServiceSubscriber = (type: FirstLoadServiceEventType) => void

/**
 * @public
 */
export declare function FlexGrow(props: { value?: number }): JSX.Element

/**
 * @public
 */
export declare interface FlexGrowProps {
  value?: number
}

/**
 * @public
 */
export declare enum FocusMode {
  DEFAULT = 'DEFAULT',
  DESCRIPTION = 'DESCRIPTION',
}

/**
 * @public
 */
export declare class FogAnimation {
  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
}

declare function formatDateTo17Digits(date?: Date): string

declare function formatDuration(startTimestamp: number, endTimestamp: number): string

declare function fromQuaternion(q: Quaternion): V4

declare function fromVector3(v: Vector3): V3

/**
 * @public
 */
export declare function getBlockDiagonalLength(
  x1: number,
  y1: number,
  z1: number,
  x2: number,
  y2: number,
  z2: number,
): number

/**
 * 根据路径从对象中获取值
 * @typeParam T - 返回值的类型
 * @param source - 源对象
 * @param path - 访问路径
 * @returns 路径对应的值，如果路径不存在则返回 undefined
 * @example
 * ```ts
 * RvUtils.getByRvPath({ a: { b: 1 } }, "a.b") // 1
 * ```
 */
declare function getByRvPath<T = unknown>(source: StoredRhineVar, path: string | RvPath): T | undefined

declare function getDistance(x1: number, y1: number, x2: number, y2: number): number

declare function getDistance3d(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number

declare function getDistanceBetweenEvents(e1: ReactEvent | NativeEvent, e2: ReactEvent | NativeEvent): number

declare function getEventPosition(e: ReactEvent | NativeEvent): [x: number, y: number]

declare function getExtension(mime?: string): Promise<string>

declare function getFileInfo(url: string): Promise<{
  name: string
  size: number
}>

declare function getHashParam(name: string): string

declare function getMime(
  input?: File | Blob | string | ArrayBuffer | Uint8Array | AnyWebByteStream | BaseTexture | Material,
): Promise<string>

declare function getMimeByBlob(object?: File | Blob): Promise<string>

declare function getMimeByBuffer(buffer?: ArrayBuffer | Uint8Array): Promise<string>

declare function getMimeByPath(path?: string): Promise<string>

declare function getMimeByStream(stream: AnyWebByteStream): Promise<string>

declare function getMimeByUrl(url?: string): Promise<string>

/**
 * @public
 */
export declare function getNearestAngle(source: number, target: number): number

/**
 * @public
 */
export declare function getNearestAngleVector3(source: Vector3, target: Vector3): Vector3

declare function getNearestNumberIndex(x: number, list: number[]): number

declare function getPageTypeBySpaceText(space: string): PageType

declare function getParam(name: string): string

/**
 * @public
 */
export declare function getPointDistance(p1: Vector3, p2: Vector3): number

declare function getSearchParams(key: string): string | undefined

/**
 * @public
 */
export declare abstract class GlobalAttribute<T extends object = never> extends BaseAttribute<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
  subscribe(subscriber: GlobalAttributeSubscriber<T>): () => void
  unsubscribe(subscriber: GlobalAttributeSubscriber<T>): void
}

/**
 * @public
 */
export declare type GlobalAttributeSubscriber<T> = (
  type: EventType,
  path: RvPath,
  value: unknown,
  oldValue: unknown,
) => void

/**
 * @public
 */
export declare class GroundAnimation {
  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 interface HighLightInfo {
  uid: number
  color: string
}

/**
 * @public
 */
export declare class HistoryService {
  static get instance(): HistoryService
  private constructor()
  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
  subscribe(subscriber: HistoryServiceSubscriber): () => void
  unsubscribe(subscriber: HistoryServiceSubscriber): void
  subscribeState(subscriber: HistoryServiceStateSubscriber): () => void
  unsubscribeState(subscriber: HistoryServiceStateSubscriber): void
  white(): void
}

/**
 * @public
 */
export declare enum HistoryServiceEventType {
  'UNDO' = 'UNDO',
  'REDO' = 'REDO',
}

/**
 * @public
 */
export declare type HistoryServiceStateSubscriber = (state: unknown) => void

/**
 * @public
 */
export declare type HistoryServiceSubscriber = (type: HistoryServiceEventType, operate: string) => void

/**
 * @public
 */
export declare interface IconPlugin extends BasePlugin {
  position: IconPluginPosition
  group: string
  label: string
  color: ThemeColor
  open: boolean
  icon: MixView<IconViewProps>
  onEnabledChange?: (value: boolean, e: MouseEvent) => void
  onIconClick?: (e: MouseEvent) => void
  onIconClickRouter?: (e: MouseEvent) => string
  onIconContextMenu?: (e: MouseEvent) => void
}

/**
 * @public
 */
export declare enum IconPluginPosition {
  TOP = 0,
  RIGHT = 1,
  BOTTOM = 2,
  LEFT = 3,
  TOP_LEFT = 4,
  BOTTOM_LEFT = 5,
  TOP_RIGHT = 6,
  BOTTOM_RIGHT = 7,
  UNKNOWN = 8,
}

/**
 * @public
 */
export declare interface IconViewProps extends DivProps {
  plugin: IconPlugin
}

/**
 * @public
 */
export declare const IMMEDIATELY_MODE_THRESHOLD_INTERVAL = 67

/**
 * @public
 */
export declare function InternationalizationProvider(props: InternationalizationProviderProps): JSX.Element

/**
 * @public
 */
export declare interface InternationalizationProviderProps {
  children?: ReactNode
}

/**
 * @public
 */
export declare class InternationalizationService {
  static get instance(): InternationalizationService
  private constructor()
  ALL_SUPPORT: Locale[]
  DEFAULT_SUPPORT: Locale
  locale: Locale
  messages: MessageTree
  load(messages: MessageTree, namespace?: string): boolean
  createIntl(namespace?: string): Intl_2
  hasIntlCached(namespace?: string): boolean
  deleteIntlCached(namespace?: string): boolean
  clearIntlCached(namespace?: string): void
  createIntlWithWait(namespace?: string): Promise<Intl_2>
  subscribe(subscriber: NamespaceSubscriber): () => void
  unsubscribe(subscriber: NamespaceSubscriber): void
  wait(namespace: string): Promise<void>
}

/**
 * @public
 */
declare type Intl_2 = (strings: TemplateStringsArray, ...values: unknown[]) => string
export { Intl_2 as Intl }

/**
 * @public
 */
export declare function isAbstractMesh(node: Node_2): node is Mesh | AbstractMesh

declare function isAttach(mime?: string): boolean

declare function isBabylon(mime?: string): boolean

declare function isChangeEventType(
  type: EventType | string,
): type is EventType.ADD | EventType.UPDATE | EventType.DELETE

/**
 * @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

declare function isFiniteVector(v: V3): boolean

declare function isMaterial(mime?: string): boolean

/**
 * @public
 */
export declare function isMesh(node: Node_2): node is Mesh

/**
 * 判断两个文件是否相同
 *
 * @param file - 目标文件
 * @param name - 另一个文件的名称
 * @param size - 另一个文件的大小
 * @param hash - 另一个文件的哈希 (可选) (通过上方 chunkHash 函数计算得出)
 *
 * @returns  是否相同
 */
declare function isSameFile(file: File, name: string, size: number, hash?: string): Promise<boolean>

declare function isSupport(mime?: string): boolean

declare function isSupportAudio(mime?: string): boolean

declare function isSupportFile(mime?: string): boolean

declare function isSupportImage(mime?: string): boolean

declare function isSupportJson(mime?: string): boolean

declare function isSupportModel(mime?: string): boolean

declare function isSupportRender(mime?: string): boolean

declare function isSupportText(mime?: string): boolean

declare function isSupportTexture(mime?: string): boolean

declare function isSupportVideo(mime?: string): boolean

declare function isTexture(mime?: string): boolean

declare function isUV(mime?: string): boolean

declare function isValidNumber(value: unknown): value is number

/**
 * @public
 */
export declare function joinPath(...args: (string | URL | JoinPathOptions)[]): string

/**
 * 一律用正斜杠（/）的智能路径拼接（URL 或 文件路径）。
 *
 * 设计要点
 * - 传入任意数量的段，顺序拼接
 * - 自动识别 URL（含 protocol-relative 的 //host）与 file://
 * - 文件路径（POSIX/Windows/UNC/驱动器号）统一输出为正斜杠
 * - 规范化重复斜杠、"."、".."
 * - 末尾斜杠可选（默认不保留）
 * - ?query 与 #hash 以最后一个非空段为准（URL 模式才生效）
 *
 */
declare interface JoinPathOptions {
  /** 是否保留末尾斜杠（默认 false） */
  keepTrailingSlash?: boolean
  /** 强制作为 URL 处理（默认自动识别） */
  treatAsUrl?: boolean
}

/**
 * @public
 */
export declare class LabelInfo {
  nid: string
  node: TransformNode | null
  text: string
  theme: LabelTheme
  x: number
  y: number
  parentElement: HTMLDivElement | null
  pointElement: HTMLDivElement | null
  lineElement: HTMLDivElement | null
  blockElement: HTMLDivElement | null
  textElement: HTMLDivElement | null
  validate: boolean
  always: boolean
  show: boolean
  lastClickTime: number
  lastSp: Vector3 | null
  constructor(nid: string, node?: TransformNode | null, text?: string, theme?: LabelTheme, x?: number, y?: number)
}

/**
 * @public
 */
export declare enum LabelTheme {
  Default = 'Default',
}

/**
 * @public
 */
export declare type LastSubscriber = (value: RsSelectionNodeInfo | null) => void

/**
 * @public
 */
export declare class LightAnimation {
  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
}

/**
 * @public
 */
export declare interface LocalData {
  fid: string
  type: LocalDataType
  mime: string
  status: LocalDataStatus
  progress: number
  url?: string
  blob?: Blob
  text?: string
  json?: unknown
  texture?: BaseTexture
  material?: Material
  uv?: unknown
  object?: unknown
}

/**
 * @public
 */
export declare class LocalDataService {
  static get instance(): LocalDataService
  private constructor()
  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
  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
}

/**
 * @public
 */
export declare enum LocalDataServiceEventType {
  ADD = 'ADD',
  REMOVE = 'REMOVE',
  START = 'START',
  PROGRESS = 'PROGRESS',
  PAUSE = 'PAUSE',
  RESUME = 'RESUME',
  LOADED = 'LOADED',
  ERROR = 'ERROR',
  CANCELED = 'CANCELED',
}

/**
 * @public
 */
export declare type LocalDataServiceSubscriber = (type: LocalDataServiceEventType, LocalData: LocalData) => void

/**
 * @public
 */
export declare enum LocalDataStatus {
  WAITING = 'WAITING',
  LOADING = 'LOADING',
  PAUSED = 'PAUSED',
  LOADED = 'LOADED',
  FAILED = 'FAILED',
  CANCELED = 'CANCELED',
}

/**
 * @public
 */
export declare enum LocalDataType {
  BLOB = 'BLOB',
  OBJECT = 'OBJECT',
}

/**
 * @public
 */
export declare enum Locale {
  ZH = 'zh',
  EN = 'en',
}

/**
 * @public
 */
export declare function MainPortal(props: MainPortalProps): ReactPortal

/**
 * @public
 */
export declare interface MainPortalProps {
  children: ReactNode
}

/**
 * 将字符串路径转换为 RvPath 数组
 * @param path - 以点分隔的路径字符串，如 "a.0.b"
 * @returns RvPath 数组，数字字符串会被转换为数字类型
 * @example
 * RvUtils.makeRvPath("a.0.b") // ['a', 0, 'b']
 */
declare function makeRvPath(path: string): RvPath

/**
 * 将 RvPath 数组转换为字符串路径
 * @param path - RvPath 数组
 * @returns 以点分隔的路径字符串
 * @example
 * RvUtils.makeRvPathString(['a', 0, 'b']) // "a.0.b"
 */
declare function makeRvPathString(path: RvPath): string

/**
 * @public
 */
export declare function MaterialSymbol(props: MaterialSymbolProps): React_2.JSX.Element

/**
 * @public
 */
export declare function materialSymbol(
  icon: string,
  options?: MaterialSymbolOptions,
): FunctionComponent<Record<string, never>>

/**
 * @public
 */
export declare type MaterialSymbolFunction = (icon: string, options?: MaterialSymbolOptions) => FunctionComponent

/**
 * @public
 */
export declare interface MaterialSymbolOptions {
  fill?: boolean
  size?: string
  color?: string
  className?: string
  style?: React_2.CSSProperties
}

/**
 * @public
 */
export declare interface MaterialSymbolProps extends SpanProps {
  size?: string
  color?: string
  className?: string
  fill?: boolean
}

/**
 * @public
 */
export declare const MathUtils: {
  toDegrees: typeof toDegrees
  toRadians: typeof toRadians
  approximatelyEqual: typeof approximatelyEqual
  getDistance: typeof getDistance
  getDistance3d: typeof getDistance3d
  getNearestNumberIndex: typeof getNearestNumberIndex
}

/**
 * @public
 */
export declare class MeetingService {
  static get instance(): MeetingService
  private constructor()
  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
  readonly IN_MEETING_STATUS: MeetingStatus[]
  inMeeting(): boolean
  isPresenter(): boolean
  isVisitor(): boolean
  isFollowingVisitor(): boolean
  isUnfollowingVisitor(): boolean
  subscribe(subscriber: MeetingStateSubscriber): () => void
  unsubscribe(subscriber: MeetingStateSubscriber): void
  getInvitationLink(): string
}

/**
 * @public
 */
export declare interface MeetingState {
  meetingId: string
  presenterId: number
  status: MeetingStatus
  startTime: number
  peopleCount: number
  forceFollow: boolean
  clickShareMode: ShareMode
  cursorShareMode: ShareMode
  selfFollow: boolean
}

/**
 * @public
 */
export declare type MeetingStateSubscriber = (state: MeetingState) => void

/**
 * @public
 */
export declare enum MeetingStatus {
  PENDING = 'PENDING',
  PROGRESSING = 'PROGRESSING',
  ENDED = 'ENDED',
  CANCELED = 'CANCELED',
  BANNED = 'BANNED',
}

/**
 * @public
 */
export declare class MenuLine {
  options: MenuLineCreateOptions
  id: string
  type: MenuLineType
  text: string
  tip: string
  icon: FunctionComponent | undefined
  view: FunctionComponent | undefined
  color: string
  disabled: boolean
  shortcut: string
  onClick: (e: MouseEvent_2) => void
  onMouseOver: (e: MouseEvent_2) => void
  onMouseOut: (e: MouseEvent_2) => void
  closeAllOnClick: boolean
  checkboxDefaultValue: boolean
  onCheckboxChange: (value: boolean) => void
  sub: ContextMenuCreateOptions | undefined
  createTime: Date
  constructor(
    options: MenuLineCreateOptions,
    id: string,
    type?: MenuLineType,
    text?: string,
    tip?: string,
    icon?: FunctionComponent | undefined,
    view?: FunctionComponent | undefined,
    color?: string,
    disabled?: boolean,
    shortcut?: string,
    onClick?: (e: MouseEvent_2) => void,
    onMouseOver?: (e: MouseEvent_2) => void,
    onMouseOut?: (e: MouseEvent_2) => void,
    closeAllOnClick?: boolean,
    checkboxDefaultValue?: boolean,
    onCheckboxChange?: (value: boolean) => void,
    sub?: ContextMenuCreateOptions | undefined, // 子菜单项
    createTime?: Date,
  )
  static fromOptions(id: string, options: MenuLineCreateOptions): MenuLine
}

/**
 * @public
 */
export declare interface MenuLineCreateOptions {
  id?: string
  type?: MenuLineType
  text?: string
  tip?: string
  icon?: FunctionComponent
  view?: FunctionComponent
  color?: string
  disabled?: boolean
  shortcut?: string
  onClick?: (e: MouseEvent_2) => void
  onMouseOver?: (e: MouseEvent_2) => void
  onMouseOut?: (e: MouseEvent_2) => void
  closeAllOnClick?: boolean
  checkboxDefaultValue?: boolean
  onCheckboxChange?: (value: boolean) => void
  sub?: ContextMenuCreateOptions
}

/**
 * @public
 */
export declare enum MenuLineType {
  BUTTON = 'BUTTON', // 单个点击用按钮
  DIVIDER = 'DIVIDER', // 分割线
  CHECKBOX = 'CHECKBOX', // 单个可选中复选框
  SUB = 'SUB', // 二级菜单
  VIEW = 'VIEW',
}

/**
 * @public
 */
export declare class Message {
  text: string
  type: MessageType
  duration: number
  id: number
  show: boolean
  height: number
  opacity: number
  constructor(text: string, type: MessageType, duration: number, id: number)
}

/**
 * @public
 */
export declare type MessageLeaf = string

/**
 * @public
 */
export declare type MessageLoader = (locale: Locale) => Promise<MessageTree>

/**
 * @public
 */
export declare class MessageService {
  static get instance(): MessageService
  private constructor()
  messages: Message[]
  info(text: string, translateNamespace?: string, duration?: number): void
  success(text: string, translateNamespace?: string, duration?: number): void
  warning(text: string, translateNamespace?: string, duration?: number): void
  error(text: string, translateNamespace?: string, duration?: number): void
  showWithTranslate(text: string, type: MessageType, translateNamespace?: string, duration?: number): Promise<void>
  show(text: string, type: MessageType, duration?: number): Promise<void>
}

/**
 * @public
 */
export declare type MessageState = 'before' | 'show' | 'after'

/**
 * @public
 */
export declare interface MessageTree {
  [key: string]: MessageTree | MessageLeaf
}

/**
 * @public
 */
export declare type MessageType = 'info' | 'warning' | 'error' | 'success'

/**
 * @public
 */
export declare type MixView<T extends Attributes | null = null> = string | FunctionComponent<T>

/**
 * @public
 */
export declare type NamespaceSubscriber = (namespaces: string[]) => void

/**
 * @public
 */
export declare type NativeAnyEventSubscriber = (e: Event | null) => void

/**
 * @public
 */
export declare type NativeDragEventSubscriber = (e: DragEvent) => void

declare type NativeEvent = MouseEvent | DragEvent | TouchEvent | WheelEvent

/**
 * @public
 */
export declare class NativeEventService {
  static get instance(): NativeEventService
  PLAYER_ID: string
  CANVAS_ID: string
  private constructor()
  subscribeClick(subscriber: NativeMouseEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribeClick(subscriber: NativeMouseEventSubscriber): void
  subscribeContextMenu(subscriber: NativeMouseEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribeContextMenu(subscriber: NativeMouseEventSubscriber): void
  subscribeDoubleClick(subscriber: NativeMouseEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribeDoubleClick(subscriber: NativeMouseEventSubscriber): void
  subscribeDrag(subscriber: NativeDragEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribeDrag(subscriber: NativeDragEventSubscriber): void
  subscribeDrop(subscriber: NativeDragEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribeDrop(subscriber: NativeDragEventSubscriber): void
  subscribeWheel(subscriber: NativeWheelEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribeWheel(subscriber: NativeWheelEventSubscriber): void
  subscribePointerDown(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribePointerDown(subscriber: NativePointerEventSubscriber): void
  subscribePointerMove(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribePointerMove(subscriber: NativePointerEventSubscriber): void
  subscribePointerUp(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribePointerUp(subscriber: NativePointerEventSubscriber): void
  subscribePointerCancel(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribePointerCancel(subscriber: NativePointerEventSubscriber): void
  subscribePointerEnter(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribePointerEnter(subscriber: NativePointerEventSubscriber): void
  subscribePointerLeave(subscriber: NativePointerEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribePointerLeave(subscriber: NativePointerEventSubscriber): void
  subscribeKeyDown(subscriber: NativeKeyboardEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribeKeyDown(subscriber: NativeKeyboardEventSubscriber): void
  subscribeKeyUp(subscriber: NativeKeyboardEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribeKeyUp(subscriber: NativeKeyboardEventSubscriber): void
  subscribeKeyDownExceptInput(
    subscriber: NativeKeyboardEventSubscriber,
    option?: NativeEventSubscribeOption,
  ): () => void
  unsubscribeKeyDownExceptInput(subscriber: NativeKeyboardEventSubscriber): void
  subscribeKeyUpExceptInput(subscriber: NativeKeyboardEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribeKeyUpExceptInput(subscriber: NativeKeyboardEventSubscriber): void
  subscribeFocus(subscriber: NativeFocusEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribeFocus(subscriber: NativeFocusEventSubscriber): void
  subscribeBlur(subscriber: NativeFocusEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribeBlur(subscriber: NativeFocusEventSubscriber): void
  subscribeScroll(subscriber: NativeUIEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribeScroll(subscriber: NativeUIEventSubscriber): void
  subscribeResize(subscriber: NativeAnyEventSubscriber, option?: NativeEventSubscribeOption): () => void
  unsubscribeResize(subscriber: NativeAnyEventSubscriber): void
}

/**
 * @public
 */
export declare interface NativeEventSubscribeOption {
  canvasOnly?: boolean
  once?: boolean
  capture?: boolean
}

/**
 * @public
 */
export declare const NativeEventUtils: {
  getEventPosition: typeof getEventPosition
  getDistanceBetweenEvents: typeof getDistanceBetweenEvents
  preventDefaultListener: typeof preventDefaultListener
  stopPropagationListener: typeof stopPropagationListener
  preventDefaultStopPropagationListener: typeof preventDefaultStopPropagationListener
}

/**
 * @public
 */
export declare type NativeFocusEventSubscriber = (e: FocusEvent) => void

/**
 * @public
 */
export declare type NativeKeyboardEventSubscriber = (e: KeyboardEvent) => void

/**
 * @public
 */
export declare type NativeMouseEventSubscriber = (e: MouseEvent) => void

/**
 * @public
 */
export declare type NativePointerEventSubscriber = (e: PointerEvent) => void

/**
 * @public
 */
export declare type NativeUIEventSubscriber = (e: UIEvent) => void

/**
 * @public
 */
export declare type NativeWheelEventSubscriber = (e: WheelEvent) => void

/**
 * @public
 */
export declare const NetworkUtils: {
  fetchJsonWithRetry: typeof fetchJsonWithRetry
  fetchBlobWithRetry: typeof fetchBlobWithRetry
}

/**
 * @public
 */
export declare abstract class NodeAttribute<T extends object = never> extends BaseAttribute<T> {
  type: AttributeType
  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
  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
  subscribeTarget(subscriber: NodeAttributeTargetSubscriber<T>): () => void
  unsubscribeTarget(subscriber: NodeAttributeTargetSubscriber<T>): void
}

/**
 * @public
 */
export declare type NodeAttributeTargetSubscriber<T extends object = never> = (
  type: TChangeType,
  path: RvPath,
  value: unknown,
  oldValue: unknown,
  sid: string,
  nid: string,
  nidList: string[],
) => void

/**
 * @public
 */
export declare type NodeMaterialChangeListener = (nid: string, fid: string, material: NodeMaterial) => void

/**
 * @public
 */
export declare interface NodeMaterialInfo {
  nid: string
  fid: string
  material: NodeMaterial
}

/**
 * @public
 */
export declare interface NodePair {
  nid: string
  uniqueId: number
  node: Node_2
}

/**
 * To [-PI, PI)
 * @public
 */
export declare function normalizeAngle(angle: number): number

/**
 * @public
 */
export declare function normalizeVector3Angle(vector: Vector3): Vector3

/**
 * @public
 */
export declare class NotFoundError extends Error {
  constructor(message: string)
}

declare function noZero(v: V3): boolean

/**
 * @public
 */
export declare const NumberUtils: {
  roundToX: typeof roundToX
  r2: typeof r2
  r3: typeof r3
  isValidNumber: typeof isValidNumber
}

/**
 * @public
 */
export declare interface OssUploadInstance {
  fid: string
  file: File
  status: OssUploadInstanceStatus
  progress: number
  data?: unknown
}

/**
 * @public
 */
export declare enum OssUploadInstanceStatus {
  WAITING = 'WAITING',
  UPLOADING = 'UPLOADING',
  PAUSED = 'PAUSED',
  COMPLETED = 'COMPLETED',
  FAILED = 'FAILED',
  CANCELED = 'CANCELED',
}

/**
 * @public
 */
export declare class OssUploadService {
  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
  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
}

/**
 * @public
 */
export declare enum OssUploadServiceEventType {
  START = 'START',
  PROGRESS = 'PROGRESS',
  PAUSE = 'PAUSE',
  RESUME = 'RESUME',
  UPLOADED = 'UPLOADED',
  FAILED = 'FAILED',
  CANCELED = 'CANCELED',
}

/**
 * @public
 */
export declare type OssUploadServiceSubscriber = (
  type: OssUploadServiceEventType,
  ossUploadInstance: OssUploadInstance,
) => void

/**
 * @public
 */
export declare interface Page {
  type: PageType
  mode: PageMode
  viewing: boolean
  pid: string
  sid: string
}

/**
 * @public
 */
export declare enum PageMode {
  DISPLAY = 'DISPLAY', // 正常显示
  FULL = 'FULL', // 3D 场景全屏 - 隐藏所有 UI 元素
  HP_BOX = 'HP_BOX', // 全息投影盒 - 隐藏所有 UI 元素 - 且四摄像头渲染
  VR = 'VR', // VR 模式
  MR = 'MR',
}

/**
 * @public
 */
export declare enum PageType {
  EDITOR = 'EDITOR',
  VIEWER = 'VIEWER',
  VISITOR = 'VISITOR',
}

/**
 * @public
 */
export declare const PageUtils: {
  getPageTypeBySpaceText: typeof getPageTypeBySpaceText
  getSearchParams: typeof getSearchParams
}

declare type PathValueArray<T = unknown> = {
  path: RvPath
  value: T
}[]

/**
 * @public
 */
export declare interface PluginConfig {
  id: string
  url: string
  entry: string
  css?: string
  messages?: {
    path: string
    namespace: string
    support: Locale[]
    default: Locale
  }
  official?: boolean
  necessary?: boolean
  private?: boolean
  information: {
    name: string
    icon?: FunctionComponent | string
    version?: string
    description?: string
  }
}

/**
 * @public
 */
export declare class PluginConnector {
  static get instance(): PluginConnector
  private constructor()
  install(plugin: BasePlugin): Promise<void>
}

/**
 * @public
 */
export declare class PluginContainerService {
  /**
   * @public
   */
  static get instance(): PluginContainerService
  private constructor()
  /**
   * @public
   */
  get pluginList(): BasePlugin[]
  /**
   * @public
   */
  addPlugin(plugin: BasePlugin): void
  /**
   * @public
   */
  removePlugin(plugin: BasePlugin): void
  /**
   * @public
   */
  openPlugin(plugin: IconPlugin): Promise<boolean>
  /**
   * @public
   */
  closePlugin(plugin: IconPlugin): Promise<boolean>
  /**
   * @public
   */
  closeDrawerPluginByPosition(position: IconPluginPosition): Promise<boolean>
}

/**
 * @public
 */
export declare enum PluginEventType {
  ADD = 'ADD',
  INSTALL = 'INSTALL',
  ENABLE = 'ENABLE',
  OPEN = 'OPEN',
  CLOSE = 'CLOSE',
  DISABLE = 'DISABLE',
  UNINSTALL = 'UNINSTALL',
  DEBUG = 'DEBUG',
}

/**
 * @public
 */
export declare interface PluginInformation {
  plugin: BasePlugin
  root?: Root
  iconButton?: HTMLSpanElement
}

/**
 * @public
 */
export declare class PluginService {
  static get instance(): PluginService
  private constructor()
  plugins: Map<string, PluginState>
  DETAILED_LOG_MODE: boolean
  INSTALL_TIMEOUT: number
  DEBUG_INSTALL_TIMEOUT: number
  createPreLoadedHook(id: string): void
  completePreLoadedHook(id: string): void
  createPreRenderedHook(id: string): void
  completePreRenderedHook(id: string): void
  protected checkPreLoaded(): void
  protected checkPreRendered(): void
  subscribe(subscriber: PluginServiceSubscriber): () => void
  unsubscribe(subscriber: PluginServiceSubscriber): void
  get(id: string): PluginState | undefined
  add(config: PluginConfig): Promise<boolean>
  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>
  isOpenablePlugin(type: PluginType): boolean
  isSideBarPlugin(type: PluginType): boolean
  isViewPlugin(type: PluginType): boolean
}

/**
 * 插件服务订阅者
 *
 * @param id - 插件id
 * @param type - 事件类型
 * @public
 */
export declare type PluginServiceSubscriber = (id: string, type: PluginEventType) => void

/**
 * @public
 */
export declare interface PluginState {
  instance?: BasePlugin
  element?: HTMLScriptElement
  styleElement?: HTMLLinkElement
  installed: boolean
  enabled: boolean
  debug?: boolean
}

/**
 * @public
 */
export declare enum PluginType {
  BUTTON = 'BUTTON',
  SWITCH = 'SWITCH',
  DRAWER = 'DRAWER',
  DIALOG = 'DIALOG',
  CONTENT = 'CONTENT',
  WINDOW = 'WINDOW',
  SERVICE = 'SERVICE',
}

/**
 * @public
 */
export declare interface PluginViewProps extends DivProps {
  plugin: DrawerPlugin | ViewPlugin | DialogPlugin
}

declare function preventDefaultListener(e: ReactEvent): void

declare function preventDefaultStopPropagationListener(e: ReactEvent): void

/**
 * @public
 */
export declare function ProgressBar(props: ProgressBarProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface ProgressBarProps extends React_2.HTMLAttributes<HTMLDivElement> {
  value?: number
  indeterminate?: boolean
  slowTransition?: boolean
  innerClassName?: string
}

declare function r2(n: number): number

declare function r3(n: number): number

declare function radiansToDegrees(v: V3): V3

declare function radiansToQuaternion(v: V3): Quaternion

declare type ReactEvent = React_2.MouseEvent | React_2.DragEvent | React_2.TouchEvent | React_2.WheelEvent

/**
 * @public
 */
export declare function recursNode(node: Node_2, fun: (node: Node_2) => void): void

declare function recursPathValue<T>(path: RvPath, value: T): PathValueArray<T>

/**
 * @public
 */
export declare function removeMixView(parent: HTMLElement): void

/**
 * @public
 */
export declare function renderMixView<T extends Attributes | null = null>(
  view: MixView<T>,
  parent: HTMLElement,
  props?: T,
): void

/**
 * @public
 */
export declare function ResourcePreview(props: ResourcePreviewProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface ResourcePreviewProps extends DivProps {
  className?: string
  mime?: string
  preview?: string
}

/**
 * ResourceService
 * @public
 */
export declare class ResourceService {
  /**
   * @public
   */
  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

declare function roundToX(num: number, x: number): number

/**
 * 动画管理器对象
 * @public
 */
export declare class RsAnimationManager {
  constructor()
  static initialize(): Promise<void>
  static analysisAnimationDuration(step: StoredRhineVar<RvStep>, lastStep?: RvStep): number
  static specialAnimation(): void
}

/**
 * @public
 */
export declare class RsAudioService {
  static get instance(): RsAudioService
  private constructor()
  processStepAudioMap(step: StoredRhineVar<RvStep>): void
  fadeOutAndPauseAllAudio(): void
  processAudioMap(audioMap: RvAudio | undefined, idKey: string): void
}

/**
 * @public
 */
export declare class RsBasicService {
  static get instance(): RsBasicService
  private constructor()
  updateBasic(
    nid: string,
    node: Node_2,
    path: string[] | RvPath,
    value: unknown,
    rvBasic: StoredRhineVar<RvBasic>,
  ): void
  updateEnable(
    nid: string,
    node: Node_2,
    rvBasic: RvBasic,
    recursive: boolean,
    duration?: number,
    quickMode?: boolean,
  ): void
}

/**
 * @public
 */
export declare class RsClick {
  static get instance(): RsClick
  private constructor()
  simplifyDoneList(delay: number): void
  show(position: V3, color: string, timestamp: number, duration?: number, id?: string): void
}

/**
 * @public
 */
export declare function RsdButton(props: RsdButtonProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface RsdButtonProps extends DivProps {
  onClick: MouseEventHandler<HTMLDivElement>
  dashed?: boolean
  text: string
  tip?: string
  icon?: string
  iconSize?: number
  single?: boolean
}

/**
 * @public
 */
export declare function RsdCheckableButton(props: RsdCheckableButtonProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface RsdCheckableButtonProps extends DivPropsSimple {
  value: boolean
  onChange: (value: boolean) => void
  label: string
  className?: string
  theme?: string
  children?: ReactNode
}

/**
 * @public
 */
export declare function RsdCheckbox(props: RsdCheckboxProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface RsdCheckboxProps extends DivPropsSimple {
  value: boolean
  onChange: (value: boolean) => void
  label: string
  className?: string
  theme?: string
}

/**
 * @public
 */
export declare function RsdColor(props: RsdColorProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface RsdColorProps extends DivPropsSimple {
  value: string
  onChange: (value: string) => void
  label: string
  disableAlpha?: boolean
  className?: string
  theme?: string
}

/**
 * @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 interface RsdFileSelectProps extends DivPropsSimple {
  label: string
  value: string
  onChange: (value: string) => void
  accept: string[]
  tip?: string
  className?: string
  theme?: ThemeColor
}

/**
 * @public
 */
export declare function RsdInput(props: RsdInputProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface RsdInputProps extends DivPropsSimple {
  value: string
  onChange: (value: string) => void
  type?: 'text' | 'number' | 'password'
  placeholder?: string
  className?: string
  theme?: string
  rows?: number
  maxLength?: number
}

/**
 * @public
 */
export declare function RsdMentions(props: RsdMentionsProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface RsdMentionsProps extends DivPropsSimple {
  value: string
  onChange: (value: string) => void
  type?: 'text' | 'number' | 'password'
  placeholder?: string
  className?: string
  theme?: string
  rows?: number
}

/**
 * @public
 */
export declare function RsdNone(props: RsdNoneProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface RsdNoneProps extends DivProps {
  label: string
  className?: string
  theme?: string
}

/**
 * @public
 */
export declare function RsdNumber(props: RsdNumberProps): React_2.JSX.Element

/**
 * @public
 */
export declare function RsdNumberList(props: RsdNumberListProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface RsdNumberListProps extends DivProps {
  style?: React.CSSProperties
  value: number[]
  keys: string[]
  onChangeIndex: (index: number, value: number | null) => void
  min?: number
  className?: string
  theme?: string
  shrink?: boolean
}

/**
 * @public
 */
export declare interface RsdNumberProps extends DivPropsSimple {
  value: number | null
  onChange: (value: number | null) => void
  label: string
  placeholder?: string
  className?: string
  theme?: string
  unit?: string
  min?: number
  max?: number
  step?: number
}

/**
 * @public
 */
export declare function RsdSelect(props: RsdSelectProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface RsdSelectProps<ValueType = string> extends DivPropsSimple {
  value: ValueType
  defaultValue?: ValueType
  options: {
    value: ValueType
    label: string
  }[]
  onChange: (value: ValueType) => void
  label: string
  className?: string
  theme?: string
  smallWidth?: boolean
}

/**
 * @public
 */
export declare function RsdSwitch(props: RsdSwitchProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface RsdSwitchProps extends DivPropsSimple {
  value: boolean
  onChange: (value: boolean) => void
  label: string
  className?: string
  theme?: string
}

/**
 * @public
 */
export declare function RsdTargetInfo(props: RsdTargetInfoProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface RsdTargetInfoProps extends DivPropsSimple {
  nid: string
  getSummaryText?(): string
  getTipText?(): string
  showTipText?: boolean
  showGetChildrenTip?: boolean
}

/**
 * @public
 */
export declare function RsdTextarea(props: RsdInputProps): React_2.JSX.Element

/**
 * @public
 */
export declare function RsdTitle(props: RsdTitleProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface RsdTitleProps extends DivProps {
  title: string
  className?: string
  tip?: string
  detail?: string
  mt?: boolean
}

/**
 * @public
 */
export declare class RsEnableService {
  /**
   * @public
   */
  static get instance(): RsEnableService
  private constructor()
  get(nid: string): boolean
  clear(): void
}

/**
 * @public
 */
export declare class RsEngine {
  static get instance(): RsEngine
  private constructor()
  canvas: HTMLCanvasElement | null
  initialized: boolean
  initialize(): Promise<void>
}

/**
 * @public
 */
export declare class RsEnvironment {
  static get instance(): RsEnvironment
  private constructor()
  mainCamera: ArcRotateCamera
  rightCamera: ArcRotateCamera
  backCamera: ArcRotateCamera
  leftCamera: ArcRotateCamera
  lights: Light[]
  shadow: ShadowGenerator
  environmentTexture: CubeTexture
  STANDARD_MODE: boolean
  adjustCamera(models: AbstractMesh[] | AbstractMesh): void
  getCameraInfo(): {
    target: {
      x: number
      y: number
      z: number
    }
    alpha: number
    beta: number
    radius: number
  }
  addShadows(meshes: AbstractMesh[] | AbstractMesh): void
  initLight(): void
  initFourCamera(camerasNode: TransformNode): void
  setActiveCamera(isFour?: boolean): void
  normalizeCameraAngle(): void
  setCameraDistance(distance: number): void
  setBackgroundColor(color: Color3): void
  getPositionToCameraDistance(p: V3 | Vector3): number
}

/**
 * @public
 */
export declare class RsEnvironmentService {
  static get instance(): RsEnvironmentService
  private constructor()
  updateEnvironment(path: RvPath, step: StoredRhineVar<RvStep>): void
  getCurrentCameraLocation(): RvCameraLocation
}

/**
 * 管理和渲染3D场景中的标签
 * @public
 */
export declare class RsLabelService {
  static get instance(): RsLabelService
  private constructor()
  labels: LabelInfo[]
  updateClick(nid: string | null | undefined): void
  getLabel(nid: string): LabelInfo | null
  ensureLabel(nid: string, node?: TransformNode | null): LabelInfo
  removeLabel(nid: string): void
  updateLabelWithNid(nid: string, rvLabel: RvLabel): void
}

/**
 * @public
 */
export declare class RsLoopAnimationManager {
  static get instance(): RsLoopAnimationManager
  private constructor()
  state: {
    enableInEditorMode: boolean
  }
  restartAnimation(nid: string, resetLocation?: boolean): void
  startAllLoopAnimations(): void
  startAnimationLoop(nid: string, node: TransformNode, data: RvLoop, locationData: RvLocation): void
  stopAllLoopAnimations(resetLocation?: boolean): void
  stopAnimation(nid: string): void
  makeTripAnimation(dis: number, speed: number, start: number, name: string, axis: string, fr: number): 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
}

/**
 * @public
 */
export declare class RsMaterialService {
  static get instance(): RsMaterialService
  private constructor()
  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 interface RsModel {
  mid: string
  progress: number
  status: RsModelStatus
  node?: Node_2
}

/**
 * @public
 */
export declare class RsModelService {
  static get instance(): RsModelService
  private constructor()
  DETAILED_LOG_MODE: boolean
  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
  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
}

/**
 * @public
 */
export declare enum RsModelServiceEventType {
  ADD = 'ADD',
  REMOVE = 'REMOVE',
  START = 'START',
  PROGRESS = 'PROGRESS',
  PAUSE = 'PAUSE',
  RESUME = 'RESUME',
  LOADED = 'LOADED',
  ERROR = 'ERROR',
  CANCELED = 'CANCELED',
}

/**
 * @public
 */
export declare type RsModelServiceSubscriber = (type: RsModelServiceEventType, rsModel: RsModel) => void

/**
 * @public
 */
export declare enum RsModelStatus {
  WAITING = 'WAITING',
  LOADING = 'LOADING',
  LOADED = 'LOADED',
  ERROR = 'ERROR',
  CANCELED = 'CANCELED',
}

/**
 * @public
 */
export declare class RsNodeMaterialAnalyzer {
  /**
   * @public
   */
  static get instance(): RsNodeMaterialAnalyzer
  static TEXTURE_NAME_MAP: Map<string, string>
  isTextureBlockName(name: string): boolean
}

/**
 * @public
 */
export declare class RsNodeMaterialManager {
  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>
  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 {
  /**
   * 获取 RsNodeService 单例实例
   *
   * @returns RsNodeService 单例对象
   */
  static get instance(): RsNodeService
  private constructor()
  /**
   * 解析节点映射关系
   *
   * 从 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
  /**
   * 生成节点映射对并保存到 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
  /**
   * 生成场景节点结构并添加到 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
  /**
   * 根据 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
  /**
   * 订阅节点映射变化
   *
   * 当 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
}

/**
 * RsSceneService 管理所有场景节点的嵌套关系变动
 * @public
 */
export declare class RsSceneService {
  static get instance(): RsSceneService
  private constructor()
  syncAll(): void
  sync(nid: string, sceneNode?: RvSceneNode | null, targetNode?: Node_2 | null, parentNode?: Node_2 | null): boolean
}

/**
 * @public
 */
export declare class RsSelection {
  static get instance(): RsSelection
  private constructor()
  gm: GizmoManager | null
  makeInfo(nid: string): RsSelectionNodeInfo | null
}

/**
 * @public
 */
export declare interface RsSelectionMaterialInfo {
  allNumber: number
  supportEditMaterialNumber: number
  hasGeometryNumber: number
  hasOtherMaterialNumber: number
  hasChildrenNumber: number
  isAbstractMeshNumber: number
}

/**
 * @public
 */
export declare interface RsSelectionNodeInfo {
  nid: string
  nodeName: string
  babylonNode: Node_2
  uniqueId: number
  mid: string
  modelLoadName: string
  rvModel: RvModel
  isTransformNode: boolean
  isAbstractMesh: boolean
  isMesh: boolean
  isCoordinateFlip: boolean
  isCoordinateRotation: boolean
  hasGeometry: boolean
  isRoot: boolean
  childrenNumber: number
  supportQuaternion: boolean
  animationNumber: number
  skeletonNumber: number
  hasMaterial: boolean
  isSupportMaterial: boolean
  supportEditMaterial: boolean
}

/**
 * @public
 */
export declare class RsSelectionService {
  static get instance(): RsSelectionService
  private constructor()
  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[]
  changeBranchMode(value?: boolean, message?: boolean): void
  toAllChildren(log?: boolean): boolean
  subscribe(subscriber: SelectedSubscriber): () => void
  unsubscribe(subscriber: SelectedSubscriber): void
  subscribeLast(subscriber: LastSubscriber): () => void
  unsubscribeLast(subscriber: LastSubscriber): void
}

/**
 * @public
 */
export declare interface RsSelectionState {
  highlight: HighLightInfo[]
  selected: RsSelectionNodeInfo[]
  last: RsSelectionNodeInfo | null
  branchMode: boolean
  materialInfo: RsSelectionMaterialInfo
}

/**
 * @public
 */
export declare class RsSeparateService {
  static get instance(): RsSeparateService
  private constructor()
  separated: string[]
  has(nid: string): boolean
  add(nid: string, mesh?: AbstractMesh, material?: Material | null): void
  /**
   * 获取节点分离后的材质
   *
   * 如果材质已经分离，则返回分离后的材质，为分离则先复制并分离再返回新材质。
   *
   * @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
}

/**
 * @public
 */
export declare class RsService {
  static get instance(): RsService
  private constructor()
  canvas: HTMLCanvasElement | undefined
  scene: Scene | undefined
  engine: Engine | WebGPUEngine | undefined
  rendering: boolean
  experience: WebXRDefaultExperience | null
  initialize(canvas: HTMLCanvasElement, scene: Scene, engine: Engine | WebGPUEngine): void
  isSupportWebXR(): boolean
  isWebXRInitialized(): boolean
  enterVR(onInitialize: () => void): Promise<void>
}

/**
 * @public
 */
export declare class RsTextureService {
  static get instance(): RsTextureService
  private constructor()
  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
}

/**
 * @public
 */
export declare class RsTransformGround {
  static get instance(): RsTransformGround
  private constructor()
  readonly root: TransformNode
  readonly ground: Mesh | undefined
  readonly mb: StandardMaterial
  readonly m1: NodeMaterial
  readonly m10: NodeMaterial
  readonly m1Color: InputBlock
  readonly m10Color: InputBlock
  readonly m1Alpha: InputBlock
  readonly m10Alpha: InputBlock
  g1: Mesh | undefined
  g10: Mesh | undefined
  createGround(): void
  hideGround(): void
  showGround(): void
  freshGround(viewing?: boolean, enableOnViewerMode?: boolean, enableOnEditorMode?: boolean): void
}

/**
 * @public
 */
export declare interface RvAnimation {
  loop?: RvLoop
  embedded?: RvNative
}

/**
 * @public
 */
export declare enum RvAttachType {
  TEXTURE = 'TEXTURE',
  MATERIAL = 'MATERIAL',
  UV = 'UV',
}

/**
 * @public
 */
export declare interface RvAudio {
  autoPlay: boolean
  fid: string
  loop: boolean
  speed: number
  volume: number
}

/**
 * @public
 */
export declare interface RvAwareness {
  clientId: number
  user: RvAwarenessUser
  device: RvAwarenessDevice
  sid: string
  meetingId: string
  selected: string[]
  camera: RvCameraLocation
  clicks: RvAwarenessClick[]
  window: RvAwarenessWindow
  cursor: V3
  openedDrawers: string[]
}

/**
 * @public
 */
export declare interface RvAwarenessClick {
  position: V3
  timestamp: number
}

/**
 * @public
 */
export declare interface RvAwarenessDevice {
  platform: string
}

/**
 * @public
 */
export declare interface RvAwarenessUser {
  name: string
  color: string
  avatar: string
  uuid: string
}

/**
 * @public
 */
export declare interface RvAwarenessWindow {
  innerWidth: number
  innerHeight: number
}

/**
 * @public
 */
export declare interface RvBase {
  global: RvGlobal
  order: RhineVarArray<string>
  steps: RhineVarMap<RvStep>
  plugin: RvPlugin
  files: RhineVarMap<RvFile>
  resources: RhineVarMap<RvResource>
  scene: RhineVarMap<RvSceneNode>
  models: RhineVarMap<RvModel>
  separate: RvSeparate
  history: RvHistory
  meetings: RhineVarMap<RvMeeting>
  version: RvVersion
}

/**
 * @public
 */
export declare interface RvBasic {
  enable: boolean
  isPickable: boolean
  visibility: number
  receiveShadows: boolean
}

/**
 * @public
 */
export declare class RvBasicAttribute {
  static get instance(): RvBasicAttribute
  private constructor()
  key: keyof RvNode
  defaultValue: RvBasic
  generate(nid: string): RvBasic
  ensure(nid: string, easyCheck?: boolean): boolean
}

/**
 * @public
 */
export declare interface RvBasicConfig {
  type: RvBasicType
  args?: Record<string, number>
  text?: string
}

/**
 * @public
 */
export declare enum RvBasicType {
  TEXT = 'TEXT',
  CUBE = 'CUBE',
  SPHERE = 'SPHERE',
  CONE = 'CONE',
  PRISM = 'PRISM',
  POLYHEDRON = 'POLYHEDRON',
  TORUS = 'TORUS',
  CYLINDER = 'CYLINDER',
  ICO_SPHERE = 'ICO_SPHERE',
  CAPSULE = 'CAPSULE',
  PLANE = 'PLANE',
}

/**
 * @public
 */
export declare interface RvCamera {
  enable: boolean
  location: RvCameraLocation
  config: {
    easy: boolean
    distanceMin: number
    distanceMax: number
    fov: number
  }
}

/**
 * @public
 */
export declare interface RvCameraLocation {
  alpha: number
  beta: number
  radius: number
  target: V3
}

/**
 * @public
 */
export declare interface RvCode {
  jumpTargetOnClick: string
}

/**
 * @public
 */
export declare class RvCodeAttribute {
  private constructor()
  key: keyof RvNode
  defaultValue: {
    jumpTargetOnClick: string
  }
  generate(): RvCode
  ensure(nid: string, easyCheck?: boolean): boolean
}

/**
 * @public
 */
export declare interface RvConfiguration {
  information: {
    collapseDescription: boolean
    description: string
    favorite: boolean
    group: string
  }
  interval: {
    enable: boolean
    enter: number
    exit: number
  }
  jump: {
    delay: number
    onlyOnce: boolean
    target: string
  }
  ui: {
    theme: ThemeBackground
    enableStepChangeButton: boolean
    enableTopbar: boolean
    hideStep: boolean
    importantStep: boolean
  }
  audio: RvAudio
  secondAudio: RvAudio
}

/**
 * @public
 */
export declare interface RvEnvironment {
  skybox: {
    background: string
  }
  light: {
    intensity: number
    diffuseColor: string
    specularColor: string
  }
  ground: {
    opacityRate: number
    baseColor: string
    enableOnViewerMode: boolean
    enableOnEditorMode: boolean
  }
  shadow: {
    enable: boolean
    darkness: number
    blurOffset: number
    blurScale: number
    onlyOnGround: boolean
    normalBias: number
  }
  camera: RvCamera
  fog: {
    enable: boolean
    density: number
    color: string
  }
}

/**
 * @public
 */
export declare interface RvFile {
  fid: string
  type: RvFileType
  name: string
  size: number
  mime: string
  hash?: string
  url: string
  createdAt: number
  updatedAt: number
  uploading?: boolean
  extra?: Record<string, unknown>
}

/**
 * @public
 */
export declare class RvFileService {
  static get instance(): RvFileService
  private constructor()
  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
  subscribe(subscriber: RvFileServiceSubscriber): () => void
  unsubscribe(subscriber: RvFileServiceSubscriber): void
  subscribeSingle(fid: string, subscriber: RvFileServiceSubscriber): () => void
  unsubscribeSingle(fid: string, subscriber: RvFileServiceSubscriber): void
  generateId(): string
  findSame(file: File): Promise<string | null>
}

/**
 * @public
 */
export declare enum RvFileServiceEventType {
  ADD = 'ADD',
  REMOVE = 'REMOVE',
}

/**
 * @public
 */
export declare type RvFileServiceSubscriber = (
  type: RvFileServiceEventType,
  fid: string,
  rvFile?: RecursiveObject<RvFile>,
) => void

/**
 * @public
 */
export declare enum RvFileType {
  OSS = 'OSS',
  URL = 'URL',
}

/**
 * @public
 */
export declare interface RvGlobal {
  information: {
    title: string
    description: string
    tags: string
  }
  ui: {
    theme: ThemeBackground
  }
  playing: {
    auto: boolean
    loop: boolean
    interval: number
  }
  support: {
    VR: boolean
    AR: boolean
    MR: boolean
    HP: boolean
  }
}

/**
 * @public
 */
export declare class RvGlobalService {
  static get instance(): RvGlobalService
  private constructor()
  state: StoredRhineVar<RvGlobal>
}

/**
 * @public
 */
export declare interface RvHistory {
  white: number
}

/**
 * @public
 */
export declare interface RvLabel {
  enable: boolean
  text: string
  alwaysShow: boolean
}

/**
 * @public
 */
export declare class RvLabelAttribute {
  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 interface RvLocation {
  position: V3
  rotation?: V3
  nearMode: boolean
  scale: V3
  rotationQuaternion?: V4
}

/**
 * @public
 */
export declare class RvLocationAttribute {
  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 interface RvLoop {
  rotationSpeed: V3
  rotationPivot: V3
  slideSpeed: V3
  slideDistance: V3
}

/**
 * @public
 */
export declare class RvLoopAttribute {
  static get instance(): RvLoopAttribute
  private constructor()
  key: string
  defaultValue: RvLoop
  generate(): RvLoop
  ensure(nid: string, easyCheck?: boolean): boolean
}

/**
 * @public
 */
export declare interface RvMaterial {
  general: RvMaterialGeneral
  preset: RvPresetType
  pbr?: RvMaterialPBR
  node?: RvMaterialNode
  texture: RvMaterialTexture
}

/**
 * @public
 */
export declare class RvMaterialAttribute {
  static get instance(): RvMaterialAttribute
  private constructor()
  /**
   * @public
   */
  key: keyof RvNode
  /**
   * @public
   */
  defaultPBRValue: RvMaterialPBR
  /**
   * @public
   */
  defaultNodeValue: RvMaterialNode
  /**
   * @public
   */
  defaultTextureValue: RvMaterialTexture
  /**
   * @public
   */
  defaultValue: RvMaterial
  /**
   * @public
   */
  generate(nid: string): RvMaterial
  /**
   * @public
   */
  ensure(nid: string, easyCheck?: boolean): boolean
  /**
   * @public
   */
  generateTexture(textureMap?: Map<string, BaseTexture>, material?: PBRMaterial | NodeMaterial): RvMaterialTexture
  /**
   * @public
   */
  generatePBR(material?: PBRMaterial): RvMaterialPBR
  /**
   * @public
   */
  generatePreset(rvMaterial?: RvMaterial): RvPresetType
  /**
   * @public
   */
  generateNode(material?: NodeMaterial): RvMaterialNode
}

/**
 * @public
 */
export declare interface RvMaterialGeneral {
  type: RvMaterialType
  isExtracted: boolean
  transparencyMode: TransparencyMode
  needDepthPrePass: boolean
}

/**
 * @public
 */
export declare interface RvMaterialNode {
  fid: string
  inputs: RvMaterialNodeInput[]
}

/**
 * @public
 */
export declare interface RvMaterialNodeInput {
  type: NodeMaterialBlockConnectionPointTypes
  key: string
  value: string | number
  range?: [number, number]
}

/**
 * @public
 */
export declare interface RvMaterialPBR {
  basic: {
    albedoColor: string
    metallic: number
    roughness: number
    emissiveColor: string
    alpha: number
  }
  advance: {
    reflectivityColor: string
    ambientColor: string
    indexOfRefraction: number
    metallicF0Factor: number
    reflectionColor: string
  }
  coat: {
    enable: boolean
    intensity: number
    roughness: number
    indexOfRefraction: number
    useRoughnessFromMainTexture: boolean
    clearCoatTexture: string
    roughnessTexture: string
    bumpTexture: string
    enableTint: boolean
    tintColor: string
    atDistance: number
    tintThickness: number
  }
}

/**
 * @public
 */
export declare interface RvMaterialTexture {
  basic: {
    albedoTexture: string
    metallicRoughnessTexture: string
    bumpTexture: string
    emissiveTexture: string
    opacityTexture: string
    ambientTexture: string
    reflectionTexture: string
    metallicReflectanceTexture: string
    refractionTexture: string
    reflectivityTexture: string
    microSurfaceTexture: string
    lightMapTexture: string
    detailMapTexture: string
    reflectanceTexture: string
    tintTexture: string
  }
  extra: {
    texture1: string
    texture2: string
    texture3: string
    texture4: string
  }
}

/**
 * @public
 */
export declare enum RvMaterialType {
  NONE = 'NONE',
  PBR = 'PBR',
  STANDARD = 'STANDARD',
  NODE = 'NODE',
  OTHER = 'OTHER',
  TERRAIN = 'TERRAIN',
  FUR = 'FUR',
  WATER = 'WATER',
  LAVA = 'LAVA',
  SKY = 'SKY',
  BACKGROUND = 'BACKGROUND',
  MULTI = 'MULTI',
  SHADER = 'SHADER',
}

/**
 * @public
 */
export declare interface RvMeeting {
  meetingId: string
  status: MeetingStatus
  startTime: number
  current: RvMeetingCurrent
  statistic: RvMeetingStatistic
  endTime?: number
}

/**
 * @public
 */
export declare interface RvMeetingCurrent {
  presenterId: number
  state: {
    peopleCount: number
  }
  config: {
    forceFollow: boolean
    clickShareMode: ShareMode
    cursorShareMode: ShareMode
  }
  visitors: number[]
}

/**
 * @public
 */
export declare class RvMeetingService {
  static get instance(): RvMeetingService
  private constructor()
  meetings: RecursiveMap<RvMeeting>
  getRvMeeting(meetingId: string): StoredRhineVar<RvMeeting> | null
  generateId(): string
  removeAllMeetings(): void
}

/**
 * @public
 */
export declare interface RvMeetingStatistic {
  people: {
    total: number
  }
}

/**
 * @public
 */
export declare interface RvModel {
  mid: string
  name: string
  origin: RvModelOrigin
  fid?: string
  config?: RvBasicConfig | Record<string, unknown>
  node?: string
}

/**
 * @public
 */
export declare interface RvModelNode {
  nid: string
  name: string
  children?: RvModelNode[]
}

/**
 * @public
 */
export declare enum RvModelOrigin {
  BASIC = 'BASIC',
  PROVIDE = 'PROVIDE',
  UPLOAD = 'UPLOAD',
}

/**
 * @public
 */
export declare class RvModelService {
  static get instance(): RvModelService
  private constructor()
  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 interface RvNative {
  enableAnimation: boolean
  playTime: number
  startFrame: number
  endFrame: number
  enableLoop: boolean
  speedRatio: number
}

/**
 * @public
 */
export declare class RvNativeAttribute {
  static get instance(): RvNativeAttribute
  private constructor()
  key: string
  defaultValue: RvNative
  generate(nid: string): RvNative
  ensure(nid: string, easyCheck?: boolean): boolean
}

/**
 * @public
 */
export declare interface RvNode {
  basic?: RvBasic
  location?: RvLocation
  material?: RvMaterial
  label?: RvLabel
  animation?: RvAnimation
  code?: RvCode
}

/**
 * @public
 */
export declare class RvNodeMaterialAnalyzer {
  static get instance(): RvNodeMaterialAnalyzer
  ensure(material: StoredRhineVar<RvMaterial>, nid: string): Promise<boolean>
}

/**
 * @public
 */
export declare class RvNodeService {
  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
}

/**
 * @public
 */
export declare interface RvPlugin {
  config: RhineVarMap<RvPluginConfig>
  debug: RhineVarMap<RvPluginDebug>
  order: string[]
}

/**
 * @public
 */
export declare interface RvPluginConfig {
  id: string
  version: string | VersionPoint
  enable: {
    viewer: EnableLevel
    editor: EnableLevel
  }
}

/**
 * RvPluginDebug
 *
 * Example:
 *
 * ```ts
 * {
 *   id: 'example-plugin',
 *   name: 'Example Plugin',
 *   enable: true,
 *
 *   url: 'http://localhost:8080',
 *   hmr: 'ws://localhost:8081',
 *
 *   entry: 'index.js',
 *   css: 'index.css',
 *   messages: {
 *     path: 'messages',
 *     support: ['en', 'zh'],
 *     default: 'en'
 *   }
 * }
 * ```
 * @public
 */
export declare interface RvPluginDebug {
  id: string
  name: string
  enable: boolean
  url: string
  hmr: string
  entry: string
  css: string
  messages: {
    path: string
    namespace: string
    support: Locale[]
    default: Locale
  }
}

/**
 * @public
 */
export declare enum RvPresetType {
  NONE = 'NONE',
  METAL = 'METAL',
  PLASTIC = 'PLASTIC',
  GLASS = 'GLASS',
  WOOD = 'WOOD',
  MIRROR = 'MIRROR',
  CRYSTAL = 'CRYSTAL',
  PAINT = 'PAINT',
  CLOTH = 'CLOTH',
}

/**
 * @public
 */
export declare interface RvResource {
  fid: string
  name: string
  type: RvResourceType
  mime: string
  preview?: string
  description?: string
  from?: {
    fid: string
    type: RvAttachType
    path: string
  }
  createdAt: number
  updatedAt: number
  extra?: Record<string, unknown>
}

/**
 * @public
 */
export declare class RvResourceService {
  static get instance(): RvResourceService
  private constructor()
  resources: RecursiveMap<RvResource>
  get(fid: string): RecursiveObject<RvResource> | undefined
  has(fid: string): boolean
  add(file: RvResource): void
  remove(fid: string): boolean
  subscribe(subscriber: RvResourceServiceSubscriber): () => void
  unsubscribe(subscriber: RvResourceServiceSubscriber): void
  subscribeSingle(fid: string, subscriber: RvResourceServiceSubscriber): () => void
  unsubscribeSingle(fid: string, subscriber: RvResourceServiceSubscriber): void
  generateId(): string
  findSame(file: File): Promise<string | null>
}

/**
 * @public
 */
export declare enum RvResourceServiceEventType {
  ADD = 'ADD',
  REMOVE = 'REMOVE',
}

/**
 * @public
 */
export declare type RvResourceServiceSubscriber = (
  type: RvResourceServiceEventType,
  fid: string,
  rvResource?: RecursiveObject<RvResource>,
) => void

/**
 * @public
 */
export declare enum RvResourceType {
  FILE = 'FILE',
  ATTACH = 'ATTACH',
}

/**
 * @public
 */
export declare interface RvSceneNode {
  nid: string
  name: string
  from: string
}

/**
 * @public
 */
export declare interface RvSceneNodeWithRelatedInfo extends RvSceneNode {
  children: string[]
  parents: string[]
}

/**
 * @public
 */
export declare class RvSceneService {
  static get instance(): RvSceneService
  private constructor()
  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[]
}

/**
 * @public
 */
export declare interface RvSeparate {
  groups: RhineVarArray<RhineVarArray>
}

/**
 * @public
 */
export declare interface RvStep {
  name: string
  sid: string
  nodes: RhineVarMap<RvNode>
  configuration: RvConfiguration
  environment: RvEnvironment
}

/**
 * @public
 */
export declare class RvStepService {
  /**
   * @public
   */
  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
}

/**
 * RvPath 路径工具类
 * 提供 RvPath 的创建、转换、访问和比较等功能
 * @public
 */
export declare const RvUtils: {
  makeRvPath: typeof makeRvPath
  makeRvPathString: typeof makeRvPathString
  ensureRvPath: typeof ensureRvPath
  ensureRvPathString: typeof ensureRvPathString
  getByRvPath: typeof getByRvPath
  setByRvPath: typeof setByRvPath
  checkRvPathOverlay: typeof checkRvPathOverlay
  checkRvPathStartWith: typeof checkRvPathStartWith
  checkAnyRvPathOverlay: typeof checkAnyRvPathOverlay
  checkRvPathSame: typeof checkRvPathSame
  checkAnyRvPathSame: typeof checkAnyRvPathSame
  isChangeEventType: typeof isChangeEventType
}

/**
 * @public
 */
export declare interface RvVersion {
  code: number
  label: string
}

declare function scaleV3(ratio: number, v: V3): V3

declare function scaleV4(ratio: number, v: V4): V4

/**
 * @public
 */
export declare class SceneService {
  static get instance(): SceneService
  private constructor()
  dragState: {
    nid: string
    x: number
    y: number
    offsetX: number
    offsetY: number
  }
}

/**
 * @public
 */
declare interface Screen_2 {
  size: ScreenSize
  scale: number
  shadowAround: boolean
  focusMode: FocusMode
  showBabylonConsole: boolean
}
export { Screen_2 as Screen }

/**
 * @public
 */
export declare enum ScreenSize {
  XS = 'XS',
  SM = 'SM',
  MD = 'MD',
  LG = 'LG',
  XL = 'XL',
}

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 interface ScrollBarProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
  children: ReactNode | undefined
  className?: string
  innerClassName?: string
  barPaddingStart?: string
  barPaddingEnd?: string
}

/**
 * @public
 */
export declare type SelectedSubscriber = (value: RsSelectionNodeInfo[]) => void

/**
 * 根据路径设置对象中的值
 * @param source - 源对象
 * @param path - 设置路径
 * @param value - 要设置的值
 * @example
 * ```ts
 * const obj = { a: { b: 1 } }
 * RvUtils.setByRvPath(obj, "a.b", 2) // obj.a.b === 2
 * ```
 */
declare function setByRvPath(source: StoredRhineVar, path: string | RvPath, value: unknown): void

/**
 * @public
 */
export declare class ShadowAnimation {
  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 enum ShareMode {
  NONE = 'NONE',
  SELF = 'SELF',
  ALL = 'ALL',
}

/**
 * @public
 */
export declare type ShowAttributeContextMenu<T> = (options: ShowAttributeContextMenuOptions<T>) => void

/**
 * @public
 */
export declare function showAttributeContextMenu<T = unknown>(options: ShowAttributeContextMenuOptions<T>): void

/**
 * @public
 */
export declare interface ShowAttributeContextMenuOptions<T> {
  event: MouseEvent_2
  label?: string
  getValue?: () => T
  copy?: (value: T) => void
  batchApply?: (value: T) => void
  jumpToLearn?: () => void
  reset?: () => void
}

/**
 * @public
 */
export declare class SkyboxAnimation {
  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
}

/**
 * @public
 */
export declare function sleep(time: number): Promise<void>

/**
 * @public
 */
export declare class SpaceService {
  static get instance(): SpaceService
  page: Page
  screen: Screen_2
  private constructor()
  /**
   * @public
   */
  subscribeStepChange(subscriber: StepChangeSubscriber): void
  /**
   * @public
   */
  unsubscribeStepChange(subscriber: StepChangeSubscriber): void
  /**
   * @public
   */
  setSid(sid: string): void
  /**
   * @public
   */
  setScreenSize(size: ScreenSize): void
  /**
   * @public
   */
  isEditorPage(type?: PageType): boolean
  /**
   * @public
   */
  isBoxMode(mode?: PageMode): boolean
  /**
   * @public
   */
  isFullMode(mode?: PageMode): boolean
}

/**
 * @public
 */
export declare type SpanProps = DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>

/**
 * @public
 */
export declare type SpanPropsSimple = Omit<SpanProps, 'onChange' | 'defaultValue'>

declare function splitName(name: string): [string, string]

/**
 * @public
 */
export declare class StaticClassInstantiationError extends Error {
  constructor(className: string)
}

/**
 * @public
 */
export declare interface Status {
  Authenticated: boolean
  DataSynchronized: boolean
  SyncInitialized: boolean
  RsInitialized: boolean
  AllInitialized: boolean
  PluginEnabled: boolean
  PluginPreLoaded: boolean
  FileLoaded: boolean
  ModelLoaded: boolean
  PluginPreRendered: boolean
  Rendered: boolean
  Shown: boolean
}

/**
 * @public
 */
export declare type StatusChangeSubscriber = (value: boolean) => void

/**
 * @public
 */
export declare class StatusService {
  static get instance(): StatusService
  private constructor()
  status: Status
  subscribeAuthenticated(subscriber: StatusChangeSubscriber): () => void
  unsubscribeAuthenticated(subscriber: StatusChangeSubscriber): void
  afterAuthenticated(subscriber: StatusChangeSubscriber): void
  waitAuthenticated(): Promise<boolean>
  subscribeDataSynchronized(subscriber: StatusChangeSubscriber): () => void
  unsubscribeDataSynchronized(subscriber: StatusChangeSubscriber): void
  afterDataSynchronized(subscriber: StatusChangeSubscriber): void
  waitDataSynchronized(): Promise<boolean>
  subscribeSyncInitialized(subscriber: StatusChangeSubscriber): () => void
  unsubscribeSyncInitialized(subscriber: StatusChangeSubscriber): void
  afterSyncInitialized(subscriber: StatusChangeSubscriber): void
  waitSyncInitialized(): Promise<boolean>
  subscribeRsInitialized(subscriber: StatusChangeSubscriber): () => void
  unsubscribeRsInitialized(subscriber: StatusChangeSubscriber): void
  afterRsInitialized(subscriber: StatusChangeSubscriber): void
  waitRsInitialized(): Promise<boolean>
  subscribeAllInitialized(subscriber: StatusChangeSubscriber): () => void
  unsubscribeAllInitialized(subscriber: StatusChangeSubscriber): void
  afterAllInitialized(subscriber: StatusChangeSubscriber): void
  waitAllInitialized(): Promise<boolean>
  subscribePluginEnabled(subscriber: StatusChangeSubscriber): () => void
  unsubscribePluginEnabled(subscriber: StatusChangeSubscriber): void
  afterPluginEnabled(subscriber: StatusChangeSubscriber): void
  waitPluginEnabled(): Promise<boolean>
  subscribePluginPreLoaded(subscriber: StatusChangeSubscriber): () => void
  unsubscribePluginPreLoaded(subscriber: StatusChangeSubscriber): void
  afterPluginPreLoaded(subscriber: StatusChangeSubscriber): void
  waitPluginPreLoaded(): Promise<boolean>
  subscribeFileLoaded(subscriber: StatusChangeSubscriber): () => void
  unsubscribeFileLoaded(subscriber: StatusChangeSubscriber): void
  afterFileLoaded(subscriber: StatusChangeSubscriber): void
  waitFileLoaded(): Promise<boolean>
  subscribeModelLoaded(subscriber: StatusChangeSubscriber): () => void
  unsubscribeModelLoaded(subscriber: StatusChangeSubscriber): void
  afterModelLoaded(subscriber: StatusChangeSubscriber): void
  waitModelLoaded(): Promise<boolean>
  subscribePluginPreRendered(subscriber: StatusChangeSubscriber): () => void
  unsubscribePluginPreRendered(subscriber: StatusChangeSubscriber): void
  afterPluginPreRendered(subscriber: StatusChangeSubscriber): void
  waitPluginPreRendered(): Promise<boolean>
  subscribeRendered(subscriber: StatusChangeSubscriber): () => void
  unsubscribeRendered(subscriber: StatusChangeSubscriber): void
  afterRendered(subscriber: StatusChangeSubscriber): void
  waitRendered(): Promise<boolean>
  subscribeShown(subscriber: StatusChangeSubscriber): () => void
  unsubscribeShown(subscriber: StatusChangeSubscriber): void
  afterShown(subscriber: StatusChangeSubscriber): void
  waitShown(): Promise<boolean>
}

/**
 * @public
 */
export declare abstract class StepAttribute<T extends object = never> extends BaseAttribute<T> {
  type: AttributeType
  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
  subscribeTarget(subscriber: StepAttributeTargetSubscriber<T>): () => void
  unsubscribeTarget(subscriber: StepAttributeTargetSubscriber<T>): void
}

/**
 * @public
 */
export declare type StepAttributeTargetSubscriber<T extends object = never> = (
  type: TChangeType,
  path: RvPath,
  value: unknown,
  oldValue: unknown,
  sid: string,
) => void

/**
 * @public
 */
export declare function StepBlockSelect(props: StepBlockSelectProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface StepBlockSelectProps extends DivPropsSimple {
  value: string[]
  onChange: (value: string[]) => void
}

/**
 * @public
 */
export declare type StepChangeSubscriber = (
  sid: string,
  step: StoredRhineVar<RvStep>,
  lastSid: string,
  lastStep: RvStep | undefined,
) => void

/**
 * @public
 */
export declare type StepOptions = {
  label: string
  value: string
}[]

declare function stopPropagationListener(e: ReactEvent): void

/**
 * @public
 */
export declare type SupportAnimationTarget = Node_2 | Scene | Material | NodeMaterialBlock | ShadowGenerator

/**
 * @public
 */
export declare class SyncService {
  OVERWRITE_MODE: boolean
  ENABLE_RHINE_VAR_LOG: boolean
  static get instance(): SyncService
  private constructor()
  url: string
  state: RecursiveObject<RvBase>
  clientId: number
  generateId(prefix: string): string
  reset(): boolean
}

/**
 * @public
 */
export declare class TargetMultiNodeService {
  static get instance(): TargetMultiNodeService
  private constructor()
  sid: string
  nid: string
  nidList: string[]
  subscribe(subscriber: TargetMultiNodeSubscriber): () => void
  unsubscribe(subscriber: TargetMultiNodeSubscriber): void
}

/**
 * @public
 */
export declare type TargetMultiNodeSubscriber = (
  type: TChangeType,
  path: RvPath,
  value: unknown,
  oldValue: unknown,
  sid: string,
  nid: string,
  nidList: string[],
) => void

/**
 * @public
 */
export declare class TargetNodeService {
  static get instance(): TargetNodeService
  private constructor()
  state: StoredRhineVar<RvNode> | null
  sid: string
  nid: string
  subscribe(subscriber: TargetNodeSubscriber): () => void
  unsubscribe(subscriber: TargetNodeSubscriber): void
}

/**
 * @public
 */
export declare type TargetNodeSubscriber = (
  type: TChangeType,
  path: RvPath,
  value: unknown,
  oldValue: unknown,
  sid: string,
  nid: string,
  rvNode: StoredRhineVar<RvNode> | null,
) => void

/**
 * @public
 */
export declare class TargetStepService {
  static get instance(): TargetStepService
  private constructor()
  /**
   * Target step state
   */
  sid: string
  state: StoredRhineVar<RvStep>
  subscribe(subscriber: TargetStepSubscriber): () => void
  unsubscribe(subscriber: TargetStepSubscriber): void
  subscribeNode(subscriber: TargetNodeSubscriber): () => void
  unsubscribeNode(subscriber: TargetNodeSubscriber): void
  /**
   * 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
}

/**
 * @public
 */
export declare type TargetStepSubscriber = (
  type: TChangeType,
  path: RvPath,
  value: unknown,
  oldValue: unknown,
  sid: string,
) => void

/**
 * @public
 */
export declare enum TChangeType {
  SYNC = 'SYNC',
  STEP = 'STEP',
  SELECT = 'SELECT',
  ADD = 'ADD',
  UPDATE = 'UPDATE',
  DELETE = 'DELETE',
}

/**
 * @public
 */
export declare interface TextureInfo {
  fid: string
  localUrl: string
  texture: Texture
}

/**
 * @public
 */
export declare enum ThemeBackground {
  DEFAULT = 'DEFAULT',
  BACKGROUND = 'BACKGROUND',
  LIGHT = 'LIGHT',
  DARK = 'DARK',
}

/**
 * @public
 */
export declare enum ThemeColor {
  GREEN = 'GREEN',
  PURPLE = 'PURPLE',
  BLUE = 'BLUE',
  PINK = 'PINK',
}

/**
 * @public
 */
export declare function ThemeProvider(props: ThemeProviderProps): JSX.Element

/**
 * @public
 */
export declare interface ThemeProviderProps {
  children?: React.ReactNode
  color?: ThemeColor
  background?: ThemeBackground
}

/**
 * @public
 */
export declare class ThemeService {
  static get instance(): ThemeService
  private constructor()
  state: ThemeState
  updateBackground(): void
  updateBackgroundByColor(color: string): void
  isDarkTheme(): boolean
}

/**
 * @public
 */
export declare enum ThemeShape {
  GENERAL = 'GENERAL',
  RHINE = 'RHINE',
}

/**
 * @public
 */
export declare interface ThemeState {
  background: ThemeBackground
  color: ThemeColor
  shape: ThemeShape
}

/**
 * @public
 */
export declare function throttle<T extends (...args: any[]) => void>(func: T, wait: number): T

/**
 * @public
 */
export declare const TimeUtils: {
  convertTimeText: typeof convertTimeText
  formatDateTo17Digits: typeof formatDateTo17Digits
  formatDuration: typeof formatDuration
}

declare function to3n(bn: number): string

declare function toArray(v: V3 | V4): number[]

declare function toArrayWithRound4(v: V3 | V4, n?: number): number[]

declare function toDegrees(angle: number): number

/**
 * @public
 */
export declare function toEuler(quaternion: Quaternion): Vector3

declare function toEulerDegrees(v: V4): V3

declare function toEulerRadians(v: V4): V3

/**
 * 360度制欧拉角转四元数
 * @public
 */
export declare function toQuaternion(x: number, y: number, z: number): Quaternion

declare function toQuaternionVector(v: V4): Quaternion

declare function toRadians(angle: number): number

declare function toVector3(v: V3): Vector3

/**
 * @public
 */
export declare enum TransparencyMode {
  OPAQUE = 'OPAQUE',
  ALPHA_TEST = 'ALPHA_TEST',
  ALPHA_BLEND = 'ALPHA_BLEND',
  ALPHA_TEST_AND_BLEND = 'ALPHA_TEST_AND_BLEND',
}

declare function trySetClipboard(url: string): Promise<boolean>

/**
 * @public
 */
export declare function UploadButtonAndList(props: UploadButtonAndListProps): React_2.JSX.Element

/**
 * @public
 */
export declare interface UploadButtonAndListProps {
  uploadText: string
  accept: string[]
  modelMode?: boolean
}

/**
 * @public
 */
export declare const UrlUtils: {
  getParam: typeof getParam
  getHashParam: typeof getHashParam
  check: typeof check
  copyCurrentUrlToClipboard: typeof copyCurrentUrlToClipboard
  copyText: typeof copyText
  trySetClipboard: typeof trySetClipboard
  extractFilenameFromUrl: typeof extractFilenameFromUrl
}

/**
 * @public
 */
export declare type UseAllSelectedInfo = () => {
  selected: RsSelectionNodeInfo[]
  materialInfo: RsSelectionMaterialInfo
  last: RsSelectionNodeInfo | null
}

/**
 * @public
 */
export declare function useAllSelectedInfo(): {
  selected: RsSelectionNodeInfo[]
  materialInfo: RsSelectionMaterialInfo
  last: RsSelectionNodeInfo | null
}

/**
 * @public
 */
export declare type UseGlobal = <T = unknown>(
  path?: string,
) => {
  state: T
}

/**
 * @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 type UseGlobalAttribute = <T extends object = never>(
  path: string | RvPath,
) => {
  state: StoredRhineVar<T> | T
  path: RvPath
  globalAttribute: GlobalAttribute<T>
  initialize(): void
  isInitialized(): boolean
  mark(path: string | RvPath): void
  get(): RecursiveCrossRhineVar<T> | undefined
  set(path: string | RvPath, value: unknown): void
  read(): StoredRhineVar<T> | T | undefined
  edit(path: string | RvPath, value: unknown): void
  editMany(list: [string | RvPath, unknown][]): void
  subscribe(subscriber: GlobalAttributeSubscriber<T>): () => void
  unsubscribe(subscriber: GlobalAttributeSubscriber<T>): void
}

/**
 * @public
 */
export declare function useGlobalAttribute<T extends object = never>(
  path?: string | RvPath,
): {
  state: T | StoredRhineVar<T>
  path: string | RvPath
  targetGlobalAttribute: GlobalAttribute<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 type UseLastSelectedInfo = () => RsSelectionNodeInfo | null

/**
 * @public
 */
export declare function useLastSelectedInfo(): RsSelectionNodeInfo | null

/**
 * @public
 */
export declare interface UserAuth {
  token: string
  refreshToken: string
  ip: string
  timestamp: number
}

/**
 * @public
 */
export declare interface UserInfo {
  uid: string
  name: string
  phone: string
  description: string
  headIcon: string
  permission: string
}

/**
 * @public
 */
export declare class UserService {
  static get instance(): UserService
  private constructor()
  auth: UserAuth
  info: UserInfo
  clear(): void
}

/**
 * @public
 */
export declare function useScript(src: string): ScriptStatus

/**
 * @public
 */
export declare type UseSelectedInfo = () => RsSelectionNodeInfo[]

/**
 * @public
 */
export declare function useSelectedInfo(): RsSelectionNodeInfo[]

/**
 * @public
 */
export declare type UseSelectedMaterialInfo = () => RsSelectionMaterialInfo

/**
 * @public
 */
export declare function useSelectedMaterialInfo(): RsSelectionMaterialInfo

/**
 * @public
 */
export declare type UseStepOptions = (withDisable: boolean) => StepOptions

/**
 * @public
 */
export declare function useStepOptions(withDisable?: boolean): StepOptions

/**
 * @public
 */
export declare type UseTargetNode = <T = unknown>(
  path?: string | RvPath,
) => {
  state: T | null
  sid: string
  nid: string
  nidList: string[]
}

/**
 * @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 type UseTargetNodeAttribute = <T extends object = never>(
  path: string | RvPath,
) => {
  state: StoredRhineVar<T> | T
  path: RvPath
  sid: string
  nid: string
  nidList: string[]
  nodeAttribute: NodeAttribute<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, 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 | undefined
  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
  subscribe(subscriber: NodeAttributeTargetSubscriber<T>): () => void
  unsubscribe(subscriber: NodeAttributeTargetSubscriber<T>): 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: NodeAttribute<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 type UseTargetStep = <T = unknown>(
  path?: string | RvPath,
) => {
  state: T
  sid: string
}

/**
 * @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 type UseTargetStepAttribute = <T extends object = never>(
  path: string | RvPath,
) => {
  state: StoredRhineVar<T> | T
  path: RvPath
  sid: string
  stepAttribute: StepAttribute<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, StoredRhineVar<T>>
  set(path: string | RvPath, value: unknown, sid?: string): void
  multiSet(path: string | RvPath, value: unknown, sidList?: string[]): void
  read(sid?: string): StoredRhineVar<T> | T | undefined
  multiRead(sidList?: string[]): Map<string, StoredRhineVar<T> | 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
  subscribe(subscriber: StepAttributeTargetSubscriber<T>): () => void
  unsubscribe(subscriber: StepAttributeTargetSubscriber<T>): void
}

/**
 * @public
 */
export declare function useTargetStepAttribute<T extends object = never>(
  path?: string | RvPath,
): {
  state: T | StoredRhineVar<T>
  path: string | RvPath
  sid: string
  targetStepAttribute: StepAttribute<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
}

/**
 * @public
 */
export declare interface V2 {
  x: number
  y: number
}

/**
 * @public
 */
export declare interface V3 {
  x: number
  y: number
  z: number
}

/**
 * @public
 */
export declare interface V4 {
  x: number
  y: number
  z: number
  w: number
}

/**
 * @public
 */
export declare const VectorUtils: {
  xyToArray: typeof xyToArray
  xyzToArray: typeof xyzToArray
  xyzwToArray: typeof xyzwToArray
  scaleV3: typeof scaleV3
  radiansToDegrees: typeof radiansToDegrees
  degreeToRadians: typeof degreeToRadians
  radiansToQuaternion: typeof radiansToQuaternion
  degreesToQuaternion: typeof degreesToQuaternion
  toVector3: typeof toVector3
  fromVector3: typeof fromVector3
  withRound: typeof withRound
  isFiniteVector: typeof isFiniteVector
  noZero: typeof noZero
  scaleV4: typeof scaleV4
  toQuaternionVector: typeof toQuaternionVector
  toEulerRadians: typeof toEulerRadians
  toEulerDegrees: typeof toEulerDegrees
  toArray: typeof toArray
  fromQuaternion: typeof fromQuaternion
  toArrayWithRound4: typeof toArrayWithRound4
}

/**
 * @public
 */
export declare enum VersionPoint {
  LATEST_STABLE = 'LATEST_STABLE',
  LATEST_NIGHTLY = 'LATEST_NIGHTLY',
  LATEST_CANARY = 'LATEST_CANARY',
}

/**
 * @public
 */
export declare interface ViewPlugin extends BasePlugin {
  view: MixView<PluginViewProps>
  onRender?: () => void
}

/**
 * @public
 */
export declare interface WithOption<T> {
  subscriber: T
  option?: NativeEventSubscribeOption
}

declare function withRound(v: V3, n?: number): V3

declare function xyToArray(
  data: V2 | null | undefined,
  round?: number,
  defaultValue?: [number, number],
): [number, number]

declare function xyzToArray(
  data: V3 | null | undefined,
  round?: number,
  defaultValue?: [number, number, number],
): [number, number, number]

declare function xyzwToArray(
  data: V4 | null | undefined,
  round?: number,
  defaultValue?: [number, number, number, number],
): [number, number, number, number]

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>