import '../../../assert/js/assert.js';
import '../../../globals.js';
/**
 * Displays a (stroked) line. Inherits Path, and allows for optimized drawing and improved parameter handling.
 *
 * @author Jonathan Olson <jonathan.olson@colorado.edu>
 */
import TReadOnlyProperty from '../../../axon/js/TReadOnlyProperty.js';
import Bounds2 from '../../../dot/js/Bounds2.js';
import Matrix3 from '../../../dot/js/Matrix3.js';
import Vector2 from '../../../dot/js/Vector2.js';
import { Shape } from '../../../kite/js/imports.js';
import StrictOmit from '../../../phet-core/js/types/StrictOmit.js';
import { CanvasContextWrapper, CanvasSelfDrawable, Instance, Path, PathOptions, SVGSelfDrawable } from '../imports.js';
type SelfOptions = {
    p1?: Vector2;
    p2?: Vector2;
    x1?: number;
    y1?: number;
    x2?: number;
    y2?: number;
};
export type LineOptions = SelfOptions & StrictOmit<PathOptions, 'shape' | 'shapeProperty'>;
export default class Line extends Path {
    private _x1;
    private _y1;
    private _x2;
    private _y2;
    constructor(options?: LineOptions);
    constructor(p1: Vector2, p2: Vector2, options?: LineOptions);
    constructor(x1: number, y1: number, x2: number, y2: number, options?: LineOptions);
    /**
     * Set all of the line's x and y values.
     *
     * @param x1 - the start x coordinate
     * @param y1 - the start y coordinate
     * @param x2 - the end x coordinate
     * @param y2 - the end y coordinate
     */
    setLine(x1: number, y1: number, x2: number, y2: number): this;
    /**
     * Set the line's first point's x and y values
     */
    setPoint1(p1: Vector2): this;
    setPoint1(x1: number, y1: number): this;
    set p1(point: Vector2);
    get p1(): Vector2;
    /**
     * Set the line's second point's x and y values
     */
    setPoint2(p1: Vector2): this;
    setPoint2(x2: number, y2: number): this;
    set p2(point: Vector2);
    get p2(): Vector2;
    /**
     * Sets the x coordinate of the first point of the line.
     */
    setX1(x1: number): this;
    set x1(value: number);
    get x1(): number;
    /**
     * Returns the x coordinate of the first point of the line.
     */
    getX1(): number;
    /**
     * Sets the y coordinate of the first point of the line.
     */
    setY1(y1: number): this;
    set y1(value: number);
    get y1(): number;
    /**
     * Returns the y coordinate of the first point of the line.
     */
    getY1(): number;
    /**
     * Sets the x coordinate of the second point of the line.
     */
    setX2(x2: number): this;
    set x2(value: number);
    get x2(): number;
    /**
     * Returns the x coordinate of the second point of the line.
     */
    getX2(): number;
    /**
     * Sets the y coordinate of the second point of the line.
     */
    setY2(y2: number): this;
    set y2(value: number);
    get y2(): number;
    /**
     * Returns the y coordinate of the second point of the line.
     */
    getY2(): number;
    /**
     * Returns a Shape that is equivalent to our rendered display. Generally used to lazily create a Shape instance
     * when one is needed, without having to do so beforehand.
     */
    private createLineShape;
    /**
     * Notifies that the line has changed and invalidates path information and our cached shape.
     */
    private invalidateLine;
    /**
     * Computes whether the provided point is "inside" (contained) in this Line's self content, or "outside".
     *
     * Since an unstroked Line contains no area, we can quickly shortcut this operation.
     *
     * @param point - Considered to be in the local coordinate frame
     */
    containsPointSelf(point: Vector2): boolean;
    /**
     * Draws the current Node's self representation, assuming the wrapper's Canvas context is already in the local
     * coordinate frame of this node.
     *
     * @param wrapper
     * @param matrix - The transformation matrix already applied to the context.
     */
    protected canvasPaintSelf(wrapper: CanvasContextWrapper, matrix: Matrix3): void;
    /**
     * Computes the bounds of the Line, including any applied stroke. Overridden for efficiency.
     */
    computeShapeBounds(): Bounds2;
    /**
     * Creates a SVG drawable for this Line.
     *
     * @param renderer - In the bitmask format specified by Renderer, which may contain additional bit flags.
     * @param instance - Instance object that will be associated with the drawable
     */
    createSVGDrawable(renderer: number, instance: Instance): SVGSelfDrawable;
    /**
     * Creates a Canvas drawable for this Line.
     *
     * @param renderer - In the bitmask format specified by Renderer, which may contain additional bit flags.
     * @param instance - Instance object that will be associated with the drawable
     */
    createCanvasDrawable(renderer: number, instance: Instance): CanvasSelfDrawable;
    /**
     * It is impossible to set another shape on this Path subtype, as its effective shape is determined by other
     * parameters.
     *
     * Throws an error if it is not null.
     */
    setShape(shape: Shape | null): this;
    /**
     * Returns an immutable copy of this Path subtype's representation.
     *
     * NOTE: This is created lazily, so don't call it if you don't have to!
     */
    getShape(): Shape;
    /**
     * Returns whether this Path has an associated Shape (instead of no shape, represented by null)
     */
    hasShape(): boolean;
    setShapeProperty(newTarget: TReadOnlyProperty<Shape | string | null> | null): this;
    mutate(options?: LineOptions): this;
    /**
     * Returns available fill renderers. (scenery-internal)
     *
     * Since our line can't be filled, we support all fill renderers.
     *
     * See Renderer for more information on the bitmasks
     */
    getFillRendererBitmask(): number;
}
export {};
//# sourceMappingURL=Line.d.ts.map