import { Vec2 } from './vec2';
/**
 * Class representing a 3x3 Matrix and providing static utilities for mathematical operations
 */
export declare class Mat3 {
    readonly array: ReadonlyArray<number>;
    /**
     * Internally-referenced static identity matrix
     */
    private static readonly IDENTITY;
    /**
     * Add two Mat3s
     *
     * @param left the first Mat3
     * @param right the second Mat3
     *
     * @returns the result of the addition
     */
    static add(left: Mat3, right: Mat3): Mat3;
    /**
     * Subtract the right Mat3 from the left
     *
     * @param left the Mat3 to subtract from
     * @param right the Mat3 to subtract
     *
     * @returns the result of the subtraction
     */
    static sub(left: Mat3, right: Mat3): Mat3;
    /**
     * Multiply two Mat3s
     *
     * @param left the first Mat3
     * @param right the second Mat3
     *
     * @returns the result of the multiplication
     */
    static mult(left: Mat3, right: Mat3): Mat3;
    /**
     * Multiply a Mat3 by a given scalar factor
     *
     * @param m the Mat3 to multiply
     * @param factor the factor to multiply by
     *
     * @returns the multiplied Mat3
     */
    static multScalar(m: Mat3, factor: number): Mat3;
    /**
     * Invert a Mat3
     *
     * @param m the Mat3 to invert
     *
     * @returns the inverse of the Mat3
     */
    static invert(m: Mat3): Mat3 | null;
    /**
     * Transpose a Mat3
     *
     * @param m the Mat3 to transpose
     *
     * @return the transposed Mat3
     */
    static transpose(m: Mat3): Mat3;
    /**
     * Calculate the adjugate of a Mat3
     *
     * @param m the Mat3
     *
     * @returns the adjugate of the Mat3
     */
    static adjoint(m: Mat3): Mat3;
    /**
     * Translate a Mat3 by a Vec2 along the x and y
     *
     * @param m the Mat3 to translate
     * @param translate the Vec2 to translate by
     *
     * @returns the translated Mat3
     */
    static translate(m: Mat3, translate: Vec2): Mat3;
    /**
     * Rotate a Mat3 by a given angle (radians)
     *
     * @param m the Mat3 to rotate
     * @param angle the angle to rotate by
     *
     * @returns the rotated Mat3
     */
    static rotate(m: Mat3, angle: number): Mat3;
    /**
     * Create a Mat3 representing a rotation by a given angle (radians)
     *
     * Useful convenience method effectively equivalent to `Mat3.rotate(new Mat3(), <angle>)`
     *
     * @param angle the angle to rotate by
     *
     * @returns the rotation Matrix
     */
    static fromRotation(angle: number): Mat3;
    /**
     * Scale a Mat3 by factors on the x and y axes, given as a Vec2
     *
     * @param m the Mat3 to scale
     * @param factor the Vec2 to scale by
     *
     * @returns the scaled Mat3
     */
    static scale(m: Mat3, factor: Vec2): Mat3;
    /**
     * Create a 3x3 projection matrix for a given screen width and height
     *
     * @param width the width of the screen
     * @param height the height of the screen
     *
     * @returns the 3x3 projection matrix
     */
    static projection(width: number, height: number): Mat3;
    /**
     * Constructor. Take and store the Mat3's values
     *
     * @param values the Mat3's values; defaults to Mat3.IDENTITY
     */
    constructor(array?: ReadonlyArray<number>);
    /**
     * Getter for the Mat3's determinant
     */
    get determinant(): number;
    /**
     * Getter for the Float32Array form of the Mat3
     */
    get float32Array(): Float32Array;
    /**
     * Getter for the readable string form of the Mat3
     */
    get string(): string;
    /**
     * Reset the Mat3's values to match the identity matrix
     */
    reset(): void;
    /**
     * Clone the Mat3
     *
     * @returns a new Mat3 with the same values as this one
     */
    clone(): Mat3;
    /**
     * Getter for a Mutable cast of the Mat3 instance; used for enabling internal-only mutation
     *
     * @returns the typecasted Mutable Mat3 instance
     */
    private get mutable();
}