export default PDOMPeer;
declare class PDOMPeer {
    /**
     * @param {PDOMInstance} pdomInstance
     * @param {Object} [options]
     * @mixes Poolable
     */
    constructor(pdomInstance: PDOMInstance, options?: Object | undefined);
    /**
     * Initializes the object (either from a freshly-created state, or from a "disposed" state brought back from a
     * pool).
     *
     * NOTE: the PDOMPeer is not fully constructed until calling PDOMPeer.update() after creating from pool.
     * @private
     *
     * @param {PDOMInstance} pdomInstance
     * @param {Object} [options]
     * @returns {PDOMPeer} - Returns 'this' reference, for chaining
     */
    private initializePDOMPeer;
    id: any;
    pdomInstance: PDOMInstance | null | undefined;
    node: import("../../imports.js").Node | null | undefined;
    display: import("../../imports.js").Display | null | undefined;
    trail: import("../../imports.js").Trail | null | undefined;
    visible: any;
    focusable: any;
    _labelSibling: HTMLElement | null | undefined;
    _descriptionSibling: HTMLElement | null | undefined;
    _containerParent: HTMLElement | null | undefined;
    topLevelElements: any[] | any[] | HTMLElement[] | undefined;
    positionDirty: boolean | undefined;
    forceReflowWorkaround: boolean | undefined;
    childPositionDirty: boolean | undefined;
    positionInPDOM: boolean | undefined;
    mutationObserver: any;
    transformListener: any;
    _preservedDisabledValue: any;
    isDisposed: boolean | undefined;
    _primarySibling: any;
    /**
     * Update the content of the peer. This must be called after the AccessibePeer is constructed from pool.
     * @param {boolean} updateIndicesStringAndElementIds - if this function should be called upon initial "construction" (in update), allows for the option to do this lazily, see https://github.com/phetsims/phet-io/issues/1847
     * @public (scenery-internal)
     */
    public update(updateIndicesStringAndElementIds: boolean): void;
    /**
     * Handle the internal ordering of the elements in the peer, this involves setting the proper value of
     * this.topLevelElements
     * @param {Object} config - the computed mixin options to be applied to the peer. (select ParallelDOM mutator keys)
     * @private
     */
    private orderElements;
    /**
     * Get the primary sibling element for the peer
     * @public
     * @returns {HTMLElement|null}
     */
    public getPrimarySibling(): HTMLElement | null;
    get primarySibling(): HTMLElement | null;
    /**
     * Get the primary sibling element for the peer
     * @public
     * @returns {HTMLElement|null}
     */
    public getLabelSibling(): HTMLElement | null;
    get labelSibling(): HTMLElement | null;
    /**
     * Get the primary sibling element for the peer
     * @public
     * @returns {HTMLElement|null}
     */
    public getDescriptionSibling(): HTMLElement | null;
    get descriptionSibling(): HTMLElement | null;
    /**
     * Get the primary sibling element for the peer
     * @public
     * @returns {HTMLElement|null}
     */
    public getContainerParent(): HTMLElement | null;
    get containerParent(): HTMLElement | null;
    /**
     * Returns the top-level element that contains the primary sibling. If there is no container parent, then the primary
     * sibling is returned.
     * @public
     *
     * @returns {HTMLElement|null}
     */
    public getTopLevelElementContainingPrimarySibling(): HTMLElement | null;
    /**
     * Recompute the aria-labelledby attributes for all of the peer's elements
     * @public
     */
    public onAriaLabelledbyAssociationChange(): void;
    /**
     * Recompute the aria-describedby attributes for all of the peer's elements
     * @public
     */
    public onAriaDescribedbyAssociationChange(): void;
    /**
     * Recompute the aria-activedescendant attributes for all of the peer's elements
     * @public
     */
    public onActiveDescendantAssociationChange(): void;
    /**
     * Set the new attribute to the element if the value is a string. It will otherwise be null or undefined and should
     * then be removed from the element. This allows empty strings to be set as values.
     *
     * @param {string} key
     * @param {string|null|undefined} value
     * @private
     */
    private handleAttributeWithPDOMOption;
    /**
     * Set all pdom attributes onto the peer elements from the model's stored data objects
     * @private
     *
     * @param {Object} [pdomOptions] - these can override the values of the node, see this.update()
     */
    private onAttributeChange;
    /**
     * Set all classes onto the peer elements from the model's stored data objects
     * @private
     */
    private onClassChange;
    /**
     * Set the input value on the peer's primary sibling element. The value attribute must be set as a Property to be
     * registered correctly by an assistive device. If null, the attribute is removed so that we don't clutter the DOM
     * with value="null" attributes.
     *
     * @public (scenery-internal)
     */
    public onInputValueChange(): void;
    /**
     * Get an element on this node, looked up by the elementName flag passed in.
     * @public (scenery-internal)
     *
     * @param {string} elementName - see PDOMUtils for valid associations
     * @returns {HTMLElement}
     */
    public getElementByName(elementName: string): HTMLElement;
    /**
     * Sets a attribute on one of the peer's window.Elements.
     * @public (scenery-internal)
     * @param {string} attribute
     * @param {*} attributeValue
     * @param {Object} [options]
     */
    public setAttributeToElement(attribute: string, attributeValue: any, options?: Object | undefined): void;
    /**
     * Remove attribute from one of the peer's window.Elements.
     * @public (scenery-internal)
     * @param {string} attribute
     * @param {Object} [options]
     */
    public removeAttributeFromElement(attribute: string, options?: Object | undefined): void;
    /**
     * Remove the given attribute from all peer elements
     * @public (scenery-internal)
     * @param {string} attribute
     */
    public removeAttributeFromAllElements(attribute: string): void;
    /**
     * Add the provided className to the element's classList.
     *
     * @public
     * @param {string} className
     * @param {Object} [options]
     */
    public setClassToElement(className: string, options?: Object | undefined): void;
    /**
     * Remove the specified className from the element.
     * @public
     *
     * @param {string} className
     * @param {Object} [options]
     */
    public removeClassFromElement(className: string, options?: Object | undefined): void;
    /**
     * Set either association attribute (aria-labelledby/describedby) on one of this peer's Elements
     * @public (scenery-internal)
     * @param {string} attribute - either aria-labelledby or aria-describedby
     * @param {Object} associationObject - see addAriaLabelledbyAssociation() for schema
     */
    public setAssociationAttribute(attribute: string, associationObject: Object): void;
    /**
     * The contentElement will either be a label or description element. The contentElement will be sorted relative to
     * the primarySibling. Its placement will also depend on whether or not this node wants to append this element,
     * see setAppendLabel() and setAppendDescription(). By default, the "content" element will be placed before the
     * primarySibling.
     *
     * NOTE: This function assumes it is called on label sibling before description sibling for inserting elements
     * into the correct order.
     *
     * @private
     *
     * @param {HTMLElement} contentElement
     * @param {boolean} appendElement
     */
    private arrangeContentElement;
    /**
     * Is this peer hidden in the PDOM
     * @public
     *
     * @returns {boolean}
     */
    public isVisible(): boolean;
    /**
     * Set whether or not the peer is visible in the PDOM
     * @public
     *
     * @param {boolean} visible
     */
    public setVisible(visible: boolean): void;
    /**
     * Returns if this peer is focused. A peer is focused if its primarySibling is focused.
     * @public (scenery-internal)
     * @returns {boolean}
     */
    public isFocused(): boolean;
    /**
     * Focus the primary sibling of the peer. If this peer is not visible, this is a no-op (native behavior).
     * @public (scenery-internal)
     */
    public focus(): void;
    /**
     * Blur the primary sibling of the peer.
     * @public (scenery-internal)
     */
    public blur(): void;
    /**
     * Make the peer focusable. Only the primary sibling is ever considered focusable.
     * @public
     * @param {boolean} focusable
     */
    public setFocusable(focusable: boolean): void;
    /**
     * Responsible for setting the content for the label sibling
     * @public (scenery-internal)
     * @param {string|null} content - the content for the label sibling.
     */
    public setLabelSiblingContent(content: string | null): void;
    /**
     * Responsible for setting the content for the description sibling
     * @public (scenery-internal)
     * @param {string|null} content - the content for the description sibling.
     */
    public setDescriptionSiblingContent(content: string | null): void;
    /**
     * Responsible for setting the content for the primary sibling
     * @public (scenery-internal)
     * @param {string|null} content - the content for the primary sibling.
     */
    public setPrimarySiblingContent(content: string | null): void;
    /**
     * Sets the pdomTransformSourceNode so that the primary sibling will be transformed with changes to along the
     * unique trail to the source node. If null, repositioning happens with transform changes along this
     * pdomInstance's trail.
     * @public
     *
     * @param {../nodes/Node|null} node
     */
    public setPDOMTransformSourceNode(node: any): void;
    /**
     * Enable or disable positioning of the sibling elements. Generally this is requiredfor accessibility to work on
     * touch screen based screen readers like phones. But repositioning DOM elements is expensive. This can be set to
     * false to optimize when positioning is not necessary.
     * @public (scenery-internal)
     *
     * @param {boolean} positionInPDOM
     */
    public setPositionInPDOM(positionInPDOM: boolean): void;
    getElementId(siblingName: any, stringId: any): string;
    updateIndicesStringAndElementIds(): void;
    /**
     * Mark that the siblings of this PDOMPeer need to be updated in the next Display update. Possibly from a
     * change of accessible content or node transformation. Does nothing if already marked dirty.
     *
     * @param [forceReflowWorkaround] - In addition to repositioning, force a reflow next animation frame? See
     *                                  this.forceReflowWorkaround for more information.
     * @private
     */
    private invalidateCSSPositioning;
    /**
     * Update the CSS positioning of the primary and label siblings. Required to support accessibility on mobile
     * devices. On activation of focusable elements, certain AT will send fake pointer events to the browser at
     * the center of the client bounding rectangle of the HTML element. By positioning elements over graphical display
     * objects we can capture those events. A transformation matrix is calculated that will transform the position
     * and dimension of the HTML element in pixels to the global coordinate frame. The matrix is used to transform
     * the bounds of the element prior to any other transformation so we can set the element's left, top, width, and
     * height with CSS attributes.
     *
     * For now we are only transforming the primary and label siblings if the primary sibling is focusable. If
     * focusable, the primary sibling needs to be transformed to receive user input. VoiceOver includes the label bounds
     * in its calculation for where to send the events, so it needs to be transformed as well. Descriptions are not
     * considered and do not need to be positioned.
     *
     * Initially, we tried to set the CSS transformations on elements directly through the transform attribute. While
     * this worked for basic input, it did not support other AT features like tapping the screen to focus elements.
     * With this strategy, the VoiceOver "touch area" was a small box around the top left corner of the element. It was
     * never clear why this was this case, but forced us to change our strategy to set the left, top, width, and height
     * attributes instead.
     *
     * This function assumes that elements have other style attributes so they can be positioned correctly and don't
     * interfere with scenery input, see SceneryStyle in PDOMUtils.
     *
     * Additional notes were taken in https://github.com/phetsims/scenery/issues/852, see that issue for more
     * information.
     *
     * Review: This function could be simplified by setting the element width/height a small arbitrary shape
     * at the center of the node's global bounds. There is a drawback in that the VO default highlight won't
     * surround the Node anymore. But it could be a performance enhancement and simplify this function.
     * Or maybe a big rectangle larger than the Display div still centered on the node so we never
     * see the VO highlight?
     *
     * @private
     */
    private positionElements;
    /**
     * Update positioning of elements in the PDOM. Does a depth first search for all descendants of parentIntsance with
     * a peer that either has dirty positioning or as a descendant with dirty positioning.
     *
     * @public (scenery-internal)
     */
    public updateSubtreePositioning(parentPositionInPDOM?: boolean): void;
    /**
     * Recursively set this PDOMPeer and children to be disabled. This will overwrite any previous value of disabled
     * that may have been set, but will keep track of the old value, and restore its state upon re-enabling.
     * @param {boolean} disabled
     * @public
     */
    public recursiveDisable(disabled: boolean): void;
    /**
     * Removes external references from this peer, and places it in the pool.
     * @public (scenery-internal)
     */
    public dispose(): void;
}
declare namespace PDOMPeer {
    export { PRIMARY_SIBLING };
    export { LABEL_SIBLING };
    export { DESCRIPTION_SIBLING };
    export { CONTAINER_PARENT };
    export let OFFSCREEN_SIBLING_BOUNDS: Bounds2;
}
import { PDOMInstance } from '../../imports.js';
declare const PRIMARY_SIBLING: "PRIMARY_SIBLING";
declare const LABEL_SIBLING: "LABEL_SIBLING";
declare const DESCRIPTION_SIBLING: "DESCRIPTION_SIBLING";
declare const CONTAINER_PARENT: "CONTAINER_PARENT";
import Bounds2 from '../../../../dot/js/Bounds2.js';
//# sourceMappingURL=PDOMPeer.d.ts.map