import { Component, Object3D, WonderlandEngine, type ComponentConstructor } from "@wonderlandengine/api";
import { Matrix3, Matrix4, Quaternion, Quaternion2, Vector3 } from "../../type_definitions/array_type_definitions.js";
import { ComponentCustomCloneParams, ComponentDeepCloneParams } from "./component_utils.js";
export declare class ObjectCloneParams {
    /** Defaults to the object to clone parent, null can be used to specify u want the scene root as the parent */
    myCloneParent: Object3D | null | undefined;
    /** Ignores components that are not clonable */
    myIgnoreNonCloneable: boolean;
    /** All components are ignored, cloning only the object hierarchy */
    myIgnoreComponents: boolean;
    /** Clones only the given object without the descendants */
    myIgnoreDescendants: boolean;
    /** Ignores all component types in this list (example: `["mesh"]`), has lower priority over `myComponentsToInclude` */
    myComponentsToIgnore: string[];
    /** Clones only the component types in this list (example: `["mesh"]`), has higher priority over `myComponentsToIgnore`, if empty it's ignored */
    myComponentsToInclude: string[];
    /** Returns true if the component must be ignored. It's called after the previous filters */
    myIgnoreComponentCallback: ((component: Component) => boolean) | null;
    /** Ignores all the objects in this list, has lower priority over `myDescendantsToInclude` */
    myDescendantsToIgnore: Object3D[];
    /** Clones only the objects in this list, has higher priority over `myDescendantsToIgnore`, if empty it's ignored */
    myDescendantsToInclude: Object3D[];
    /** Returns true if the object must be ignored. It's called after the previous filters */
    myIgnoreDescendantCallback: ((component: Object3D) => boolean) | null;
    /** Uses the default component clone function */
    myUseDefaultComponentClone: boolean;
    /** Uses the default component clone function only as fallback, that is if there is no custom component clone */
    myUseDefaultComponentCloneAsFallback: boolean;
    /** Automatically starts the component even if it's cloned not activated, keeping it not active. This also triggers `onActivate` and `onDeactivate` once */
    myDefaultComponentCloneAutoStartIfNotActive: boolean;
    /** Uses the default object clone function, ignoring all the other clone settings but `myCloneParent` and `myDefaultComponentCloneAutoStartIfNotActive` */
    myUseDefaultObjectClone: boolean;
    /** Uses the default object clone function only as fallback, that is if the object is not PP cloneable */
    myUseDefaultObjectCloneAsFallback: boolean;
    /** Used to specify if the object components must be deep cloned or not, you can also override the behavior for specific components and variables */
    myComponentDeepCloneParams: ComponentDeepCloneParams;
    /** This class can be filled with whatever custom paramater the component clone functions could need */
    myComponentCustomCloneParams: ComponentCustomCloneParams;
}
export declare function getPosition(object: Readonly<Object3D>): Vector3;
export declare function getPosition<T extends Vector3>(object: Readonly<Object3D>, outPosition: T): T;
export declare function getPositionWorld(object: Readonly<Object3D>): Vector3;
export declare function getPositionWorld<T extends Vector3>(object: Readonly<Object3D>, outPosition: T): T;
export declare function getPositionLocal(object: Readonly<Object3D>): Matrix3;
export declare function getPositionLocal<T extends Vector3>(object: Readonly<Object3D>, outPosition: T): T;
export declare function getRotation(object: Readonly<Object3D>): Vector3;
export declare function getRotation<T extends Vector3>(object: Readonly<Object3D>, outRotation: T): T;
export declare function getRotationDegrees(object: Readonly<Object3D>): Vector3;
export declare function getRotationDegrees<T extends Vector3>(object: Readonly<Object3D>, outRotation: T): T;
export declare function getRotationRadians(object: Readonly<Object3D>): Vector3;
export declare function getRotationRadians<T extends Vector3>(object: Readonly<Object3D>, outRotation: T): T;
export declare function getRotationMatrix(object: Readonly<Object3D>): Matrix3;
export declare function getRotationMatrix<T extends Matrix3>(object: Readonly<Object3D>, outRotation: T): T;
export declare function getRotationQuat(object: Readonly<Object3D>): Quaternion;
export declare function getRotationQuat<T extends Quaternion>(object: Readonly<Object3D>, outRotation: T): T;
export declare function getRotationWorld(object: Readonly<Object3D>): Vector3;
export declare function getRotationWorld<T extends Vector3>(object: Readonly<Object3D>, outRotation: T): T;
export declare function getRotationWorldDegrees(object: Readonly<Object3D>): Vector3;
export declare function getRotationWorldDegrees<T extends Vector3>(object: Readonly<Object3D>, outRotation: T): T;
export declare const getRotationWorldRadians: {
    (object: Readonly<Object3D>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, outRotation: T): T;
};
export declare const getRotationWorldMatrix: {
    (object: Readonly<Object3D>): Matrix3;
    <T extends Matrix3>(object: Readonly<Object3D>, outRotation: T): T;
};
export declare function getRotationWorldQuat(object: Readonly<Object3D>): Quaternion;
export declare function getRotationWorldQuat<T extends Quaternion>(object: Readonly<Object3D>, outRotation: T): T;
export declare function getRotationLocal(object: Readonly<Object3D>): Vector3;
export declare function getRotationLocal<T extends Vector3>(object: Readonly<Object3D>, outRotation: T): T;
export declare function getRotationLocalDegrees(object: Readonly<Object3D>): Vector3;
export declare function getRotationLocalDegrees<T extends Vector3>(object: Readonly<Object3D>, outRotation: T): T;
export declare const getRotationLocalRadians: {
    (object: Readonly<Object3D>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, outRotation: T): T;
};
export declare const getRotationLocalMatrix: {
    (object: Readonly<Object3D>): Matrix3;
    <T extends Matrix3>(object: Readonly<Object3D>, outRotation: T): T;
};
export declare function getRotationLocalQuat(object: Readonly<Object3D>): Quaternion;
export declare function getRotationLocalQuat<T extends Quaternion>(object: Readonly<Object3D>, outRotation: T): T;
export declare function getScale(object: Readonly<Object3D>): Vector3;
export declare function getScale<T extends Vector3>(object: Readonly<Object3D>, outScale: T): T;
export declare function getScaleWorld(object: Readonly<Object3D>): Vector3;
export declare function getScaleWorld<T extends Vector3>(object: Readonly<Object3D>, outScale: T): T;
export declare function getScaleLocal(object: Readonly<Object3D>): Vector3;
export declare function getScaleLocal<T extends Vector3>(object: Readonly<Object3D>, outScale: T): T;
export declare function getTransform(object: Readonly<Object3D>): Matrix4;
export declare function getTransform<T extends Matrix4>(object: Readonly<Object3D>, outTransform: T): T;
export declare function getTransformMatrix(object: Readonly<Object3D>): Matrix4;
export declare function getTransformMatrix<T extends Matrix4>(object: Readonly<Object3D>, outTransform: T): T;
export declare function getTransformQuat(object: Readonly<Object3D>): Quaternion2;
export declare function getTransformQuat<T extends Quaternion2>(object: Readonly<Object3D>, outTransform: T): T;
export declare function getTransformWorld(object: Readonly<Object3D>): Matrix4;
export declare function getTransformWorld<T extends Matrix4>(object: Readonly<Object3D>, outTransform: T): T;
export declare const getTransformWorldMatrix: {
    (object: Readonly<Object3D>): Matrix4;
    <T extends Matrix4>(object: Readonly<Object3D>, outTransform: T): T;
};
export declare function getTransformWorldQuat(object: Readonly<Object3D>): Quaternion2;
export declare function getTransformWorldQuat<T extends Quaternion2>(object: Readonly<Object3D>, outTransform: T): T;
export declare function getTransformLocal(object: Readonly<Object3D>): Matrix4;
export declare function getTransformLocal<T extends Matrix4>(object: Readonly<Object3D>, outTransform: T): T;
export declare const getTransformLocalMatrix: {
    (object: Readonly<Object3D>): Matrix4;
    <T extends Matrix4>(object: Readonly<Object3D>, outTransform: T): T;
};
export declare function getTransformLocalQuat(object: Readonly<Object3D>): Quaternion2;
export declare function getTransformLocalQuat<T extends Quaternion2>(object: Readonly<Object3D>, outTransform: T): T;
export declare function getAxes(object: Readonly<Object3D>): [Vector3, Vector3, Vector3];
export declare function getAxes<T extends Vector3, U extends Vector3, V extends Vector3>(object: Readonly<Object3D>, outAxes: [T, U, V]): [T, U, V];
export declare function getAxesWorld(object: Readonly<Object3D>): [Vector3, Vector3, Vector3];
export declare function getAxesWorld<T extends Vector3, U extends Vector3, V extends Vector3>(object: Readonly<Object3D>, outAxes: [T, U, V]): [T, U, V];
export declare function getAxesLocal(object: Readonly<Object3D>): [Vector3, Vector3, Vector3];
export declare function getAxesLocal<T extends Vector3, U extends Vector3, V extends Vector3>(object: Readonly<Object3D>, outAxes: [T, U, V]): [T, U, V];
export declare function getForward(object: Readonly<Object3D>): Vector3;
export declare function getForward<T extends Vector3>(object: Readonly<Object3D>, outForward: T): T;
export declare const getForwardWorld: {
    (object: Readonly<Object3D>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, outForward: T): T;
};
export declare const getForwardLocal: {
    (object: Readonly<Object3D>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, outForward: T): T;
};
export declare function getBackward(object: Readonly<Object3D>): Vector3;
export declare function getBackward<T extends Vector3>(object: Readonly<Object3D>, outBackward: T): T;
export declare const getBackwardWorld: {
    (object: Readonly<Object3D>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, outBackward: T): T;
};
export declare const getBackwardLocal: {
    (object: Readonly<Object3D>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, outBackward: T): T;
};
export declare function getUp(object: Readonly<Object3D>): Vector3;
export declare function getUp<T extends Vector3>(object: Readonly<Object3D>, outUp: T): T;
export declare const getUpWorld: {
    (object: Readonly<Object3D>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, outUp: T): T;
};
export declare const getUpLocal: {
    (object: Readonly<Object3D>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, outUp: T): T;
};
export declare function getDown(object: Readonly<Object3D>): Vector3;
export declare function getDown<T extends Vector3>(object: Readonly<Object3D>, outDown: T): T;
export declare const getDownWorld: {
    (object: Readonly<Object3D>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, outDown: T): T;
};
export declare const getDownLocal: {
    (object: Readonly<Object3D>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, outDown: T): T;
};
export declare function getLeft(object: Readonly<Object3D>): Vector3;
export declare function getLeft<T extends Vector3>(object: Readonly<Object3D>, outLeft: T): T;
export declare const getLeftWorld: {
    (object: Readonly<Object3D>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, outLeft: T): T;
};
export declare const getLeftLocal: {
    (object: Readonly<Object3D>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, outLeft: T): T;
};
export declare function getRight(object: Readonly<Object3D>): Vector3;
export declare function getRight<T extends Vector3>(object: Readonly<Object3D>, outRight: T): T;
export declare const getRightWorld: {
    (object: Readonly<Object3D>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, outRight: T): T;
};
export declare const getRightLocal: {
    (object: Readonly<Object3D>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, outRight: T): T;
};
export declare function setPosition(object: Object3D, position: Readonly<Vector3>): Object3D;
export declare function setPositionWorld(object: Object3D, position: Readonly<Vector3>): Object3D;
export declare function setPositionLocal(object: Object3D, position: Readonly<Vector3>): Object3D;
export declare function setRotation(object: Object3D, rotation: Readonly<Vector3>): Object3D;
export declare function setRotationDegrees(object: Object3D, rotation: Readonly<Vector3>): Object3D;
export declare function setRotationRadians(object: Object3D, rotation: Readonly<Vector3>): Object3D;
export declare function setRotationMatrix(object: Object3D, rotation: Readonly<Matrix3>): Object3D;
export declare function setRotationQuat(object: Object3D, rotation: Readonly<Quaternion>): Object3D;
export declare function setRotationWorld(object: Object3D, rotation: Readonly<Vector3>): Object3D;
export declare const setRotationWorldDegrees: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
export declare const setRotationWorldRadians: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
export declare const setRotationWorldMatrix: (object: Object3D, rotation: Readonly<Matrix3>) => Object3D;
export declare function setRotationWorldQuat(object: Object3D, rotation: Readonly<Quaternion>): Object3D;
export declare function setRotationLocal(object: Object3D, rotation: Readonly<Vector3>): Object3D;
export declare const setRotationLocalDegrees: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
export declare const setRotationLocalRadians: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
export declare const setRotationLocalMatrix: (object: Object3D, rotation: Readonly<Matrix3>) => Object3D;
export declare function setRotationLocalQuat(object: Object3D, rotation: Readonly<Quaternion>): Object3D;
export declare function setScale(object: Object3D, scale: Readonly<Vector3>): Object3D;
export declare function setScale(object: Object3D, uniformScale: number): Object3D;
export declare const setScaleWorld: {
    (object: Object3D, scale: Readonly<Vector3>): Object3D;
    (object: Object3D, uniformScale: number): Object3D;
};
export declare const setScaleLocal: {
    (object: Object3D, scale: Readonly<Vector3>): Object3D;
    (object: Object3D, uniformScale: number): Object3D;
};
export declare function setAxes(object: Object3D, left?: Readonly<Vector3>, up?: Readonly<Vector3>, forward?: Readonly<Vector3>): Object3D;
export declare function setAxesWorld(object: Object3D, left?: Readonly<Vector3>, up?: Readonly<Vector3>, forward?: Readonly<Vector3>): Object3D;
export declare function setAxesLocal(object: Object3D, left?: Readonly<Vector3>, up?: Readonly<Vector3>, forward?: Readonly<Vector3>): Object3D;
export declare function setForward(object: Object3D, forward: Readonly<Vector3>, up?: Readonly<Vector3>, left?: Readonly<Vector3>): Object3D;
export declare const setForwardWorld: (object: Object3D, forward: Readonly<Vector3>, up?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
export declare const setForwardLocal: (object: Object3D, forward: Readonly<Vector3>, up?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
export declare function setBackward(object: Object3D, backward: Readonly<Vector3>, up?: Readonly<Vector3>, left?: Readonly<Vector3>): Object3D;
export declare const setBackwardWorld: (object: Object3D, backward: Readonly<Vector3>, up?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
export declare const setBackwardLocal: (object: Object3D, backward: Readonly<Vector3>, up?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
export declare function setUp(object: Object3D, up: Readonly<Vector3>, forward?: Readonly<Vector3>, left?: Readonly<Vector3>): Object3D;
export declare const setUpWorld: (object: Object3D, up: Readonly<Vector3>, forward?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
export declare const setUpLocal: (object: Object3D, up: Readonly<Vector3>, forward?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
export declare function setDown(object: Object3D, down: Readonly<Vector3>, forward?: Readonly<Vector3>, left?: Readonly<Vector3>): Object3D;
export declare const setDownWorld: (object: Object3D, down: Readonly<Vector3>, forward?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
export declare const setDownLocal: (object: Object3D, down: Readonly<Vector3>, forward?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
export declare function setLeft(object: Object3D, left: Readonly<Vector3>, up?: Readonly<Vector3>, forward?: Readonly<Vector3>): Object3D;
export declare const setLeftWorld: (object: Object3D, left: Readonly<Vector3>, up?: Readonly<Vector3>, forward?: Readonly<Vector3>) => Object3D;
export declare const setLeftLocal: (object: Object3D, left: Readonly<Vector3>, up?: Readonly<Vector3>, forward?: Readonly<Vector3>) => Object3D;
export declare function setRight(object: Object3D, right: Readonly<Vector3>, up?: Readonly<Vector3>, forward?: Readonly<Vector3>): Object3D;
export declare const setRightWorld: (object: Object3D, right: Readonly<Vector3>, up?: Readonly<Vector3>, forward?: Readonly<Vector3>) => Object3D;
export declare const setRightLocal: (object: Object3D, right: Readonly<Vector3>, up?: Readonly<Vector3>, forward?: Readonly<Vector3>) => Object3D;
export declare function setTransform(object: Object3D, transform: Readonly<Matrix4>): Object3D;
export declare function setTransformMatrix(object: Object3D, transform: Readonly<Matrix4>): Object3D;
export declare function setTransformQuat(object: Object3D, transform: Readonly<Quaternion2>): Object3D;
export declare function setTransformWorld(object: Object3D, transform: Readonly<Matrix4>): Object3D;
export declare const setTransformWorldMatrix: (object: Object3D, transform: Readonly<Matrix4>) => Object3D;
export declare function setTransformWorldQuat(object: Object3D, transform: Readonly<Quaternion2>): Object3D;
export declare function setTransformLocal(object: Object3D, transform: Readonly<Matrix4>): Object3D;
export declare const setTransformLocalMatrix: (object: Object3D, transform: Readonly<Matrix4>) => Object3D;
export declare function setTransformLocalQuat(object: Object3D, transform: Readonly<Quaternion2>): Object3D;
export declare function resetPosition(object: Object3D): Object3D;
export declare const resetPositionWorld: (object: Object3D) => Object3D;
export declare const resetPositionLocal: (object: Object3D) => Object3D;
export declare function resetRotation(object: Object3D): Object3D;
export declare const resetRotationWorld: (object: Object3D) => Object3D;
export declare const resetRotationLocal: (object: Object3D) => Object3D;
export declare function resetScale(object: Object3D): Object3D;
export declare const resetScaleWorld: (object: Object3D) => Object3D;
export declare const resetScaleLocal: (object: Object3D) => Object3D;
export declare function resetTransform(object: Object3D): Object3D;
export declare function resetTransformWorld(object: Object3D): Object3D;
export declare function resetTransformLocal(object: Object3D): Object3D;
export declare function translate(object: Object3D, translation: Readonly<Vector3>): Object3D;
export declare function translateWorld(object: Object3D, translation: Readonly<Vector3>): Object3D;
export declare function translateLocal(object: Object3D, translation: Readonly<Vector3>): Object3D;
export declare function translateObject(object: Object3D, translation: Readonly<Vector3>): Object3D;
export declare function translateAxis(object: Object3D, amount: number, direction: Readonly<Vector3>): Object3D;
export declare const translateAxisWorld: (object: Object3D, amount: number, direction: Readonly<Vector3>) => Object3D;
export declare const translateAxisLocal: (object: Object3D, amount: number, direction: Readonly<Vector3>) => Object3D;
export declare const translateAxisObject: (object: Object3D, amount: number, direction: Readonly<Vector3>) => Object3D;
export declare function rotate(object: Object3D, rotation: Readonly<Vector3>): Object3D;
export declare function rotateDegrees(object: Object3D, rotation: Readonly<Vector3>): Object3D;
export declare function rotateRadians(object: Object3D, rotation: Readonly<Vector3>): Object3D;
export declare function rotateMatrix(object: Object3D, rotation: Readonly<Matrix3>): Object3D;
export declare function rotateQuat(object: Object3D, rotation: Readonly<Quaternion>): Object3D;
export declare function rotateWorld(object: Object3D, rotation: Readonly<Vector3>): Object3D;
export declare const rotateWorldDegrees: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
export declare const rotateWorldRadians: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
export declare const rotateWorldMatrix: (object: Object3D, rotation: Readonly<Matrix3>) => Object3D;
export declare const rotateWorldQuat: (object: Object3D, rotation: Readonly<Quaternion>) => Object3D;
export declare function rotateLocal(object: Object3D, rotation: Readonly<Vector3>): Object3D;
export declare const rotateLocalDegrees: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
export declare const rotateLocalRadians: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
export declare const rotateLocalMatrix: (object: Object3D, rotation: Readonly<Matrix3>) => Object3D;
export declare const rotateLocalQuat: (object: Object3D, rotation: Readonly<Quaternion>) => Object3D;
export declare function rotateObject(object: Object3D, rotation: Readonly<Vector3>): Object3D;
export declare const rotateObjectDegrees: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
export declare const rotateObjectRadians: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
export declare const rotateObjectMatrix: (object: Object3D, rotation: Readonly<Matrix3>) => Object3D;
export declare function rotateObjectQuat(object: Object3D, rotation: Readonly<Quaternion>): Object3D;
export declare function rotateAxis(object: Object3D, angle: number, axis: Readonly<Vector3>): Object3D;
export declare function rotateAxisDegrees(object: Object3D, angle: number, axis: Readonly<Vector3>): Object3D;
export declare function rotateAxisRadians(object: Object3D, angle: number, axis: Readonly<Vector3>): Object3D;
export declare function rotateAxisWorld(object: Object3D, angle: number, axis: Readonly<Vector3>): Object3D;
export declare function rotateAxisWorldDegrees(object: Object3D, angle: number, axis: Readonly<Vector3>): Object3D;
export declare const rotateAxisWorldRadians: (object: Object3D, angle: number, axis: Readonly<Vector3>) => Object3D;
export declare function rotateAxisLocal(object: Object3D, angle: number, axis: Readonly<Vector3>): Object3D;
export declare function rotateAxisLocalDegrees(object: Object3D, angle: number, axis: Readonly<Vector3>): Object3D;
export declare const rotateAxisLocalRadians: (object: Object3D, angle: number, axis: Readonly<Vector3>) => Object3D;
export declare function rotateAxisObject(object: Object3D, angle: number, axis: Readonly<Vector3>): Object3D;
export declare function rotateAxisObjectDegrees(object: Object3D, angle: number, axis: Readonly<Vector3>): Object3D;
export declare const rotateAxisObjectRadians: (object: Object3D, angle: number, axis: Readonly<Vector3>) => Object3D;
export declare function rotateAround(object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare function rotateAroundDegrees(object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare function rotateAroundRadians(object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare function rotateAroundMatrix(object: Object3D, rotation: Readonly<Matrix3>, origin: Readonly<Vector3>): Object3D;
export declare function rotateAroundQuat(object: Object3D, rotation: Readonly<Quaternion>, origin: Readonly<Vector3>): Object3D;
export declare function rotateAroundWorld(object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare const rotateAroundWorldDegrees: (object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
export declare const rotateAroundWorldRadians: (object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
export declare const rotateAroundWorldMatrix: (object: Object3D, rotation: Readonly<Matrix3>, origin: Readonly<Vector3>) => Object3D;
export declare const rotateAroundWorldQuat: (object: Object3D, rotation: Readonly<Quaternion>, origin: Readonly<Vector3>) => Object3D;
export declare function rotateAroundLocal(object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare const rotateAroundLocalDegrees: (object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
export declare const rotateAroundLocalRadians: (object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
export declare const rotateAroundLocalMatrix: (object: Object3D, rotation: Readonly<Matrix3>, origin: Readonly<Vector3>) => Object3D;
export declare const rotateAroundLocalQuat: (object: Object3D, rotation: Readonly<Quaternion>, origin: Readonly<Vector3>) => Object3D;
export declare function rotateAroundObject(object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare const rotateAroundObjectDegrees: (object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
export declare const rotateAroundObjectRadians: (object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
export declare const rotateAroundObjectMatrix: (object: Object3D, rotation: Readonly<Matrix3>, origin: Readonly<Vector3>) => Object3D;
export declare const rotateAroundObjectQuat: (object: Object3D, rotation: Readonly<Quaternion>, origin: Readonly<Vector3>) => Object3D;
export declare function rotateAroundAxis(object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare function rotateAroundAxisDegrees(object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare function rotateAroundAxisRadians(object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare function rotateAroundAxisWorld(object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare function rotateAroundAxisWorldDegrees(object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare const rotateAroundAxisWorldRadians: (object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
export declare function rotateAroundAxisLocal(object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare function rotateAroundAxisLocalDegrees(object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare const rotateAroundAxisLocalRadians: (object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
export declare function rotateAroundAxisObject(object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare function rotateAroundAxisObjectDegrees(object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>): Object3D;
export declare const rotateAroundAxisObjectRadians: (object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
export declare const scaleObject: {
    (object: Object3D, scale: Readonly<Vector3>): Object3D;
    (object: Object3D, uniformScale: number): Object3D;
};
export declare function lookAt(object: Object3D, position: Readonly<Vector3>, up?: Readonly<Vector3>): Object3D;
export declare const lookAtWorld: (object: Object3D, position: Readonly<Vector3>, up?: Readonly<Vector3>) => Object3D;
export declare const lookAtLocal: (object: Object3D, position: Readonly<Vector3>, up?: Readonly<Vector3>) => Object3D;
export declare function lookTo(object: Object3D, direction: Readonly<Vector3>, up?: Readonly<Vector3>): Object3D;
export declare const lookToWorld: (object: Object3D, direction: Readonly<Vector3>, up?: Readonly<Vector3>) => Object3D;
export declare const lookToLocal: (object: Object3D, direction: Readonly<Vector3>, up?: Readonly<Vector3>) => Object3D;
export declare const convertPositionObjectToWorld: {
    (object: Readonly<Object3D>, position: Readonly<Vector3>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, position: Readonly<Vector3>, outPosition: T): T;
};
export declare const convertDirectionObjectToWorld: {
    (object: Readonly<Object3D>, direction: Readonly<Vector3>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, direction: Readonly<Vector3>, outDirection: T): T;
};
export declare const convertPositionWorldToObject: {
    (object: Readonly<Object3D>, position: Readonly<Vector3>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, position: Readonly<Vector3>, outPosition: T): T;
};
export declare const convertDirectionWorldToObject: {
    (object: Readonly<Object3D>, direction: Readonly<Vector3>): Vector3;
    <T extends Vector3>(object: Readonly<Object3D>, direction: Readonly<Vector3>, outDirection: T): T;
};
export declare function convertPositionLocalToWorld(object: Readonly<Object3D>, position: Readonly<Vector3>): Vector3;
export declare function convertPositionLocalToWorld<T extends Vector3>(object: Readonly<Object3D>, position: Readonly<Vector3>, outPosition: T): T;
export declare function convertDirectionLocalToWorld(object: Readonly<Object3D>, direction: Readonly<Vector3>): Vector3;
export declare function convertDirectionLocalToWorld<T extends Vector3>(object: Readonly<Object3D>, direction: Readonly<Vector3>, outDirection: T): T;
export declare function convertPositionWorldToLocal(object: Readonly<Object3D>, position: Readonly<Vector3>): Vector3;
export declare function convertPositionWorldToLocal<T extends Vector3>(object: Readonly<Object3D>, position: Readonly<Vector3>, outPosition: T): T;
export declare function convertDirectionWorldToLocal(object: Readonly<Object3D>, direction: Readonly<Vector3>): Vector3;
export declare function convertDirectionWorldToLocal<T extends Vector3>(object: Readonly<Object3D>, direction: Readonly<Vector3>, outDirection: T): T;
export declare function convertPositionObjectToLocal(object: Readonly<Object3D>, position: Readonly<Vector3>): Vector3;
export declare function convertPositionObjectToLocal<T extends Vector3>(object: Readonly<Object3D>, position: Readonly<Vector3>, outPosition: T): T;
export declare function convertDirectionObjectToLocal(object: Readonly<Object3D>, direction: Readonly<Vector3>): Vector3;
export declare function convertDirectionObjectToLocal<T extends Vector3>(object: Readonly<Object3D>, direction: Readonly<Vector3>, outDirection: T): T;
export declare function convertPositionLocalToObject(object: Readonly<Object3D>, position: Readonly<Vector3>): Vector3;
export declare function convertPositionLocalToObject<T extends Vector3>(object: Readonly<Object3D>, position: Readonly<Vector3>, outPosition: T): T;
export declare function convertDirectionLocalToObject(object: Readonly<Object3D>, direction: Readonly<Vector3>): Vector3;
export declare function convertDirectionLocalToObject<T extends Vector3>(object: Readonly<Object3D>, direction: Readonly<Vector3>, outDirection: T): T;
export declare function convertTransformObjectToWorld<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<T>): T;
export declare function convertTransformObjectToWorld<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<Matrix4>, outTransform: T): T;
export declare const convertTransformObjectToWorldMatrix: {
    <T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<T>): T;
    <T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<Matrix4>, outTransform: T): T;
};
export declare const convertTransformObjectToWorldQuat: {
    <T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<T>): T;
    <T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<Quaternion2>, outTransform: T): T;
};
export declare function convertTransformWorldToObject<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<T>): T;
export declare function convertTransformWorldToObject<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<Matrix4>, outTransform: T): T;
export declare const convertTransformWorldToObjectMatrix: {
    <T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<T>): T;
    <T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<Matrix4>, outTransform: T): T;
};
export declare const convertTransformWorldToObjectQuat: {
    <T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<T>): T;
    <T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<Quaternion2>, outTransform: T): T;
};
export declare function convertTransformLocalToWorld<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<T>): T;
export declare function convertTransformLocalToWorld<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<Matrix4>, outTransform: T): T;
export declare function convertTransformLocalToWorldMatrix<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<T>): T;
export declare function convertTransformLocalToWorldMatrix<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<Matrix4>, outTransform: T): T;
export declare function convertTransformLocalToWorldQuat<T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<T>): T;
export declare function convertTransformLocalToWorldQuat<T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<Quaternion2>, outTransform: T): T;
export declare function convertTransformWorldToLocal<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<T>): T;
export declare function convertTransformWorldToLocal<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<Matrix4>, outTransform: T): T;
export declare function convertTransformWorldToLocalMatrix<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<T>): T;
export declare function convertTransformWorldToLocalMatrix<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<Matrix4>, outTransform: T): T;
export declare function convertTransformWorldToLocalQuat<T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<T>): T;
export declare function convertTransformWorldToLocalQuat<T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<Quaternion2>, outTransform: T): T;
export declare function convertTransformObjectToLocal<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<T>): T;
export declare function convertTransformObjectToLocal<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<Matrix4>, outTransform: T): T;
export declare function convertTransformObjectToLocalMatrix<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<T>): T;
export declare function convertTransformObjectToLocalMatrix<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<Matrix4>, outTransform: T): T;
export declare function convertTransformObjectToLocalQuat<T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<T>): T;
export declare function convertTransformObjectToLocalQuat<T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<Quaternion2>, outTransform: T): T;
export declare function convertTransformLocalToObject<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<T>): T;
export declare function convertTransformLocalToObject<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<Matrix4>, outTransform: T): T;
export declare function convertTransformLocalToObjectMatrix<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<T>): T;
export declare function convertTransformLocalToObjectMatrix<T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<Matrix4>, outTransform: T): T;
export declare function convertTransformLocalToObjectQuat<T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<T>): T;
export declare function convertTransformLocalToObjectQuat<T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<Quaternion2>, outTransform: T): T;
export declare const setParent: (object: Object3D, newParent: Object3D, keepTransformWorld?: boolean) => Object3D;
export declare function getParent(object: Readonly<Object3D>): Object3D | null;
export declare function addComponent<T extends Component>(object: Object3D, classOrType: ComponentConstructor<T> | string, paramsOrActive?: Record<string, unknown> | boolean, active?: boolean): T | null;
export declare function getComponent<T extends Component>(object: Readonly<Object3D>, classOrType: ComponentConstructor<T> | string, index?: number): T | null;
export declare function getComponentSelf<T extends Component>(object: Readonly<Object3D>, classOrType: ComponentConstructor<T> | string, index?: number): T | null;
export declare function getComponentHierarchy<T extends Component>(object: Readonly<Object3D>, classOrType: ComponentConstructor<T> | string, index?: number): T | null;
export declare function getComponentHierarchyBreadth<T extends Component>(object: Readonly<Object3D>, classOrType: ComponentConstructor<T> | string, index?: number): T | null;
export declare function getComponentHierarchyDepth<T extends Component>(object: Readonly<Object3D>, classOrType: ComponentConstructor<T> | string, index?: number): T | null;
export declare function getComponentDescendants<T extends Component>(object: Readonly<Object3D>, classOrType: ComponentConstructor<T> | string, index?: number): T | null;
export declare function getComponentDescendantsBreadth<T extends Component>(object: Readonly<Object3D>, classOrType: ComponentConstructor<T> | string, index?: number): T | null;
export declare function getComponentDescendantsDepth<T extends Component>(object: Readonly<Object3D>, classOrType: ComponentConstructor<T> | string, index?: number): T | null;
export declare function getComponentChildren<T extends Component>(object: Readonly<Object3D>, classOrType: ComponentConstructor<T> | string, index?: number): T | null;
export declare function getComponents<T extends Component>(object: Readonly<Object3D>, classOrType?: ComponentConstructor<T> | string): T[];
export declare function getComponentsSelf<T extends Component>(object: Readonly<Object3D>, classOrType?: ComponentConstructor<T> | string): T[];
export declare function getComponentsHierarchy<T extends Component>(object: Readonly<Object3D>, classOrType?: ComponentConstructor<T> | string): T[];
export declare function getComponentsHierarchyBreadth<T extends Component>(object: Readonly<Object3D>, classOrType?: ComponentConstructor<T> | string): T[];
export declare function getComponentsHierarchyDepth<T extends Component>(object: Readonly<Object3D>, classOrType?: ComponentConstructor<T> | string): T[];
export declare function getComponentsDescendants<T extends Component>(object: Readonly<Object3D>, classOrType?: ComponentConstructor<T> | string): T[];
export declare function getComponentsDescendantsBreadth<T extends Component>(object: Readonly<Object3D>, classOrType?: ComponentConstructor<T> | string): T[];
export declare function getComponentsDescendantsDepth<T extends Component>(object: Readonly<Object3D>, classOrType?: ComponentConstructor<T> | string): T[];
export declare function getComponentsChildren<T extends Component>(object: Readonly<Object3D>, classOrType?: ComponentConstructor<T> | string): T[];
export declare function setActive(object: Object3D, active: boolean): Object3D;
export declare function setActiveSelf(object: Object3D, active: boolean): Object3D;
export declare function setActiveHierarchy(object: Object3D, active: boolean): Object3D;
export declare function setActiveHierarchyBreadth(object: Object3D, active: boolean): Object3D;
export declare function setActiveHierarchyDepth(object: Object3D, active: boolean): Object3D;
export declare function setActiveDescendants(object: Object3D, active: boolean): Object3D;
export declare function setActiveDescendantsBreadth(object: Object3D, active: boolean): Object3D;
export declare function setActiveDescendantsDepth(object: Object3D, active: boolean): Object3D;
export declare function setActiveChildren(object: Object3D, active: boolean): Object3D;
export declare function hasUniformScale(object: Readonly<Object3D>): boolean;
export declare const hasUniformScaleWorld: (object: Readonly<Object3D>) => boolean;
export declare const hasUniformScaleLocal: (object: Readonly<Object3D>) => boolean;
export declare const clone: (object: Readonly<Object3D>, cloneParams?: Readonly<ObjectCloneParams>) => Object3D | null;
export declare function isCloneable(object: Readonly<Object3D>, cloneParams?: Readonly<ObjectCloneParams>): boolean;
export declare function toString(object: Readonly<Object3D>): string;
export declare const toStringExtended: (object: Readonly<Object3D>) => string;
export declare const toStringCompact: (object: Readonly<Object3D>) => string;
export declare function log(object: Readonly<Object3D>): Object3D;
export declare function logExtended(object: Readonly<Object3D>): Object3D;
export declare function logCompact(object: Readonly<Object3D>): Object3D;
export declare function warn(object: Readonly<Object3D>): Object3D;
export declare function warnExtended(object: Readonly<Object3D>): Object3D;
export declare function warnCompact(object: Readonly<Object3D>): Object3D;
export declare function error(object: Readonly<Object3D>): Object3D;
export declare function errorExtended(object: Readonly<Object3D>): Object3D;
export declare function errorCompact(object: Readonly<Object3D>): Object3D;
export declare function getObjectByName(object: Readonly<Object3D>, name: string, isRegex?: boolean, index?: number): Object3D | null;
export declare function getObjectByNameHierarchy(object: Readonly<Object3D>, name: string, isRegex?: boolean, index?: number): Object3D | null;
export declare function getObjectByNameHierarchyBreadth(object: Readonly<Object3D>, name: string, isRegex?: boolean, index?: number): Object3D | null;
export declare function getObjectByNameHierarchyDepth(object: Readonly<Object3D>, name: string, isRegex?: boolean, index?: number): Object3D | null;
export declare function getObjectByNameDescendants(object: Readonly<Object3D>, name: string, isRegex?: boolean, index?: number): Object3D | null;
export declare function getObjectByNameDescendantsBreadth(object: Readonly<Object3D>, name: string, isRegex?: boolean, index?: number): Object3D | null;
export declare function getObjectByNameDescendantsDepth(object: Readonly<Object3D>, name: string, isRegex?: boolean, index?: number): Object3D | null;
export declare function getObjectByNameChildren(object: Readonly<Object3D>, name: string, isRegex?: boolean, index?: number): Object3D | null;
export declare function getObjectsByName(object: Readonly<Object3D>, name: string, isRegex?: boolean): Object3D[];
export declare function getObjectsByNameHierarchy(object: Readonly<Object3D>, name: string, isRegex?: boolean): Object3D[];
export declare function getObjectsByNameHierarchyBreadth(object: Readonly<Object3D>, name: string, isRegex?: boolean): Object3D[];
export declare function getObjectsByNameHierarchyDepth(object: Readonly<Object3D>, name: string, isRegex?: boolean): Object3D[];
export declare function getObjectsByNameDescendants(object: Readonly<Object3D>, name: string, isRegex?: boolean): Object3D[];
export declare function getObjectsByNameDescendantsBreadth(object: Readonly<Object3D>, name: string, isRegex?: boolean): Object3D[];
export declare function getObjectsByNameDescendantsDepth(object: Readonly<Object3D>, name: string, isRegex?: boolean): Object3D[];
export declare function getObjectsByNameChildren(object: Readonly<Object3D>, name: string, isRegex?: boolean): Object3D[];
export declare function getObjectByID(object: Readonly<Object3D>, id: number): Object3D | null;
export declare function getObjectByIDHierarchy(object: Readonly<Object3D>, id: number): Object3D | null;
export declare function getObjectByIDHierarchyBreadth(object: Readonly<Object3D>, id: number): Object3D | null;
export declare function getObjectByIDHierarchyDepth(object: Readonly<Object3D>, id: number): Object3D | null;
export declare function getObjectByIDDescendants(object: Readonly<Object3D>, id: number): Object3D | null;
export declare function getObjectByIDDescendantsBreadth(object: Readonly<Object3D>, id: number): Object3D | null;
export declare function getObjectByIDDescendantsDepth(object: Readonly<Object3D>, id: number): Object3D | null;
export declare function getObjectByIDChildren(object: Readonly<Object3D>, id: number): Object3D | null;
export declare function getHierarchy(object: Readonly<Object3D>): Object3D[];
export declare function getHierarchyBreadth(object: Readonly<Object3D>): Object3D[];
export declare function getHierarchyDepth(object: Readonly<Object3D>): Object3D[];
export declare function getDescendants(object: Readonly<Object3D>): Object3D[];
export declare function getDescendantsBreadth(object: Readonly<Object3D>): Object3D[];
export declare function getDescendantsDepth(object: Readonly<Object3D>): Object3D[];
export declare function getChildren(object: Readonly<Object3D>): Object3D[];
export declare function getSelf(object: Readonly<Object3D>): Object3D;
export declare function addChild(object: Object3D): Object3D;
export declare function getName(object: Readonly<Object3D>): string;
export declare function setName(object: Object3D, name: string): Object3D;
export declare function getEngine(object: Readonly<Object3D>): WonderlandEngine;
export declare function getID(object: Readonly<Object3D>): number;
export declare function markDirty(object: Object3D): Object3D;
export declare function isTransformChanged(object: Readonly<Object3D>): boolean;
export declare function destroy(object: Object3D): void;
export declare function reserveObjects(object: Readonly<Object3D>, count: number): Object3D;
export declare function reserveObjectsSelf(object: Readonly<Object3D>, count: number): Object3D;
export declare function reserveObjectsHierarchy(object: Readonly<Object3D>, count: number): Object3D;
export declare function reserveObjectsDescendants(object: Readonly<Object3D>, count: number): Object3D;
export declare function reserveObjectsChildren(object: Readonly<Object3D>, count: number): Object3D;
export declare function getComponentsAmountMap(object: Readonly<Object3D>): Map<string, number>;
export declare function getComponentsAmountMap(object: Readonly<Object3D>, outComponentsAmountMap: Map<string, number>): Map<string, number>;
export declare function getComponentsAmountMapSelf(object: Readonly<Object3D>): Map<string, number>;
export declare function getComponentsAmountMapSelf(object: Readonly<Object3D>, outComponentsAmountMap: Map<string, number>): Map<string, number>;
export declare function getComponentsAmountMapHierarchy(object: Readonly<Object3D>): Map<string, number>;
export declare function getComponentsAmountMapHierarchy(object: Readonly<Object3D>, outComponentsAmountMap: Map<string, number>): Map<string, number>;
export declare function getComponentsAmountMapDescendants(object: Readonly<Object3D>): Map<string, number>;
export declare function getComponentsAmountMapDescendants(object: Readonly<Object3D>, outComponentsAmountMap: Map<string, number>): Map<string, number>;
export declare function getComponentsAmountMapChildren(object: Readonly<Object3D>): Map<string, number>;
export declare function getComponentsAmountMapChildren(object: Readonly<Object3D>, outComponentsAmountMap: Map<string, number>): Map<string, number>;
export declare function getComponentObjects<T extends Component>(objects: Object3D[], classOrType: ComponentConstructor<T> | string, index?: number): T | null;
export declare function getComponentsObjects<T extends Component>(objects: Object3D[], classOrType?: ComponentConstructor<T> | string): T[];
export declare function setActiveObjects(objects: Object3D[], active: boolean): void;
export declare function getObjectByNameObjects(objects: Object3D[], name: string, isRegex?: boolean, index?: number): Object3D | null;
export declare function getObjectsByNameObjects(objects: Object3D[], name: string, isRegex?: boolean): Object3D[];
export declare function getObjectByIDObjects(objects: Object3D[], id: number, index?: number): Object3D | null;
export declare function getObjectsByIDObjects(objects: Object3D[], id: number): Object3D[];
export declare function wrapObject(id: number, engine?: Readonly<WonderlandEngine> | null): Object3D | null;
/**
 * How to use
 *
 * By default the functions work on `World` space, rotations are in `Degrees` and transforms are `Matrix4` (and not `Quat2`)
 * For functions that work with rotations, `Matrix` means `Matrix3` and `Quat` means `Quat`
 * For functions that work with transforms, `Matrix` means `Matrix4` and `Quat` means `Quat2`
 *
 *
 * You can add a suffix like `World`/`Local`/`Object` at the end of some functions to specify the space, example:
 *     - `getPositionLocal` to get the position in local space (parent space)
 *     - `translateObject` to translate in object space
 *
 *
 * For rotations u can add a suffix like `Degrees`/`Radians`/`Quat`/`Matrix` to use a specific version, example:
 *     - `getRotationDegrees`
 *     - `setRotationLocalMatrix`
 *     - `rotateWorldQuat`
 *
 *
 * For transform u can add a suffix like `Quat`/`Matrix` to use a specific version, example:
 *     - `getTransformQuat`
 *     - `setTransformWorldMatrix`
 *
 *
 * Some functions let you specify if u want them to work on the `Hierarchy`/`Descendants`/`Children`/`Self` where:
 *     - `Self`: the current object only
 *     - `Children`: direct children of the object
 *     - `Descendants`: all the children of the object, including child of child and so on
 *     - `Hierarchy`: `Descendants` plus the current object
 *
 * Examples:
 *     - `getComponent`
 *     - `getComponentHierarchy`
 *     - `getComponentsAmountMapDescendants`
 *     - `setActiveChildren`
 *     - `setActiveSelf`
 *
 * By default the functions work on the `Hierarchy`
 *
 * On some of the functions where u can specify `Hierarchy`/`Descendants` u can also specify if the algorithm should explore by `Breadth`/`Depth`, example:
 *     - `getComponentHierarchyBreadth`
 *     - `setActiveDescendantsDepth`
 *
 * By default the functions explore by `Breadth`
 *
 * The functions leave u the choice of forwarding an out parameter or just get the return value, example:
 *     - `let position = ObjectUtils.getPosition(object)`
 *     - `ObjectUtils.getPosition(object, position)`
 *     - the out parameter is always the last one
 *
 *
 * If a method require an engine parameter, u can always avoid specifying it and it will by default use the current main engine
 * If a method require a scene parameter, u can always avoid specifying it and it will by default use the scene from the current main engine
 */
export declare const ObjectUtils: {
    readonly getPosition: typeof getPosition;
    readonly getPositionWorld: typeof getPositionWorld;
    readonly getPositionLocal: typeof getPositionLocal;
    readonly getRotation: typeof getRotation;
    readonly getRotationDegrees: typeof getRotationDegrees;
    readonly getRotationRadians: typeof getRotationRadians;
    readonly getRotationMatrix: typeof getRotationMatrix;
    readonly getRotationQuat: typeof getRotationQuat;
    readonly getRotationWorld: typeof getRotationWorld;
    readonly getRotationWorldDegrees: typeof getRotationWorldDegrees;
    readonly getRotationWorldRadians: {
        (object: Readonly<Object3D>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, outRotation: T): T;
    };
    readonly getRotationWorldMatrix: {
        (object: Readonly<Object3D>): Matrix3;
        <T extends Matrix3>(object: Readonly<Object3D>, outRotation: T): T;
    };
    readonly getRotationWorldQuat: typeof getRotationWorldQuat;
    readonly getRotationLocal: typeof getRotationLocal;
    readonly getRotationLocalDegrees: typeof getRotationLocalDegrees;
    readonly getRotationLocalRadians: {
        (object: Readonly<Object3D>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, outRotation: T): T;
    };
    readonly getRotationLocalMatrix: {
        (object: Readonly<Object3D>): Matrix3;
        <T extends Matrix3>(object: Readonly<Object3D>, outRotation: T): T;
    };
    readonly getRotationLocalQuat: typeof getRotationLocalQuat;
    readonly getScale: typeof getScale;
    readonly getScaleWorld: typeof getScaleWorld;
    readonly getScaleLocal: typeof getScaleLocal;
    readonly getTransform: typeof getTransform;
    readonly getTransformMatrix: typeof getTransformMatrix;
    readonly getTransformQuat: typeof getTransformQuat;
    readonly getTransformWorld: typeof getTransformWorld;
    readonly getTransformWorldMatrix: {
        (object: Readonly<Object3D>): Matrix4;
        <T extends Matrix4>(object: Readonly<Object3D>, outTransform: T): T;
    };
    readonly getTransformWorldQuat: typeof getTransformWorldQuat;
    readonly getTransformLocal: typeof getTransformLocal;
    readonly getTransformLocalMatrix: {
        (object: Readonly<Object3D>): Matrix4;
        <T extends Matrix4>(object: Readonly<Object3D>, outTransform: T): T;
    };
    readonly getTransformLocalQuat: typeof getTransformLocalQuat;
    readonly getAxes: typeof getAxes;
    readonly getAxesWorld: typeof getAxesWorld;
    readonly getAxesLocal: typeof getAxesLocal;
    readonly getForward: typeof getForward;
    readonly getForwardWorld: {
        (object: Readonly<Object3D>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, outForward: T): T;
    };
    readonly getForwardLocal: {
        (object: Readonly<Object3D>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, outForward: T): T;
    };
    readonly getBackward: typeof getBackward;
    readonly getBackwardWorld: {
        (object: Readonly<Object3D>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, outBackward: T): T;
    };
    readonly getBackwardLocal: {
        (object: Readonly<Object3D>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, outBackward: T): T;
    };
    readonly getUp: typeof getUp;
    readonly getUpWorld: {
        (object: Readonly<Object3D>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, outUp: T): T;
    };
    readonly getUpLocal: {
        (object: Readonly<Object3D>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, outUp: T): T;
    };
    readonly getDown: typeof getDown;
    readonly getDownWorld: {
        (object: Readonly<Object3D>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, outDown: T): T;
    };
    readonly getDownLocal: {
        (object: Readonly<Object3D>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, outDown: T): T;
    };
    readonly getLeft: typeof getLeft;
    readonly getLeftWorld: {
        (object: Readonly<Object3D>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, outLeft: T): T;
    };
    readonly getLeftLocal: {
        (object: Readonly<Object3D>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, outLeft: T): T;
    };
    readonly getRight: typeof getRight;
    readonly getRightWorld: {
        (object: Readonly<Object3D>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, outRight: T): T;
    };
    readonly getRightLocal: {
        (object: Readonly<Object3D>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, outRight: T): T;
    };
    readonly setPosition: typeof setPosition;
    readonly setPositionWorld: typeof setPositionWorld;
    readonly setPositionLocal: typeof setPositionLocal;
    readonly setRotation: typeof setRotation;
    readonly setRotationDegrees: typeof setRotationDegrees;
    readonly setRotationRadians: typeof setRotationRadians;
    readonly setRotationMatrix: typeof setRotationMatrix;
    readonly setRotationQuat: typeof setRotationQuat;
    readonly setRotationWorld: typeof setRotationWorld;
    readonly setRotationWorldDegrees: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
    readonly setRotationWorldRadians: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
    readonly setRotationWorldMatrix: (object: Object3D, rotation: Readonly<Matrix3>) => Object3D;
    readonly setRotationWorldQuat: typeof setRotationWorldQuat;
    readonly setRotationLocal: typeof setRotationLocal;
    readonly setRotationLocalDegrees: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
    readonly setRotationLocalRadians: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
    readonly setRotationLocalMatrix: (object: Object3D, rotation: Readonly<Matrix3>) => Object3D;
    readonly setRotationLocalQuat: typeof setRotationLocalQuat;
    readonly setScale: typeof setScale;
    readonly setScaleWorld: {
        (object: Object3D, scale: Readonly<Vector3>): Object3D;
        (object: Object3D, uniformScale: number): Object3D;
    };
    readonly setScaleLocal: {
        (object: Object3D, scale: Readonly<Vector3>): Object3D;
        (object: Object3D, uniformScale: number): Object3D;
    };
    readonly setAxes: typeof setAxes;
    readonly setAxesWorld: typeof setAxesWorld;
    readonly setAxesLocal: typeof setAxesLocal;
    readonly setForward: typeof setForward;
    readonly setForwardWorld: (object: Object3D, forward: Readonly<Vector3>, up?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
    readonly setForwardLocal: (object: Object3D, forward: Readonly<Vector3>, up?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
    readonly setBackward: typeof setBackward;
    readonly setBackwardWorld: (object: Object3D, backward: Readonly<Vector3>, up?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
    readonly setBackwardLocal: (object: Object3D, backward: Readonly<Vector3>, up?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
    readonly setUp: typeof setUp;
    readonly setUpWorld: (object: Object3D, up: Readonly<Vector3>, forward?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
    readonly setUpLocal: (object: Object3D, up: Readonly<Vector3>, forward?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
    readonly setDown: typeof setDown;
    readonly setDownWorld: (object: Object3D, down: Readonly<Vector3>, forward?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
    readonly setDownLocal: (object: Object3D, down: Readonly<Vector3>, forward?: Readonly<Vector3>, left?: Readonly<Vector3>) => Object3D;
    readonly setLeft: typeof setLeft;
    readonly setLeftWorld: (object: Object3D, left: Readonly<Vector3>, up?: Readonly<Vector3>, forward?: Readonly<Vector3>) => Object3D;
    readonly setLeftLocal: (object: Object3D, left: Readonly<Vector3>, up?: Readonly<Vector3>, forward?: Readonly<Vector3>) => Object3D;
    readonly setRight: typeof setRight;
    readonly setRightWorld: (object: Object3D, right: Readonly<Vector3>, up?: Readonly<Vector3>, forward?: Readonly<Vector3>) => Object3D;
    readonly setRightLocal: (object: Object3D, right: Readonly<Vector3>, up?: Readonly<Vector3>, forward?: Readonly<Vector3>) => Object3D;
    readonly setTransform: typeof setTransform;
    readonly setTransformMatrix: typeof setTransformMatrix;
    readonly setTransformQuat: typeof setTransformQuat;
    readonly setTransformWorld: typeof setTransformWorld;
    readonly setTransformWorldMatrix: (object: Object3D, transform: Readonly<Matrix4>) => Object3D;
    readonly setTransformWorldQuat: typeof setTransformWorldQuat;
    readonly setTransformLocal: typeof setTransformLocal;
    readonly setTransformLocalMatrix: (object: Object3D, transform: Readonly<Matrix4>) => Object3D;
    readonly setTransformLocalQuat: typeof setTransformLocalQuat;
    readonly resetPosition: typeof resetPosition;
    readonly resetPositionWorld: (object: Object3D) => Object3D;
    readonly resetPositionLocal: (object: Object3D) => Object3D;
    readonly resetRotation: typeof resetRotation;
    readonly resetRotationWorld: (object: Object3D) => Object3D;
    readonly resetRotationLocal: (object: Object3D) => Object3D;
    readonly resetScale: typeof resetScale;
    readonly resetScaleWorld: (object: Object3D) => Object3D;
    readonly resetScaleLocal: (object: Object3D) => Object3D;
    readonly resetTransform: typeof resetTransform;
    readonly resetTransformWorld: typeof resetTransformWorld;
    readonly resetTransformLocal: typeof resetTransformLocal;
    readonly translate: typeof translate;
    readonly translateWorld: typeof translateWorld;
    readonly translateLocal: typeof translateLocal;
    readonly translateObject: typeof translateObject;
    readonly translateAxis: typeof translateAxis;
    readonly translateAxisWorld: (object: Object3D, amount: number, direction: Readonly<Vector3>) => Object3D;
    readonly translateAxisLocal: (object: Object3D, amount: number, direction: Readonly<Vector3>) => Object3D;
    readonly translateAxisObject: (object: Object3D, amount: number, direction: Readonly<Vector3>) => Object3D;
    readonly rotate: typeof rotate;
    readonly rotateDegrees: typeof rotateDegrees;
    readonly rotateRadians: typeof rotateRadians;
    readonly rotateMatrix: typeof rotateMatrix;
    readonly rotateQuat: typeof rotateQuat;
    readonly rotateWorld: typeof rotateWorld;
    readonly rotateWorldDegrees: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
    readonly rotateWorldRadians: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
    readonly rotateWorldMatrix: (object: Object3D, rotation: Readonly<Matrix3>) => Object3D;
    readonly rotateWorldQuat: (object: Object3D, rotation: Readonly<Quaternion>) => Object3D;
    readonly rotateLocal: typeof rotateLocal;
    readonly rotateLocalDegrees: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
    readonly rotateLocalRadians: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
    readonly rotateLocalMatrix: (object: Object3D, rotation: Readonly<Matrix3>) => Object3D;
    readonly rotateLocalQuat: (object: Object3D, rotation: Readonly<Quaternion>) => Object3D;
    readonly rotateObject: typeof rotateObject;
    readonly rotateObjectDegrees: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
    readonly rotateObjectRadians: (object: Object3D, rotation: Readonly<Vector3>) => Object3D;
    readonly rotateObjectMatrix: (object: Object3D, rotation: Readonly<Matrix3>) => Object3D;
    readonly rotateObjectQuat: typeof rotateObjectQuat;
    readonly rotateAxis: typeof rotateAxis;
    readonly rotateAxisDegrees: typeof rotateAxisDegrees;
    readonly rotateAxisRadians: typeof rotateAxisRadians;
    readonly rotateAxisWorld: typeof rotateAxisWorld;
    readonly rotateAxisWorldDegrees: typeof rotateAxisWorldDegrees;
    readonly rotateAxisWorldRadians: (object: Object3D, angle: number, axis: Readonly<Vector3>) => Object3D;
    readonly rotateAxisLocal: typeof rotateAxisLocal;
    readonly rotateAxisLocalDegrees: typeof rotateAxisLocalDegrees;
    readonly rotateAxisLocalRadians: (object: Object3D, angle: number, axis: Readonly<Vector3>) => Object3D;
    readonly rotateAxisObject: typeof rotateAxisObject;
    readonly rotateAxisObjectDegrees: typeof rotateAxisObjectDegrees;
    readonly rotateAxisObjectRadians: (object: Object3D, angle: number, axis: Readonly<Vector3>) => Object3D;
    readonly rotateAround: typeof rotateAround;
    readonly rotateAroundDegrees: typeof rotateAroundDegrees;
    readonly rotateAroundRadians: typeof rotateAroundRadians;
    readonly rotateAroundMatrix: typeof rotateAroundMatrix;
    readonly rotateAroundQuat: typeof rotateAroundQuat;
    readonly rotateAroundWorld: typeof rotateAroundWorld;
    readonly rotateAroundWorldDegrees: (object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
    readonly rotateAroundWorldRadians: (object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
    readonly rotateAroundWorldMatrix: (object: Object3D, rotation: Readonly<Matrix3>, origin: Readonly<Vector3>) => Object3D;
    readonly rotateAroundWorldQuat: (object: Object3D, rotation: Readonly<Quaternion>, origin: Readonly<Vector3>) => Object3D;
    readonly rotateAroundLocal: typeof rotateAroundLocal;
    readonly rotateAroundLocalDegrees: (object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
    readonly rotateAroundLocalRadians: (object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
    readonly rotateAroundLocalMatrix: (object: Object3D, rotation: Readonly<Matrix3>, origin: Readonly<Vector3>) => Object3D;
    readonly rotateAroundLocalQuat: (object: Object3D, rotation: Readonly<Quaternion>, origin: Readonly<Vector3>) => Object3D;
    readonly rotateAroundObject: typeof rotateAroundObject;
    readonly rotateAroundObjectDegrees: (object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
    readonly rotateAroundObjectRadians: (object: Object3D, rotation: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
    readonly rotateAroundObjectMatrix: (object: Object3D, rotation: Readonly<Matrix3>, origin: Readonly<Vector3>) => Object3D;
    readonly rotateAroundObjectQuat: (object: Object3D, rotation: Readonly<Quaternion>, origin: Readonly<Vector3>) => Object3D;
    readonly rotateAroundAxis: typeof rotateAroundAxis;
    readonly rotateAroundAxisDegrees: typeof rotateAroundAxisDegrees;
    readonly rotateAroundAxisRadians: typeof rotateAroundAxisRadians;
    readonly rotateAroundAxisWorld: typeof rotateAroundAxisWorld;
    readonly rotateAroundAxisWorldDegrees: typeof rotateAroundAxisWorldDegrees;
    readonly rotateAroundAxisWorldRadians: (object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
    readonly rotateAroundAxisLocal: typeof rotateAroundAxisLocal;
    readonly rotateAroundAxisLocalDegrees: typeof rotateAroundAxisLocalDegrees;
    readonly rotateAroundAxisLocalRadians: (object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
    readonly rotateAroundAxisObject: typeof rotateAroundAxisObject;
    readonly rotateAroundAxisObjectDegrees: typeof rotateAroundAxisObjectDegrees;
    readonly rotateAroundAxisObjectRadians: (object: Object3D, angle: number, axis: Readonly<Vector3>, origin: Readonly<Vector3>) => Object3D;
    readonly scaleObject: {
        (object: Object3D, scale: Readonly<Vector3>): Object3D;
        (object: Object3D, uniformScale: number): Object3D;
    };
    readonly lookAt: typeof lookAt;
    readonly lookAtWorld: (object: Object3D, position: Readonly<Vector3>, up?: Readonly<Vector3>) => Object3D;
    readonly lookAtLocal: (object: Object3D, position: Readonly<Vector3>, up?: Readonly<Vector3>) => Object3D;
    readonly lookTo: typeof lookTo;
    readonly lookToWorld: (object: Object3D, direction: Readonly<Vector3>, up?: Readonly<Vector3>) => Object3D;
    readonly lookToLocal: (object: Object3D, direction: Readonly<Vector3>, up?: Readonly<Vector3>) => Object3D;
    readonly convertPositionObjectToWorld: {
        (object: Readonly<Object3D>, position: Readonly<Vector3>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, position: Readonly<Vector3>, outPosition: T): T;
    };
    readonly convertDirectionObjectToWorld: {
        (object: Readonly<Object3D>, direction: Readonly<Vector3>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, direction: Readonly<Vector3>, outDirection: T): T;
    };
    readonly convertPositionWorldToObject: {
        (object: Readonly<Object3D>, position: Readonly<Vector3>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, position: Readonly<Vector3>, outPosition: T): T;
    };
    readonly convertDirectionWorldToObject: {
        (object: Readonly<Object3D>, direction: Readonly<Vector3>): Vector3;
        <T extends Vector3>(object: Readonly<Object3D>, direction: Readonly<Vector3>, outDirection: T): T;
    };
    readonly convertPositionLocalToWorld: typeof convertPositionLocalToWorld;
    readonly convertDirectionLocalToWorld: typeof convertDirectionLocalToWorld;
    readonly convertPositionWorldToLocal: typeof convertPositionWorldToLocal;
    readonly convertDirectionWorldToLocal: typeof convertDirectionWorldToLocal;
    readonly convertPositionObjectToLocal: typeof convertPositionObjectToLocal;
    readonly convertDirectionObjectToLocal: typeof convertDirectionObjectToLocal;
    readonly convertPositionLocalToObject: typeof convertPositionLocalToObject;
    readonly convertDirectionLocalToObject: typeof convertDirectionLocalToObject;
    readonly convertTransformObjectToWorld: typeof convertTransformObjectToWorld;
    readonly convertTransformObjectToWorldMatrix: {
        <T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<T>): T;
        <T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<Matrix4>, outTransform: T): T;
    };
    readonly convertTransformObjectToWorldQuat: {
        <T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<T>): T;
        <T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<Quaternion2>, outTransform: T): T;
    };
    readonly convertTransformWorldToObject: typeof convertTransformWorldToObject;
    readonly convertTransformWorldToObjectMatrix: {
        <T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<T>): T;
        <T extends Matrix4>(object: Readonly<Object3D>, transform: Readonly<Matrix4>, outTransform: T): T;
    };
    readonly convertTransformWorldToObjectQuat: {
        <T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<T>): T;
        <T extends Quaternion2>(object: Readonly<Object3D>, transform: Readonly<Quaternion2>, outTransform: T): T;
    };
    readonly convertTransformLocalToWorld: typeof convertTransformLocalToWorld;
    readonly convertTransformLocalToWorldMatrix: typeof convertTransformLocalToWorldMatrix;
    readonly convertTransformLocalToWorldQuat: typeof convertTransformLocalToWorldQuat;
    readonly convertTransformWorldToLocal: typeof convertTransformWorldToLocal;
    readonly convertTransformWorldToLocalMatrix: typeof convertTransformWorldToLocalMatrix;
    readonly convertTransformWorldToLocalQuat: typeof convertTransformWorldToLocalQuat;
    readonly convertTransformObjectToLocal: typeof convertTransformObjectToLocal;
    readonly convertTransformObjectToLocalMatrix: typeof convertTransformObjectToLocalMatrix;
    readonly convertTransformObjectToLocalQuat: typeof convertTransformObjectToLocalQuat;
    readonly convertTransformLocalToObject: typeof convertTransformLocalToObject;
    readonly convertTransformLocalToObjectMatrix: typeof convertTransformLocalToObjectMatrix;
    readonly convertTransformLocalToObjectQuat: typeof convertTransformLocalToObjectQuat;
    readonly setParent: (object: Object3D, newParent: Object3D, keepTransformWorld?: boolean) => Object3D;
    readonly getParent: typeof getParent;
    readonly addComponent: typeof addComponent;
    readonly getComponent: typeof getComponent;
    readonly getComponentSelf: typeof getComponentSelf;
    readonly getComponentHierarchy: typeof getComponentHierarchy;
    readonly getComponentHierarchyBreadth: typeof getComponentHierarchyBreadth;
    readonly getComponentHierarchyDepth: typeof getComponentHierarchyDepth;
    readonly getComponentDescendants: typeof getComponentDescendants;
    readonly getComponentDescendantsBreadth: typeof getComponentDescendantsBreadth;
    readonly getComponentDescendantsDepth: typeof getComponentDescendantsDepth;
    readonly getComponentChildren: typeof getComponentChildren;
    readonly getComponents: typeof getComponents;
    readonly getComponentsSelf: typeof getComponentsSelf;
    readonly getComponentsHierarchy: typeof getComponentsHierarchy;
    readonly getComponentsHierarchyBreadth: typeof getComponentsHierarchyBreadth;
    readonly getComponentsHierarchyDepth: typeof getComponentsHierarchyDepth;
    readonly getComponentsDescendants: typeof getComponentsDescendants;
    readonly getComponentsDescendantsBreadth: typeof getComponentsDescendantsBreadth;
    readonly getComponentsDescendantsDepth: typeof getComponentsDescendantsDepth;
    readonly getComponentsChildren: typeof getComponentsChildren;
    readonly setActive: typeof setActive;
    readonly setActiveSelf: typeof setActiveSelf;
    readonly setActiveHierarchy: typeof setActiveHierarchy;
    readonly setActiveHierarchyBreadth: typeof setActiveHierarchyBreadth;
    readonly setActiveHierarchyDepth: typeof setActiveHierarchyDepth;
    readonly setActiveDescendants: typeof setActiveDescendants;
    readonly setActiveDescendantsBreadth: typeof setActiveDescendantsBreadth;
    readonly setActiveDescendantsDepth: typeof setActiveDescendantsDepth;
    readonly setActiveChildren: typeof setActiveChildren;
    readonly hasUniformScale: typeof hasUniformScale;
    readonly hasUniformScaleWorld: (object: Readonly<Object3D>) => boolean;
    readonly hasUniformScaleLocal: (object: Readonly<Object3D>) => boolean;
    readonly clone: (object: Readonly<Object3D>, cloneParams?: Readonly<ObjectCloneParams>) => Object3D | null;
    readonly isCloneable: typeof isCloneable;
    readonly toString: typeof toString;
    readonly toStringExtended: (object: Readonly<Object3D>) => string;
    readonly toStringCompact: (object: Readonly<Object3D>) => string;
    readonly log: typeof log;
    readonly logExtended: typeof logExtended;
    readonly logCompact: typeof logCompact;
    readonly warn: typeof warn;
    readonly warnExtended: typeof warnExtended;
    readonly warnCompact: typeof warnCompact;
    readonly error: typeof error;
    readonly errorExtended: typeof errorExtended;
    readonly errorCompact: typeof errorCompact;
    readonly getObjectByName: typeof getObjectByName;
    readonly getObjectByNameHierarchy: typeof getObjectByNameHierarchy;
    readonly getObjectByNameHierarchyBreadth: typeof getObjectByNameHierarchyBreadth;
    readonly getObjectByNameHierarchyDepth: typeof getObjectByNameHierarchyDepth;
    readonly getObjectByNameDescendants: typeof getObjectByNameDescendants;
    readonly getObjectByNameDescendantsBreadth: typeof getObjectByNameDescendantsBreadth;
    readonly getObjectByNameDescendantsDepth: typeof getObjectByNameDescendantsDepth;
    readonly getObjectByNameChildren: typeof getObjectByNameChildren;
    readonly getObjectsByName: typeof getObjectsByName;
    readonly getObjectsByNameHierarchy: typeof getObjectsByNameHierarchy;
    readonly getObjectsByNameHierarchyBreadth: typeof getObjectsByNameHierarchyBreadth;
    readonly getObjectsByNameHierarchyDepth: typeof getObjectsByNameHierarchyDepth;
    readonly getObjectsByNameDescendants: typeof getObjectsByNameDescendants;
    readonly getObjectsByNameDescendantsBreadth: typeof getObjectsByNameDescendantsBreadth;
    readonly getObjectsByNameDescendantsDepth: typeof getObjectsByNameDescendantsDepth;
    readonly getObjectsByNameChildren: typeof getObjectsByNameChildren;
    readonly getObjectByID: typeof getObjectByID;
    readonly getObjectByIDHierarchy: typeof getObjectByIDHierarchy;
    readonly getObjectByIDHierarchyBreadth: typeof getObjectByIDHierarchyBreadth;
    readonly getObjectByIDHierarchyDepth: typeof getObjectByIDHierarchyDepth;
    readonly getObjectByIDDescendants: typeof getObjectByIDDescendants;
    readonly getObjectByIDDescendantsBreadth: typeof getObjectByIDDescendantsBreadth;
    readonly getObjectByIDDescendantsDepth: typeof getObjectByIDDescendantsDepth;
    readonly getObjectByIDChildren: typeof getObjectByIDChildren;
    readonly getHierarchy: typeof getHierarchy;
    readonly getHierarchyBreadth: typeof getHierarchyBreadth;
    readonly getHierarchyDepth: typeof getHierarchyDepth;
    readonly getDescendants: typeof getDescendants;
    readonly getDescendantsBreadth: typeof getDescendantsBreadth;
    readonly getDescendantsDepth: typeof getDescendantsDepth;
    readonly getChildren: typeof getChildren;
    readonly getSelf: typeof getSelf;
    readonly addChild: typeof addChild;
    readonly getName: typeof getName;
    readonly setName: typeof setName;
    readonly getEngine: typeof getEngine;
    readonly getID: typeof getID;
    readonly markDirty: typeof markDirty;
    readonly isTransformChanged: typeof isTransformChanged;
    readonly destroy: typeof destroy;
    readonly reserveObjects: typeof reserveObjects;
    readonly reserveObjectsSelf: typeof reserveObjectsSelf;
    readonly reserveObjectsHierarchy: typeof reserveObjectsHierarchy;
    readonly reserveObjectsDescendants: typeof reserveObjectsDescendants;
    readonly reserveObjectsChildren: typeof reserveObjectsChildren;
    readonly getComponentsAmountMap: typeof getComponentsAmountMap;
    readonly getComponentsAmountMapSelf: typeof getComponentsAmountMapSelf;
    readonly getComponentsAmountMapHierarchy: typeof getComponentsAmountMapHierarchy;
    readonly getComponentsAmountMapDescendants: typeof getComponentsAmountMapDescendants;
    readonly getComponentsAmountMapChildren: typeof getComponentsAmountMapChildren;
    readonly getComponentObjects: typeof getComponentObjects;
    readonly getComponentsObjects: typeof getComponentsObjects;
    readonly setActiveObjects: typeof setActiveObjects;
    readonly getObjectByNameObjects: typeof getObjectByNameObjects;
    readonly getObjectsByNameObjects: typeof getObjectsByNameObjects;
    readonly getObjectByIDObjects: typeof getObjectByIDObjects;
    readonly getObjectsByIDObjects: typeof getObjectsByIDObjects;
    readonly wrapObject: typeof wrapObject;
};