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