import { VectorLike } from '@equinor/videx-linear-algebra';
/**
 * Vector2 class with x and y component. Can also be used as an array with two indices, i.e. using [0] and [1].
 * @class
 * @alias Vector2
 */
export default class Vector2 {
    /**
     * Declare that Vector2 will have numeric properties.
     */
    [index: number]: number;
    /**
     * Does the vector mutate?
     */
    isMutating: boolean;
    /**
     * Length variable to use vector as array.
     */
    length: number;
    /**
     * Construct a new Vector2 with identical x and y components.
     * @param value Value of x and y component
     */
    constructor(value: number);
    /**
     * Construct a new Vector2.
     * @param x Initial x component of vector
     * @param y Initial y component of vector
     */
    constructor(x: number, y: number);
    /**
     * Construct a new Vector2 using component from another vector.
     * @param vector
     */
    constructor(vector: VectorLike);
    /**
     * Construct a new Vector2 using an object with an x and y key.
     * @param vector
     */
    constructor(vector: {
        x: number;
        y: number;
    });
    /**
     * Construct a new Vector2.
     * @param nums A series of numbers
     */
    constructor(...nums: number[]);
    /**
     * Alternative getter/setter for x component.
     */
    get x(): number;
    set x(value: number);
    /**
     * Alternative getter/setter for y component.
     */
    get y(): number;
    set y(value: number);
    /**
     * Magnitude of vector.
     */
    get magnitude(): number;
    set magnitude(val: number);
    /**
     * Set mutable and return reference to self.
     * @returns Reference to self
     */
    get mutable(): Vector2;
    /**
     * Set immutable and return reference to self.
     * @returns Reference to self
     */
    get immutable(): Vector2;
    /**
     * [Mutation] Set both components of vector.
     * @param value Value of x and y component
     * @returns Reference to self
     */
    set(value: number): Vector2;
    /**
     * [Mutation] Set both components of vector.
     * @param x New x component of vector
     * @param y New y component of vector
     * @returns Reference to self
     */
    set(x: number, y: number): Vector2;
    /**
     * [Mutation] Set both components of vector.
     * @param vector Vector-like object with values on the format: [ x, y ]
     * @returns Reference to self
     */
    set(vector: VectorLike): Vector2;
    /**
     * Add values of given vector to target vector.
     * @param x X component to add
     * @param y Y component to add
     * @returns Resulting vector
     */
    add(x: number, y: number): Vector2;
    /**
     * Add values of given vector to target vector.
     * @param vector Vector to add
     * @returns Resulting vector
     */
    add(vector: VectorLike): Vector2;
    /**
     * a + b
     *
     * Add two values together.
     * @param a Left operand
     * @param b Right operand
     * @returns Resulting vector
     * @static
     */
    static add(a: VectorLike, b: VectorLike): Vector2;
    /**
     * Subtract from vector.
     * @param x X component to subtract
     * @param y Y component to subtract
     * @returns Resulting vector
     */
    sub(x: number, y: number): Vector2;
    /**
     * Subtract from vector.
     * @param vector Vector to subtract
     * @returns Resulting vector
     */
    sub(vector: VectorLike): Vector2;
    /**
     * a - b
     *
     * Subtract second vector from first vector.
     * @param a Left operand
     * @param b Right operand
     * @returns Resulting vector
     */
    static sub(a: VectorLike, b: VectorLike): Vector2;
    /**
     * target - this
     *
     * Subtract this vector from given vector.
     * @param x X component to subtract from
     * @param y Y component to subtract from
     * @returns Resulting vector
     */
    subFrom(x: number, y: number): Vector2;
    /**
     * target - this
     *
     * Subtract this vector from given vector.
     * @param vector Vector to to subtract from
     * @returns Resulting vector
     */
    subFrom(vector: VectorLike): Vector2;
    /**
     * v / n
     *
     * Divide vector by a numeric value.
     * @param v Vector to divide
     * @param n Numeric value
     * @returns Resulting vector
     */
    static divide(v: VectorLike, n: number): Vector2;
    /**
     * v * n
     *
     * Multiply vector by a numeric value.
     * @param v Vector to multiply
     * @param n Numeric value
     * @returns Resulting vector
     */
    static multiply(v: VectorLike, n: number): Vector2;
    /**
     * Scale vector by a numeric value.
     * @param n Numeric value
     * @returns Resulting vector
     */
    scale(n: number): Vector2;
    /**
     * Rescale the vector to given length.
     * @param n Numeric value
     * @returns Resulting vector
     */
    rescale(n: number): Vector2;
    /**
     * Ensures that the magnitude of the vector does not
     * exceed a given length.
     * @param {Number} n Numeric value
     * @returns {Vector2} Resulting vector
     */
    clampMagnitude(n: number): Vector2;
    /**
     * Rotate the vector by specified amount of radians. Positive
     * rotation is counter-clockwise.
     * @param rad Radians to rotate
     * @returns Resulting vector
     */
    rotate(rad: number): Vector2;
    /**
     * Rotate the vector by specified amount of degrees. Positive
     * rotation is counter-clockwise.
     * @param rad Degrees to rotate
     * @returns Resulting vector
     */
    rotateDeg(deg: number): Vector2;
    /**
     * Rotate the vector counter-clockwise by an amount of 90 degrees. Resulting
     * vector is perpendicular to the original.
     * @returns Resulting vector
     */
    rotate90(): Vector2;
    /**
     * Rotate the vector counter-clockwise by an amount of 180 degrees. Resulting
     * vector is opposite of original.
     * @returns Resulting vector
     */
    rotate180(): Vector2;
    /**
     * Rotate the vector counter-clockwise by an amount of 270 degrees. Resulting
     * vector is perpendicular to the original.
     * @returns Resulting vector
     */
    rotate270(): Vector2;
    /**
     * [Mutation] Normalizes the vector.
     * @returns Reference to vector
     */
    normalize(): Vector2;
    /**
     * Get normalized version of vector.
     * @returns Resulting vector
     */
    normalized(): Vector2;
    /**
     * Get distance between two positions.
     * @param a First position
     * @param b Second position
     * @returns Distance between positions
     */
    static distance(a: VectorLike, b: VectorLike): number;
    /**
     * Get dot product between two vectors.
     * @param a First vector
     * @param b Second vector
     * @return Dot product
     */
    static dot(a: VectorLike, b: VectorLike): number;
    /**
     * Get cross product between two vectors.
     * @param a First vector
     * @param b Second vector
     * @return Cross product
     */
    static cross(a: VectorLike, b: VectorLike): number;
    /**
     * Get angle (in radians) between vector and [1, 0].
     * @param v Target vector
     * @return Angle in radians
     */
    static angleRight(v: VectorLike): number;
    /**
     * Get angle (in degrees) between vector and [1, 0].
     * @param v Target vector
     * @return Angle in degrees
     */
    static angleRightDeg(v: VectorLike): number;
    /**
     * Get angle (in radians) between two vectors.
     * @param a First vector
     * @param b Second vector
     * @returns Angle in radians
     */
    static angle(a: VectorLike, b: VectorLike): number;
    /**
     * Get angle (in degrees) between two vectors.
     * @param a First vector
     * @param b Second vector
     * @returns Angle in degrees
     */
    static angleDeg(a: VectorLike, b: VectorLike): number;
    /**
     * Get signed angle (in radians) between two vectors.
     * @param a First vector
     * @param b Second vector
     * @returns Signed angle in radians
     */
    static signedAngle(a: VectorLike, b: VectorLike): number;
    /**
     * Get signed angle (in degrees) between two vectors.
     * @param a First vector
     * @param b Second vector
     * @returns Signed angle in degrees
     */
    static signedAngleDeg(a: VectorLike, b: VectorLike): number;
    /**
     * Interpolate between two positions with given value n.
     * @param a Position to interpolate from
     * @param b Position to interpolate to
     * @param t Value between 0 - 1 used for interpolation
     * @returns Interpolated position
     */
    static lerp(a: VectorLike, b: VectorLike, t: number): Vector2;
    /**
     * Rotates a vector, v1, towards a second vector, v2, based on a factor, n.
     * @param a Vector to interpolate from
     * @param b Vector to interpolate to
     * @param t Value between 0 - 1 used for interpolation
     * @returns Interpolated vector
     */
    static lerpRot(a: VectorLike, b: VectorLike, t: number): Vector2;
    /**
     * Creates a new vector with identical values.
     * Mutable state is not transferred.
     * @returns Clone of vector
     */
    clone(): Vector2;
    /**
     * Returns true if a equals b. Epsilon defines allowed deviation for the x and y component.
     * @param a Vector to evaluate
     * @param b Vector to compare with
     * @param epsilon Accepted deviation (Default: 0)
     * @returns Are vectors equal?
     */
    static equals(a: VectorLike, b: VectorLike, epsilon?: number): boolean;
    /**
     * Returns true if vector equals b. Epsilon defines allowed deviation for the x and y component.
     * @param vector Vector to compare with
     * @param epsilon Accepted deviation (Default: 0)
     * @returns Are vectors equal?
     */
    equals(vector: VectorLike, epsilon?: number): boolean;
    /**
     * Returns true if x and y is zero, otherwise returns false.
     * @param a Vector to evaluate
     * @param epsilon Accepted deviation from 0.00 (Default: 0)
     * @returns Is target zero vector?
     */
    static isZeroVector(vector: VectorLike, epsilon?: number): boolean;
    /**
     * Returns true if x and y is zero, otherwise returns false.
     * @param epsilon Accepted deviation from 0.00 (Default: 0)
     * @returns Is target zero vector?
     */
    isZeroVector(epsilon?: number): boolean;
    /**
     * Create an array from the vector.
     * @returns Array on the format: [ x, y ]
     */
    toArray(): [number, number];
    /**
     * [Mutation] Modifies both the x and y-component of a vector using a given function.
     * @param modifier Function used to modify
     * @returns Reference to vector
     */
    modify(modifier: (d: number) => number): Vector2;
    [Symbol.iterator](): {
        next: () => {
            value: number;
            done: boolean;
        };
    };
    /**
     * Vector2 with values: [0, 0].
     * @memberof Vector2
     */
    static get zero(): Vector2;
    /**
     * Vector2 with values: [1, 1].
     * @memberof Vector2
     */
    static get one(): Vector2;
    /**
     * Vector2 with values: [∞, ∞].
     * @memberof Vector2
     */
    static get positiveInfinity(): Vector2;
    /**
     * Vector2 with values: [-∞, -∞].
     * @memberof Vector2
     */
    static get negativeInfinity(): Vector2;
    /**
     * Vector2 with values: [0, 1].
     * @memberof Vector2
     */
    static get up(): Vector2;
    /**
     * Vector2 with values: [1, 0].
     * @memberof Vector2
     */
    static get right(): Vector2;
    /**
     * Vector2 with values: [0, -1].
     * @memberof Vector2
     */
    static get down(): Vector2;
    /**
     * Vector2 with values: [-1, 0].
     * @memberof Vector2
     */
    static get left(): Vector2;
}