import { Matrix4 } from "./Matrix4";
import { Euler } from "./Euler";
/** A two dimensional vector */
export declare type vec2 = {
    x: number;
    y: number;
};
/** A three dimensional vector*/
export declare type vec3 = {
    x: number;
    y: number;
    z: number;
};
/** A two or three dimensional vector */
export declare type vec2or3 = {
    x: number;
    y: number;
    z?: number;
};
/** Class with public static methods to make arithmetic operations on vectors easier. */
export declare class Vector {
    /**
     * Creates a new vec2 with absolute values of components
     * @param input
     */
    static AbsoluteComponents2(input: vec2): vec2;
    /**
     * Creates a new vec3 with absolute values of components
     * @param input
     */
    static AbsoluteComponents3(input: vec3): vec3;
    /**
     * Factory acting as constructor for vec2
     * @param x
     * @param y
     */
    static CreateVec2(x?: number, y?: number): vec2;
    /**
     * Factory acting as constructor for vec3
     * @param x
     * @param y
     * @param z
     */
    static CreateVec3(x?: number, y?: number, z?: number): vec3;
    /**
     * Clone function for vec2
     * @param input
     */
    static CloneVec2(input: vec2): vec2;
    /**
     * Clone function for vec3
     * @param input
     */
    static CloneVec3(input: vec3): vec3;
    /**
     * Copy vec2 vector
     * @param input
     */
    static CopyVec2(from: vec2, to: vec2): void;
    /**
     * Copy vec3 vector
     * @param input
     */
    static CopyVec3(from: vec3, to: vec3): void;
    /**
     * Returns normalized vec2
     * @param vector
     */
    static Normalize2(vector: vec2, length?: number): vec2 | undefined;
    /**
     * Returns normalized vec3
     * @param vector
     */
    static Normalize3(vector: vec3, length?: number): vec3 | undefined;
    /**
     * Normalizes vec2 vector
     * @param vector
     */
    static NormalizeInPlace2(vector: vec2, length?: number): vec2 | undefined;
    /**
     * Normalizes vec3 vector
     * @param vector
     */
    static NormalizeInPlace3(vector: vec3, length?: number): vec3 | undefined;
    /**
     * Subtracts second from first vec2
     * @param first
     * @param second
     */
    static Sub2(first: vec2, second: vec2): vec2;
    /**
     * Subtracts second from first vec3
     * @param first
     * @param second
     */
    static Sub3(first: vec3, second: vec3): vec3;
    /**
     * Subtracts given vec2s from first and saves it into the first
     * @param vectors
     */
    static SubOnFirst2(...vectors: vec2[]): vec2 | undefined;
    /**
     * Subtracts given vec3s from first and saves it into the first
     * @param vectors
     */
    static SubOnFirst3(...vectors: vec3[]): vec3 | undefined;
    /**
     * Returns sum of given vec2s
     * @param vectors
     */
    static Add2(...vectors: vec2[]): vec2;
    /**
     * Returns sum of given vec3s
     * @param vectors
     */
    static Add3(...vectors: vec3[]): vec3;
    /**
     * Sums up given vec2s and saves it into the first
     * @param vectors
     */
    static AddOnFirst2(...vectors: vec2[]): vec2 | undefined;
    /**
     * Sums up given vec3s and saves it into the first
     * @param vectors
     */
    static AddOnFirst3(...vectors: vec3[]): vec3 | undefined;
    /**
     * Returns squared magnitude of vec2
     * @param vector
     */
    static MagnitudeSquared2(vector: vec2): number;
    /**
     * Returns squared magnitude of vec3
     * @param vector
     */
    static MagnitudeSquared3(vector: vec3): number;
    /**
     * Returns magnitude (length) of vec2
     * @param vector
     */
    static Magnitude2(vector: vec2): number;
    /**
     * Returns magnitude (length) of vec3
     * @param vector
     */
    static Magnitude3(vector: vec3): number;
    /**
     * Returns first parameter with the maximum entries from other vec2 parameters
     * @param input
     * @oaram vectors
     */
    static MaximizeInPlace2(input: vec2, ...vectors: vec2[]): vec2;
    /**
     * Returns first parameter with the maximum entries from other vec3 parameters
     * @param input
     * @oaram vectors
     */
    static MaximizeInPlace3(input: vec3, ...vectors: vec3[]): vec3;
    /**
     * Returns first parameter with the minimum entries from other vec2 parameters
     * @param input
     * @oaram vectors
     */
    static MinimizeInPlace2(input: vec2, ...vectors: vec2[]): vec2;
    /**
     * Returns first parameter with the minimum entries from other vec3 parameters
     * @param input
     * @oaram vectors
     */
    static MinimizeInPlace3(input: vec3, ...vectors: vec3[]): vec3;
    /**
     * Returns inner product of first and second vec2
     * @param first
     * @param second
     */
    static InnerProduct2(first: vec2, second: vec2): number;
    /**
     * Returns inner product of first and second vec3
     * @param first
     * @param second
     */
    static InnerProduct3(first: vec3, second: vec3): number;
    /**
     * Returns cross product of first and second vec3
     * @param first
     * @param second
     */
    static Cross3(first: vec3, second: vec3): vec3;
    /**
     * Returns distance between first and second vec2
     * @param first
     * @param second
     */
    static Distance2(first: vec2, second: vec2): number;
    /**
     * Returns distance between first and second vec3
     * @param first
     * @param second
     */
    static Distance3(first: vec3, second: vec3): number;
    /**
     * Returns scaled vec2
     * @param scalar
     * @param vector
     */
    static ScalarMultiply2(scalar: number, vector: vec2): vec2;
    /**
     * Returns scaled vec3
     * @param scalar
     * @param vector
     */
    static ScalarMultiply3(scalar: number, vector: vec3): vec3;
    /**
     * Scales vec2 vector
     * @param scalar
     * @param vector
     */
    static ScalarMultiplyInPlace2(scalar: number, vector: vec2): vec2;
    /**
     * Scales vec3 vector
     * @param scalar
     * @param vector
     */
    static ScalarMultiplyInPlace3(scalar: number, vector: vec3): vec3;
    /**
     * Returns vec2 with offset
     * @param offset
     * @param vector
     */
    static ScalarAdd2(offset: number, vector: vec2): vec2;
    /**
     * Returns vec3 with offset
     * @param offset
     * @param vector
     */
    static ScalarAdd3(offset: number, vector: vec3): vec3;
    /**
     * Adds offset on vec2 vector
     * @param offset
     * @param vector
     */
    static ScalarAddInPlace2(offset: number, vector: vec2): vec2;
    /**
     * Adds offset on vec3 vector
     * @param offset
     * @param vector
     */
    static ScalarAddInPlace3(offset: number, vector: vec3): vec3;
    /**
     * Returns a vec2 with negated components
     * @param vector
     */
    static Reverse2(vector: vec2): vec2;
    /**
     * Returns a vec3 with negated components
     * @param vector
     */
    static Reverse3(vector: vec3): vec3;
    /**
     * Negates components of vec2 vector
     * @param vector
     */
    static ReverseInPlace2(vector: vec2): vec2;
    /**
     * Negates components of vec3 vector
     * @param vector
     */
    static ReverseInPlace3(vector: vec3): vec3;
    /**
     * Compare two vec2's on equality (with optional deviation)
     * @param first
     * @param second
     * @param deviation
     */
    static IsEqual2(first: vec2, second: vec2, deviation?: number): boolean;
    /**
     * Compare two vec3's on equality (with optional deviation)
     * @param first
     * @param second
     * @param deviation
     */
    static IsEqual3(first: vec3, second: vec3, deviation?: number): boolean;
    /**
     * calculate angle (in radians) between two direction vectors (vec2)
     * @param v
     * @param w
     */
    static AngleBetweenVectors2(v: vec2, w: vec2): number;
    /**
     * calculate angle (in radians) between two direction vectors (vec3)
     * @param v
     * @param w
     */
    static AngleBetweenVectors3(v: vec3, w: vec3): number;
    static ApplyMatrix4(v: vec3, mat: Matrix4): vec3;
    static RotateVec3(v: vec3, eulerRotation: Euler): vec3;
    /** Convenience function to stringify vec2 */
    static StringifyVec2(v: vec2, precision?: number): string;
    /** Convenience function to stringify vec3 */
    static StringifyVec3(v: vec3, precision?: number): string;
    /** Convenience function to check if vec2 has invalid entries (no Not-a-Number, on infinite values) */
    static HasInvalidEntries2(v: vec2): boolean;
    /** Convenience function to check if vec3 has invalid entries (no Not-a-Number, on infinite values) */
    static HasInvalidEntries3(v: vec3): boolean;
}
