import '../../../assert/js/assert.js';
import '../../../globals.js';
/**
 * A Node for a focus highlight that takes a shape and creates a Path with the default styling of a focus highlight
 * for a11y. The FocusHighlight has two paths.  The FocusHighlight path is an 'outer' highlight that is a little
 * lighter in color and transparency.  It as a child 'inner' path that is darker and more opaque, which gives the
 * focus highlight the illusion that it fades out.
 *
 * @author Michael Kauzmann (PhET Interactive Simulations)
 * @author Jesse Greenberg (PhET Interactive Simulations)
 */
import Emitter from '../../../axon/js/Emitter.js';
import TReadOnlyProperty from '../../../axon/js/TReadOnlyProperty.js';
import Matrix3 from '../../../dot/js/Matrix3.js';
import StrictOmit from '../../../phet-core/js/types/StrictOmit.js';
import { Color, InputShape, Node, Path, PathOptions, TPaint, Trail } from '../imports.js';
type SelfOptions = {
    outerStroke?: TPaint;
    innerStroke?: TPaint;
    outerLineWidth?: number | null;
    innerLineWidth?: number | null;
    dashed?: boolean;
    transformSourceNode?: Node | null;
};
export type HighlightPathOptions = SelfOptions & StrictOmit<PathOptions, 'stroke' | 'lineWidth'>;
declare class HighlightPath extends Path {
    private _innerHighlightColor;
    private _outerHighlightColor;
    readonly highlightChangedEmitter: Emitter<[]>;
    readonly transformSourceNode: Node | null;
    private readonly outerLineWidth;
    private readonly innerLineWidth;
    protected readonly innerHighlightPath: Path;
    static readonly OUTER_FOCUS_COLOR: Color;
    static readonly INNER_FOCUS_COLOR: Color;
    static readonly INNER_LIGHT_GROUP_FOCUS_COLOR: Color;
    static readonly OUTER_LIGHT_GROUP_FOCUS_COLOR: Color;
    static readonly INNER_DARK_GROUP_FOCUS_COLOR: Color;
    static readonly OUTER_DARK_GROUP_FOCUS_COLOR: Color;
    static readonly GROUP_OUTER_LINE_WIDTH = 2;
    static readonly GROUP_INNER_LINE_WIDTH = 2;
    static layoutScale: number;
    /**
     * @param [shape] - the shape for the focus highlight
     * @param [providedOptions]
     */
    constructor(shape: InputShape | TReadOnlyProperty<InputShape>, providedOptions?: HighlightPathOptions);
    /**
     * Mutating convenience function to mutate both the innerHighlightPath and outerHighlightPath.
     */
    mutateWithInnerHighlight(options: PathOptions): void;
    /**
     * Mutate both inner and outer Paths to make the stroke dashed by using `lineDash`.
     */
    setDashed(dashOn: boolean): void;
    /**
     * Update the shape of the child path (inner highlight) and this path (outer highlight). Note for the purposes
     * of chaining the outer Path (this) is returned, not the inner Path.
     */
    setShape(shape: InputShape): this;
    /**
     * Update the line width of both Paths based on transform of this Path, or another Node passed in (usually the
     * node that is being highlighted). Can be overridden by the options
     * passed in the constructor.
     */
    updateLineWidth(matrix: Matrix3): void;
    /**
     * Given a transformation matrix, return the lineWidth of this focus highlight (unless a custom
     * lineWidth was specified in the options).
     *
     * Note - this takes a matrix3 instead of a Node because that is already computed by the highlight
     * overlay and we can avoid the extra computation of the Node's local-to-global matrix.
     */
    getOuterLineWidth(matrix: Matrix3): number;
    /**
     * Given a transformation matrix, return the lineWidth of this focus highlight (unless a custom
     * lineWidth was specified in the options).
     *
     * Note - this takes a matrix3 instead of a Node because that is already computed by the highlight
     * overlay and we can avoid the extra computation of the Node's local-to-global matrix.
     */
    getInnerLineWidth(matrix: Matrix3): number;
    /**
     * Set the inner color of this focus highlight.
     */
    setInnerHighlightColor(color: TPaint): void;
    set innerHighlightColor(color: TPaint);
    get innerHighlightColor(): TPaint;
    /**
     * Get the inner color of this focus highlight path.
     */
    getInnerHighlightColor(): TPaint;
    /**
     * Set the outer color of this focus highlight.
     */
    setOuterHighlightColor(color: TPaint): void;
    set outerHighlightColor(color: TPaint);
    get outerHighlightColor(): TPaint;
    /**
     * Get the color of the outer highlight for this HighlightPath
     */
    getOuterHighlightColor(): TPaint;
    /**
     * Return the trail to the transform source node being used for this focus highlight. So that we can observe
     * transforms applied to the source node so that the focus highlight can update accordingly.
     * (scenery-internal)
     *
     * @param focusedTrail - Trail to focused Node, to help search unique Trail to the transformSourceNode
     */
    getUniqueHighlightTrail(focusedTrail: Trail): Trail;
    /**
     * Get the inner line width for a transformation matrix (presumably from the Node being highlighted).
     */
    private static getInnerLineWidthFromMatrix;
    /**
     * Get the outer line width for a transformation matrix (presumably from the Node being highlighted).
     */
    private static getOuterLineWidthFromMatrix;
    /**
     * Get a scalar width to use for the focus highlight based on the global transformation matrix
     * (presumably from the Node being highlighted). This helps make sure that the highlight
     * line width remains consistent even when the Node has some scale applied to it.
     */
    private static localToGlobalScaleFromMatrix;
    /**
     * Get the coefficient needed to scale the highlights bounds to surround the node being highlighted elegantly.
     * The highlight is based on a Node's bounds, so it should be scaled out a certain amount so that there is white
     * space between the edge of the component and the beginning (inside edge) of the focusHighlight
     */
    static getDilationCoefficient(matrix: Matrix3): number;
    /**
     * Returns the highlight dilation coefficient when there is no transformation.
     */
    static getDefaultDilationCoefficient(): number;
    /**
     * Returns the highlight dilation coefficient for a group focus highlight, which is a bit
     * larger than the typical dilation coefficient.
     */
    static getDefaultGroupDilationCoefficient(): number;
    /**
     * The default highlight line width. The outer line width is wider and can be used as a value for layout. This is the
     * value of the line width without any transformation. The actual value in the global coordinate frame may change
     * based on the pan/zoom of the screen.
     */
    static getDefaultHighlightLineWidth(): number;
    /**
     * Get the dilation coefficient for a group focus highlight, which extends even further beyond node bounds
     * than a regular focus highlight. The group focus highlight goes around a node whenever its descendant has focus,
     * so this will always surround the normal focus highlight.
     */
    static getGroupDilationCoefficient(matrix: Matrix3): number;
    /**
     * Returns a matrix representing the inverse of the pan/zoom transform, so that the highlight can be drawn in the
     * global coordinate frame. Do not modify this matrix.
     */
    private static getPanZoomCorrectingMatrix;
    /**
     * Returns a matrix that corrects for the layout scale of the application, so that the highlight can be drawn in the
     * global coordinate frame. Do not modify this matrix.
     */
    private static getLayoutCorrectingMatrix;
    /**
     * Returns a final matrix to use to scale a highlight so that it is in a consistent size relative to the
     * application layout bounds.
     */
    static getCorrectiveScalingMatrix(): Matrix3;
}
export default HighlightPath;
//# sourceMappingURL=HighlightPath.d.ts.map