import '../../../assert/js/assert.js';
import '../../../globals.js';
/**
 * A circular node that 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, DOMSelfDrawable, Instance, Path, PathOptions, SVGSelfDrawable, VoicingOptions } from '../imports.js';
type SelfOptions = {
    radius?: number;
};
export type CircleOptions = SelfOptions & VoicingOptions & StrictOmit<PathOptions, 'shape' | 'shapeProperty'>;
export default class Circle extends Path {
    private _radius;
    /**
     * NOTE: There are two ways of invoking the constructor:
     * - new Circle( radius, { ... } )
     * - new Circle( { radius: radius, ... } )
     *
     * This allows the radius to be included in the parameter object for when that is convenient.
     *
     * @param radius - The (non-negative) radius of the circle
     * @param  [options] - Circle-specific options are documented in CIRCLE_OPTION_KEYS above, and can be provided
     *                     along-side options for Node
     */
    constructor(options?: CircleOptions);
    constructor(radius: number, options?: CircleOptions);
    /**
     * Determines the default allowed renderers (returned via the Renderer bitmask) that are allowed, given the
     * current stroke options. (scenery-internal)
     *
     * We can support the DOM renderer if there is a solid-styled stroke (which otherwise wouldn't be supported).
     */
    getStrokeRendererBitmask(): number;
    /**
     * Determines the allowed renderers that are allowed (or excluded) based on the current Path. (scenery-internal)
     */
    getPathRendererBitmask(): number;
    /**
     * Notifies that the circle has changed (probably the radius), and invalidates path information and our cached
     * shape.
     */
    private invalidateCircle;
    /**
     * 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 createCircleShape;
    /**
     * Returns whether this Circle's selfBounds is intersected by the specified bounds.
     *
     * @param bounds - Bounds to test, assumed to be in the local coordinate frame.
     */
    intersectsBoundsSelf(bounds: Bounds2): 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;
    /**
     * Creates a DOM drawable for this Circle. (scenery-internal)
     *
     * @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
     */
    createDOMDrawable(renderer: number, instance: Instance): DOMSelfDrawable;
    /**
     * Creates a SVG drawable for this Circle. (scenery-internal)
     *
     * @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 Circle. (scenery-internal)
     *
     * @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;
    /**
     * Sets the radius of the circle.
     */
    setRadius(radius: number): this;
    set radius(value: number);
    get radius(): number;
    /**
     * Returns the radius of the circle.
     */
    getRadius(): number;
    /**
     * Computes the bounds of the Circle, including any applied stroke. Overridden for efficiency.
     */
    computeShapeBounds(): Bounds2;
    /**
     * Computes whether the provided point is "inside" (contained) in this Circle's self content, or "outside".
     *
     * Exists to optimize hit detection, as it's quick to compute for circles.
     *
     * @param point - Considered to be in the local coordinate frame
     */
    containsPointSelf(point: Vector2): boolean;
    /**
     * It is impossible to set another shape on this Path subtype, as its effective shape is determined by other
     * parameters.
     *
     * @param shape - 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?: CircleOptions): this;
}
export {};
//# sourceMappingURL=Circle.d.ts.map