import '../../../../assert/js/assert.js';
import '../../../../globals.js';
import TEmitter from '../../../../axon/js/TEmitter.js';
import TProperty from '../../../../axon/js/TProperty.js';
import TReadOnlyProperty from '../../../../axon/js/TReadOnlyProperty.js';
import Bounds2 from '../../../../dot/js/Bounds2.js';
import PickOptional from '../../../../phet-core/js/types/PickOptional.js';
import StrictOmit from '../../../../phet-core/js/types/StrictOmit.js';
import PhetioObject, { PhetioObjectOptions } from '../../../../tandem/js/PhetioObject.js';
import { TAlertable } from '../../../../utterance-queue/js/Utterance.js';
import type UtteranceQueue from '../../../../utterance-queue/js/UtteranceQueue.js';
import { Highlight, Node, PDOMDisplaysInfo, PDOMInstance, Trail } from '../../imports.js';
export type PDOMValueType = string | TReadOnlyProperty<string>;
export type LimitPanDirection = 'horizontal' | 'vertical';
declare const ACCESSIBILITY_OPTION_KEYS: string[];
type ParallelDOMSelfOptions = {
    focusable?: boolean | null;
    tagName?: string | null;
    accessibleName?: PDOMValueType | null;
    accessibleParagraph?: PDOMValueType | null;
    helpText?: PDOMValueType | null;
    pdomHeading?: PDOMValueType | null;
    accessibleNameBehavior?: PDOMBehaviorFunction;
    helpTextBehavior?: PDOMBehaviorFunction;
    pdomHeadingBehavior?: PDOMBehaviorFunction;
    containerTagName?: string | null;
    containerAriaRole?: string | null;
    innerContent?: PDOMValueType | null;
    inputType?: string | null;
    inputValue?: PDOMValueType | null | number;
    pdomChecked?: boolean;
    pdomNamespace?: string | null;
    ariaLabel?: PDOMValueType | null;
    ariaRole?: string | null;
    ariaValueText?: PDOMValueType | null;
    labelTagName?: string | null;
    labelContent?: PDOMValueType | null;
    appendLabel?: boolean;
    descriptionTagName?: string | null;
    descriptionContent?: PDOMValueType | null;
    appendDescription?: boolean;
    focusHighlight?: Highlight;
    focusHighlightLayerable?: boolean;
    groupFocusHighlight?: Node | boolean;
    pdomVisibleProperty?: TReadOnlyProperty<boolean> | null;
    pdomVisible?: boolean;
    pdomOrder?: (Node | null)[] | null;
    ariaLabelledbyAssociations?: Association[];
    ariaDescribedbyAssociations?: Association[];
    activeDescendantAssociations?: Association[];
    focusPanTargetBoundsProperty?: TReadOnlyProperty<Bounds2> | null;
    limitPanDirection?: LimitPanDirection | null;
    positionInPDOM?: boolean;
    pdomTransformSourceNode?: Node | null;
};
export type ParallelDOMOptions = ParallelDOMSelfOptions & PhetioObjectOptions;
export type RemoveParallelDOMOptions<T extends ParallelDOMOptions> = StrictOmit<T, keyof ParallelDOMSelfOptions>;
export type TrimParallelDOMOptions<T extends ParallelDOMSelfOptions> = RemoveParallelDOMOptions<T> & PickOptional<ParallelDOMSelfOptions, 'accessibleName' | 'helpText' | 'focusable' | 'pdomVisible'>;
type PDOMAttribute = {
    attribute: string;
    value: PDOMValueType | boolean | number;
    listener: ((rawValue: string | boolean | number) => void) | null;
    options: SetPDOMAttributeOptions;
};
type PDOMClass = {
    className: string;
    options: SetPDOMClassOptions;
};
export type Association = {
    otherNode: Node;
    otherElementName: string;
    thisElementName: string;
};
type SetPDOMAttributeOptions = {
    namespace?: string | null;
    type?: 'attribute' | 'property';
    elementName?: string;
};
type RemovePDOMAttributeOptions = {
    namespace?: string | null;
    elementName?: string;
};
type HasPDOMAttributeOptions = {
    namespace?: string | null;
    elementName?: string;
};
type SetPDOMClassOptions = {
    elementName?: string;
};
type RemovePDOMClassOptions = {
    elementName?: string;
};
/**
 *
 * @param node - the Node that the pdom behavior is being applied to
 * @param options - options to mutate within the function
 * @param value - the value that you are setting the behavior of, like the accessibleName
 * @param callbacksForOtherNodes - behavior function also support taking state from a Node and using it to
 * set the accessible content for another Node. If this is the case, that logic should be set in a closure and added to
 * this list for execution after this Node is fully created. See discussion in https://github.com/phetsims/sun/issues/503#issuecomment-676541373
 * @returns the options that have been mutated by the behavior function.
 */
export type PDOMBehaviorFunction = (node: Node, options: ParallelDOMOptions, value: PDOMValueType, callbacksForOtherNodes: (() => void)[]) => ParallelDOMOptions;
export default class ParallelDOM extends PhetioObject {
    private _tagName;
    private _containerTagName;
    private _labelTagName;
    private _descriptionTagName;
    private _inputType;
    private _inputValue;
    private _pdomChecked;
    private _appendLabel;
    private _appendDescription;
    private _pdomAttributes;
    private _pdomClasses;
    private _labelContent;
    private _innerContent;
    private _descriptionContent;
    private _pdomNamespace;
    private _ariaLabel;
    private _hasAppliedAriaLabel;
    private _ariaRole;
    private _containerAriaRole;
    private _ariaValueText;
    private _hasAppliedAriaValueText;
    private _ariaLabelledbyAssociations;
    private _nodesThatAreAriaLabelledbyThisNode;
    private _ariaDescribedbyAssociations;
    private _nodesThatAreAriaDescribedbyThisNode;
    private _activeDescendantAssociations;
    private _nodesThatAreActiveDescendantToThisNode;
    private _focusableOverride;
    private _focusHighlight;
    private _focusHighlightLayerable;
    private _groupFocusHighlight;
    private readonly _pdomVisibleProperty;
    private _pdomOrder;
    _pdomParent: Node | null;
    private _pdomTransformSourceNode;
    private _focusPanTargetBoundsProperty;
    private _limitPanDirection;
    _pdomDisplaysInfo: PDOMDisplaysInfo;
    private readonly _pdomInstances;
    private _positionInPDOM;
    private excludeLabelSiblingFromInput;
    private _accessibleName;
    private _accessibleNameBehavior;
    private _accessibleParagraph;
    private _helpText;
    private _helpTextBehavior;
    private _pdomHeading;
    private _headingLevel;
    private _pdomHeadingBehavior;
    readonly focusHighlightChangedEmitter: TEmitter;
    readonly pdomParentChangedEmitter: TEmitter;
    readonly pdomDisplaysEmitter: TEmitter;
    protected pdomBoundInputEnabledListener: (enabled: boolean) => void;
    protected _onPDOMContentChangeListener: () => void;
    protected _onInputValueChangeListener: () => void;
    protected _onAriaLabelChangeListener: () => void;
    protected _onAriaValueTextChangeListener: () => void;
    protected _onLabelContentChangeListener: () => void;
    protected _onDescriptionContentChangeListener: () => void;
    protected _onInnerContentChangeListener: () => void;
    protected constructor(options?: PhetioObjectOptions);
    /***********************************************************************************************************/
    /***********************************************************************************************************/
    /**
     * Dispose accessibility by removing all listeners on this Node for accessible input. ParallelDOM is disposed
     * by calling Node.dispose(), so this function is scenery-internal.
     * (scenery-internal)
     */
    protected disposeParallelDOM(): void;
    private pdomInputEnabledListener;
    /**
     * Get whether this Node's primary DOM element currently has focus.
     */
    isFocused(): boolean;
    get focused(): boolean;
    /**
     * Focus this Node's primary dom element. The element must not be hidden, and it must be focusable. If the Node
     * has more than one instance, this will fail because the DOM element is not uniquely defined. If accessibility
     * is not enabled, this will be a no op. When ParallelDOM is more widely used, the no op can be replaced
     * with an assertion that checks for pdom content.
     */
    focus(): void;
    /**
     * Remove focus from this Node's primary DOM element.  The focus highlight will disappear, and the element will not receive
     * keyboard events when it doesn't have focus.
     */
    blur(): void;
    /**
     * Called when assertions are enabled and once the Node has been completely constructed. This is the time to
     * make sure that options are set up the way they are expected to be. For example. you don't want accessibleName
     * and labelContent declared.
     * (only called by Screen.js)
     */
    pdomAudit(): void;
    /***********************************************************************************************************/
    /***********************************************************************************************************/
    /**
     * Sets the accessible name that describes this Node. The accessible name is the semantic title for the Node. It is
     * the content that will be read by a screen reader when the Node is discovered by the virtual cursor.
     *
     * For more information about accessible names in web accessibility see
     * https://developer.paciellogroup.com/blog/2017/04/what-is-an-accessible-name/.
     *
     * Part of the higher level API, the accessibleNameBehavior function will set the appropriate options on this Node
     * to create the desired accessible name. See the documentation for setAccessibleNameBehavior() for more information.
     */
    setAccessibleName(accessibleName: PDOMValueType | null): void;
    set accessibleName(accessibleName: PDOMValueType | null);
    get accessibleName(): string | null;
    /**
     * Get the accessible name that describes this Node.
     */
    getAccessibleName(): string | null;
    /**
     * Sets this Node as a paragraph with the provided content. This lets you easily describe Nodes for screen readers. This
     * is most useful for non-interactive elements that need to be described.
     *
     * myImageNode.setAccessibleParagraph( 'This is a picture of a cat' );
     *
     * This is part of the "Higher level API", but there is no customizing behavior function for this function.
     */
    setAccessibleParagraph(accessibleParagraph: PDOMValueType | null): void;
    set accessibleParagraph(accessibleParagraph: PDOMValueType | null);
    get accessibleParagraph(): string | null;
    /**
     * Get the accessible paragraph that represents/describe.
     */
    getAccessibleParagraph(): string | null;
    /**
     * Remove this Node from the PDOM by clearing its pdom content. This can be useful when creating icons from
     * pdom content.
     */
    removeFromPDOM(): void;
    /**
     * accessibleNameBehavior is a function that will set the appropriate options on this Node to get the desired
     * accessible name.
     *
     * The default value does the best it can to create an accessible name for a variety of different ParallelDOM
     * options and tag names. If a Node uses more complicated markup, you can provide your own function to
     * meet your requirements. If you do this, it is up to you to make sure that the Accessible Name is properly
     * being set and conveyed to AT, as it is very hard to validate this function.
     */
    setAccessibleNameBehavior(accessibleNameBehavior: PDOMBehaviorFunction): void;
    set accessibleNameBehavior(accessibleNameBehavior: PDOMBehaviorFunction);
    get accessibleNameBehavior(): PDOMBehaviorFunction;
    /**
     * Get the help text of the interactive element.
     */
    getAccessibleNameBehavior(): PDOMBehaviorFunction;
    /**
     * Set the Node heading content. This by default will be a heading tag whose level is dependent on how many parents
     * Nodes are heading Nodes. See computeHeadingLevel() for more info
     *
     * @experimental - NOTE: use with caution, a11y team reserves the right to change API (though unlikely).
     *                 Not yet fully implemented, see https://github.com/phetsims/scenery/issues/867
     */
    setPDOMHeading(pdomHeading: PDOMValueType | null): void;
    set pdomHeading(pdomHeading: PDOMValueType | null);
    get pdomHeading(): string | null;
    /**
     * Get the value of this Node's heading. Use null to clear the heading
     *
     * @experimental - NOTE: use with caution, a11y team reserves the right to change API (though unlikely).
     *                 Not yet fully implemented, see https://github.com/phetsims/scenery/issues/867
     */
    getPDOMHeading(): string | null;
    /**
     * Set the behavior of how `this.pdomHeading` is set in the PDOM. See default behavior function for more
     * information.
     *
     * @experimental - NOTE: use with caution, a11y team reserves the right to change API (though unlikely).
     *                 Not yet fully implemented, see https://github.com/phetsims/scenery/issues/867
     */
    setPDOMHeadingBehavior(pdomHeadingBehavior: PDOMBehaviorFunction): void;
    set pdomHeadingBehavior(pdomHeadingBehavior: PDOMBehaviorFunction);
    get pdomHeadingBehavior(): PDOMBehaviorFunction;
    /**
     * Get the help text of the interactive element.
     *
     * @experimental - NOTE: use with caution, a11y team reserves the right to change API (though unlikely).
     *                 Not yet fully implemented, see https://github.com/phetsims/scenery/issues/867
     */
    getPDOMHeadingBehavior(): PDOMBehaviorFunction;
    /**
     * Get the tag name of the DOM element representing this Node for accessibility.
     *
     * @experimental - NOTE: use with caution, a11y team reserves the right to change API (though unlikely).
     *                 Not yet fully implemented, see https://github.com/phetsims/scenery/issues/867
     */
    getHeadingLevel(): number | null;
    get headingLevel(): number | null;
    /**
     // TODO: what if ancestor changes, see https://github.com/phetsims/scenery/issues/855
     * Sets this Node's heading level, by recursing up the accessibility tree to find headings this Node
     * is nested under.
     *
     * @experimental - NOTE: use with caution, a11y team reserves the right to change API (though unlikely).
     *                 Not yet fully implemented, see https://github.com/phetsims/scenery/issues/867
     */
    private computeHeadingLevel;
    /**
     * Sets the help text for this Node. Help text usually provides additional information that describes what a Node
     * is or how to interact with it. It will be read by a screen reader when discovered by the virtual cursor.
     *
     * Part of the higher level API, the helpTextBehavior function will set the appropriate options on this Node
     * to create the desired help text. See the documentation for setHelpTextBehavior() for more information.
     */
    setHelpText(helpText: PDOMValueType | null): void;
    set helpText(helpText: PDOMValueType | null);
    get helpText(): string | null;
    /**
     * Get the help text for this Node.
     */
    getHelpText(): string | null;
    /**
     * helpTextBehavior is a function that will set the appropriate options on this Node to get the desired help text.
     *
     * The default value does the best it can to create the help text based on the values for other ParallelDOM options.
     * Usually, this is a paragraph element that comes after the Node's primary sibling in the PDOM. If you need to
     * customize this behavior, you can provide your own function to meet your requirements. If you provide your own
     * function, it is up to you to make sure that the help text is properly being set and is discoverable by AT.
     */
    setHelpTextBehavior(helpTextBehavior: PDOMBehaviorFunction): void;
    set helpTextBehavior(helpTextBehavior: PDOMBehaviorFunction);
    get helpTextBehavior(): PDOMBehaviorFunction;
    /**
     * Get the help text of the interactive element.
     */
    getHelpTextBehavior(): PDOMBehaviorFunction;
    /***********************************************************************************************************/
    /***********************************************************************************************************/
    /**
     * Set the tag name for the primary sibling in the PDOM. DOM element tag names are read-only, so this
     * function will create a new DOM element each time it is called for the Node's PDOMPeer and
     * reset the pdom content.
     *
     * This is the "entry point" for Parallel DOM content. When a Node has a tagName it will appear in the Parallel DOM
     * and other attributes can be set. Without it, nothing will appear in the Parallel DOM.
     */
    setTagName(tagName: string | null): void;
    set tagName(tagName: string | null);
    get tagName(): string | null;
    /**
     * Get the tag name of the DOM element representing this Node for accessibility.
     */
    getTagName(): string | null;
    /**
     * Set the tag name for the accessible label sibling for this Node. DOM element tag names are read-only,
     * so this will require creating a new PDOMPeer for this Node (reconstructing all DOM Elements). If
     * labelContent is specified without calling this method, then the DEFAULT_LABEL_TAG_NAME will be used as the
     * tag name for the label sibling. Use null to clear the label sibling element from the PDOM.
     */
    setLabelTagName(tagName: string | null): void;
    set labelTagName(tagName: string | null);
    get labelTagName(): string | null;
    /**
     * Get the label sibling HTML tag name.
     */
    getLabelTagName(): string | null;
    /**
     * Set the tag name for the description sibling. HTML element tag names are read-only, so this will require creating
     * a new HTML element, and inserting it into the DOM. The tag name provided must support
     * innerHTML and textContent. If descriptionContent is specified without this option,
     * then descriptionTagName will be set to DEFAULT_DESCRIPTION_TAG_NAME.
     *
     * Passing 'null' will clear away the description sibling.
     */
    setDescriptionTagName(tagName: string | null): void;
    set descriptionTagName(tagName: string | null);
    get descriptionTagName(): string | null;
    /**
     * Get the HTML tag name for the description sibling.
     */
    getDescriptionTagName(): string | null;
    /**
     * Sets the type for an input element.  Element must have the INPUT tag name. The input attribute is not
     * specified as readonly, so invalidating pdom content is not necessary.
     */
    setInputType(inputType: string | null): void;
    set inputType(inputType: string | null);
    get inputType(): string | null;
    /**
     * Get the input type. Input type is only relevant if this Node's primary sibling has tag name "INPUT".
     */
    getInputType(): string | null;
    /**
     * By default the label will be prepended before the primary sibling in the PDOM. This
     * option allows you to instead have the label added after the primary sibling. Note: The label will always
     * be in front of the description sibling. If this flag is set with `appendDescription`, the order will be
     *
     * <container>
     *   <primary sibling/>
     *   <label sibling/>
     *   <description sibling/>
     * </container>
     */
    setAppendLabel(appendLabel: boolean): void;
    set appendLabel(appendLabel: boolean);
    get appendLabel(): boolean;
    /**
     * Get whether the label sibling should be appended after the primary sibling.
     */
    getAppendLabel(): boolean;
    /**
     * By default the label will be prepended before the primary sibling in the PDOM. This
     * option allows you to instead have the label added after the primary sibling. Note: The label will always
     * be in front of the description sibling. If this flag is set with `appendLabel`, the order will be
     *
     * <container>
     *   <primary sibling/>
     *   <label sibling/>
     *   <description sibling/>
     * </container>
     */
    setAppendDescription(appendDescription: boolean): void;
    set appendDescription(appendDescription: boolean);
    get appendDescription(): boolean;
    /**
     * Get whether the description sibling should be appended after the primary sibling.
     */
    getAppendDescription(): boolean;
    /**
     * Set the container parent tag name. By specifying this container parent, an element will be created that
     * acts as a container for this Node's primary sibling DOM Element and its label and description siblings.
     * This containerTagName will default to DEFAULT_LABEL_TAG_NAME, and be added to the PDOM automatically if
     * more than just the primary sibling is created.
     *
     * For instance, a button element with a label and description will be contained like the following
     * if the containerTagName is specified as 'section'.
     *
     * <section id='parent-container-trail-id'>
     *   <button>Press me!</button>
     *   <p>Button label</p>
     *   <p>Button description</p>
     * </section>
     */
    setContainerTagName(tagName: string | null): void;
    set containerTagName(tagName: string | null);
    get containerTagName(): string | null;
    /**
     * Get the tag name for the container parent element.
     */
    getContainerTagName(): string | null;
    private invalidatePeerLabelSiblingContent;
    /**
     * Set the content of the label sibling for the this Node.  The label sibling will default to the value of
     * DEFAULT_LABEL_TAG_NAME if no `labelTagName` is provided. If the label sibling is a `LABEL` html element,
     * then the `for` attribute will automatically be added, pointing to the Node's primary sibling.
     *
     * This method supports adding content in two ways, with HTMLElement.textContent and HTMLElement.innerHTML.
     * The DOM setter is chosen based on if the label passes the `containsFormattingTags`.
     *
     * Passing a null label value will not clear the whole label sibling, just the inner content of the DOM Element.
     */
    setLabelContent(labelContent: PDOMValueType | null): void;
    set labelContent(label: PDOMValueType | null);
    get labelContent(): string | null;
    /**
     * Get the content for this Node's label sibling DOM element.
     */
    getLabelContent(): string | null;
    private onInnerContentPropertyChange;
    /**
     * Set the inner content for the primary sibling of the PDOMPeers of this Node. Will be set as textContent
     * unless content is html which uses exclusively formatting tags. A Node with inner content cannot
     * have accessible descendants because this content will override the HTML of descendants of this Node.
     */
    setInnerContent(innerContent: PDOMValueType | null): void;
    set innerContent(content: PDOMValueType | null);
    get innerContent(): string | null;
    /**
     * Get the inner content, the string that is the innerHTML or innerText for the Node's primary sibling.
     */
    getInnerContent(): string | null;
    private invalidatePeerDescriptionSiblingContent;
    /**
     * Set the description content for this Node's primary sibling. The description sibling tag name must support
     * innerHTML and textContent. If a description element does not exist yet, a default
     * DEFAULT_LABEL_TAG_NAME will be assigned to the descriptionTagName.
     */
    setDescriptionContent(descriptionContent: PDOMValueType | null): void;
    set descriptionContent(textContent: PDOMValueType | null);
    get descriptionContent(): string | null;
    /**
     * Get the content for this Node's description sibling DOM Element.
     */
    getDescriptionContent(): string | null;
    /**
     * Set the ARIA role for this Node's primary sibling. According to the W3C, the ARIA role is read-only for a DOM
     * element.  So this will create a new DOM element for this Node with the desired role, and replace the old
     * element in the DOM. Note that the aria role can completely change the events that fire from an element,
     * especially when using a screen reader. For example, a role of `application` will largely bypass the default
     * behavior and logic of the screen reader, triggering keydown/keyup events even for buttons that would usually
     * only receive a "click" event.
     *
     * @param ariaRole - role for the element, see
     *                            https://www.w3.org/TR/html-aria/#allowed-aria-roles-states-and-properties
     *                            for a list of roles, states, and properties.
     */
    setAriaRole(ariaRole: string | null): void;
    set ariaRole(ariaRole: string | null);
    get ariaRole(): string | null;
    /**
     * Get the ARIA role representing this Node.
     */
    getAriaRole(): string | null;
    /**
     * Set the ARIA role for this Node's container parent element.  According to the W3C, the ARIA role is read-only
     * for a DOM element. This will create a new DOM element for the container parent with the desired role, and
     * replace it in the DOM.
     *
     * @param ariaRole - role for the element, see
     *                            https://www.w3.org/TR/html-aria/#allowed-aria-roles-states-and-properties
     *                            for a list of roles, states, and properties.
     */
    setContainerAriaRole(ariaRole: string | null): void;
    set containerAriaRole(ariaRole: string | null);
    get containerAriaRole(): string | null;
    /**
     * Get the ARIA role assigned to the container parent element.
     */
    getContainerAriaRole(): string | null;
    private onAriaValueTextChange;
    /**
     * Set the aria-valuetext of this Node independently from the changing value, if necessary. Setting to null will
     * clear this attribute.
     */
    setAriaValueText(ariaValueText: PDOMValueType | null): void;
    set ariaValueText(ariaValueText: PDOMValueType | null);
    get ariaValueText(): string | null;
    /**
     * Get the value of the aria-valuetext attribute for this Node's primary sibling. If null, then the attribute
     * has not been set on the primary sibling.
     */
    getAriaValueText(): string | null;
    /**
     * Sets the namespace for the primary element (relevant for MathML/SVG/etc.)
     *
     * For example, to create a MathML element:
     * { tagName: 'math', pdomNamespace: 'http://www.w3.org/1998/Math/MathML' }
     *
     * or for SVG:
     * { tagName: 'svg', pdomNamespace: 'http://www.w3.org/2000/svg' }
     *
     * @param pdomNamespace - Null indicates no namespace.
     */
    setPDOMNamespace(pdomNamespace: string | null): this;
    set pdomNamespace(value: string | null);
    get pdomNamespace(): string | null;
    /**
     * Returns the accessible namespace (see setPDOMNamespace for more information).
     */
    getPDOMNamespace(): string | null;
    private onAriaLabelChange;
    /**
     * Sets the 'aria-label' attribute for labelling the Node's primary sibling. By using the
     * 'aria-label' attribute, the label will be read on focus, but can not be found with the
     * virtual cursor. This is one way to set a DOM Element's Accessible Name.
     *
     * @param ariaLabel - the text for the aria label attribute
     */
    setAriaLabel(ariaLabel: PDOMValueType | null): void;
    set ariaLabel(ariaLabel: PDOMValueType | null);
    get ariaLabel(): string | null;
    /**
     * Get the value of the aria-label attribute for this Node's primary sibling.
     */
    getAriaLabel(): string | null;
    /**
     * Set the focus highlight for this Node. By default, the focus highlight will be a pink rectangle that
     * surrounds the Node's local bounds.  If focus highlight is set to 'invisible', the Node will not have
     * any highlighting when it receives focus.
     *
     * Use the local coordinate frame when drawing a custom highlight for this Node.
     */
    setFocusHighlight(focusHighlight: Highlight): void;
    set focusHighlight(focusHighlight: Highlight);
    get focusHighlight(): Highlight;
    /**
     * Get the focus highlight for this Node.
     */
    getFocusHighlight(): Highlight;
    /**
     * Setting a flag to break default and allow the focus highlight to be (z) layered into the scene graph.
     * This will set the visibility of the layered focus highlight, it will always be invisible until this Node has
     * focus.
     */
    setFocusHighlightLayerable(focusHighlightLayerable: boolean): void;
    set focusHighlightLayerable(focusHighlightLayerable: boolean);
    get focusHighlightLayerable(): boolean;
    /**
     * Get the flag for if this Node is layerable in the scene graph (or if it is always on top, like the default).
     */
    getFocusHighlightLayerable(): boolean;
    /**
     * Set whether or not this Node has a group focus highlight. If this Node has a group focus highlight, an extra
     * focus highlight will surround this Node whenever a descendant Node has focus. Generally
     * useful to indicate nested keyboard navigation. If true, the group focus highlight will surround
     * this Node's local bounds. Otherwise, the Node will be used.
     *
     * TODO: Support more than one group focus highlight (multiple ancestors could have groupFocusHighlight), see https://github.com/phetsims/scenery/issues/1608
     */
    setGroupFocusHighlight(groupHighlight: Node | boolean): void;
    set groupFocusHighlight(groupHighlight: Node | boolean);
    get groupFocusHighlight(): Node | boolean;
    /**
     * Get whether or not this Node has a 'group' focus highlight, see setter for more information.
     */
    getGroupFocusHighlight(): Node | boolean;
    /**
     * Very similar algorithm to setChildren in Node.js
     * @param ariaLabelledbyAssociations - list of associationObjects, see this._ariaLabelledbyAssociations.
     */
    setAriaLabelledbyAssociations(ariaLabelledbyAssociations: Association[]): void;
    set ariaLabelledbyAssociations(ariaLabelledbyAssociations: Association[]);
    get ariaLabelledbyAssociations(): Association[];
    getAriaLabelledbyAssociations(): Association[];
    /**
     * Add an aria-labelledby association to this Node. The data in the associationObject will be implemented like
     * "a peer's HTMLElement of this Node (specified with the string constant stored in `thisElementName`) will have an
     * aria-labelledby attribute with a value that includes the `otherNode`'s peer HTMLElement's id (specified with
     * `otherElementName`)."
     *
     * There can be more than one association because an aria-labelledby attribute's value can be a space separated
     * list of HTML ids, and not just a single id, see https://www.w3.org/WAI/GL/wiki/Using_aria-labelledby_to_concatenate_a_label_from_several_text_nodes
     */
    addAriaLabelledbyAssociation(associationObject: Association): void;
    /**
     * Remove an aria-labelledby association object, see addAriaLabelledbyAssociation for more details
     */
    removeAriaLabelledbyAssociation(associationObject: Association): void;
    /**
     * Remove the reference to the Node that is using this Node's ID as an aria-labelledby value (scenery-internal)
     */
    removeNodeThatIsAriaLabelledByThisNode(node: Node): void;
    /**
     * Trigger the view update for each PDOMPeer
     */
    updateAriaLabelledbyAssociationsInPeers(): void;
    /**
     * Update the associations for aria-labelledby (scenery-internal)
     */
    updateOtherNodesAriaLabelledby(): void;
    /**
     * The list of Nodes that are aria-labelledby this Node (other Node's peer element will have this Node's Peer element's
     * id in the aria-labelledby attribute
     */
    getNodesThatAreAriaLabelledbyThisNode(): Node[];
    get nodesThatAreAriaLabelledbyThisNode(): Node[];
    setAriaDescribedbyAssociations(ariaDescribedbyAssociations: Association[]): void;
    set ariaDescribedbyAssociations(ariaDescribedbyAssociations: Association[]);
    get ariaDescribedbyAssociations(): Association[];
    getAriaDescribedbyAssociations(): Association[];
    /**
     * Add an aria-describedby association to this Node. The data in the associationObject will be implemented like
     * "a peer's HTMLElement of this Node (specified with the string constant stored in `thisElementName`) will have an
     * aria-describedby attribute with a value that includes the `otherNode`'s peer HTMLElement's id (specified with
     * `otherElementName`)."
     *
     * There can be more than one association because an aria-describedby attribute's value can be a space separated
     * list of HTML ids, and not just a single id, see https://www.w3.org/WAI/GL/wiki/Using_aria-labelledby_to_concatenate_a_label_from_several_text_nodes
     */
    addAriaDescribedbyAssociation(associationObject: Association): void;
    /**
     * Is this object already in the describedby association list
     */
    hasAriaDescribedbyAssociation(associationObject: Association): boolean;
    /**
     * Remove an aria-describedby association object, see addAriaDescribedbyAssociation for more details
     */
    removeAriaDescribedbyAssociation(associationObject: Association): void;
    /**
     * Remove the reference to the Node that is using this Node's ID as an aria-describedby value (scenery-internal)
     */
    removeNodeThatIsAriaDescribedByThisNode(node: Node): void;
    /**
     * Trigger the view update for each PDOMPeer
     */
    updateAriaDescribedbyAssociationsInPeers(): void;
    /**
     * Update the associations for aria-describedby (scenery-internal)
     */
    updateOtherNodesAriaDescribedby(): void;
    /**
     * The list of Nodes that are aria-describedby this Node (other Node's peer element will have this Node's Peer element's
     * id in the aria-describedby attribute
     */
    getNodesThatAreAriaDescribedbyThisNode(): Node[];
    get nodesThatAreAriaDescribedbyThisNode(): Node[];
    setActiveDescendantAssociations(activeDescendantAssociations: Association[]): void;
    set activeDescendantAssociations(activeDescendantAssociations: Association[]);
    get activeDescendantAssociations(): Association[];
    getActiveDescendantAssociations(): Association[];
    /**
     * Add an aria-activeDescendant association to this Node. The data in the associationObject will be implemented like
     * "a peer's HTMLElement of this Node (specified with the string constant stored in `thisElementName`) will have an
     * aria-activeDescendant attribute with a value that includes the `otherNode`'s peer HTMLElement's id (specified with
     * `otherElementName`)."
     */
    addActiveDescendantAssociation(associationObject: Association): void;
    /**
     * Remove an aria-activeDescendant association object, see addActiveDescendantAssociation for more details
     */
    removeActiveDescendantAssociation(associationObject: Association): void;
    /**
     * Remove the reference to the Node that is using this Node's ID as an aria-activeDescendant value (scenery-internal)
     */
    private removeNodeThatIsActiveDescendantThisNode;
    /**
     * Trigger the view update for each PDOMPeer
     */
    private updateActiveDescendantAssociationsInPeers;
    /**
     * Update the associations for aria-activeDescendant (scenery-internal)
     */
    updateOtherNodesActiveDescendant(): void;
    /**
     * The list of Nodes that are aria-activeDescendant this Node (other Node's peer element will have this Node's Peer element's
     * id in the aria-activeDescendant attribute
     */
    private getNodesThatAreActiveDescendantToThisNode;
    private get nodesThatAreActiveDescendantToThisNode();
    /**
     * Sets the PDOM/DOM order for this Node. This includes not only focused items, but elements that can be
     * placed in the Parallel DOM. If provided, it will override the focus order between children (and
     * optionally arbitrary subtrees). If not provided, the focus order will default to the rendering order
     * (first children first, last children last), determined by the children array. A Node must be connected to a scene
     * graph (via children) in order for pdomOrder to apply. Thus, `setPDOMOrder` cannot be used in exchange for
     * setting a Node as a child.
     *
     * In the general case, when pdomOrder is specified, it's an array of Nodes, with optionally one
     * element being a placeholder for "the rest of the children", signified by null. This means that, for
     * accessibility, it will act as if the children for this Node WERE the pdomOrder (potentially
     * supplemented with other children via the placeholder).
     *
     * For example, if you have the tree:
     *   a
     *     b
     *       d
     *       e
     *     c
     *       g
     *       f
     *         h
     *
     * and we specify b.pdomOrder = [ e, f, d, c ], then the pdom structure will act as if the tree is:
     *  a
     *    b
     *      e
     *      f <--- the entire subtree of `f` gets placed here under `b`, pulling it out from where it was before.
     *        h
     *      d
     *      c <--- note that `g` is NOT under `c` anymore, because it got pulled out under b directly
     *        g
     *
     * The placeholder (`null`) will get filled in with all direct children that are NOT in any pdomOrder.
     * If there is no placeholder specified, it will act as if the placeholder is at the end of the order.
     * The value `null` (the default) and the empty array (`[]`) both act as if the only order is the placeholder,
     * i.e. `[null]`.
     *
     * Some general constraints for the orders are:
     * - Nodes must be attached to a Display (in a scene graph) to be shown in a pdom order.
     * - You can't specify a Node in more than one pdomOrder, and you can't specify duplicates of a value
     *   in a pdomOrder.
     * - You can't specify an ancestor of a Node in that Node's pdomOrder
     *   (e.g. this.pdomOrder = this.parents ).
     *
     * Note that specifying something in a pdomOrder will effectively remove it from all of its parents for
     * the pdom tree (so if you create `tmpNode.pdomOrder = [ a ]` then toss the tmpNode without
     * disposing it, `a` won't show up in the parallel DOM). If there is a need for that, disposing a Node
     * effectively removes its pdomOrder.
     *
     * See https://github.com/phetsims/scenery-phet/issues/365#issuecomment-381302583 for more information on the
     * decisions and design for this feature.
     */
    setPDOMOrder(pdomOrder: (Node | null)[] | null): void;
    set pdomOrder(value: (Node | null)[] | null);
    get pdomOrder(): (Node | null)[] | null;
    /**
     * Returns the pdom (focus) order for this Node.
     *
     * Making changes to the returned array will not affect this Node's order. It returns a defensive copy.
     */
    getPDOMOrder(): (Node | null)[] | null;
    /**
     * Returns whether this Node has a pdomOrder that is effectively different than the default.
     *
     * NOTE: `null`, `[]` and `[null]` are all effectively the same thing, so this will return true for any of
     * those. Usage of `null` is recommended, as it doesn't create the extra object reference (but some code
     * that generates arrays may be more convenient).
     */
    hasPDOMOrder(): boolean;
    /**
     * Returns our "PDOM parent" if available: the Node that specifies this Node in its pdomOrder.
     */
    getPDOMParent(): Node | null;
    get pdomParent(): Node | null;
    /**
     * Returns the "effective" pdom children for the Node (which may be different based on the order or other
     * excluded subtrees).
     *
     * If there is no pdomOrder specified, this is basically "all children that don't have pdom parents"
     * (a Node has a "PDOM parent" if it is specified in a pdomOrder).
     *
     * Otherwise (if it has a pdomOrder), it is the pdomOrder, with the above list of Nodes placed
     * in at the location of the placeholder. If there is no placeholder, it acts like a placeholder was the last
     * element of the pdomOrder (see setPDOMOrder for more documentation information).
     *
     * NOTE: If you specify a child in the pdomOrder, it will NOT be double-included (since it will have an
     * PDOM parent).
     *
     * (scenery-internal)
     */
    getEffectiveChildren(): Node[];
    /**
     * Called when our pdomVisible Property changes values.
     */
    private onPdomVisiblePropertyChange;
    /**
     * Sets what Property our pdomVisibleProperty is backed by, so that changes to this provided Property will change this
     * Node's pdom visibility, and vice versa. This does not change this._pdomVisibleProperty. See TinyForwardingProperty.setTargetProperty()
     * for more info.
     */
    setPdomVisibleProperty(newTarget: TReadOnlyProperty<boolean> | null): this;
    /**
     * See setPdomVisibleProperty() for more information
     */
    set pdomVisibleProperty(property: TReadOnlyProperty<boolean> | null);
    /**
     * See getPdomVisibleProperty() for more information
     */
    get pdomVisibleProperty(): TProperty<boolean>;
    /**
     * Get this Node's pdomVisibleProperty. See Node.getVisibleProperty for more information
     */
    getPdomVisibleProperty(): TProperty<boolean>;
    /**
     * Hide completely from a screen reader and the browser by setting the hidden attribute on the Node's
     * representative DOM element. If the sibling DOM Elements have a container parent, the container
     * should be hidden so that all PDOM elements are hidden as well.  Hiding the element will remove it from the focus
     * order.
     */
    setPDOMVisible(visible: boolean): void;
    set pdomVisible(visible: boolean);
    get pdomVisible(): boolean;
    /**
     * Get whether or not this Node's representative DOM element is visible.
     */
    isPDOMVisible(): boolean;
    /**
     * Returns true if any of the PDOMInstances for the Node are globally visible and displayed in the PDOM. A
     * PDOMInstance is globally visible if Node and all ancestors are pdomVisible. PDOMInstance visibility is
     * updated synchronously, so this returns the most up-to-date information without requiring Display.updateDisplay
     */
    isPDOMDisplayed(): boolean;
    get pdomDisplayed(): boolean;
    private invalidatePeerInputValue;
    /**
     * Set the value of an input element.  Element must be a form element to support the value attribute. The input
     * value is converted to string since input values are generally string for HTML.
     */
    setInputValue(inputValue: PDOMValueType | number | null): void;
    set inputValue(value: PDOMValueType | number | null);
    get inputValue(): string | number | null;
    /**
     * Get the value of the element. Element must be a form element to support the value attribute.
     */
    getInputValue(): string | null;
    /**
     * Set whether or not the checked attribute appears on the dom elements associated with this Node's
     * pdom content.  This is only useful for inputs of type 'radio' and 'checkbox'. A 'checked' input
     * is considered selected to the browser and assistive technology.
     */
    setPDOMChecked(checked: boolean): void;
    set pdomChecked(checked: boolean);
    get pdomChecked(): boolean;
    /**
     * Get whether or not the pdom input is 'checked'.
     */
    getPDOMChecked(): boolean;
    /**
     * Get an array containing all pdom attributes that have been added to this Node's primary sibling.
     */
    getPDOMAttributes(): PDOMAttribute[];
    get pdomAttributes(): PDOMAttribute[];
    /**
     * Set a particular attribute or property for this Node's primary sibling, generally to provide extra semantic information for
     * a screen reader.
     *
     * @param attribute - string naming the attribute
     * @param value - the value for the attribute, if boolean, then it will be set as a javascript property on the HTMLElement rather than an attribute
     * @param [providedOptions]
     */
    setPDOMAttribute(attribute: string, value: PDOMValueType | boolean | number, providedOptions?: SetPDOMAttributeOptions): void;
    /**
     * Remove a particular attribute, removing the associated semantic information from the DOM element.
     *
     * It is HIGHLY recommended that you never call this function from an attribute set with `type:'property'`, see
     * setPDOMAttribute for the option details.
     *
     * @param attribute - name of the attribute to remove
     * @param [providedOptions]
     */
    removePDOMAttribute(attribute: string, providedOptions?: RemovePDOMAttributeOptions): void;
    /**
     * Remove all attributes from this Node's dom element.
     */
    removePDOMAttributes(): void;
    /**
     * Remove a particular attribute, removing the associated semantic information from the DOM element.
     *
     * @param attribute - name of the attribute to remove
     * @param [providedOptions]
     */
    hasPDOMAttribute(attribute: string, providedOptions?: HasPDOMAttributeOptions): boolean;
    /**
     * Add the class to the PDOM element's classList. The PDOM is generally invisible,
     * but some styling occasionally has an impact on semantics so it is necessary to set styles.
     * Add a class with this function and define the style in stylesheets (likely SceneryStyle).
     */
    setPDOMClass(className: string, providedOptions?: SetPDOMClassOptions): void;
    /**
     * Remove a class from the classList of one of the elements for this Node.
     */
    removePDOMClass(className: string, providedOptions?: RemovePDOMClassOptions): void;
    /**
     * Get the list of classes assigned to PDOM elements for this Node.
     */
    getPDOMClasses(): PDOMClass[];
    get pdomClasses(): PDOMClass[];
    /**
     * Make the DOM element explicitly focusable with a tab index. Native HTML form elements will generally be in
     * the navigation order without explicitly setting focusable.  If these need to be removed from the navigation
     * order, call setFocusable( false ).  Removing an element from the focus order does not hide the element from
     * assistive technology.
     *
     * @param focusable - null to use the default browser focus for the primary element
     */
    setFocusable(focusable: boolean | null): void;
    set focusable(isFocusable: boolean | null);
    get focusable(): boolean;
    /**
     * Get whether or not the Node is focusable. Use the focusOverride, and then default to browser defined
     * focusable elements.
     */
    isFocusable(): boolean;
    /**
     * Sets the source Node that controls positioning of the primary sibling. Transforms along the trail to this
     * Node are observed so that the primary sibling is positioned correctly in the global coordinate frame.
     *
     * The transformSourceNode cannot use DAG for now because we need a unique trail to observe transforms.
     *
     * By default, transforms along trails to all of this Node's PDOMInstances are observed. But this
     * function can be used if you have a visual Node represented in the PDOM by a different Node in the scene
     * graph but still need the other Node's PDOM content positioned over the visual Node. For example, this could
     * be required to catch all fake pointer events that may come from certain types of screen readers.
     */
    setPDOMTransformSourceNode(node: Node | null): void;
    set pdomTransformSourceNode(node: Node | null);
    get pdomTransformSourceNode(): Node | null;
    /**
     * Get the source Node that controls positioning of the primary sibling in the global coordinate frame. See
     * setPDOMTransformSourceNode for more in depth information.
     */
    getPDOMTransformSourceNode(): Node | null;
    /**
     * Used by the animatedPanZoomSingleton. It will try to keep these bounds visible in the viewport when this Node
     * (or any ancestor) has a transform change while focused. This is useful if the bounds of your focusable
     * Node do not accurately surround the conceptual interactive component. If null, this Node's local bounds
     * are used.
     *
     * At this time, the Property cannot be changed after it is set.
     */
    setFocusPanTargetBoundsProperty(boundsProperty: null | TReadOnlyProperty<Bounds2>): void;
    /**
     * Returns the function for creating global bounds to keep in the viewport while the component has focus, see the
     * setFocusPanTargetBoundsProperty function for more information.
     */
    getFocusPanTargetBoundsProperty(): null | TReadOnlyProperty<Bounds2>;
    /**
     * See setFocusPanTargetBoundsProperty for more information.
     */
    set focusPanTargetBoundsProperty(boundsProperty: null | TReadOnlyProperty<Bounds2>);
    /**
     * See getFocusPanTargetBoundsProperty for more information.
     */
    get focusPanTargetBoundsProperty(): null | TReadOnlyProperty<Bounds2>;
    /**
     * Sets the direction that the global AnimatedPanZoomListener will pan while interacting with this Node. Pan will ONLY
     * occur in this dimension. This is especially useful for panning to large Nodes where panning to the center of the
     * Node would move other Nodes out of the viewport.
     *
     * Set to null for default behavior (panning in all directions).
     */
    setLimitPanDirection(limitPanDirection: LimitPanDirection | null): void;
    /**
     * See setLimitPanDirection for more information.
     */
    getLimitPanDirection(): LimitPanDirection | null;
    /**
     * See setLimitPanDirection for more information.
     * @param limitPanDirection
     */
    set limitPanDirection(limitPanDirection: LimitPanDirection);
    /**
     * See getLimitPanDirection for more information.
     */
    get limitPanDirection(): LimitPanDirection | null;
    /**
     * Sets whether the PDOM sibling elements are positioned in the correct place in the viewport. Doing so is a
     * requirement for custom gestures on touch based screen readers. However, doing this DOM layout is expensive so
     * only do this when necessary. Generally only needed for elements that utilize a "double tap and hold" gesture
     * to drag and drop.
     *
     * Positioning the PDOM element will caused some screen readers to send both click and pointer events to the
     * location of the Node in global coordinates. Do not position elements that use click listeners since activation
     * will fire twice (once for the pointer event listeners and once for the click event listeners).
     */
    setPositionInPDOM(positionInPDOM: boolean): void;
    set positionInPDOM(positionInPDOM: boolean);
    get positionInPDOM(): boolean;
    /**
     * Gets whether or not we are positioning the PDOM sibling elements. See setPositionInPDOM().
     */
    getPositionInPDOM(): boolean;
    /**
     * This function should be used sparingly as a workaround. If used, any DOM input events received from the label
     * sibling will not be dispatched as SceneryEvents in Input.js. The label sibling may receive input by screen
     * readers if the virtual cursor is over it. That is usually fine, but there is a bug with NVDA and Firefox where
     * both the label sibling AND primary sibling receive events in this case, and both bubble up to the root of the
     * PDOM, and so we would otherwise dispatch two SceneryEvents instead of one.
     *
     * See https://github.com/phetsims/a11y-research/issues/156 for more information.
     */
    setExcludeLabelSiblingFromInput(): void;
    /**
     * Return true if this Node is a PhET-iO archetype or it is a Node descendant of a PhET-iO archetype.
     * See https://github.com/phetsims/joist/issues/817
     */
    isInsidePhetioArchetype(node?: Node): boolean;
    /**
     * Alert on all interactive description utteranceQueues located on each connected Display. See
     * Node.getConnectedDisplays. Note that if your Node is not connected to a Display, this function will have
     * no effect.
     */
    alertDescriptionUtterance(utterance: TAlertable): void;
    /**
     * Apply a callback on each utteranceQueue that this Node has a connection to (via Display). Note that only
     * accessible Displays have utteranceQueues that this function will interface with.
     */
    forEachUtteranceQueue(callback: (queue: UtteranceQueue) => void): void;
    /***********************************************************************************************************/
    /***********************************************************************************************************/
    /**
     * Used to get a list of all settable options and their current values. (scenery-internal)
     *
     * @returns - keys are all accessibility option keys, and the values are the values of those properties
     * on this Node.
     */
    getBaseOptions(): ParallelDOMOptions;
    /**
     * Returns a recursive data structure that represents the nested ordering of pdom content for this Node's
     * subtree. Each "Item" will have the type { trail: {Trail}, children: {Array.<Item>} }, forming a tree-like
     * structure. (scenery-internal)
     */
    getNestedPDOMOrder(): {
        trail: Trail;
        children: Node[];
    }[];
    /**
     * Sets the pdom content for a Node. See constructor for more information. Not part of the ParallelDOM
     * API (scenery-internal)
     */
    private onPDOMContentChange;
    /**
     * Returns whether or not this Node has any representation for the Parallel DOM.
     * Note this is still true if the content is pdomVisible=false or is otherwise hidden.
     */
    get hasPDOMContent(): boolean;
    /**
     * Called when the Node is added as a child to this Node AND the Node's subtree contains pdom content.
     * We need to notify all Displays that can see this change, so that they can update the PDOMInstance tree.
     */
    protected onPDOMAddChild(node: Node): void;
    /**
     * Called when the Node is removed as a child from this Node AND the Node's subtree contains pdom content.
     * We need to notify all Displays that can see this change, so that they can update the PDOMInstance tree.
     */
    protected onPDOMRemoveChild(node: Node): void;
    /**
     * Called when this Node's children are reordered (with nothing added/removed).
     */
    protected onPDOMReorderedChildren(): void;
    /**
     * Handles linking and checking child PhET-iO Properties such as Node.visibleProperty and Node.enabledProperty.
     */
    updateLinkedElementForProperty<T>(tandemName: string, oldProperty?: TReadOnlyProperty<T> | null, newProperty?: TReadOnlyProperty<T> | null): void;
    /**
     * Returns a reference to the pdom instances array. (scenery-internal)
     */
    getPDOMInstances(): PDOMInstance[];
    get pdomInstances(): PDOMInstance[];
    /**
     * Adds a PDOMInstance reference to our array. (scenery-internal)
     */
    addPDOMInstance(pdomInstance: PDOMInstance): void;
    /**
     * Removes a PDOMInstance reference from our array. (scenery-internal)
     */
    removePDOMInstance(pdomInstance: PDOMInstance): void;
    static BASIC_ACCESSIBLE_NAME_BEHAVIOR(node: Node, options: ParallelDOMOptions, accessibleName: PDOMValueType): ParallelDOMOptions;
    /**
     * A behavior function for accessible name so that when accessibleName is set on the provided Node, it will be forwarded
     * to otherNode. This is useful when a component is composed of other Nodes that implement the accessibility,
     * but the high level API should be available for the entire component.
     */
    static forwardAccessibleName(node: ParallelDOM, otherNode: ParallelDOM): void;
    /**
     * A behavior function for help text so that when helpText is set on the provided 'node', it will be forwarded `otherNode`.
     * This is useful when a component is composed of other Nodes that implement the accessibility, but the high level API
     * should be available for the entire component.
     */
    static forwardHelpText(node: ParallelDOM, otherNode: ParallelDOM): void;
    static HELP_TEXT_BEFORE_CONTENT(node: Node, options: ParallelDOMOptions, helpText: PDOMValueType): ParallelDOMOptions;
    static HELP_TEXT_AFTER_CONTENT(node: Node, options: ParallelDOMOptions, helpText: PDOMValueType): ParallelDOMOptions;
    /**
     * If the Node does not have a tagName yet, set it to the default.
     */
    private static useDefaultTagName;
}
export { ACCESSIBILITY_OPTION_KEYS };
//# sourceMappingURL=ParallelDOM.d.ts.map