import { type RectangleLike } from './rectangle';
import { Geometry } from './geometry';
import type { PointLike, PointData, PointBearing, PointOptions } from '../types';
export { PointLike, PointData, PointBearing, PointOptions };
export declare class Point extends Geometry implements PointLike {
    static create(x?: number | Point | PointOptions, y?: number): Point;
    static clone(p: Point | PointOptions): Point;
    static equals(p1?: PointLike, p2?: PointLike): boolean;
    static rotateEx(point: Point | PointOptions, cos: number, sin: number, center?: Point | PointOptions): Point;
    static toJSON(p: Point | PointOptions): {
        x: number;
        y: number;
    };
    /**
     * Returns a new Point object from the given polar coordinates.
     * @see http://en.wikipedia.org/wiki/Polar_coordinate_system
     */
    static fromPolar(r: number, rad: number, origin?: Point | PointOptions): Point;
    /**
     * Converts rectangular to polar coordinates.
     */
    static toPolar(point: Point | PointOptions, origin?: Point | PointOptions): Point;
    static equalPoints(p1: PointLike[], p2: PointLike[]): boolean;
    /**
     * Returns a point with random coordinates that fall within the range
     * `[x1, x2]` and `[y1, y2]`.
     */
    static random(x1: number, x2: number, y1: number, y2: number): Point;
    static rotate(point: Point | PointOptions, angle: number, center?: Point | PointOptions): Point;
    static isPoint(instance: any): instance is Point;
    static isPointLike(p: any): p is PointLike;
    static isPointData(p: any): p is PointData;
    x: number;
    y: number;
    constructor();
    constructor(x?: number, y?: number);
    /**
     * Rounds the point to the given precision.
     */
    round(precision?: number): this;
    add(x: number, y: number): this;
    add(p: PointOptions): this;
    update(x: number, y: number): this;
    update(p: PointOptions): this;
    translate(dx: number, dy: number): this;
    translate(p: PointOptions): this;
    /**
     * Rotate the point by `degree` around `center`.
     */
    rotate(degree: number, center?: PointOptions): this;
    /**
     * Scale point by `sx` and `sy` around the given `origin`. If origin is
     * not specified, the point is scaled around `0, 0`.
     */
    scale(sx: number, sy: number, origin?: PointOptions): this;
    /**
     * Chooses the point closest to this point from among `points`. If `points`
     * is an empty array, `null` is returned.
     */
    closest(points: PointOptions[]): Point;
    /**
     * Returns the distance between the point and another point `p`.
     */
    distance(p: PointOptions): number;
    /**
     * Returns the squared distance between the point and another point `p`.
     *
     * Useful for distance comparisons in which real distance is not necessary
     * (saves one `Math.sqrt()` operation).
     */
    squaredDistance(p: PointOptions): number;
    manhattanDistance(p: PointOptions): number;
    /**
     * Returns the magnitude of the point vector.
     *
     * @see http://en.wikipedia.org/wiki/Magnitude_(mathematics)
     */
    magnitude(): number;
    /**
     * Returns the angle(in degrees) between vector from this point to `p` and
     * the x-axis.
     */
    theta(p?: PointOptions): number;
    /**
     * Returns the angle(in degrees) between vector from this point to `p1` and
     * the vector from this point to `p2`.
     *
     * The ordering of points `p1` and `p2` is important.
     *
     * The function returns a value between `0` and `180` when the angle (in the
     * direction from `p1` to `p2`) is clockwise, and a value between `180` and
     * `360` when the angle is counterclockwise.
     *
     * Returns `NaN` if either of the points `p1` and `p2` is equal with this point.
     */
    angleBetween(p1: PointOptions, p2: PointOptions): number;
    /**
     * Returns the angle(in degrees) between the line from `(0,0)` and this point
     * and the line from `(0,0)` to `p`.
     *
     * The function returns a value between `0` and `180` when the angle (in the
     * direction from this point to `p`) is clockwise, and a value between `180`
     * and `360` when the angle is counterclockwise. Returns `NaN` if called from
     * point `(0,0)` or if `p` is `(0,0)`.
     */
    vectorAngle(p: PointOptions): number;
    /**
     * Converts rectangular to polar coordinates.
     */
    toPolar(origin?: PointOptions): this;
    /**
     * Returns the change in angle(in degrees) that is the result of moving the
     * point from its previous position to its current position.
     *
     * More specifically, this function computes the angle between the line from
     * the ref point to the previous position of this point(i.e. current position
     * `-dx`, `-dy`) and the line from the `ref` point to the current position of
     * this point.
     *
     * The function returns a positive value between `0` and `180` when the angle
     * (in the direction from previous position of this point to its current
     * position) is clockwise, and a negative value between `0` and `-180` when
     * the angle is counterclockwise.
     *
     * The function returns `0` if the previous and current positions of this
     * point are the same (i.e. both `dx` and `dy` are `0`).
     */
    changeInAngle(dx: number, dy: number, ref?: PointOptions): number;
    /**
     * If the point lies outside the rectangle `rect`, adjust the point so that
     * it becomes the nearest point on the boundary of `rect`.
     */
    adhereToRect(rect: RectangleLike): this;
    /**
     * Returns the bearing(cardinal direction) between me and the given point.
     *
     * @see https://en.wikipedia.org/wiki/Cardinal_direction
     */
    bearing(p: PointOptions): PointBearing;
    /**
     * Returns the cross product of the vector from me to `p1` and the vector
     * from me to `p2`.
     *
     * The left-hand rule is used because the coordinate system is left-handed.
     */
    cross(p1: PointOptions, p2: PointOptions): number;
    /**
     * Returns the dot product of this point with given other point.
     */
    dot(p: PointOptions): number;
    /**
     * Returns a point that has coordinates computed as a difference between the
     * point and another point with coordinates `dx` and `dy`.
     *
     * If only `dx` is specified and is a number, `dy` is considered to be zero.
     * If only `dx` is specified and is an object, it is considered to be another
     * point or an object in the form `{ x: [number], y: [number] }`
     */
    diff(dx: number, dy: number): Point;
    diff(p: PointOptions): Point;
    /**
     * Returns an interpolation between me and point `p` for a parametert in
     * the closed interval `[0, 1]`.
     */
    lerp(p: PointOptions, t: number): Point;
    /**
     * Normalize the point vector, scale the line segment between `(0, 0)`
     * and the point in order for it to have the given length. If length is
     * not specified, it is considered to be `1`; in that case, a unit vector
     * is computed.
     */
    normalize(length?: number): this;
    /**
     * Moves this point along the line starting from `ref` to this point by a
     * certain `distance`.
     */
    move(ref: PointOptions, distance: number): this;
    /**
     * Returns a point that is the reflection of me with the center of inversion
     * in `ref` point.
     */
    reflection(ref: PointOptions): Point;
    /**
     * Snaps the point(change its x and y coordinates) to a grid of size `gridSize`
     * (or `gridSize` x `gridSizeY` for non-uniform grid).
     */
    snapToGrid(gridSize: number): this;
    snapToGrid(gx: number, gy: number): this;
    snapToGrid(gx: number, gy?: number): this;
    equals(p: PointOptions): boolean;
    clone(): Point;
    /**
     * Returns the point as a simple JSON object. For example: `{ x: 0, y: 0 }`.
     */
    toJSON(): {
        x: number;
        y: number;
    };
    serialize(): string;
}