import type { PointLike } from './Point';
import type { Vector } from './Vector';
/**
 * Class representing an affine transformation 3x3 matrix:
 * <pre>
 *      [ a  c  tx
 * A =    b  d  ty
 *        0  0  1  ]
 * </pre
 * @type {Matrix}
 */
export declare class Matrix {
    a: number;
    b: number;
    c: number;
    d: number;
    tx: number;
    ty: number;
    _inverse: Matrix | null;
    static EMPTY: Readonly<Matrix>;
    static IDENTITY: Readonly<Matrix>;
    static fromTransform(x: number, y: number, rotation: number, scale: number): Matrix;
    /**
     * Construct new instance of affine transformation matrix <br/>
     * If parameters omitted, construct identity matrix a = 1, d = 1
     * @param a - position(0,0)   sx*cos(alpha)
     * @param b - position (0,1)  sx*sin(alpha)
     * @param c - position (1,0)  -sy*sin(alpha)
     * @param d - position (1,1)  sy*cos(alpha)
     * @param tx - position (2,0) translation by x
     * @param ty - position (2,1) translation by y
     */
    constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number);
    /**
     * Return new cloned instance of matrix
     */
    clone(): Matrix;
    get inverse(): Matrix;
    /**
     * Return the matrix inverse
     */
    invert(): Matrix;
    /**
     * Return this matrix, inverted
     */
    invertMut(): this;
    /**
     * Get the determinant of matrix
     */
    determinant(): number;
    /**
     * Transform vector [x,y] using transformation matrix. <br/>
     * Vector [x,y] is an abstract array[2] of numbers and not a FlattenJS object <br/>
     * The result is also an abstract vector [x',y'] = A * [x,y]:
     * <code>
     * [x'       [ ax + by + tx
     *  y'   =     cx + dy + ty
     *  1]                    1 ]
     * </code>
     */
    transform(x: number, y: number): [number, number];
    transformMut(p: PointLike): PointLike;
    /**
     * Returns result of multiplication of this matrix by other matrix
     */
    multiply(other: Matrix): Matrix;
    multiplyMut(other: Matrix): this;
    /**
     * Return new matrix as a result of multiplication of the current matrix
     * by the matrix(1,0,0,1,tx,ty)
     */
    translate(v: Vector): Matrix;
    translate(x: number, y: number): Matrix;
    /**
     * Return new matrix as a result of multiplication of the current matrix
     * by the matrix that defines rotation by given angle (in radians) around
     * center of rotation (centerX,centerY) in counterclockwise direction
     * @param angle - angle in radians
     * @param centerX - center of rotation
     * @param centerY - center of rotation
     */
    rotate(angle: number, centerX?: number, centerY?: number): Matrix;
    /**
     * Return new matrix as a result of multiplication of the current matrix
     * by the matrix (sx,0,0,sy,0,0) that defines scaling
     * @param sx
     * @param sy
     */
    scale(sx: number, sy: number): Matrix;
    /**
     * Returns true if two matrix are equal parameter by parameter
     */
    equalTo(matrix: Matrix): boolean;
    isIdentity(): boolean;
}
/**
 * Function to create matrix equivalent to "new" constructor
 */
export declare const matrix: (a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number) => Matrix;
//# sourceMappingURL=Matrix.d.ts.map