import { Quaternion } from "./Quaternion";
import { Vector3 } from "./Vector3";
/** 4x4 Matrix */
export declare class Matrix4 {
    elements: [[number, number, number, number], [number, number, number, number], [number, number, number, number], [number, number, number, number]];
    constructor(elements: [[number, number, number, number], [number, number, number, number], [number, number, number, number], [number, number, number, number]]);
    /**
     * Creates a new Matrix4
     * @param elements (optional)
     */
    static create(elements?: number[][]): Matrix4;
    /**
     * Creates a new Matrix4 with rotation
     * @param quaternion Quaternion
     */
    static createFromQuaternion(quaternion: Quaternion): Matrix4;
    /**
     * Returns an identity Matrix4
     */
    static identity(): Matrix4;
    /**
     * Sets the given matrix in place
     * @param matrix Matrix4
     * @param n11_n44 number elements
     */
    static set(matrix: Matrix4, n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number): void;
    /**
     * Creates new matrix from input
     * @param matrix Matrix4
     */
    static clone(matrix: Matrix4): Matrix4;
    /**
     * Copies values from input matrix 1 to input matrix 2
     * @param from Matrix4 1
     * @param to Matrix4 2
     */
    static copy(from: Matrix4, to: Matrix4): void;
    /**
     * Creates a new Matrix3 with absolute values of elements
     * @param input
     */
    static absoluteElements(input: Matrix4): Matrix4;
    /**
     * Creates a new Matrix4 with A + B
     * @param matA Matrix4 A
     * @param matB Matrix4 B
     */
    static add(matA: Matrix4, matB: Matrix4): Matrix4;
    /**
     * Creates new Matrix4 and multiplies matrix with scalar (on all elements)
     * @param matrix Matrix4
     * @param scalar number
     */
    static multiplyScalar(matrix: Matrix4, scalar: number): Matrix4;
    /**
     * Creates a new Matrix4 with A * B
     * @param matA Matrix4 A
     * @param matB Matrix4 B
     */
    static multiply(a: Matrix4, b: Matrix4): Matrix4;
    /**
     * Returns the inverse from matrix
     * @param matrix Matrix4
     */
    static getInverse(matrix: Matrix4): Matrix4 | undefined;
    /**
     * Returns the transposed matrix as a new Matrix4
     * @param matrix Matrix4
     */
    static transpose(matrix: Matrix4): Matrix4;
    /**
     * Returns the scale matrix for given scale vector
     * @param scale vec3
     */
    static getScaleMatrix(scale: Vector3): Matrix4;
    /**
     * Builds a new rotation matrix with quaternion (in place)
     * @param matrix Matrix4
     * @param quaternion Quaternion
     */
    static makeRotationMatrixFromQuaternionInPlace(matrix: Matrix4, quaternion: Quaternion): void;
    /**
     * Returns the X rotation matrix for given angle
     * @param angle in radians (number)
     */
    static getXRotationMatrix(angle: number): Matrix4;
    /**
     * Returns the Y rotation matrix for given angle
     * @param angle in radians (number)
     */
    static getYRotationMatrix(angle: number): Matrix4;
    /**
     * Returns the Z rotation matrix for given angle
     * @param angle in radians (number)
     */
    static getZRotationMatrix(angle: number): Matrix4;
    /**
     * Returns the translation matrix for given position vector
     * @param pos vec3
     */
    static getTranslationMatrix(pos: Vector3): Matrix4;
    /**
     * Returns transformation matrix composed of translation, rotation and scale.
     * @param translation vec3
     * @param rotation Quaternion
     * @param scale vec3
     */
    static compose(translation: Vector3, rotation: Quaternion, scale: Vector3): Matrix4;
    /**
     * Decomposes the given matrix into the translation, rotation and scale components.
     * @param matrix Matrix4
     * @returns Object\[Position as Vector3, Rotation as Quaternion, Scale as Vector3\]
     */
    static decompose(matrix: Matrix4): Object[];
    /**
     * Evaluates a rotation needed to be applied to an object positioned at sourcePoint to face destPoint.
     * When no rotation is applied, the eye looks at positive z-axis.
     * @param eye Vector3 - Coordinates of source point
     * @param target Vector3 - Coordinates of destination point
     * @param up (optional) Vector3 - Where does the up vector points to? (needs to be a unit vector!)
     * @param base (optional) String - Enum: {"x", "y", "z"} Where does your geometry points to when inserted? Default: z
     */
    static lookAt(eye: Vector3, target: Vector3, up?: Vector3, base?: string): Matrix4;
    /**
     * Computes determinant of given Matrix4
     * @param matrix Matrix4
     */
    static determinant(matrix: Matrix4): number;
    /**
     * Checks if both matrices are equal
     * @param matA Matrix3|Matrix4
     * @param matB Matrix3|Matrix4
     */
    static equals(matA: Matrix4, matB: Matrix4): boolean;
    /**
     * Returns a String representing the given matrix
     * @param matrix Matrix4
     */
    static stringify(matrix: Matrix4): String;
}
