// Generated by dts-bundle v0.7.3
// Dependencies for this module:
//   ../../@richlox/common
//   ../../inversify
//   ../../three

import { IAssetMap } from '@richlox/common';
import { FPathResolver, Observable } from '@richlox/common';
import { ContainerModule } from 'inversify';
import { IObjectData } from '@richlox/common';
import { interfaces } from 'inversify';
import { IObjectSerializer } from '@richlox/common';
import { AnimationAction } from 'three';
import { FDisposableCollection, Observable } from '@richlox/common';
import { AnimationAction, AnimationClip, AnimationMixer, Object3D } from 'three';
import { Object3D } from 'three';
import { IDisposable, Observable } from '@richlox/common';
import { OrthographicCamera } from 'three';
import { Material, ShadowMapType, TypedArray } from 'three';
import { IConstructor } from '@richlox/common';
import { FDisposableCollection } from '@richlox/common';
import { IDisposable } from '@richlox/common';
import { Camera } from 'three';
import { FSerializeFilter, IDeserializeScope } from '@richlox/common';
import { Audio } from 'three';
import { Audio, AudioListener } from 'three';
import { PerspectiveCamera } from 'three';
import { AmbientLight } from 'three';
import { DirectionalLight } from 'three';
import { HemisphereLight } from 'three';
import { Light } from 'three';
import { PointLight } from 'three';
import { RectAreaLight } from 'three';
import { SpotLight } from 'three';
import { BoxBufferGeometry } from 'three';
import { Bone } from 'three';
import { Mesh, MeshStandardMaterial } from 'three';
import { PlaneBufferGeometry } from 'three';
import { Bone, Skeleton, SkeletonHelper } from 'three';
import { SphereBufferGeometry } from 'three';
import { Spherical } from 'three';
import { EDisposeReason, FDisposableCollection, Observable } from '@richlox/common';
import { EDisposeReason, FDisposableCollection, FObjectData, FSerializeFilter, IDeserializeScope, ISerializeScope } from '@richlox/common';
import { EDisposeReason, ELifecycle, ILifecycle } from '@richlox/common';
import { Material, Object3D } from 'three';
import { FDisposableCollection, IDisposable } from '@richlox/common';
import { LineBasicMaterial, LineSegments } from 'three';
import { Camera, Intersection } from 'three';
import { IInitializer, Observable } from '@richlox/common';
import { BufferGeometry } from 'three';
import { Color } from 'three';
import { Euler } from 'three';
export { MathUtils as FMath } from 'three';
import { Matrix3, Matrix4 } from 'three';
import { Quaternion } from 'three';
import { Vector2, Vector3, Vector4 } from 'three';
import { AnimationClip } from 'three';
import { ESuffix, FObjectData, FSerializeFilter, IDeserializeScope, ISerializeScope } from '@richlox/common';
import { AudioLoader } from 'three';
import { ESuffix, FObjectData, FSerializeFilter, IConstructor, IDeserializeScope, ISerializable, ISerializeScope } from '@richlox/common';
import { Font } from 'three';
import { BufferGeometry, InterleavedBufferAttribute, ObjectLoader } from 'three';
import { Material, MaterialParameters, Texture } from 'three';
import { ESuffix, FObjectData, FSerializeFilter, IConstructor, IDeserializeScope, ISerializeScope } from '@richlox/common';
import { LineBasicMaterial, LineBasicMaterialParameters, LineDashedMaterial, LineDashedMaterialParameters, MeshBasicMaterial, MeshBasicMaterialParameters, MeshDepthMaterial, MeshDepthMaterialParameters, MeshDistanceMaterial, MeshDistanceMaterialParameters, MeshLambertMaterial, MeshLambertMaterialParameters, MeshMatcapMaterial, MeshMatcapMaterialParameters, MeshNormalMaterial, MeshNormalMaterialParameters, MeshPhongMaterial, MeshPhongMaterialParameters, MeshPhysicalMaterial, MeshPhysicalMaterialParameters, MeshStandardMaterial, MeshStandardMaterialParameters, MeshToonMaterial, MeshToonMaterialParameters, PointsMaterial, PointsMaterialParameters, RawShaderMaterial, ShaderMaterial, ShaderMaterialParameters, SpriteMaterial, SpriteMaterialParameters } from 'three';
import { ESuffix, FObjectData, FPathResolver, FSerializeFilter, IConstructor, IDeserializeScope, ISerializeScope, Observable } from '@richlox/common';
import { FObjectData, FSerializeFilter, IConstructor, IDeserializeScope, ISerializable, ISerializeScope } from '@richlox/common';
import { Skeleton } from 'three';
import { FObjectData, FSerializeFilter, IDeserializeScope, ISerializeScope } from '@richlox/common';
import { Bone, ObjectLoader, Skeleton } from 'three';
import { Mesh } from 'three';
import { ObjectLoader, Texture } from 'three';
import { ESuffix, FObjectData, FSerializeFilter, IDeserializeScope, Observable } from '@richlox/common';
import { FObjectData, FSerializeFilter, IBasic, IConstructor, IDeserializeScope, ISerializeScope, Observable } from '@richlox/common';
import { Scene } from 'three';
import { EDisposeReason, ELifecycle, ESuffix, FObjectData, FSerializeFilter, IDeserializeScope, IInitializable, IInitializer, ILifecycle, ISerializeScope, Observable } from '@richlox/common';
import { FSerializeFilter, IDeserializeScope, Observable } from '@richlox/common';
import { IConstructor, IExposeClass } from '@richlox/common';
import { EDisposeReason, ESuffix, FObjectData, FSerializeFilter, IAbstractor, IDeserializeScope, IInitializer, ISerializeScope, Observable } from '@richlox/common';
import { EDisposeReason, ELifecycle, FObjectData, FSerializeFilter, IDeserializeScope, IInitializable, ILifecycle, ISerializeScope, Observable } from '@richlox/common';
import { AudioListener, Camera, Intersection, Raycaster, Scene, WebGLRenderer } from 'three';
import { IDisposable, IInitializer, Observable } from '@richlox/common';
import { Container, ContainerModule } from 'inversify';
import { FPathResolver, IAbstractor, IConstructor } from '@richlox/common';
import { FPathResolver, IDeserializeScope } from '@richlox/common';
import { FPathResolver } from '@richlox/common';
import { EObjectType, IDeserializeScope, IObjectData, ISerializable } from '@richlox/common';
import { EObjectType, FLazyWriter, FPathResolver, FReader, IDeserializeScope, IObjectData, ISerializable } from '@richlox/common';
import { ESerializeKey } from '@richlox/common';
import { ESerializeKey, IConstructor } from '@richlox/common';
import { ESerializeKey, FLazyWriter, FPathResolver, FSerializeFilter, IDeserializeScope, IObjectSerializer, ISerializeScope } from '@richlox/common';
import { ISerializable, TByte } from '@richlox/common';
import { Texture } from 'three';
import { Observable } from '@richlox/common';
import { SpriteMaterial, Texture } from 'three';
import { SpriteMaterial } from 'three';
import { LineSegments } from 'three';
import { TLinkedList } from '@richlox/common';
import { Object3D, OrthographicCamera, Scene } from 'three';
import { EDisposeReason, ELifecycle, IInitializable, ILifecycle } from '@richlox/common';
import { Camera, EventDispatcher, Intersection, Object3D, Raycaster } from 'three';
import { Intersection } from 'three';
import { BufferGeometry, Intersection, Object3D, Raycaster, Vector2 } from 'three';

export class FApplication {
    protected readonly systems: FSystemManager;
    protected readonly world: TWorld;
    protected readonly config: IGameConfig;
    protected readonly assetSystem: FAssetSystem;
    protected readonly moduleResolver: FModuleResolver;
    protected readonly loader: FLoader;
    protected readonly rawDataLoader: IRawDataLoader;
    loadScene(): Promise<RLScene | undefined>;
    start(loadScene?: () => Promise<RLScene | undefined>, bBegin?: boolean): Promise<void>;
    exit(): void;
}

export function updateAssetMap(newAssetMap?: IAssetMap): void;

export class FChromeFilesystem implements IFileSystem {
    protected readonly pathResolver: FPathResolver;
    close(entry: Entry): Promise<boolean>;
    get lowLevel(): FileSystem;
    onChange: Observable<Entry | undefined>;
    mount(): Promise<FileSystem>;
    isSame(file1: Entry, file2: Entry): boolean;
    writeFile(content: string | Blob, path: string | FileEntry): Promise<FileEntry>;
    readFile<S extends 'string' | 'array'>(type: S, path: string | FileEntry, start?: number, end?: number): Promise<(S extends 'string' ? string : ArrayBuffer) | undefined>;
    readString(path: string | FileEntry, start?: number, end?: number): Promise<string | undefined>;
    readBin(path: string | FileEntry, start?: number, end?: number): Promise<ArrayBuffer | undefined>;
    getFileOrDirectory(path: string): Promise<Entry | undefined>;
    copy(srcFileOrDirectory: string | Entry, dest: string | DirectoryEntry, newName?: string): Promise<Entry | undefined>;
    rename(fileOrDirectory: string | Entry, newName: string): Promise<Entry | undefined>;
    move(srcFileOrDirectory: string | Entry, dest: string | DirectoryEntry, newName?: string): Promise<Entry>;
    iterateDirectory(path: string | DirectoryEntry, visitor: FVisitor, isRecursion?: boolean): Promise<boolean>;
    isDirectory(path: string | Entry): Promise<boolean>;
    isDirectoryExisted(path: string): Promise<boolean>;
    getDirectory(path: string | DirectoryEntry): Promise<DirectoryEntry | undefined>;
    createDirectory(path: string): Promise<DirectoryEntry>;
    isFileExisted(fileName: string): Promise<boolean>;
    getFile(fileName: string | FileEntry): Promise<FileEntry | undefined>;
    createFile(fileName: string): Promise<FileEntry>;
    deleteFile(fileName: string | FileEntry): Promise<boolean>;
    deleteDirectory(path: string | DirectoryEntry): Promise<boolean>;
}

export const browserModule: ContainerModule;

export class FResourceLoader {
    protected filesystem: IFileSystem;
    path: string;
    getUrl(): string;
    fetchLocal(url: string): Promise<Response>;
    load(): Promise<ArrayBuffer | undefined>;
}
export class FBrowserRawDataLoader implements IRawDataLoader {
    protected readonly resourceLoader: FResourceLoader;
    protected _package_fs: FPackageFile | undefined;
    constructor(resourceLoader: FResourceLoader);
    init(): Promise<void>;
    getObjectUrl(uri?: string): Promise<string | undefined>;
    getObjectData(uri?: string): Promise<ArrayBuffer | string | undefined>;
    createObjectData(uri?: string, resourceData?: IObjectData): Promise<boolean>;
    saveObjectData(uri?: string, resourceData?: IObjectData): Promise<boolean>;
}

export class FIndexeddbFilesystem implements IFileSystem {
    mount(): Promise<any>;
    protected getRegExp(path: string): RegExp;
    iterateDirectory(path: string | IDirectoryEntry, visitor: FVisitor, isRecursion?: boolean | undefined): Promise<boolean>;
    isDirectory(path: string | IEntry): Promise<boolean>;
    isDirectoryExisted(path: string): Promise<boolean>;
    getDirectory(path: string | IEntry): Promise<IDirectoryEntry | undefined>;
    createDirectory(path: string): Promise<IDirectoryEntry>;
    isFileExisted(fileName: string): Promise<boolean>;
    getFile(fileName: string | IEntry): Promise<IFileEntry | undefined>;
    createFile(fileName: string): Promise<IFileEntry>;
    deleteFile(fileName: string | IFileEntry): Promise<boolean>;
    deleteDirectory(path: string | IDirectoryEntry): Promise<boolean>;
    close(entry: IEntry): Promise<boolean>;
    copy(srcFileOrDirectory: string | IEntry, dest: string | IEntry, newName?: string | undefined): Promise<IEntry | undefined>;
    rename(fileOrDirectory: string | IEntry, newName: string): Promise<IEntry | undefined>;
    move(srcFileOrDirectory: string | IEntry, dest: string | IEntry, newName?: string | undefined): Promise<IEntry>;
    getFileOrDirectory(path: string): Promise<IEntry | undefined>;
    readString(path: string | IFileEntry, start?: number | undefined, end?: number | undefined): Promise<string | undefined>;
    readBin(path: string | IFileEntry, start?: number | undefined, end?: number | undefined): Promise<ArrayBuffer | undefined>;
    writeFile(content: string | Blob, path: string | IFileEntry): Promise<IFileEntry>;
    isSame(file1: IEntry, file2: IEntry): boolean;
}

export class FSessionStorageFilesystem implements IFileSystem {
    mount(): Promise<any>;
    protected getRegExp(path: string): RegExp;
    iterateDirectory(path: string | IDirectoryEntry, visitor: FVisitor, isRecursion?: boolean | undefined): Promise<boolean>;
    isDirectory(path: string | IEntry): Promise<boolean>;
    isDirectoryExisted(path: string): Promise<boolean>;
    getDirectory(path: string | IEntry): Promise<IDirectoryEntry | undefined>;
    createDirectory(path: string): Promise<IDirectoryEntry>;
    isFileExisted(fileName: string): Promise<boolean>;
    getFile(fileName: string | IEntry): Promise<IFileEntry | undefined>;
    createFile(fileName: string): Promise<IFileEntry>;
    deleteFile(fileName: string | IFileEntry): Promise<boolean>;
    deleteDirectory(path: string | IDirectoryEntry): Promise<boolean>;
    close(entry: IEntry): Promise<boolean>;
    copy(srcFileOrDirectory: string | IEntry, dest: string | IEntry, newName?: string | undefined): Promise<IEntry | undefined>;
    rename(fileOrDirectory: string | IEntry, newName: string): Promise<IEntry | undefined>;
    move(srcFileOrDirectory: string | IEntry, dest: string | IEntry, newName?: string | undefined): Promise<IEntry>;
    getFileOrDirectory(path: string): Promise<IEntry | undefined>;
    readString(path: string | IFileEntry, start?: number | undefined, end?: number | undefined): Promise<string | undefined>;
    readBin(path: string | IFileEntry, start?: number | undefined, end?: number | undefined): Promise<ArrayBuffer | undefined>;
    writeFile(content: string | Blob, path: string | IFileEntry): Promise<IFileEntry>;
    isSame(file1: IEntry, file2: IEntry): boolean;
}

export enum EMode {
    Game = 0,
    Edit = 1,
    PIE = 2
}
export class FContext {
    static get require(): Function | undefined;
    static get modules(): object | undefined;
    static get mode(): EMode;
    static get objectSerializer(): IObjectSerializer;
    static get<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T;
    static getTagged<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: any): T;
    static getNamed<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): T;
    static getAll<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T[];
    static getAllTagged<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: any): T[];
    static getAllNamed<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): T[];
    static load(...modules: interfaces.ContainerModule[]): void;
    static loadAsync(...modules: interfaces.AsyncContainerModule[]): Promise<void>;
    static get rebind(): interfaces.Rebind;
    static littleEndian: boolean;
    static version: string;
}

export class FAnimationBlend {
    get blendMap(): Map<FAnimationBlend | AnimationAction, number>;
    get value(): number;
    getEffectiveWeight(): number;
    setEffectiveWeight(val: number): void;
    set enabled(val: boolean);
    get target(): number | undefined;
    set target(val: number | undefined);
    protected _blendMap: Map<AnimationAction, number>;
    readonly range: FVector2;
    constructor(func: () => number);
    stop(): void;
}

export class FAnimationNode implements IState {
    asfm: FAnimationStateMachine;
    action: AnimationAction | FAnimationBlend;
    fadeInDuration: number;
    fadeOutDuration: number;
    onFinish: Observable<void>;
    protected _disposed: FDisposableCollection;
    constructor(animation: FAnimationStateMachine, action: AnimationAction | FAnimationBlend, onFinish?: () => void);
    dispose(): void;
    name: string;
    exe(deltaSecond: number): void;
    enter(from: IState): void;
    leave(to: IState): void;
}
export interface IAniConnection extends IConection {
}
export namespace IAniConnection {
    function create(condition: (from: FAnimationNode, to: FAnimationNode) => boolean): IAniConnection;
}
export class FAnimationStateMachine extends FStateMachine {
    get animation(): FAnimation;
    set animation(val: FAnimation);
    addNode(action: AnimationAction | FAnimationBlend, onFinish?: () => void): FAnimationNode;
    addSubStateMachine(): FAnimationStateMachine;
    tick(deltaSecond: number): void;
}

/**
  * 动画管理
  *
  * @export
  * @class FAnimation
  */
export class FAnimation {
    get timeScale(): number;
    set timeScale(val: number);
    get mixer(): AnimationMixer;
    get actions(): Readonly<Map<string, AnimationAction>>;
    clipActions(mesh: Object3D, animations: AnimationClip[]): void;
    addAnimations(...animations: AnimationClip[]): void;
    addKeyEvent(animation: string, event: IKeyFrameEvent, frame?: number): void;
    addKeyEvent(animation: AnimationAction, event: IKeyFrameEvent, frame?: number): void;
    removeAction(...value: string[]): void;
    removeAllAction(): void;
    tick(deltaSecond: number): void;
    getAllAction(): string[];
    fadeTo(startAction: string, endAction: string, duration: number): void;
    fadeTo(startAction: AnimationAction, endAction: AnimationAction, duration: number): void;
    activateAllAction(): void;
    activateAction(value: AnimationAction | string): void;
    play(value: AnimationAction | string): void;
    deactivateAllAction(): void;
    deactivateAction(value: AnimationAction | string): void;
    pauseAllAction(): void;
    pauseAction(value: AnimationAction | string): void;
    unpauseAllAction(): void;
    unpauseAction(value: AnimationAction): void;
    setWeight(action: AnimationAction, weight: number): void;
    getAction(action: AnimationAction | string): AnimationAction | undefined;
    protected readonly _range: FVector2;
    createBlend1D(func: () => number, ...list: [string | FAnimationBlend, number][]): FAnimationBlend;
    blend(blend?: FAnimationBlend, value?: number): void;
    fade(from: FAnimationBlend | AnimationAction, to: FAnimationBlend | AnimationAction, duration: number): void;
    get fading(): FAnimationBlend | undefined;
}

export const defaultSize: number[];

/********************************************************************************
  * Copyright 2019 Richlox
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
export class FBaseControls implements IInputEventReceiver, IDisposable {
    get receiveInput(): boolean;
    enabled: boolean;
    center: import("three").Vector3;
    panSpeed: number;
    zoomSpeed: number;
    rotationSpeed: number;
    onChange: Observable<void>;
    constructor(dom: HTMLElement, object?: Object3D);
    onMouseMouseWheel(event: WheelEvent): void;
    control(object: Object3D): void;
    focus(target: Object3D): void;
    pan(delta: FVector3): void;
    zoom(delta: FVector3): void;
    rotate(delta: FVector3): void;
    dispose(): void;
    _onMouseDown(event: MouseEvent): void;
    _onMouseMove(event: MouseEvent): void;
    _onMouseUp(event: MouseEvent): void;
}

export class FOrthoControls {
    constructor(camera: OrthographicCamera, domElement: HTMLElement);
    enable(): void;
    disable(): void;
    onMouseMove(event: MouseEvent): void;
    onMouseDown(event: MouseEvent): void;
    onMouseUp(): void;
    onMouseWheel(event: WheelEvent): void;
}

export const coreModule: ContainerModule;

export const ArrayTypes: Map<string, IConstructor<TypedArray>>;
export const MaterialTypes: Map<string, IConstructor<Material>>;
export const Renderer: unique symbol;
export const MainViewport: unique symbol;
export const WorldMode: unique symbol;
export enum EWorldMode {
        Game = 0,
        Editor = 1
}
/**
    * 游戏世界配置
    *
    * @export
    * @interface IWorldConfig
    */
export interface IWorldConfig {
        physicallyCorrectLights?: boolean;
        clearColor?: FColor | string | number;
        clearColorAlpha?: number;
        antialias?: boolean;
        bShadowMap?: boolean;
        shadowMapType?: ShadowMapType;
        autoClear?: boolean;
        devicePixelRatio?: number;
        raycasterNear?: number;
        raycasterFar?: number;
}
export const defaultWorldConfig: IWorldConfig;
export const IGameConfig: unique symbol;
/**
    * 游戏配置
    *
    * @export
    * @interface IGameConfig
    */
export interface IGameConfig {
        /**
            * 分辨率
            *
            * @type {number[]}
            * @memberof IGameConfig
            */
        screenSize: number[];
        /**
            * 开始场景
            *
            * @type {string}
            * @memberof IGameConfig
            */
        startScene?: string;
        /**
            * 游戏世界配置
            *
            * @type {IWorldConfig}
            * @memberof IGameConfig
            */
        world: IWorldConfig;
        enginePlugins?: string[];
        /**
            * 插件列表，如果是 undefined ，刚加载所有插件
            *
            * @type {string[]}
            * @memberof IGameConfig
            */
        plugins?: string[];
}
/**
    * 模块配置
    *
    * @export
    * @interface IModuleConfig
    */
export interface IModuleConfig {
        /**
            * 模块名称
            *
            * @type {string}
            * @memberof IModuleConfig
            */
        name: string;
        /**
            * 版本号
            *
            * @type {string}
            * @memberof IModuleConfig
            */
        version: string;
        /**
            * 描述
            *
            * @type {string}
            * @memberof IModuleConfig
            */
        description?: string;
        createdAt?: string;
        createdBy?: string;
        gitId?: string;
        id?: number;
        released?: boolean;
        repository?: string;
        repositoryName?: string;
}
export const defaultGameConfig: IGameConfig;
export const GameModeClass: unique symbol;
export const GameStateClass: unique symbol;
export const PawnClass: unique symbol;
export const ControllerClass: unique symbol;
export const PlayerStartClass: unique symbol;
export const CameraSystemClass: unique symbol;

export abstract class TEvent<T> {
    protected disposes: FDisposableCollection;
    get object(): T;
    constructor(object: T);
    start(): void;
    stop(): void;
    protected abstract _bind(): void;
    protected _unbind(): void;
}

export interface IState extends IDisposable {
    name: string;
    enter(from: IState): void;
    leave(to: IState): void;
    exe(deltaSecond: number): void;
}
export class FInitState implements IState {
    name: string;
    lastState?: IState;
    enter(from: IState): void;
    leave(to: IState): void;
    exe(deltaSecond: number): void;
    dispose(): void;
}
export interface IConection {
    condition(from: IState, to: IState): boolean;
}
export abstract class FStateMachine implements IState {
    protected _parent?: FStateMachine;
    protected _exited: boolean;
    get enterToStartState(): boolean;
    set enterToStartState(val: boolean);
    get nowState(): IState;
    constructor();
    dispose(): void;
    name: string;
    enter(from: IState): void;
    leave(to: IState): void;
    restart(): void;
    exit(to: IState): void;
    protected addState(state: IState): void;
    protected addSubStateMachine(sfm: FStateMachine): void;
    connect(stateFrom: IState, stateTo: IState, connection: IConection): void;
    connectStart(state: IState, connection: IConection): void;
    exe(deltaSecond: number): void;
}

export class ACameraSystem extends AActor {
    get main(): Camera;
    set main(val: Camera);
    constructor(viewport: IViewport);
    resize(width: number, height: number): void;
    getCamera(id: number): Camera | undefined;
    addCamera(camera: Camera): void;
    protected _createMainCamera(): Camera;
    dispose(): void;
}

export class ASky extends AActor {
    get turbidity(): number;
    set turbidity(val: number);
    get rayleigh(): number;
    set rayleigh(val: number);
    get mieCoefficient(): number;
    set mieCoefficient(val: number);
    get mieDirectionalG(): number;
    set mieDirectionalG(val: number);
    get luminance(): number;
    set luminance(val: number);
    get inclination(): number;
    set inclination(val: number);
    get azimuth(): number;
    set azimuth(val: number);
    get sun(): boolean;
    set sun(val: boolean);
    constructor(name?: string);
    protected createSky(): void;
    initialize(): Promise<void>;
    protected afterDeserialize(): Promise<void>;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
}

export class AGameMode extends AActor {
    get isLockPointer(): boolean;
    set isLockPointer(val: boolean);
    get gameStateClass(): RLClass<AGameState>;
    set gameStateClass(val: RLClass<AGameState>);
    protected _gameStateClass: RLClass<AGameState>;
    get pawnClass(): RLClass<APawn>;
    set pawnClass(val: RLClass<APawn>);
    protected _pawnClass: RLClass<APawn>;
    get controllerClass(): RLClass<APlayerController>;
    set controllerClass(val: RLClass<APlayerController>);
    protected _controllerClass: RLClass<APlayerController>;
    get gameState(): AGameState;
    get playerController(): APlayerController;
    constructor();
    beginPlay(): Promise<void>;
    allActorBeginPlay(): Promise<void>;
    protected choosePlayerStart(): APlayerStart | undefined;
    protected fixedStartPosition(pawn: APawn): void;
}

export class AGameState extends AActor {
}

export class ACharacter extends APawn {
    get halfHeight(): number;
    set halfHeight(val: number);
    protected _halfHeight: number;
    get radius(): number;
    set radius(val: number);
    protected _radius: number;
    constructor();
    initialize(): Promise<void>;
    protected createPrimitive(): Promise<CPrimitive>;
    protected createMovement(): Promise<CCharacterMovementComponent>;
}

export class AController extends AActor {
    get isLockPointer(): boolean;
    set isLockPointer(val: boolean);
    get isLocked(): boolean;
    get pawn(): APawn;
    constructor(name?: string);
    protected readonly _directionMux: FVector2;
    onKeyPressing(keys: Readonly<Set<EKeycode>>, deltaSecond: number): void;
    onMouseMove(position: FVector2, movement: FVector2): void;
    control(pawn: APawn): void;
    lockPointer(): void;
    unlockPointer(): void;
    beginPlay(): Promise<void>;
    dispose(): void;
    get disableController(): boolean;
    set disableController(val: boolean);
}

export interface IPawn extends RLTransformable {
        /**
            * 半高
            *
            * @type {number}
            * @memberof IPawn
            */
        halfHeight: number;
        /**
            * 视角距离中心点高度
            *
            * @type {number}
            * @memberof IPawn
            */
        eyeHeight: number;
        /**
            * 视角方向
            *
            * @type {Readonly<FVector3>}
            * @memberof IPawn
            */
        eyeDirection: Readonly<FVector3>;
        /**
            * 向前方向
            *
            * @type {Readonly<FVector3>}
            * @memberof IPawn
            */
        forward: Readonly<FVector3>;
        /**
            * 碰撞类型
            *
            * @type {ECollisionType}
            * @memberof IPawn
            */
        collisionType: ECollisionType;
        /**
            * 碰撞通道
            *
            * @type {ECollisionType[]}
            * @memberof IPawn
            */
        collisionChannel: ECollisionType[];
        /**
            * 摄像机
            *
            * @type {CPerspectiveCamera}
            * @memberof IPawn
            */
        eye: CPerspectiveCamera;
        /**
            * 碰撞体
            *
            * @type {CPrimitive}
            * @memberof IPawn
            */
        primitive: CPrimitive;
}
export namespace IPawn {
        function is(obj?: any): obj is IPawn;
}

export class APawn extends AActor implements IPawn {
        get halfHeight(): number;
        get eyeHeight(): number;
        get eyeDirection(): Readonly<FVector3>;
        get forward(): Readonly<FVector3>;
        get collisionType(): ECollisionType;
        get collisionChannel(): ECollisionType[];
        get eye(): CPerspectiveCamera;
        get primitive(): CPrimitive;
        get movement(): CBasicMovementComponent;
        /**
            * 控制器
            *
            * @type {AController}
            * @memberof APawn
            */
        get controller(): AController;
        set controller(val: AController);
        protected _camera: CPerspectiveCamera;
        protected _springArm: CSpringArm;
        protected _primitive: CPrimitive;
        protected _movement: CBasicMovementComponent;
        initialize(): Promise<void>;
        protected afterDeserialize(): Promise<void>;
        protected afterCopy(): Promise<void>;
        protected createCamera(): Promise<CPerspectiveCamera>;
        protected createSpringArm(): Promise<CSpringArm>;
        protected createPrimitive(): Promise<CPrimitive>;
        protected createMovement(): Promise<CBasicMovementComponent>;
        afterAwake(): Promise<void>;
        beginPlay(): Promise<void>;
        protected _forwardDirection: FVector3;
        /**
            * 移动
            *
            * @param {FVector2} dir 移动方向
            * @memberof APawn
            */
        move(dir: FVector3): void;
        /**
            * 水平移动
            *
            * @param {FVector2} dir 移动方向
            * @memberof APawn
            */
        moveHorizon(dir: FVector2): void;
        /**
            * 视角上下转动
            *
            * @param {number} up 转动方向和大小，负数向下转动
            * @memberof APawn
            */
        lookUp(up: number): void;
        /**
            * 视角左右转动
            *
            * @param {number} right 转动方向和大小，负数向左转动
            * @memberof APawn
            */
        lookRight(right: number): void;
        /**
            * 跳跃
            *
            * @memberof APawn
            */
        jump(): void;
}

export class APlayerController extends AController {
    constructor();
    onKeyPressing(keys: Readonly<Set<EKeycode>>, deltaSecond: number): void;
    onKeyDown(keys: IKeyEvent): void;
    onMouseMove(position: FVector2, movement: FVector2): void;
}

export class APlayerStart extends AActor {
    protected _helper?: FCapsuleHelper;
    protected readonly _disposables: FDisposableCollection;
    constructor();
    onAwake(): Promise<void>;
    protected drawDebug(): void;
    protected updateDebug(): void;
    dispose(): void;
}

export class CAudio2D extends CAudio {
    protected get rawAudio(): Audio;
    protected createRawAudio(): void;
    play(): void;
    stop(): void;
    pause(): void;
    isPlaying(): boolean;
    getDuration(): number | undefined;
    getPlaybackRate(): number;
    setPlaybackRate(rate: number): void;
}

export class CAudio3D extends CAudio {
    protected get rawAudio(): Audio;
    protected createRawAudio(): void;
    play(): void;
    stop(): void;
    pause(): void;
    isPlaying(): boolean;
    getDuration(): number | undefined;
    getPlaybackRate(): number;
    setPlaybackRate(rate: number): void;
}

export abstract class CAudio extends CComponent {
    protected readonly _audioListener: AudioListener;
    get audio(): RLAudio | undefined;
    set audio(val: RLAudio | undefined);
    protected readonly parameters: {
        audio?: RLAudio;
        bAutoPlay: boolean;
    };
    get isAutoPlay(): boolean;
    set isAutoPlay(value: boolean);
    get isLoop(): boolean;
    set isLoop(value: boolean);
    get volume(): number;
    set volume(value: number);
    constructor(audio?: RLAudio, isAutoPlay?: boolean, isLoop?: boolean, volume?: number);
    beginPlay(): Promise<void>;
    protected abstract rawAudio: Audio;
    protected abstract createRawAudio(): void;
    dispose(): void;
    abstract play(): void;
    abstract stop(): void;
    abstract pause(): void;
    abstract isPlaying(): boolean;
    abstract getDuration(): number | undefined;
    abstract getPlaybackRate(): number;
    abstract setPlaybackRate(rate: number): void;
}

export class CFollowCamera<T extends Camera = Camera> extends CComponent {
    maxCameraSpeed: number;
    cameraAcceleration: number;
    heightOffset: number;
    radius: number;
    rotationOffset: number;
    lockOwner: boolean;
    lowerRadiusLimit?: number;
    upperRadiusLimit?: number;
    lowerHeightOffsetLimit?: number;
    upperHeightOffsetLimit?: number;
    lowerRotationOffsetLimit?: number;
    upperRotationOffsetLimit?: number;
    get targetTransform(): FMatrix4;
    get camera(): T;
    set camera(val: T);
    protected _targetTransform: FMatrix4;
    tick(deltaSecond: number): void;
    protected _follow(): void;
}

export class FOrthographicConfig extends FStruct {
    left: number;
    right: number;
    top: number;
    bottom: number;
    near: number;
    far: number;
}
export type IOrthographicConfig = IStruct<FOrthographicConfig>;
export class COrthographicCamera extends CComponent {
    constructor(params?: IOrthographicConfig);
    onAwake(): Promise<void>;
    protected updateCameraProperty(data: IPropertyChangeData): void;
    dispose(): void;
}

export class FPerspectiveConfig extends FStruct {
    fov: number;
    aspect: number;
    near: number;
    far: number;
}
export type IPerspectiveConfig = IStruct<FPerspectiveConfig>;
export class CPerspectiveCamera extends CComponent {
    get camera(): PerspectiveCamera;
    constructor(params?: IPerspectiveConfig);
    onAwake(): Promise<void>;
    protected updateCameraProperty(data: IPropertyChangeData): void;
    dispose(): void;
}

export class CAmbientLight extends ILight {
    protected readonly _light: AmbientLight;
    constructor(color?: string | number | FColor, intensity?: number);
}

export class CDirectionalLight extends ILight {
    get shadowCameraLeft(): number;
    set shadowCameraLeft(value: number);
    get shadowCameraRight(): number;
    set shadowCameraRight(value: number);
    get shadowCameraTop(): number;
    set shadowCameraTop(value: number);
    get shadowCameraBottom(): number;
    set shadowCameraBottom(value: number);
    get shadowCameraNear(): number;
    set shadowCameraNear(value: number);
    get shadowCameraFar(): number;
    set shadowCameraFar(value: number);
    protected readonly _light: DirectionalLight;
    constructor(color?: FColor | string | number, intensity?: number);
    onAwake(): Promise<void>;
}

export class CHemisphereLight extends ILight {
    get skyColor(): FColor;
    set skyColor(value: FColor);
    get groundColor(): FColor;
    set groundColor(value: FColor);
    protected readonly _light: HemisphereLight;
    constructor(skyColor?: FColor | string | number, groundColor?: FColor | string | number, intensity?: number);
    onAwake(): Promise<void>;
}

export abstract class ILight extends CComponent {
    protected _disposables: FDisposableCollection;
    get color(): FColor;
    set color(value: FColor);
    get intensity(): number;
    set intensity(value: number);
    get castShadow(): boolean;
    set castShadow(value: boolean);
    get shadowMapSize(): FVector2;
    set shadowMapSize(value: FVector2);
    get shadowBias(): number;
    set shadowBias(value: number);
    get shadowRadius(): number;
    set shadowRadius(value: number);
    protected abstract _light: Light;
    dispose(): void;
}

export class CPointLight extends ILight {
    get shadowCameraFov(): number;
    set shadowCameraFov(val: number);
    get shadowCameraAspect(): number;
    set shadowCameraAspect(val: number);
    get shadowCameraNear(): number;
    set shadowCameraNear(val: number);
    get shadowCameraFar(): number;
    set shadowCameraFar(val: number);
    get distance(): number;
    set distance(value: number);
    get decay(): number;
    set decay(value: number);
    protected readonly _light: PointLight;
    constructor(color?: FColor | string | number, intensity?: number, distance?: number, decay?: number);
    onAwake(): Promise<void>;
}

export class CRectAreaLight extends ILight {
    get width(): number;
    set width(value: number);
    get height(): number;
    set height(value: number);
    protected readonly _light: RectAreaLight;
    constructor(color?: FColor | string | number, intensity?: number, width?: number, height?: number);
}

export class CSpotLight extends ILight {
    get shadowCameraFov(): number;
    set shadowCameraFov(val: number);
    get shadowCameraAspect(): number;
    set shadowCameraAspect(val: number);
    get shadowCameraNear(): number;
    set shadowCameraNear(val: number);
    get shadowCameraFar(): number;
    set shadowCameraFar(val: number);
    get distance(): number;
    set distance(value: number);
    get decay(): number;
    set decay(value: number);
    get angle(): number;
    set angle(value: number);
    get penumbra(): number;
    set penumbra(value: number);
    protected readonly _light: SpotLight;
    constructor(color?: FColor | string | number, intensity?: number, distance?: number, angle?: number, exponent?: number, decay?: number);
    onAwake(): Promise<void>;
}

export class CCube extends IMesh {
    get bound(): FBoxShape;
    get width(): number;
    set width(val: number);
    get height(): number;
    set height(val: number);
    get depth(): number;
    set depth(val: number);
    get widthSegments(): number;
    set widthSegments(val: number);
    get heightSegments(): number;
    set heightSegments(val: number);
    get depthSegments(): number;
    set depthSegments(val: number);
    protected _geometry: BoxBufferGeometry;
    constructor(width?: number, height?: number, depth?: number, material?: RLMaterial, widthSegments?: number, heightSegments?: number, depthSegments?: number);
}

export interface IBound {
    bound: FBoxShape;
    attachBone: string;
}
export namespace IBound {
    function is(obj: any): obj is IBound;
}
export interface ISkeletonMesh {
    getSkeleton(): Readonly<Array<Bone>> | undefined;
}
export namespace ISkeletonMesh {
    function is(obj: any): obj is ISkeletonMesh;
}

export abstract class IBasicMesh extends CComponent implements IBound {
    abstract bound: FBoxShape;
    get attachBone(): string;
    set attachBone(val: string);
    protected afterDeserialize(): Promise<void>;
    protected afterCopy(): Promise<void>;
    protected _onBoneChanged(): void;
}
export abstract class IMesh extends IBasicMesh {
    get material(): RLMaterial | undefined;
    set material(val: RLMaterial | undefined);
    get castShadow(): boolean;
    set castShadow(val: boolean);
    get receiveShadow(): boolean;
    set receiveShadow(val: boolean);
    protected _mesh: Mesh;
    protected readonly _defaultMaterial: MeshStandardMaterial;
    protected updateMaterial(): void;
    constructor();
}

export class CLineSegments extends CComponent {
    get bound(): FVector3;
    get points(): FVector3[];
    set points(val: FVector3[]);
    constructor(points?: FVector3[]);
    protected updateAttribute(): void;
}

export class CPlane extends IMesh {
    get bound(): FBoxShape;
    get width(): number;
    set width(val: number);
    get height(): number;
    set height(val: number);
    get widthSegments(): number;
    set widthSegments(val: number);
    get heightSegments(): number;
    set heightSegments(val: number);
    protected _geometry: PlaneBufferGeometry;
    constructor(width?: number, height?: number, material?: RLMaterial, widthSegments?: number, heightSegments?: number);
}

export class CSkeletonMeshComponent extends IBasicMesh implements ISkeletonMesh {
    get bound(): FBoxShape;
    get castShadow(): boolean;
    set castShadow(val: boolean);
    get receiveShadow(): boolean;
    set receiveShadow(val: boolean);
    protected disposables: FDisposableCollection;
    get ASFM(): FAnimationStateMachine;
    get animations(): RLAnimationAsset[];
    set animations(val: RLAnimationAsset[]);
    get defaultAnimation(): number;
    set defaultAnimation(val: number);
    protected readonly parameters: {
        castShadow: boolean;
        receiveShadow: boolean;
        skeletonMeshes: RLSkeletonMesh[];
        skeleton?: RLSkeleton;
        rawSkeleton?: Skeleton;
        defaultAnimation?: string;
        animations: RLAnimationAsset[];
        showSkeleton: boolean;
    };
    get skeletonMeshes(): RLSkeletonMesh[];
    set skeletonMeshes(val: RLSkeletonMesh[]);
    get skeleton(): RLSkeleton | undefined;
    set skeleton(val: RLSkeleton | undefined);
    get showSkeleton(): boolean;
    set showSkeleton(val: boolean);
    constructor(skeletonMeshes?: RLSkeletonMesh[], skeleton?: RLSkeleton);
    getSkeleton(): Readonly<Array<Bone>> | undefined;
    addSkeletonMesh(...meshes: (RLSkeletonMesh | undefined)[]): void;
    addAnimation(...animations: (RLAnimationAsset | undefined)[]): void;
    protected updateMesh(): void;
    protected skeletonHelper?: SkeletonHelper;
    protected setSkeletonVisible(val: boolean): void;
    protected updateSkeleton(val: RLSkeleton | undefined): void;
    protected updateAnimation(): void;
    onAwake(): Promise<void>;
    beginPlay(): Promise<void>;
    tick(deltaTime: number): void;
    dispose(): void;
}

export class CSphere extends IMesh {
    get bound(): FBoxShape;
    get radius(): number;
    set radius(val: number);
    get widthSegments(): number;
    set widthSegments(val: number);
    get heightSegments(): number;
    set heightSegments(val: number);
    get phiStart(): number;
    set phiStart(val: number);
    get phiLength(): number;
    set phiLength(val: number);
    get thetaStart(): number;
    set thetaStart(val: number);
    get thetaLength(): number;
    set thetaLength(val: number);
    protected _geometry: SphereBufferGeometry;
    constructor(radius?: number, material?: RLMaterial, widthSegments?: number, heightSegments?: number, phiStart?: number, phiLength?: number, thetaStart?: number, thetaLength?: number);
}

export class CStaticMeshComponent extends IBasicMesh {
    get bound(): FBoxShape;
    protected disposables: FDisposableCollection;
    protected readonly parameters: {
        castShadow: boolean;
        receiveShadow: boolean;
        staticMeshes: RLStaticMesh[];
    };
    get staticMeshes(): RLStaticMesh[];
    set staticMeshes(val: RLStaticMesh[]);
    get castShadow(): boolean;
    set castShadow(val: boolean);
    get receiveShadow(): boolean;
    set receiveShadow(val: boolean);
    constructor(staticMeshes?: RLStaticMesh[]);
    protected updateMesh(): void;
    beginPlay(): Promise<void>;
    dispose(): void;
}

export class CBasicMovementComponent extends CComponent {
        /**
            * 是否飘浮
            *
            * @readonly
            * @type {boolean}
            * @memberof CBasicMovementComponent
            */
        get float(): boolean;
        set float(val: boolean);
        /**
            * 重力
            *
            * @readonly
            * @type {FVector3}
            * @memberof CBasicMovementComponent
            */
        get gravity(): FVector3;
        set gravity(val: FVector3);
        /**
            * 重量大小
            *
            * @readonly
            * @type {number}
            * @memberof CBasicMovementComponent
            */
        get mass(): number;
        set mass(val: number);
        /**
            * 最大速度
            *
            * @readonly
            * @type {number}
            * @memberof CBasicMovementComponent
            */
        get maxSpeed(): number;
        set maxSpeed(val: number);
        /**
            * 移动时的力度大小
            *
            * @readonly
            * @type {number}
            * @memberof CBasicMovementComponent
            */
        get moveForce(): number;
        set moveForce(val: number);
        protected _moveForce: number;
        /**
            * 视角是否跟随人物转动
            *
            * @readonly
            * @type {boolean}
            * @memberof CBasicMovementComponent
            */
        get turnOnEyeDirection(): boolean;
        set turnOnEyeDirection(val: boolean);
        protected _turnOnEyeDirection: boolean;
        /**
            * 视角转动速度
            *
            * @readonly
            * @type {number}
            * @memberof CBasicMovementComponent
            */
        get lookSpeed(): number;
        set lookSpeed(val: number);
        protected _lookSpeed: number;
        /**
            * 角色转动速度
            *
            * @readonly
            * @type {number}
            * @memberof CBasicMovementComponent
            */
        get turnSpeed(): number;
        set turnSpeed(val: number);
        protected _turnSpeed: number;
        /**
            * 跳跃时的冲力
            *
            * @readonly
            * @type {number}
            * @memberof CBasicMovementComponent
            */
        get jumpImpact(): number;
        set jumpImpact(val: number);
        protected _jumpImpact: number;
        /**
            * 自由视角时，视角上下转动的范围
            *
            * @readonly
            * @type {FVector2}
            * @memberof CBasicMovementComponent
            */
        get lookUpRange(): FVector2;
        set lookUpRange(val: FVector2);
        protected _lookUpRange: FVector2;
        /**
            * 自由视角时，视角左右转动的范围
            *
            * @readonly
            * @type {FVector2}
            * @memberof CBasicMovementComponent
            */
        get lookRightRange(): FVector2;
        set lookRightRange(val: FVector2);
        protected _lookRightRange: FVector2;
        /**
            * 移动时的受力方向与速度方向相反时，是否立即停止
            *
            * @readonly
            * @type {boolean}
            * @memberof CBasicMovementComponent
            */
        get stopImmediately(): boolean;
        set stopImmediately(val: boolean);
        protected _stopImmediately: boolean;
        protected readonly _disposables: FDisposableCollection;
        protected pawn: IPawn;
        protected readonly _overlapping: Map<ICollisionObject, IManifoldPoint[]>;
        protected _turn: number;
        protected readonly _spherical: Spherical;
        protected readonly _deltaAngle: FVector2;
        protected readonly _moveDirection: FVector3;
        protected readonly _rightDirection: FVector3;
        applyForce(force: FVector3): void;
        applyImpact(impact: FVector3): void;
        get inAir(): boolean;
        lookUp(up: number): void;
        lookRight(right: number): void;
        move(direction: FVector3): void;
        moveHorizon(dir: FVector2): void;
        jump(): void;
        get velocity(): FVector3;
        get speed(): number;
        get horizonSpeed(): number;
        get verticalSpeed(): number;
        get overlappingObjects(): Readonly<Map<ICollisionObject, IManifoldPoint[]>>;
        onAwake(): Promise<void>;
        hitTest(deltaSecond: number, primitive: CPrimitive, force: FVector3, velocity: FVector3): FVector3;
        protected calcPosition(deltaSecond: number, isRoot?: boolean): Readonly<FVector3>;
        protected movement(deltaSecond: number): void;
        tick(deltaSecond: number): void;
        protected look(deltaSecond: number): void;
}

export class CCharacterMovementComponent extends CBasicMovementComponent {
    constructor();
}

export class CBoxCollision extends CPrimitive {
    get shape(): FBoxShape;
    set shape(val: FBoxShape);
    protected _shape: FBoxShape;
    constructor();
    drawDebug(): void;
    protected updateDebug(): void;
    dispose(): void;
}

export class CCapsuleCollision extends CPrimitive {
    get shape(): FCapsuleShape;
    set shape(val: FCapsuleShape);
    protected _shape: FCapsuleShape;
    constructor();
    drawDebug(): void;
    protected updateDebug(): void;
    dispose(): void;
}

export abstract class CPrimitive extends IBasicMesh implements IGhostObject {
    get bound(): FBoxShape;
    showDebugOnPlay: boolean;
    get collisionType(): ECollisionType;
    set collisionType(val: ECollisionType);
    readonly collisionChannel: ECollisionType[];
    get onBeginOverlap(): Observable<[ICollisionObject, IManifoldPoint[]]>;
    get onOverlapping(): Observable<[ICollisionObject, IManifoldPoint[]]>;
    get onEndOverlap(): Observable<[ICollisionObject, IManifoldPoint[]]>;
    get shape(): FShape;
    get collisionObject(): IGhostObject;
    protected collisionWorld: ICollisionWorld;
    protected readonly factory: CollisionObjectFactory;
    protected _collision: IGhostObject;
    protected readonly disposes: FDisposableCollection;
    protected _shape: FShape;
    protected _helper?: FHelper;
    constructor();
    getOverlappingObjects(): ICollisionObject[];
    getNumOverlappingObjects(): number;
    getOverlappingObject(index: number): ICollisionObject | undefined;
    onAwake(): Promise<void>;
    beginPlay(): Promise<void>;
    protected debug(): void;
    getUserPointer(): void;
    setUserPointer(userPointer: any): void;
    destroyUserPoint(): void;
    setAnisotropicFriction(anisotropicFriction: FVector3, frictionMode: number): void;
    getCollisionShape(): FShape;
    setContactProcessingThreshold(contactProcessingThreshold: number): void;
    setActivationState(newState: number): void;
    forceActivationState(newState: number): void;
    activate(forceActivation?: boolean): void;
    isActive(): boolean;
    isKinematicObject(): boolean;
    isStaticObject(): boolean;
    isStaticOrKinematicObject(): boolean;
    getRestitution(): number;
    getFriction(): number;
    getRollingFriction(): number;
    setRestitution(rest: number): void;
    setFriction(frict: number): void;
    setRollingFriction(frict: number): void;
    getWorldTransform(): FTransform;
    getCollisionFlags(): number;
    setCollisionFlags(flags: number): void;
    setWorldTransform(worldTrans: FTransform): void;
    setCollisionShape(collisionShape: FShape): void;
    setCcdMotionThreshold(ccdMotionThreshold: number): void;
    setCcdSweptSphereRadius(radius: number): void;
    endPlay(reason: EDisposeReason): void;
    abstract drawDebug(): void;
    protected abstract updateDebug(): void;
}

export class CSphereCollision extends CPrimitive {
    get shape(): FSphereShape;
    set shape(val: FSphereShape);
    protected _shape: FSphereShape;
    constructor();
    drawDebug(): void;
    protected updateDebug(): void;
    dispose(): void;
}

export enum ERigidBodyShape {
    Box = 0,
    Sphere = 1,
    Capsule = 2
}
export class CRigidBody extends IBasicMesh implements IRigidBody {
    get bound(): FBoxShape;
    protected showDebugOnPlay: boolean;
    get collisionType(): ECollisionType;
    set collisionType(val: ECollisionType);
    readonly collisionChannel: ECollisionType[];
    protected get shapeType(): ERigidBodyShape;
    protected set shapeType(v: ERigidBodyShape);
    get shape(): FShape;
    set shape(v: FShape);
    protected _shape: FShape;
    get onBeginOverlap(): Observable<[ICollisionObject, IManifoldPoint[]]>;
    get onOverlapping(): Observable<[ICollisionObject, IManifoldPoint[]]>;
    get onEndOverlap(): Observable<[ICollisionObject, IManifoldPoint[]]>;
    enablePhysics: boolean;
    config: IRigidBodyConfig;
    get collisionObject(): IRigidBody;
    protected physicsWorld: IPhysicsWorld;
    protected readonly factory: RigidBodyFactory;
    protected readonly disposes: FDisposableCollection;
    constructor();
    onAwake(): Promise<void>;
    beginPlay(): Promise<void>;
    protected _helper?: FHelper;
    protected _helperObject?: FWireFrameHelperObject;
    protected debug(): void;
    protected updateShape(): void;
    protected updateDebug(): void;
    getUserPointer(): any;
    setUserPointer(userPointer: any): void;
    getCenterOfMassTransform(): FTransform;
    setCenterOfMassTransform(transform: FTransform): void;
    setSleepingThresholds(linear: number, angular: number): void;
    getLinearDamping(): number;
    getAngularDamping(): number;
    setDamping(lin_damping: number, ang_damping: number): void;
    setMassProps(mass: number, inertia: FVector3): void;
    getLinearFactor(): FVector3;
    setLinearFactor(linearFactor: FVector3): void;
    applyTorque(torque: FVector3): void;
    applyLocalTorque(torque: FVector3): void;
    applyForce(force: FVector3, rel_pos: FVector3): void;
    applyCentralForce(force: FVector3): void;
    applyCentralLocalForce(force: FVector3): void;
    applyTorqueImpulse(torque: FVector3): void;
    applyImpulse(impulse: FVector3, rel_pos: FVector3): void;
    applyCentralImpulse(impulse: FVector3): void;
    updateInertiaTensor(): void;
    getLinearVelocity(): FVector3;
    getAngularVelocity(): FVector3;
    setLinearVelocity(lin_vel: FVector3): void;
    setAngularVelocity(ang_vel: FVector3): void;
    getAngularFactor(): FVector3;
    setAngularFactor(angularFactor: FVector3): void;
    getAabb(aabbMin: FVector3, aabbMax: FVector3): void;
    getGravity(): FVector3;
    setGravity(acceleration: FVector3): void;
    getMotionState(): IMotionState;
    setMotionState(motionState: IMotionState): void;
    setAnisotropicFriction(anisotropicFriction: FVector3, frictionMode: number): void;
    getCollisionShape(): FShape;
    setContactProcessingThreshold(contactProcessingThreshold: number): void;
    setActivationState(newState: number): void;
    forceActivationState(newState: number): void;
    activate(forceActivation?: boolean): void;
    isActive(): boolean;
    isKinematicObject(): boolean;
    isStaticObject(): boolean;
    isStaticOrKinematicObject(): boolean;
    getRestitution(): number;
    getFriction(): number;
    getRollingFriction(): number;
    setRestitution(rest: number): void;
    setFriction(frict: number): void;
    setRollingFriction(frict: number): void;
    getWorldTransform(): FTransform;
    getCollisionFlags(): number;
    setCollisionFlags(flags: number): void;
    setWorldTransform(worldTrans: FTransform): void;
    setCollisionShape(collisionShape: FShape): void;
    setCcdMotionThreshold(ccdMotionThreshold: number): void;
    setCcdSweptSphereRadius(radius: number): void;
    destroyUserPoint(): void;
    tick(deltaSecond: number): void;
    endPlay(reason: EDisposeReason): void;
}

export class CScriptComponent extends CComponent {
    protected disposables: FDisposableCollection;
    get script(): RLScript;
    set script(script: RLScript);
    protected get scriptExecutor(): FScriptExecutor | undefined;
    protected set scriptExecutor(val: FScriptExecutor | undefined);
    protected _updateScript(): void;
    _beginPlay(): Promise<void>;
    beginPlay(): Promise<void>;
    tick(deltaSecond: number): void;
    endPlay(reason: EDisposeReason): void;
    dispose(): void;
    protected startSerialize(objectDatas: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
    protected startDeserialize(data: FObjectData, scope: IDeserializeScope): Promise<boolean>;
}

export abstract class FScriptExecutor extends FStruct implements ILifecycle {
        protected component: CComponent;
        protected owner: AActor;
        readonly type: string;
        protected get isExecutor(): boolean;
        get lifeState(): ELifecycle;
        get tickable(): boolean;
        constructor(component: CComponent, owner: AActor);
        /**
            * 对象在场景中开始事件，执行一次
            *
            * @returns {Promise<void>}
            * @memberof ILifecycle
            */
        abstract beginPlay?(): Promise<void>;
        /**
            * 帧事件，每帧执行
            *
            * @param {number} deltaSecond 和上一帧之间的时间间隔
            * @memberof ILifecycle
            */
        abstract tick?(deltaSecond: number): void;
        /**
            * 对象在场景中结束事件，执行一次
            *
            * @param {EDisposeReason} reason 结束原因
            * @memberof ILifecycle
            */
        abstract endPlay?(reason: EDisposeReason): void;
        dispose(): void;
}
export class FBasicScript extends FScriptExecutor {
        onAwake(): Promise<void>;
        beginPlay(): Promise<void>;
        tick(deltaSecond: number): void;
        endPlay(reason: EDisposeReason): void;
}

export class CSpringArm extends CComponent {
    get length(): number;
    set length(val: number);
    protected pawn?: IPawn;
    initialize(): Promise<void>;
    onAwake(): Promise<void>;
    protected getPosition(eyeDirection: FVector3): Readonly<FVector3>;
    updatePosition(eyeDirection: FVector3): void;
    tick(deltaSecond: number): void;
}

export class CSpriteFrames extends CComponent {
    time: number;
    get spriteMaterials(): RLSpriteMaterial[];
    set spriteMaterials(materials: RLSpriteMaterial[]);
    constructor(spriteMaterials?: RLSpriteMaterial[]);
    protected updateMaterial(): void;
    tick(deltaSecond: number): void;
}

export class CSprite extends CComponent {
    get spriteMaterial(): RLSpriteMaterial | undefined;
    set spriteMaterial(material: RLSpriteMaterial | undefined);
    constructor(spriteMaterial?: RLSpriteMaterial);
    protected updateMaterial(): void;
}

export class TGameWorld extends TWorld {
    protected _initWorld(): Promise<void>;
}

export class FBoxHelper extends FHelper {
    get halfExtents(): FVector3;
    set halfExtents(val: FVector3);
    protected _halfExtents: FVector3;
    update(): void;
}

export class FCapsuleHelper extends FHelper {
    get radius(): number;
    protected _radius: number;
    get halfHeight(): number;
    setValue(radius: number, halfHeight: number): void;
    update(): void;
}

export abstract class FHelperObject implements IDisposable {
    protected _object: Object3D;
    protected _material: Material;
    protected disposables: FDisposableCollection;
    constructor(transformable: RLTransformable);
    protected abstract init(transformable: RLTransformable): void;
    dispose(): void;
}

export class FWireFrameHelperObject extends FHelperObject {
    get wireFrame(): LineSegments;
    get material(): LineBasicMaterial;
    protected init(transformable: RLTransformable): void;
}

export abstract class FHelper {
    get wireFrame(): LineSegments;
    get material(): LineBasicMaterial;
    protected _helperObject: FWireFrameHelperObject;
    constructor(helperObject: FWireFrameHelperObject);
    abstract update(): void;
}

export class FSphereHelper extends FHelper {
    get radius(): number;
    set radius(val: number);
    protected _radius: number;
    update(): void;
}

export const ViewportFactory: unique symbol;
export type ViewportFactory = () => IViewport;
export interface IViewport {
        name: string;
        canvas: HTMLCanvasElement;
        width: number;
        height: number;
        onResize: Observable<FVector2>;
        camera?: Camera;
        gui?: RLGui;
        isRenderGui?: boolean;
        background?: FColor;
        alpha?: number;
        disable?: boolean;
        orthoFactor: number;
}
/**
    * 碰撞结果
    *
    * @export
    * @interface IHitResult
    * @extends {Intersection}
    */
export interface IHitResult extends Intersection {
        transformable: RLTransformable;
}
export const intersectionToHit: (intersection: Intersection) => IHitResult;
export enum EGameState {
        Playing = 0,
        Paused = 1
}
export const IWorld: unique symbol;
/**
    * 游戏世界接口
    *
    * @export
    * @interface IWorld
    */
export interface IWorld {
        onGameStateChanged: Observable<EGameState>;
        isPlaying: boolean;
        activeScene: RLScene;
        viewport: Readonly<Map<string, IViewport>>;
        addViewport(viewport: IViewport): void;
        removeViewport(name: string): IViewport | undefined;
        /**
            * 在当前激活场景中生成 Actor
            *
            * @template T Actor 子类类型
            * @param {IInitializer<T>} c Actor 构造器
            * @param {...ConstructorParameters<IInitializer<T>>} constructorArgs 构造参数
            * @returns {Promise<InstanceType<IInitializer<T>>>} Actor
            * @memberof IWorld
            */
        spawnActor<T extends AActor>(c: IInitializer<T>, ...constructorArgs: ConstructorParameters<IInitializer<T>>): Promise<InstanceType<IInitializer<T>>>;
        /**
            * 查找场景中符合特定类型所有 Actor
            *
            * @template T Actor 子类类型
            * @param {IInitializer<T>} c Actor 子类构造器
            * @param {Array<InstanceType<IInitializer<T>>>} actors 结果
            * @memberof RLScene
            */
        findActorsByClass<T extends AActor>(c: IInitializer<T>, actors: Array<InstanceType<IInitializer<T>>>): void;
        /**
            * 射线检测，返回第一个结果
            *
            * @param {FVector3} start 起点
            * @param {FVector3} direction 方向
            * @returns {(IHitResult | undefined)} 第一个检测结果
            * @memberof IWorld
            */
        renderLineTrace(start: FVector3, direction: FVector3, ignore?: RLTransformable[], far?: number): IHitResult | undefined;
        /**
            * 射线检测，返回所有结果
            *
            * @param {FVector3} start 起点
            * @param {FVector3} direction 方向
            * @returns {IHitResult[]} 所有检测结果
            * @memberof IWorld
            */
        multiRenderLineTrace(start: FVector3, direction: FVector3, ignore?: RLTransformable[], far?: number): IHitResult[];
        /**
            * 鼠标位置的射线检测，返回第一个结果
            *
            * @param {Camera} camera 当前摄像机
            * @param {FVector2} mousePosition 鼠标位置
            * @returns {(IHitResult | undefined)} 第一个检测结果
            * @memberof IWorld
            */
        mouseRenderLineTrace(camera: Camera, mousePosition: FVector2, ignore?: RLTransformable[], far?: number): IHitResult | undefined;
        /**
            * 鼠标位置的射线检测，返回所有结果
            *
            * @param {Camera} camera 当前摄像机
            * @param {FVector2} mousePosition 鼠标位置
            * @returns {IHitResult[]} 所有检测结果
            * @memberof IWorld
            */
        multiMouseRenderLineTrace(camera: Camera, mousePosition: FVector2, ignore?: RLTransformable[], far?: number, result?: IHitResult[]): IHitResult[];
        /**
            * 获取鼠标在当前 canvas 中的位置
            *
            * @param {MouseEvent} event
            * @returns {FVector2}
            * @memberof IWorld
            */
        getMousePosition(event: MouseEvent): FVector2;
        physicsLineTrace(from: FVector3 | FVector4, to: FVector3 | FVector4, collisionType: ECollisionType, collisionChannel: Array<ECollisionType>, ignores?: Set<ICollisionObject>, scene?: RLScene): ISinglePhysicsRayResult;
        multiPhysicsLineTrace(from: FVector3 | FVector4, to: FVector3 | FVector4, collisionType: ECollisionType, collisionChannel: Array<ECollisionType>, ignores?: Set<ICollisionObject>, scene?: RLScene): IMultiPhysicsRayResult;
        physicsSweep(castShape: FShape, from: FTransform, to: FTransform, collisionType: ECollisionType, collisionChannel: Array<ECollisionType>, ignores?: Set<ICollisionObject>, allowedCcdPenetration?: number, scene?: RLScene): IPhysicsSweepResult;
        switch(scene: RLScene | string, disposeOld?: boolean): Promise<RLScene | undefined>;
}
export class FWorld {
        static world: IWorld;
}
export const GWorld: () => IWorld;

/**
  * 胶囊体几何顶点
  *
  * @export
  * @class FCapsuleBufferGeometry
  * @extends {BufferGeometry}
  */
export class FCapsuleBufferGeometry extends BufferGeometry {
    radiusTop: number;
    radiusBottom: number;
    height: number;
    radialSegments: number;
    heightSegments: number;
    capsTopSegments: number;
    capsBottomSegments: number;
    thetaStart: number;
    thetaLength: number;
    constructor(radiusTop?: number, radiusBottom?: number, height?: number, radialSegments?: number, heightSegments?: number, capsTopSegments?: number, capsBottomSegments?: number, thetaStart?: number, thetaLength?: number);
    calculateVertexCount(): number;
    calculateIndexCount(): number;
    generateTorso(): void;
}

/**
  * AABB 盒体碰撞检测
  *
  * @export
  * @class FAABBCollision
  * @implements {ICollision}
  */
export class FAABBCollision implements ICollision {
    get shape(): FBoxShape;
    constructor(shape: FBoxShape);
    intersect(collision: ICollision): boolean;
    inside(collision: ICollision): boolean;
    contain(other: ICollision | FVector3): boolean;
}

/**
    * 碰撞检测接口
    *
    * @export
    * @interface ICollision
    */
export interface ICollision {
        /**
            * 碰撞形状
            *
            * @type {FShape}
            * @memberof ICollision
            */
        shape: FShape;
        /**
            * 是否与检测对象相交
            *
            * @param {ICollision} other 检测对象
            * @returns {boolean}
            * @memberof ICollision
            */
        intersect(other: ICollision): boolean;
        /**
            * 是否完全在检测象象内
            *
            * @param {ICollision} other 检测对象
            * @returns {boolean}
            * @memberof ICollision
            */
        inside(other: ICollision): boolean;
        /**
            * 是否完全包含检测对象
            *
            * @param {(FVector3 | ICollision)} other 检测对象
            * @returns {boolean}
            * @memberof ICollision
            */
        contain(other: FVector3 | ICollision): boolean;
}
export class FCollisionMisc {
        static intersect_Line_AABB(a: FLine, b: FBoxShape): boolean;
        static intersect_AABB_AABB(a: FBoxShape, b: FBoxShape): boolean;
        static intersect_AABB_Sphere(a: FBoxShape, b: FSphereShape): boolean;
        static intersect_AABB_Capsule(a: FBoxShape, b: FCapsuleShape): boolean;
        static intersect_Sphere_Sphere(a: FSphereShape, b: FSphereShape): boolean;
        static intersect_Sphere_Capsule(a: FSphereShape, b: FCapsuleShape): boolean;
        static intersect_Capsule_Capsule(a: FCapsuleShape, b: FCapsuleShape): boolean;
        static inside_Point_AABB(a: FVector3, b: FBoxShape): boolean;
        static inside_Point_Sphere(a: FVector3, b: FSphereShape): boolean;
        static inside_AABB_AABB(a: FBoxShape, b: FBoxShape): boolean;
        static inside_AABB_Sphere(a: FBoxShape, b: FSphereShape): boolean;
        static inside_Sphere_AABB(a: FSphereShape, b: FBoxShape): boolean;
        static inside_Sphere_Sphere(a: FSphereShape, b: FSphereShape): boolean;
}

/**
  * 球体碰撞检测
  *
  * @export
  * @class FSphereCollision
  * @implements {ICollision}
  */
export class FSphereCollision implements ICollision {
    get shape(): FSphereShape;
    constructor(shape: FSphereShape);
    intersect(collision: ICollision): boolean;
    inside(collision: ICollision): boolean;
    contain(other: ICollision | FVector3): boolean;
}

export type FColor = Color;
export const FColor: typeof Color;

export type FEuler = Euler;
export const FEuler: typeof Euler;

export namespace _FMath {
    function Simpson(a: number, b: number, func: (v: number) => number): number;
    function LeastSquares(sampleX: FMatrix, sampleY: FMatrix): FMatrix | undefined;
    function LeastSquaresFromPoints(data: FVector2[] | FVector3[]): FMatrix | undefined;
    function clamp(value: number, min: number, max: number): number;
    function rotate(v: FVector2, value: number): FVector2;
    function withIn(src: FVector2, range: FVector2): boolean;
}

export class FMatrix {
    static Identity(n: number): FMatrix;
    constructor(row: number, column: number);
    set(arg: number[]): this;
    get(index: number): number;
    length(): number;
    getRow(index: number): number[] | undefined;
    getColumn(index: number): number[] | undefined;
    transpose(): FMatrix;
    cofactor(row?: number, column?: number): number;
    mul(other: FMatrix | number): FMatrix | undefined;
    mul2Ref(other: number): this;
    adjugate(): FMatrix | undefined;
    inverse(): FMatrix | undefined;
}

export type FMatrix3 = Matrix3;
export type FMatrix4 = Matrix4;
export const FMatrix3: typeof Matrix3;
export const FMatrix4: typeof Matrix4;

export type FPlane = FVector4;
export const FPlane: typeof import("three").Vector4;

export type FQuaternion = Quaternion;
export const FQuaternion: typeof Quaternion;

/**
    * 盒体
    *
    * @export
    * @class FBoxShape
    * @extends {FShape}
    */
export class FBoxShape extends FShape {
        get bound(): FBoxShape;
        protected _bound?: FBoxShape;
        /**
            * 盒体三维半边长
            *
            * @type {FVector3}
            * @memberof FBoxShape
            */
        get halfExtents(): FVector3;
        set halfExtents(value: FVector3);
        /**
            * Creates an instance of FBoxShape.
            * @param {FVector3} halfExtents 盒体三维半边长
            * @param {FVector3} [origin] 中心位置
            * @memberof FBoxShape
            */
        constructor(halfExtents?: FVector3, origin?: FVector3);
        /**
            * 与其它盒体相加
            *
            * @param {FBoxShape} other 其它盒体
            * @memberof FBoxShape
            */
        add(other: FShape): void;
        set(points: FVector3[]): void;
        /**
            * 是否与其它盒体相同
            *
            * @param {this} other 其它盒体
            * @returns {boolean}
            * @memberof FBoxShape
            */
        equals(other: this): boolean;
}

/**
    * 胶囊体
    *
    * @export
    * @class FCapsuleShape
    * @extends {FShape}
    */
export class FCapsuleShape extends FShape {
        get bound(): FBoxShape;
        /**
            * 半径
            *
            * @readonly
            * @type {number}
            * @memberof FCapsuleShape
            */
        get radius(): number;
        set radius(val: number);
        /**
            * 半高
            *
            * @readonly
            * @type {number}
            * @memberof FCapsuleShape
            */
        get halfHeight(): number;
        set halfHeight(val: number);
        /**
            * Creates an instance of FCapsuleShape.
            * @param {number} radius 半径
            * @param {number} halfHeight 半高
            * @param {FVector3} [origin] 中心位置
            * @memberof FCapsuleShape
            */
        constructor(radius?: number, halfHeight?: number, origin?: FVector3);
        /**
            * 与其它胶囊体是否相等
            *
            * @param {this} other 其它胶囊体
            * @returns {boolean}
            * @memberof FCapsuleShape
            */
        equals(other: this): boolean;
}

/**
    * 直线
    *
    * @export
    * @class FLine
    * @extends {FShape}
    */
export class FLine extends FShape {
        get bound(): FBoxShape;
        /**
            * 直线三维空间中的方向
            *
            * @readonly
            * @type {FVector3}
            * @memberof FLine
            */
        get direction(): FVector3;
        /**
            * Creates an instance of FLine.
            * @param {FVector3} origin 直线上的某一点
            * @param {FVector3} direction 直线方向
            * @memberof FLine
            */
        constructor(origin?: FVector3, direction?: FVector3);
        /**
            * 点与直线距离的平方
            *
            * @param {FVector3} point 点
            * @returns {number} 距离的平方
            * @memberof FLine
            */
        squareDistance(point: FVector3): number;
        /**
            * 点与直线的距离
            *
            * @param {FVector3} point 点
            * @returns {number} 距离
            * @memberof FLine
            */
        distance(point: FVector3): number;
        protected _diff(point: FVector3): [FVector3, number];
        /**
            * 是否与其它直线相同
            *
            * @param {this} other 其它直线
            * @returns {boolean}
            * @memberof FLine
            */
        equals(other: this): boolean;
}

/**
    * 射线
    *
    * @export
    * @class FRay
    * @extends {FLine}
    */
export class FRay extends FLine {
        protected _diff(point: FVector3): [FVector3, number];
        /**
            * 是否与其它射线相同
            *
            * @param {this} other 其它射线
            * @returns {boolean}
            * @memberof FLine
            */
        equals(other: this): boolean;
}

/**
    * 线段
    *
    * @export
    * @class FSegment
    * @extends {FLine}
    */
export class FSegment extends FLine {
        /**
            * 线段长度
            *
            * @readonly
            * @type {number}
            * @memberof FSegment
            */
        get length(): number;
        /**
            * Creates an instance of FSegment.
            * @param {FVector3} origin 起点
            * @param {FVector3} direction 方向
            * @param {number} length 长度
            * @memberof FSegment
            */
        constructor(origin?: FVector3, direction?: FVector3, length?: number);
        protected _diff(point: FVector3): [FVector3, number];
        /**
            * 是否与其它线段相同
            *
            * @param {this} other 其它线段
            * @returns {boolean}
            * @memberof FSegment
            */
        equals(other: this): boolean;
}

/**
    * 形状基类
    *
    * @export
    * @abstract
    * @class FShape
    */
export abstract class FShape extends FStruct {
        /**
            * 中心位置
            *
            * @type {Readonly<FVector3>}
            * @memberof FShape
            */
        get origin(): Readonly<FVector3>;
        set origin(value: Readonly<FVector3>);
        get scale(): FVector3;
        set scale(v: FVector3);
        abstract bound: FShape;
        protected _origin: FVector3;
        protected _scale: FVector3;
        /**
            * Creates an instance of FShape.
            * @param {FVector3} [origin] 中心位置
            * @memberof FShape
            */
        constructor(origin?: FVector3);
        equals(other: this): boolean;
}

/**
    * 球体
    *
    * @export
    * @class FSphereShape
    * @extends {FShape}
    */
export class FSphereShape extends FShape {
        get bound(): FBoxShape;
        /**
            * 半径
            *
            * @readonly
            * @type {number}
            * @memberof FSphereShape
            */
        get radius(): number;
        set radius(val: number);
        /**
            * Creates an instance of FSphereShape.
            * @param {number} radius 半径
            * @param {FVector3} [origin] 中心位置
            * @memberof FSphereShape
            */
        constructor(radius?: number, origin?: FVector3);
        /**
            * 是否与其它球体相同
            *
            * @param {this} other 其它球体
            * @returns {boolean}
            * @memberof FSphereShape
            */
        equals(other: this): boolean;
}

export class FTransform {
    get position(): FVector3;
    get rotation(): FEuler;
    get scale(): FVector3;
    get quat(): FQuaternion;
    static get Identity(): FTransform;
    constructor(translate?: FVector3, rotation?: FEuler, scale?: FVector3);
    clone(): FTransform;
    equals(other: this): boolean;
    copy(transform: FTransform): this;
    setTranslate(translate: FVector3): void;
    setRotation(rotation: FEuler): void;
    setScale(scale: FVector3): void;
    setTranslateX(value: number): void;
    setTranslateY(value: number): void;
    setTranslateZ(value: number): void;
    setRoll(value: number): void;
    setPitch(value: number): void;
    setYaw(value: number): void;
    SetScaleX(value: number): void;
    SetScaleY(value: number): void;
    SetScaleZ(value: number): void;
    toArray(): number[];
    toMatrix(): FMatrix4;
    fromArray(data: number[]): this;
    fromMatrix(matrix: FMatrix4): this;
}

export type FVector2 = Vector2;
export type FVector3 = Vector3;
export type FVector4 = Vector4;
export const FVector2: typeof Vector2;
export const FVector3: typeof Vector3;
export const FVector4: typeof Vector4;
export namespace FVector {
    const LEFT: () => Readonly<FVector3>;
    const RIGHT: () => Readonly<FVector3>;
    const UP: () => Readonly<FVector3>;
    const DOWN: () => Readonly<FVector3>;
    const FORWARD: () => Readonly<FVector3>;
    const BACK: () => Readonly<FVector3>;
    function fix(vector: FVector2 | FVector3 | FVector4): void;
    function fixDirection(vector: FVector3): void;
}

export const animationAsset: unique symbol;
export const lastKey: unique symbol;
export type IKeyFrameEvent = (time: number, key: number) => void;
export class RLAnimationAsset extends RLObject {
    get isRootMotion(): boolean;
    set isRootMotion(val: boolean);
    get rootBoneName(): string;
    set rootBoneName(val: string);
    lastKey?: number;
    get suffix(): ESuffix;
    get isShareData(): boolean;
    get animation(): AnimationClip;
    constructor(animation: AnimationClip);
    addEvent(frame: number, event: IKeyFrameEvent): void;
    getEvent(frame: number): IKeyFrameEvent[] | undefined;
    protected _setAnimation(val: AnimationClip): void;
    protected startSerialize(objectDatas: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
    protected startDeserialize(objectData: FObjectData, scope: IDeserializeScope): Promise<boolean>;
}

export class RLAudio extends RLObject {
    protected readonly audioLoader: AudioLoader;
    get suffix(): ESuffix;
    get isShareData(): boolean;
    get audio(): AudioBuffer | undefined;
    constructor(audio: ArrayBuffer, name: string);
    protected _load(url: string): Promise<AudioBuffer>;
    load(): Promise<void>;
    protected startSerialize(objectDatas: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
    protected startDeserialize(data: FObjectData, scope: IDeserializeScope): Promise<boolean>;
}

export class RLClass<O extends object = object> extends RLObject {
    protected readonly classLoader: FClasses;
    protected _cls: IConstructor<O>;
    protected _classPath: string[];
    get suffix(): ESuffix;
    get ctor(): IConstructor<O>;
    get classPath(): Readonly<string[]>;
    get parent(): IConstructor<object>;
    constructor(ctor?: IConstructor<O>, path?: string);
    protected startSerialize(objectDatas: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
    protected startDeserialize(data: FObjectData, scope: IDeserializeScope): Promise<boolean>;
    static isSerializable(cls: object | undefined): cls is ISerializable;
    static isSerializableClass(cls: any | undefined): boolean;
    static getDefaultObject<T>(obj: object): Readonly<T> | undefined;
    static getMutableDefaultObject<T>(obj: object): T | undefined;
}

export class RLFont extends RLObject {
    get suffix(): ESuffix;
    get font(): Font;
    constructor(font: Font, name: string);
    protected startSerialize(objectDatas: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
    protected startDeserialize(data: FObjectData, scope: IDeserializeScope): Promise<boolean>;
}

export interface ISkeletonInfo {
    skeleton: string;
    bones?: number[];
    boneInverses?: FMatrix4[];
}
export class RLGeometry extends RLObject {
    protected static readonly objectLoader: ObjectLoader;
    get suffix(): ESuffix;
    get isShareData(): boolean;
    get geometry(): BufferGeometry;
    get skeletonInfo(): ISkeletonInfo | undefined;
    constructor(geometry: BufferGeometry, subSkeleton?: ISkeletonInfo);
    protected serializeInterleavedBufferAttribute(attrs: FObjectData<InterleavedBufferAttribute>): FObjectData;
    protected startSerialize(objectDatas: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected deserializeInterleavedBufferAttribute(src: FObjectData): FObjectData<InterleavedBufferAttribute>;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
    protected startDeserialize(obj: FObjectData, scope: IDeserializeScope): Promise<boolean>;
}

export type FMaterialParameters<T extends MaterialParameters = MaterialParameters> = FStruct & {
    [P in keyof T]: T[P] extends (Texture | null | undefined) ? RLTexture : T[P];
};
export type IMaterialParameters<T extends MaterialParameters = MaterialParameters> = IStruct<FMaterialParameters<T>>;
export abstract class RLMaterial<M extends Material = Material, P extends MaterialParameters = MaterialParameters> extends RLObject {
    get isShareData(): boolean;
    get suffix(): ESuffix;
    get material(): M;
    protected _width: number;
    get width(): number;
    protected _height: number;
    get height(): number;
    protected params: FMaterialParameters<P>;
    constructor(value: IConstructor<M>, params?: IMaterialParameters<P>);
    protected updateParams(ctor: IConstructor<M> | undefined, params: FMaterialParameters<P>): void;
    protected startSerialize(objectDatas: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected startDeserialize(data: FObjectData, scope: IDeserializeScope): Promise<boolean>;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
}

export class RLLineBasicMaterial extends RLMaterial<LineBasicMaterial, LineBasicMaterialParameters> {
    protected params: FMaterialParameters<LineBasicMaterialParameters>;
    constructor(params?: IMaterialParameters<LineBasicMaterialParameters>);
}
export class RLLineDashedMaterial extends RLMaterial<LineDashedMaterial, LineDashedMaterialParameters> {
    protected params: FMaterialParameters<LineDashedMaterialParameters>;
    constructor(params?: IMaterialParameters<LineDashedMaterialParameters>);
}
export class RLMeshBasicMaterial extends RLMaterial<MeshBasicMaterial, MeshBasicMaterialParameters> {
    protected params: FMaterialParameters<MeshBasicMaterialParameters>;
    constructor(params?: IMaterialParameters<MeshBasicMaterialParameters>);
}
export class RLMeshDepthMaterial extends RLMaterial<MeshDepthMaterial, MeshDepthMaterialParameters> {
    protected params: FMaterialParameters<MeshDepthMaterialParameters>;
    constructor(params?: IMaterialParameters<MeshDepthMaterialParameters>);
}
export class RLMeshDistanceMaterial extends RLMaterial<MeshDistanceMaterial, MeshDistanceMaterialParameters> {
    protected params: FMaterialParameters<MeshDistanceMaterialParameters>;
    constructor(params?: IMaterialParameters<MeshDistanceMaterialParameters>);
}
export class RLMeshLambertMaterial extends RLMaterial<MeshLambertMaterial, MeshLambertMaterialParameters> {
    protected params: FMaterialParameters<MeshLambertMaterialParameters>;
    constructor(params?: IMaterialParameters<MeshLambertMaterialParameters>);
}
export class RLMeshMatcapMaterial extends RLMaterial<MeshMatcapMaterial, MeshMatcapMaterialParameters> {
    protected params: FMaterialParameters<MeshMatcapMaterialParameters>;
    constructor(params?: IMaterialParameters<MeshMatcapMaterialParameters>);
}
export class RLMeshNormalMaterial extends RLMaterial<MeshNormalMaterial, MeshNormalMaterialParameters> {
    protected params: FMaterialParameters<MeshNormalMaterialParameters>;
    constructor(params?: IMaterialParameters<MeshNormalMaterialParameters>);
}
export class RLMeshPhongMaterial extends RLMaterial<MeshPhongMaterial, MeshPhongMaterialParameters> {
    protected params: FMaterialParameters<MeshPhongMaterialParameters>;
    constructor(params?: IMaterialParameters<MeshPhongMaterialParameters>);
}
export class RLMeshPhysicalMaterial extends RLMaterial<MeshPhysicalMaterial, MeshPhysicalMaterialParameters> {
    protected params: FMaterialParameters<MeshPhysicalMaterialParameters>;
    constructor(params?: IMaterialParameters<MeshPhysicalMaterialParameters>);
}
export class RLMeshStandardMaterial extends RLMaterial<MeshStandardMaterial, MeshStandardMaterialParameters> {
    protected params: FMaterialParameters<MeshStandardMaterialParameters>;
    constructor(params?: IMaterialParameters<MeshStandardMaterialParameters>);
}
export class RLMeshToonMaterial extends RLMaterial<MeshToonMaterial, MeshToonMaterialParameters> {
    protected params: FMaterialParameters<MeshToonMaterialParameters>;
    constructor(params?: IMaterialParameters<MeshToonMaterialParameters>);
}
export class RLPointsMaterial extends RLMaterial<PointsMaterial, PointsMaterialParameters> {
    protected params: FMaterialParameters<PointsMaterialParameters>;
    constructor(params?: IMaterialParameters<PointsMaterialParameters>);
}
export class RLRawShaderMaterial extends RLMaterial<RawShaderMaterial, ShaderMaterialParameters> {
    protected params: FMaterialParameters<ShaderMaterialParameters>;
    constructor(params?: IMaterialParameters<ShaderMaterialParameters>);
}
export class RLShaderMaterial extends RLMaterial<ShaderMaterial, ShaderMaterialParameters> {
    protected params: FMaterialParameters<ShaderMaterialParameters>;
    constructor(params?: IMaterialParameters<ShaderMaterialParameters>);
}
export class RLSpriteMaterial extends RLMaterial<SpriteMaterial, SpriteMaterialParameters> {
    protected params: FMaterialParameters<SpriteMaterialParameters>;
    constructor(params?: IMaterialParameters<SpriteMaterialParameters>);
}
export const RLMaterialTypes: Map<Function, IConstructor<RLMaterial>>;

type IScript = IConstructor<FScriptExecutor>;
export class RLScript extends RLObject {
    onConstructorUpdate: Observable<IScript>;
    get suffix(): ESuffix;
    get isShareData(): boolean;
    get content(): string;
    set content(val: string);
    get scriptId(): string;
    set scriptId(val: string);
    get scriptConstructor(): IScript;
    protected readonly _rawDataLoader: IRawDataLoader;
    protected readonly _pathResolver: FPathResolver;
    constructor();
    protected startSerialize(objectDatas: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
    protected _updateContent(content: string): boolean;
    updateScript(path?: string): boolean;
    protected startDeserialize(data: FObjectData, scope: IDeserializeScope): Promise<boolean>;
}
export {};

export class RLSerializable extends RLObject {
    protected _cls: IConstructor<ISerializable>;
    protected _classPath: string[];
    get ctor(): IConstructor<ISerializable>;
    get classPath(): string[];
    constructor(cls: IConstructor<ISerializable>, classPath: string);
    protected startSerialize(objectDatas: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
    protected startDeserialize(data: FObjectData, scope: IDeserializeScope): Promise<boolean>;
}

export class RLSkeletonMesh extends RLStaticMesh {
    protected readonly parameters: {
        _skeleton?: RLSkeleton;
        _rawSkeleton?: Skeleton;
        _geometry?: RLGeometry;
        _material?: RLMaterial | Array<RLMaterial>;
    };
    get skeleton(): RLSkeleton | undefined;
    set skeleton(skeleton: RLSkeleton | undefined);
    constructor(name: string, geometry?: RLGeometry, material?: RLMaterial | Array<RLMaterial>, skeleton?: RLSkeleton, matrix?: FMatrix4);
    protected startSerialize(objectDatas: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected startDeserialize(data: FObjectData, scope: IDeserializeScope): Promise<boolean>;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
    protected newMesh(): void;
}

export class RLSkeleton extends RLObject {
    protected static objectLoader: ObjectLoader;
    get suffix(): ESuffix;
    get isShareData(): boolean;
    get skeleton(): Skeleton;
    constructor(skeleton: Skeleton, name: string);
    protected serializeBone(boneArray: Bone[]): FObjectData;
    protected cloneBone(boneArray: Bone[]): Bone[];
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
    protected startSerialize(objectDatas: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected deserializeBone(bonesJson: FObjectData, keys: string[]): Bone[];
    protected startDeserialize(obj: FObjectData, scope: IDeserializeScope): Promise<boolean>;
}

export class RLStaticMesh extends RLObject {
    get suffix(): ESuffix;
    protected readonly parameters: {
        _geometry?: RLGeometry;
        _material?: RLMaterial | Array<RLMaterial>;
    };
    get attachBoneName(): string;
    set attachBoneName(val: string);
    get attachBoneTransform(): FTransform;
    set attachBoneTransform(val: FTransform);
    get geometry(): RLGeometry | undefined;
    set geometry(geo: RLGeometry | undefined);
    get material(): RLMaterial | Array<RLMaterial> | undefined;
    set material(mat: RLMaterial | Array<RLMaterial> | undefined);
    get mesh(): Mesh;
    protected _mesh: Mesh;
    protected readonly _matrix?: FMatrix4;
    constructor(mesh: Mesh, geometry?: RLGeometry, material?: RLMaterial | Array<RLMaterial>, matrix?: FMatrix4);
    constructor(name: string, geometry?: RLGeometry, material?: RLMaterial | Array<RLMaterial>, matrix?: FMatrix4);
    protected startSerialize(objectDatas: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected loadMesh(data: FObjectData): void;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
    protected startDeserialize(data: FObjectData, scope: IDeserializeScope): Promise<boolean>;
    protected newMesh(): void;
}

export class RLTexture extends RLObject {
    protected static readonly objectLoader: ObjectLoader;
    get suffix(): ESuffix;
    get isShareData(): boolean;
    get texture(): Texture;
    constructor(texture: Texture);
    protected getDataURL(image: HTMLCanvasElement | HTMLImageElement): string;
    protected startSerialize(objectDatas: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
    protected startDeserialize(data: FObjectData, scope: IDeserializeScope): Promise<boolean>;
}

export abstract class FAssetBase<T extends RLObject> {
        abstract object: Promise<T | undefined>;
        onLoaded: Observable<T>;
        onLoadFailed: Observable<void>;
        protected _gamePath: string | undefined;
        protected _object?: T;
        protected readonly loader: FLoader;
        protected readonly pathResolver: FPathResolver;
        protected bLoad: boolean;
        get gamePath(): string | undefined;
        set gamePath(gamePath: string | undefined);
        resetGamePath(gamePath?: string): Promise<void>;
        constructor(gamePath?: string);
        protected load(): Promise<void>;
        protected _loadGamePath(gamePath: string): Promise<T | undefined>;
}
/**
    * 资源
    *
    * @export
    * @class FAsset
    * @extends {FAssetBase<T>}
    * @template T
    */
export class FAsset<T extends RLObject> extends FAssetBase<T> {
        constructor(gamePath?: string);
        get object(): Promise<T | undefined>;
}
/**
    * 资源引用
    *
    * @export
    * @class FReference
    * @extends {FAssetBase<T>}
    * @template T
    */
export class FReference<T extends RLObject> extends FAssetBase<T> {
        get object(): Promise<T | undefined>;
}

export const RLAsset = "Asset";
export const defaultObjectKey: unique symbol;
export const defaultObjectPathKey: unique symbol;
export const setDefaultToObject: (obj: RLObject, defaultObj: RLObject, path: string) => void;
export const getResourceUid: (obj: object) => string | undefined;
export const setResourceUid: (obj: object, path: string) => void;
export const getDefaultObject: <T extends RLObject>(obj: object) => Readonly<T> | undefined;
export const getMutableDefaultObject: <T extends RLObject>(obj: object) => T | undefined;
/**
  * 基类，包括对象拷贝、序列化、反序列化
  *
  * @export
  * @class RLObject
  * @extends {FStruct}
  */
export class RLObject extends FStruct {
    onNameChanged: Observable<string>;
    dispose(): void;
    get suffix(): ESuffix;
    get isShareData(): boolean;
    get isClass(): boolean;
    get uid(): string;
    get name(): string;
    set name(newName: string);
    protected _name: string;
    constructor(name?: string);
    protected startDeserialize(serialized: FObjectData, scope: IDeserializeScope): Promise<boolean>;
    protected startCopy(src: this, scope: IDeserializeScope, filter?: FSerializeFilter): Promise<void>;
    protected startApplyChange(serialized: FObjectData, scope: IDeserializeScope): Promise<FObjectData>;
}

export enum EStructOperator {
    Serialize = 0,
    Copy = 1,
    Compare = 2,
    Resource = 3,
    Bind = 4,
    Dirty = 5
}
export interface IPropertyChangeData {
    property: string;
    oldValue: any;
    newValue: any;
}
export const root: unique symbol;
export const ObjectSerializerName: unique symbol;
export abstract class FStruct implements IBasic {
    get isSerialized(): boolean;
    get dirty(): boolean;
    protected ___isDirty: boolean;
    onDirtyChanged: Observable<string>;
    get rootDeserialized(): Promise<boolean> | boolean;
    get rootCopy(): Promise<boolean> | boolean;
    readonly onPropertyChange: Observable<IPropertyChangeData>;
    protected notifyPropertyChange(data: IPropertyChangeData): void;
    createPropertyChangeProxy(): this;
    serialize(scope?: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected beforeSerialize(): Promise<boolean>;
    getSerializeKeys(opt: EStructOperator): Map<string, boolean>;
    protected startSerialize(scope: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected afterSerialize(data: FObjectData): Promise<void>;
    deserialize(data: FObjectData, scope?: IDeserializeScope): Promise<boolean>;
    protected beforeDeserialize(): Promise<boolean>;
    protected startDeserialize(serialized: FObjectData, scope: IDeserializeScope): Promise<boolean>;
    protected afterDeserialize(): Promise<void>;
    protected afterCopy(): Promise<void>;
    copy(src: this, scope?: IDeserializeScope, filter?: FSerializeFilter): Promise<void>;
    protected startCopy(src: this, scope: IDeserializeScope, filter?: FSerializeFilter): Promise<void>;
    clone(): Promise<this>;
    compare(other: this | undefined, result: FObjectData, scope?: IDeserializeScope, filter?: FSerializeFilter): Promise<boolean>;
    protected startCompare(other: this | undefined, result: FObjectData, scope: IDeserializeScope, filter?: FSerializeFilter): Promise<boolean>;
    applyChange(serialized: FObjectData, scope?: IDeserializeScope): Promise<FObjectData>;
    protected startApplyChange(serialized: FObjectData, scope: IDeserializeScope): Promise<FObjectData>;
    clearDirty(): void;
    isDirty(set?: Set<FStruct>): boolean;
}
export type IStruct<T extends FStruct> = Omit<T, 'serialize' | 'deserialize' | 'copy' | 'compare' | 'applyChange' | 'clone' | 'getSerializeKeys' | 'createPropertyChangeProxy' | 'onPropertyChange' | 'rootDeserialized' | 'rootCopy' | '_rootDeserialized' | '_rootCopy' | 'isSerialized' | '_isSerialized' | 'onDirtyChanged' | 'dirty' | '___isDirty' | 'isDirty' | 'clearDirty'>;
export function struct<T extends FStruct>(st: IStruct<T>, proto?: IConstructor<T>): T;

export interface IPrimitive extends IDisposable {
    onBeginOverlap: Observable<[ICollisionObject, IManifoldPoint[]]>;
    onOverlapping: Observable<[ICollisionObject, IManifoldPoint[]]>;
    onEndOverlap: Observable<[ICollisionObject, IManifoldPoint[]]>;
}
export namespace IPrimitive {
    function is(obj: any): obj is IPrimitive;
}
export interface ICollisionObject extends IPrimitive {
    collisionObject: any;
    setAnisotropicFriction(anisotropicFriction: FVector3, frictionMode: number): void;
    getCollisionShape(): FShape;
    setContactProcessingThreshold(contactProcessingThreshold: number): void;
    setActivationState(newState: number): void;
    forceActivationState(newState: number): void;
    activate(forceActivation?: boolean): void;
    isActive(): boolean;
    isKinematicObject(): boolean;
    isStaticObject(): boolean;
    isStaticOrKinematicObject(): boolean;
    getRestitution(): number;
    getFriction(): number;
    getRollingFriction(): number;
    setRestitution(rest: number): void;
    setFriction(frict: number): void;
    setRollingFriction(frict: number): void;
    getWorldTransform(): FTransform;
    getCollisionFlags(): number;
    setCollisionFlags(flags: number): void;
    setWorldTransform(worldTrans: FTransform): void;
    setCollisionShape(collisionShape: FShape): void;
    setCcdMotionThreshold(ccdMotionThreshold: number): void;
    setCcdSweptSphereRadius(radius: number): void;
    getUserPointer(): any;
    setUserPointer(userPointer: any): void;
    destroyUserPoint(): void;
}
export namespace ICollisionObject {
    function is(obj: any): obj is ICollisionObject;
}

export interface ISinglePhysicsRayResult {
    hasHit: boolean;
    collisionFilterGroup: number;
    collisionFilterMask: number;
    closestHitFraction: number;
    collisionObject: ICollisionObject;
    hitNormal: FVector3;
    hitPosition: FVector3;
}
export interface IMultiPhysicsRayResult {
    hasHit: boolean;
    collisionFilterGroup: number;
    collisionFilterMask: number;
    closestHitFraction: number;
    collisionObjects: ICollisionObject[];
    hitNormals: FVector3[];
    hitPositions: FVector3[];
    hitFractions: number[];
}
export interface IPhysicsSweepResult {
    hasHit: boolean;
    collisionFilterGroup: number;
    collisionFilterMask: number;
    closestHitFraction: number;
    hitNormal: FVector3;
    hitPosition: FVector3;
    destination: FVector3;
    collisionObject: ICollisionObject;
}
export interface IManifoldPoint {
    positionWorldOnOther: FVector3;
    positionWorld: FVector3;
    appliedImpulse: number;
    distance: number;
    localPointOnOther: FVector3;
    localPoint: FVector3;
    normalWorldOnOther: FVector3;
    normalWorld: FVector3;
    userPersistentData: any;
}
export interface IPersistentManifold {
    body0: ICollisionObject;
    body1: ICollisionObject;
    numContacts: number;
    getContactPoint(index: number): IManifoldPoint;
}
export const ICollisionWorld: unique symbol;
export interface ICollisionWorld extends IDisposable {
    rawWorld: any;
    getNumManifolds(): number;
    getManifoldByIndex(index: number): IPersistentManifold;
    rayTest(rayFromWorld: FVector3 | FVector4, rayToWorld: FVector3 | FVector4, collisionType: ECollisionType, collisionChannel: Array<ECollisionType>, ignores?: Set<ICollisionObject>): ISinglePhysicsRayResult;
    rayTestAll(rayFromWorld: FVector3 | FVector4, rayToWorld: FVector3 | FVector4, collisionType: ECollisionType, collisionChannel: Array<ECollisionType>, ignores?: Set<ICollisionObject>): IMultiPhysicsRayResult;
    convexSweepTest(castShape: FShape, from: FTransform, to: FTransform, collisionType: ECollisionType, collisionChannel: Array<ECollisionType>, ignores?: Set<ICollisionObject>, allowedCcdPenetration?: number): IPhysicsSweepResult;
    addCollisionObject(collisionObject: ICollisionObject, collisionFilterGroup?: number, collisionFilterMask?: number): void;
    removeCollisionObject(collisionObject: ICollisionObject): void;
    updateSingleAabb(colObj: ICollisionObject): void;
    update(deltaSecond: number): void;
}

export enum ECollisionType {
    Type_01 = 1,
    Type_02 = 2,
    Type_03 = 4,
    Type_04 = 8,
    Type_05 = 16,
    Type_06 = 32,
    Type_07 = 64,
    Type_08 = 128,
    Type_09 = 256,
    Type_10 = 512,
    Type_11 = 1024,
    Type_12 = 2048,
    Type_13 = 4096,
    Type_14 = 8192,
    Type_15 = 16384,
    Type_16 = 32768,
    Type_17 = 65536,
    Type_18 = 131072,
    Type_19 = 262144,
    Type_20 = 524288,
    Type_21 = 1048576,
    Type_22 = 2097152,
    Type_23 = 4194304,
    Type_24 = 8388608,
    Type_25 = 16777216,
    Type_26 = 33554432,
    Type_27 = 67108864,
    Type_28 = 134217728,
    Type_29 = 268435456,
    Type_30 = 536870912,
    Type_31 = 1073741824,
    Type_32 = -2147483648
}

export type CollisionObjectFactory = (trans: FTransform, shape: FShape) => IGhostObject;
export const CollisionObjectFactory: unique symbol;
export interface IGhostObject extends ICollisionObject {
    getOverlappingObjects(): ICollisionObject[];
    getNumOverlappingObjects(): number;
    getOverlappingObject(index: number): ICollisionObject | undefined;
}

export const IPhysicsWorld: unique symbol;
export interface IPhysicsWorld extends ICollisionWorld {
    setGravity(gravity: FVector3): void;
    getGravity(): FVector3;
    addRigidBody(body: IRigidBody): void;
    addRigidBody(body: IRigidBody, group: number, mask: number): void;
    removeRigidBody(body: IRigidBody): void;
    addSoftBody(body: ISoftBody, collisionFilterGroup: number, collisionFilterMask: number): void;
    removeSoftBody(body: ISoftBody): void;
}

export interface IMotionState {
    transform: FTransform;
}
export interface IRigidBodyConfig {
    margin?: number;
    mass?: number;
    localInertia?: FVector3;
}
export type RigidBodyFactory = (trans: FTransform, shape: FShape, config: IRigidBodyConfig) => IRigidBody;
export const RigidBodyFactory: unique symbol;
export interface IRigidBody extends ICollisionObject {
    getCenterOfMassTransform(): FTransform;
    setCenterOfMassTransform(transform: FTransform): void;
    setSleepingThresholds(linear: number, angular: number): void;
    getLinearDamping(): number;
    getAngularDamping(): number;
    setDamping(lin_damping: number, ang_damping: number): void;
    setMassProps(mass: number, inertia: FVector3): void;
    getLinearFactor(): FVector3;
    setLinearFactor(linearFactor: FVector3): void;
    applyTorque(torque: FVector3): void;
    applyLocalTorque(torque: FVector3): void;
    applyForce(force: FVector3, rel_pos: FVector3): void;
    applyCentralForce(force: FVector3): void;
    applyCentralLocalForce(force: FVector3): void;
    applyTorqueImpulse(torque: FVector3): void;
    applyImpulse(impulse: FVector3, rel_pos: FVector3): void;
    applyCentralImpulse(impulse: FVector3): void;
    updateInertiaTensor(): void;
    getLinearVelocity(): FVector3;
    getAngularVelocity(): FVector3;
    setLinearVelocity(lin_vel: FVector3): void;
    setAngularVelocity(ang_vel: FVector3): void;
    getAngularFactor(): FVector3;
    setAngularFactor(angularFactor: FVector3): void;
    getAabb(aabbMin: FVector3, aabbMax: FVector3): void;
    getGravity(): FVector3;
    setGravity(acceleration: FVector3): void;
    getMotionState(): IMotionState;
    setMotionState(motionState: IMotionState): void;
}

export interface ISoftBodyWorldConfig {
    airDensity: number;
    waterDensity: number;
    waterOffset: number;
    maxDisplacement: number;
    waterNormal: FVector3;
    gravity: FVector3;
}
export interface ISoftBodyConfig {
    kVCF: number;
    kDP: number;
    kDG: number;
    kVC: number;
    kDF: number;
    kMT: number;
    kCHR: number;
    kKHR: number;
    kSHR: number;
    kAHR: number;
    kSRHR_CL: number;
    kSKHR_CL: number;
    kSSHR_CL: number;
    kSR_SPLT_CL: number;
    kSK_SPLT_CL: number;
    kSS_SPLT_CL: number;
    maxVolume: number;
    timescale: number;
    viterations: number;
    piterations: number;
    diterations: number;
    citerations: number;
    collisions: number;
}
export interface ISoftNode {
    x: FVector3;
    q: FVector3;
    v: FVector3;
    f: FVector3;
    n: FVector3;
    im: number;
    area: number;
}
export type SoftBodyFactory = (softWorldConfig: ISoftBodyWorldConfig, nodeCount: number, x: FVector3, m: number[]) => ISoftBody;
export const SoftBodyFactory: unique symbol;
export type RopeFactory = (from: FVector3, to: FVector3, res: number, fixed: number) => ISoftBody;
export const RopeFactory: unique symbol;
export interface ISoftBody extends ICollisionObject {
    getConfig(): ISoftBodyConfig;
    seConfig(cfg: ISoftBodyConfig): void;
    getNodes(): ISoftNode[];
    checkLink(node0: number, node1: number): boolean;
    checkFace(node0: number, node1: number, node2: number): boolean;
    appendNode(x: FVector3, m: number): void;
    appendAnchor(node: number, body: IRigidBody, disableCollisionBetweenLinkedBodies: boolean, influence: number): void;
    addForce(force: FVector3, node?: number): void;
    addAeroForceToNode(windVelocity: FVector3, nodeIndex: number): void;
    getTotalMass(): number;
    setTotalMass(mass: number, fromFaces: boolean): void;
    setMass(node: number, mass: number): void;
    transform(trs: FTransform): void;
    translate(trs: FVector3): void;
    rotate(rot: FQuaternion): void;
    scale(scl: FVector3): void;
    generateClusters(k: number, maxIterations?: number): number;
}

export class RLDefaultScene extends RLGameScene {
    initialize(): Promise<void>;
    protected addDefaultActor(): Promise<void>;
}

/**
  * 游戏场景
  *
  * @export
  * @abstract
  * @class RLGameScene
  * @extends {RLObject}
  * @implements {IInitializable}
  */
export class RLGameScene extends RLScene {
    get gameModeClass(): RLClass<AGameMode>;
    set gameModeClass(val: RLClass<AGameMode>);
    protected _gameModeClass: RLClass<AGameMode>;
    get cameraSystemClass(): RLClass<ACameraSystem>;
    set cameraSystemClass(val: RLClass<ACameraSystem>);
    protected _cameraSystemClass: RLClass<ACameraSystem>;
    get gui(): RLGui;
    get gameMode(): AGameMode;
    get cameraSystem(): ACameraSystem;
    protected _widgetScene: RLGui;
    constructor();
    initialize(): Promise<void>;
    onAwake(): Promise<void>;
    afterAwake(): Promise<void>;
    beginPlay(): Promise<void>;
    tick(deltaSecond: number): void;
    dispose(): void;
}

export interface IScene {
    physicsWorld: IPhysicsWorld;
    rawScene: Scene;
    gui: RLGui;
}
export namespace IScene {
    function is(obj: any): obj is IScene;
}

/**
    * 游戏场景
    *
    * @export
    * @abstract
    * @class RLScene
    * @extends {RLObject}
    * @implements {IInitializable}
    */
export abstract class RLScene extends RLObject implements IInitializable, IScene, ILifecycle {
        readonly type: string;
        get isShareData(): boolean;
        get lifeState(): ELifecycle;
        protected _lifeState: ELifecycle;
        get suffix(): ESuffix;
        get rawScene(): Scene;
        get physicsWorld(): IPhysicsWorld;
        get gameInputEvent(): TGameInputSystem;
        protected readonly _gameInputEvent: TGameInputSystem;
        protected _owner: this;
        protected _rawScene: Scene;
        protected _actors: Map<string, IActor>;
        protected _prefabs: Map<string, RLPrefab>;
        protected readonly _physicsWorld: IPhysicsWorld;
        onAddObject: Observable<Array<RLTransformable>>;
        onRemoveObject: Observable<Array<RLTransformable>>;
        onBeforeDispose: Observable<this>;
        protected readonly loader: FLoader;
        constructor();
        abstract get gui(): any;
        initialize(): Promise<void>;
        get tickable(): boolean;
        set tickable(value: boolean);
        abstract onAwake(): Promise<void>;
        abstract afterAwake(): Promise<void>;
        abstract beginPlay(): Promise<void>;
        tick(deltaSecond: number): void;
        getActorById(uid: string): IActor | undefined;
        endPlay(reason: EDisposeReason): void;
        getRootAttachable(): RLAttachable[];
        dispose(): void;
        /**
            * 生成新 Actor
            *
            * @template T Actor 子类类型
            * @param {T} c Actor 子类构造器
            * @param {...ConstructorParameters<T>} args 构造参数
            * @returns {Promise<InstanceType<T>>}
            * @memberof RLScene
            */
        spawnActor<T extends IInitializer<IActor>>(c: T, ...args: ConstructorParameters<T>): Promise<InstanceType<T>>;
        loadActor<T extends IActor>(c: string): Promise<T | undefined>;
        /**
            * 生成 Prefab
            *
            * @param {...IActor[]} actors Prefab 中的 Actor
            * @returns {Promise<RLPrefab>} Prefab
            * @memberof RLScene
            */
        spawnPrefab(...actors: IActor[]): Promise<RLPrefab>;
        /**
            * 查找场景中符合特定类型所有 Actor
            *
            * @template T Actor 子类类型
            * @param {IInitializer<T>} c Actor 子类构造器
            * @param {Array<InstanceType<IInitializer<T>>>} actors 结果
            * @memberof RLScene
            */
        findActorsByClass<T extends IActor>(c: IInitializer<T>, actors: Array<InstanceType<IInitializer<T>>>): void;
        /**
            * 向场景中添加 Actor
            *
            * @param {IActor} actor
            * @returns {Promise<void>}
            * @memberof RLScene
            */
        addActor(actor: IActor): Promise<void>;
        protected _addActor(actor: IActor): void;
        /**
            * 向场中添加 Prefab
            *
            * @param {RLPrefab} prefab
            * @returns {Promise<void>}
            * @memberof RLScene
            */
        addPrefab(prefab: RLPrefab): void;
        protected _removeActor(actor?: IActor): void;
        protected _removePrefab(prefab?: RLPrefab, bKeepActor?: boolean): void;
        serialize(option?: ISerializeScope, _filter?: FSerializeFilter): Promise<FObjectData | undefined>;
        copy(src: this, scope?: IDeserializeScope, _filter?: FSerializeFilter): Promise<void>;
        protected startCopy(src: this, scope: IDeserializeScope, _filter: FSerializeFilter): Promise<void>;
        protected startSerialize(scope: ISerializeScope, _filter?: FSerializeFilter): Promise<FObjectData | undefined>;
        protected startDeserialize(serialized: FObjectData, scope: IDeserializeScope): Promise<boolean>;
        getSerializeKeys(opt: EStructOperator): Map<string, boolean>;
}

/**
  * Actor
  *
  * @export
  * @class AActor
  * @extends {RLAttachable}
  */
export class AActor extends IActor {
    protected get scene(): RLGameScene;
}

export enum EAttachRule {
    KeepWorld = 0,
    KeepRelative = 1
}
export interface IAttachObserveData {
    oldParent?: RLAttachable;
    newParent?: RLAttachable;
}
export class RLAttachable extends RLTransformable {
    onAttachChange: Observable<IAttachObserveData>;
    getScene(): any;
    get rootParent(): RLAttachable | undefined;
    get children(): Map<string, RLAttachable>;
    parent?: RLAttachable;
    attachTo(actor: RLAttachable, rule?: EAttachRule): void;
    detach(): void;
    remove(value: string | RLAttachable): void;
    removeAll(): void;
    dispose(): void;
    protected afterDeserialize(): Promise<void>;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
}

/**
    * 组件
    *
    * @export
    * @abstract
    * @class CComponent
    * @extends {IComponent}
    */
export abstract class CComponent extends IComponent {
        static __injectActor: AActor | undefined;
        /**
            * 组件所属 Actor
            *
            * @readonly
            * @type {AActor}
            * @memberof CComponent
            */
        get owner(): AActor;
        protected get scene(): RLGameScene | undefined;
        onAwake(): Promise<void>;
        dispose(): void;
}
export interface IGroupComponent {
        group: string;
        comps: IExposeComponentData[];
}
export interface IExposeComponentData extends IExposeClass {
        ctor: IConstructor<CComponent>;
        name: string;
}
export const getEditableComponent: () => IGroupComponent[];

export const actorSerializeFilter: FSerializeFilter;
export interface IActorObserveData {
        actor: IActor;
        component: IComponent;
}
/**
    * Actor
    *
    * @export
    * @class AActor
    * @extends {RLAttachable}
    */
export class IActor extends RLAttachable implements IInputEventReceiver {
        receiveInput: boolean;
        onMouseDown?(event: IKeyEvent): void;
        onMouseUp?(event: IKeyEvent): void;
        onMouseEnter?(position: FVector2): void;
        onMouseOverlapping?(position: FVector2): void;
        onMouseLeave?(position: FVector2): void;
        onMouseDoubleClick?(event: IKeyEvent): void;
        onMouseMove?(position: FVector2, movement: FVector2): void;
        onMouseMouseWheel?(event: WheelEvent): void;
        onKeyDown?(event: IKeyEvent): void;
        onKeyPressing?(keys: Readonly<Set<EKeycode>>, deltaSecond: number, mousePosition?: FVector2): void;
        onKeyUp?(event: IKeyEvent): void;
        protected registerInput(): void;
        protected unregisterInput(): void;
        protected key(...keys: EKeycode[]): boolean;
        readonly type: string;
        get suffix(): ESuffix;
        get isClass(): boolean;
        /**
            * 获取 Actor 的所有组件
            *
            * @readonly
            * @type {IComponent[]} 组件集合
            * @memberof AActor
            */
        get components(): IComponent[];
        /**
            * Actor 添加组件成功回调
            *
            * @type {Observable<IActorObserveData>}
            * @memberof AActor
            */
        onAddComponent: Observable<IActorObserveData>;
        /**
            * Actor 移除组件成功回调
            *
            * @type {Observable<IActorObserveData>}
            * @memberof AActor
            */
        onRemoveComponent: Observable<IActorObserveData>;
        protected _components: Map<string, IComponent>;
        onAwake(): Promise<void>;
        beginPlay(): Promise<void>;
        endPlay(reason: EDisposeReason): void;
        /**
            * 创建新组件
            *
            * @template T 组件类型
            * @param {T} c 组件构造器
            * @param {...ConstructorParameters<T>} args 构造参数
            * @returns {Promise<InstanceType<T>>} 新组件
            * @memberof AActor
            */
        createComponent<T extends IInitializer<IComponent>>(c: T, ...args: ConstructorParameters<T>): Promise<InstanceType<T>>;
        /**
            * 移除组件
            *
            * @param {string} arg
            * @memberof AActor
            */
        destroyComponent(arg: string): void;
        /**
            * 获取 Actor 中第一个指定类型的组件
            *
            * @template T 组件类型
            * @param {T} arg 组件构造器
            * @returns {(InstanceType<T> | undefined)} 组件
            * @memberof AActor
            */
        getComponentByType<T extends IComponent>(arg: IAbstractor<T>): T | undefined;
        /**
            * 获取 Actor 中所有指定类型的组件
            *
            * @template T 组件类型
            * @param {IConstructor<T>} arg 组件构造器
            * @returns {T[]} 组件集合
            * @memberof AActor
            */
        getComponentsByType<T extends IComponent>(arg: IAbstractor<T>): T[];
        /**
            * 获取组件
            *
            * @template T 组件类型
            * @param {string} arg 组件 uid
            * @returns {(T | undefined)} 组件
            * @memberof AActor
            */
        getComponent<T extends IComponent>(arg: string): T | undefined;
        getBound(includeMesh?: boolean): [Readonly<FBoxShape>, IBound[]];
        getCollisionObject(): Array<ICollisionObject>;
        getSkeleton(): Readonly<Array<Bone>> | undefined;
        tick(deltaSecond: number): void;
        serialize(option?: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
        copy(src: this, scope?: IDeserializeScope, filter?: FSerializeFilter): Promise<void>;
        clone(): Promise<this>;
        protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
        protected startSerialize(scope: ISerializeScope, _filter?: FSerializeFilter): Promise<FObjectData | undefined>;
        protected startDeserialize(serialized: FObjectData, scope: IDeserializeScope): Promise<boolean>;
        dispose(): void;
        getSerializeKeys(opt: EStructOperator): Map<string, boolean>;
}

export abstract class IComponent extends RLTransformable {
    readonly type: string;
    constructor(name?: string);
    get isClass(): boolean;
    abstract get owner(): object;
}

/**
  * Prefab
  *
  * @export
  * @abstract
  * @class IComponent
  * @extends {RLTransformable}
  */
export class RLPrefab extends RLAttachable {
    readonly type: string;
}

export class RLTransformable extends RLObject implements IInitializable, ILifecycle {
    readonly type: string;
    get lifeState(): ELifecycle;
    protected _owner: any;
    initialize(): Promise<void>;
    onDispose: Observable<void>;
    get transform(): FTransform;
    set transform(trans: FTransform);
    get rawObject(): Object3D;
    set rawObject(val: Object3D);
    get position(): FVector3;
    set position(position: FVector3);
    get rotation(): FEuler;
    set rotation(rotation: FEuler);
    get quaternion(): FQuaternion;
    set quaternion(quaternion: FQuaternion);
    get scale(): FVector3;
    set scale(scale: FVector3);
    get visible(): boolean;
    set visible(bVisible: boolean);
    get matrixWorld(): FMatrix4;
    set matrixWorld(matrixWorld: FMatrix4);
    get matrix(): FMatrix4;
    set matrix(matrix: FMatrix4);
    constructor(name?: string);
    lookAt(position: FVector3): void;
    protected startSerialize(objectDatas: ISerializeScope, filter?: FSerializeFilter): Promise<FObjectData | undefined>;
    protected startDeserialize(data: FObjectData, scope: IDeserializeScope): Promise<boolean>;
    protected startCopy(src: this, scope: IDeserializeScope, filter: FSerializeFilter): Promise<void>;
    onAwake(): Promise<void>;
    afterAwake(): Promise<void>;
    beginPlay(): Promise<void>;
    tick(deltaSecond: number): void;
    dispose(): void;
    getSerializeKeys(opt: EStructOperator): Map<string, boolean>;
    endPlay(reason: EDisposeReason): void;
    get tickable(): boolean;
    set tickable(value: boolean);
}

export type updateFunc = (deltaSecond: number) => void;
export class FSceneRenderer {
    protected _renderScene(renderer: WebGLRenderer, scene: Scene | undefined, camera: Camera): void;
    protected _doRender(world: TWorld, viewport: IViewport, updateCameraFunc?: (camera: Camera) => void, updateGui?: (gui: RLGui) => void): [Scene, Camera];
    protected _viewportCache: Map<string, FVector2>;
    render(world: TWorld): void;
}
export class TWorld implements IWorld, IDisposable {
    onGameStateChanged: Observable<EGameState>;
    get viewport(): Readonly<Map<string, IViewport>>;
    addViewport(viewport: IViewport): void;
    removeViewport(name: string): IViewport | undefined;
    get audioListener(): AudioListener;
    get isPlaying(): boolean;
    pause(): void;
    resume(): void;
    get renderer(): WebGLRenderer;
    get gui(): RLGui;
    get activeScene(): RLGameScene;
    onBeforeToScene: Observable<{
        oldScene: RLGameScene;
        scene: RLGameScene;
    }>;
    onToScene: Observable<{
        oldScene: RLGameScene;
        scene: RLGameScene;
    }>;
    afterRender: Observable<[Scene, Camera]>;
    protected _bTickScene: boolean;
    constructor(_renderer: WebGLRenderer, _audioListener: AudioListener, _raycaster: Raycaster, _loader: FLoader, _mainViewport: IViewport);
    renderLineTrace(start: FVector3, direction: FVector3, ignore?: RLTransformable[], far?: number): IHitResult | undefined;
    _renderLineTrace(scene: RLGameScene, start: FVector3, direction: FVector3, ignore?: RLTransformable[], far?: number): IHitResult | undefined;
    multiRenderLineTrace(start: FVector3, direction: FVector3, ignore?: RLTransformable[], far?: number): IHitResult[];
    protected _multiRenderLineTrace(scene: RLGameScene, start: FVector3, direction: FVector3, ignore?: RLTransformable[], far?: number): IHitResult[];
    mouseRenderLineTrace(camera: Camera, mousePosition: FVector2, ignore?: RLTransformable[], far?: number): IHitResult | undefined;
    protected _mouseRenderLineTrace(scene: RLGameScene, camera: Camera, mousePosition: FVector2, ignore?: RLTransformable[], far?: number): IHitResult | undefined;
    multiMouseRenderLineTrace(camera: Camera, mousePosition: FVector2, ignore?: RLTransformable[], far?: number, result?: IHitResult[]): IHitResult[];
    protected _multiMouseRenderLineTrace(scene: RLGameScene, camera: Camera, mousePosition: FVector2, ignore?: RLTransformable[], far?: number, result?: IHitResult[]): IHitResult[];
    protected _intersect(raycaster: Raycaster, scene: RLGameScene, ignore?: RLTransformable[], far?: number): Intersection[];
    getMousePosition(event: MouseEvent): FVector2;
    physicsLineTrace(from: FVector3 | FVector4, to: FVector3 | FVector4, collisionType: ECollisionType, collisionChannel: Array<ECollisionType>, ignores?: Set<ICollisionObject>, scene?: RLGameScene): ISinglePhysicsRayResult;
    multiPhysicsLineTrace(from: FVector3 | FVector4, to: FVector3 | FVector4, collisionType: ECollisionType, collisionChannel: Array<ECollisionType>, ignores?: Set<ICollisionObject>, scene?: RLGameScene): IMultiPhysicsRayResult;
    physicsSweep(castShape: FShape, from: FTransform, to: FTransform, collisionType: ECollisionType, collisionChannel: Array<ECollisionType>, ignores?: Set<ICollisionObject>, allowedCcdPenetration?: number, scene?: RLGameScene): IPhysicsSweepResult;
    createScene<T extends IInitializer<RLGameScene>>(c: T, ...args: ConstructorParameters<T>): Promise<InstanceType<T>>;
    spawnActor<T extends IInitializer<AActor>>(c: T, ...args: ConstructorParameters<T>): Promise<InstanceType<T>>;
    findActorsByClass<T extends AActor>(c: IInitializer<T>, actors: Array<InstanceType<IInitializer<T>>>): void;
    switch(scene: RLGameScene | string, disposeOld?: boolean): Promise<RLGameScene | undefined>;
    toScene(scene: RLGameScene, bBeginPlay?: boolean, disposeOld?: boolean): Promise<void>;
    startRender(): void;
    runRenderLoop(renderFunction: updateFunc): void;
    protected _initWorld(): Promise<void>;
    protected beginFrame(): void;
    protected endFrame(): void;
    protected tick(deltaSecond: number): void;
    dispose(): void;
}

export const engineModule: ContainerModule;
export const setGameConfig: (gameConfig: IGameConfig) => void;
export const engineModuleLoader: () => Container;

export class TGameInputSystem extends TInputEvent implements IDisposable {
    protected readonly _viewport: IViewport;
    protected readonly _world: IWorld;
    constructor(_viewport: IViewport, _world: IWorld);
    Key(...keys: EKeycode[]): boolean;
    register(receiver: IInputEventReceiver): void;
    unregister(receiver: IInputEventReceiver): void;
    clear(): void;
    protected _onMouseDown(event: MouseEvent): void;
    protected _onMouseUp(event: MouseEvent): void;
    protected _onMouseDoubleClick(event: MouseEvent): void;
    protected _onMouseMove(event: MouseEvent): Promise<void>;
    protected _onMouseEnter(event: MouseEvent): void;
    protected _onMouseLeave(event: MouseEvent): void;
    protected _onMouseMouseWheel(event: WheelEvent): void;
    protected _onKeyDown(event: KeyboardEvent): void;
    protected _onKeyPress(event: KeyboardEvent): void;
    protected _onKeyUp(event: KeyboardEvent): void;
    tick(deltaSecond: number): void;
    dispose(): void;
}

export function bindRawInput<K extends keyof HTMLElementEventMap>(obj: GlobalEventHandlers, type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): IDisposable;

export interface IKeyEvent {
    code: EKeycode;
    keys: Readonly<Set<EKeycode>>;
    mousePosition?: FVector2;
}
export interface IInputEventReceiver {
    receiveInput: boolean;
    onMouseDown?(event: IKeyEvent): void;
    onMouseUp?(event: IKeyEvent): void;
    onMouseEnter?(position: FVector2): void;
    onMouseOverlapping?(position: FVector2): void;
    onMouseLeave?(position: FVector2): void;
    onMouseDoubleClick?(event: IKeyEvent): void;
    onMouseMove?(position: FVector2, movement: FVector2): void;
    onMouseMouseWheel?(event: WheelEvent): void;
    onKeyDown?(event: IKeyEvent): void;
    onKeyPressing?(keys: Readonly<Set<EKeycode>>, deltaSecond: number, mousePosition?: FVector2): void;
    onKeyUp?(event: IKeyEvent): void;
}
export const InputEvent: unique symbol;
/**
  * 输入事件
  *
  * @export
  * @abstract
  * @class TInputEvent
  * @extends {TEvent<HTMLCanvasElement>}
  */
export abstract class TInputEvent extends TEvent<HTMLCanvasElement> {
    protected _captureKeyboard: boolean;
    protected _disposables: FDisposableCollection;
    protected _bindRawInput<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions, obj?: GlobalEventHandlers): IDisposable;
    protected _bind(): void;
    protected _unbind(): void;
    protected abstract _onMouseDown(event: MouseEvent): void;
    protected abstract _onMouseUp(event: MouseEvent): void;
    protected abstract _onMouseDoubleClick(event: MouseEvent): void;
    protected abstract _onMouseMove(event: MouseEvent): void;
    protected abstract _onMouseEnter(event: MouseEvent): void;
    protected abstract _onMouseLeave(event: MouseEvent): void;
    protected abstract _onMouseMouseWheel(event: WheelEvent): void;
    protected abstract _onKeyDown(event: KeyboardEvent): void;
    protected abstract _onKeyPress(event: KeyboardEvent): void;
    protected abstract _onKeyUp(event: KeyboardEvent): void;
}

export const inputModule: ContainerModule;

export const onKeycode: (e: KeyboardEvent, ...matches: Array<[EKeycode, () => void]>) => void;
export const getKeycode: (e: KeyboardEvent) => EKeycode;
export enum EKeycode {
    CANCEL = 3,
    HELP = 6,
    BACK_SPACE = 8,
    TAB = 9,
    CLEAR = 12,
    RETURN = 13,
    ENTER = 14,
    SHIFT = 16,
    CONTROL = 17,
    ALT = 18,
    PAUSE = 19,
    CAPS_LOCK = 20,
    ESCAPE = 27,
    SPACE = 32,
    PAGE_UP = 33,
    PAGE_DOWN = 34,
    END = 35,
    HOME = 36,
    LEFT = 37,
    UP = 38,
    RIGHT = 39,
    DOWN = 40,
    PRINTSCREEN = 44,
    INSERT = 45,
    DELETE = 46,
    NUM_0 = 48,
    NUM_1 = 49,
    NUM_2 = 50,
    NUM_3 = 51,
    NUM_4 = 52,
    NUM_5 = 53,
    NUM_6 = 54,
    NUM_7 = 55,
    NUM_8 = 56,
    NUM_9 = 57,
    SEMICOLON = 59,
    EQUALS = 61,
    A = 65,
    B = 66,
    C = 67,
    D = 68,
    E = 69,
    F = 70,
    G = 71,
    H = 72,
    I = 73,
    J = 74,
    K = 75,
    L = 76,
    M = 77,
    N = 78,
    O = 79,
    P = 80,
    Q = 81,
    R = 82,
    S = 83,
    T = 84,
    U = 85,
    V = 86,
    W = 87,
    X = 88,
    Y = 89,
    Z = 90,
    LEFT_CMD = 91,
    RIGHT_CMD = 93,
    CONTEXT_MENU = 93,
    NUMPAD0 = 96,
    NUMPAD1 = 97,
    NUMPAD2 = 98,
    NUMPAD3 = 99,
    NUMPAD4 = 100,
    NUMPAD5 = 101,
    NUMPAD6 = 102,
    NUMPAD7 = 103,
    NUMPAD8 = 104,
    NUMPAD9 = 105,
    MULTIPLY = 106,
    ADD = 107,
    SEPARATOR = 108,
    SUBTRACT = 109,
    DECIMAL = 110,
    DIVIDE = 111,
    F1 = 112,
    F2 = 113,
    F3 = 114,
    F4 = 115,
    F5 = 116,
    F6 = 117,
    F7 = 118,
    F8 = 119,
    F9 = 120,
    F10 = 121,
    F11 = 122,
    F12 = 123,
    F13 = 124,
    F14 = 125,
    F15 = 126,
    F16 = 127,
    F17 = 128,
    F18 = 129,
    F19 = 130,
    F20 = 131,
    F21 = 132,
    F22 = 133,
    F23 = 134,
    F24 = 135,
    NUM_LOCK = 144,
    SCROLL_LOCK = 145,
    COMMA = 188,
    PERIOD = 190,
    SLASH = 191,
    BACK_QUOTE = 192,
    OPEN_BRACKET = 219,
    BACK_SLASH = 220,
    CLOSE_BRACKET = 221,
    QUOTE = 222,
    META = 224,
    MOUSE_LEFT = 500,
    MOUSE_MIDDLE = 501,
    MOUSE_RIGHT = 502
}

export const replaceGameModulesId: (content: string) => string;
export const replaceModuleId: (origin: string) => string;
export interface IClassInfo {
    classPath: string;
    className: string;
}
export class FClasses {
    protected readonly pathResolver: FPathResolver;
    protected getModuleId<T extends object>(obj?: T): Set<string> | undefined;
    protected getModuleId<T extends object>(ctor?: IConstructor<T>): Set<string> | undefined;
    getClassPath<T extends object>(obj?: T): string | undefined;
    getClassPath<T extends object>(ctor?: IConstructor<T>): string | undefined;
    getClassInfo<T extends object>(obj?: T): IClassInfo | undefined;
    getClassInfo<T extends object>(ctor?: IConstructor<T>): IClassInfo | undefined;
    getModule(moduleId?: string): any | undefined;
    getClass<T extends object = object>(classPath?: string): IConstructor<T> | undefined;
    getClass<T extends object = object>(moduleId?: string, className?: string): IConstructor<T> | undefined;
    getClassByPath<T extends object = object>(classPath?: string): IConstructor<T> | undefined;
    getClassByPath<T extends object = object>(moduleId?: string, className?: string): IConstructor<T> | undefined;
    getFromModule<T extends object = object>(moduleId: string, ctor: IAbstractor<T>): Set<IConstructor<T>> | undefined;
    getRLObjectClasses(forceUpdate?: boolean): Set<IConstructor<RLObject>>;
    getClasses<T extends RLObject>(ctor: IAbstractor<T>): Set<IConstructor<T>>;
    getActorClasses(): Set<IConstructor<AActor>>;
    getComponentClasses(): Set<IConstructor<CComponent>>;
}

export const IClassLoader: unique symbol;
export interface IClassLoader {
    getConstructor(name: string): IConstructor<object> | undefined;
}

export class FConfigResolver {
    protected packagePath: string;
    protected configPath: string;
    protected readonly projectConfig: IGameConfig;
    loadConfig(config: any, pkg: any): void;
}

export interface IEntry {
    isFile: boolean;
    isDirectory: boolean;
    name: string;
    fullPath: string;
    filesystem: any;
}
export interface IFileEntry extends IEntry {
}
export interface IDirectoryEntry extends IEntry {
}
export type FVisitor = (fileOrDirectory: IEntry) => Promise<boolean>;
export const IFileSystem: unique symbol;
export interface IFileSystem {
    mount: () => Promise<any>;
    iterateDirectory(path: string | IDirectoryEntry, visitor: FVisitor, isRecursion?: boolean): Promise<boolean>;
    isDirectory(path: string | IEntry): Promise<boolean>;
    isDirectoryExisted(path: string): Promise<boolean>;
    getDirectory(path: string | IEntry): Promise<IDirectoryEntry | undefined>;
    createDirectory(path: string): Promise<IDirectoryEntry>;
    isFileExisted(fileName: string): Promise<boolean>;
    getFile(fileName: string | IEntry): Promise<IFileEntry | undefined>;
    createFile(fileName: string): Promise<IFileEntry>;
    deleteFile(fileName: string | IFileEntry): Promise<boolean>;
    deleteDirectory(path: string | IDirectoryEntry): Promise<boolean>;
    close(entry: IEntry): Promise<boolean>;
    copy(srcFileOrDirectory: string | IEntry, dest: string | IEntry, newName?: string): Promise<IEntry | undefined>;
    rename(fileOrDirectory: string | IEntry, newName: string): Promise<IEntry | undefined>;
    move(srcFileOrDirectory: string | IEntry, dest: string | IEntry, newName?: string): Promise<IEntry>;
    getFileOrDirectory(path: string): Promise<IEntry | undefined>;
    readString(path: string | IFileEntry, start?: number, end?: number): Promise<string | undefined>;
    readBin(path: string | IFileEntry, start?: number, end?: number): Promise<ArrayBuffer | undefined>;
    writeFile(content: string | Blob, path: string | IFileEntry): Promise<IFileEntry>;
    isSame(file1: IEntry, file2: IEntry): boolean;
}

export const loaderModule: ContainerModule;

export interface ILoadOption {
    rawData?: ArrayBuffer | string;
    isDefault?: boolean;
    scope?: IDeserializeScope;
}
export class FLoader {
    protected readonly rawDataLoader: IRawDataLoader;
    protected readonly serializeProcessor: ISerializeProcessor;
    protected readonly classLoader: FClasses;
    protected readonly pathResolver: FPathResolver;
    get loadedObjects(): Readonly<Map<string, RLObject>>;
    loadObject<T extends RLObject = RLObject>(gamePath?: string, option?: ILoadOption): Promise<T | undefined>;
    loadResourceDefaultObjectTo<T extends RLObject = RLObject>(object?: T, gamePath?: string): Promise<boolean>;
    getDefaultObject(gamePath?: string): RLObject | undefined;
    protected _load<T extends RLObject>(data: ArrayBuffer | string, gamePath: string, scope?: IDeserializeScope): Promise<T | undefined>;
    protected _loadTo<T extends RLObject>(object: T, data: ArrayBuffer | string, scope?: IDeserializeScope): Promise<T | undefined>;
    addDefault(defaultObj: RLObject, gamePath: string): void;
    removeDefault(gamePath: string): void;
    clear(): void;
}

export class FPackageFile {
    protected readonly _pathResolver: FPathResolver;
    constructor(ab: ArrayBuffer, mountPoint?: string);
    mount(): Promise<boolean>;
    read(relPath: string): Promise<ArrayBuffer | undefined>;
    protected _resolve(absPath: string): string;
}

export const IRawDataLoader: unique symbol;
export interface IRawDataLoader {
    init(): Promise<void>;
    getObjectUrl(path?: string): Promise<string | undefined>;
    getObjectData(path?: string): Promise<ArrayBuffer | string | undefined>;
    createObjectData(path?: string, resourceData?: IObjectData): Promise<boolean>;
    saveObjectData(path?: string, resourceData?: IObjectData): Promise<boolean>;
}

export const ISerializeProcessor: unique symbol;
export interface ISerializeProcessor {
    type: EObjectType;
    serialize(obj?: ISerializable | RLObject, classPath?: boolean): Promise<IObjectData | undefined>;
    deserialize(resourceData?: IObjectData, scope?: IDeserializeScope, gamePath?: string): Promise<ISerializable | RLObject | undefined>;
    createObject(classPath?: string, scope?: IDeserializeScope, gamePath?: string): Promise<ISerializable | RLObject | undefined>;
    deserializeTo(object?: ISerializable | RLObject, resourceData?: IObjectData, scope?: IDeserializeScope): Promise<boolean>;
}

export class FObjectProcessor implements ISerializeProcessor {
    protected readonly classLoader: FClasses;
    protected readonly pathResolver: FPathResolver;
    protected readonly _writer: FLazyWriter;
    protected readonly _reader: FReader;
    get type(): EObjectType;
    serialize(object?: ISerializable | RLObject, bClassPath?: boolean): Promise<IObjectData | undefined>;
    deserialize(resourceData?: IObjectData, scope?: IDeserializeScope, gamePath?: string): Promise<ISerializable | RLObject | undefined>;
    createObject(classPath?: string, scope?: IDeserializeScope, gamePath?: string): Promise<ISerializable | RLObject | undefined>;
    deserializeTo(object?: ISerializable | RLObject, resourceData?: IObjectData, scope?: IDeserializeScope): Promise<boolean>;
}

export type TSerializeFunc = (v: any) => Promise<FSerializeType>;
export type TDeserializeFunc = (v: any) => Promise<any>;
export type TCopyFunc = (origin: any, value: any) => Promise<any>;
export type TCompareFunc = (origin: any, value: any) => Promise<[ESerializeKey, any] | undefined>;
export type TApplyFunc = (origin: any, value: any) => Promise<[any, [ESerializeKey, any]] | undefined>;
export interface IContainerSerializer {
}
export namespace IContainerSerializer {
    function isKey(k: ESerializeKey): boolean;
}
export namespace IArraySerializer {
    function serialize(m: Array<any>, serializer: TSerializeFunc): Promise<FSerializeType>;
    function deserialize(data: any, serializer: TDeserializeFunc): Promise<Array<any>>;
    function copy(origin: any, value: Array<any>, serializer: TCopyFunc): Promise<Array<any>>;
    function compare(value: any, value2: Array<any>, serializer: TCompareFunc): Promise<[ESerializeKey, any]>;
    function apply(origin: any, data: any, serializer: TApplyFunc): Promise<[any, [ESerializeKey, any]]>;
}
export namespace ISetSerializer {
    function serialize(m: Set<any>, serializer: TSerializeFunc): Promise<FSerializeType>;
    function deserialize(data: any, serializer: TDeserializeFunc): Promise<Set<any>>;
    function copy(origin: any, value: Set<any>, serializer: TCopyFunc): Promise<Set<any>>;
    function compare(value: any, value2: Set<any>, serializer: TCompareFunc): Promise<[ESerializeKey, any]>;
    function apply(origin: any, data: any, serializer: TApplyFunc): Promise<[any, [ESerializeKey, any]] | undefined>;
}
export namespace IMapSerializer {
    function serialize(m: Map<any, any>, serializer: TSerializeFunc): Promise<FSerializeType>;
    function deserialize(data: any, serializer: TDeserializeFunc): Promise<Map<any, any>>;
    function copy(origin: any, value: Map<any, any>, serializer: TCopyFunc): Promise<Map<any, any>>;
    function compare(value: any, value2: Map<any, any>, serializer: TCompareFunc): Promise<[ESerializeKey, any]>;
    function apply(origin: any, data: any, serializer: TApplyFunc): Promise<[any, [ESerializeKey, any]] | undefined>;
}

export type FSerializeType = [ESerializeKey, any];
export interface IMathSerializer {
    toArray(): number[];
    fromArray(array: number[]): this;
    equals(v: this): boolean;
    clone(): this;
    copy(m: this): this;
}
export namespace IMathSerializer {
    function isKey(k: ESerializeKey): boolean;
    function is(obj: any): obj is IMathSerializer;
    function get(k: ESerializeKey): IConstructor<IMathSerializer> | undefined;
    function serialize(m: IMathSerializer): FSerializeType;
    function deserialize(ser: FSerializeType): IMathSerializer | undefined;
    function clone(m: IMathSerializer): IMathSerializer;
    function copy(origin: any, m: IMathSerializer): IMathSerializer;
    function compare(m0: any, m1: IMathSerializer): FSerializeType | undefined;
    function apply(origin: IMathSerializer, ser: FSerializeType): [any, FSerializeType] | undefined;
}

export const defaultFilter: FSerializeFilter;
export class FObjectSerializer implements IObjectSerializer {
    protected readonly loader: FLoader;
    protected readonly classLoader: FClasses;
    protected readonly pathResolver: FPathResolver;
    protected readonly _writer: FLazyWriter;
    protected readonly _writer2: FLazyWriter;
    protected getResources(value: FStruct, scope: ISerializeScope, filter?: FSerializeFilter): Promise<void>;
    protected getOrCreateUid(object: object): string;
    serialize(value: any, scope: ISerializeScope, filter?: FSerializeFilter): Promise<any>;
    deserialize(value: FSerializeType, scope: IDeserializeScope): Promise<any>;
    copy(origin: any, value: any, scope: IDeserializeScope, filter?: FSerializeFilter): Promise<any>;
    compare(value: any, value2: any, scope: IDeserializeScope, filter?: FSerializeFilter): Promise<[ESerializeKey, any] | undefined>;
    applyChange(origin: any, value: FSerializeType, scope: IDeserializeScope): Promise<[any, [ESerializeKey, any]] | undefined>;
}

export const createSerializableSync: () => TByte;
export const createSerializable: (serializable?: RLObject | ISerializable | undefined) => Promise<TByte>;
export const resolveSerializable: (serializable: TByte) => Promise<RLObject | ISerializable | undefined>;

export interface IModule {
    load?(): Promise<void>;
    onAllLoaded?(): Promise<void>;
    unLoad?(): Promise<void>;
}

export const moduleModule: ContainerModule;

export class FModuleResolver {
    protected readonly gameConfig: IGameConfig;
    protected readonly classLoader: FClasses;
    loadModules(): Promise<void>;
    unloadModules(): Promise<void>;
    unloadModule(...moduleNames: string[]): Promise<void>;
    reloadModules(): Promise<void>;
}

export const Provider: unique symbol;
export interface Provider<T extends object> {
    /**
      * @param recursive `true` if the contributions should be collected from the parent containers as well. Otherwise,
      * `false`. It is `false` by default.
      */
    getProviders(recursive?: boolean): T[];
}
export type Bindable = interfaces.Bind | interfaces.Container;
export namespace Bindable {
    function isContainer(arg: Bindable): arg is interfaces.Container;
}
export function bindProvider(bindable: Bindable, id: symbol): void;

export class FAssetSystem extends FSystem {
    protected readonly filesystem: IFileSystem;
    dispose(): void;
    protected readonly objectProcessor: ISerializeProcessor;
    get assets(): object[];
    get paths(): string[];
    getPath(obj: object): string | undefined;
    getAsset(path: string): object | undefined;
    constructor(filesystem: IFileSystem);
    saveObject(obj: RLObject, path: string): Promise<IEntry | undefined>;
    saveScene(path: string, scene: RLScene): Promise<IEntry | undefined>;
    loadScene(v: string | IFileEntry): Promise<RLScene | undefined>;
    addAsset(path: string, obj: any): void;
    removeAsset(value: string | any): void;
    init(): Promise<void>;
    tick(deltaSecond: number): void;
}

export class FSystemManager {
    protected readonly provider: Provider<ISystem>;
    constructor(provider: Provider<ISystem>);
    start(): Promise<void>;
    tick(deltaSecond: number): void;
    dispose(): void;
}

export const systemModule: ContainerModule;

export const ISystem: unique symbol;
export interface ISystem extends IDisposable {
    init(): Promise<void>;
    tick(deltaSecond: number): void;
}
export abstract class FSystem implements ISystem {
    abstract init(): Promise<void>;
    abstract tick(deltaSecond: number): void;
    abstract dispose(): void;
}

export abstract class WBasic extends IWidgetBody implements IStyle {
    calcContentSize(): {
        width: number;
        height: number;
    };
    overrideFill(fill: FVector2, fillWidth: number, fillHeight: number): {
        width: number;
        height: number;
    };
}

export class IButtonStyle extends IImageStyle {
    click?: Texture;
    hover?: Texture;
}
export class WButton extends WImage implements IContainer<TCanvasSlot>, IButtonStyle {
    get slot(): TCanvasSlot;
    onClick: Observable<void>;
    click: Texture;
    hover: Texture;
    constructor(style?: IButtonStyle);
    foreachSlot(func: (slot: TCanvasSlot) => void): void;
    removeSlot(id: number): void;
    mouseDown(): void;
    mouseUp(): void;
    mouseEnter(): void;
    mouseLeave(): void;
    calcContentSize(): {
        width: number;
        height: number;
    };
    tick(deltaSecond: number): void;
    protected _resize(): void;
}

export class IImageStyle extends IStyle {
    img?: Texture;
    keepRatio?: boolean;
}
export class WImage extends WBasic implements IImageStyle {
    tick(deltaSecond: number): void;
    get color(): string;
    set color(v: string);
    get img(): Texture | undefined;
    set img(value: Texture | undefined);
    get material(): SpriteMaterial;
    protected _material: SpriteMaterial;
    protected _size: FVector2;
    constructor(style?: IImageStyle);
    calcContentSize(): {
        width: number;
        height: number;
    };
    overrideFill(fill: FVector2, inWidth: number, inHeight: number): {
        width: number;
        height: number;
    };
    protected _resize(): void;
    updateColor(): void;
    protected getRotation(): number;
}

export class ITextStyle extends IStyle {
    fontFamily?: string;
    fontSize?: number;
    fontWeight?: number;
}
export class WText extends WBasic implements IStyle {
    get material(): SpriteMaterial;
    get text(): string;
    set text(v: string);
    color: string;
    fontFamily: string;
    fontSize: number;
    fontWeight: number;
    isSprite: boolean;
    protected _material: SpriteMaterial;
    constructor(text?: string, style?: ITextStyle);
    tick(deltaSecond: number): void;
    protected _resize(): void;
    updateText(): void;
}

export class WCanvas extends WContainer<TCanvasSlot> {
    get slots(): Map<number, TCanvasSlot>;
    get slot(): TCanvasSlot;
    foreachSlot(func: (slot: TCanvasSlot) => void): void;
    removeSlot(id: number): void;
    protected _resize(): void;
}

export class IContainerStyle extends IStyle {
    isDrawFrame?: boolean;
}
export abstract class WContainer<S extends TSlot> extends WBasic implements IContainer<S> {
    abstract get slot(): S;
    isDrawFrame: boolean;
    abstract removeSlot(id: number): void;
    abstract foreachSlot(func: (slot: S) => void): void;
    constructor(isDrawFrame?: boolean);
    tick(deltaSecond: number): void;
}

export enum ESquareOf {
    None = 0,
    Width = 1,
    Height = 2,
    Longest = 3,
    Shortest = 4
}
export interface IGridStyle extends IContainerStyle {
    size?: FVector2;
    squareOf?: ESquareOf;
}
export function coordToIndex(count: number, column: number, row: number): number;
export function indexToCoord(count: number, index: number): FVector2;
export function positionToCoord(gridSize: FVector2, origin: FVector3, position: FVector3): FVector2;
export function coordToPosition(gridSize: FVector2, origin: FVector2, column: number, row: number): FVector3;
export class WGrid extends WContainer<TGridSlot> {
    get gridSize(): FVector2;
    get origin(): FVector2;
    get leftCorner(): FVector2;
    get frame(): LineSegments;
    get slot(): TGridSlot;
    size: FVector2;
    squareOf: ESquareOf;
    constructor(style?: IGridStyle, isDrawFrame?: boolean);
    foreachSlot(func: (slot: TGridSlot) => void): void;
    removeSlot(id: number): void;
    slotAt(columnOrIndex: number, row?: number): TGridSlot;
    overrideFill(fill: FVector2, fillWidth: number, fillHeight: number): {
        width: number;
        height: number;
    };
    protected _resize(): void;
}

export class WHorizontal extends WLiner<THorizontalSlot> {
    get slot(): THorizontalSlot;
}

export enum EPathRotate {
    _0 = 0,
    _90 = 1,
    _180 = 2,
    _270 = 3,
    Length = 4
}
export class TPath {
    get path(): number[][];
    get pathRotate(): EPathRotate;
    set pathRotate(v: EPathRotate);
    get positions(): FVector2[];
    get row(): FVector2;
    get column(): FVector2;
    id: number;
    constructor(path: number[][], rotate?: EPathRotate);
    protected calcPosition(): void;
}
export interface IPathGridStyle extends IContainerStyle {
    path?: TPath;
    squareOf?: ESquareOf;
    pathRotate?: EPathRotate;
}
export class WPathGrid extends WContainer<TGridSlot> implements IPathGridStyle {
    get pathRotate(): EPathRotate;
    set pathRotate(v: EPathRotate);
    get origin(): FVector2;
    get slot(): TGridSlot;
    get rowCount(): number;
    get columnCount(): number;
    set path(v: TPath);
    set squareOf(v: ESquareOf);
    protected readonly _origin: FVector2;
    protected _path: TPath;
    protected readonly _gridSize: FVector2;
    constructor(style?: IPathGridStyle, isDrawFrame?: boolean);
    foreachSlot(func: (slot: TGridSlot) => void): void;
    removeSlot(id: number): void;
    slotAt(index: number): TGridSlot;
    overrideFill(fillIn: FVector2, fillWidth: number, fillHeight: number): {
        width: number;
        height: number;
    };
    protected _resize(): void;
}

export class TCanvasSlot extends TSlot {
    getAutoSize(): boolean;
    autoSize(value: boolean): this;
    getOffset(): IOffset;
    offset(x: number, y: number): this;
    getAlignment(): FVector2;
    alignment(x: number, y: number): this;
    getAnchors(): FVector2;
    anchors(x: number, y: number): this;
    adjust(x: number, y: number): this;
    calc(): ISlotState;
    protected _calc(origin: FVector3, containerWidth: number, elementWidth: number, containerHeight: number, elementHeight: number): ISlotState;
}

interface IGridCoord {
    x: number;
    y: number;
}
export class TGridSlot extends TSlot {
    set coord(value: IGridCoord);
    set origin(value: FVector2);
    constructor(container: IContainer<TGridSlot>, coord: IGridCoord, gridSize: FVector2, origin: FVector2);
    calc(): ISlotState;
}
export {};

export class THorizontalSlot extends TCanvasSlot {
    set containerSize(v: FVector2);
    set totalWeight(value: number);
    get origin(): FVector3;
    protected _totalWeight: number;
    protected _containerSize: FVector2;
    protected readonly _slotList: TLinkedList<THorizontalSlot>;
    constructor(container: IContainer<THorizontalSlot>, slotList: TLinkedList<THorizontalSlot>);
    getWeight(): number;
    weight(weight: number): this;
    calc(): ISlotState;
}
export abstract class WLiner<T extends THorizontalSlot> extends WContainer<T> {
    get frame(): LineSegments;
    abstract get slot(): T;
    protected _frame: LineSegments;
    protected readonly _linerSlots: TLinkedList<T>;
    foreachSlot(func: (slot: T) => void): void;
    removeSlot(id: number): void;
    protected _resize(): void;
}

export interface ISlotState {
    width: number;
    height: number;
    position: FVector3;
    pivot: FVector3;
}
export abstract class TSlot extends IWidgetElement implements IElement {
    get size(): Readonly<FVector2>;
    set size(val: Readonly<FVector2>);
    get inSize(): Readonly<FVector2>;
    get container(): IContainer<any>;
    get widget(): WBasic | undefined;
    protected _childModel?: IStyle;
    protected readonly _container: IContainer<any>;
    protected readonly _size: FVector2;
    protected readonly _inSize: FVector2;
    constructor(size: FVector2, container: IContainer<any>);
    getFill(): FVector2;
    fill(x: number, y: number): this;
    getMargin(): Margin;
    margin(left: number, bottom?: number, right?: number, top?: number): this;
    isMarginScale(): boolean;
    marginScale(v: boolean): this;
    create<T extends IConstructor<WBasic>>(c: T, ...constructorArgs: ConstructorParameters<T>): InstanceType<T>;
    __delete(): this;
    abstract calc(): ISlotState;
    tick(deltaSecond: number): void;
    protected _resize(): void;
}

export class TVerticalSlot extends THorizontalSlot {
    calc(): ISlotState;
}

export class WVertical extends WLiner<TVerticalSlot> {
    get slot(): TVerticalSlot;
}

export class RLGui extends RLObject implements IInitializable, ILifecycle, IWidgetSource {
    readonly type: string;
    get lifeState(): ELifecycle;
    protected _lifeState: ELifecycle;
    get elements(): Map<number, WView>;
    get input(): TWidgetInput;
    get camera(): OrthographicCamera;
    get canvas(): HTMLCanvasElement;
    get renderSize(): FVector2;
    get children(): Object3D[];
    get rawScene(): Scene;
    protected _rawScene: Scene;
    protected readonly _size: import("three").Vector2;
    protected readonly _canvas: HTMLCanvasElement;
    protected readonly _world: IWorld;
    constructor();
    get tickable(): boolean;
    onAwake(): Promise<void>;
    beginPlay(): Promise<void>;
    endPlay(reason: EDisposeReason): void;
    dispose(): void;
    addView(cxt: viewFunc): Promise<void>;
    refresh(width: number, height: number, recursive?: boolean): void;
    initialize(): Promise<void>;
    tick(deltaSecond: number): void;
}

export enum EInputEvent {
    onMouseDown = "onMouseDown",
    onMouseMove = "onMouseMove",
    onMouseUp = "onMouseUp",
    onMouseWheel = "onMouseWheel",
    onMouseEnter = "onMouseEnter",
    onMouseLeave = "onMouseLeave",
    onTouchStart = "onTouchStart",
    onTouchMove = "onTouchMove",
    onTouchEnd = "onTouchEnd",
    onTouchEnter = "onTouchEnter",
    onTouchLeave = "onTouchLeave",
    onTouchCancel = "onTouchCancel",
    onKeyDown = "onKeyDown",
    onKeyPress = "onKeyPress",
    onKeyUp = "onKeyUp",
    onPick = "onPick",
    unPick = "unPick",
    onMove = "onMove",
    onSlip = "onSlip",
    onSlipRight = "onSlipRight",
    onSlipRightDown = "onSlipRightDown",
    onSlipUp = "onSlipUp",
    onSlipRightUp = "onSlipRightUp"
}
export enum ESlip {
    Left = 0,
    LeftUp = 1,
    Up = 2,
    RightUp = 3,
    Right = 4,
    RightDown = 5,
    Down = 6,
    LeftDown = 7
}
export interface IWidgetSource {
    canvas: HTMLCanvasElement;
    renderSize: FVector2;
    camera: Camera;
    children: Object3D[];
}
export interface ISlipEvent {
    points: FVector2[];
    time: number;
    intersection?: Intersection[];
}
export class TBasicInput extends EventDispatcher {
    protected get raycaster(): Raycaster;
    static useMouseForTouch: boolean;
    slipLength: number;
    slippingMaxTime: number;
    endSlipMaxTime: number;
    protected onSlipEvent(id: number, data: ISlipEvent, direction: ESlip): {
        id: number;
        direction: ESlip;
    };
    protected onSlipLeftEvent(id: number, data: ISlipEvent): {
        id: number;
        axis: number;
    };
    protected onSlipUpEvent(id: number, data: ISlipEvent): {
        id: number;
        axis: number;
    };
    protected onSlipRightUpEvent(id: number, data: ISlipEvent): {
        id: number;
        axis: number;
    };
    protected onSlipRightEvent(id: number, data: ISlipEvent): {
        id: number;
        axis: number;
    };
    protected onSlipRightDownEvent(id: number, data: ISlipEvent): {
        id: number;
        axis: number;
    };
    protected onSlipDownEvent(id: number, data: ISlipEvent): {
        id: number;
        axis: number;
    };
    protected onSlipLeftDownEvent(id: number, data: ISlipEvent): {
        id: number;
        axis: number;
    };
    protected onSlipLeftUpEvent(id: number, data: ISlipEvent): {
        id: number;
        axis: number;
    };
    protected startSlip(id: number, pos: FVector2): ISlipEvent;
    protected slipping(id: number, pos: FVector2): void;
    protected endSlip(id: number, pos: FVector2): void;
}

export class TWidgetInput extends TBasicInput {
    constructor(data: IWidgetSource);
    protected _bindRawInput<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): IDisposable;
    bind(): void;
    unbind(): void;
    protected _mousePos(elem: HTMLElement, mouseEvent: MouseEvent | Touch): FVector2;
    protected _bindMouseEvent(): void;
    protected _bindTouchEvent(): void;
    protected _intersect(mouse: FVector2): Intersection[];
}

export class Margin {
    left: number;
    top: number;
    right: number;
    bottom: number;
    constructor(src?: Margin);
}
export interface IElement {
    size: FVector2;
}
export interface IContainer<T extends TSlot> {
    slot: T;
    foreachSlot(func: (slot: T) => void): void;
    removeSlot(id: number): void;
}
export interface IChild extends IElement {
    removeFrom(): void;
}
export interface IOffset {
    x: number;
    y: number;
}

export interface IWidgetEventData {
    ray: Raycaster;
    touch?: Touch;
    wheelEvent?: WheelEvent;
    mouseEvent?: MouseEvent;
    intersection?: Intersection;
}
export abstract class IWidgetBody extends IWidgetElement {
    get __owner(): TSlot;
    get pickable(): boolean;
    set pickable(v: boolean);
    static __injectOwner?: Object3D;
    isSprite?: boolean;
    geometry: BufferGeometry;
    center: Vector2;
    protected _owner: Object3D;
    constructor();
    mouseDown(data: IWidgetEventData): void;
    mouseMove(data: IWidgetEventData): void;
    mouseUp(data: IWidgetEventData): void;
    mouseWheel(data: IWidgetEventData): void;
    mouseEnter(data: IWidgetEventData): void;
    mouseLeave(data: IWidgetEventData): void;
    touchStart(data: IWidgetEventData): void;
    touchMove(data: IWidgetEventData): void;
    touchEnd(data: IWidgetEventData): void;
    touchEnter(data: IWidgetEventData): void;
    touchLeave(data: IWidgetEventData): void;
    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
    copy(source: IWidgetBody): this;
    __copy(src: object): void;
    protected getRotation(): number;
}

export abstract class IWidgetElement extends Object3D {
    get needResize(): boolean;
    set needResize(val: boolean);
    onAfterRefresh: Observable<void>;
    size: FVector2;
    abstract tick(deltaSecond: number): void;
    protected abstract _resize(): void;
    resize(): void;
}

export interface IWidgetLifecycle {
    refresh(recursive?: boolean): void;
}

export class IStyle {
    isSprite?: boolean;
    alpha?: number;
    color?: string;
    zIndex?: number;
    shadowBlur?: number;
    shadowOffsetX?: number;
    shadowOffsetY?: number;
    shadowColor?: number;
    isEventBlocker?: boolean;
    readonly ___dirty?: Set<string | number | symbol>;
    ___widget?: WBasic;
}

export type viewFunc = (v: WView) => Promise<any>;
export class WView extends Object3D implements IContainer<TCanvasSlot> {
    get slot(): TCanvasSlot;
    get elements(): Map<number, TCanvasSlot>;
    fixScreen: boolean;
    size: FVector2;
    radio: number;
    constructor(viewWidth: number, viewHeight: number, radio?: number, fixScreen?: boolean);
    foreachSlot(func: (slot: TCanvasSlot) => void): void;
    refresh(viewWidth: number, viewHeight: number, recursive?: boolean): void;
    removeSlot(id: number): void;
    tick(deltaSecond: number): void;
    protected _calc(w: number, h: number): {
        width: number;
        height: number;
    };
}

export function getFrame(size: FVector2, width: number, height: number): {
    points: FVector3[];
    gridWidth: number;
    gridHeight: number;
};

export const widgetModule: ContainerModule;