import { Matrix4 } from "./Matrix4";
import { Euler } from "./Euler";
/** A three dimensional vector */
export declare class Vector3 {
    x: number;
    y: number;
    z: number;
    constructor(x: number, y: number, z: number);
    /**
     * Factory acting as constructor for Vector3
     * @param x
     * @param y
     * @param z
     */
    static create(x?: number, y?: number, z?: number): Vector3;
    /**
     * Clone function for Vector3
     * @param input
     */
    static clone(input: Vector3): Vector3;
    /**
     * Copy Vector3 vector
     * @param input
     */
    static copy(from: Vector3, to: Vector3): void;
    /**
     * Compare two Vector3's on equality (with optional deviation)
     * @param first
     * @param second
     * @param deviation
     */
    static isEqual(first: Vector3, second: Vector3, deviation?: number): boolean;
    /**
     * Creates a new Vector3 with absolute values of components
     * @param input
     */
    static absoluteComponents(input: Vector3): Vector3;
    /**
     * Returns normalized Vector3
     * @param vector
     */
    static normalize(vector: Vector3, length?: number): Vector3 | undefined;
    /**
     * Normalizes Vector3 vector
     * @param vector
     */
    static normalizeInPlace(vector: Vector3, length?: number): void;
    /**
     * Returns sum of given Vector3s
     * @param vectors
     */
    static add(...vectors: Vector3[]): Vector3;
    /**
     * Sums up given Vector3s and saves it into the first
     * @param vectors
     */
    static addOnFirst(...vectors: Vector3[]): Vector3 | undefined;
    /**
     * Subtracts second from first Vector3
     * @param first
     * @param second
     */
    static sub(first: Vector3, second: Vector3): Vector3;
    /**
     * Subtracts given Vector3s from first and saves it into the first
     * @param vectors
     */
    static subOnFirst(...vectors: Vector3[]): Vector3 | undefined;
    /**
     * Returns inner/dot product of first and second Vector3
     * @param first
     * @param second
     */
    static innerProduct(first: Vector3, second: Vector3): number;
    /**
     * Returns cross product of first and second Vector3
     * @param first
     * @param second
     */
    static crossProduct(first: Vector3, second: Vector3): Vector3;
    /**
     * Returns product of v and mat as new Vector3
     * @param vector
     * @param matrix
     */
    static multiplyWithMatrix4(vector: Vector3, matrix: Matrix4): Vector3;
    /**
     * Returns Vector3 with offset
     * @param offset
     * @param vector
     */
    static scalarAdd(offset: number, vector: Vector3): Vector3;
    /**
     * Adds offset on Vector3 vector
     * @param offset
     * @param vector
     */
    static scalarAddInPlace(offset: number, vector: Vector3): void;
    /**
     * Returns scaled Vector3
     * @param scalar
     * @param vector
     */
    static scalarMultiply(scalar: number, vector: Vector3): Vector3;
    /**
     * Scales Vector3 vector
     * @param scalar
     * @param vector
     */
    static scalarMultiplyInPlace(scalar: number, vector: Vector3): void;
    /**
     * Returns magnitude (length) of Vector3
     * @param vector
     */
    static magnitude(vector: Vector3): number;
    /**
     * Returns squared magnitude of Vector3
     * @param vector
     */
    static magnitudeSquared(vector: Vector3): number;
    /**
     * Returns distance between first and second Vector3
     * @param first
     * @param second
     */
    static distance(first: Vector3, second: Vector3): number;
    /**
     * Returns first parameter with the maximum entries from other Vector3 parameters
     * @param input
     * @oaram vectors
     */
    static maximizeInPlace(input: Vector3, ...vectors: Vector3[]): void;
    /**
     * Returns first parameter with the minimum entries from other Vector3 parameters
     * @param input
     * @oaram vectors
     */
    static minimizeInPlace(input: Vector3, ...vectors: Vector3[]): void;
    /**
     * Returns a Vector3 with negated components
     * @param vector
     */
    static reverse(vector: Vector3): Vector3;
    /**
     * Negates components of Vector3 vector
     * @param vector
     */
    static reverseInPlace(vector: Vector3): Vector3;
    /**
     * calculate angle (in radians) between two direction vectors (Vector3)
     * @param v
     * @param w
     */
    static angleBetween(v: Vector3, w: Vector3): number;
    /**
     * Rotates the Vector by applying a rotation matrix built by given Euler.
     * @param v Vector3
     * @param eulerRotation Euler
     */
    static rotate(v: Vector3, eulerRotation: Euler): Vector3;
    /** Convenience function to stringify Vector3 */
    static stringify(v: Vector3, precision?: number): string;
    /** Convenience function to check if Vector3 has invalid entries (no Not-a-Number, on infinite values) */
    static hasInvalidEntries(v: Vector3): boolean;
}
