export default PDOMUtils;
declare namespace PDOMUtils {
    /**
     * Given a Property or string, return the Propergy value if it is a property. Otherwise just return the string.
     * Useful for forwarding the string to DOM content, but allowing the API to take a StringProperty. Eventually
     * PDOM may support dynamic strings.
     * @param valueOrProperty
     * @returns {string|Property}
     */
    export function unwrapStringProperty(valueOrProperty: any): string | Property;
    /**
     * Get the next focusable element relative to the currently focused element and under the parentElement.
     * Can be useful if you want to emulate the 'Tab' key behavior or just transition focus to the next element
     * in the document. If no next focusable can be found, it will return the currently focused element.
     * @public
     *
     * @param {HTMLElement} [parentElement] - optional, search will be limited to elements under this element
     * @returns {HTMLElement}
     */
    export function getNextFocusable(parentElement?: HTMLElement): HTMLElement;
    /**
     * Get the previous focusable element relative to the currently focused element under the parentElement. Can be
     * useful if you want to emulate 'Shift+Tab' behavior. If no next focusable can be found, it will return the
     * currently focused element.
     * @public
     *
     * @param {HTMLElement} [parentElement] - optional, search will be limited to elements under this parent
     * @returns {HTMLElement}
     */
    export function getPreviousFocusable(parentElement?: HTMLElement): HTMLElement;
    /**
     * Get the first focusable element under the parentElement. If no element is available, the document.body is
     * returned.
     *
     * @param {HTMLElement} [parentElement] - optionally restrict the search to elements under this parent
     * @returns {HTMLElement}
     */
    export function getFirstFocusable(parentElement?: HTMLElement): HTMLElement;
    /**
     * Return a random focusable element in the document. Particularly useful for fuzz testing.
     * @public
     *
     * @parma {Random} random
     * @returns {HTMLElement}
     */
    export function getRandomFocusable(random: any): HTMLElement;
    /**
     * ParallelDOM trait values may be in a Property to support dynamic locales. This function
     * returns the Property value in that case. The value may be a string, boolean, or number -
     * all of which are valid values for native HTML attributes.
     *
     * @param {string | boolean | number | TReadOnlyProperty<string|boolean|number>} valueOrProperty
     * @returns {string|boolean|number}
     */
    export function unwrapProperty(valueOrProperty: string | boolean | number | TReadOnlyProperty<string | boolean | number>): string | boolean | number;
    /**
     * If the textContent has any tags that are not formatting tags, return false. Only checking for
     * tags that are not in the allowed FORMATTING_TAGS. If there are no tags at all, return false.
     * @public
     *
     * @param {string} textContent
     * @returns {boolean}
     */
    export function containsFormattingTags(textContent: string): boolean;
    /**
     * If the text content uses formatting tags, set the content as innerHTML. Otherwise, set as textContent.
     * In general, textContent is more secure and much faster because it doesn't trigger DOM styling and
     * element insertions.
     * @public
     *
     * @param {Element} domElement
     * @param {string|number|null} textContent - domElement is cleared of content if null, could have acceptable HTML
     *                                    "formatting" tags in it
     */
    export function setTextContent(domElement: Element, textContent: string | number | null): void;
    /**
     * Given a tagName, test if the element will be focuable by default by the browser.
     * Different from isElementFocusable, because this only looks at tags that the browser will automatically put
     * a >=0 tab index on.
     * @public
     *
     * NOTE: Uses a set of browser types as the definition of default focusable elements,
     * see https://stackoverflow.com/questions/1599660/which-html-elements-can-receive-focus
     *
     * @param tagName
     * @returns {boolean}
     */
    export function tagIsDefaultFocusable(tagName: any): boolean;
    /**
     * Returns true if the element is focusable. Assumes that all focusable  elements have tabIndex >= 0, which
     * is only true for elements of the Parallel DOM.
     *
     * @param {HTMLElement} domElement
     * @returns {boolean}
     */
    export function isElementFocusable(domElement: HTMLElement): boolean;
    /**
     * @public
     *
     * @param {string} tagName
     * @returns {boolean} - true if the tag does support inner content
     */
    export function tagNameSupportsContent(tagName: string): boolean;
    /**
     * Helper function to remove multiple HTMLElements from another HTMLElement
     * @public
     *
     * @param {HTMLElement} element
     * @param {Array.<HTMLElement>} childrenToRemove
     */
    export function removeElements(element: HTMLElement, childrenToRemove: Array<HTMLElement>): void;
    /**
     * Helper function to add multiple elements as children to a parent
     * @public
     *
     * @param {HTMLElement} element - to add children to
     * @param {Array.<HTMLElement>} childrenToAdd
     * @param {HTMLElement} [beforeThisElement] - if not supplied, the insertBefore call will just use 'null'
     */
    export function insertElements(element: HTMLElement, childrenToAdd: Array<HTMLElement>, beforeThisElement?: HTMLElement): void;
    /**
     * Create an HTML element.  Unless this is a form element or explicitly marked as focusable, add a negative
     * tab index. IE gives all elements a tabIndex of 0 and handles tab navigation internally, so this marks
     * which elements should not be in the focus order.
     *
     * @public
     * @param  {string} tagName
     * @param {boolean} focusable - should the element be explicitly added to the focus order?
     * @param {Object} [options]
     * @returns {HTMLElement}
     */
    export function createElement(tagName: string, focusable: boolean, options?: Object): HTMLElement;
    /**
     * Add a tab index to an element when overriding the default focus behavior for the element. Adding tabindex
     * to an element can only be done when overriding the default browser behavior because tabindex interferes with
     * the way JAWS reads through content on Chrome, see https://github.com/phetsims/scenery/issues/893
     *
     * If default behavior and focusable align, the tabindex attribute is removed so that can't interfere with a
     * screen reader.
     * @public (scenery-internal)
     *
     * @param {HTMLElement} element
     * @param {boolean} focusable
     */
    export function overrideFocusWithTabIndex(element: HTMLElement, focusable: boolean): void;
    /**
     * Given a Node, search for a stringProperty in the Node or its children, recursively. This
     * is useful for finding a string to set as ParallelDOM content.
     *
     * This uses a depth first search to find the first instance of Text or RichText under the Node.
     * It won't necessarily be the closest to the root of the Node or most "prominent" Text/RichText
     * if there are multiple Text/RichText nodes.
     *
     * @public
     * @returns {TReadOnlyProperty<string>|null}
     */
    export function findStringProperty(node: any): TReadOnlyProperty<string> | null;
    export namespace TAGS {
        export { INPUT_TAG as INPUT };
        export { LABEL_TAG as LABEL };
        export { BUTTON_TAG as BUTTON };
        export { TEXTAREA_TAG as TEXTAREA };
        export { SELECT_TAG as SELECT };
        export { OPTGROUP_TAG as OPTGROUP };
        export { DATALIST_TAG as DATALIST };
        export { OUTPUT_TAG as OUTPUT };
        export { DIV_TAG as DIV };
        export { A_TAG as A };
        export { P_TAG as P };
        export { BOLD_TAG as B };
        export { STRONG_TAG as STRONG };
        export { I_TAG as I };
        export { EM_TAG as EM };
        export { MARK_TAG as MARK };
        export { SMALL_TAG as SMALL };
        export { DEL_TAG as DEL };
        export { INS_TAG as INS };
        export { SUB_TAG as SUB };
        export { SUP_TAG as SUP };
    }
    export let FORM_ELEMENTS: string[];
    export { DIV_TAG as DEFAULT_CONTAINER_TAG_NAME };
    export { P_TAG as DEFAULT_DESCRIPTION_TAG_NAME };
    export { P_TAG as DEFAULT_LABEL_TAG_NAME };
    export { ASSOCIATION_ATTRIBUTES };
    export let INPUT_TYPES_THAT_SUPPORT_CHECKED: string[];
    export { DOM_EVENTS };
    export { USER_GESTURE_EVENTS };
    export { BLOCKED_DOM_EVENTS };
    export { DATA_PDOM_UNIQUE_ID };
    export let PDOM_UNIQUE_ID_SEPARATOR: string;
    export let DATA_EXCLUDE_FROM_INPUT: string;
}
declare const INPUT_TAG: "INPUT";
declare const LABEL_TAG: "LABEL";
declare const BUTTON_TAG: "BUTTON";
declare const TEXTAREA_TAG: "TEXTAREA";
declare const SELECT_TAG: "SELECT";
declare const OPTGROUP_TAG: "OPTGROUP";
declare const DATALIST_TAG: "DATALIST";
declare const OUTPUT_TAG: "OUTPUT";
declare const DIV_TAG: "DIV";
declare const A_TAG: "A";
declare const P_TAG: "P";
declare const BOLD_TAG: "B";
declare const STRONG_TAG: "STRONG";
declare const I_TAG: "I";
declare const EM_TAG: "EM";
declare const MARK_TAG: "MARK";
declare const SMALL_TAG: "SMALL";
declare const DEL_TAG: "DEL";
declare const INS_TAG: "INS";
declare const SUB_TAG: "SUB";
declare const SUP_TAG: "SUP";
declare const ASSOCIATION_ATTRIBUTES: string[];
declare const DOM_EVENTS: string[];
declare const USER_GESTURE_EVENTS: string[];
declare const BLOCKED_DOM_EVENTS: string[];
declare const DATA_PDOM_UNIQUE_ID: "data-unique-id";
//# sourceMappingURL=PDOMUtils.d.ts.map