declare namespace APJS {
  /**
   * @class
   * An axis-aligned bounding box, or AABB for short, is a box aligned with coordinate axes and fully enclosing some object
   * @example
   * let aabb_1 = new AABB(new Vector3f(-1, -1, -1), new Vector3f(1, 1, 1));
   */
  class AABB {
    /**
     * Constructs an instance of the Axis-Aligned Bounding Box (AABB).
     */
    constructor();
    /**
     * Constructs an Axis-Aligned Bounding Box (AABB).
     * @param min - The minimum corner of the box.
     * @param max - The maximum corner of the box.
     */
    constructor(min?: Vector3f, max?: Vector3f);
    /**
     * @description The minimal point-X of the box.
     */
    get minX(): number;
    /**
     * @description Sets the minimum x-coordinate of the axis-aligned bounding box (AABB).
     */
    set minX(value: number);
    /**
     * @description The minimal point-Y of the box.
     */
    get minY(): number;
    /**
     * @description Sets the minimum Y-coordinate of the axis-aligned bounding box (AABB).
     */
    set minY(value: number);
    /**
     * @description The minimal point-Z of the box.
     */
    get minZ(): number;
    /**
     * @description Sets the minimum Z-coordinate of the axis-aligned bounding box (AABB).
     */
    set minZ(value: number);
    /**
     * @description The max point-X of the box.
     */
    get maxX(): number;
    /**
     * @description Sets the maximum X-coordinate of the AABB (Axis-Aligned Bounding Box).
     */
    set maxX(value: number);
    /**
     * @description The max point-Y of the box.
     */
    get maxY(): number;
    /**
     * @description Sets the maximum Y-coordinate of the axis-aligned bounding box (AABB).
     */
    set maxY(value: number);
    /**
     * @description The max point-Z of the box.
     */
    get maxZ(): number;
    /**
     * @description Sets the maximum Z-coordinate of the axis-aligned bounding box (AABB).
     */
    set maxZ(value: number);
    /**
     * @description Returns whether this AABB is equal to the specified `v` AABB.
     * @param v - The AABB to compare with.
     * @returns A boolean indicating whether the two AABBs are equal.
     */
    equals(v: AABB): boolean;
    /**
     * @description Returns a clone of this AABB.
     * @returns {AABB} - A new instance of AABB with the same properties as this one.
     */
    clone(): AABB;
    /**
     * @description Returns a string representation of the AABB.
     * @returns The string representation of the AABB.
     */
    toString(): string;
    /**
     * @description Determines if the current AABB intersects with another AABB.
     * @param other - The other AABB to check for intersection.
     * @returns A boolean indicating whether the two AABBs intersect.
     */
    intersects(other: AABB): boolean;
  }
  /**
   * @namespace AlgorithmManager
   */
  namespace AlgorithmManager {
    /**
     * @description get Result
     * @example
     * const result = APJS.AlgorithmManager.getResult();
     * if (result.getFaceCount() > 0) {
     *   //TODO
     * }
     */
    function getResult(): AlgorithmResult;
  }
  /**
   * @interface AlgorithmResult
   */
  interface AlgorithmResult {
    /**
     * @description getFaceAttributeCount
     * @returns {number}
     */
    getFaceAttributeCount(): number;
    /**
     * @description getFaceAttributeInfo
     * @param {number} index
     * @returns {FaceAttributeInterface}
     */
    getFaceAttributeInfo(index: number): FaceAttributeInterface;
    /**
     * @description getFaceBaseInfo
     * @param {number} index
     * @returns {Face106Interface}
     */
    getFaceBaseInfo(index: number): Face106Interface;
    /**
     * @description getFaceCount
     * @returns {number}
     */
    getFaceCount(): number;
    /**
     * @description getFaceFaceMask
     * @param {number} index
     * @returns {FaceFaceMaskInterface}
     */
    getFaceFaceMask(index: number): FaceFaceMaskInterface;
    /**
     * @description getFaceMouthMask
     * @param {number} index
     * @returns {FaceMouthMaskInterface}
     */
    getFaceMouthMask(index: number): FaceMouthMaskInterface;
    /**
     * @description getFacePetInfo
     * @param {number} index
     * @returns {FacePetInfoInterface}
     */
    getFacePetInfo(index: number): FacePetInfoInterface;
    /**
     * @description getFacePetInfoCount
     * @returns {number}
     */
    getFacePetInfoCount(): number;
    /**
     * @description getFaceTeethMask
     * @param {number} index
     * @returns {FaceTeethMaskInterface}
     */
    getFaceTeethMask(index: number): FaceTeethMaskInterface;
  }
  /**
   * @description AnimatedTextureEvent
   * @enum
   * @property {number} PlayBegin
   * @property {number} PlayEnd
   * @property {number} LoopBegin
   * @property {number} LoopEnd
   * @property {number} KeyFrame
   * @property {number} Pause
   * @property {number} Resume
   * @example
   * const imageComponent = this.getSceneObject().getComponent('Image') as APJS.Image;
   * const tex = imageComponent.texture;
   * const emitter = APJS.EventManager.getObjectEmitter(tex);
   * emitter.on(APJS.AnimatedTextureEvent.LoopEnd, this.onLoopEnd, this);
   */
  enum AnimatedTextureEvent {
    PlayBegin,
    PlayEnd,
    LoopBegin,
    LoopEnd,
    KeyFrame,
    Pause,
    Resume
  }
  /**
   * @description AnimatedTexturePlayMode
   * @enum
   * @property {number} Forward
   * @property {number} PingPong
   * @property {number} Randomize
   * @property {number} Shuffle
   */
  enum AnimatedTexturePlayMode {
    Forward = 0,
    PingPong = 1,
    Randomize = 2,
    Shuffle = 3
  }
  /**
   * @class AnimatedTextureProvider
   */
  class AnimatedTextureProvider extends TextureDelegateProvider {
    /**
     * @description reverse
     * @type {boolean}
     */
    get reverse(): boolean;
    set reverse(value: boolean);
    /**
     * @description playMode
     * @type {AnimatedTexturePlayMode}
     */
    get playMode(): AnimatedTexturePlayMode;
    set playMode(value: AnimatedTexturePlayMode);
    /**
     * @description loopCount
     * @type {number}
     */
    get loopCount(): number;
    set loopCount(value: number);
    /**
     * @description fps
     * @type {number}
     */
    get fps(): number;
    set fps(value: number);
    /**
     * @description duration
     * @type {any}
     */
    get duration(): number;
    set duration(value: number);
    /**
     * @description Starts the animation playback.
     */
    play(): void;
    /**
     * @description pause
     * @returns {void}
     */
    pause(): void;
    /**
     * @description Stops animation playback, resets to initial state, and displays the first frame.
     */
    stop(): void;
    /**
     * @description Resumes the animation playback.
     */
    resume(): void;
    /**
     * @description Resets the animation to its initial state and restarts playback.
     */
    reset(): void;
    /**
     * @description Gets the total number of frames in the animation sequence.
     * @returns Total frame count
     */
    getFrameCount(): number;
  }
  /**
   * @class Animation
   * @extends AObject
   * @description Animation. Stores keyframe based animations. Used by Animator to play back animations.
   */
  class Animation extends AObject {
    protected constructor();
    /**
     * @description total duration in seconds
     * @type {number}
     */
    get duration(): number;
    /**
     * @description default start time for this animation
     * @type {number}
     */
    get startTime(): number;
    /**
     * @description default end time for this animation
     * @type {number}
     */
    get endTime(): number;
    /**
     * @readonly
     * @description The frame count of the animation.
     * Determined by the track with the highest number of frames.
     * Enabling animation compression on import may reduce this value.
     * @type {number}
     */
    get frameCount(): number;
    /**
     * @description set default WrapMode for this animation
     * @type {AnimationWrapMode}
     */
    get wrapMode(): AnimationWrapMode;
    /**
     * @description set default WrapMode for this animation
     * @type {AnimationWrapMode}
     */
    set wrapMode(inWrapMode: AnimationWrapMode);
    /**
     * @description set default playback speed for this animation
     * @type {number}
     */
    get speed(): number;
    set speed(inSpeed: number);
  }
  /**
   * @description AnimationWrapMode
   * @enum
   * @property Once - When time reaches the end of the animation clip, the clip will automatically stop playing.
   * @property Repeat - When time reaches the end of the animation clip, time will continue at the beginning.
   * @property PingPong - When time reaches the end of the animation clip, time will ping pong back between beginning and end.
   * @property ClampForever - Plays back the animation. When it reaches the end, it will keep playing the last frame and never stop playing.
   */
  enum AnimationWrapMode {
    Once = 1,
    Repeat = 0,
    PingPong = -1,
    ClampForever = -2
  }
  /**
   * @class Animator
   * @extends Component
   * @description Animator. Component that plays back animations.
   */
  class Animator extends Component {
    protected constructor();
    /**
     * @description Get current playing Animation
     */
    get playback(): Animation | null;
    /**
     * @description Set current playing Animation
     */
    set playback(animation: Animation | null);
    /**
     * @description Get Animation Resource of this animator.
     */
    get animations(): Animation[];
    /**
     * @description Set Animation Resource of this animator
     */
    set animations(value: Animation[]);
    /**
     * @description get animation resource by name
     * @param name - name
     */
    getAnimation(name: string): Animation;
    /**
     * @description Deprecated. play animation exclusively in default layer, use playState instead
     * @param animationName - animation's name
     * @param wrapMode - loopCount or wrap mode, a value above 0 means loopCount
     * @param speed - play speed
     * @param fadeTime - blend weight fade duration, if is 0, do transition immediately
     */
    play(animationName: string, wrapMode: number | AnimationWrapMode, speed: number, fadeInTime?: number): void;
    /**
     * @description stop all animations playing in this animator
     */
    stopAll(): void;
    /**
     * @description pause all animations playing in this animator
     */
    pauseAll(): void;
    /**
     * @description resume all animations playing in this animator
     */
    resumeAll(): void;
  }
  /**
   * @class AObject
   */
  class AObject {
    protected constructor();
    /**
     * @description Returns the object's name.
     */
    get name(): string;
    /**
     * @description Sets the name of the object
     */
    set name(value: string);
  }
  /**
   * @class AudioAsset
   * @extends AObject
   * @description Audio clip of resource.
   */
  class AudioAsset extends AObject {
    protected constructor();
  }
  /**
   * @class
   */
  abstract class BasicScriptComponent {
    /**
     * @description get the scene object this component is attached to
     * @returns the scene object this component is attached to
     */
    getSceneObject(): SceneObject;
    /**
     * @description Called by engine when component itself is enabled.
     */
    onEnable(): void;
    /**
     * @description Called by engine when component itself is disabled.
     */
    onDisable(): void;
    /**
     * @description Called by engine when component is added to SceneObject, will be called even if component is disabled.
     */
    onInit(): void;
    /**
     * @description Called by engine when component is started, will not be called if component is disabled.
     */
    onStart(): void;
    /**
     * @description Called by engine every frame.
     * @param deltaTime - Time duration from last update by second
     */
    onUpdate(deltaTime: number): void;
    /**
     * @description Called by engine every frame after all systems updated.
     * @param deltaTime - Time duration from last update by second
     */
    onLateUpdate(deltaTime: number): void;
    /**
     * @description Called by engine when component is destroyed.
     */
    onDestroy(): void;
    /**
     * @description Component by engine when events occurred.
     * @param event - IEvent object.
     */
    onEvent(event: IEvent): void;
  }
  /**
   * @class BoxCollider
   * @extends Collider
   */
  class BoxCollider extends Collider {
    protected constructor();
    /**
     * @description collider size
     * @type {Vector3f}
     */
    get size(): Vector3f;
    set size(value: Vector3f);
  }
  /**
   * @class BoxCollider2D
   * @extends Collider2D
   */
  class BoxCollider2D extends Collider2D {
    protected constructor();
    /**
     * @description 2d box collider size
     * @type {Vector2f}
     */
    get size(): Vector2f;
    set size(value: Vector2f);
  }
  /**
   * @class Camera
   * @description
   * <br/>A Camera is a device through which the player views the world.
   * <br/>use sceneObject.addComponent("Camera") to create one camera component
   * @example
   * let cam = sceneObj.addComponent("Camera");
   * cam.clearColor = new Color(0,0,0,1);
   */
  class Camera extends Component {
    protected constructor();
    /**
     * @description When enableClearColor is true and inputTexture is null, this color is used to clear this Camera's renderTarget before drawing to it.
     */
    get clearColor(): Color;
    /**
     * @description Sets the clear color for the camera.
     */
    set clearColor(color: Color);
    /**
     * @description The clear type of the current camera.
     */
    get clearType(): CameraClearType;
    /**
     * @description Sets the type of clearing operation for the camera.
     */
    set clearType(type: CameraClearType);
    /**
     * @description Gets the type of the camera, which can be either CameraType.Ortho or CameraType.PERSPECTIVE.
     * @returns The current type of the camera.
     */
    get cameraType(): CameraType;
    /**
     * @description Sets the type of the camera.
     */
    set cameraType(type: CameraType);
    /**
     * @description The orthographic height of the camera if the camera type is orthographic.
     */
    get orthoHeight(): number;
    /**
     * @description Sets the orthographic height of the camera.
     */
    set orthoHeight(height: number);
    /**
     * @description The distance of the far clipping plane.
     */
    get far(): number;
    /**
     * @description Sets the far clipping plane of the camera, defining the maximum distance at which objects are visible.
     */
    set far(value: number);
    /**
     * @description The distance of the near clipping plane.
     */
    get near(): number;
    /**
     * @description Sets the near clipping plane of the camera, defining the closest distance at which objects are visible.
     */
    set near(value: number);
    /**
     * @description The Camera's field of view in radians.
     */
    get fov(): number;
    /**
     * @description Sets the field of view (FOV) for the camera.
     */
    set fov(value: number);
    /**
     * @description Gets the field of view type for the camera.
     */
    get fovType(): CameraFovType;
    /**
     * @description Sets the field of view type for the camera.
     */
    set fovType(value: CameraFovType);
    /**
     * @description This texture is used to clear the Camera's renderTarget before drawing.
     * <br/>If this texture is null, clearColor will be used instead.
     */
    get inputTexture(): Texture | null;
    /**
     * @description Sets the input texture for the camera.
     */
    set inputTexture(value: Texture | null);
    /**
     * @description The set of layers this Camera will render.
     */
    get renderLayer(): LayerSet;
    /**
     * @description Sets the render layer for the camera.
     */
    set renderLayer(value: LayerSet);
    /**
     * @description Gets the render texture associated with the current camera.
     * @returns The render texture of the camera.
     */
    get renderTexture(): Texture;
    /**
     * @description Sets the render texture for the camera.
     */
    set renderTexture(value: Texture);
    /**
     * @description Gets the depth render texture associated with the current camera.
     * @returns The depth render texture.
     */
    get depthRenderTexture(): Texture;
    /**
     * @description Sets the depth render texture for the camera.
     */
    set depthRenderTexture(value: Texture);
    /**
     * @description The camera's viewport, default is (0,0,1,1)
     * @returns The current viewport of the camera.
     */
    get viewport(): Rect;
    /**
     * @description Sets the camera's viewport to the specified rectangular area.
     */
    set viewport(value: Rect);
    /**
     * @description The sorting order the Camera renders in. Every frame, Cameras render in ascending order determined by their renderOrder properties.
     */
    get renderOrder(): number;
    /**
     * @description Sets the render order of the camera.
     */
    set renderOrder(value: number);
    /**
     * @readonly
     * @type {Matrix4x4f}
     * @description The projection matrix of the current camera.
     */
    get projectionMatrix(): Matrix4x4f;
    /**
     * @description Converts a point from view port space to world space.
     * @param viewPortPoint - A point in view port space represented as a Vector3f.
     * @returns The corresponding point in world space as a Vector3f.
     */
    viewportToWorldPoint(viewPortPoint: Vector3f): Vector3f;
    /**
     * Projects a point from world space to viewport space.
     * @param worldPoint - A point in world space represented as a Vector3f.
     * @returns The calculated point in viewport space as a Vector3f.
     */
    worldToViewportPoint(worldPoint: Vector3f): Vector3f;
    /**
     * Converts a screen space position to a world space position, given an absolute depth.
     * @param screenPoint - A point in screen space represented as a Vector3f.
     * @returns The corresponding world space position as a Vector3f.
     */
    screenToWorldPoint(screenPoint: Vector3f): Vector3f;
    /**
     * Converts a world space position to a screen space position.
     * Screen position is based on the current rendered screen resolution W x H. Therefore, it represents within the range ([0,W], [0,H]), where (0,0) is the bottom-left of the screen and (W,H) is the top-right.
     * @param worldPoint - The world space point as a Vector3f.
     * @returns The corresponding screen space position as a Vector3f.
     */
    worldToScreenPoint(worldPoint: Vector3f): Vector3f;
    /**
     * @description Generates a ray from the specified position in this camera's viewport space.
     * @param viewportPoint - A point in viewport space represented as a Vector2f.
     * @returns The calculated world space ray as a Ray object.
     */
    viewportPointToRay(viewportPoint: Vector2f): Ray;
    /**
     * @description Generates a ray from the screen position in this camera's view space.
     * @param screenPoint - A point in screen space represented as a Vector2f.
     * @returns The calculated world space ray as a Ray object.
     */
    ScreenPointToRay(screenPoint: Vector2f): Ray;
    /**
     * @description Retrieves the transformation matrix that converts coordinates from world space to clip space.
     * @returns The 4x4 matrix representing the world-to-clip space transformation.
     */
    getWorldToClipMatrix(): Matrix4x4f;
    /**
     * @description Get the matrix that transforms from camera space to world space.
     * Use this to calculate where in the world a specific camera space point is located.
     * @returns The transformation matrix from camera space to world space.
     */
    getCameraToWorldMatrix(): Matrix4x4f;
    /**
     * @description Retrieves the matrix that transforms coordinates from world space to camera space.
     * <br/>This matrix is commonly known as the "view matrix" in graphics literature.
     * <br/>It can be used to determine the position of game objects in camera space or to specify a custom camera location independent of its transform.
     * @returns The transformation matrix from world space to camera space.
     */
    getWorldToCameraMatrix(): Matrix4x4f;
    /**
     * @description Gets the camera's forward direction, also known as the look-at direction.
     * @returns The forward direction vector of the camera.
     */
    getLookAt(): Vector3f;
  }
  /**
   * @description Camera Clear Type Enum.
   * @enum
   * @property Color - Clear color only.
   * @property Depth - Clear depth only.
   * @property ColorDepth - Clear color and depth.
   * @property Dont - Clear nothing.
   * @property DepthStencil - Clear depth and stencil
   * @property ColorDepthStencil - Clear color, depth and stencil
   * @property Stencil - Clear stencil only.
   * @property ColorStencil - Clear color and stencil.
   * @property Texture
   * @property TextureDepth
   */
  enum CameraClearType {
    Color,
    Depth,
    ColorDepth,
    Dont,
    DepthStencil,
    ColorDepthStencil,
    Stencil,
    ColorStencil,
    Texture,
    TextureDepth
  }
  /**
   * @description Camera Field of View (FOV) Type.
   * @enum
   * @property Custom - Custom FOV setting.
   * @property Physical - FOV based on physical properties.
   */
  enum CameraFovType {
    Custom,
    Physical
  }
  /**
   * @description Camera Projection Type Enum.
   * @enum
   * @property Perspective - Perspective projection.
   * @property Ortho - Orthogonal projection.
   */
  enum CameraType {
    Perspective,
    Ortho
  }
  /**
   * @class CapsuleCollider
   * @extends Collider
   */
  class CapsuleCollider extends Collider {
    protected constructor();
    /**
     * @description capsule collider radius
     * @type {number}
     */
    get radius(): number;
    set radius(value: number);
    /**
     * @description capsule height
     * @type {number}
     */
    get height(): number;
    set height(value: number);
  }
  /**
   * @class CircleCollider2D
   * @extends Collider2D
   */
  class CircleCollider2D extends Collider2D {
    protected constructor();
    /**
     * @description the radius of the circle collider
     */
    get radius(): number;
    set radius(value: number);
    get fitImage(): boolean;
    set fitImage(value: boolean);
  }
  /**
   * @class Collider
   * @extends DynamicComponent
   */
  class Collider extends DynamicComponent {
    protected constructor();
    /**
     * @description Whether the collider is tangible.
     * When true, the collider is tangible and objects will collide with it normally.
     * When false, it becomes a trigger — objects can pass through it, but
     * collision events can still be detected.
     * @type {boolean}
     */
    get isTangible(): boolean;
    set isTangible(value: boolean);
    /**
     * @description The center position of the collider.
     * @type {Vector3f}
     */
    get center(): Vector3f;
    set center(value: Vector3f);
    /**
     * @description Whether the collider is interactable through interactor node.
     * When true, Physics Interactor Script Graph Node can be used to drag this object.
     * @type {boolean}
     */
    get interactable(): boolean;
    set interactable(value: boolean);
    /**
     * @description The physics material of the collider.
     * @type {PhysicsMaterial}
     */
    get physicsMaterial(): PhysicsMaterial | null;
    set physicsMaterial(value: PhysicsMaterial | null);
    /**
     * @description The rotation of the collider in quaternion form.
     * @type {Quaternionf}
     */
    get rotation(): Quaternionf;
    set rotation(value: Quaternionf);
    /**
     * @description The collider’s rotation in euler angles (degrees).
     * @type {Vector3f}
     */
    get eulerAngles(): Vector3f;
    set eulerAngles(value: Vector3f);
    /**
     * @description Whether the collider emits collision events for custom script.
     * When true, the collider will send collision events
     * every frame (Enter / Stay / Exit).
     * Enable this if your script needs to listen for collision callbacks.
     * @type {boolean}
     */
    get emitCollisionEvent(): boolean;
    set emitCollisionEvent(value: boolean);
  }
  /**
   * @class Collider2D
   * @extends DynamicComponent
   */
  class Collider2D extends DynamicComponent {
    protected constructor();
    /**
     * @description The center position offset of the collider.
     * @type {Vector2f}
     */
    get offset(): Vector2f;
    set offset(value: Vector2f);
    /**
     * @description The physics material of the collider.
     * @type {PhysicsMaterial}
     */
    get physicsMaterial(): PhysicsMaterial | null;
    set physicsMaterial(value: PhysicsMaterial | null);
    /**
     * @description Whether the collider is tangible.
     * When true, the collider is tangible and objects will collide with it normally.
     * When false, it becomes a trigger — objects can pass through it, but
     * collision events can still be detected.
     * @type {boolean}
     */
    get isTangible(): boolean;
    set isTangible(value: boolean);
    /**
     * @description Whether the collider emits collision events for custom script.
     * When true, the collider will send collision events
     * every frame (Enter / Stay / Exit).
     * Enable this if your script needs to listen for collision callbacks.
     * @type {boolean}
     */
    get emitCollisionEvent(): boolean;
    set emitCollisionEvent(value: boolean);
  }
  class CollisionEvent {
    constructor();
    /**
     * @readonly
     * @description Enter
     * @type {UserEventType}
     */
    static get Enter(): UserEventType;
    /**
     * @readonly
     * @description Stay
     * @type {UserEventType}
     */
    static get Stay(): UserEventType;
    /**
     * @readonly
     * @description Exit
     * @type {UserEventType}
     */
    static get Exit(): UserEventType;
  }
  class CollisionEvent2D {
    constructor();
    /**
     * @readonly
     * @description Enter
     * @type {UserEventType}
     */
    static get Enter(): UserEventType;
    /**
     * @readonly
     * @description Stay
     * @type {UserEventType}
     */
    static get Stay(): UserEventType;
    /**
     * @readonly
     * @description Exit
     * @type {UserEventType}
     */
    static get Exit(): UserEventType;
  }
  class CollisionInfo {
    constructor(point: Vector3f, normal: Vector3f, otherObject: SceneObject | null);
    /**
     * @description The point of contact in world space.
     * @type {Vector3f}
     */
    readonly point: Vector3f;
    /**
     * @description The normal of contact in world space.
     * @type {Vector3f}
     */
    readonly normal: Vector3f;
    /**
     * @description The other object involved in the collision.
     * @type {SceneObject | null}
     */
    readonly otherObject: SceneObject | null;
  }
  class CollisionInfo2D {
    constructor(point: Vector2f, normal: Vector2f, otherObject: SceneObject | null);
    /**
     * @description The point of contact in world space.
     * @type {Vector2f}
     */
    readonly point: Vector2f;
    /**
     * @description The normal of contact in world space.
     * @type {Vector2f}
     */
    readonly normal: Vector2f;
    /**
     * @description The other object involved in the collision.
     * @type {SceneObject | null}
     */
    readonly otherObject: SceneObject | null;
  }
  /**
   * @class Color
   * @example
   * const white = new Color(1, 1, 1, 1);
   */
  class Color {
    /**
     * @description Color's channel R
     */
    r: number;
    /**
     * @description Color's channel G
     */
    g: number;
    /**
     * @description Color's channel B
     */
    b: number;
    /**
     * @description Color's channel A
     */
    a: number;
    /**
     * @description Constructs a new Color instance.
     * @param r - The red component of the color, or an existing Color object. Defaults to 0 if not provided.
     * @param g - The green component of the color. Defaults to 0 if not provided.
     * @param b - The blue component of the color. Defaults to 0 if not provided.
     * @param a - The alpha (opacity) component of the color. Defaults to 0 if not provided.
     */
    constructor(r?: number, g?: number, b?: number, a?: number);
    /**
     * @description Compares the current color with another color for equality.
     * @param v - The color to compare against.
     * @returns A boolean indicating whether the two colors are equal.
     */
    equals(v: Color): boolean;
    /**
     * @description Converts the color to a string representation.
     * @returns {string} - The string representation of the color in the format "Color(R: r, G: g, B: b, A: a)" where r, g, b, and a are fixed to 5 decimal places.
     */
    toString(): string;
    /**
     * @description Creates and returns a deep copy of the current color instance.
     * @returns {Color} - A new Color object with the same properties as the original.
     */
    clone(): Color;
    /**
     * @description Compares two colors for equality.
     * @param v0 - The first color to compare.
     * @param v1 - The second color to compare.
     * @returns A boolean indicating whether the two colors are equal.
     */
    static equals(v0: Color, v1: Color): boolean;
  }
  /**
   * @description Represents the color channels that can be masked in a graphics operation.
   * @enum
   * @property R Red channel mask.
   * @property G Green channel mask.
   * @property B Blue channel mask.
   * @property A Alpha channel mask.
   */
  enum ColorMask {
    R,
    G,
    B,
    A
  }
  /**
   * @class Component
   * @description
   * Base class for everything attached to a SceneObject.
   * <br/> Note that your code will never directly create a Component. Instead, you write script code, and attach the script to a SceneObject.
   * <br/> use SceneObject.addComponent("MeshRenderer");
   * @extends AObject
   * @example let renderCom = currSceneObj.addComponent("MeshRenderer");
   */
  class Component extends AObject {
    protected constructor();
    /**
     * @type {boolean}
     * @description Controls the component is enabled
     */
    get enabled(): boolean;
    set enabled(value: boolean);
    /**
     * @description Is inherited enabled
     * @returns {boolean}
     */
    isInheritedEnabled(): boolean;
    /**
     * @description get the scene object this component is attached to
     * @returns {SceneObject} the scene object this component is attached to
     */
    getSceneObject(): SceneObject;
  }
  /**
   * @description Defines the culling mode for rendering.
   * @enum
   * @property None No faces are culled.
   * @property Front Front-facing faces are culled.
   * @property Back Back-facing faces are culled.
   * @property FrontAndBack Both front and back-facing faces are culled.
   */
  enum CullMode {
    None,
    Front,
    Back,
    FrontAndBack
  }
  /**
   * @description Defines the depth comparison function used for depth testing.
   * @enum
   * @property Never - Depth test never passes.
   * @property Less - Depth test passes if the incoming depth value is less than the stored depth value.
   * @property Equal - Depth test passes if the incoming depth value is equal to the stored depth value.
   * @property LessOrEqual - Depth test passes if the incoming depth value is less than or equal to the stored depth value.
   * @property Greater - Depth test passes if the incoming depth value is greater than the stored depth value.
   * @property NotEqual - Depth test passes if the incoming depth value is not equal to the stored depth value.
   * @property GreaterOrEqual - Depth test passes if the incoming depth value is greater than or equal to the stored depth value.
   * @property Always - Depth test always passes.
   */
  enum DepthFunction {
    Never,
    Less,
    Equal,
    LessOrEqual,
    Greater,
    NotEqual,
    GreaterOrEqual,
    Always
  }
  /**
   * @namespace DeviceInfo
   * @description Get information of current device.
   */
  namespace DeviceInfo {
    /**
     * @memberof DeviceInfo
     * @description Get OS of the device.
     */
    function getOS(): OS;
    /**
     * @memberof DeviceInfo
     * @description Get the camera facing type of the device.
     */
    function getCameraFacingType(): number;
  }
  /**
   * @class DirectionalLight
   * @extends Light
   * @description Class of DirectionalLight.
   */
  class DirectionalLight extends Light {
    constructor();
    /**
     * @description set get current light's Shadow Enable.
     */
    get castShadow(): boolean;
    set castShadow(value: boolean);
    /**
     * @description current light shadow map resolution
     */
    get shadowResolution(): Vector2f;
    set shadowResolution(value: Vector2f);
    /**
     * @description current light's shadowBias
     */
    get shadowBias(): number;
    set shadowBias(value: number);
    /**
     * @description set and get light's shadow Strength
     */
    get shadowStrength(): number;
    set shadowStrength(value: number);
    /**
     * @description current light's softShadow Enable
     */
    get softShadow(): boolean;
    set softShadow(value: boolean);
    /**
     * @description current light's shadowSoftness
     */
    get shadowSoftness(): number;
    set shadowSoftness(value: number);
    /**
     * @description current light's ShadowColor
     */
    get shadowColor(): Color;
    set shadowColor(value: Color);
    /**
     * @description set and get shadowFrustumArea
     */
    get shadowFrustumArea(): number;
    set shadowFrustumArea(value: number);
    /**
     * @description set and shadowAutoFrustum
     */
    get shadowAutoFrustum(): boolean;
    set shadowAutoFrustum(value: boolean);
    /**
     * @description set and get shadowFrustumNear
     */
    get shadowFrustumNear(): number;
    set shadowFrustumNear(value: number);
    /**
     * @description set and get shadowFrustumFar
     */
    get shadowFrustumFar(): number;
    set shadowFrustumFar(value: number);
  }
  /**
   * @class DistanceJoint2D
   * @extends Joint2D
   */
  class DistanceJoint2D extends Joint2D {
    protected constructor();
  }
  /**
   * @class DynamicBitset
   */
  class DynamicBitset {
    /**
     * Constructs a new instance of the DynamicBitset class.
     */
    constructor();
    /**
     * Constructs a new instance of the DynamicBitset.
     * @param v0 - The initial size or value for the bitset.
     * @param v1 - An optional parameter that could represent an additional size or value for initialization.
     */
    constructor(v0: number, v1: number);
    /**
     * @description Compares the current DynamicBitset with another DynamicBitset for equality.
     * @param v - The DynamicBitset to compare against.
     * @returns A boolean indicating whether the two DynamicBitsets are equal.
     */
    equals(v: DynamicBitset): boolean;
    /**
     * @description Returns a string representation of the DynamicBitset.
     * @returns A string representing the current state of the DynamicBitset.
     */
    toString(): string;
    /**
     * @description Tests if the specified bit is set in the DynamicBitset.
     * @param v - The index of the bit to test.
     * @returns A boolean indicating whether the bit at the specified index is set.
     */
    test(v: number): boolean;
    /**
     * @description Checks if any bit in the dynamic bitset is set to true.
     * @returns {boolean} - Returns true if at least one bit is set, otherwise false.
     */
    any(): boolean;
    /**
     * @description Checks if the bitset is empty, meaning all bits are unset.
     * @returns {boolean} - True if no bits are set, otherwise false.
     */
    none(): boolean;
    /**
     * @description Resets the bitset to a specified value.
     * @param v - The value to reset the bitset to.
     * @returns The modified DynamicBitset instance.
     */
    reset(v: number): DynamicBitset;
    /**
     * @description Set the value in the dynamic bitset.
     * If no arguments are provided, sets the default value.
     * If one argument is provided, sets the value at the specified index.
     * If two arguments are provided, sets the range of values from the start index to the end index.
     * @param v - The index or start index for setting the value.
     * @param v1 - The end index for setting a range of values.
     */
    set(v?: number, v1?: number): void;
    /**
     * @description Compares two DynamicBitset instances for equality.
     * @param v0 - The left-hand side DynamicBitset instance to compare.
     * @param v1 - The right-hand side DynamicBitset instance to compare.
     * @returns A boolean indicating whether the two DynamicBitset instances are equal.
     */
    static equals(v0: DynamicBitset, v1: DynamicBitset): boolean;
  }
  /**
   * @class DynamicChain
   * @extends DynamicComponent
   */
  class DynamicChain extends DynamicComponent {
    protected constructor();
    /**
     * @description the damping value of the dynamic chain
     * @type {number}
     */
    get damping(): number;
    set damping(value: number);
    /**
     * @description the elasticity value of the dynamic chain
     * @type {number}
     */
    get elasticity(): number;
    set elasticity(value: number);
    /**
     * @description the stiffness of the dynamic chain
     * @type {number}
     */
    get stiffness(): number;
    set stiffness(value: number);
    /**
     * @description the total inertia of the dynamic chain
     * @type {number}
     */
    get inertia(): number;
    set inertia(value: number);
    /**
     * @description the consistent external force applied to the dynamic chain
     * @type {number}
     */
    get force(): Vector3f;
    set force(value: Vector3f);
    /**
     * @description whether is the local force or not.
     * @type {boolean}
     */
    get isLocalForce(): boolean;
    set isLocalForce(value: boolean);
    /**
     * @description whether it rotated related to another object
     * @type {boolean}
     */
    get isRelative(): boolean;
    set isRelative(value: boolean);
    /**
     * @description whether enable animation physics blending
     * @type {boolean}
     */
    get physicsAnimation(): boolean;
    set physicsAnimation(value: boolean);
    /**
     * @description the animation physics blending value
     * @type {number}
     */
    get physicsAnimationRate(): number;
    set physicsAnimationRate(value: number);
  }
  /**
   * @class DynamicComponent
   * @extends Component
   */
  class DynamicComponent extends Component {
    protected constructor();
  }
  /**
   * @class EdgeCollider2D
   * @extends Collider2D
   */
  class EdgeCollider2D extends Collider2D {
    protected constructor();
    /**
     * @description The points of the edge collider.
     * @type {Vector2f[]}
     */
    get points(): Vector2f[];
    set points(value: Vector2f[]);
  }
  /**
   * @class EnvironmentLight
   * @description EnvironmentLight. environment light component.
   * @extends Component
   */
  class EnvironmentLight extends Component {
    constructor();
    /**
     * @description environment light render layer
     * @type {LayerSet}
     */
    get renderLayer(): LayerSet;
    set renderLayer(value: LayerSet);
    /**
     * @description set environment map, only support texture cube map
     * @type {Texture}
     */
    set environmentMap(value: Texture);
    /**
     * @description environmentMap
     * @type {Texture}
     */
    get environmentMap(): Texture;
    /**
     * @description environment light intensity
     * @type {number}
     */
    set intensity(value: number);
    get intensity(): number;
    /**
     * @description environment light rotation
     * @type {number}
     */
    set rotation(value: number);
    get rotation(): number;
    /**
     * @description environment light color
     * @type {Color}
     */
    set color(color: Color);
    get color(): Color;
  }
  /**
   * @namespace
   * EventManager
   */
  namespace EventManager {
    /**
     * @description Define a user-defined event type.
     * This method allows you to create and register a custom event type with a unique identifier,
     * which can be used to trigger and handle events in your application.
     *
     * @param eventName - The unique identifier for the user event type. Can be either a number or a string.
     * @returns The newly defined or existing UserEventType associated with the provided identifier.
     *
     * @example
     * const USER_EVENT_01: UserEventType = APJS.EventManager.defineUserEventType(42);
     * const USER_EVENT_02: UserEventType = APJS.EventManager.defineUserEventType('foo');
     */
    function defineUserEventType(eventName: number | string): UserEventType;
    /**
     * @description Create and return a new event instance based on the provided event type.
     * @param eventType - The type of the event, which can be either a numeric code or a predefined UserEventType enum value.
     * @returns An IEvent object representing the created event.
     * @example
     * const event = APJS.EventManager.createEvent(myEventType);
     */
    function createEvent(eventType: number | UserEventType): IEvent;
    /**
     * @description Retrieves the global event emitter instance. If it doesn't exist, it creates a new one.
     * @returns The global event emitter instance.
     * @example
     * const emitter = APJS.EventManager.getGlobalEmitter();
     * emitter.emit(myEvent);
     */
    function getGlobalEmitter(): IEventEmitter;
    /**
     * @description Retrieves the event emitter associated with a given object.
     * @param obj - The object for which to get the event emitter. This can be an AObject.
     * @returns The event emitter for the specified object, or undefined if the object is invalid or not supported.
     * @example
     * const emitter = APJS.EventManager.getObjectEmitter(myObject);
     * emitter.emit(myEvent);
     */
    function getObjectEmitter(obj: AObject): IEventEmitter;
  }
  /**
   * @description Event type
   * @enum
   * @property {number} Touch Touch event, the event args is [TouchData, ]
   * @property {number} RecordStart Record start event, the event args is empty
   * @property {number} RecordEnd Record end event, the event args is empty
   * @example
   *  let callback = (event:IEvent) => {
   *    const touchInfo = event.args[0] as APJS.TouchData;
   *    const touchPhase = touchInfo.phase;
   *    ...
   *
   *  }
   *
   *  const globalEmitter = APJS.EventManager.getGlobalEmitter();
   *  globalEmitter.on(APJS.EventType.Touch, callback);
   */
  enum EventType {
    Touch,
    RecordStart,
    RecordEnd
  }
  /**
   * @interface
   * Face106Interface
   */
  interface Face106Interface {
    /**
     * @readonly
     * @description Each detected face has a unique faceID. When a face that was lost during tracking is detected again, it will have a new faceID.
     */
    readonly ID: number;
    /**
     * @readonly
     * @description Eye distance
     */
    readonly eyeDistance: number;
    /**
     * @readonly
     * @description Pitch angle, in radians
     */
    readonly pitch: number;
    /**
     * @readonly
     * @description Vector2f **Flat Array** <br/>Array of 106 key points of the human face.
     */
    readonly pointsArray: Float32Array;
    /**
     * @readonly
     * @description The rectangular area of the face
     */
    readonly rect: Rect;
    /**
     * @readonly
     * @description Rotation angle, in radians
     */
    readonly roll: number;
    /**
     * @readonly
     * @description score
     */
    readonly score: number;
    /**
     * @readonly
     * @description Visibility of corresponding points. The point is not occluded: 1.0, and occluded: 0.0
     */
    readonly visibilityArray: Float32Array;
    /**
     * @readonly
     * @description Horizontal rotation angle, in radians
     */
    readonly yaw: number;
    /**
     * @description Action check
     * @param action - action
     */
    hasAction(action: number | FaceAction): boolean;
  }
  /**
   * @description Enum representing various facial actions that face can perform.
   * @enum
   * @property BrowJump Causes the face eyebrows to jump.
   * @property EyeBlink Makes the face blink both eyes.
   * @property EyeBlinkLeft Makes the face blink only the left eye.
   * @property EyeBlinkRight Makes the face blink only the right eye.
   * @property HeadPitch Tilts the face head up and down.
   * @property HeadYaw Turns the face head side to side.
   * @property MouthAh Opens the face mouth in an "ah" shape.
   * @property MouthPout Puts the face mouth into a pouting position.
   * @property SideNod Nods the face head from side to side.
   */
  enum FaceAction {
    BrowJump,
    EyeBlink,
    EyeBlinkLeft,
    EyeBlinkRight,
    HeadPitch,
    HeadYaw,
    MouthAh,
    MouthPout,
    SideNod
  }
  /**
   * @description Enum representing different facial expressions.
   * @enum
   * @property Unknown Unknown expression.
   * @property Angry Angry expression.
   * @property Disgust Disgusted expression.
   * @property Fear Fearful expression.
   * @property Happy Happy expression.
   * @property Sad Sad expression.
   * @property Surprise Surprised expression.
   * @property Neutral Neutral expression.
   */
  enum FaceAttrExpression {
    Unknown,
    Angry,
    Disgust,
    Fear,
    Happy,
    Sad,
    Surprise,
    Neutral
  }
  /**
   * @description Gender attribute of a face.
   * @enum
   * @property Unknown The gender is unknown.
   * @property Male The gender is male.
   * @property Female The gender is female.
   */
  enum FaceAttrGender {
    Unknown,
    Male,
    Female
  }
  /**
   * @interface
   * FaceAttributeInterface
   */
  interface FaceAttributeInterface {
    /**
     * @readonly
     * @description age
     */
    readonly age: number;
    /**
     * @readonly
     * @description attractiveness score
     */
    readonly attractive: number;
    /**
     * @readonly
     * @description Probability of being male
     */
    readonly boyProbability: number;
    /**
     * @readonly
     * @description The probabilities of facial expression types
     */
    readonly expressionProbabilities: Float32Array;
    /**
     * @readonly
     * @description Expression type
     */
    readonly expressionType: FaceAttrExpression;
    /**
     * @readonly
     * @description gender
     */
    readonly gender: FaceAttrGender;
    /**
     * @readonly
     * @description Degree of happiness
     */
    readonly happyScore: number;
  }
  /**
   * @interface
   * FaceFaceMaskInterface
   */
  interface FaceFaceMaskInterface {
    /**
     * @readonly
     * @description Each detected face has a unique faceID. When a face that was lost during tracking is detected again, it will have a new faceID.
     */
    readonly ID: number;
    /**
     * @readonly
     * @description Face mask. size = faceMaskSize * faceMaskSize
     */
    readonly faceMask: Uint8Array;
    /**
     * @readonly
     * @description Face mask size.
     */
    readonly faceMaskSize: number;
  }
  /**
   * @class FaceMakeup
   * @extends Component
   */
  class FaceMakeup extends Component {
    constructor();
    /**
     * @description intensity
     * @type {number}
     */
    get intensity(): number;
    set intensity(value: number);
    /**
     * @description makeupTexture
     * @type {Texture}
     */
    get makeupTexture(): Texture | null;
    set makeupTexture(value: Texture | null);
    /**
     * @description opacityEnabled
     * @type {boolean}
     */
    get opacityEnabled(): boolean;
    set opacityEnabled(value: boolean);
    /**
     * @description opacityTexture
     * @type {Texture}
     */
    get opacityTexture(): Texture | null;
    set opacityTexture(value: Texture | null);
    /**
     * @description color
     * @type {Color}
     */
    get color(): Color;
    set color(value: Color);
    /**
     * @description set material property for one face index
     * @param {string} key
     * @param {number} index
     * @param {number} value
     * @returns {void}
     */
    setMaterialPropertyByIndex(key: string, face: number, value: number): void;
    /**
     * @description set uniform for all face indexes
     * @param {string} key
     * @param {number | Vector4f | Matrix4x4f | Texture} value
     * @returns {void}
     */
    setMaterialProperty(key: string, value: number | Vector4f | Matrix4x4f | Texture): void;
  }
  /**
   * @interface
   * FaceMouthMaskInterface
   */
  interface FaceMouthMaskInterface {
    /**
     * @readonly
     * @description Each detected face has a unique faceID. When a face that was lost during tracking is detected again, it will have a new faceID.
     */
    readonly ID: number;
    /**
     * @readonly
     * @description Face mask. size = faceMaskSize * faceMaskSize
     */
    readonly faceMask: Uint8Array;
    /**
     * @readonly
     * @description Face mask size.
     */
    readonly faceMaskSize: number;
  }
  /**
   * @interface
   * FacePetInfoInterface
   */
  interface FacePetInfoInterface {
    /**
     * @readonly
     * @description Each detected pet face has a unique faceID. When a pet face that was lost during tracking is detected again, it will have a new faceID.
     */
    readonly ID: number;
    /**
     * @readonly
     * @description Action type <br/>
     The 1st, 2nd, and 3rd digits are respectively encoded as: left eye open/close, right eye open/close, mouth open/close
     */
    readonly action: number;
    /**
     * @readonly
     * @description Ear status <br/>
     0 indicates the ears are upright, and 1 indicates the ears are drooping.
     */
    readonly earType: number;
    /**
     * @readonly
     * @description Pet face types (cat, dog, human)
     */
    readonly facePetType: FacePetType;
    /**
     * @readonly
     * @description Pitch angle, with the real measurement being negative above and positive below, in radians
     */
    readonly pitch: number;
    /**
     * @readonly
     * @description Vector2f **Flat Array**. Normalized, 2D key point coordinates.
     */
    readonly pointsArray: Float32Array;
    /**
     * @readonly
     * @description The rectangular area of the pet face
     */
    readonly rect: Rect;
    /**
     * @readonly
     * @description Rotation angle, with the true measurement being negative on the left and positive on the right, in radians
     */
    readonly roll: number;
    /**
     * @readonly
     * @description score
     */
    readonly score: number;
    /**
     * @readonly
     * @description Horizontal rotation angle, with the true measurement being negative on the left and positive on the right, in radians
     */
    readonly yaw: number;
  }
  /**
   * @description Represents different types of face pets.
   * @enum
   * @property Cat Represents a cat face pet.
   * @property Dog Represents a dog face pet.
   * @property Human Represents a human face pet.
   * @property Others Represents other types of face pets.
   */
  enum FacePetType {
    Cat,
    Dog,
    Human,
    Others
  }
  /**
   * @interface
   * FaceTeethMaskInterface
   */
  interface FaceTeethMaskInterface {
    /**
     * @readonly
     * @description Each detected face has a unique faceID. When a face that was lost during tracking is detected again, it will have a new faceID.
     */
    readonly ID: number;
    /**
     * @readonly
     * @description Face mask. size = faceMaskSize * faceMaskSize
     */
    readonly faceMask: Uint8Array;
    /**
     * @readonly
     * @description Face mask size.
     */
    readonly faceMaskSize: number;
  }
  /**
   * @description FilterMipmapMode
   * @enum
   * @property None
   * @property Nearest
   * @property Linear
   */
  enum FilterMipmapMode {
    None,
    Nearest,
    Linear
  }
  /**
   * @description FilterMode
   * @enum
   * @property Nearest
   * @property Linear
   */
  enum FilterMode {
    Nearest,
    Linear
  }
  /**
   * @class FixedJoint
   * @extends Joint3D
   */
  class FixedJoint extends Joint3D {
    protected constructor();
  }
  /**
   * @class FixedJoint2D
   * @extends Joint2D
   */
  class FixedJoint2D extends Joint2D {
    protected constructor();
  }
  /**
   * @enum GifEvent
   * @property {number} playBeginEventType
   * @property {number} playEndEventType
   * @property {number} pauseEventType
   * @property {number} resumeEventType
   * @property {number} playKeyFrameEventType
   * @example
   * const imageComponent = this.getSceneObject().getComponent('Image') as APJS.Image;
   * const tex = imageComponent.texture;
   * const emitter = APJS.EventManager.getObjectEmitter(tex);
   * emitter.on(APJS.GifEvent.playEndEventType, this.onPlayEnd, this);
   */
  enum GifEvent {
    playBeginEventType,
    playEndEventType,
    pauseEventType,
    resumeEventType,
    playKeyFrameEventType
  }
  /**
   * @class GifTextureProvider
   */
  class GifTextureProvider extends TextureDelegateProvider {
    /**
     * @description loopCount
     * @type {number}
     */
    get loopCount(): number;
    set loopCount(value: number);
    /**
     * @description fps
     * @type {number}
     */
    get fps(): number;
    set fps(value: number);
    /**
     * @description duration
     * @type {number}
     */
    get duration(): number;
    set duration(value: number);
    /**
     * @description getFrameCount
     * @type {number}
     */
    getFrameCount(): number;
    /**
     * @description getCurrentPlayingFrame
     * @returns {number}
     */
    getCurrentPlayingFrame(): number;
    /**
     * @description playFromStart
     * @returns {void}
     */
    playFromStart(): void;
    /**
     * @description pause
     * @returns {void}
     */
    pause(): void;
    /**
     * @description resume
     * @returns {void}
     */
    resume(): void;
    /**
     * @description seek
     * @param {number} frameIndex
     * @returns {void}
     */
    seek(frameIndex: number): void;
  }
  /**
   * @class GSplatCollider
   * @extends Collider
   */
  class GSplatCollider extends Collider {
    protected constructor();
    /**
     * @description Whether the collider is tangible.
     * @type {boolean}
     */
    get isTangible(): boolean;
    set isTangible(value: boolean);
    /**
     * @description Whether the collider is interactable.
     * @type {boolean}
     */
    get interactable(): boolean;
    set interactable(value: boolean);
  }
  /**
   * @namespace
   * HapticsModule
   * @description Provides haptic feedback related functionality
   */
  namespace HapticsModule {
    /**
     * Triggers device vibration
     * @param duration Vibration duration in milliseconds, range 10-200, default 30
     * @param strength Vibration strength (0-1), default 0.7
     * @param frequency Vibration frequency (0-1), default 0.5
     */
    function triggerVibration(duration?: number, strength?: number, frequency?: number): void;
  }
  /**
   * @class HingeJoint
   * @extends Joint3D
   */
  class HingeJoint extends Joint3D {
    protected constructor();
    /**
     * @description Whether the joint uses limits.
     * @type {boolean}
     */
    get useLimits(): boolean;
    set useLimits(value: boolean);
    /**
     * @description The minimum angle of the joint.
     * @type {number}
     */
    get minAngle(): number;
    set minAngle(value: number);
    /**
     * @description The maximum angle of the joint.
     * @type {number}
     */
    get maxAngle(): number;
    set maxAngle(value: number);
  }
  /**
   * @class HingeJoint2D
   * @extends Joint2D
   */
  class HingeJoint2D extends Joint2D {
    protected constructor();
    /**
     * @description Whether to use angle limits for the hinge joint.
     * @type {boolean}
     */
    get useLimits(): boolean;
    set useLimits(value: boolean);
    /**
     * @description The maximum angle of the hinge joint.
     * @type {number}
     */
    get maxAngle(): number;
    set maxAngle(value: number);
    /**
     * @description The minimum angle of the hinge joint.
     * @type {number}
     */
    get minAngle(): number;
    set minAngle(value: number);
  }
  /**
   * @description Defines local horizontal alignment types for text typesetting, which refers to the horizontal alignment relative to the writing direction. Specifically, when the text is written horizontally, this alignment corresponds to the visually horizontal direction. Conversely, in vertical writing mode, this alignment translates to the visually vertical direction.
   * @enum
   * @property Left - Align to left edge.
   * @property Center - Center horizontally.
   * @property Right - Align to right edge.
   * @property Flush - Stretch to fill container.
   */
  enum HorizontalAlignment {
    Left,
    Center,
    Right,
    Flush
  }
  /**
   * @interface
   * IEvent
   */
  interface IEvent {
    /**
     * @description The type of the event, which can be either a number or a UserEventType.
     */
    get type(): number | UserEventType;
    /**
     * @description Sets the type of the event, which can be a number or a UserEventType.
     */
    set type(value: number | UserEventType);
    /**
     * @description Arguments passed to the event.
     */
    get args(): any[];
    /**
     * @param args - The arguments to be set for the event.
     */
    set args(args: any[]);
  }
  /**
   * @interface
   * IEventEmitter
   */
  interface IEventEmitter {
    /**
     * @description Registers an event listener for a specified event type, invoking the provided callback function when the event is triggered.
     * @param eventType - The type of event to listen for, which can be either a number or a predefined UserEventType.
     * @param callback - A function that will be executed when the event occurs. This function receives an IEvent object as its parameter.
     * @param context - (Optional) The execution context in which the callback function should be called.
     * @example
     * emitter.on(myEventType, this.onMyEventType, this);
     */
    on(eventType: number | UserEventType, callback: (event: IEvent) => void, context?: object): void;
    /**
     * @description Register a callback that will be executed only once for the specified event type.
     * @param eventType - The type of event to listen for. Can be either a number or a UserEventType enum value.
     * @param callback - The function to execute when the event is triggered. It takes an IEvent object as its parameter.
     * @param context - Optional. The context in which the callback will be executed. This can be used to maintain 'this' reference inside the callback.
     * @example
     * emitter.once(myEventType, this.onMyEventType, this);
     */
    once(eventType: number | UserEventType, callback: (event: IEvent) => void, context?: object): void;
    /**
     * @description Unregister an event callback from the robot.
     * @param eventType - The type of event to unregister. Can be a number or a UserEventType enum value.
     * @param callback - The callback function that was previously registered to handle the event.
     * @param context - Optional. The context object that was used when registering the callback.
     * @example
     * emitter.off(myEventType, this.onMyEventType, this);
     */
    off(eventType: number | UserEventType, callback: (event: IEvent) => void, context?: object): void;
    /**
     * Emits a specified event.
     * @param event - The event object to be emitted.
     * @example
     * emitter.emit(APJS.EventManager.createEvent(MY_EVENT_TYPE));
     */
    emit(event: IEvent): void;
  }
  /**
   * @class Image
   * @extends Renderer
   */
  class Image extends Renderer {
    protected constructor();
    /**
     * @description The main texture of the Image component
     * @type {Texture}
     */
    get texture(): Texture;
    set texture(value: Texture);
    /**
     * @description opacity of the image
     * @type {number}
     */
    get opacity(): number;
    set opacity(value: number);
    /**
     * @description base color of the current material
     * @type {Color}
     */
    get color(): Color;
    set color(value: Color);
    /**
     * @description The size of the image, takes effect according to the stretch mode
     * @type {Vector2f}
     */
    get size(): Vector2f;
    set size(value: Vector2f);
    /**
     * @description The pivot point of the Image, the typical range is [0, 1]
     * @type {Vector2f}
     */
    get pivot(): Vector2f;
    set pivot(value: Vector2f);
    /**
     * @description Determine whether to flip the image horizontally
     * @type {boolean}
     */
    get flipX(): boolean;
    set flipX(value: boolean);
    /**
     * @description Determine whether to flip the image vertically
     * @type {boolean}
     */
    get flipY(): boolean;
    set flipY(value: boolean);
    /**
     * @description Determine how the image is stretched to the required size
     * @type {StretchMode}
     */
    get stretchMode(): StretchMode;
    set stretchMode(value: StretchMode);
  }
  /**
   * @class Joint2D
   * @extends DynamicComponent
   */
  class Joint2D extends DynamicComponent {
    protected constructor();
    /**
     * @description The local anchor point on this body.
     * @type {Vector2f}
     */
    get anchor(): Vector2f;
    set anchor(value: Vector2f);
    /**
     * @description The local anchor point on the connected body.
     * @type {Vector2f}
     */
    get connectedAnchor(): Vector2f;
    set connectedAnchor(value: Vector2f);
    /**
     * @description Whether the joint is breakable.
     * @type {boolean}
     */
    get breakable(): boolean;
    set breakable(value: boolean);
    /**
     * @description The maximum force that can be exerted on the connected body.
     * @type {number}
     */
    get breakingForce(): number;
    set breakingForce(value: number);
    /**
     * @description The maximum torque that can be exerted on the connected body.
     * @type {number}
     */
    get breakingTorque(): number;
    set breakingTorque(value: number);
  }
  /**
   * @class Joint3D
   * @extends DynamicComponent
   */
  class Joint3D extends DynamicComponent {
    protected constructor();
    /**
     * @description The force at which the joint breaks.
     * @type {number}
     */
    get breakingForce(): number;
    set breakingForce(value: number);
    /**
     * @description The torque at which the joint breaks.
     * @type {number}
     */
    get breakingTorque(): number;
    set breakingTorque(value: number);
    /**
     * @description The anchor point of the joint.
     * @type {Vector3f}
     */
    get anchor(): Vector3f;
    set anchor(value: Vector3f);
    /**
     * @description The anchor point of the connected body.
     * @type {Vector3f}
     */
    get connectedAnchor(): Vector3f;
    set connectedAnchor(value: Vector3f);
  }
  /**
   * @class
   */
  class JsonAsset {
    protected constructor();
    /**
     * @readonly
     * @description Get the parsed JSON structured data
     * @type {any}
     */
    get json(): any;
  }
  /**
   * @class LayerSet
   */
  class LayerSet {
    /**
     * @description Constructs a LayerSet instance.
     * @param rtti - Optional parameter that can be either a number representing the count of bits. If undefined, defaults to a new `DynamicBitset` with 64 bits.
     * @param mask - Optional parameter representing the mask value for the `DynamicBitset`. Defaults to 0 if not provided.
     */
    constructor(rtti?: number, mask?: number);
    /**
     * @description Clear layer set
     * @example
     * camera.renderLayer = camera.renderLayer.clear();
     */
    clear(bitsNum?: number): this;
    /**
     * @description Retrieves the value of a specific layer.
     * @param layerIndex - The index of the layer to retrieve.
     * @returns A boolean indicating whether the specified layer is active or not.
     * @example
     * if (camera.renderLayer.get(sceneObject.layer)) {
     *   // Do something.
     * }
     */
    get(layerIndex: number): boolean;
    /**
     * @description Set layer
     * @param {number} layer
     * @param {boolean} value
     * @returns {this}
     * @example
     *
     * const LAYER_DEFAULT = 0;
     * const LAYER_1 = 1;
     * //..
     * camera.renderLayer = camera.renderLayer.set(DEFAULT_LAYER, true);
     * camera.renderLayer = camera.renderLayer.set(LAYER_1, true);
     */
    set(layer: number, value: boolean): this;
    /**
     * @description Checks if the layer set is empty.
     * @returns A boolean indicating whether the layer set contains no elements.
     */
    isEmpty(): boolean;
    /**
     * @description Compares the current LayerSet with another LayerSet for equality.
     * @param v - The LayerSet to compare against.
     * @returns A boolean indicating whether the two LayerSets are equal.
     */
    equals(v: LayerSet): boolean;
    /**
     * @description Returns a string representation of the LayerSet object.
     * @returns A string representing the LayerSet object.
     */
    toString(): string;
  }
  /**
   * @class Light
   * @extends Component
   */
  class Light extends Component {
    protected constructor();
    /**
     * @description get current light's Color
     * @type {Color}
     */
    get color(): Color;
    set color(value: Color);
    /**
     * @description get current light's Intensity
     * @type {number}
     */
    get intensity(): number;
    set intensity(value: number);
    /**
     * @description layers that affected by this light
     * @type {LayerSet}
     */
    get renderLayer(): LayerSet;
    set renderLayer(value: LayerSet);
  }
  /**
   * @class LookAt
   * @extends Component
   * @description look at component to decide current object's orientation by target's position or orientation
   */
  class LookAt extends Component {
    protected constructor();
    /**
     * @description Target object transform
     * @type {Transform | null}
     */
    get target(): Transform | null;
    set target(value: Transform | null);
    /**
     * @description Look at mode
     * @type {LookAtMode}
     */
    get mode(): LookAtMode;
    set mode(value: LookAtMode);
    /**
     * @description World up vector mode
     * @type {LookAtWorldUp}
     */
    get worldUp(): LookAtWorldUp;
    set worldUp(value: LookAtWorldUp);
    /**
     * @description Look at aim direction
     * @type {LookAtDirection}
     */
    get directionAim(): LookAtDirection;
    set directionAim(value: LookAtDirection);
    /**
     * @description Look at up direction
     * @type {LookAtDirection}
     */
    get directionUp(): LookAtDirection;
    set directionUp(value: LookAtDirection);
    /**
     * @description Additional offset rotation
     * @type {Vector3f}
     */
    get offsetRotation(): Vector3f;
    set offsetRotation(value: Vector3f);
  }
  /**
   * @description LookAtDirection
   * @enum
   * @property  X - Axis X
   * @property  Y - Axis Y
   * @property  Z - Axis Z
   * @property  NegativeX - Negative Axis X
   * @property  NegativeY - Negative Axis Y
   * @property  NegativeZ - Negative Axis Z
   */
  enum LookAtDirection {
    X,
    Y,
    Z,
    NegativeX,
    NegativeY,
    NegativeZ
  }
  /**
   * @description LookAtMode
   * @enum
   * @property  LookAtDirection - Look at target direction
   * @property  LookAtPoint - Look at target point
   */
  enum LookAtMode {
    LookAtDirection,
    LookAtPoint
  }
  /**
   * @description LookAtWorldUp
   * @enum
   * @property  SceneY - Scene Y
   * @property  TargetY - Target Y
   * @property  ObjectX - Object X
   * @property  ObjectY - Object Y
   * @property  ObjectZ - Object Z
   * @property  SceneX - Scene X
   * @property  SceneZ - Scene Z
   * @property  TargetX - Target X
   * @property  TargetZ - Target Z
   */
  enum LookAtWorldUp {
    SceneY,
    TargetY,
    ObjectX,
    ObjectY,
    ObjectZ,
    SceneX,
    SceneZ,
    TargetX,
    TargetZ
  }
  /**
   * @class Material
   * @extends AObject
   * @description Material. This class exposes all properties from a material, allowing you to animate them. You can also use it to set custom shader properties that can't be accessed through the inspector.
   */
  class Material extends AObject {
    protected constructor();
    /**
     * @description renderQueue
     */
    get renderQueue(): number;
    /**
     * @description Sets the render queue for the material.
     */
    set renderQueue(value: number);
    /**
     * @description Gets the passes for the material.
     */
    get passes(): Pass[];
    /**
     * @description Sets the passes for the material.
     */
    set passes(value: Pass[]);
    /**
     * @description clone
     */
    clone(): Material;
    /**
     * @description Sets a named float value.
     * @param name - The name of the float property.
     * @param value - The float value to set.
     */
    setFloat(name: string, value: number): void;
    /**
     * @description Get a named float value.
     * @param name - The name of the float property.
     */
    getFloat(name: string): number | undefined;
    /**
     * @description Sets a named matrix value.
     * @param name - The name of the matrix property.
     * @param m - The matrix value to set.
     */
    setMatrix(name: string, m: Matrix4x4f): void;
    /**
     * @description Get a named matrix value.
     * @param name - The name of the matrix property.
     */
    getMatrix(name: string): Matrix4x4f | undefined;
    /**
     * @description Sets a named texture value.
     * @param name - The name of the texture property.
     * @param texture - The texture value to set.
     */
    setTexture(name: string, texture: Texture): void;
    /**
     * @description Get a named texture value.
     * @param name - The name of the texture property.
     */
    getTexture(name: string): Texture | null;
    /**
     * @description The main pass of the material. If no passes exist, a new one is created and returned.
     */
    get mainPass(): Pass;
    /**
     * @description Sets the main pass for the material.
     */
    set mainPass(value: Pass);
    /**
     * @description Sets a vector value in the material by its name.
     * @param name - The name of the vector property to set.
     * @param value - The vector value to set, which can be of type Vector2f, Vector3f, or Vector4f.
     */
    setVector(name: string, value: Vector2f | Vector3f | Vector4f): void;
    /**
     * @description Retrieves a vector property by name from the material.
     * @param name - The name of the vector property to retrieve.
     * @returns A Vector2f, Vector3f, or Vector4f object if found; otherwise, undefined.
     */
    getVector(name: string): Vector2f | Vector3f | Vector4f | undefined;
    /**
     * @description Sets the color of a material property by name.
     * @param name - The name of the material property to set the color for.
     * @param color - The Color object containing the RGBA values to be set.
     */
    setColor(name: string, color: Color): void;
    /**
     * @description Retrieves the color associated with a given name from the material's properties.
     * @param name - The name of the property to retrieve the color from.
     * @returns A Color object if the property exists and is a Vector4f, otherwise undefined.
     */
    getColor(name: string): Color | undefined;
  }
  /**
   * @class Matrix3x3f
   * A standard 3x3 transformation matrix.（<b>column major</b>]
   */
  class Matrix3x3f {
    /**
     * Constructs a new 3x3 matrix with default values.
     */
    constructor();
    /**
     * @description Constructs a 3x3 matrix with optional initial values.
     * @param m0 - The value at position (0,0).
     * @param m1 - The value at position (0,1).
     * @param m2 - The value at position (0,2).
     * @param m3 - The value at position (1,0).
     * @param m4 - The value at position (1,1).
     * @param m5 - The value at position (1,2).
     * @param m6 - The value at position (2,0).
     * @param m7 - The value at position (2,1).
     * @param m8 - The value at position (2,2).
     */
    constructor(m0?: number, m1?: number, m2?: number, m3?: number, m4?: number, m5?: number, m6?: number, m7?: number, m8?: number);
    /**
     * @description Retrieves the value at the specified row and column in the 3x3 matrix.
     * @param row - The row index (0-based) of the element to retrieve.
     * @param column - The column index (0-based) of the element to retrieve.
     * @returns The value at the specified row and column.
     */
    get(row: number, column: number): number;
    /**
     * @description Sets the value at a specified row and column in the matrix.
     * @param row - The row index (0-based).
     * @param column - The column index (0-based).
     * @param value - The value to set at the specified position.
     * @returns This instance of Matrix3x3f for method chaining.
     */
    set(row: number, column: number, value: number): this;
    /**
     * @description The first column of the matrix.
     */
    get column0(): Vector3f;
    /**
     * @description Sets the values of column 0 in the Matrix3x3f using a Vector3f.
     */
    set column0(value: Vector3f);
    /**
     * @description The second column of the matrix.
     */
    get column1(): Vector3f;
    /**
     * @description Sets the values of the first column in the 3x3 matrix.
     */
    set column1(value: Vector3f);
    /**
     * @description The third column of the matrix.
     */
    get column2(): Vector3f;
    /**
     * @description Sets the values of the second column in the 3x3 matrix.
     */
    set column2(value: Vector3f);
    /**
     * @description Compares this matrix with another matrix for equality.
     * This method performs a direct value comparison of the elements in both matrices.
     * @param other - The Matrix3x3f object to compare with this matrix.
     * @returns A boolean indicating whether the two matrices are equal.
     */
    equals(other: Matrix3x3f): boolean;
    /**
     * @description Returns a clone of the current Matrix3x3f instance.
     * @returns - A new Matrix3x3f object with the same data as the original.
     */
    clone(): Matrix3x3f;
    /**
     * @description Returns a string representation of the Matrix3x3f, with each element formatted to five decimal places.
     * @returns - The string representation of the matrix.
     */
    toString(): string;
    /**
     * @description Adds the specified matrix to this matrix and returns the result.
     * @param other - The matrix to add to this matrix.
     * @returns This matrix after addition.
     */
    add(other: Matrix3x3f): this;
    /**
     * @description Returns the result of subtracting another 3x3 matrix from this matrix.
     * @param other - The matrix to be subtracted from this matrix.
     * @returns This matrix after performing the subtraction.
     */
    subtract(other: Matrix3x3f): this;
    /**
     * @description Multiplies the current matrix by another matrix or a scalar.
     * @param other - The matrix or scalar to multiply with.
     * @returns The modified instance of the current matrix after multiplication.
     */
    multiply(other: Matrix3x3f | number): this;
    /**
     * @description Multiplies each element of the matrix by a given scalar.
     * @param scalar - The scalar value to multiply with each element of the matrix.
     * @returns This instance of Matrix3x3f after performing the scalar multiplication.
     */
    multiplyScalar(scalar: number): this;
    /**
     * @description Divides each element of the current matrix by the corresponding element of another matrix.
     * @param other - The matrix to divide by.
     * @returns This matrix after performing the division.
     */
    divide(other: Matrix3x3f): this;
    /**
     * @description Returns the inverse of the matrix.
     * @returns The current instance with its values set to the inverse of the original matrix.
     */
    inverse(): this;
    /**
     * @description Returns the transpose of this matrix.
     * @returns - The transposed matrix.
     */
    transpose(): this;
  }
  /**
   * @class Matrix4x4f
   * A standard 4x4 transformation matrix.（<b>column major</b>]
   * A transformation matrix can perform arbitrary linear 3D transformations
   * (i.e. translation, rotation, scale, shear etc.) and perspective transformations using homogenous coordinates.
   */
  class Matrix4x4f {
    /**
     * Constructs a new 4x4 matrix with default values.
     */
    constructor();
    /**
     * @description Constructs a 4x4 matrix with optional initial values.
     * @param m0 - Value at row 0, column 0 of the matrix.
     * @param m1 - Value at row 0, column 1 of the matrix.
     * @param m2 - Value at row 0, column 2 of the matrix.
     * @param m3 - Value at row 0, column 3 of the matrix.
     * @param m4 - Value at row 1, column 0 of the matrix.
     * @param m5 - Value at row 1, column 1 of the matrix.
     * @param m6 - Value at row 1, column 2 of the matrix.
     * @param m7 - Value at row 1, column 3 of the matrix.
     * @param m8 - Value at row 2, column 0 of the matrix.
     * @param m9 - Value at row 2, column 1 of the matrix.
     * @param m10 - Value at row 2, column 2 of the matrix.
     * @param m11 - Value at row 2, column 3 of the matrix.
     * @param m12 - Value at row 3, column 0 of the matrix.
     * @param m13 - Value at row 3, column 1 of the matrix.
     * @param m14 - Value at row 3, column 2 of the matrix.
     * @param m15 - Value at row 3, column 3 of the matrix.
     */
    constructor(m0?: number, m1?: number, m2?: number, m3?: number, m4?: number, m5?: number, m6?: number, m7?: number, m8?: number, m9?: number, m10?: number, m11?: number, m12?: number, m13?: number, m14?: number, m15?: number);
    /**
     * @description Retrieves the value at the specified row and column in the matrix.
     * @param row - The row index of the desired element (0-based).
     * @param column - The column index of the desired element (0-based).
     * @returns The value at the specified row and column.
     */
    get(row: number, column: number): number;
    /**
     * @description Sets the value at a specified row and column in the matrix.
     * @param row - The row index (0-based).
     * @param column - The column index (0-based).
     * @param value - The value to set at the specified position.
     * @returns This instance of Matrix4x4f for method chaining.
     */
    set(row: number, column: number, value: number): this;
    /**
     * @description Sets the values of a specified row in the matrix using a Vector4f.
     * @param row - The index of the row to set [0-3].
     * @param v - A Vector4f containing the values (c0, c1, c2, c3) for the row.
     * @returns This instance of Matrix4x4f with the updated row values.
     */
    setRow(row: number, v: Vector4f): this;
    /**
     * @description Sets the values of a specified column in the matrix.
     * @param col - The index of the column to set (0-3).
     * @param v - A Vector4f object containing the new values for the column (r0, r1, r2, r3).
     * @returns This instance of Matrix4x4f with the updated column values.
     */
    setColumn(col: number, v: Vector4f): this;
    /**
     * @description The first column of the matrix.
     */
    get column0(): Vector4f;
    /**
     * @description Sets the first column of the 4x4 matrix with the provided Vector4f values.
     */
    set column0(value: Vector4f);
    /**
     * @description The second column of the matrix.
     */
    get column1(): Vector4f;
    /**
     * @description Sets the values of the first column in the 4x4 matrix.
     */
    set column1(value: Vector4f);
    /**
     * @description The third column of the matrix.
     */
    get column2(): Vector4f;
    /**
     * @description Sets the second column of the 4x4 matrix with the provided Vector4f values.
     */
    set column2(value: Vector4f);
    /**
     * @description The fourth column of the matrix.
     * @returns {Vector4f} A Vector4f representing the fourth column of the matrix.
     */
    get column3(): Vector4f;
    /**
     * @description Sets the third column of the 4x4 matrix with the provided Vector4f values.
     */
    set column3(value: Vector4f);
    /**
     * @description Compares this matrix with another matrix for equality.
     * This method performs a direct value comparison of the elements in both matrices.
     * @param other - The Matrix4x4f object to compare with this matrix.
     * @returns A boolean indicating whether the two matrices are equal.
     */
    equals(other: Matrix4x4f): boolean;
    /**
     * @description Returns a clone of the current Matrix4x4f instance.
     * @returns - A new Matrix4x4f object with the same data as the original.
     */
    clone(): Matrix4x4f;
    /**
     * @description Returns a string representation of the Matrix4x4f, with each element formatted to five decimal places.
     * @returns - The string representation of the matrix.
     */
    toString(): string;
    /**
     * @description Adds the specified matrix to this matrix and returns the result.
     * @param other - The matrix to add to this matrix.
     * @returns This matrix after addition.
     */
    add(other: Matrix4x4f): this;
    /**
     * @description Subtracts the provided matrix from this matrix and returns the result.
     * @param other - The matrix to subtract from this matrix.
     * @returns This matrix after subtraction.
     */
    subtract(other: Matrix4x4f): this;
    /**
     * @description Multiplies the current matrix by another matrix or a scalar.
     * @param other - The matrix or scalar to multiply with.
     * @returns The modified instance of the current matrix after multiplication.
     */
    multiply(other: Matrix4x4f | number): this;
    /**
     * @description Multiplies each element of the matrix by a given scalar.
     * @param scalar - The scalar value to multiply with each element of the matrix.
     * @returns This instance of Matrix4x4f after performing the scalar multiplication.
     */
    multiplyScalar(scalar: number): this;
    /**
     * @description Divides each element of the current matrix by the corresponding element of another matrix.
     * @param other - The matrix to divide by.
     * @returns This matrix after performing the division.
     */
    divide(other: Matrix4x4f): this;
    /**
     * @description Returns an Euler angle representation of this matrix's rotation.
     * @returns - A vector containing the Euler angles (pitch, yaw, roll) in radians.
     */
    getEulerAngles(): Vector3f;
    /**
     * @description Returns the inverse of the matrix.
     * @returns - The current instance of Matrix4x4f with its values set to the inverse of the original matrix.
     */
    inverse(): this;
    /**
     * @description Multiplies the given direction vector by this matrix and returns the resulting vector.
     * @param dir - The direction vector to be multiplied.
     * @returns A new Vector3f representing the result of the multiplication.
     */
    multiplyDirection(dir: Vector3f): Vector3f;
    /**
     * @description Multiplies the given 3D point by this 4x4 matrix and returns the resulting point.
     * @param point - The 3D point to be multiplied by the matrix.
     * @returns A new Vector3f representing the result of the multiplication.
     */
    multiplyPoint(point: Vector3f): Vector3f;
    /**
     * @description Multiplies the given vector by this 4x4 matrix and returns the resulting vector.
     * @param vec - A 4-dimensional vector (Vector4f) to be multiplied by the matrix.
     * @returns The resulting 4-dimensional vector after multiplication.
     */
    multiplyVector(vec: Vector4f): Vector4f;
    /**
     * @description Returns the transpose of this matrix.
     * @returns - The transposed matrix.
     */
    transpose(): this;
    /**
     * @description Sets the translation component of the matrix using a Vector3f.
     * @param v - The translation vector to be applied.
     * @returns This instance of Matrix4x4f with the updated translation.
     */
    setTranslate(v: Vector3f): this;
    /**
     * @description Translates the matrix by a given vector.
     * @param vec - The translation vector to apply.
     * @returns This matrix after applying the translation.
     */
    translate(vec: Vector3f): this;
    /**
     * @description Sets the scale of the matrix using a Vector3f.
     * @param v - A Vector3f representing the scaling factors along the x, y, and z axes.
     * @returns The current instance of Matrix4x4f with the updated scale values.
     */
    setScale(v: Vector3f): this;
    /**
     * @description Scales the matrix by the components of the given vector.
     * @param vec - A Vector3f object representing the scaling factors along each axis.
     * @returns The modified Matrix4x4f instance.
     */
    scale(vec: Vector3f): this;
    /**
     * @description Sets the matrix to a rotation that aligns the vector `from` to the vector `to`.
     * @param from - The initial vector.
     * @param to - The target vector.
     * @returns This matrix with the applied rotation.
     */
    setFromToRotation(from: Vector3f, to: Vector3f): this;
    /**
     * @description Decomposes the matrix into its translation, rotation, and scale components.
     * @param translation - The vector to store the translation component.
     * @param rotation - The quaternion to store the rotation component.
     * @param scale - The vector to store the scale component.
     */
    getDecompose(translation: Vector3f, rotation: Quaternionf, scale: Vector3f): void;
    /**
     * @description Composes the matrix by setting its translation, rotation, and scale (TRS).
     * @param translation - The translation vector to apply.
     * @param rotation - The quaternion representing the rotation to apply.
     * @param scale - The scaling vector to apply.
     * @returns This instance of Matrix4x4f with the applied transformations.
     */
    compose(translation: Vector3f, rotation: Quaternionf, scale: Vector3f): this;
    /**
     * @description Approximate comparison of the two Matrix4x4f matrices by comparing the value of each dimension with a specified tolerance.
     * @param mat1 - The first Matrix4x4f to compare.
     * @param mat2 - The second Matrix4x4f to compare.
     * @param dist - The tolerance value for comparison.
     * @returns A boolean indicating whether the two matrices are approximately equal within the given tolerance.
     */
    static compareApproximately(mat1: Matrix4x4f, mat2: Matrix4x4f, dist: number): boolean;
    /**
     * @description Generates a new transformation matrix that orients an object to look at a specified target.
     * @param eye - The position of the viewer/camera.
     * @param center - The position of the target to look at.
     * @param up - The upward direction in the world, typically (0, 1, 0).
     * @returns A new Matrix4x4f representing the transformation that orients an object to look from 'eye' towards 'center'.
     */
    static lookAt(eye: Vector3f, center: Vector3f, up: Vector3f): Matrix4x4f;
    /**
     * @description Returns a new 4x4 matrix with the specified Euler angles (in radians).
     * @param euler - A Vector3f representing the Euler angles.
     * @returns A new Matrix4x4f instance constructed from the given Euler angles.
     */
    static makeFromEulerAngles(euler: Vector3f): Matrix4x4f;
    /**
     * @description Returns a new 4x4 matrix with the specified rotation.
     * @param rotation - A Quaternionf representing the desired rotation.
     * @returns A new Matrix4x4f instance with the applied rotation.
     */
    static makeFromRotation(rotation: Quaternionf): Matrix4x4f;
    /**
     * @description Returns a new 4x4 matrix with the specified scaling factors.
     * @param scale - A Vector3f representing the scaling factors along the x, y, and z axes.
     * @returns A new Matrix4x4f instance with the applied scaling.
     */
    static makeFromScale(scale: Vector3f): Matrix4x4f;
    /**
     * @description Returns a new 4x4 matrix with the specified translation applied.
     * @param translation - A Vector3f representing the translation to apply.
     * @returns A new Matrix4x4f with the given translation.
     */
    static makeFromTranslation(translation: Vector3f): Matrix4x4f;
    /**
     * @description Generates a new orthographic projection matrix using the provided arguments.
     * @param left - The coordinate for the left vertical clipping plane.
     * @param right - The coordinate for the right vertical clipping plane.
     * @param bottom - The coordinate for the bottom horizontal clipping plane.
     * @param top - The coordinate for the top horizontal clipping plane.
     * @param zNear - The distance to the near depth clipping plane. This value is negative if the plane is behind the viewer.
     * @param zFar - The distance to the far depth clipping plane. This value is negative if the plane is behind the viewer.
     * @returns A new orthographic projection matrix as a Matrix4x4f object.
     */
    static orthographic(left: number, right: number, bottom: number, top: number, zNear: number, zFar: number): Matrix4x4f;
    /**
     * @description Generates a perspective projection matrix using the provided field of view, aspect ratio, and near/far clipping planes.
     * @param fovY - The vertical field of view angle in degrees.
     * @param aspect - The aspect ratio (width divided by height) of the viewport.
     * @param zNear - The distance to the near clipping plane.
     * @param zFar - The distance to the far clipping plane.
     * @returns A new Matrix4x4f representing the perspective projection matrix.
     */
    static perspective(fovY: number, aspect: number, zNear: number, zFar: number): Matrix4x4f;
  }
  /**
   * @class Mesh.
   */
  class Mesh extends AObject {
    protected constructor();
    /**
     * @description Gets the axis-aligned bounding box (AABB) of the mesh.
     * @returns The bounding box of the mesh.
     */
    get boundingBox(): AABB;
    /**
     * @description Sets the bounding box of the mesh using an Axis-Aligned Bounding Box (AABB).
     */
    set boundingBox(aabb: AABB);
    /**
     * @description Retrieves the vertex attributes of the mesh.
     * @returns An array of VertexAttributeDesc objects representing the vertex attributes.
     */
    getVertexAttributes(): VertexAttributeDesc[];
    /**
     * @description Retrieves the number of vertices in the mesh.
     * @returns The count of vertices as a number.
     */
    getVertexCount(): number;
    /**
     * @description Retrieves the topology of the mesh by getting the primitive type from the first SubMesh.
     * @returns The topology of the mesh.
     */
    getTopology(): MeshTopology;
    /**
     * @description Retrieves the vertices of the mesh.
     * @returns {Float32Array} - An array containing the vertex data of the mesh.
     */
    getVertices(): Float32Array;
    /**
     * @description Retrieves the triangles that make up the mesh.
     * @returns {Uint16Array} - An array of 16-bit unsigned integers representing the indices of the vertices that form the triangles.
     */
    getTriangles(): Uint16Array;
  }
  /**
   * @class MeshCollider
   * @extends Collider
   */
  class MeshCollider extends Collider {
    protected constructor();
    /**
     * @description Whether to use convex hull
     * @type {boolean}
     */
    get convex(): boolean;
    set convex(value: boolean);
  }
  /**
   * @class MeshRenderer
   * @description class for the mesh renderer
   */
  class MeshRenderer extends Renderer {
    protected constructor();
    /**
     * @description Retrieves the mesh associated with the MeshRenderer.
     * @returns The mesh object.
     */
    get mesh(): Mesh;
    /**
     * @description Sets the mesh for the renderer.
     */
    set mesh(value: Mesh);
    /**
     * @description Gets the first shared material used by the MeshRenderer.
     */
    get mainMaterial(): Material | null;
    /**
     * @description Sets the main material for the MeshRenderer.
     */
    set mainMaterial(value: Material | null);
    /**
     * @description Retrieves the main pass from the object's shared material.
     * @returns The first pass of the shared material, or null if no passes are available.
     */
    get mainPass(): Pass | null;
    /**
     * @description Retrieves the axis-aligned bounding box (AABB) for this mesh renderer.
     * @returns The axis-aligned bounding box representing the bounds of the mesh.
     */
    getBoundingBox(): AABB;
  }
  /**
   * @description Represents the topology of a mesh, defining how vertices are connected to form primitives.
   * @enum
   * @property Points Each vertex is a separate point.
   * @property Lines Each pair of consecutive vertices forms a line segment.
   * @property LineLoop A series of lines where each vertex connects to the next and the last vertex connects back to the first.
   * @property LineStrip A series of connected line segments where each vertex (except the first) uses the previous vertex as an endpoint.
   * @property Triangles Each set of three consecutive vertices forms a triangle.
   * @property TriangleStrip A series of triangles where each new vertex (after the first two) forms a triangle with the previous two vertices.
   * @property TriangleFan A series of triangles where each new vertex (after the first two) forms a triangle with the first vertex and the previous vertex.
   * @property Unknown The mesh topology is unknown or not specified.
   */
  enum MeshTopology {
    Points,
    Lines,
    LineLoop,
    LineStrip,
    Triangles,
    TriangleStrip,
    TriangleFan,
    Unknown
  }
  /**
   * @class MorpherComponent
   * @extends Component
   * @description morpher component
   */
  class MorpherComponent extends Component {
    constructor();
    /**
     * @description Whether to calculate normal
     * @type {boolean}
     */
    get calculateNormal(): boolean;
    set calculateNormal(value: boolean);
    /**
     * @description Whether this component has a weight for the blend shape with matching name.
     * @param {string} name
     * @returns {boolean}
     */
    hasBlendShapeWeight(name: string): boolean;
    /**
     * @description Get weight value of blendShape channel, return 0 if not found
     * @param {string} name
     * @returns {number}
     */
    getBlendShapeWeight(name: string): number;
    /**
     * @description Set weight value of blendShape channel
     * @param {string} name
     * @param {number} weight
     * @returns {void}
     */
    setBlendShapeWeight(name: string, weight: number): void;
    /**
     * @description Reset blendShape weights to 0
     * @returns {void}
     */
    clearBlendShapeWeights(): void;
  }
  /**
   * @enum Mp4Event
   * @property {number} PlayBegin
   * @property {number} PlayEnd
   * @property {number} Pause
   * @property {number} Resume
   * @property {number} KeyFrameInSecond
   * @property {number} Stop
   * @example
   * const imageComponent = this.getSceneObject().getComponent('Image') as APJS.Image;
   * const tex = imageComponent.texture;
   * const emitter = APJS.EventManager.getObjectEmitter(tex);
   * emitter.on(APJS.Mp4Event.PlayEnd, this.onPlayEnd, this);
   */
  enum Mp4Event {
    PlayBegin,
    PlayEnd,
    Pause,
    Resume,
    KeyFrameInSecond,
    Stop
  }
  /**
   * @class Mp4TextureProvider
   */
  class Mp4TextureProvider extends TextureDelegateProvider {
    /**
     * @description Gets the number of times the video will loop. -1 means infinite loop.
     */
    get loopCount(): number;
    /**
     * @description Sets the number of times the video will loop.
     */
    set loopCount(value: number);
    /**
     * @readonly
     * @description duration
     * @type {number}
     */
    get duration(): number;
    /**
     * @readonly
     * @description currentTime
     * @type {number}
     */
    get currentTime(): number;
    /**
     * @description Starts video playback from the beginning.
     */
    play(): void;
    /**
     * @description Pauses video playback at the current position.
     */
    pause(): void;
    /**
     * @description Resumes paused video playback.
     */
    resume(): void;
    /**
     * @description Stops video playback and resets to initial state.
     */
    stop(): void;
  }
  /**
   * @description Device OS
   * @enum
   * @property Android - Android system.
   * @property IOS - IOS system.
   * @property Windows - Windows system
   * @property MacOS - MacOS system.
   * @property Linux - Linux system.
   * @property HarmonyOS - HarmonyOS system.
   */
  enum OS {
    Android = 0,
    IOS = 1,
    Windows = 2,
    MacOS = 3,
    Linux = 4,
    HarmonyOS = 5
  }
  /**
   * @class Pass
   * @extends AObject
   * @description Pass
   */
  class Pass extends AObject {
    protected constructor();
    /**
     * @description Indicates whether depth testing is enabled for the pass.
     */
    get depthTest(): boolean;
    /**
     * @description Sets the depth test state for the render pass.
     */
    set depthTest(value: boolean);
    /**
     * @description Indicates whether depth writing is enabled for the pass.
     */
    get depthWrite(): boolean;
    /**
     * @description Sets the depth write state for the pass.
     */
    set depthWrite(value: boolean);
    /**
     * @description The depth function used for depth comparison in the rendering pass.
     */
    get depthFunction(): DepthFunction;
    /**
     * @description Sets the depth function for the pass.
     */
    set depthFunction(value: DepthFunction);
    /**
     * @description The stencil state of the pass.
     */
    get stencilState(): StencilState;
    /**
     * @description Sets the stencil state for the pass.
     */
    set stencilState(value: StencilState);
    /**
     * @description The color mask for the first attachment in the render state's color blend settings.
     */
    get colorMask(): ColorMask;
    /**
     * @description Sets the color mask for the pass.
     */
    set colorMask(value: ColorMask);
    /**
     * @description The culling mode for the rendering pass, which determines how triangles are culled based on their orientation.
     */
    get cullMode(): CullMode;
    /**
     * @description Sets the cull mode for the pass.
     */
    set cullMode(value: CullMode);
  }
  /**
   * @class Physic2D
   */
  class Physics2D {
    /**
     * 2d world gravity
     * @description gravity acceleration
     * @default new Vector2f(0, -9.8)
     * @type {Vector2f}
     */
    static get gravity(): Vector2f;
    static set gravity(value: Vector2f);
    /**
     * 2d world time speed
     * @description time speed of 2d world
     * @default 1.0
     * @type {number}
     */
    static get timeSpeed(): number;
    static set timeSpeed(value: number);
    /**
     * @description Casts a ray in 2D space and returns information about the hits.
     * @param ray The ray to cast.
     * @param maxDistance The maximum distance the ray should cast.
     * @param nearest Whether to return the nearest hit or all hits.
     * @param layerMask The layer mask to filter hits.
     * @returns An array of RaycastHit2D objects representing the hits.
     */
    static raycast2D(ray: Ray, maxDistance: number, nearest: boolean, layerMask?: LayerSet): RaycastHit2D[];
  }
  /**
   * @class Physics3D
   */
  class Physics3D {
    /**
     * @description 3d world gravity
     * @type {Vector3f}
     */
    static get gravity(): Vector3f;
    static set gravity(value: Vector3f);
    /**
     * @description gravity multiplayer
     * @type {number}
     */
    static get gravityFactor(): number;
    static set gravityFactor(value: number);
    /**
     * @description 3d physics simulation timeScale
     * @type {number}
     */
    static get timeScale(): number;
    static set timeScale(value: number);
    static raycast(ray: Ray, maxDistance: number, nearest: boolean, layerMask?: LayerSet): RaycastHit3D[];
  }
  /**
   * @class PhysicsMaterial
   * @extends AObject
   * @description physics material
   */
  class PhysicsMaterial extends AObject {
    protected constructor();
    /**
     * @description Set the Static Friction
     * @type {number}
     */
    get staticFriction(): number;
    set staticFriction(value: number);
    /**
     * @description Set the Dynamic Friction
     * @type {number}
     */
    get dynamicFriction(): number;
    set dynamicFriction(value: number);
    /**
     * @description Set the Bounciness(also elasticity)
     * @type {number}
     */
    get bounciness(): number;
    set bounciness(value: number);
  }
  /**
   * @class PointJoint
   * @extends Joint3D
   */
  class PointJoint extends Joint3D {
    protected constructor();
  }
  /**
   * @class PointLight
   * @extends Light
   */
  class PointLight extends Light {
    constructor();
    /**
     * @description get and set current point light's Attenuation Range
     * @type {number}
     */
    get attenuationRange(): number;
    set attenuationRange(value: number);
  }
  /**
   * @class PolygonCollider2D
   * @extends Collider2D
   */
  class PolygonCollider2D extends Collider2D {
    protected constructor();
  }
  /**
   * @class Prefab
   * @description
   * This is the type of Prefab
   * <br/>Prefabs allow you to create reusable SceneObject instances
   * @extends AObject
   */
  class Prefab extends AObject {
    protected constructor();
    /**
     * Instantiates a scene object.
     * @param {SceneObject} parent The parent scene object of the instantiated scene object.
     * @returns {SceneObject} The instantiated scene object.
     */
    instantiate(parent: SceneObject): SceneObject | null;
  }
  /**
   * @class Provider
   * @description base Provider for texture and mesh
   * @inheritdoc
   */
  class Provider {
  }
  /**
   * @class Quaternionf
   * <br/> Quaternions are used to represent rotations.
   * <br/> A quaternion is a four-tuple of real numbers {x,y,z,w}.
   * <br/> A quaternion is a mathematically convenient alternative to the euler angle representation.
   * <br/> You can interpolate a quaternion without experiencing gimbal lock.
   * <br/> You can also use a quaternion to concatenate a series of rotations into a single representation.
   * @example
   * print(Quaternionf.dot(transform.localRotation, Quaternionf.identity()));
   */
  class Quaternionf {
    /**
     * @description Represents the x component of the quaternion, which is a part of the Quaternionf object used to describe rotations in 3D space.
     */
    x: number;
    /**
     * @description Represents the y component of the quaternion in a Quaternionf object.
     */
    y: number;
    /**
     * @description Represents the z component of the quaternion in a Quaternionf object.
     */
    z: number;
    /**
     * @description The w component of the quaternion, representing the scalar part in a 4-dimensional space.
     */
    w: number;
    /**
     * Constructs a new instance of the Quaternionf class.
     */
    constructor();
    /**
     * Constructs a new Quaternionf instance.
     * @param x - The x component of the quaternion (optional).
     * @param y - The y component of the quaternion (optional).
     * @param z - The z component of the quaternion (optional).
     * @param w - The w component of the quaternion (optional).
     */
    constructor(x?: number, y?: number, z?: number, w?: number);
    /**
     * @description Sets the quaternion data with the specified x, y, z, and w components.
     * @param x - The x component of the quaternion.
     * @param y - The y component of the quaternion.
     * @param z - The z component of the quaternion.
     * @param w - The w component of the quaternion.
     * @returns This instance of Quaternionf with updated values.
     */
    set(x: number, y: number, z: number, w: number): this;
    /**
     * @description Creates and returns a clone of the current Quaternionf instance.
     * @returns A new Quaternionf object with the same values as the original.
     */
    clone(): Quaternionf;
    /**
     * @description Returns the dot product of the current quaternion with another quaternion.
     * @param other - The quaternion to calculate the dot product with.
     * @returns The dot product as a number.
     */
    dot(other: Quaternionf): number;
    /**
     * @description Returns whether this quaternion is equal to the specified quaternion.
     * @param other - The quaternion to compare with.
     * @returns A boolean indicating whether the two quaternions are equal.
     */
    equals(other: Quaternionf): boolean;
    /**
     * @description Returns the rotation angle of the quaternion.
     * @returns The rotation angle in radians.
     */
    getAngle(): number;
    /**
     * @description Returns the rotation axis of the quaternion.
     * @returns The normalized vector representing the axis of rotation.
     */
    getAxis(): Vector3f;
    /**
     * @description Returns an inverted version of the Quaternionf by negating its x, y, and z components.
     * @returns The current instance of Quaternionf with inverted values.
     */
    inverse(): this;
    /**
     * @description Multiplies this quaternion by another quaternion `other` and updates the current quaternion with the result.
     * @param other - The quaternion to multiply with.
     * @returns This quaternion after multiplication.
     */
    multiply(other: Quaternionf): Quaternionf;
    /**
     * @description Returns the result of rotating direction vector `other` by this quaternion.
     * @param other - The vector to be rotated.
     * @returns A new `Vector3f` representing the rotated vector.
     */
    multiplyVector(other: Vector3f): Vector3f;
    /**
     * @description Normalizes the Quaternionf, ensuring it has a unit length.
     * If the quaternion's length is zero, it sets the quaternion to (0, 0, 0, 1).
     * Otherwise, it scales the quaternion components so that its length becomes one.
     * @returns The normalized Quaternionf instance.
     */
    normalize(): Quaternionf;
    /**
     * @description Converts the quaternion to an Euler angle representation in radians.
     * @returns A vector containing the Euler angles (pitch, yaw, roll) in radians.
     */
    toEulerAngles(): Vector3f;
    /**
     * @description Returns a string representation of the vector.
     * @returns A string representation of the vector.
     */
    toString(): string;
    /**
     * @description Returns a new quaternion with the specified angle and axis.
     * @param angle - The rotation angle in radians.
     * @param axis - The axis of rotation as a Vector3f object.
     * @returns A new Quaternionf representing the rotation.
     */
    static makeFromAngleAxis(angle: number, axis: Vector3f): Quaternionf;
    /**
     * @description Returns a new quaternion using the Euler angles provided in `eulerVec` (in radians).
     * @param eulerVec - A Vector3f representing the Euler angles in radians.
     * @returns A new Quaternionf created from the given Euler angles.
     */
    static makeFromEulerAngles(eulerVec: Vector3f): Quaternionf;
    /**
     * @description Returns the identity quaternion.
     * @returns The identity quaternion represented as a Quaternionf object.
     */
    static identity(): Quaternionf;
    /**
     * @description Returns a new Quaternionf linearly interpolated between `a` and `b`.
     * @param a - The first Quaternionf object.
     * @param b - The second Quaternionf object.
     * @param t - The interpolation factor, typically ranging from 0 to 1.
     * @returns A new Quaternionf representing the linear interpolation between `a` and `b`.
     */
    static lerp(a: Quaternionf, b: Quaternionf, t: number): Quaternionf;
    /**
     * @description Returns a new Quaternionf that represents the rotation needed to look in the direction of the `forward` vector with the specified `up` vector.
     * @param forward - The forward direction vector.
     * @param up - The upward direction vector.
     * @returns A new Quaternionf representing the orientation.
     */
    static lookAt(forward: Vector3f, up: Vector3f): Quaternionf;
    /**
     * @description Returns a rotation Quaternionf that represents the shortest arc rotation from direction vector `from` to direction vector `to`.
     * @param from - The initial direction vector.
     * @param to - The target direction vector.
     * @returns A Quaternionf representing the rotation from `from` to `to`.
     */
    static rotationFromTo(from: Vector3f, to: Vector3f): Quaternionf;
    /**
     * @description Returns a new Quaternionf spherically linearly interpolated between `a` and `b`.
     * @param a - The starting Quaternionf.
     * @param b - The ending Quaternionf.
     * @param t - The interpolation factor, typically ranging from 0 to 1.
     * @returns A new Quaternionf representing the spherical linear interpolation between `a` and `b`.
     */
    static slerp(a: Quaternionf, b: Quaternionf, t: number): Quaternionf;
    /**
     * @description Returns the angle between two quaternions `a` and `b`.
     * @param a - The first quaternion.
     * @param b - The second quaternion.
     * @returns The angle in radians between the two quaternions.
     */
    static angleBetween(a: Quaternionf, b: Quaternionf): number;
  }
  /**
   * @class Ray
   */
  class Ray {
    /**
     * Constructs a new instance of the Ray class.
     */
    constructor();
    /**
     * Constructs a new Ray object.
     * @param min - The starting point of the ray as a 3D vector.
     * @param max - (Optional) The endpoint of the ray as a 3D vector. If not provided, the ray is considered to be infinite in length from the starting point.
     */
    constructor(min: Vector3f, max?: Vector3f);
    /**
     * @description Gets the origin point of the ray.
     * @returns The origin point as a Vector3f object.
     */
    get origin(): Vector3f;
    /**
     * @description Sets the origin of the ray to the specified Vector3f value.
     */
    set origin(value: Vector3f);
    /**
     * @description Normalized vector representing the direction of the ray.
     */
    get direction(): Vector3f;
    /**
     * @description Sets the direction of the ray using a 3D vector.
     */
    set direction(value: Vector3f);
    /**
     * @description Creates and returns a deep copy of the current ray.
     * @returns A new instance of Ray with the same origin and direction as the original.
     */
    clone(): Ray;
    /**
     * @description Compares this ray with another ray for equality.
     * @param other - The ray to compare with.
     * @returns A boolean indicating whether the two rays are equal.
     */
    equals(other: Ray): boolean;
    /**
     * @description Returns a string representation of the Ray object.
     * @returns A string describing the Ray object.
     */
    toString(): string;
  }
  class RaycastHit2D {
    /**
     * @description The point of contact in world space.
     * @type {Vector2f}
     */
    readonly point: Vector2f;
    /**
     * @description The normal of contact in world space.
     * @type {Vector2f}
     */
    readonly normal: Vector2f;
    /**
     * @description The collider involved in the collision.
     * @type {Collider2D | null}
     */
    readonly collider: Collider2D | null;
    /**
     * @description The other object involved in the collision.
     * @type {SceneObject | null}
     */
    readonly colliderObject: SceneObject | null;
    constructor(point: Vector2f, normal: Vector2f, collider: Collider2D | null, colliderObject: SceneObject | null);
  }
  class RaycastHit3D {
    /**
     * @description The point of contact in world space.
     * @type {Vector3f}
     */
    readonly point: Vector3f;
    /**
     * @description The normal of contact in world space.
     * @type {Vector3f}
     */
    readonly normal: Vector3f;
    /**
     * @description The collider involved in the collision.
     * @type {Collider | null}
     */
    readonly collider: Collider | null;
    /**
     * @description The object that the collider belongs to.
     * @type {SceneObject | null}
     */
    readonly colliderObject: SceneObject | null;
    constructor(point: Vector3f, normal: Vector3f, collider: Collider | null, colliderObject: SceneObject | null);
  }
  /**
   * @class Rect
   */
  class Rect {
    /**
     * Represents the x-coordinate of a rectangle's position.
     */
    x: number;
    /**
     * Represents the y-coordinate of a rectangle's position or dimension.
     */
    y: number;
    /**
     * Represents the width of the rectangle.
     */
    width: number;
    /**
     * Represents the height of the rectangle.
     */
    height: number;
    /**
     * @description Constructs a new Rect instance.
     * @param x - The x-coordinate of the rectangle or another Rect instance to clone.
     * @param y - The y-coordinate of the rectangle. Defaults to 0 if not provided.
     * @param width - The width of the rectangle. Defaults to 0 if not provided.
     * @param height - The height of the rectangle. Defaults to 0 if not provided.
     */
    constructor(x?: number, y?: number, width?: number, height?: number);
    /**
     * @description Creates and returns a deep copy of the current rectangle.
     * @returns A new instance of Rect with the same properties as the original.
     */
    clone(): Rect;
    /**
     * Determines if this rectangle is equal to another rectangle.
     * @param other - The rectangle to compare with.
     * @returns A boolean indicating whether the rectangles are equal.
     */
    equals(other: Rect): boolean;
    /**
     * Returns a string representation of the rectangle.
     * @returns A formatted string describing the rectangle's coordinates and dimensions.
     */
    toString(): string;
  }
  /**
   * @class Renderer
   */
  class Renderer extends Component {
    protected constructor();
    /**
     * @description Gets the shadow mode of the renderer.
     */
    get shadowMode(): ShadowMode;
    /**
     * @description Sets the shadow mode for the Renderer. This determines whether the object casts and/or receives shadows.
     */
    set shadowMode(value: ShadowMode);
  }
  /**
   * RenderTextureProvider
   * @class RenderTextureProvider
   * @extends TextureProvider
   * let tex = RenderTextureProvider.create();
   * let format = tex.colorFormat;
   * if (tex.getControl().inputTexture == null)
   * tex.getControl().inputTexture = script.rt;
   */
  class RenderTextureProvider extends TextureProvider {
    protected constructor();
    /**
     * @description RT's ClearType
     * @type {CameraClearType}
     */
    get clearType(): CameraClearType;
    set clearType(ct: CameraClearType);
    /**
     * @default Color(0,0,0,1)
     * @description When enableClearColor is true and inputTexture is null, this color is used to clear this Camera's renderTarget before drawing to it.
     * @type {Color}
     */
    get clearColor(): Color;
    set clearColor(color: Color);
    /**
     * @type {Texture | undefined}
     * @description Set/Get input texture
     */
    get inputTexture(): Texture | undefined;
    set inputTexture(value: Texture | undefined);
    /**
     * @description set RT Width
     * @param {number} value
     * @returns {void}
     */
    setWidth(value: number): void;
    /**
     * @description set RT Height
     * @param {number} value
     * @returns {void}
     */
    setHeight(value: number): void;
  }
  /**
   * @class RigidBody
   * @extends DynamicComponent
   */
  class RigidBody extends DynamicComponent {
    protected constructor();
    /**
     * @description mass
     * @type {number}
     */
    get mass(): number;
    set mass(value: number);
    /**
     * @description damping
     * @type {number}
     */
    get damping(): number;
    set damping(value: number);
    /**
     * @description angular damping
     * @type {number}
     */
    get angularDamping(): number;
    set angularDamping(value: number);
    /**
     * @description force
     * @type {Vector3f}
     */
    get force(): Vector3f;
    set force(value: Vector3f);
    /**
     * @description torque
     * @type {Vector3f}
     */
    get torque(): Vector3f;
    set torque(value: Vector3f);
    /**
     * @description freezeX
     * @type {boolean}
     */
    get freezeX(): boolean;
    set freezeX(value: boolean);
    /**
     * @description freezeY
     * @type {boolean}
     */
    get freezeY(): boolean;
    set freezeY(value: boolean);
    /**
     * @description freezeZ
     * @type {boolean}
     */
    get freezeZ(): boolean;
    set freezeZ(value: boolean);
    /**
     * @description static
     * @type {boolean}
     */
    get static(): boolean;
    set static(value: boolean);
    /**
     * @description physicsAnimation
     * @type {boolean}
     */
    get physicsAnimation(): boolean;
    set physicsAnimation(value: boolean);
    /**
     * @description physicsAnimationRate
     * @type {number}
     */
    get physicsAnimationRate(): number;
    set physicsAnimationRate(value: number);
    /**
     * @description useGravity
     * @type {boolean}
     */
    get useGravity(): boolean;
    set useGravity(value: boolean);
    /**
     * @description position
     * @type {Vector3f}
     */
    get position(): Vector3f;
    set position(value: Vector3f);
    /**
     * @description rotation
     * @type {Quaternionf}
     */
    get rotation(): Quaternionf;
    set rotation(value: Quaternionf);
    /**
     * @description eulerAngles
     * @type {Vector3f}
     */
    get eulerAngles(): Vector3f;
    set eulerAngles(value: Vector3f);
    /**
     * @description velocity
     * @type {Vector3f}
     */
    get velocity(): Vector3f;
    set velocity(value: Vector3f);
    /**
     * @description angularVelocity
     * @type {Vector3f}
     */
    get angularVelocity(): Vector3f;
    set angularVelocity(value: Vector3f);
    /**
     * @description inertiaTensor
     * @type {Vector3f}
     */
    get inertiaTensor(): Vector3f;
    set inertiaTensor(value: Vector3f);
    /**
     * @description addForce
     * @param {Vector3f} force
     * @param {boolean} isLocal
     * @returns {void}
     */
    addForce(force: Vector3f, isLocal?: boolean): void;
    /**
     * @description addTorque
     * @param {Vector3f} torque
     * @returns {void}
     */
    addTorque(torque: Vector3f): void;
  }
  /**
   * @class RigidBody2D
   * @extends DynamicComponent
   */
  class RigidBody2D extends DynamicComponent {
    protected constructor();
    /**
     * @description Is the RigidBody2D static or not
     * @type {boolean}
     */
    get static(): boolean;
    set static(value: boolean);
    /**
     * @description Whether the RigidBody2D use gravity or not
     * @type {boolean}
     */
    get useGravity(): boolean;
    set useGravity(value: boolean);
    /**
     * @description The gravity scale of the RigidBody2D
     * @type {number}
     */
    get mass(): number;
    set mass(value: number);
    /**
     * @description The position of the RigidBody2D
     * @type {Vector2f}
     */
    get position(): Vector2f;
    set position(value: Vector2f);
    /**
     * @description The rotation of the RigidBody2D
     * @type {number}
     */
    get rotation(): number;
    set rotation(value: number);
    /**
     * @description The linear damping of the RigidBody2D
     * @type {number}
     */
    get damping(): number;
    set damping(value: number);
    /**
     * @description The angular damping of the RigidBody2D
     * @type {number}
     */
    get angularDamping(): number;
    set angularDamping(value: number);
    /**
     * @description Whether the RigidBody2D is freezed in x axis or not
     * @type {boolean}
     */
    get freezeX(): boolean;
    set freezeX(value: boolean);
    /**
     * @description Whether the RigidBody2D is freezed in y axis or not
     * @type {boolean}
     */
    get freezeY(): boolean;
    set freezeY(value: boolean);
    /**
     * @description Whether the RigidBody2D is freezed in rotation
     * @type {boolean}
     */
    get freezeZ(): boolean;
    set freezeZ(value: boolean);
    /**
     * @description The force of the RigidBody2D
     * @type {Vector2f}
     */
    get force(): Vector2f;
    set force(value: Vector2f);
    /**
     * @description The torque of the RigidBody2D
     * @type {number}
     */
    get torque(): number;
    set torque(value: number);
    /**
     * @description The gravity scale of the RigidBody2D
     * @type {number}
     */
    get gravityScale(): number;
    set gravityScale(value: number);
    /**
     * @description The velocity of the RigidBody2D
     * @type {Vector2f}
     */
    get velocity(): Vector2f;
    set velocity(value: Vector2f);
    /**
     * @description The angular velocity of the RigidBody2D
     * @type {number}
     */
    get angularVelocity(): number;
    set angularVelocity(value: number);
    /**
     * @description Add the force to the RigidBody2D
     * @param force The force to add
     */
    addForce(force: Vector2f): void;
    /**
     * @description Add the torque to the RigidBody2D
     * @param torque The torque to add
     */
    addTorque(torque: number): void;
  }
  /**
   * @class Scene
   * @description <b>runtime</b> can on script with [this.scene] get one scene
   * @example
   * let currScene = this.scene;
   */
  class Scene extends AObject {
    protected constructor();
    /**
     * @description Create and add a scene object to this scene
     * @param name - the name of sceneObject
     * @returns the created SceneObject
     * @example
     * let newObj = this.scene.createSceneObject('newObj');
     */
    createSceneObject(name: string): SceneObject;
    /**
     * @description remove scene object from the scene
     * <br/> (if obj does not belong to the scene or is invalid return false)
     * @param obj - Object that need to be removed from the scene
     * @returns remove is success?
     * @example
     * let foundObj = this.scene.findSceneObject('newObj');
     * if (foundObj) {
     *   this.scene.removeSceneObject(foundObj);
     * }
     */
    removeSceneObject(obj: SceneObject): boolean;
    /**
     * @description
     * get all the root scene objects in the Scene.
     */
    getRootSceneObjects(): SceneObject[];
    /**
     * @description
     * get all the sceneObject in the Scene.
     * @example
     * var sceneObjects = this.scene.getAllSceneObjects();
     * sceneObjects.forEach(obj => {
     *   // TODO
     * })
     */
    getAllSceneObjects(): SceneObject[];
    /**
     * @description find scene object by name from an scene object tree or subtree in the scene
     * @param name - scene object name
     * @param root - root scene object of scene object tree or subtree
     * @return found scene object
     * @example
     * let foundObj = this.scene.findSceneObject('newObj');
     * if (foundObj) {
     *   this.scene.removeSceneObject(foundObj);
     * }
     */
    findSceneObject(name: string, root?: SceneObject): SceneObject | null;
  }
  /**
   * @class SceneObject
   * @description
   * <br/>SceneObject is the base class for all SceneObjects in Scenes.
   * <br/>can use scene.createSceneObject() to create one SceneObject
   */
  class SceneObject extends AObject {
    protected constructor();
    /**
     * @type {boolean}
     * @description
     * The enabled status of SceneObject it self.
     */
    get enabled(): boolean;
    /**
     * @description Sets whether the SceneObject is enabled, which affects its visibility and interaction in the scene.
     * If need to enable child SceneObject, use '**setEnabledInHierarchy**' instead.
     */
    set enabled(enabled: boolean);
    /**
     * @type {number}
     * @description
     * can use Layers for selective rendering from cameras.
     */
    get layer(): number;
    /**
     * @description Sets the layer of the SceneObject.
     */
    set layer(value: number);
    /**
     * @readonly
     * @tsd_constant
     * @type {Scene}
     * @description
     * the scene to which this scene object belongs
     */
    get scene(): Scene;
    /**
     * @type {SceneObject | null}
     * @tsd_constant
     * @description
     * The parent of the SceneObject.
     * <br/> Changing the parent will modify the parent-relative position,
     * <br/> scale and rotation but keep the world space position, rotation and scale the same.
     */
    get parent(): SceneObject | null;
    /**
     * @description Sets the parent of the SceneObject. If a new parent is provided, it reassigns the object's transform to the new parent.
     *              If no parent is provided (null), it removes the object from its current parent.
     */
    set parent(parent: SceneObject | null);
    /**
     * @description
     * the SceneObject's current is enable on Scene Hierarchy
     * if parent or parent's parent  enable is false ,return false
     * @return {boolean} isEnabledInHierarchy
     */
    isEnabledInHierarchy(): boolean;
    /**
     * @description setEnabledInHierarchy
     * @param {boolean} enabled
     * @returns {void}
     */
    setEnabledInHierarchy(enabled: boolean): void;
    /**
     * @description Finds a child by name and returns it.
     * @param {string} name sceneObject name
     * @return {SceneObject | null} SceneObject The found child transform. Null if child with matching name isn't found.
     */
    getChild(name: string): SceneObject | null;
    /**
     * @description Get all children SceneObjects of the SceneObject.
     * @returns {SceneObject[]}
     */
    getChildren(): SceneObject[];
    /**
     * @description add component with type on the SceneObject
     * @param {string}type the type of component
     * @returns {Component | null} component
     */
    addComponent(type: string): Component | null;
    /**
     * @description get component with type on the SceneObject
     * @param type - the type of component
     * @returns component
     */
    getComponent(type: string): Component | null;
    /**
     * @param type - Optional parameter representing the component's typename.
     * @description get all component of the SceneObject
     * @returns components
     */
    getComponents(type?: string): Component[];
    /**
     * @param type - Component's typename
     * @description getComponentsRecursive
     * @returns components
     */
    getComponentsRecursive(type: string): Component[];
    /**
     * @description clone this sceneObject
     * @returns the clone result
     */
    clone(): SceneObject;
    /**
     * @description get transform of the SceneObject
     * @returns transform
     */
    getTransform(): Transform;
    /**
     * @description removeComponent
     * if com is transform return failure, and 'com' didn't attached on this.
     * @param comp - the component to be removed
     * @returns the remove is success
     */
    removeComponent(comp: Component): boolean;
  }
  /**
   * @class ScreenTextureProvider
   * @extends RenderTextureProvider
   */
  class ScreenTextureProvider extends RenderTextureProvider {
    protected constructor();
    /**
     * @type {ScreenTextureSizeMode}
     * @description Get size mode
     */
    get sizeMode(): ScreenTextureSizeMode;
    set sizeMode(value: ScreenTextureSizeMode);
  }
  /**
   * @description Defines the size modes for screen textures.
   * @enum {number}
   * @property FollowScreen Represents that the screen texture size follows the screen size.
   * @property FollowInput Represents that the screen texture size follows the input size.
   * @property Custom Represents that the screen texture size is custom.
   */
  enum ScreenTextureSizeMode {
    FollowScreen,
    FollowInput,
    Custom
  }
  /**
   * Manages screen space transformations for UI elements, including positioning, sizing, and anchoring.
   * Extends the base Transform class to provide UI-specific layout functionality such as anchor points,
   * pivot positioning, and screen space rect calculations.
   * @class ScreenTransform
   * @extends Transform
   */
  class ScreenTransform extends Transform {
    constructor();
    /**
     * The position of the UI element relative to its anchors.
     * This position is calculated from the element's pivot point and adjusted based on anchor positions.
     */
    get anchoredPosition(): Vector2f;
    set anchoredPosition(value: Vector2f);
    /**
     * The size difference between the UI element and its parent's rect.
     * Positive values expand the element beyond the parent's bounds, negative values shrink it.
     */
    get sizeDelta(): Vector2f;
    set sizeDelta(value: Vector2f);
    /**
     * The pivot point of the UI element, normalized to [0,1] range.
     * Determines the origin point for rotation, scaling, and positioning calculations.
     */
    get pivot(): Vector2f;
    set pivot(value: Vector2f);
    /**
     * The anchor points that define how the UI element is positioned relative to its parent.
     * Format: [minX, minY, maxX, maxY], each in [0,1] range relative to parent's rect.
     */
    get anchors(): Vector4f;
    set anchors(value: Vector4f);
    /**
     * The offset values from the anchors, defining the element's position within the anchor bounds.
     * Format: [left, bottom, right, top] offsets in pixels.
     */
    get offsets(): Vector4f;
    set offsets(value: Vector4f);
    /**
     * The 2D scaling factor applied to the UI element.
     */
    get scale(): Vector2f;
    set scale(value: Vector2f);
    /**
     * The 2D rotation angle in degrees applied to the UI element.
     * Rotation is performed around the element's pivot point.
     */
    get rotation(): number;
    set rotation(value: number);
  }
  /**
   * @description Defines the shadow casting and receiving modes for a renderable object.
   * @enum
   * @property Caster - The object casts shadows but does not receive them.
   * @property Receiver - The object receives shadows but does not cast them.
   * @property None - The object neither casts nor receives shadows.
   */
  enum ShadowMode {
    Caster = 1,
    Receiver = 2,
    None = 0
  }
  /**
   * @class SkinMeshRenderer
   * @extends Renderer
   */
  class SkinMeshRenderer extends Renderer {
    protected constructor();
    /**
     * @description Retrieves the mesh associated with the SkinMeshRenderer.
     */
    get mesh(): Mesh;
    /**
     * @description Sets the mesh for the SkinMeshRenderer.
     */
    set mesh(value: Mesh);
    /**
     * @description Gets the first shared material used by the SkinMeshRenderer.
     */
    get mainMaterial(): Material | null;
    /**
     * @description Sets the main material for the SkinMeshRenderer.
     */
    set mainMaterial(value: Material | null);
    /**
     * @description Retrieves the main pass from the object's shared material.
     * @returns The first pass of the shared material, or null if no passes are available.
     */
    get mainPass(): Pass | null;
    /**
     * @description Retrieves the axis-aligned bounding box (AABB) for the skin mesh renderer.
     * @returns The axis-aligned bounding box representing the bounds of the skin mesh.
     */
    getBoundingBox(): AABB;
  }
  /**
   * @class SphereCollider
   * @extends Collider
   */
  class SphereCollider extends Collider {
    protected constructor();
    /**
     * @description The radius of the sphere collider.
     * @type {number}
     */
    get radius(): number;
    set radius(value: number);
  }
  /**
   * @class SpotLight
   * @extends Light
   * @description Class of SpotLight.
   */
  class SpotLight extends Light {
    constructor();
    /**
     * @description get or set current spotLight's Attenuation Range
     * @type {number}
     */
    get attenuationRange(): number;
    set attenuationRange(value: number);
    /**
     * @description get or set current spotLight's Inner Angle
     * @type {number}
     */
    get innerAngle(): number;
    set innerAngle(value: number);
    /**
     * @description get current spotlight's Outer Angle.
     * @type {number}
     */
    get outerAngle(): number;
    set outerAngle(value: number);
  }
  /**
   * @class SpringJoint
   * @extends Joint3D
   */
  class SpringJoint extends Joint3D {
    protected constructor();
    /**
     * @description The damping of the spring joint.
     * @type {number}
     */
    get damping(): number;
    set damping(value: number);
    /**
     * @description The tolerance of the spring joint.
     * @type {number}
     */
    get tolerance(): number;
    set tolerance(value: number);
  }
  /**
   * @class SpringJoint2D
   * @extends Joint2D
   */
  class SpringJoint2D extends Joint2D {
    protected constructor();
    /**
     * @description The damping factor of the spring joint.
     * @type {number}
     */
    get damping(): number;
    set damping(value: number);
    /**
     * @description The tolerance of the spring joint.
     * @type {number}
     */
    get tolerance(): number;
    set tolerance(value: number);
  }
  /**
   * @description Stencil function used for comparing stencil values.
   * @enum
   * @property Never - The comparison never passes.
   * @property Less - The comparison passes if the reference value is less than the stored stencil value.
   * @property Equal - The comparison passes if the reference value is equal to the stored stencil value.
   * @property LessOrEqual - The comparison passes if the reference value is less than or equal to the stored stencil value.
   * @property Greater - The comparison passes if the reference value is greater than the stored stencil value.
   * @property NotEqual - The comparison passes if the reference value is not equal to the stored stencil value.
   * @property GreaterOrEqual - The comparison passes if the reference value is greater than or equal to the stored stencil value.
   * @property Always - The comparison always passes.
   */
  enum StencilFunction {
    Never,
    Less,
    Equal,
    LessOrEqual,
    Greater,
    NotEqual,
    GreaterOrEqual,
    Always
  }
  /**
   * @description Defines the operations that can be performed on the stencil buffer.
   * @enum
   * @property Keep Keeps the current value of the stencil buffer.
   * @property Zero Sets the stencil buffer to zero.
   * @property Replace Replaces the current stencil buffer value with a reference value.
   * @property IncrementAndClamp Increments the current stencil buffer value and clamps it to the maximum representable unsigned integer.
   * @property DecrementAndClamp Decrements the current stencil buffer value and clamps it to zero.
   * @property Invert Bitwise inverts the current stencil buffer value.
   * @property IncrementAndWrap Increments the current stencil buffer value and wraps it around if necessary.
   * @property DecrementAndWrap Decrements the current stencil buffer value and wraps it around if necessary.
   */
  enum StencilOperation {
    Keep,
    Zero,
    Replace,
    IncrementAndClamp,
    DecrementAndClamp,
    Invert,
    IncrementAndWrap,
    DecrementAndWrap
  }
  /**
   * @class DepthStencilState
   * @extends AObject
   * @description depth stencil state
   */
  class StencilState extends AObject {
    protected constructor();
    /**
     * @description Indicates whether stencil testing is enabled.
     */
    get enable(): boolean;
    /**
     * @description Enables or disables the stencil test for the StencilState.
     */
    set enable(value: boolean);
    /**
     * @description The operation to perform when the stencil test fails.
     */
    get failOperation(): StencilOperation;
    /**
     * @description Sets the stencil operation to perform when a fragment fails the stencil test.
     */
    set failOperation(value: StencilOperation);
    /**
     * @description Gets or sets the stencil operation for both front and back faces.
     */
    get passOperation(): StencilOperation;
    /**
     * @description Sets the stencil operation for both front and back faces.
     */
    set passOperation(value: StencilOperation);
    /**
     * @description The comparison function used for the stencil test.
     */
    get compareFunction(): StencilFunction;
    /**
     * @description Sets the compare function for the stencil state.
     */
    set compareFunction(value: StencilFunction);
    /**
     * @description The mask applied to the stencil buffer for reading operations.
     */
    get readMask(): number;
    /**
     * @description Sets the read mask for the stencil state.
     */
    set readMask(value: number);
    /**
     * @description The write mask for the stencil state, which determines which bits can be written to the stencil buffer.
     */
    get writeMask(): number;
    /**
     * @description Sets the write mask for both front and back stencil states.
     */
    set writeMask(value: number);
    /**
     * @description The reference value for the stencil state.
     */
    get referenceValue(): number;
    /**
     * @description Sets the reference value for both front and back stencil operations.
     */
    set referenceValue(value: number);
  }
  /**
   * @description Stretch Mode
   * @enum
   * @property Fit Fit the size, keep the aspect ratio
   * @property FitWidth Fit the width, keep the aspect ratio
   * @property FitHeight Fit the height, keep the aspect ratio
   * @property Stretch Stretch fill, keep the aspect ratio
   * @property Fill Fill, keep the aspect ratio
   * @property FillAndCut Fill and cut
   * @property TextureSize Use the texture original size
   */
  enum StretchMode {
    Fit = 0,
    FitWidth = 1,
    FitHeight = 2,
    Stretch = 3,
    Fill = 4,
    FillAndCut = 5,
    TextureSize = 6
  }
  /**
   * @class Text
   * @extends Renderer
   */
  class Text extends Renderer {
    protected constructor();
    /**
     * @description font size (pixel)
     * @type {number}
     */
    get fontSize(): number;
    set fontSize(value: number);
    /**
     * @description the spacing between letters, with the unit being the single line height
     * @type {number}
     */
    get letterSpacing(): number;
    set letterSpacing(value: number);
    /**
     * @description the spacing between lines, with the unit being the single line height
     * @type {number}
     */
    get lineSpacing(): number;
    set lineSpacing(value: number);
    /**
     * @description text string
     */
    get text(): string;
    /**
     * @description Sets the content of the text component.
     */
    set text(value: string);
    /**
     * @description global opacity of text, its styles, and the background
     * @type {number}
     */
    get opacity(): number;
    set opacity(value: number);
    /**
     * @description current bold state based on font style, true if current font style is BOLD or BOLD_ITALIC
     * @type {boolean}
     */
    get bold(): boolean;
    set bold(enable: boolean);
    /**
     * @description current italic state based on font style, true if current font style is ITALIC or BOLD_ITALIC
     * @type {boolean}
     */
    get italic(): boolean;
    set italic(enable: boolean);
    /**
     * @description local horizontal alignment, which refers to the horizontal alignment relative to the writing direction
     * @type {HorizontalAlignment}
     */
    get horizontalAlignment(): HorizontalAlignment;
    set horizontalAlignment(value: HorizontalAlignment);
    /**
     * @description local vertical alignment, which refers to the vertical alignment relative to the writing direction
     * @returns {VerticalAlignment}
     */
    get verticalAlignment(): VerticalAlignment;
    set verticalAlignment(value: VerticalAlignment);
    /**
     * @description color
     * @type {Color}
     */
    get color(): Color;
    set color(value: Color);
  }
  /**
   * @class Texture
   */
  class Texture extends AObject {
    protected constructor();
    /**
     * @description Gets whether mipmap is enabled for the texture.
     */
    get enableMipmap(): boolean;
    /**
     * @description Enables or disables mipmapping for the texture.
     */
    set enableMipmap(value: boolean);
    /**
     * @description Gets the minimization filter mode of the texture.
     * @returns The current minimization filter mode.
     */
    get filterMin(): FilterMode;
    /**
     * @description Sets the minimum filter mode for the texture.
     */
    set filterMin(value: FilterMode);
    /**
     * @description Gets the magnification filter mode of the texture.
     * @returns The current magnification filter mode.
     */
    get filterMag(): FilterMode;
    /**
     * @description Sets the magnification filter mode for the texture.
     */
    set filterMag(value: FilterMode);
    /**
     * @description Gets the mipmap mode for the texture.
     * @returns The current mipmap mode.
     */
    get filterMipmap(): FilterMipmapMode;
    /**
     * @description Sets the mipmap filtering mode for the texture.
     */
    set filterMipmap(value: FilterMipmapMode);
    /**
     * @description Get the wrap mode of the S dimension.
     * @returns The current wrap mode for the S dimension.
     */
    get wrapModeS(): WrapMode;
    /**
     * @description Sets the wrap mode for the S coordinate of the texture.
     */
    set wrapModeS(value: WrapMode);
    /**
     * @description Get the wrap mode of the T dimension.
     * @returns The current wrap mode for the T dimension.
     */
    get wrapModeT(): WrapMode;
    /**
     * @description Sets the vertical wrapping mode of the texture.
     */
    set wrapModeT(value: WrapMode);
    /**
     * @description Gets the wrap mode of the R dimension.
     * @returns The current wrap mode for the R dimension.
     */
    get wrapModeR(): WrapMode;
    /**
     * @description Sets the wrap mode for the red component of the texture.
     */
    set wrapModeR(value: WrapMode);
    /**
     * @description Gets the maximum anisotropy level of the current texture.
     */
    get maxAnisotropy(): number;
    /**
     * @description Sets the maximum anisotropy for the texture, which improves texture quality when viewed at oblique angles.
     */
    set maxAnisotropy(value: number);
    /**
     * @description Retrieves the width of the texture.
     * @returns The width of the texture as a number.
     */
    getWidth(): number;
    /**
     * @description Retrieves the height of the texture.
     * @returns The height of the texture as a number.
     */
    getHeight(): number;
    /**
     * @description Retrieves the depth of the source texture.
     * @returns The depth of the texture as a number.
     */
    getDepth(): number;
    /**
     * @description Retrieves the control associated with the texture.
     *              In runtime, it checks and loads the JS asset if necessary,
     *              then retrieves the JS asset by GUID from the map. If the JS asset is found,
     *              it returns the asset as a TextureProvider; otherwise, it returns the internal __control property.
     * @returns The control associated with the texture, either as a TextureProvider or the internal __control property.
     */
    getControl(): TextureProvider;
  }
  /**
   * @class Texture2DProvider
   * @description
   * <br/><b>new Texture2DProvider() is an invalid constructor</b>
   * <br/>If you need a 2D texture, you can get an texture by calling TextureUtil.createTexture2D()
   * @example
   * let provider = tex.getControl() as Texture2DProvider;
   */
  class Texture2DProvider extends TextureProvider {
    protected constructor();
    /**
     * @description Whether to initialize the memory data for transparency premultiplication
     */
    get alphaPremul(): boolean;
    set alphaPremul(value: boolean);
  }
  /**
   * @class TextureDelegateProvider
   * @description
   * <br/><b>new TextureDelegateProvider() is an invalid constructor</b>
   * <br/>If you need a Delegate texture, you can get an texture by calling TextureUtil.createTextureDelegate()
   */
  class TextureDelegateProvider extends TextureProvider {
    protected constructor();
  }
  /**
   * @class TextureProvider
   * @description
   * TextureProvider. Basic properties and functionality of all TextureProviders
   * <br/>then you can use TextureUtil to create texture.
   */
  class TextureProvider extends Provider {
    protected constructor();
  }
  /**
   * @class TouchData
   * @description The touch data is carried by touch event, record the info of one touch point.
   * @extends AObject
   */
  class TouchData extends AObject {
    protected constructor();
    /**
     * @readonly
     * @description The touch phase of this touch.
     */
    get phase(): TouchPhase;
    /**
     * @readonly
     * @description Touch position.
     */
    get position(): Vector2f;
    /**
     * @readonly
     * @description Touch force.
     */
    get force(): number;
    /**
     * @readonly
     * @description Touch id, it is useful for multi-touch.
     */
    get touchId(): number;
    /**
     * @readonly
     * @description Touch count, it is useful for multi-touch.
     */
    get touchCount(): number;
  }
  /**
   * @description TouchPhase
   * @enum
   * @property Began - Touch screen began.
   * @property Moved - Touch screen moved.
   * @property Ended - Touch was lifted from the screen, This is the final phase of a touch.
   * @property Canceled - The device cancelled tracking for touch.
   */
  enum TouchPhase {
    Began,
    Moved,
    Ended,
    Canceled
  }
  /**
   * @class Transform
   * @description
   * Position, rotation and scale of an object.
   * <br/>Every object in a Scene has a Transform. It's used to store and manipulate the position, rotation and scale of the object.
   * <br/>Every Transform can have a parent, which allows you to apply position, rotation and scale hierarchically.
   * <br/>This is the hierarchy seen in the Hierarchy pane. They also support enumerators so you can loop through children using:
   * <br/>
   * @example let transform = currObj.getTransform();
   */
  class Transform extends Component {
    protected constructor();
    /**
     * @description Gets or sets the Transform's position relative to its parent.
     * @returns The local position of the Transform.
     */
    get localPosition(): Vector3f;
    /**
     * @description Sets the local position of the transform using a Vector3f value.
     */
    set localPosition(value: Vector3f);
    /**
     * @description Gets the Transform's rotation relative to its parent.
     * @returns The local rotation as a Quaternionf.
     */
    get localRotation(): Quaternionf;
    /**
     * @description Sets the local rotation of the transform using a quaternion.
     */
    set localRotation(value: Quaternionf);
    /**
     * @description Gets the Transform's local euler angles.
     */
    get localEulerAngles(): Vector3f;
    /**
     * @description Sets the local Euler angles of the transform in degrees.
     */
    set localEulerAngles(value: Vector3f);
    /**
     * @description Gets the Transform's scale relative to its parent.
     * @returns The local scale of the Transform.
     */
    get localScale(): Vector3f;
    /**
     * @description Sets the local scale of the transform using a Vector3f value.
     */
    set localScale(value: Vector3f);
    /**
     * @description Gets the local transformation matrix of the Transform.
     * @returns The local matrix representing the object's position, rotation, and scale relative to its parent.
     */
    get localMatrix(): Matrix4x4f;
    /**
     * @description Sets the local transformation matrix of the object.
     */
    set localMatrix(value: Matrix4x4f);
    /**
     * @description Get the world transformation matrix of this object.
     * <br/>Retrieving the world matrix may involve a matrix transformation operation.
     * @returns The world matrix representing the object's position, rotation, and scale in world space.
     */
    getWorldMatrix(): Matrix4x4f;
    /**
     * @description Sets the world transformation matrix for the object.
     * @param matrix - The 4x4 matrix representing the new world transformation.
     */
    setWorldMatrix(matrix: Matrix4x4f): void;
    /**
     * @description Returns the Transform's position relative to the world.
     * <br/>Obtaining the rotation in world space may trigger a matrix transformation operation.
     * @returns {Vector3f} - The position of the Transform in world space.
     */
    getWorldPosition(): Vector3f;
    /**
     * Sets the Transform's position in world space.
     * <br/> Modifying the world position may result in a matrix transformation operation.
     * @param worldPosition - The desired world space position as a Vector3f.
     */
    setWorldPosition(worldPosition: Vector3f): void;
    /**
     * @description Returns the Transform's rotation relative to the world.
     * <br/>Obtaining the rotation in world space may trigger a matrix transformation operation.
     * @returns The rotation of the transform in world space.
     */
    getWorldRotation(): Quaternionf;
    /**
     * @description Sets the Transform's rotation relative to the world.
     * <br/> Setting the world space rotation may trigger a matrix transformation operation.
     * @param worldRotation - The world space rotation as a Quaternionf.
     */
    setWorldRotation(worldRotation: Quaternionf): void;
    /**
     * @description Returns the Transform's scale relative to the world.
     * <br/>Obtaining the scale in world space may trigger a matrix transformation operation.
     * @returns The scale of the transform in world space.
     */
    getWorldScale(): Vector3f;
    /**
     * @description Sets the Transform's scale relative to the world.
     * <br/>This may produce lossy results when parent objects are rotated, so use `setLocalScale()` instead if possible.
     * @param worldScale - the world space Scale as a Vector3f
     */
    setWorldScale(worldScale: Vector3f): void;
  }
  /**
   * @description Represents the event type for a user action, encoded as a number.
   */
  type UserEventType = number;
  /**
   * @class Vector2f
   * A two dimensional vector.
   * @example
   * let zero_p = new Vector2f();
   * let custom_p = new Vector2f(88, 88);
   */
  class Vector2f {
    /**
     * Represents the x-coordinate in a 2-dimensional vector.
     */
    x: number;
    /**
     * Represents the y-coordinate in a 2D vector.
     */
    y: number;
    /**
     * Constructs a new instance of the Vector2f class.
     */
    constructor();
    /**
     * Constructs a new 2D vector.
     * @param x - The x-coordinate of the vector (optional).
     * @param y - The y-coordinate of the vector (optional).
     */
    constructor(x?: number, y?: number);
    /**
     * @description Determines if this vector is equal to the specified vector.
     * @param vec - The vector to compare with.
     * @returns A boolean indicating whether the vectors are equal.
     */
    equals(vec: Vector2f): boolean;
    /**
     * @description Sets the two-dimensional coordinates of this vector.
     * @param x - The x-coordinate to set.
     * @param y - The y-coordinate to set.
     * @returns This instance of Vector2f with updated coordinates.
     */
    set(x: number, y: number): this;
    /**
     * @description Creates and returns a clone of the current Vector2f instance.
     * @returns A new Vector2f object with the same x and y values as the original.
     */
    clone(): Vector2f;
    /**
     * @description Adds the components of `vec` to this vector.
     * @param vec - The vector whose components will be added to this vector.
     * @returns This vector with updated components after addition.
     */
    add(vec: Vector2f): this;
    /**
     * @description Subtracts the components of `vec` from this vector.
     * @param vec - The vector to subtract from this vector.
     * @returns This vector after subtraction.
     */
    subtract(vec: Vector2f): this;
    /**
     * @description Returns the angle in radians between the current vector and the specified vector `vec`.
     * @param vec - The target vector to calculate the angle against.
     * @returns The angle in radians between the two vectors.
     */
    angleTo(vec: Vector2f): number;
    /**
     * @description Returns the squared length (magnitude) of the vector.
     * @returns The square of the vector's magnitude.
     */
    sqrMagnitude(): number;
    /**
     * @description Calculates and returns the magnitude (length) of the vector.
     * @returns The magnitude of the vector.
     */
    magnitude(): number;
    /**
     * @description Clamps the length of this vector to the specified `length` and returns this vector.
     * @param length - The maximum length to clamp the vector to.
     * @returns This vector with its length clamped to the specified value.
     */
    clampLength(length: number): this;
    /**
     * @description Calculates and returns the Euclidean distance between the current vector and another vector `vec`.
     * @param vec - The target vector to which the distance is calculated.
     * @returns The distance as a number.
     */
    distance(vec: Vector2f): number;
    /**
     * @description Divides the current vector by another vector `vec` component-wise.
     * @param vec - The vector to divide by, where each component is used to divide the corresponding component of the current vector.
     * @returns This vector after performing the division.
     */
    divide(vec: Vector2f): this;
    /**
     * @description Returns the dot product of the vector and `vec`.
     * @param vec - The vector to compute the dot product with.
     * @returns The dot product as a number.
     */
    dot(vec: Vector2f): number;
    /**
     * @description Performs dimensional-wise multiplication of the vector with the given `value`.
     * If `value` is a number, multiplies both x and y components by that number.
     * If `value` is another Vector2f, multiplies each component of this vector by the corresponding component of `value`.
     * @param value - A number or another Vector2f to multiply with.
     * @returns This instance of Vector2f after performing the multiplication.
     */
    multiply(value: number | Vector2f): this;
    /**
     * Multiplies the x and y dimensions of the vector by a given scalar value.
     * @param scale - The scalar value to multiply the vector's dimensions by.
     * @returns This instance of Vector2f with updated dimensions.
     */
    multiplyScalar(scale: number): this;
    /**
     * @description Scales the vector to have a length of 1 and returns the normalized vector.
     * @returns The normalized vector.
     */
    normalize(): this;
    /**
     * @description Projects the current vector onto the given vector `vec` and returns the result.
     * @param vec - The vector to project onto.
     * @returns The current vector after being projected onto `vec`.
     */
    project(vec: Vector2f): this;
    /**
     * @description Reflects the vector across the plane defined by the normal `vec` and returns this.
     * @param vec - The normal vector defining the reflection plane.
     * @returns This vector after being reflected.
     */
    reflect(vec: Vector2f): this;
    /**
     * @description Inverts the components of the vector.
     * @returns {this} - The current instance of Vector2f with inverted x and y values.
     */
    inverse(): this;
    /**
     * @description Returns a string representation of the vector.
     * @returns A string in the format "Vector2f(x, y)" where x and y are fixed to 5 decimal places.
     */
    toString(): string;
    /**
     * @description Approximate comparison of the two vectors by the value of each dimension with a specified distance threshold.
     * @param vec1 - The first vector to compare.
     * @param vec2 - The second vector to compare.
     * @param dist - The maximum allowed difference between corresponding dimensions for the vectors to be considered approximately equal.
     * @returns A boolean indicating whether the two vectors are approximately equal within the given distance threshold.
     * @example
     * let a = new Vector2f(0.0000001, 0.0000001);
     * let b = new Vector2f(0.0000000, 0.0000000);
     * Vector2f.compareApproximately(a, b, 0.0001); // true
     */
    static compareApproximately(vec1: Vector2f, vec2: Vector2f, dist: number): boolean;
    /**
     * @description Linearly interpolates between the two vectors `vecA` and `vecB` by the factor `t`.
     * @param vecA - The starting vector.
     * @param vecB - The ending vector.
     * @param t - The interpolation factor, typically ranging from 0 to 1.
     * @returns A new Vector2f representing the interpolated position between `vecA` and `vecB`.
     */
    static lerp(vecA: Vector2f, vecB: Vector2f, t: number): Vector2f;
    /**
     * @description Returns a new vector containing the largest value of each component from the two input vectors.
     * @param vecA - The first vector to compare.
     * @param vecB - The second vector to compare.
     * @returns A new Vector2f instance with components set to the maximum values from vecA and vecB.
     */
    static max(vecA: Vector2f, vecB: Vector2f): Vector2f;
    /**
     * @description Returns a new vector containing the smallest value of each component from the two input vectors.
     * @param vecA - The first vector to compare.
     * @param vecB - The second vector to compare.
     * @returns A new Vector2f instance with components set to the minimum values from vecA and vecB.
     */
    static min(vecA: Vector2f, vecB: Vector2f): Vector2f;
  }
  /**
   * @class Vector3f
   * A three dimensional vector.
   * @example
   * let zero_p = new Vector3f();
   * let custom_p = new Vector3f(88.8, 88.8, 88.8);
   */
  class Vector3f {
    /**
     * Represents the x-coordinate in a 3-dimensional vector.
     */
    x: number;
    /**
     * Represents the y-coordinate in a 3-dimensional vector.
     */
    y: number;
    /**
     * Represents the z-coordinate in a 3-dimensional vector.
     */
    z: number;
    /**
     * Constructs a new instance of the Vector3f class.
     */
    constructor();
    /**
     * Constructs a new 3D vector.
     * @param x - The X component of the vector (optional).
     * @param y - The Y component of the vector (optional).
     * @param z - The Z component of the vector (optional).
     */
    constructor(x?: number, y?: number, z?: number);
    /**
     * @description Calculates and returns the magnitude (length) of the vector.
     * @returns {number} - The magnitude of the vector.
     */
    magnitude(): number;
    /**
     * @description Returns the squared magnitude (length) of the vector.
     * @returns {number} - The squared magnitude of the vector.
     */
    sqrMagnitude(): number;
    /**
     * @description Determines if this vector is equal to the specified vector.
     * @param other - The vector to compare with.
     * @returns A boolean indicating whether the vectors are equal.
     */
    equals(other: Vector3f): boolean;
    /**
     * @description Returns a string representation of the vector.
     * @returns A string in the format "Vector3f(x, y, z)" where x, y, and z are fixed to 5 decimal places.
     */
    toString(): string;
    /**
     * @description Sets the three-dimensional coordinates of this vector.
     * @param x - The x-coordinate value to set.
     * @param y - The y-coordinate value to set.
     * @param z - The z-coordinate value to set.
     * @returns This instance with updated coordinates.
     */
    set(x: number, y: number, z: number): this;
    /**
     * @description Returns the angle in radians between the current vector and another specified vector.
     * @param other - The target vector to calculate the angle against.
     * @returns The angle in radians between the two vectors.
     */
    angleTo(other: Vector3f): number;
    /**
     * @description Clamps the length of this vector to the specified `length` and returns this vector.
     * @param length - The length to which the vector's length should be clamped.
     * @returns This vector with its length clamped to the specified value.
     */
    clampLength(length: number): this;
    /**
     * @description Creates and returns a new instance of Vector3f with the same x, y, and z values as the current vector.
     * @returns A new Vector3f object that is a clone of the current vector.
     */
    clone(): Vector3f;
    /**
     * @description Computes the cross product of the current vector with another vector and updates the current vector with the result.
     * @param other - The vector to compute the cross product with.
     * @returns The updated vector, which is the cross product of the original vector and the provided vector.
     */
    cross(other: Vector3f): this;
    /**
     * @description Calculates and returns the Euclidean distance between the current vector and another vector.
     * @param other - The target vector to calculate the distance to.
     * @returns The calculated distance as a number.
     */
    distance(other: Vector3f): number;
    /**
     * @description Divides the current vector by another vector or a scalar.
     * @param value - The divisor, which can be either a Vector3f instance or a number.
     * @returns The modified vector after division.
     */
    divide(value: number | Vector3f): this;
    /**
     * @description Returns the dot product of the vector and another vector.
     * @param other - The vector to compute the dot product with.
     * @returns The dot product as a number.
     */
    dot(other: Vector3f): number;
    /**
     * @description Returns the dimension-wise multiplication product of the vector and the given value.
     * If the value is a Vector3f, it multiplies each component (x, y, z) of the current vector by the corresponding component of the given vector.
     * If the value is a number, it multiplies each component (x, y, z) of the current vector by that number.
     * @param value - A Vector3f or a number to multiply with the vector's components
     * @returns The modified vector after multiplication
     */
    multiply(value: number | Vector3f): this;
    /**
     * Multiplies each component (x, y, z) of the vector by a given scalar.
     * @param scalar - The number to multiply each component of the vector by.
     * @returns This instance of Vector3f with updated components.
     */
    multiplyScalar(scalar: number): this;
    /**
     * @description Scales the vector to have a length of 1 and returns the modified vector.
     * @returns The normalized vector.
     */
    normalize(): this;
    /**
     * @description Projects the current vector onto the specified vector and modifies the current vector to be the result.
     * @param other - The vector onto which the current vector is projected.
     * @returns The modified current vector after projection.
     */
    project(other: Vector3f): this;
    /**
     * Projects the current vector onto the plane defined by the given normal vector.
     * @param normal - The normal vector of the plane to project onto.
     * @returns This vector after being projected onto the specified plane.
     */
    projectOnPlane(normal: Vector3f): this;
    /**
     * @description Reflects this vector across the plane defined by the normal 'normal' and returns this.
     * @param normal - The normal vector defining the reflection plane.
     * @returns This vector after being reflected.
     */
    reflect(normal: Vector3f): this;
    /**
     * @description Adds the components of another vector to this vector.
     * @param other - The vector whose components will be added to this vector.
     * @returns This vector with updated components after addition.
     */
    add(other: Vector3f): this;
    /**
     * @description Subtracts the components of the given vector from this vector and returns this vector.
     * @param other - The vector to subtract from this vector.
     * @returns This vector after subtraction.
     */
    subtract(other: Vector3f): this;
    /**
     * @description Inverts the components of this vector.
     * @returns {this} - The current instance with inverted x, y, and z values.
     */
    inverse(): this;
    /**
     * @description Linearly interpolates between the two vectors `vecA` and `vecB` by the factor `t`.
     * @param vecA - The starting vector.
     * @param vecB - The ending vector.
     * @param t - The interpolation factor, typically ranging from 0 to 1.
     * @returns A new `Vector3f` that represents the interpolated position between `vecA` and `vecB`.
     */
    static lerp(vecA: Vector3f, vecB: Vector3f, t: number): Vector3f;
    /**
     * @description Approximate comparison of the two vectors by the value of each dimension with a specified tolerance.
     * @param vec1 - The first vector to compare.
     * @param vec2 - The second vector to compare.
     * @param dist - The maximum allowed difference between corresponding dimensions for the vectors to be considered approximately equal.
     * @returns A boolean indicating whether the vectors are approximately equal within the given tolerance.
     * @example
     * let a = new Vector3f(0.0000001, 0.0000001, 0.0000001);
     * let b = new Vector3f(0.0000000, 0.0000000, 0.0);
     * Vector3f.compareApproximately(a, b, 0.0001); // true
     */
    static compareApproximately(vec1: Vector3f, vec2: Vector3f, dist: number): boolean;
    /**
     * @description Returns a new vector containing the largest value of each component from the two input vectors.
     * @param vecA - The first vector to compare.
     * @param vecB - The second vector to compare.
     * @returns A new Vector3f instance with components set to the maximum values from vecA and vecB.
     */
    static max(vecA: Vector3f, vecB: Vector3f): Vector3f;
    /**
     * @description Returns a new vector containing the smallest value of each component from the two input vectors.
     * @param vecA - The first vector to compare.
     * @param vecB - The second vector to compare.
     * @returns A new Vector3f instance with components set to the minimum values from vecA and vecB.
     */
    static min(vecA: Vector3f, vecB: Vector3f): Vector3f;
  }
  /**
   * @class Vector4f
   * A four dimensional vector.
   * @example
   * let zero_p = new Vector4f();
   * let custom_p = new Vector4f(88.8, 88.8, 88.8, 88.8);
   */
  class Vector4f {
    /**
     * Represents the x-coordinate in a four-dimensional vector.
     */
    x: number;
    /**
     * Represents the y-coordinate in a four-dimensional vector.
     */
    y: number;
    /**
     * Represents the z-coordinate in a four-dimensional vector.
     */
    z: number;
    /**
     * Represents the w component of a four-dimensional vector.
     */
    w: number;
    /**
     * Constructs a new instance of the Vector4f class.
     */
    constructor();
    /**
     * Constructs a new 4-dimensional vector.
     * @param x - The x component of the vector (optional).
     * @param y - The y component of the vector (optional).
     * @param z - The z component of the vector (optional).
     * @param w - The w component of the vector (optional).
     */
    constructor(x?: number, y?: number, z?: number, w?: number);
    /**
     * Constructs a new 4-dimensional vector from a 3-dimensional vector.
     * @param x - A 3-dimensional vector representing the first three components of the new vector. The fourth component is assumed to be 0.
     */
    constructor(x: Vector3f);
    /**
     * Constructs a new instance of the Vector4f class.
     * @param x - An instance of Vector4f to initialize the new object with.
     */
    constructor(x: Vector4f);
    /**
     * @description Sets the four-dimensional components of this vector.
     * @param x - The value for the x component.
     * @param y - The value for the y component.
     * @param z - The value for the z component.
     * @param w - The value for the w component.
     * @returns This instance with updated components.
     */
    set(x: number, y: number, z: number, w: number): this;
    /**
     * @returns The length (magnitude) of the vector.
     * @description Calculates and returns the Euclidean length (magnitude) of the vector.
     */
    magnitude(): number;
    /**
     * @returns The squared magnitude (length) of the vector.
     * @description Calculates and returns the squared magnitude of the vector, which is the dot product of the vector with itself.
     */
    sqrMagnitude(): number;
    /**
     * @description Adds the components of `other` to this Vector4f.
     * @param other - The Vector4f whose components will be added to this vector.
     * @returns This Vector4f after addition.
     */
    add(other: Vector4f): this;
    /**
     * @description Subtracts the components of the given vector from this vector and returns this vector.
     * @param other - The vector to subtract from this vector.
     * @returns This vector after subtraction.
     */
    subtract(other: Vector4f): this;
    /**
     * @description Clamps the length of this vector to the specified `length` and returns this vector.
     * @param length - The length to which the vector's length should be clamped.
     * @returns This vector with its length clamped to the specified value.
     */
    clampLength(length: number): this;
    /**
     * @description Returns a clone of the current Vector4f instance.
     * @returns {Vector4f} - A new Vector4f object with the same values as the original.
     */
    clone(): Vector4f;
    /**
     * @description Calculates and returns the Euclidean distance between this vector and another vector in 4-dimensional space.
     * @param other - The target vector to calculate the distance to.
     * @returns The calculated distance as a number.
     */
    distance(other: Vector4f): number;
    /**
     * @description Divides each component of the vector by the corresponding component of the given vector.
     * @param other - The vector to divide by.
     * @returns This vector after division.
     */
    divide(other: Vector4f): this;
    /**
     * @description Returns the dot product of the vector and another vector.
     * @param other - The vector to calculate the dot product with.
     * @returns The dot product as a number.
     */
    dot(other: Vector4f): number;
    /**
     * @description Determines if this `Vector4f` is equal to another `Vector4f`.
     * @param other - The `Vector4f` to compare with.
     * @returns A boolean indicating whether the two vectors are equal.
     */
    equals(other: Vector4f): boolean;
    /**
     * @description Returns the dimension-wise multiplication product of the vector and another vector or a scalar.
     * @param other - The vector or scalar to multiply with. If it's a Vector4f, performs element-wise multiplication. If it's a number, multiplies each component of the vector by this number.
     * @returns This vector after performing the multiplication.
     */
    multiply(other: Vector4f | number): this;
    /**
     * Multiplies each component of the vector (x, y, z, w) by a given scalar.
     * @param scalar - The number to multiply each component of the vector by.
     * @returns This instance of Vector4f with updated components.
     */
    multiplyScalar(scalar: number): this;
    /**
     * @description Scales the vector to have a length of 1 and returns the modified vector.
     * @returns {this} - The normalized vector.
     */
    normalize(): this;
    /**
     * @description Inverts the components of this Vector4f.
     * @returns {this} - The current instance of Vector4f with inverted components.
     */
    inverse(): this;
    /**
     * @description Returns a string representation of the vector.
     * @returns A string in the format "Vector4f(x, y, z, w)" where x, y, z, and w are fixed to 5 decimal places.
     */
    toString(): string;
    /**
     * @description Approximate comparison of the two vectors by the value of each dimension within a specified distance.
     * @param vec1 - The first vector to compare.
     * @param vec2 - The second vector to compare.
     * @param dist - The maximum allowed difference between corresponding dimensions of the vectors for them to be considered approximately equal.
     * @returns A boolean indicating whether the vectors are approximately equal within the given distance.
     * @example
     * let a = new Vector4f(0.0000001, 0.0000001, 0.0000001, 0.0);
     * let b = new Vector4f(0.0000000, 0.0000000, 0.0, 0.0);
     * Vector4f.compareApproximately(a, b, 0.0001); // true
     */
    static compareApproximately(vec1: Vector4f, vec2: Vector4f, dist: number): boolean;
    /**
     * @description Linearly interpolates between the two vectors `vecA` and `vecB` by the factor `t`.
     * @param vecA - The starting vector.
     * @param vecB - The ending vector.
     * @param t - The interpolation factor, typically ranging from 0 to 1.
     * @returns A new `Vector4f` that represents the interpolated position between `vecA` and `vecB`.
     */
    static lerp(vecA: Vector4f, vecB: Vector4f, t: number): Vector4f;
    /**
     * @description Returns a new vector containing the largest value of each component from the two input vectors.
     * @param vecA - The first vector to compare.
     * @param vecB - The second vector to compare.
     * @returns A new Vector4f with components being the maximum values from vecA and vecB.
     */
    static max(vecA: Vector4f, vecB: Vector4f): Vector4f;
    /**
     * @description Returns a new vector containing the smallest value of each component from the two input vectors.
     * @param vecA - The first vector to compare.
     * @param vecB - The second vector to compare.
     * @returns A new Vector4f instance with components set to the minimum values from vecA and vecB.
     */
    static min(vecA: Vector4f, vecB: Vector4f): Vector4f;
  }
  /**
   * @class
   * Describes the attributes of a vertex in a mesh.
   * @example
   * let desc = new VertexAttributeDesc();
   * desc.attribute = VertexAttributeType.Position;
   * desc.name = "position";
   */
  class VertexAttributeDesc {
    attribute?: VertexAttributeType;
    name?: string;
    componentCount?: number;
  }
  /**
   * @description Types of vertex attributes used in rendering.
   * @enum
   * @property Position Represents the position attribute of a vertex.
   * @property Normal Represents the normal attribute of a vertex.
   * @property Tangent Represents the tangent attribute of a vertex.
   * @property BiNormal Represents the binormal attribute of a vertex.
   * @property Color Represents the color attribute of a vertex.
   * @property Weight Represents the weight attribute of a vertex, often used for skinning.
   * @property TexCoord0 Represents the first texture coordinate attribute of a vertex.
   * @property TexCoord1 Represents the second texture coordinate attribute of a vertex.
   * @property TexCoord2 Represents the third texture coordinate attribute of a vertex.
   * @property TexCoord3 Represents the fourth texture coordinate attribute of a vertex.
   * @property TexCoord4 Represents the fifth texture coordinate attribute of a vertex.
   * @property TexCoord5 Represents the sixth texture coordinate attribute of a vertex.
   * @property TexCoord6 Represents the seventh texture coordinate attribute of a vertex.
   * @property TexCoord7 Represents the eighth texture coordinate attribute of a vertex.
   * @property UserDefine0 Represents a user-defined attribute of a vertex.
   * @property UserDefine1 Represents another user-defined attribute of a vertex.
   * @property Indices Represents the indices attribute of a vertex, typically used for bone indices in skinning.
   * @property PositionOffset Represents an offset to the position attribute of a vertex.
   * @property NormalOffset Represents an offset to the normal attribute of a vertex.
   * @property TangentOffset Represents an offset to the tangent attribute of a vertex.
   * @property Unknown Represents an unknown or undefined vertex attribute type.
   */
  enum VertexAttributeType {
    Position,
    Normal,
    Tangent,
    BiNormal,
    Color,
    Weight,
    TexCoord0,
    TexCoord1,
    TexCoord2,
    TexCoord3,
    TexCoord4,
    TexCoord5,
    TexCoord6,
    TexCoord7,
    UserDefine0,
    UserDefine1,
    Indices,
    PositionOffset,
    NormalOffset,
    TangentOffset,
    Unknown
  }
  /**
   * @description Defines local vertical alignment types for text typesetting, which refers to the vertical alignment relative to the writing direction. Specifically, when the text is written horizontally, this alignment corresponds to the visually vertical direction. Conversely, in vertical writing mode, this alignment translates to the visually horizontal direction.
   * @enum
   * @property Top - Align to top edge.
   * @property Center - Center vertically.
   * @property Bottom - Align to bottom edge.
   */
  enum VerticalAlignment {
    Top,
    Center,
    Bottom
  }
  /**
   * @class VFXEffectBlock
   * @extends Component
   * @description Component that controls a visual effect instance, including playback, seed, camera binding, and exposed slot values.
   */
  class VisualEffect extends Component {
    protected constructor();
    /**
     * @description The VFX profile asset used by this effect.
     * @type {VisualEffectAsset}
     */
    get asset(): VisualEffectAsset;
    set asset(value: VisualEffectAsset);
    /**
     * @description Stop the visual effect playback.
     * @returns {void}
     */
    stop(): void;
    /**
     * @description Set the random seed for the VFX simulation.
     * @param {number} seed Random seed value
     * @returns {void}
     */
    setStartSeed(seed: number): void;
    /**
     * @description Reset the visual effect to its initial state.
     * @returns {void}
     */
    reset(): void;
    /**
     * @description Start or resume the visual effect playback.
     * @returns {void}
     */
    play(): void;
    /**
     * @description Pause the visual effect playback.
     * @returns {void}
     */
    pause(): void;
    /**
     * @description Whether the visual effect is currently playing.
     * @type {boolean}
     */
    get isPlaying(): boolean;
  }
  /**
   * @class VisualEffectAsset
   * @extends AObject
   * @description Represents a VFX profile resource.
   * It stores graph structure, point caches, attribute maps,
   * and simulation settings (such as instancing and prewarm).
   * Used as the asset backing a VisualEffect component.
   */
  class VisualEffectAsset extends AObject {
    protected constructor();
  }
  /**
   * @description WrapMode
   * @enum
   * @property Repeat    Tiles the texture, creating a repeating pattern.
   * @property Clamp     Clamps the texture to the last pixel at the edge.
   * @property Mirror    Tiles the texture, creating a repeating pattern by mirroring it at every integer boundary.
   */
  enum WrapMode {
    Repeat,
    Clamp,
    Mirror
  }
  interface UserGlobalType {
      [key: string]: any;
  }
  /**
   * Global
   * <br/>Global is a global object that can be used to store global variables.
   * <br/>You can use Global to store global variables that are used in multiple scripts.
   */
  const Global: UserGlobalType;
}
