export default Transform4;
declare class Transform4 {
    /**
     * Creates a transform based around an initial matrix.
     * @public
     *
     * @param {Matrix4} matrix
     */
    constructor(matrix: Matrix4);
    matrix: any;
    inverse: any;
    matrixTransposed: any;
    inverseTransposed: any;
    inverseValid: boolean;
    transposeValid: boolean;
    inverseTransposeValid: boolean;
    changeEmitter: TinyEmitter<[]>;
    /**
     * Sets the value of the primary matrix directly from a Matrix4. Does not change the Matrix4 instance of this
     * Transform4.
     * @public
     *
     * @param {Matrix4} matrix
     */
    public setMatrix(matrix: Matrix4): void;
    /**
     * This should be called after our internal matrix is changed. It marks the other dependent matrices as invalid,
     * and sends out notifications of the change.
     * @private
     */
    private invalidate;
    /**
     * Modifies the primary matrix such that: this.matrix = matrix * this.matrix.
     * @public
     *
     * @param {Matrix4} matrix
     */
    public prepend(matrix: Matrix4): void;
    /**
     * Modifies the primary matrix such that: this.matrix = this.matrix * matrix
     * @public
     *
     * @param {Matrix4} matrix
     */
    public append(matrix: Matrix4): void;
    /**
     * Like prepend(), but prepends the other transform's matrix.
     * @public
     *
     * @param {Transform4} transform
     */
    public prependTransform(transform: Transform4): void;
    /**
     * Like append(), but appends the other transform's matrix.
     * @public
     *
     * @param {Transform4} transform
     */
    public appendTransform(transform: Transform4): void;
    /**
     * Sets the transform of a Canvas context to be equivalent to the 2D affine part of this transform.
     * @public
     *
     * @param {CanvasRenderingContext2D} context
     */
    public applyToCanvasContext(context: CanvasRenderingContext2D): void;
    /**
     * Creates a copy of this transform.
     * @public
     *
     * @returns {Transform4}
     */
    public copy(): Transform4;
    /**
     * Returns the primary matrix of this transform.
     * @public
     *
     * @returns {Matrix4}
     */
    public getMatrix(): Matrix4;
    /**
     * Returns the inverse of the primary matrix of this transform.
     * @public
     *
     * @returns {Matrix4}
     */
    public getInverse(): Matrix4;
    /**
     * Returns the transpose of the primary matrix of this transform.
     * @public
     *
     * @returns {Matrix4}
     */
    public getMatrixTransposed(): Matrix4;
    /**
     * Returns the inverse of the transpose of matrix of this transform.
     * @public
     *
     * @returns {Matrix4}
     */
    public getInverseTransposed(): Matrix4;
    /**
     * Returns whether our primary matrix is known to be an identity matrix. If false is returned, it doesn't necessarily
     * mean our matrix isn't an identity matrix, just that it is unlikely in normal usage.
     * @public
     *
     * @returns {boolean}
     */
    public isIdentity(): boolean;
    /**
     * Returns whether any components of our primary matrix are either infinite or NaN.
     * @public
     *
     * @returns {boolean}
     */
    public isFinite(): boolean;
    /**
     * Transforms a 3-dimensional vector like it is a point with a position (translation is applied).
     * @public
     *
     * For an affine matrix $M$, the result is the homogeneous multiplication $M\begin{bmatrix} x \\ y \\ z \\ 1 \end{bmatrix}$.
     *
     * @param {Vector3} v
     * @returns {Vector3}
     */
    public transformPosition3(v: Vector3): Vector3;
    /**
     * Transforms a 3-dimensional vector like position is irrelevant (translation is not applied).
     * @public
     *
     * @param {Vector3} v
     * @returns {Vector3}
     */
    public transformDelta3(v: Vector3): Vector3;
    /**
     * Transforms a 3-dimensional vector like it is a normal to a surface (so that the surface is transformed, and the new
     * normal to the surface at the transformed point is returned).
     * @public
     *
     * @param {Vector3} v
     * @returns {Vector3}
     */
    public transformNormal3(v: Vector3): Vector3;
    /**
     * Returns the x-coordinate difference for two transformed vectors, which add the x-coordinate difference of the input
     * x (and same y,z values) beforehand.
     * @public
     *
     * @param {number} x
     * @returns {number}
     */
    public transformDeltaX(x: number): number;
    /**
     * Returns the y-coordinate difference for two transformed vectors, which add the y-coordinate difference of the input
     * y (and same x,z values) beforehand.
     * @public
     *
     * @param {number} y
     * @returns {number}
     */
    public transformDeltaY(y: number): number;
    /**
     * Returns the z-coordinate difference for two transformed vectors, which add the z-coordinate difference of the input
     * z (and same x,y values) beforehand.
     * @public
     *
     * @param {number} z
     * @returns {number}
     */
    public transformDeltaZ(z: number): number;
    /**
     * Returns a transformed ray.
     * @public
     *
     * @param {Ray3} ray
     * @returns {Ray3}
     */
    public transformRay(ray: Ray3): Ray3;
    /**
     * Transforms a 3-dimensional vector by the inverse of our transform like it is a point with a position (translation is applied).
     * @public
     *
     * For an affine matrix $M$, the result is the homogeneous multiplication $M^{-1}\begin{bmatrix} x \\ y \\ z \\ 1 \end{bmatrix}$.
     *
     * This is the inverse of transformPosition3().
     *
     * @param {Vector3} v
     * @returns {Vector3}
     */
    public inversePosition3(v: Vector3): Vector3;
    /**
     * Transforms a 3-dimensional vector by the inverse of our transform like position is irrelevant (translation is not applied).
     * @public
     *
     * This is the inverse of transformDelta3().
     *
     * @param {Vector3} v
     * @returns {Vector3}
     */
    public inverseDelta3(v: Vector3): Vector3;
    /**
     * Transforms a 3-dimensional vector by the inverse of our transform like it is a normal to a curve (so that the
     * curve is transformed, and the new normal to the curve at the transformed point is returned).
     * @public
     *
     * This is the inverse of transformNormal3().
     *
     * @param {Vector3} v
     * @returns {Vector3}
     */
    public inverseNormal3(v: Vector3): Vector3;
    /**
     * Returns the x-coordinate difference for two inverse-transformed vectors, which add the x-coordinate difference of the input
     * x (and same y,z values) beforehand.
     * @public
     *
     * This is the inverse of transformDeltaX().
     *
     * @param {number} x
     * @returns {number}
     */
    public inverseDeltaX(x: number): number;
    /**
     * Returns the y-coordinate difference for two inverse-transformed vectors, which add the y-coordinate difference of the input
     * y (and same x,z values) beforehand.
     * @public
     *
     * This is the inverse of transformDeltaY().
     *
     * @param {number} y
     * @returns {number}
     */
    public inverseDeltaY(y: number): number;
    /**
     * Returns the z-coordinate difference for two inverse-transformed vectors, which add the z-coordinate difference of the input
     * z (and same x,y values) beforehand.
     * @public
     *
     * This is the inverse of transformDeltaZ().
     *
     * @param {number} z
     * @returns {number}
     */
    public inverseDeltaZ(z: number): number;
    /**
     * Returns an inverse-transformed ray.
     * @public
     *
     * This is the inverse of transformRay()
     *
     * @param {Ray3} ray
     * @returns {Ray3}
     */
    public inverseRay(ray: Ray3): Ray3;
}
import TinyEmitter from '../../axon/js/TinyEmitter.js';
import Matrix4 from './Matrix4.js';
import Vector3 from './Vector3.js';
import Ray3 from './Ray3.js';
//# sourceMappingURL=Transform4.d.ts.map