/**
 * Quadric Error Metric
 * Upper-triangular portion of a symmetric 4x4 matrix encoding a quadric form.
 *
 * Layout (10 elements):
 *   [0]=a2 [1]=ab [2]=ac [3]=ad
 *          [4]=b2 [5]=bc [6]=bd
 *                 [7]=c2 [8]=cd
 *                        [9]=d2
 */
export class Quadric3 extends Float64Array {
    constructor();
    set a2(arg: any);
    get a2(): any;
    0: any;
    set ab(arg: any);
    get ab(): any;
    1: any;
    set ac(arg: any);
    get ac(): any;
    2: any;
    set ad(arg: any);
    get ad(): any;
    3: any;
    set b2(arg: any);
    get b2(): any;
    4: any;
    set bc(arg: any);
    get bc(): any;
    5: any;
    set bd(arg: any);
    get bd(): any;
    6: any;
    set c2(arg: any);
    get c2(): any;
    7: any;
    set cd(arg: any);
    get cd(): any;
    8: any;
    set d2(arg: any);
    get d2(): any;
    9: any;
    /**
     *
     * @param {ArrayLike<number>|number[]|Float32Array} result
     */
    toVector3(result: ArrayLike<number> | number[] | Float32Array): void;
    /**
     *
     * @param {ArrayLike<number>|number[]|Float32Array} m3
     */
    toTensorM3(m3: ArrayLike<number> | number[] | Float32Array): void;
    /**
     * Equivalent to taking a tensor followed by matrix inversion
     * @param {ArrayLike<number>|number[]|Float32Array} m3
     * @param {number} epsilon
     * @returns {boolean} whether operation was successful or not
     */
    toTensorM3Inverse(m3: ArrayLike<number> | number[] | Float32Array, epsilon: number): boolean;
    /**
     * Set from plane expressed as a 4 component vector
     * @param {number} x plane normal
     * @param {number} y plane normal
     * @param {number} z plane normal
     * @param {number} w plane offset
     */
    setFromVector4(x: number, y: number, z: number, w: number): void;
    /**
     * Squared distance from the given point to plane encoded by the quadric
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @returns {number}
     */
    evaluate(x: number, y: number, z: number): number;
    /**
     * Find the optimal vertex position based on the quadric
     *
     * @param {number[]} out vector3
     * @returns {boolean}
     */
    optimize(out: number[]): boolean;
    /**
     *
     * @param {Quadric3} Q
     */
    add(Q: Quadric3): void;
    /**
     *
     * @param {number} v
     */
    multiplyScalar(v: number): void;
    /**
     *
     * @returns {Quadric3}
     */
    clone(): Quadric3;
    /**
     *
     * @param {Quadric3} other
     */
    copy(other: Quadric3): void;
    /**
     * Set all matrix values to 0
     */
    clear(): void;
    /**
     * Useful for type checking
     * @readonly
     * @type {boolean}
     */
    readonly isQuadric3: boolean;
}
//# sourceMappingURL=Quadric3.d.ts.map