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