import * as TinyCollision from '../../basics/collision.mjs';
import TinyElementObserver from './TinyElementObserver.mjs';
export type TinyHtmlAny = TinyHtml<ConstructorElValues>;
export type AppendCheckerTemplate = TinyNode | TinyNode[] | string | false | null | undefined;
export type AppendCheckerValues = AppendCheckerTemplate | AppendCheckerTemplate[];
export type HoverEventCallback = (ev: MouseEvent) => void;
export type StyleFxResult = Map<HTMLElement, Animation | null>;
export type AnimationSfxData = Record<string, (string | number)[]>;
export type StyleEffectsRdFn = (effects: AnimationSfxData) => boolean;
export type StyleEffectsFn = (el: HTMLElement, keyframes: AnimationSfxData, prop: string, style: CSSStyleDeclaration) => void;
export type StyleEffectsProps = Record<string, StyleEffectsFn>;
export type OnScrollAnimation = (progress: {
    x: number;
    y: number;
    isComplete: boolean;
    time: number;
}) => void;
export type Easings = 'linear' | 'easeInQuad' | 'easeOutQuad' | 'easeInOutQuad' | 'easeInCubic' | 'easeOutCubic' | 'easeInOutCubic';
export type TinyNode = Node | TinyHtmlAny | null;
export type TinyElement = Element | TinyHtmlAny;
export type TinyHtmlElement = HTMLElement | TinyHtmlAny;
export type TinyEventTarget = EventTarget | TinyHtmlAny;
export type TinyInputElement = InputElement | TinyHtmlAny;
export type TinyElementAndWindow = ElementAndWindow | TinyHtmlAny;
export type ElementAndWindow = Element | Window;
export type TinyElementAndWinAndDoc = ElementAndWinAndDoc | TinyHtmlAny;
export type ElementAndWinAndDoc = Element | Window | Document;
export type TinyElementWithDoc = ElementWithDoc | TinyHtmlAny;
export type ElementWithDoc = Element | Document;
export type WinnowRequest = string | Element | Element[] | ((index: number, el: Element) => boolean);
export type ConstructorElValues = Window | Element | Document | Text;
export type EventRegistryOptions = boolean | AddEventListenerOptions;
export type EventRegistryItem = {
    /**
     * - The function to be executed when the event is triggered.
     */
    handler: EventListenerOrEventListenerObject | null;
    /**
     * - Optional configuration passed to the listener.
     */
    options?: EventRegistryOptions;
};
export type EventRegistryList = Record<string, EventRegistryItem[]>;
export type ElementDataStore = Record<string, any>;
export type StyleEffects = Record<string, string | (string | number)[]>;
export type ObjRect = import('../../basics/collision.mjs').ObjRect;
export type CollisionDirLock = 'top' | 'bottom' | 'left' | 'right';
export type HtmlElBoxSides = {
    /**
     * - Total horizontal size (left + right)
     */
    x: number;
    /**
     * - Total vertical size (top + bottom)
     */
    y: number;
    left: number;
    right: number;
    top: number;
    bottom: number;
};
export type SetValueBase = string | number | Date | boolean | null;
export type GetValueTypes = 'string' | 'date' | 'number';
export type SetValueList = SetValueBase | SetValueBase[];
export type InputElement = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | HTMLOptionElement;
export type HtmlParsed = [
    tagName: string,
    attributes: Record<string, string>,
    ...children: (string | HtmlParsed)[]
];
export type TinyHtmlConstructor = (ConstructorElValues | ConstructorElValues[] | NodeListOf<Element> | HTMLCollectionOf<Element> | NodeListOf<HTMLElement> | string);
/**
 * Possible directions from which a collision was detected and locked.
 *
 * @typedef {'top'|'bottom'|'left'|'right'} CollisionDirLock
 */
/**
 * @typedef {Object} HtmlElBoxSides
 * @property {number} x - Total horizontal size (left + right)
 * @property {number} y - Total vertical size (top + bottom)
 * @property {number} left
 * @property {number} right
 * @property {number} top
 * @property {number} bottom
 */
/**
 * @typedef {string | number | Date | boolean | null} SetValueBase - Primitive types accepted as input values.
 */
/**
 * @typedef {'string' | 'date' | 'number'} GetValueTypes
 * Types of value extractors supported by TinyHtml._valTypes.
 */
/**
 * @typedef {SetValueBase|SetValueBase[]} SetValueList - A single value or an array of values to be assigned to the input element.
 */
/**
 * A list of HTML form elements that can have a `.value` property used by TinyHtml.
 * Includes common input types used in forms.
 *
 * @typedef {HTMLInputElement|HTMLSelectElement|HTMLTextAreaElement|HTMLOptionElement} InputElement
 */
/**
 * Represents a parsed HTML element in JSON-like array form.
 *
 * @typedef {[
 *   tagName: string, // The tag name of the element (e.g., 'div', 'img')
 *   attributes: Record<string, string>, // All element attributes as key-value pairs
 *   ...children: (string | HtmlParsed)[] // Text or nested elements
 * ]} HtmlParsed
 */
/**
 * Represents all possible inputs accepted by the TinyHtml constructor.
 * Can be a single element, an array of elements, array-like DOM collections,
 * or a CSS selector string.
 *
 * @typedef {(
 *   ConstructorElValues |
 *   ConstructorElValues[] |
 *   NodeListOf<Element> |
 *   HTMLCollectionOf<Element> |
 *   NodeListOf<HTMLElement> |
 *   string
 * )} TinyHtmlConstructor
 */
/**
 * TinyHtml is a utility class that provides static and instance-level methods
 * for precise dimension and position computations on HTML elements.
 * It mimics some jQuery functionalities while using native browser APIs.
 *
 * Inspired by the jQuery project's open source implementations of element dimension
 * and offset utilities. This class serves as a lightweight alternative using modern DOM APIs.
 *
 * @template {TinyHtmlConstructor} TinyHtmlT
 * @class
 */
declare class TinyHtml<TinyHtmlT extends TinyHtmlConstructor> {
    #private;
    /** @typedef {import('../../basics/collision.mjs').ObjRect} ObjRect */
    static Utils: {
        areElsCollTop: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
        areElsCollBottom: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
        areElsCollLeft: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
        areElsCollRight: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
        areElsCollPerfTop: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
        areElsCollPerfBottom: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
        areElsCollPerfLeft: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
        areElsCollPerfRight: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
        areElsColliding: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
        areElsPerfColliding: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => boolean;
        getElsColliding: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => string | null;
        getElsPerfColliding: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => 'top' | 'bottom' | 'left' | 'right' | null;
        getElsCollOverlap: (rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect) => {
            overlapLeft: number;
            overlapRight: number;
            overlapTop: number;
            overlapBottom: number;
        };
        getElsCollOverlapPos: ({ overlapLeft, overlapRight, overlapTop, overlapBottom, }?: {
            overlapLeft?: number;
            overlapRight?: number;
            overlapTop?: number;
            overlapBottom?: number;
        }) => {
            dirX: TinyCollision.Dirs;
            dirY: TinyCollision.Dirs;
        };
        getRectCenter: (rect: TinyCollision.ObjRect) => {
            x: number;
            y: number;
        };
        getElsRelativeCenterOffset(rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect): {
            x: number;
            y: number;
        };
        getElsCollDirDepth(rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect): {
            inDir: TinyCollision.Dirs | null;
            dirX: TinyCollision.Dirs | null;
            dirY: TinyCollision.Dirs | null;
            depthX: number;
            depthY: number;
        };
        getElsCollDetails(rect1: TinyCollision.ObjRect, rect2: TinyCollision.ObjRect): {
            depth: TinyCollision.CollData;
            dirs: TinyCollision.CollDirs;
            isNeg: TinyCollision.NegCollDirs;
        };
    };
    /** @returns {number} */
    static get version(): number;
    /**
     * Gets whether debug output is enabled.
     * @returns {boolean} True if debug output is enabled; otherwise, false.
     */
    static get elemDebug(): boolean;
    /**
     * Enables or disables debug output.
     * @param {boolean} value True to enable debug output; false to disable.
     * @throws {TypeError} Thrown if the provided value is not a boolean.
     */
    static set elemDebug(value: boolean);
    /**
     * Logs a standardized debug error for element validation, including a console.table
     * with the involved elements. Use this when an element argument is invalid, unexpected,
     * or fails a guard/validation.
     *
     * The output includes:
     *  - A concise error header
     *  - A stack trace (when supported)
     *  - A table of elements (index, typeof, constructor, summary, value)
     *  - The specific problematic element, if provided
     *
     * @param {(ConstructorElValues | EventTarget | TinyElement | null)[]} elems
     *        A list of elements participating in the operation (may include nulls).
     * @param {ConstructorElValues | EventTarget | TinyElement | null} [elem]
     *        The specific element that triggered the error, if available.
     * @returns {void}
     */
    static _debugElemError(elems: (ConstructorElValues | EventTarget | TinyElement | null)[], elem?: ConstructorElValues | EventTarget | TinyElement | null): void;
    /**
     * Parse inline styles into an object.
     * @param {string} styleText
     * @returns {Record<string,string>}
     */
    static parseStyle(styleText: string): Record<string, string>;
    static get tinyObserver(): TinyElementObserver<HTMLElement> | undefined;
    /**
     * Fetches an HTML file from the given URL, parses it to JSON.
     *
     * @param {string | URL | globalThis.Request} url - The URL of the HTML file.
     * @param {RequestInit} [ops] - Optional fetch configuration (e.g., method, headers, cache, etc).
     * @returns {Promise<HtmlParsed[]>} A promise that resolves with the parsed JSON representation of the HTML structure.
     */
    static fetchHtmlFile(url: string | URL | globalThis.Request, ops?: RequestInit): Promise<HtmlParsed[]>;
    /**
     * Fetches an HTML file from the given URL, parses it to JSON, then converts it to DOM nodes.
     *
     * @param {string} url - The URL of the HTML file.
     * @param {RequestInit} [ops] - Optional fetch configuration (e.g., method, headers, cache, etc).
     * @returns {Promise<(HTMLElement|Text)[]>} A promise that resolves with the DOM nodes.
     */
    static fetchHtmlNodes(url: string, ops?: RequestInit): Promise<(HTMLElement | Text)[]>;
    /**
     * Fetches an HTML file from the given URL, parses it to JSON, then converts it to TinyHtml instances.
     *
     * @param {string} url - The URL of the HTML file.
     * @param {RequestInit} [ops] - Optional fetch configuration (e.g., method, headers, cache, etc).
     * Returns the promise that resolves with the TinyHtml instances.
     */
    static fetchHtmlTinyElems(url: string, ops?: RequestInit): Promise<TinyHtml<Element | Text>[]>;
    /**
     * Converts the content of a <template> to an array of HtmlParsed.
     *
     * @param {HTMLTemplateElement} nodes
     * @returns {HtmlParsed[]}
     */
    static templateToJson(nodes: HTMLTemplateElement): HtmlParsed[];
    /**
     * Converts the content of a <template> to real DOM nodes.
     *
     * @param {HTMLTemplateElement} nodes
     * @returns {(Element|Text)[]}
     */
    static templateToNodes(nodes: HTMLTemplateElement): (Element | Text)[];
    /**
     * Converts the content of a <template> to an array of TinyHtml elements.
     *
     * @param {HTMLTemplateElement} nodes
     * @returns {TinyHtml<Element|Text>[]}
     */
    static templateToTinyElems(nodes: HTMLTemplateElement): TinyHtml<Element | Text>[];
    /**
     * Parses a full HTML string into a JSON-like structure.
     *
     * @param {string} htmlString - Full HTML markup as a string.
     * @returns {HtmlParsed[]} An array of parsed HTML elements in structured format.
     */
    static htmlToJson(htmlString: string): HtmlParsed[];
    /**
     * Converts a JSON-like HTML structure back to DOM Elements.
     *
     * @param {HtmlParsed[]} jsonArray - Parsed JSON format of HTML.
     * @returns {(HTMLElement|Text)[]} List of DOM nodes.
     */
    static jsonToNodes(jsonArray: HtmlParsed[]): (HTMLElement | Text)[];
    /**
     * Converts a JSON-like HTML structure back to TinyHtml instances.
     *
     * @param {HtmlParsed[]} jsonArray - Parsed JSON format of HTML.
     * @returns {TinyHtml<HTMLElement | Text>[]} List of TinyHtml instances.
     */
    static jsonToTinyElems(jsonArray: HtmlParsed[]): TinyHtml<HTMLElement | Text>[];
    /**
     * Creates a new TinyHtml element from a tag name and optional attributes.
     *
     * You can alias this method for convenience:
     * ```js
     * const createElement = TinyHtml.createFrom;
     * const myDiv = createElement('div', { class: 'box' });
     * ```
     *
     * @param {string} tagName - The HTML tag name (e.g., 'div', 'span', 'button').
     * @param {Record<string, string|number|null>} [attrs] - Optional key-value pairs representing HTML attributes.
     *                                                If the value is `null`, the attribute will still be set with an empty value.
     * @returns {TinyHtml<HTMLElement>} - A new instance of TinyHtml representing the created element.
     * @throws {TypeError} - If `tagName` is not a string, or `attrs` is not a plain object when defined.
     */
    static createFrom(tagName: string, attrs?: Record<string, string | number | null>): TinyHtml<HTMLElement>;
    /**
     * Creates a new DOM element with the specified tag name and options, then wraps it in a TinyHtml instance.
     *
     * @param {string} tagName - The tag name of the element to create (e.g., 'div', 'span').
     * @param {ElementCreationOptions} [ops] - Optional settings for creating the element.
     * @returns {TinyHtml<HTMLElement>} A TinyHtml instance wrapping the newly created DOM element.
     * @throws {TypeError} If tagName is not a string or ops is not an object.
     */
    static createElement(tagName: string, ops?: ElementCreationOptions): TinyHtml<HTMLElement>;
    /**
     * Creates a new TinyHtml instance that wraps a DOM TextNode.
     *
     * This method is useful when you want to insert raw text content into the DOM
     * without it being interpreted as HTML. The returned instance behaves like any
     * other TinyHtml element and can be appended or manipulated as needed.
     *
     * @param {string} value - The plain text content to be wrapped in a TextNode.
     * @returns {TinyHtml<Text>} A TinyHtml instance wrapping the newly created DOM TextNode.
     * @throws {TypeError} If the provided value is not a string.
     */
    static createTextNode(value: string): TinyHtml<Text>;
    /**
     * @deprecated Use the {@link createFromHTML} instead.
     *
     * Creates an HTMLElement or TextNode from an HTML string.
     * Supports both elements and plain text.
     *
     * @param {string} htmlString - The HTML string to convert.
     * @returns {TinyHtml<Element>} - A single HTMLElement or TextNode.
     */
    static createElementFromHTML(htmlString: string): TinyHtml<Element>;
    /**
     * Creates an HTMLElement or TextNode from an HTML string.
     * Supports both elements and plain text.
     *
     * @param {string} htmlString - The HTML string to convert.
     * @returns {TinyHtml<Element>} - A single HTMLElement or TextNode.
     */
    static createFromHTML(htmlString: string): TinyHtml<Element>;
    /**
     * Creates an HTMLElement or TextNode from an HTML string.
     * Supports both elements and plain text.
     *
     * @param {string} htmlString - The HTML string to convert.
     * @returns {TinyHtml<Element>} - A single HTMLElement or TextNode.
     */
    static createFromHtml(htmlString: string): TinyHtml<Element>;
    /**
     * Queries the document for the first element matching the CSS selector and wraps it in a TinyHtml instance.
     *
     * @param {string} selector - A valid CSS selector string.
     * @param {Document|Element} elem - Target element.
     * @returns {TinyHtml<Element>|null} A TinyHtml instance wrapping the matched element.
     */
    static query(selector: string, elem?: Document | Element): TinyHtml<Element> | null;
    /**
     * Queries the element for the first element matching the CSS selector and wraps it in a TinyHtml instance.
     *
     * @param {string} selector - A valid CSS selector string.
     * @returns {TinyHtml<Element>|null} A TinyHtml instance wrapping the matched element.
     */
    querySelector(selector: string): TinyHtml<Element> | null;
    /**
     * Queries the document for all elements matching the CSS selector and wraps them in TinyHtml instances.
     *
     * @param {string} selector - A valid CSS selector string.
     * @param {Document|Element} elem - Target element.
     * @returns {TinyHtml<NodeListOf<Element>>} An array of TinyHtml instances wrapping the matched elements.
     */
    static queryAll(selector: string, elem?: Document | Element): TinyHtml<NodeListOf<Element>>;
    /**
     * Queries the element for all elements matching the CSS selector and wraps them in TinyHtml instances.
     *
     * @param {string} selector - A valid CSS selector string.
     * @returns {TinyHtml<NodeListOf<Element>>} An array of TinyHtml instances wrapping the matched elements.
     */
    querySelectorAll(selector: string): TinyHtml<NodeListOf<Element>>;
    /**
     * Retrieves an element by its ID and wraps it in a TinyHtml instance.
     *
     * @param {string} selector - The ID of the element to retrieve.
     * @returns {TinyHtml<HTMLElement>|null} A TinyHtml instance wrapping the found element.
     */
    static getById(selector: string): TinyHtml<HTMLElement> | null;
    /**
     * Retrieves all elements with the specified class name and wraps them in TinyHtml instances.
     *
     * @param {string} selector - The class name to search for.
     * @param {Document|Element} elem - Target element.
     * @returns {TinyHtml<HTMLCollectionOf<Element>>} An array of TinyHtml instances wrapping the found elements.
     */
    static getByClassName(selector: string, elem?: Document | Element): TinyHtml<HTMLCollectionOf<Element>>;
    /**
     * Retrieves all elements with the specified class name and wraps them in TinyHtml instances.
     *
     * @param {string} selector - The class name to search for.
     * @returns {TinyHtml<HTMLCollectionOf<Element>>} An array of TinyHtml instances wrapping the found elements.
     */
    getElementsByClassName(selector: string): TinyHtml<HTMLCollectionOf<Element>>;
    /**
     * Retrieves all elements with the specified name attribute and wraps them in TinyHtml instances.
     *
     * @param {string} selector - The name attribute to search for.
     * @returns {TinyHtml<NodeListOf<HTMLElement>>} An array of TinyHtml instances wrapping the found elements.
     */
    static getByName(selector: string): TinyHtml<NodeListOf<HTMLElement>>;
    /**
     * Retrieves all elements with the specified local tag name within the given namespace URI,
     * and wraps them in TinyHtml instances.
     *
     * @param {string} localName - The local name (tag) of the elements to search for.
     * @param {string|null} [namespaceURI='http://www.w3.org/1999/xhtml'] - The namespace URI to search within.
     * @param {Document|Element} elem - Target element.
     * @returns {TinyHtml<HTMLCollectionOf<Element>>} An array of TinyHtml instances wrapping the found elements.
     */
    static getByTagNameNS(localName: string, namespaceURI?: string | null, elem?: Document | Element): TinyHtml<HTMLCollectionOf<Element>>;
    /**
     * Retrieves all elements with the specified local tag name within the given namespace URI,
     * and wraps them in TinyHtml instances.
     *
     * @param {string} localName - The local name (tag) of the elements to search for.
     * @param {string|null} [namespaceURI='http://www.w3.org/1999/xhtml'] - The namespace URI to search within.
     * @returns {TinyHtml<HTMLCollectionOf<Element>>} An array of TinyHtml instances wrapping the found elements.
     */
    getElementsByTagNameNS(localName: string, namespaceURI?: string | null): TinyHtml<HTMLCollectionOf<Element>>;
    /**
     * Returns the current targets held by this instance.
     *
     * @returns {ConstructorElValues[]} - The instance's targets element.
     */
    get elements(): ConstructorElValues[];
    /**
     * Iterates over all elements, executing the provided callback on each.
     * @param {(element: TinyHtmlAny, index: number, items: TinyHtmlAny[]) => void} callback - Function invoked for each element.
     * @returns {this} The current instance for chaining.
     */
    forEach(callback: (element: TinyHtmlAny, index: number, items: TinyHtmlAny[]) => void): this;
    /**
     * Returns the current target held by this instance.
     *
     * @param {number} index - The index of the element to retrieve.
     * @returns {ConstructorElValues} - The instance's target element.
     */
    get(index: number): ConstructorElValues;
    /**
     * Extracts a single DOM element from the internal list at the specified index.
     *
     * @param {number} index - The index of the element to extract.
     * @returns {TinyHtmlAny} A new TinyHtml instance wrapping the extracted element.
     */
    extract(index: number): TinyHtmlAny;
    /**
     * Checks whether the element exists at the given index.
     *
     * @param {number} index - The index to check.
     * @returns {boolean} - True if the element exists; otherwise, false.
     */
    exists(index: number): boolean;
    /**
     * Returns the current Element held by this instance.
     *
     * @param {string} where - The method name or context calling this.
     * @param {number} index - The index of the element to retrieve.
     * @returns {ConstructorElValues} - The instance's element.
     */
    _getElement(where: string, index: number): ConstructorElValues;
    /**
     * Returns the current Elements held by this instance.
     *
     * @param {string} where - The method name or context calling this.
     * @returns {ConstructorElValues[]} - The instance's elements.
     */
    _getElements(where: string): ConstructorElValues[];
    /**
     * Prepares and validates multiple elements against allowed types.
     *
     * @param {TinyElement | EventTarget | null | (TinyElement | EventTarget | null)[]} elems - The input elements to validate.
     * @param {string} where - The method name or context calling this.
     * @param {any[]} TheTinyElements - The list of allowed constructors (e.g., Element, Document).
     * @param {string[]} elemName - The list of expected element names for error reporting.
     * @returns {any[]} - A flat array of validated elements.
     * @throws {Error} - If any element is not an instance of one of the allowed types.
     */
    static _preElemsTemplate(elems: TinyElement | EventTarget | null | (TinyElement | EventTarget | null)[], where: string, TheTinyElements: any[], elemName: string[]): any[];
    /**
     * Prepares and validates multiple elements against allowed types.
     *
     * @param {string} where - The method name or context calling this.
     * @param {any[]} TheTinyElements - The list of allowed constructors (e.g., Element, Document).
     * @param {string[]} elemName - The list of expected element names for error reporting.
     * @returns {any[]} - A flat array of validated elements.
     * @throws {Error} - If any element is not an instance of one of the allowed types.
     */
    _preElemsTemplate(where: string, TheTinyElements: any[], elemName: string[]): any[];
    /**
     * Prepares and validates a single element against allowed types.
     *
     * @param {TinyElement | EventTarget | null | (TinyElement | EventTarget | null)[]} elems - The input element or list to validate.
     * @param {string} where - The method name or context calling this.
     * @param {any[]} TheTinyElements - The list of allowed constructors (e.g., Element, Document).
     * @param {string[]} elemName - The list of expected element names for error reporting.
     * @param {boolean} [canNull=false] - Whether `null` is allowed as a valid value.
     * @returns {any} - The validated element or `null` if allowed.
     * @throws {Error} - If the element is not valid or if multiple elements are provided.
     */
    static _preElemTemplate(elems: TinyElement | EventTarget | null | (TinyElement | EventTarget | null)[], where: string, TheTinyElements: any[], elemName: string[], canNull?: boolean): any;
    /**
     * Prepares and validates a single element against allowed types.
     *
     * @param {string} where - The method name or context calling this.
     * @param {any[]} TheTinyElements - The list of allowed constructors (e.g., Element, Document).
     * @param {string[]} elemName - The list of expected element names for error reporting.
     * @param {boolean} [canNull=false] - Whether `null` is allowed as a valid value.
     * @returns {any} - The validated element or `null` if allowed.
     * @throws {Error} - If the element is not valid or if multiple elements are provided.
     */
    _preElemTemplate(where: string, TheTinyElements: any[], elemName: string[], canNull?: boolean): any;
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single elements.
     *
     * @param {TinyElement|TinyElement[]} elems - A single element or array of elements.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {Element[]} - Always returns an array of elements.
     */
    static _preElems(elems: TinyElement | TinyElement[], where: string): Element[];
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single elements.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {Element[]} - Always returns an array of elements.
     */
    _preElems(where: string): Element[];
    /**
     * Ensures the input is returned as an single element.
     * Useful to normalize operations across multiple or single elements.
     *
     * @param {TinyElement|TinyElement[]} elems - A single element or array of elements.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {Element} - Always returns an single element.
     */
    static _preElem(elems: TinyElement | TinyElement[], where: string): Element;
    /**
     * Ensures the input is returned as an single element.
     * Useful to normalize operations across multiple or single elements.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {Element} - Always returns an single element.
     */
    _preElem(where: string): Element;
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single nodes.
     *
     * @param {TinyNode|TinyNode[]} elems - A single node or array of nodes.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {Node[]} - Always returns an array of nodes.
     */
    static _preNodeElems(elems: TinyNode | TinyNode[], where: string): Node[];
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single nodes.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {Node[]} - Always returns an array of nodes.
     */
    _preNodeElems(where: string): Node[];
    /**
     * Ensures the input is returned as an single node.
     * Useful to normalize operations across multiple or single nodes.
     *
     * @param {TinyNode|TinyNode[]} elems - A single node or array of nodes.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {Node} - Always returns an single node.
     */
    static _preNodeElem(elems: TinyNode | TinyNode[], where: string): Node;
    /**
     * Ensures the input is returned as an single node.
     * Useful to normalize operations across multiple or single nodes.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {Node} - Always returns an single node.
     */
    _preNodeElem(where: string): Node;
    /**
     * Ensures the input is returned as an single node.
     * Useful to normalize operations across multiple or single nodes.
     *
     * @param {TinyNode|TinyNode[]} elems - A single node or array of nodes.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {Node|null} - Always returns an single node or null.
     */
    static _preNodeElemWithNull(elems: TinyNode | TinyNode[], where: string): Node | null;
    /**
     * Ensures the input is returned as an single node.
     * Useful to normalize operations across multiple or single nodes.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {Node|null} - Always returns an single node or null.
     */
    _preNodeElemWithNull(where: string): Node | null;
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single html elements.
     *
     * @param {TinyElement|TinyElement[]} elems - A single html element or array of html elements.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {HTMLElement[]} - Always returns an array of html elements.
     */
    static _preHtmlElems(elems: TinyElement | TinyElement[], where: string): HTMLElement[];
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single html elements.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {HTMLElement[]} - Always returns an array of html elements.
     */
    _preHtmlElems(where: string): HTMLElement[];
    /**
     * Ensures the input is returned as an single html element.
     * Useful to normalize operations across multiple or single html elements.
     *
     * @param {TinyElement|TinyElement[]} elems - A single html element or array of html elements.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {HTMLElement} - Always returns an single html element.
     */
    static _preHtmlElem(elems: TinyElement | TinyElement[], where: string): HTMLElement;
    /**
     * Ensures the input is returned as an single html element.
     * Useful to normalize operations across multiple or single html elements.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {HTMLElement} - Always returns an single html element.
     */
    _preHtmlElem(where: string): HTMLElement;
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single event target elements.
     *
     * @param {TinyInputElement|TinyInputElement[]} elems - A single event target element or array of html elements.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {InputElement[]} - Always returns an array of event target elements.
     */
    static _preInputElems(elems: TinyInputElement | TinyInputElement[], where: string): InputElement[];
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single event target elements.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {InputElement[]} - Always returns an array of event target elements.
     */
    _preInputElems(where: string): InputElement[];
    /**
     * Ensures the input is returned as an single event target element.
     * Useful to normalize operations across multiple or single event target elements.
     *
     * @param {TinyInputElement|TinyInputElement[]} elems - A single event target element or array of html elements.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {InputElement} - Always returns an single event target element.
     */
    static _preInputElem(elems: TinyInputElement | TinyInputElement[], where: string): InputElement;
    /**
     * Ensures the input is returned as an single event target element.
     * Useful to normalize operations across multiple or single event target elements.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {InputElement} - Always returns an single event target element.
     */
    _preInputElem(where: string): InputElement;
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single event target elements.
     *
     * @param {TinyEventTarget|TinyEventTarget[]} elems - A single event target element or array of html elements.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {EventTarget[]} - Always returns an array of event target elements.
     */
    static _preEventTargetElems(elems: TinyEventTarget | TinyEventTarget[], where: string): EventTarget[];
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single event target elements.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {EventTarget[]} - Always returns an array of event target elements.
     */
    _preEventTargetElems(where: string): EventTarget[];
    /**
     * Ensures the input is returned as an single event target element.
     * Useful to normalize operations across multiple or single event target elements.
     *
     * @param {TinyEventTarget|TinyEventTarget[]} elems - A single event target element or array of html elements.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {EventTarget} - Always returns an single event target element.
     */
    static _preEventTargetElem(elems: TinyEventTarget | TinyEventTarget[], where: string): EventTarget;
    /**
     * Ensures the input is returned as an single event target element.
     * Useful to normalize operations across multiple or single event target elements.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {EventTarget} - Always returns an single event target element.
     */
    _preEventTargetElem(where: string): EventTarget;
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single element/window elements.
     *
     * @param {TinyElementAndWindow|TinyElementAndWindow[]} elems - A single element/window element or array of html elements.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {ElementAndWindow[]} - Always returns an array of element/window elements.
     */
    static _preElemsAndWindow(elems: TinyElementAndWindow | TinyElementAndWindow[], where: string): ElementAndWindow[];
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single element/window elements.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {ElementAndWindow[]} - Always returns an array of element/window elements.
     */
    _preElemsAndWindow(where: string): ElementAndWindow[];
    /**
     * Ensures the input is returned as an single element/window element.
     * Useful to normalize operations across multiple or single element/window elements.
     *
     * @param {TinyElementAndWindow|TinyElementAndWindow[]} elems - A single element/window element or array of html elements.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {ElementAndWindow} - Always returns an single element/window element.
     */
    static _preElemAndWindow(elems: TinyElementAndWindow | TinyElementAndWindow[], where: string): ElementAndWindow;
    /**
     * Ensures the input is returned as an single element/window element.
     * Useful to normalize operations across multiple or single element/window elements.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {ElementAndWindow} - Always returns an single element/window element.
     */
    _preElemAndWindow(where: string): ElementAndWindow;
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single element/window/document elements.
     *
     * @param {TinyElementAndWinAndDoc|TinyElementAndWinAndDoc[]} elems - A single element/document/window element or array of html elements.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {ElementAndWindow[]} - Always returns an array of element/document/window elements.
     */
    static _preElemsAndWinAndDoc(elems: TinyElementAndWinAndDoc | TinyElementAndWinAndDoc[], where: string): ElementAndWindow[];
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single element/window/document elements.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {ElementAndWindow[]} - Always returns an array of element/document/window elements.
     */
    _preElemsAndWinAndDoc(where: string): ElementAndWindow[];
    /**
     * Ensures the input is returned as an single element/window/document element.
     * Useful to normalize operations across multiple or single element/window/document elements.
     *
     * @param {TinyElementAndWinAndDoc|TinyElementAndWinAndDoc[]} elems - A single element/document/window element or array of html elements.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {ElementAndWindow} - Always returns an single element/document/window element.
     */
    static _preElemAndWinAndDoc(elems: TinyElementAndWinAndDoc | TinyElementAndWinAndDoc[], where: string): ElementAndWindow;
    /**
     * Ensures the input is returned as an single element/window/document element.
     * Useful to normalize operations across multiple or single element/window/document elements.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {ElementAndWindow} - Always returns an single element/document/window element.
     */
    _preElemAndWinAndDoc(where: string): ElementAndWindow;
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single element with document elements.
     *
     * @param {TinyElementWithDoc|TinyElementWithDoc[]} elems - A single element with document element or array of html elements.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {ElementWithDoc[]} - Always returns an array of element with document elements.
     */
    static _preElemsWithDoc(elems: TinyElementWithDoc | TinyElementWithDoc[], where: string): ElementWithDoc[];
    /**
     * Ensures the input is returned as an array.
     * Useful to normalize operations across multiple or single element with document elements.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {ElementWithDoc[]} - Always returns an array of element with document elements.
     */
    _preElemsWithDoc(where: string): ElementWithDoc[];
    /**
     * Ensures the input is returned as an single element with document element.
     * Useful to normalize operations across multiple or single element with document elements.
     *
     * @param {TinyElementWithDoc|TinyElementWithDoc[]} elems - A single element/window element or array of html elements.
     * @param {string} where - The method or context name where validation is being called.
     * @returns {ElementWithDoc} - Always returns an single element/window element.
     */
    static _preElemWithDoc(elems: TinyElementWithDoc | TinyElementWithDoc[], where: string): ElementWithDoc;
    /**
     * Ensures the input is returned as an single element with document element.
     * Useful to normalize operations across multiple or single element with document elements.
     *
     * @param {string} where - The method or context name where validation is being called.
     * @returns {ElementWithDoc} - Always returns an single element/window element.
     */
    _preElemWithDoc(where: string): ElementWithDoc;
    /**
     * Normalizes and converts one or more DOM elements (or TinyHtml instances)
     * into an array of `TinyHtml` instances.
     *
     * - If a plain DOM element is passed, it is wrapped into a `TinyHtml` instance.
     * - If a `TinyHtml` instance is already passed, it is preserved.
     * - If an array is passed, all elements inside are converted accordingly.
     *
     * This ensures consistent access to methods of the `TinyHtml` class regardless
     * of the input form.
     *
     * @param {TinyElement|Text|(TinyElement|Text)[]} elems - A single element or an array of elements (DOM or TinyHtml).
     * Returns the array of TinyHtml instances corresponding to the input elements.
     */
    static toTinyElm(elems: TinyElement | Text | (TinyElement | Text)[]): TinyHtml<Element | Text>[];
    /**
     * Extracts native `Element` instances from one or more elements,
     * which can be either raw DOM elements or wrapped in `TinyHtml`.
     *
     * - If a `TinyHtml` instance is passed, its internal DOM element is extracted.
     * - If a raw DOM element is passed, it is returned as-is.
     * - If an array is passed, each element is processed accordingly.
     *
     * This function guarantees that the return value is always an array of
     * raw `Element` objects, regardless of whether the input was
     * a mix of `TinyHtml` or native DOM elements.
     *
     * @param {TinyElement|TinyElement[]} elems - A single element or an array of elements (DOM or TinyHtml`).
     * @returns {Element[]} An array of Element instances extracted from the input.
     */
    static fromTinyElm(elems: TinyElement | TinyElement[]): Element[];
    /**
     * Filters an array of elements based on a selector, function, element, or array of elements.
     *
     * @param {TinyElement|TinyElement[]} elems
     * @param {WinnowRequest} qualifier
     * @param {string} where - The context/method name using this validation.
     * @param {boolean} not Whether to invert the result (used for .not())
     * @returns {Element[]}
     */
    static winnow(elems: TinyElement | TinyElement[], qualifier: WinnowRequest, where: string, not?: boolean): Element[];
    /**
     * Filters a set of elements by a CSS selector.
     *
     * @param {TinyElement|TinyElement[]} elems
     * @param {string} selector
     * @param {boolean} not
     * @returns {Element[]}
     */
    static filter(elems: TinyElement | TinyElement[], selector: string, not?: boolean): Element[];
    /**
     * Returns only the elements matching the given selector or function.
     *
     * @param {TinyElement|TinyElement[]} elems
     * @param {WinnowRequest} selector
     * @returns {Element[]}
     */
    static filterOnly(elems: TinyElement | TinyElement[], selector: WinnowRequest): Element[];
    /**
     * Returns only the elements **not** matching the given selector or function.
     *
     * @param {TinyElement|TinyElement[]} elems
     * @param {WinnowRequest} selector
     * @returns {Element[]}
     */
    static not(elems: TinyElement | TinyElement[], selector: WinnowRequest): Element[];
    /**
     * Returns only the elements **not** matching the given selector or function.
     *
     * @param {WinnowRequest} selector
     * @returns {Element[]}
     */
    not(selector: WinnowRequest): Element[];
    /**
     * Finds elements matching a selector within a context.
     *
     * @param {TinyElement|TinyElement[]} context
     * @param {string} selector
     * @returns {Element[]}
     */
    static find(context: TinyElement | TinyElement[], selector: string): Element[];
    /**
     * Finds elements in your element matching a selector within a context.
     *
     * @param {string} selector
     * @returns {Element[]}
     */
    find(selector: string): Element[];
    /**
     * Checks if at least one element matches the selector.
     *
     * @param {TinyElement|TinyElement[]} elems
     * @param {WinnowRequest} selector
     * @returns {boolean}
     */
    static is(elems: TinyElement | TinyElement[], selector: WinnowRequest): boolean;
    /**
     * Checks if the element matches the selector.
     *
     * @param {WinnowRequest} selector
     * @returns {boolean}
     */
    is(selector: WinnowRequest): boolean;
    /**
     * Returns elements from the current list that contain the given target(s).
     * @param {TinyElement|TinyElement[]} roots - A single element or an array of elements (DOM or TinyHtml).
     * @param {string|TinyElement|TinyElement[]} target - Selector or DOM element(s).
     * @returns {Element[]} Elements that contain the target.
     */
    static has(roots: TinyElement | TinyElement[], target: string | TinyElement | TinyElement[]): Element[];
    /**
     * Returns elements from the current list that contain the given target(s).
     * @param {string|TinyElement|TinyElement[]} target - Selector or DOM element(s).
     * @returns {Element[]} Elements that contain the target.
     */
    has(target: string | TinyElement | TinyElement[]): Element[];
    /**
     * Finds the closest ancestor (including self) that matches the selector.
     *
     * @param {TinyElement|TinyElement[]} els - A single element or an array of elements (DOM or TinyHtml).
     * @param {string|Element} selector - A selector string or DOM element to match.
     * @param {Element|null} [context] - An optional context to stop searching.
     * @returns {Element[]}
     */
    static closest(els: TinyElement | TinyElement[], selector: string | Element, context?: Element | null): Element[];
    /**
     * Finds the closest ancestor (including self) that matches the selector.
     *
     * @param {string|Element} selector - A selector string or DOM element to match.
     * @param {Element|null} [context] - An optional context to stop searching.
     * @returns {Element[]}
     */
    closest(selector: string | Element, context?: Element | null): Element[];
    /**
     * Compares two DOM elements to determine if they refer to the same node in the document.
     *
     * This performs a strict equality check (`===`) between the two elements.
     *
     * @param {TinyNode} elem - The first DOM element to compare.
     * @param {TinyNode} otherElem - The second DOM element to compare.
     * @returns {boolean} `true` if both elements are the same DOM node; otherwise, `false`.
     */
    static isSameDom(elem: TinyNode, otherElem: TinyNode): boolean;
    /**
     * Compares two DOM elements to determine if they refer to the same node in the document.
     *
     * This performs a strict equality check (`===`) between the two elements.
     *
     * @param {TinyNode} elem - The DOM element to compare.
     * @returns {boolean} `true` if both elements are the same DOM node; otherwise, `false`.
     */
    isSameDom(elem: TinyNode): boolean;
    /**
     * Returns a shallow copy of the internal data.
     * @type {ElementDataStore}
     */
    get _data(): ElementDataStore;
    /**
     * Replaces the internal data with a new object.
     * @param {ElementDataStore} value - Must be a non-null object.
     * @throws {Error} If the value is not a valid object.
     */
    set _data(value: ElementDataStore);
    /**
     * Internal data selectors for accessing public or private data stores.
     *
     * @type {Record<string, (where: string, elem: TinyElement) => ElementDataStore>}
     */
    static _dataSelector: Record<string, (where: string, elem: TinyElement) => ElementDataStore>;
    /**
     * Retrieves data associated with a DOM element.
     *
     * If a `key` is provided, the corresponding value is returned.
     * If no `key` is given, a shallow copy of all stored data is returned.
     *
     * @param {TinyElement} el - The DOM element.
     * @param {string|null} [key] - The specific key to retrieve from the data store.
     * @param {boolean} [isPrivate=false] - Whether to access the private data store.
     * @returns {ElementDataStore|undefined|any} - The stored value, all data, or undefined if the key doesn't exist.
     */
    static data(el: TinyElement, key?: string | null, isPrivate?: boolean): ElementDataStore | undefined | any;
    /**
     * Retrieves data associated with a DOM element.
     *
     * If a `key` is provided, the corresponding value is returned.
     * If no `key` is given, a shallow copy of all stored data is returned.
     *
     * @param {string} [key] - The specific key to retrieve from the data store.
     * @param {boolean} [isPrivate=false] - Whether to access the private data store.
     * @returns {ElementDataStore|undefined|any} - The stored value, all data, or undefined if the key doesn't exist.
     */
    data(key?: string, isPrivate?: boolean): ElementDataStore | undefined | any;
    /**
     * Stores a value associated with a specific key for a DOM element.
     *
     * @template {TinyElement} T
     * @param {T} el - The DOM element.
     * @param {string} key - The key under which the data will be stored.
     * @param {any} value - The value to store.
     * @param {boolean} [isPrivate=false] - Whether to store the data in the private store.
     * @returns {T}
     */
    static setData<T extends TinyElement>(el: T, key: string, value: any, isPrivate?: boolean): T;
    /**
     * Stores a value associated with a specific key for a DOM element.
     *
     * @param {string} key - The key under which the data will be stored.
     * @param {any} value - The value to store.
     * @param {boolean} [isPrivate=false] - Whether to store the data in the private store.
     * @returns {this}
     */
    setData(key: string, value: any, isPrivate?: boolean): this;
    /**
     * Checks if a specific key exists in the data store of a DOM element.
     *
     * @template {TinyElement} T
     * @param {T} el - The DOM element.
     * @param {string} key - The key to check.
     * @param {boolean} [isPrivate=false] - Whether to check the private store.
     * @returns {boolean}
     */
    static hasData<T extends TinyElement>(el: T, key: string, isPrivate?: boolean): boolean;
    /**
     * Checks if a specific key exists in the data store of this element.
     *
     * @param {string} key - The key to check.
     * @param {boolean} [isPrivate=false] - Whether to check the private store.
     * @returns {boolean}
     */
    hasData(key: string, isPrivate?: boolean): boolean;
    /**
     * Removes a value associated with a specific key from the data store of a DOM element.
     *
     * @param {TinyElement} el - The DOM element.
     * @param {string} key - The key to remove.
     * @param {boolean} [isPrivate=false] - Whether to remove from the private store.
     * @returns {boolean}
     */
    static removeData(el: TinyElement, key: string, isPrivate?: boolean): boolean;
    /**
     * Removes a value associated with a specific key from the data store of this element.
     *
     * @param {string} key - The key to remove.
     * @param {boolean} [isPrivate=false] - Whether to remove from the private store.
     * @returns {boolean}
     */
    removeData(key: string, isPrivate?: boolean): boolean;
    /**
     * Get the sibling element in a given direction.
     *
     * @param {TinyNode} el
     * @param {"previousSibling"|"nextSibling"} direction
     * @param {string} where
     * @returns {ChildNode|null}
     */
    static _getSibling(el: TinyNode, direction: "previousSibling" | "nextSibling", where: string): ChildNode | null;
    /**
     * Get all sibling elements excluding the given one.
     *
     * @param {Node|null} start
     * @param {Node|null} [exclude]
     * @returns {ChildNode[]}
     */
    static _getSiblings(start: Node | null, exclude?: Node | null): ChildNode[];
    /**
     * Traverse DOM in a direction collecting elements.
     *
     * @param {TinyNode} el
     * @param {"parentNode"|"nextSibling"|"previousSibling"} direction
     * @param {TinyNode|string} [until]
     * @param {string} [where='domDir']
     * @returns {ChildNode[]}
     */
    static domDir(el: TinyNode, direction: "parentNode" | "nextSibling" | "previousSibling", until?: TinyNode | string, where?: string): ChildNode[];
    /**
     * Returns the direct parent node of the given element, excluding document fragments.
     *
     * @param {TinyNode} el - The DOM node to find the parent of.
     * @returns {ParentNode|null} The parent node or null if not found.
     */
    static parent(el: TinyNode): ParentNode | null;
    /**
     * Returns the direct parent node of the given element, excluding document fragments.
     *
     * @returns {ParentNode|null} The parent node or null if not found.
     */
    parent(): ParentNode | null;
    /**
     * Returns all ancestor nodes of the given element, optionally stopping before a specific ancestor.
     *
     * @param {TinyNode} el - The DOM node to start from.
     * @param {TinyNode|string} [until] - A node or selector to stop before.
     * @returns {ChildNode[]} An array of ancestor nodes.
     */
    static parents(el: TinyNode, until?: TinyNode | string): ChildNode[];
    /**
     * Returns all ancestor nodes of the given element, optionally stopping before a specific ancestor.
     *
     * @param {TinyNode|string} [until] - A node or selector to stop before.
     * @returns {ChildNode[]} An array of ancestor nodes.
     */
    parents(until?: TinyNode | string): ChildNode[];
    /**
     * Returns the next sibling of the given element.
     *
     * @param {TinyNode} el - The DOM node to start from.
     * @returns {ChildNode|null} The next sibling or null if none found.
     */
    static next(el: TinyNode): ChildNode | null;
    /**
     * Returns the next sibling of the given element.
     *
     * @returns {ChildNode|null} The next sibling or null if none found.
     */
    next(): ChildNode | null;
    /**
     * Returns the previous sibling of the given element.
     *
     * @param {TinyNode} el - The DOM node to start from.
     * @returns {ChildNode|null} The previous sibling or null if none found.
     */
    static prev(el: TinyNode): ChildNode | null;
    /**
     * Returns the previous sibling of the given element.
     *
     * @returns {ChildNode|null} The previous sibling or null if none found.
     */
    prev(): ChildNode | null;
    /**
     * Returns all next sibling nodes after the given element.
     *
     * @param {TinyNode} el - The DOM node to start from.
     * @returns {ChildNode[]} An array of next sibling nodes.
     */
    static nextAll(el: TinyNode): ChildNode[];
    /**
     * Returns all next sibling nodes after the given element.
     *
     * @returns {ChildNode[]} An array of next sibling nodes.
     */
    nextAll(): ChildNode[];
    /**
     * Returns all previous sibling nodes before the given element.
     *
     * @param {TinyNode} el - The DOM node to start from.
     * @returns {ChildNode[]} An array of previous sibling nodes.
     */
    static prevAll(el: TinyNode): ChildNode[];
    /**
     * Returns all previous sibling nodes before the given element.
     *
     * @returns {ChildNode[]} An array of previous sibling nodes.
     */
    prevAll(): ChildNode[];
    /**
     * Returns all next sibling nodes up to (but not including) the node matched by a selector or element.
     *
     * @param {TinyNode} el - The DOM node to start from.
     * @param {TinyNode|string} [until] - A node or selector to stop before.
     * @returns {ChildNode[]} An array of next sibling nodes.
     */
    static nextUntil(el: TinyNode, until?: TinyNode | string): ChildNode[];
    /**
     * Returns all next sibling nodes up to (but not including) the node matched by a selector or element.
     *
     * @param {TinyNode|string} [until] - A node or selector to stop before.
     * @returns {ChildNode[]} An array of next sibling nodes.
     */
    nextUntil(until?: TinyNode | string): ChildNode[];
    /**
     * Returns all previous sibling nodes up to (but not including) the node matched by a selector or element.
     *
     * @param {TinyNode} el - The DOM node to start from.
     * @param {TinyNode|string} [until] - A node or selector to stop before.
     * @returns {ChildNode[]} An array of previous sibling nodes.
     */
    static prevUntil(el: TinyNode, until?: TinyNode | string): ChildNode[];
    /**
     * Returns all previous sibling nodes up to (but not including) the node matched by a selector or element.
     *
     * @param {TinyNode|string} [until] - A node or selector to stop before.
     * @returns {ChildNode[]} An array of previous sibling nodes.
     */
    prevUntil(until?: TinyNode | string): ChildNode[];
    /**
     * Returns all sibling nodes of the given element, excluding itself.
     *
     * @param {TinyNode} el - The DOM node to find siblings of.
     * @returns {ChildNode[]} An array of sibling nodes.
     */
    static siblings(el: TinyNode): ChildNode[];
    /**
     * Returns all sibling nodes of the given element, excluding itself.
     *
     * @returns {ChildNode[]} An array of sibling nodes.
     */
    siblings(): ChildNode[];
    /**
     * Returns all child nodes of the given element.
     *
     * @param {TinyNode} el - The DOM node to get children from.
     * @returns {ChildNode[]} An array of child nodes.
     */
    static children(el: TinyNode): ChildNode[];
    /**
     * Returns all child nodes of the given element.
     *
     * @returns {ChildNode[]} An array of child nodes.
     */
    children(): ChildNode[];
    /**
     * Returns the contents of the given node. For `<template>` it returns its content; for `<iframe>`, the document.
     *
     * @param {TinyNode} el - The DOM node to get contents from.
     * @returns {(ChildNode|DocumentFragment)[]|Document[]} An array of child nodes or the content document of an iframe.
     */
    static contents(el: TinyNode): (ChildNode | DocumentFragment)[] | Document[];
    /**
     * Returns the contents of the given node. For `<template>` it returns its content; for `<iframe>`, the document.
     *
     * @returns {(ChildNode|DocumentFragment)[]|Document[]} An array of child nodes or the content document of an iframe.
     */
    contents(): (ChildNode | DocumentFragment)[] | Document[];
    /**
     * Clone each element.
     * @param {TinyNode|TinyNode[]} el
     * @param {boolean} [deep=true]
     * @returns {Node[]}
     */
    static clone(el: TinyNode | TinyNode[], deep?: boolean): Node[];
    /**
     * Clone the element.
     * @param {boolean} [deep=true]
     * @returns {Node}
     */
    clone(deep?: boolean): Node;
    /**
     * Normalize and validate nodes before DOM insertion.
     * Converts TinyNode-like structures or strings into DOM-compatible nodes.
     * @type {(where: string, ...nodes: (AppendCheckerValues|Record<string, AppendCheckerValues>)[]) => (Node | string)[]}
     */
    static _appendChecker(where: string, ...nodes: (Record<string, AppendCheckerValues> | AppendCheckerValues)[]): (string | Node)[];
    /**
     * Appends child elements or strings to the end of the target element(s).
     *
     * @template {TinyElement} T
     * @param {T} el - The target element(s) to receive children.
     * @param {...(AppendCheckerValues|Record<string, AppendCheckerValues>)} children - The child elements or text to append.
     * @returns {T}
     */
    static append<T extends TinyElement>(el: T, ...children: (AppendCheckerValues | Record<string, AppendCheckerValues>)[]): T;
    /**
     * Appends child elements or strings to the end of the target element(s).
     *
     * @param {...(AppendCheckerValues|Record<string, AppendCheckerValues>)} children - The child elements or text to append.
     * @returns {this}
     */
    append(...children: (AppendCheckerValues | Record<string, AppendCheckerValues>)[]): this;
    /**
     * Prepends child elements or strings to the beginning of the target element(s).
     *
     * @template {TinyElement} T
     * @param {T} el - The target element(s) to receive children.
     * @param {...(AppendCheckerValues|Record<string, AppendCheckerValues>)} children - The child elements or text to prepend.
     * @returns {T}
     */
    static prepend<T extends TinyElement>(el: T, ...children: (AppendCheckerValues | Record<string, AppendCheckerValues>)[]): T;
    /**
     * Prepends child elements or strings to the beginning of the target element(s).
     *
     * @param {...(AppendCheckerValues|Record<string, AppendCheckerValues>)} children - The child elements or text to prepend.
     * @returns {this}
     */
    prepend(...children: (AppendCheckerValues | Record<string, AppendCheckerValues>)[]): this;
    /**
     * Inserts elements or strings immediately before the target element(s) in the DOM.
     *
     * @template {TinyElement} T
     * @param {T} el - The target element(s) before which new content is inserted.
     * @param {...(AppendCheckerValues|Record<string, AppendCheckerValues>)} children - Elements or text to insert before the target.
     * @returns {T}
     */
    static before<T extends TinyElement>(el: T, ...children: (AppendCheckerValues | Record<string, AppendCheckerValues>)[]): T;
    /**
     * Inserts elements or strings immediately before the target element(s) in the DOM.
     *
     * @param {...(AppendCheckerValues|Record<string, AppendCheckerValues>)} children - Elements or text to insert before the target.
     * @returns {this}
     */
    before(...children: (AppendCheckerValues | Record<string, AppendCheckerValues>)[]): this;
    /**
     * Inserts elements or strings immediately after the target element(s) in the DOM.
     *
     * @template {TinyElement} T
     * @param {T} el - The target element(s) after which new content is inserted.
     * @param {...(AppendCheckerValues|Record<string, AppendCheckerValues>)} children - Elements or text to insert after the target.
     * @returns {T}
     */
    static after<T extends TinyElement>(el: T, ...children: (AppendCheckerValues | Record<string, AppendCheckerValues>)[]): T;
    /**
     * Inserts elements or strings immediately after the target element(s) in the DOM.
     *
     * @param {...(AppendCheckerValues|Record<string, AppendCheckerValues>)} children - Elements or text to insert after the target.
     * @returns {this}
     */
    after(...children: (AppendCheckerValues | Record<string, AppendCheckerValues>)[]): this;
    /**
     * Replaces the target element(s) in the DOM with new elements or text.
     *
     * @template {TinyElement} T
     * @param {T} el - The element(s) to be replaced.
     * @param {...(AppendCheckerValues|Record<string, AppendCheckerValues>)} newNodes - New elements or text to replace the target.
     * @returns {T}
     */
    static replaceWith<T extends TinyElement>(el: T, ...newNodes: (AppendCheckerValues | Record<string, AppendCheckerValues>)[]): T;
    /**
     * Replaces the target element(s) in the DOM with new elements or text.
     *
     * @param {...(AppendCheckerValues|Record<string, AppendCheckerValues>)} newNodes - New elements or text to replace the target.
     * @returns {this}
     */
    replaceWith(...newNodes: (AppendCheckerValues | Record<string, AppendCheckerValues>)[]): this;
    /**
     * Appends the given element(s) to each target element in sequence.
     *
     * @template {TinyNode | TinyNode[]} T
     * @param {T} el - The element(s) to append.
     * @param {TinyNode | TinyNode[]} targets - Target element(s) where content will be appended.
     * @returns {T}
     */
    static appendTo<T extends TinyNode | TinyNode[]>(el: T, targets: TinyNode | TinyNode[]): T;
    /**
     * Appends the given element(s) to each target element in sequence.
     *
     * @param {TinyNode | TinyNode[]} targets - Target element(s) where content will be appended.
     * @returns {this}
     */
    appendTo(targets: TinyNode | TinyNode[]): this;
    /**
     * Prepends the given element(s) to each target element in sequence.
     *
     * @template {TinyElement | TinyElement[]} T
     * @param {T} el - The element(s) to prepend.
     * @param {TinyElement | TinyElement[]} targets - Target element(s) where content will be prepended.
     * @returns {T}
     */
    static prependTo<T extends TinyElement | TinyElement[]>(el: T, targets: TinyElement | TinyElement[]): T;
    /**
     * Prepends the given element(s) to each target element in sequence.
     *
     * @param {TinyElement | TinyElement[]} targets - Target element(s) where content will be prepended.
     * @returns {this}
     */
    prependTo(targets: TinyElement | TinyElement[]): this;
    /**
     * Inserts the element before a child of a given target, or before the target itself.
     *
     * @template {TinyNode | TinyNode[]} T
     * @param {T} el - The element(s) to insert.
     * @param {TinyNode | TinyNode[]} target - The reference element where insertion happens.
     * @param {TinyNode | TinyNode[] | null} [child=null] - Optional child to insert before, defaults to target.
     * @returns {T}
     */
    static insertBefore<T extends TinyNode | TinyNode[]>(el: T, target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): T;
    /**
     * Inserts the element before a child of a given target, or before the target itself.
     *
     * @param {TinyNode | TinyNode[]} target - The reference element where insertion happens.
     * @param {TinyNode | TinyNode[] | null} [child=null] - Optional child to insert before, defaults to target.
     * @returns {this}
     */
    insertBefore(target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): this;
    /**
     * Inserts the element after a child of a given target, or after the target itself.
     *
     * @template {TinyNode | TinyNode[]} T
     * @param {T} el - The element(s) to insert.
     * @param {TinyNode | TinyNode[]} target - The reference element where insertion happens.
     * @param {TinyNode | TinyNode[] | null} [child=null] - Optional child to insert after, defaults to target.
     * @returns {T}
     */
    static insertAfter<T extends TinyNode | TinyNode[]>(el: T, target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): T;
    /**
     * Inserts the element after a child of a given target, or after the target itself.
     *
     * @param {TinyNode | TinyNode[]} target - The reference element where insertion happens.
     * @param {TinyNode | TinyNode[] | null} [child=null] - Optional child to insert after, defaults to target.
     * @returns {this}
     */
    insertAfter(target: TinyNode | TinyNode[], child?: TinyNode | TinyNode[] | null): this;
    /**
     * Replaces all target elements with the provided element(s).
     * If multiple targets exist, the inserted elements are cloned accordingly.
     *
     * @template {TinyNode | TinyNode[]} T
     * @param {T} el - The new element(s) to insert.
     * @param {TinyNode | TinyNode[]} targets - The elements to be replaced.
     * @returns {T}
     */
    static replaceAll<T extends TinyNode | TinyNode[]>(el: T, targets: TinyNode | TinyNode[]): T;
    /**
     * Replaces all target elements with the provided element(s).
     * If multiple targets exist, the inserted elements are cloned accordingly.
     *
     * @param {TinyNode | TinyNode[]} targets - The elements to be replaced.
     * @returns {this}
     */
    replaceAll(targets: TinyNode | TinyNode[]): this;
    /**
     * Returns the number of elements currently stored in the internal element list.
     *
     * @returns {number} The total count of elements.
     */
    get size(): number;
    /**
     * Validates if all provided items are acceptable constructor values.
     *
     * @param {any[]|NodeListOf<Element>|HTMLCollectionOf<Element>|NodeListOf<HTMLElement>} els - The elements to validate.
     * @throws {Error} If any element is not a valid target.
     */
    static _elCheck(els: any[] | NodeListOf<Element> | HTMLCollectionOf<Element> | NodeListOf<HTMLElement>): void;
    /**
     * A new TinyHtml object containing the combined elements.
     *
     * @template {TinyHtmlConstructor} T
     * @param {T} el - The elements to add.
     * @returns {TinyHtml<TinyHtmlT|T>} The new length of the internal collection.
     */
    add<T extends TinyHtmlConstructor>(el: T): TinyHtml<TinyHtmlT | T>;
    /**
     * Resolves the given constructor input into a normalized array of elements.
     *
     * @param {TinyHtmlConstructor} el - A selector string, element, array-like collection, or array of constructor values.
     * @returns {ConstructorElValues[]} A normalized array of DOM elements/values.
     * @throws {Error} If a TinyHtml instance is passed (nesting TinyHtml inside TinyHtml is not allowed).
     * @throws {Error} If the resolved elements are not valid constructor values.
     */
    static _selector(el: TinyHtmlConstructor): ConstructorElValues[];
    /**
     * Creates an instance of TinyHtml for a specific Element.
     * Useful when you want to operate repeatedly on the same element using instance methods.
     * @param {TinyHtmlT} el - The element to wrap and manipulate.
     */
    constructor(el: TinyHtmlT);
    /**
     * Checks whether the given object is a window.
     * @param {*} obj - The object to test.
     * @returns {obj is Window} - True if it's a Window.
     */
    static isWindow(obj: any): obj is Window;
    /**
     * Returns the full computed CSS styles for the given element.
     *
     * @param {TinyElement} el - The element to retrieve styles from.
     * @returns {CSSStyleDeclaration} The computed style object for the element.
     */
    static css(el: TinyElement): CSSStyleDeclaration;
    /**
     * Returns the full computed CSS styles for the given element.
     *
     * @returns {CSSStyleDeclaration} The computed style object for the element.
     */
    css(): CSSStyleDeclaration;
    /**
     * Returns the value of a specific computed CSS property from the given element as a string.
     *
     * @param {TinyElement} el - The element to retrieve the style property from.
     * @param {string} prop - The name of the CSS property (camelCase or kebab-case).
     * @returns {string|null} The value of the CSS property as a string, or null if not found or invalid.
     */
    static cssString(el: TinyElement, prop: string): string | null;
    /**
     * Returns the value of a specific computed CSS property from the given element as a string.
     *
     * @param {string} prop - The name of the CSS property (camelCase or kebab-case).
     * @returns {string|null} The value of the CSS property as a string, or null if not found or invalid.
     */
    cssString(prop: string): string | null;
    /**
     * Returns a subset of computed CSS styles based on the given list of properties.
     *
     * @param {TinyElement} el - The element to retrieve styles from.
     * @param {string[]} prop - An array of CSS property names to retrieve.
     * @returns {Partial<CSSStyleDeclaration>} An object containing the requested styles.
     */
    static cssList(el: TinyElement, prop: string[]): Partial<CSSStyleDeclaration>;
    /**
     * Returns a subset of computed CSS styles based on the given list of properties.
     *
     * @param {string[]} prop - An array of CSS property names to retrieve.
     * @returns {Partial<CSSStyleDeclaration>} An object containing the requested styles.
     */
    cssList(prop: string[]): Partial<CSSStyleDeclaration>;
    /**
     * Returns the computed CSS float value of a property.
     * @param {TinyElement} el - The element to inspect.
     * @param {string} prop - The CSS property.
     * @returns {number} - The parsed float value.
     */
    static cssFloat(el: TinyElement, prop: string): number;
    /**
     * Returns the computed CSS float value of a property.
     * @param {string} prop - The CSS property.
     * @returns {number} - The parsed float value.
     */
    cssFloat(prop: string): number;
    /**
     * Returns computed float values of multiple CSS properties.
     * @param {TinyElement} el - The element to inspect.
     * @param {string[]} prop - An array of CSS properties.
     * @returns {Record<string, number>} - Map of property to float value.
     */
    static cssFloats(el: TinyElement, prop: string[]): Record<string, number>;
    /**
     * Returns computed float values of multiple CSS properties.
     * @param {string[]} prop - An array of CSS properties.
     * @returns {Record<string, number>} - Map of property to float value.
     */
    cssFloats(prop: string[]): Record<string, number>;
    /**
     * Public proxy to manage camelCase ➝ kebab-case CSS property aliasing.
     *
     * Modifying this object ensures that the reverse mapping in `cssPropRevAliases` is updated accordingly.
     *
     * @type {Record<string | symbol, string>}
     */
    static cssPropAliases: Record<string | symbol, string>;
    /**
     * Reverse map of `cssPropAliases`, mapping kebab-case back to camelCase CSS property names.
     *
     * This enables consistent bidirectional lookups of style properties.
     *
     * @type {Record<string | symbol, string>}
     */
    static cssPropRevAliases: Record<string | symbol, string>;
    /**
     * Converts a camelCase string to kebab-case
     * @param {string} str
     * @returns {string}
     */
    static toStyleKc(str: string): string;
    /**
     * Converts a kebab-case string to camelCase
     * @param {string} str
     * @returns {string}
     */
    static toStyleCc(str: string): string;
    /**
     * Sets one or more CSS inline style properties on the given element(s).
     *
     * - If `prop` is a string, the `value` will be applied to that property.
     * - If `prop` is an object, each key-value pair will be applied as a CSS property and value.
     *
     * @template {TinyHtmlElement|TinyHtmlElement[]} T
     * @param {T} el - The element to inspect.
     * @param {string|Object} prop - The property name or an object with key-value pairs
     * @param {string|null} [value=null] - The value to set (if `prop` is a string)
     * @returns {T}
     */
    static setStyle<T extends TinyHtmlElement | TinyHtmlElement[]>(el: T, prop: string | Object, value?: string | null): T;
    /**
     * Sets one or more CSS inline style properties on the given element(s).
     *
     * - If `prop` is a string, the `value` will be applied to that property.
     * - If `prop` is an object, each key-value pair will be applied as a CSS property and value.
     *
     * @param {string|Object} prop - The property name or an object with key-value pairs
     * @param {string|null} [value=null] - The value to set (if `prop` is a string)
     * @returns {this}
     */
    setStyle(prop: string | Object, value?: string | null): this;
    /**
     * Gets the value of a specific inline style property.
     *
     * Returns only the value set directly via the `style` attribute.
     *
     * @param {TinyHtmlElement|TinyHtmlElement[]} el - A single element to inspect.
     * @param {string} prop - The style property name to retrieve.
     * @returns {string} The style value of the specified property.
     */
    static getStyle(el: TinyHtmlElement | TinyHtmlElement[], prop: string): string;
    /**
     * Gets the value of a specific inline style property.
     *
     * Returns only the value set directly via the `style` attribute.
     *
     * @param {string} prop - The style property name to retrieve.
     * @returns {string} The style value of the specified property.
     */
    getStyle(prop: string): string;
    /**
     * Gets all inline styles defined directly on the element (`style` attribute).
     *
     * Returns an object with all property-value pairs in kebab-case format.
     *
     * @param {TinyHtmlElement|TinyHtmlElement[]} el - A single element to inspect.
     * @param {Object} [settings={}] - Optional configuration settings.
     * @param {boolean} [settings.camelCase=false] - If `true`, the property names will be converted to camelCase.
     * @param {boolean} [settings.rawAttr=false] - If `true`, reads the style string from the `style` attribute instead of using the style object.
     * @returns {Record<string, string>} All inline styles as an object.
     *
     * @throws {TypeError} If `camelCase` or `rawAttr` is not a boolean.
     */
    static style(el: TinyHtmlElement | TinyHtmlElement[], { camelCase, rawAttr }?: {
        camelCase?: boolean;
        rawAttr?: boolean;
    }): Record<string, string>;
    /**
     * Gets all inline styles defined directly on the element (`style` attribute).
     *
     * Returns an object with all property-value pairs in kebab-case format.
     *
     * @param {Object} [settings={}] - Optional configuration settings.
     * @param {boolean} [settings.camelCase=false] - If `true`, the property names will be converted to camelCase.
     * @param {boolean} [settings.rawAttr=false] - If `true`, reads the style string from the `style` attribute instead of using the style object.
     * @returns {Record<string, string>} All inline styles as an object.
     */
    style(settings?: {
        camelCase?: boolean;
        rawAttr?: boolean;
    }): Record<string, string>;
    /**
     * Removes one or more inline CSS properties from the given element(s).
     *
     * @template {TinyHtmlElement|TinyHtmlElement[]} T
     * @param {T} el - A single element or an array of elements.
     * @param {string|string[]} prop - A property name or an array of property names to remove.
     * @returns {T}
     */
    static removeStyle<T extends TinyHtmlElement | TinyHtmlElement[]>(el: T, prop: string | string[]): T;
    /**
     * Removes one or more inline CSS properties from the given element(s).
     *
     * @param {string|string[]} prop - A property name or an array of property names to remove.
     * @returns {this}
     */
    removeStyle(prop: string | string[]): this;
    /**
     * Toggles a CSS property value between two given values.
     *
     * The current computed value is compared to `val1`. If it matches, the property is set to `val2`. Otherwise, it is set to `val1`.
     *
     * @template {TinyHtmlElement|TinyHtmlElement[]} T
     * @param {T} el - A single element or an array of elements.
     * @param {string} prop - The CSS property to toggle.
     * @param {string} val1 - The first value (used as "current" check).
     * @param {string} val2 - The second value (used as the "alternative").
     * @returns {T}
     */
    static toggleStyle<T extends TinyHtmlElement | TinyHtmlElement[]>(el: T, prop: string, val1: string, val2: string): T;
    /**
     * Toggles a CSS property value between two given values.
     *
     * The current computed value is compared to `val1`. If it matches, the property is set to `val2`. Otherwise, it is set to `val1`.
     *
     * @param {string} prop - The CSS property to toggle.
     * @param {string} val1 - The first value (used as "current" check).
     * @param {string} val2 - The second value (used as the "alternative").
     * @returns {this}
     */
    toggleStyle(prop: string, val1: string, val2: string): this;
    /**
     * Removes all inline styles (`style` attribute) from the given element(s).
     *
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el - A single element or an array of elements.
     * @returns {T}
     */
    static clearStyle<T extends TinyElement | TinyElement[]>(el: T): T;
    /**
     * Removes all inline styles (`style` attribute) from the given element(s).
     * @returns {this}
     */
    clearStyle(): this;
    /**
     * Focus the element.
     *
     * @template {TinyHtmlElement} T
     * @param {T} el - The element or a selector string.
     * @returns {T}
     */
    static focus<T extends TinyHtmlElement>(el: T): T;
    /**
     * Focus the element.
     * @returns {this}
     */
    focus(): this;
    /**
     * Blur the element.
     *
     * @template {TinyHtmlElement} T
     * @param {T} el - The element or a selector string.
     * @returns {T}
     */
    static blur<T extends TinyHtmlElement>(el: T): T;
    /**
     * Blur the element.
     * @returns {this}
     */
    blur(): this;
    /**
     * Select the text content of an input or textarea element.
     *
     * @template {TinyHtmlAny|HTMLInputElement|HTMLTextAreaElement} T
     * @param {T} el - The element or a selector string.
     * @returns {T}
     */
    static select<T extends TinyHtmlAny | HTMLInputElement | HTMLTextAreaElement>(el: T): T;
    /**
     * Select the text content of an input or textarea element.
     * @returns {this}
     */
    select(): this;
    /**
     * Interprets a value as a boolean `true` if it matches a common truthy representation.
     *
     * This method checks if the input is any of the common forms used to represent `true`,
     * such as the string `'true'`, `'1'`, `'on'`, the boolean `true`, or the number `1`.
     *
     * @param {string|boolean|number} [value] - The value to interpret as boolean.
     * @returns {boolean} `true` if the value represents a truthy state, otherwise `false`.
     */
    static boolCheck(value?: string | boolean | number): boolean;
    /**
     * Sets the vertical scroll position of the window.
     * @param {number} value - Sets the scroll position.
     */
    static setWinScrollTop(value: number): void;
    /**
     * Sets the horizontal scroll position of the window.
     * @param {number} value - Sets the scroll position.
     */
    static setWinScrollLeft(value: number): void;
    /**
     * Gets the vertical scroll position of the window.
     * @returns {number} - The current scroll top value.
     */
    static winScrollTop(): number;
    /**
     * Gets the horizontal scroll position of the window.
     * @returns {number} - The current scroll left value.
     */
    static winScrollLeft(): number;
    /**
     * Returns the current height of the viewport.
     * @returns {number} - Viewport height in pixels.
     */
    static winInnerHeight(): number;
    /**
     * Returns the current width of the viewport.
     * @returns {number} - Viewport width in pixels.
     */
    static winInnerWidth(): number;
    /**
     * Checks if the page is currently scrolled to the very top.
     *
     * This method compares the current vertical scroll position with the total document height.
     * It's useful for detecting if the user has reached the top of the page.
     *
     * @returns {boolean} `true` if the page is scrolled to the top, otherwise `false`.
     */
    static isPageTop(): boolean;
    /**
     * Checks if the page is currently scrolled to the very bottom.
     *
     * This method uses the `scrollY` and `innerHeight` properties to determine if the
     * user has reached the end of the document.
     *
     * @returns {boolean} `true` if the page is scrolled to the bottom, otherwise `false`.
     */
    static isPageBottom(): boolean;
    /**
     * Gets the width or height of an element based on the box model.
     * @param {TinyElementAndWinAndDoc} el - The element or window.
     * @param {"width"|"height"} type - Dimension type.
     * @param {"content"|"padding"|"border"|"margin"} [extra='content'] - Box model context.
     * @returns {number} - Computed dimension.
     * @throws {TypeError} If `type` or `extra` is not a string.
     */
    static getDimension(el: TinyElementAndWinAndDoc, type: "width" | "height", extra?: "content" | "padding" | "border" | "margin"): number;
    /**
     * Gets the width or height of an element based on the box model.
     * @param {"width"|"height"} type - Dimension type.
     * @param {"content"|"padding"|"border"|"margin"} extra - Box model context.
     * @returns {number} - Computed dimension.
     */
    getDimension(type: "width" | "height", extra: "content" | "padding" | "border" | "margin"): number;
    /**
     * Sets the height of the element.
     * @template {TinyHtmlElement} T
     * @param {T} el - Target element.
     * @param {string|number} value - Height value.
     * @throws {TypeError} If `value` is neither a string nor number.
     * @returns {T}
     */
    static setHeight<T extends TinyHtmlElement>(el: T, value: string | number): T;
    /**
     * Sets the height of the element.
     * @param {string|number} value - Height value.
     * @returns {this}
     */
    setHeight(value: string | number): this;
    /**
     * Sets the height of the element.
     * @param {string|number} value - Height value.
     */
    set height(value: string | number);
    /**
     * Sets the width of the element.
     * @template {TinyHtmlElement} T
     * @param {T} el - Target element.
     * @param {string|number} value - Width value.
     * @throws {TypeError} If `value` is neither a string nor number.
     * @returns {T}
     */
    static setWidth<T extends TinyHtmlElement>(el: T, value: string | number): T;
    /**
     * Sets the width of the element.
     * @param {string|number} value - Width value.
     * @returns {this}
     */
    setWidth(value: string | number): this;
    /**
     * Sets the width of the element.
     * @param {string|number} value - Width value.
     */
    set width(value: string | number);
    /**
     * Returns content box height.
     * @param {TinyElementAndWinAndDoc} el - Target element.
     * @returns {number}
     */
    static height(el: TinyElementAndWinAndDoc): number;
    /**
     * Returns content box height.
     * @returns {number}
     */
    get height(): number;
    /**
     * Returns content box width.
     * @param {TinyElementAndWinAndDoc} el - Target element.
     * @returns {number}
     */
    static width(el: TinyElementAndWinAndDoc): number;
    /**
     * Returns content box width.
     * @returns {number}
     */
    get width(): number;
    /**
     * Returns padding box height.
     * @param {TinyElementAndWinAndDoc} el - Target element.
     * @returns {number}
     */
    static innerHeight(el: TinyElementAndWinAndDoc): number;
    /**
     * Returns padding box height.
     * @returns {number}
     */
    innerHeight(): number;
    /**
     * Returns padding box width.
     * @param {TinyElementAndWinAndDoc} el - Target element.
     * @returns {number}
     */
    static innerWidth(el: TinyElementAndWinAndDoc): number;
    /**
     * Returns padding box width.
     * @returns {number}
     */
    innerWidth(): number;
    /**
     * Returns outer height of the element, optionally including margin.
     * @param {TinyElementAndWinAndDoc} el - Target element.
     * @param {boolean} [includeMargin=false] - Whether to include margin.
     * @returns {number}
     */
    static outerHeight(el: TinyElementAndWinAndDoc, includeMargin?: boolean): number;
    /**
     * Returns outer height of the element, optionally including margin.
     * @param {boolean} [includeMargin=false] - Whether to include margin.
     * @returns {number}
     */
    outerHeight(includeMargin?: boolean): number;
    /**
     * Returns outer width of the element, optionally including margin.
     * @param {TinyElementAndWinAndDoc} el - Target element.
     * @param {boolean} [includeMargin=false] - Whether to include margin.
     * @returns {number}
     */
    static outerWidth(el: TinyElementAndWinAndDoc, includeMargin?: boolean): number;
    /**
     * Returns outer width of the element, optionally including margin.
     * @param {boolean} [includeMargin=false] - Whether to include margin.
     * @returns {number}
     */
    outerWidth(includeMargin?: boolean): number;
    /**
     * Gets the current display value.
     * @returns {string}
     */
    get mainDisplay(): string;
    /**
     * Sets the display value.
     * @param {string} value
     * @throws {TypeError} If the value is not a string.
     */
    set mainDisplay(value: string);
    /**
     * Gets the default display value.
     * @returns {string}
     */
    static get defaultDisplay(): string;
    /**
     * Sets the default display value.
     * @param {string} value
     * @throws {TypeError} If the value is not a string.
     */
    static set defaultDisplay(value: string);
    /**
     * Retrieves stored animation data for a given element and key.
     * If no data exists yet, initializes storage for that element.
     *
     * @param {HTMLElement} el - The element whose data should be retrieved.
     * @param {string} where - The key to read (e.g., "origHeight").
     * @returns {string|number|undefined} - The stored value, or undefined.
     */
    static getAnimateData(el: HTMLElement, where: string): string | number | undefined;
    /**
     * Stores animation data for a given element and key.
     * Used to cache original size/values for animations.
     *
     * @param {HTMLElement} el - The element whose data should be set.
     * @param {string} where - The key to store under (e.g., "origHeight").
     * @param {string|number} value - The value to store.
     */
    static setAnimateData(el: HTMLElement, where: string, value: string | number): void;
    /**
     * Returns the current global setting for cancelling old style-based animations.
     *
     * @returns {boolean} True if old animations are cancelled by default, false otherwise.
     */
    static get cancelOldStyleFx(): boolean;
    /**
     * Updates the global setting that determines whether old style-based animations
     * are cancelled before new ones start.
     *
     * @param {boolean} value - True to cancel old animations by default, false to keep them running.
     * @throws {TypeError} If the value is not a boolean.
     */
    static set cancelOldStyleFx(value: boolean);
    /**
     * Get a cloned copy of predefined animation speeds.
     * @returns {Record<string, number | KeyframeAnimationOptions>}
     */
    static get styleFxSpeeds(): Record<string, number | KeyframeAnimationOptions>;
    /**
     * Replace the predefined animation speeds.
     * @param {Record<string, number | KeyframeAnimationOptions>} speeds
     * @throws {TypeError} If input is not a valid object of speed definitions.
     */
    static set styleFxSpeeds(speeds: Record<string, number | KeyframeAnimationOptions>);
    /**
     * Get a predefined animation speed by name.
     *
     * @param {string} name - The name of the speed entry.
     * @returns {number | KeyframeAnimationOptions | undefined} A cloned value of the speed entry, or undefined if not found.
     */
    static getStyleFxSpeed(name: string): number | KeyframeAnimationOptions | undefined;
    /**
     * Set or overwrite a predefined animation speed.
     *
     * @param {string} name - The name of the speed entry.
     * @param {number | KeyframeAnimationOptions} value - The value to store.
     * @throws {TypeError} If value is not a number or KeyframeAnimationOptions object.
     */
    static setStyleFxSpeed(name: string, value: number | KeyframeAnimationOptions): void;
    /**
     * Delete a predefined animation speed by name.
     *
     * @param {string} name - The name of the speed entry to delete.
     * @returns {boolean} True if the property was deleted, false otherwise.
     */
    static deleteStyleFxSpeed(name: string): boolean;
    /**
     * Check if a predefined animation speed exists.
     *
     * @param {string} name - The name of the speed entry to check.
     * @returns {boolean} True if the speed entry exists, false otherwise.
     */
    static hasStyleFxSpeed(name: string): boolean;
    /**
     * Returns a deep-cloned copy of the registered style effects.
     *
     * @returns {Record<string, StyleEffects>}
     */
    static get styleEffects(): Record<string, StyleEffects>;
    /**
     * Replace the entire styleEffects map with a new one.
     *
     * @param {Record<string, StyleEffects>} value
     */
    static set styleEffects(value: Record<string, StyleEffects>);
    /**
     * Get a deep-cloned style effect by name.
     * @param {string} name
     * @returns {StyleEffects|undefined}
     */
    static getStyleEffect(name: string): StyleEffects | undefined;
    /**
     * Set or replace a style effect.
     * @param {string} name
     * @param {StyleEffects} value
     */
    static setStyleEffect(name: string, value: StyleEffects): void;
    /**
     * Delete a style effect.
     * @param {string} name
     * @returns {boolean} True if deleted.
     */
    static deleteStyleEffect(name: string): boolean;
    /**
     * Check if a style effect exists.
     * @param {string} name
     * @returns {boolean}
     */
    static hasStyleEffect(name: string): boolean;
    /**
     * Get a cloned copy of style inverse values.
     * @returns {Record<string, string>}
     */
    static get styleEffectInverse(): Record<string, string>;
    /**
     * Replace the style inverse values.
     * @param {Record<string, string>} values
     * @throws {TypeError} If not a valid object with functions as values.
     */
    static set styleEffectInverse(values: Record<string, string>);
    /**
     * Get a registered inverse values.
     *
     * @param {string} name - The detector name.
     * @returns {string | null} The value if found, otherwise undefined.
     */
    static getStyleEffectInverse(name: string): string | null;
    /**
     * Register or overwrite a inverse value.
     *
     * @param {string} name - The detector name.
     * @param {string} value - The inverse value.
     * @throws {TypeError} If fn is not a string.
     */
    static setStyleEffectInverse(name: string, value: string): void;
    /**
     * Delete a inverse value by name.
     *
     * @param {string} name - The inverse value name to delete.
     * @returns {boolean} True if deleted, false otherwise.
     */
    static deleteStyleEffectInverse(name: string): boolean;
    /**
     * Check if a inverse value is registered.
     *
     * @param {string} name - The inverse value name to check.
     * @returns {boolean} True if registered, false otherwise.
     */
    static hasStyleEffectInverse(name: string): boolean;
    /**
     * Get a cloned copy of style effects repeat detectors.
     * @returns {Record<string, StyleEffectsRdFn>}
     */
    static get styleEffectsRd(): Record<string, StyleEffectsRdFn>;
    /**
     * Replace the style effects repeat detectors.
     * @param {Record<string, StyleEffectsRdFn>} detectors
     * @throws {TypeError} If not a valid object with functions as values.
     */
    static set styleEffectsRd(detectors: Record<string, StyleEffectsRdFn>);
    /**
     * Get a registered repeat detector function by name.
     *
     * @param {string} name - The detector name.
     * @returns {StyleEffectsRdFn | null} The function if found, otherwise undefined.
     */
    static getStyleEffectRd(name: string): StyleEffectsRdFn | null;
    /**
     * Register or overwrite a repeat detector function.
     *
     * @param {string} name - The detector name.
     * @param {StyleEffectsRdFn} fn - The detector function.
     * @throws {TypeError} If fn is not a function.
     */
    static setStyleEffectRd(name: string, fn: StyleEffectsRdFn): void;
    /**
     * Delete a repeat detector function by name.
     *
     * @param {string} name - The detector name to delete.
     * @returns {boolean} True if deleted, false otherwise.
     */
    static deleteStyleEffectRd(name: string): boolean;
    /**
     * Check if a repeat detector function is registered.
     *
     * @param {string} name - The detector name to check.
     * @returns {boolean} True if registered, false otherwise.
     */
    static hasStyleEffectRd(name: string): boolean;
    /**
     * Returns a shallow-cloned copy of the property effect handlers.
     *
     * @returns {StyleEffectsProps}
     */
    static get styleEffectsProps(): StyleEffectsProps;
    /**
     * Replace the entire styleEffectsProps map with a new one.
     *
     * @param {StyleEffectsProps} value
     */
    static set styleEffectsProps(value: StyleEffectsProps);
    /**
     * Get a style effect property handler by name.
     *
     * @param {string} name - The property handler name.
     * @returns {StyleEffectsFn | null} The handler function, or undefined if not found.
     */
    static getStyleEffectProp(name: string): StyleEffectsFn | null;
    /**
     * Register or overwrite a style effect property handler.
     *
     * @param {string} name - The property handler name.
     * @param {StyleEffectsFn} fn - The handler function.
     * @throws {TypeError} If fn is not a function.
     */
    static setStyleEffectProp(name: string, fn: StyleEffectsFn): void;
    /**
     * Delete a style effect property handler by name.
     *
     * @param {string} name - The property handler name to delete.
     * @returns {boolean} True if deleted, false otherwise.
     */
    static deleteStyleEffectProp(name: string): boolean;
    /**
     * Check if a style effect property handler exists.
     *
     * @param {string} name - The property handler name to check.
     * @returns {boolean} True if the handler exists, false otherwise.
     */
    static hasStyleEffectProp(name: string): boolean;
    /**
     * Generates effect parameters to create standard animations.
     *
     * @param {string} type - The effect type.
     * @param {boolean} [includeWidth=false] - Whether width (and opacity) should be included.
     * @returns {Record<string, string>} - A mapping of CSS properties to effect type.
     */
    static genStyleFx(type: string, includeWidth?: boolean): Record<string, string>;
    /**
     * Applies style-based effects (slide, fade) to one or more elements.
     * Converts abstract effect definitions (e.g., `{ height: "show" }`)
     * into concrete Web Animations API keyframes.
     *
     * @param {TinyHtmlElement|TinyHtmlElement[]} el - A single element or an array of elements.
     * @param {string} id - The style effect id.
     * @param {StyleEffects} props - The style effect definition.
     * @param {number | KeyframeAnimationOptions | string} [ops] - Timing options.
     * @returns {StyleFxResult}
     */
    static applyStyleFx(el: TinyHtmlElement | TinyHtmlElement[], id: string, props: StyleEffects, ops?: number | KeyframeAnimationOptions | string): StyleFxResult;
    /**
     * Applies style-based effects (slide, fade) to one or more elements.
     * Converts abstract effect definitions (e.g., `{ height: "show" }`)
     * into concrete Web Animations API keyframes.
     *
     * @param {string} id - The style effect id.
     * @param {StyleEffects} props - The style effect definition.
     * @param {number | KeyframeAnimationOptions} [ops] - Timing options.
     * @returns {StyleFxResult}
     */
    applyStyleFx(id: string, props: StyleEffects, ops?: number | KeyframeAnimationOptions): StyleFxResult;
    /**
     * Get the current animation entry for a given element.
     * @param {HTMLElement} el - The target element.
     * @returns {string|null|undefined} Returns string or null to animation.
     */
    static getCurrentAnimationId(el: HTMLElement): string | null | undefined;
    /**
     * Applies an animation to one or multiple TinyElement instances.
     *
     * If `cancelOldAnim` is true, any currently running animation on the same element
     * will be cancelled before the new one starts.
     *
     * @param {TinyHtmlElement|TinyHtmlElement[]} el - A single TinyElement or an array of TinyElements to animate.
     * @param {Keyframe[] | PropertyIndexedKeyframes | null} keyframes - Keyframes that define the animation.
     * @param {number | KeyframeAnimationOptions | string} [ops] - Timing or configuration options for the animation.
     * @param {string|null} [id] - The style effect id.
     * @param {boolean} [cancelOldAnim=TinyHtml.cancelOldStyleFx] - Whether to cancel previous animations on the same element.
     * @returns {Animation[]}
     */
    static animate(el: TinyHtmlElement | TinyHtmlElement[], keyframes: Keyframe[] | PropertyIndexedKeyframes | null, ops?: number | KeyframeAnimationOptions | string, id?: string | null, cancelOldAnim?: boolean): Animation[];
    /**
     * Applies an animation to one or multiple TinyElement instances.
     *
     * If `cancelOldAnim` is true, any currently running animation on the same element
     * will be cancelled before the new one starts.
     *
     * @param {Keyframe[] | PropertyIndexedKeyframes | null} keyframes - Keyframes that define the animation.
     * @param {number | KeyframeAnimationOptions | string} [ops] - Timing or configuration options for the animation.
     * @param {string|null} [id] - The style effect id.
     * @param {boolean} [cancelOldAnim=TinyHtml.cancelOldStyleFx] - Whether to cancel previous animations on the same element.
     * @returns {Animation[]}
     */
    animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, ops?: number | KeyframeAnimationOptions | string, id?: string | null, cancelOldAnim?: boolean): Animation[];
    /**
     * Stops the current animation(s) on one or multiple TinyElement instances.
     *
     * If an animation is running on the element(s), it will be cancelled immediately.
     *
     * @param {TinyHtmlElement|TinyHtmlElement[]} el - A single TinyElement or an array of TinyElements.
     * @returns {boolean[]} The same element(s) provided as input, for chaining.
     */
    static stop(el: TinyHtmlElement | TinyHtmlElement[]): boolean[];
    /**
     * Stops the current animation(s) on this TinyElement instance.
     *
     * @returns {boolean[]}
     */
    stop(): boolean[];
    /**
     * Show animation (slideDown).
     * @param {TinyHtmlElement|TinyHtmlElement[]} el
     * @param {number | KeyframeAnimationOptions | string} [ops]
     * @returns {StyleFxResult}
     */
    static slideDown(el: TinyHtmlElement | TinyHtmlElement[], ops?: number | KeyframeAnimationOptions | string): StyleFxResult;
    /**
     * Show animation (slideDown).
     * @param {number | KeyframeAnimationOptions | string} [ops]
     * @returns {StyleFxResult}
     */
    slideDown(ops?: number | KeyframeAnimationOptions | string): StyleFxResult;
    /**
     * Hide animation (slideUp).
     * @param {TinyHtmlElement|TinyHtmlElement[]} el
     * @param {number | KeyframeAnimationOptions | string} [ops]
     * @returns {StyleFxResult}
     */
    static slideUp(el: TinyHtmlElement | TinyHtmlElement[], ops?: number | KeyframeAnimationOptions | string): StyleFxResult;
    /**
     * Hide animation (slideUp).
     * @param {number | KeyframeAnimationOptions | string} [ops]
     * @returns {StyleFxResult}
     */
    slideUp(ops?: number | KeyframeAnimationOptions | string): StyleFxResult;
    /**
     * Toggle slide animation.
     * @param {TinyHtmlElement|TinyHtmlElement[]} el
     * @param {number | KeyframeAnimationOptions | string} [ops]
     * @returns {StyleFxResult}
     */
    static slideToggle(el: TinyHtmlElement | TinyHtmlElement[], ops?: number | KeyframeAnimationOptions | string): StyleFxResult;
    /**
     * Toggle slide animation.
     * @param {number | KeyframeAnimationOptions | string} [ops]
     * @returns {StyleFxResult}
     */
    slideToggle(ops?: number | KeyframeAnimationOptions | string): StyleFxResult;
    /**
     * Fade in animation.
     * @param {TinyHtmlElement|TinyHtmlElement[]} el
     * @param {number | KeyframeAnimationOptions | string} [ops]
     * @returns {StyleFxResult}
     */
    static fadeIn(el: TinyHtmlElement | TinyHtmlElement[], ops?: number | KeyframeAnimationOptions | string): StyleFxResult;
    /**
     * Fade in animation.
     * @param {number | KeyframeAnimationOptions | string} [ops]
     * @returns {StyleFxResult}
     */
    fadeIn(ops?: number | KeyframeAnimationOptions | string): StyleFxResult;
    /**
     * Fade out animation.
     * @param {TinyHtmlElement|TinyHtmlElement[]} el
     * @param {number | KeyframeAnimationOptions | string} [ops]
     * @returns {StyleFxResult}
     */
    static fadeOut(el: TinyHtmlElement | TinyHtmlElement[], ops?: number | KeyframeAnimationOptions | string): StyleFxResult;
    /**
     * Fade out animation.
     * @param {number | KeyframeAnimationOptions | string} [ops]
     * @returns {StyleFxResult}
     */
    fadeOut(ops?: number | KeyframeAnimationOptions | string): StyleFxResult;
    /**
     * Fade toggle animation.
     * @param {TinyHtmlElement|TinyHtmlElement[]} el
     * @param {number | KeyframeAnimationOptions | string} [ops]
     * @returns {StyleFxResult}
     */
    static fadeToggle(el: TinyHtmlElement | TinyHtmlElement[], ops?: number | KeyframeAnimationOptions | string): StyleFxResult;
    /**
     * Fade toggle animation.
     * @param {number | KeyframeAnimationOptions | string} [ops]
     * @returns {StyleFxResult}
     */
    fadeToggle(ops?: number | KeyframeAnimationOptions | string): StyleFxResult;
    /**
     * Animate the opacity of elements to a target value.
     * If the element is hidden (display:none), it will be made visible first
     * so the fade animation can occur.
     *
     * @param {TinyHtmlElement|TinyHtmlElement[]} el - Target element(s) to fade.
     * @param {number} opacity - Final opacity value (between 0 and 1).
     * @param {number | KeyframeAnimationOptions | string} [ops] - Duration or animation options.
     * @param {string} [mainDisplay=TinyHtml.#defaultDisplay] - Sets the main display value.
     * @returns {StyleFxResult}
     * @throws {TypeError} If opacity is not a number between 0 and 1.
     * @throws {TypeError} If ops is not number|string|object when provided.
     */
    static fadeTo(el: TinyHtmlElement | TinyHtmlElement[], opacity: number, ops?: number | KeyframeAnimationOptions | string, mainDisplay?: string): StyleFxResult;
    /**
     * Animate the opacity of elements to a target value.
     * If the element is hidden (display:none), it will be made visible first
     * so the fade animation can occur.
     *
     * @param {number} opacity - Final opacity value (between 0 and 1).
     * @param {number | KeyframeAnimationOptions | string} [ops] - Duration or animation options.
     * @param {string} [mainDisplay=this.#mainDisplay] - Sets the main display value.
     * @returns {StyleFxResult}
     * @throws {TypeError} If opacity is not a number between 0 and 1.
     * @throws {TypeError} If ops is not number|string|object when provided.
     */
    fadeTo(opacity: number, ops?: number | KeyframeAnimationOptions | string, mainDisplay?: string): StyleFxResult;
    /**
     * Gets the offset of the element relative to the document.
     * @param {TinyElement} el - Target element.
     * @returns {{top: number, left: number}}
     */
    static offset(el: TinyElement): {
        top: number;
        left: number;
    };
    /**
     * Gets the offset of the element relative to the document.
     * @returns {{top: number, left: number}}
     */
    offset(): {
        top: number;
        left: number;
    };
    /**
     * Gets the position of the element relative to its offset parent.
     * @param {TinyHtmlElement} el - Target element.
     * @returns {{top: number, left: number}}
     */
    static position(el: TinyHtmlElement): {
        top: number;
        left: number;
    };
    /**
     * Gets the position of the element relative to its offset parent.
     * @returns {{top: number, left: number}}
     */
    position(): {
        top: number;
        left: number;
    };
    /**
     * Gets the closest positioned ancestor element.
     * @param {TinyHtmlElement} el - Target element.
     * @returns {HTMLElement} - Offset parent element.
     */
    static offsetParent(el: TinyHtmlElement): HTMLElement;
    /**
     * Gets the closest positioned ancestor element.
     * @returns {HTMLElement} - Offset parent element.
     */
    offsetParent(): HTMLElement;
    /**
     * Gets the vertical scroll position.
     * @param {TinyElementAndWindow} el - Element or window.
     * @returns {number}
     */
    static scrollTop(el: TinyElementAndWindow): number;
    /**
     * Gets the vertical scroll position.
     * @returns {number}
     */
    scrollTop(): number;
    /**
     * Gets the horizontal scroll position.
     * @param {TinyElementAndWindow} el - Element or window.
     * @returns {number}
     */
    static scrollLeft(el: TinyElementAndWindow): number;
    /**
     * Gets the horizontal scroll position.
     * @returns {number}
     */
    scrollLeft(): number;
    /**
     * Collection of easing functions used for scroll and animation calculations.
     * Each function receives a normalized time value (`t` from 0 to 1) and returns the eased progress.
     *
     * @type {Record<string, (t: number) => number>}
     */
    static easings: Record<string, (t: number) => number>;
    /**
     * Smoothly scrolls one or more elements (or the window) to the specified X and Y coordinates
     * using a custom duration and easing function.
     *
     * If `duration` or a valid `easing` is not provided, the scroll will be performed immediately.
     *
     * @template {TinyElementAndWindow|TinyElementAndWindow[]} T
     * @param {T} el - A single element, array of elements, or the window to scroll.
     * @param {Object} [settings={}] - Configuration object for the scroll animation.
     * @param {number} [settings.targetX] - The horizontal scroll target in pixels.
     * @param {number} [settings.targetY] - The vertical scroll target in pixels.
     * @param {number} [settings.duration] - The duration of the animation in milliseconds.
     * @param {Easings} [settings.easing] - The easing function name to use for the scroll animation.
     * @param {OnScrollAnimation} [settings.onAnimation] - Optional callback invoked on each animation
     *   frame with the current scroll position, normalized animation time (`0` to `1`), and a completion flag.
     * @returns {T}
     * @throws {TypeError} If `el` is not a valid element, array, or window.
     * @throws {TypeError} If `targetX` or `targetY` is defined but not a number.
     * @throws {TypeError} If `duration` is defined but not a number.
     * @throws {TypeError} If `easing` is defined but not a valid easing function name.
     * @throws {TypeError} If `onAnimation` is defined but not a function.
     */
    static scrollToXY<T extends TinyElementAndWindow | TinyElementAndWindow[]>(el: T, { targetX, targetY, duration, easing, onAnimation }?: {
        targetX?: number;
        targetY?: number;
        duration?: number;
        easing?: Easings;
        onAnimation?: OnScrollAnimation;
    }): T;
    /**
     * Smoothly scrolls one or more elements (or the window) to the specified X and Y coordinates
     * using a custom duration and easing function.
     *
     * If `duration` or a valid `easing` is not provided, the scroll will be performed immediately.
     *
     * @param {Object} [settings={}] - Configuration object for the scroll animation.
     * @param {number} [settings.targetX] - The horizontal scroll target in pixels.
     * @param {number} [settings.targetY] - The vertical scroll target in pixels.
     * @param {number} [settings.duration] - The duration of the animation in milliseconds.
     * @param {Easings} [settings.easing] - The easing function name to use for the scroll animation.
     * @param {OnScrollAnimation} [settings.onAnimation] - Optional callback invoked on each animation
     *   frame with the current scroll position, normalized animation time (`0` to `1`), and a completion flag.
     * @returns {this}
     */
    scrollToXY({ targetX, targetY, duration, easing, onAnimation }?: {
        targetX?: number;
        targetY?: number;
        duration?: number;
        easing?: Easings;
        onAnimation?: OnScrollAnimation;
    }): this;
    /**
     * Sets the vertical scroll position.
     * @template {TinyElementAndWindow|TinyElementAndWindow[]} T
     * @param {T} el - Element or window.
     * @param {number} value - Scroll top value.
     * @returns {T}
     */
    static setScrollTop<T extends TinyElementAndWindow | TinyElementAndWindow[]>(el: T, value: number): T;
    /**
     * Sets the vertical scroll position.
     * @param {number} value - Scroll top value.
     * @returns {this}
     */
    setScrollTop(value: number): this;
    /**
     * Sets the horizontal scroll position.
     * @template {TinyElementAndWindow|TinyElementAndWindow[]} T
     * @param {T} el - Element or window.
     * @param {number} value - Scroll left value.
     * @returns {T}
     */
    static setScrollLeft<T extends TinyElementAndWindow | TinyElementAndWindow[]>(el: T, value: number): T;
    /**
     * Sets the horizontal scroll position.
     * @param {number} value - Scroll left value.
     * @returns {this}
     */
    setScrollLeft(value: number): this;
    /**
     * Returns the total border width and individual sides from `border{Side}Width` CSS properties.
     *
     * @param {TinyElement} el - The target DOM element.
     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border widths, and each side individually.
     */
    static borderWidth(el: TinyElement): HtmlElBoxSides;
    /**
     * Returns the total border width and individual sides from `border{Side}Width` CSS properties.
     *
     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border widths, and each side individually.
     */
    borderWidth(): HtmlElBoxSides;
    /**
     * Returns the total border size and individual sides from `border{Side}` CSS properties.
     *
     * @param {TinyElement} el - The target DOM element.
     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border sizes, and each side individually.
     */
    static border(el: TinyElement): HtmlElBoxSides;
    /**
     * Returns the total border size and individual sides from `border{Side}` CSS properties.
     *
     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) border sizes, and each side individually.
     */
    border(): HtmlElBoxSides;
    /**
     * Returns the total margin and individual sides from `margin{Side}` CSS properties.
     *
     * @param {TinyElement} el - The target DOM element.
     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) margins, and each side individually.
     */
    static margin(el: TinyElement): HtmlElBoxSides;
    /**
     * Returns the total margin and individual sides from `margin{Side}` CSS properties.
     *
     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) margins, and each side individually.
     */
    margin(): HtmlElBoxSides;
    /**
     * Returns the total padding and individual sides from `padding{Side}` CSS properties.
     *
     * @param {TinyElement} el - The target DOM element.
     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) paddings, and each side individually.
     */
    static padding(el: TinyElement): HtmlElBoxSides;
    /**
     * Returns the total padding and individual sides from `padding{Side}` CSS properties.
     *
     * @returns {HtmlElBoxSides} - Total horizontal (x) and vertical (y) paddings, and each side individually.
     */
    padding(): HtmlElBoxSides;
    /**
     * Gets the value of classCanWhitespace.
     * @returns {boolean}
     */
    static get classCanWhitespace(): boolean;
    /**
     * Sets the value of classCanWhitespace.
     * @param {boolean} value
     */
    static set classCanWhitespace(value: boolean);
    /**
     * Adds one or more CSS class names to the element.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {...string} args - One or more class names to add.
     * @returns {T}
     */
    static addClass<T extends TinyElement | TinyElement[]>(el: T, ...args: string[]): T;
    /**
     * Adds one or more CSS class names to the element.
     * @param {...string} args - One or more class names to add.
     * @returns {this}
     */
    addClass(...args: string[]): this;
    /**
     * Removes one or more CSS class names from the element.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {...string} args - One or more class names to remove.
     * @returns {T}
     */
    static removeClass<T extends TinyElement | TinyElement[]>(el: T, ...args: string[]): T;
    /**
     * Removes one or more CSS class names from the element.
     * @param {...string} args - One or more class names to remove.
     * @returns {this}
     */
    removeClass(...args: string[]): this;
    /**
     * Replaces an existing class name with a new one.
     * @param {TinyElement|TinyElement[]} el - Target element.
     * @param {string} token - The class name to be replaced.
     * @param {string} newToken - The new class name to apply.
     * @returns {boolean[]} Whether the replacement was successful.
     * @throws {TypeError} If either argument is not a string.
     */
    static replaceClass(el: TinyElement | TinyElement[], token: string, newToken: string): boolean[];
    /**
     * Replaces an existing class name with a new one.
     * @param {string} token - The class name to be replaced.
     * @param {string} newToken - The new class name to apply.
     * @returns {boolean} Whether the replacement was successful.
     * @throws {TypeError} If either argument is not a string.
     */
    replaceClass(token: string, newToken: string): boolean;
    /**
     * Returns the class name at the specified index.
     * @param {TinyElement} el - Target element.
     * @param {number} index - The index of the class name.
     * @returns {string|null} The class name at the index or null if not found.
     * @throws {TypeError} If the index is not a number.
     */
    static classItem(el: TinyElement, index: number): string | null;
    /**
     * Returns the class name at the specified index.
     * @param {number} index - The index of the class name.
     * @returns {string|null} The class name at the index or null if not found.
     * @throws {TypeError} If the index is not a number.
     */
    classItem(index: number): string | null;
    /**
     * Toggles a class name on the element with an optional force boolean.
     * @param {TinyElement|TinyElement[]} el - Target element.
     * @param {string} token - The class name to toggle.
     * @param {boolean} [force] - If true, adds the class; if false, removes it.
     * @returns {boolean[]} Whether the class is present after the toggle.
     * @throws {TypeError} If token is not a string or force is not a boolean.
     */
    static toggleClass(el: TinyElement | TinyElement[], token: string, force?: boolean): boolean[];
    /**
     * Toggles a class name on the element with an optional force boolean.
     * @param {string} token - The class name to toggle.
     * @param {boolean} force - If true, adds the class; if false, removes it.
     * @returns {boolean} Whether the class is present after the toggle.
     * @throws {TypeError} If token is not a string or force is not a boolean.
     */
    toggleClass(token: string, force: boolean): boolean;
    /**
     * Checks if the element contains the given class name.
     * @param {TinyElement} el - Target element.
     * @param {string} token - The class name to check.
     * @returns {boolean} True if the class is present, false otherwise.
     * @throws {TypeError} If token is not a string.
     */
    static hasClass(el: TinyElement, token: string): boolean;
    /**
     * Checks if the element contains the given class name.
     * @param {string} token - The class name to check.
     * @returns {boolean} True if the class is present, false otherwise.
     * @throws {TypeError} If token is not a string.
     */
    hasClass(token: string): boolean;
    /**
     * Returns the number of classes applied to the element.
     * @param {TinyElement} el - Target element.
     * @returns {number} The number of classes.
     */
    static classLength(el: TinyElement): number;
    /**
     * Returns the number of classes applied to the element.
     * @returns {number} The number of classes.
     */
    classLength(): number;
    /**
     * Returns all class names as an array of strings.
     * @param {TinyElement} el - Target element.
     * @returns {string[]} An array of class names.
     */
    static classList(el: TinyElement): string[];
    /**
     * Returns all class names as an array of strings.
     * @returns {string[]} An array of class names.
     */
    classList(): string[];
    /**
     * Returns the tag name of the element.
     * @param {TinyElement} el - Target element.
     * @returns {string} The tag name in uppercase.
     */
    static tagName(el: TinyElement): string;
    /**
     * Returns the tag name of the element.
     * @returns {string} The tag name in uppercase.
     */
    tagName(): string;
    /**
     * Returns the ID of the element.
     * @param {TinyElement} el - Target element.
     * @returns {string} The element's ID.
     */
    static id(el: TinyElement): string;
    /**
     * Returns the ID of the element.
     * @returns {string} The element's ID.
     */
    get id(): string;
    /**
     * Set the id on an element.
     * @param {string} value - Id name.
     */
    set id(value: string);
    /**
     * Returns the BigInt content of the element.
     * @param {TinyElement} el - Target element.
     * @returns {bigint|null} The BigInt content or null if none.
     */
    static toBigInt(el: TinyElement): bigint | null;
    /**
     * Returns the BigInt content of the element.
     * @returns {bigint|null}
     */
    toBigInt(): bigint | null;
    /**
     * Set BigInt content of elements.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {bigint} value
     * @returns {T}
     */
    static setBigInt<T extends TinyElement | TinyElement[]>(el: T, value: bigint): T;
    /**
     * Set BigInt content of the element.
     * @param {bigint} value
     * @returns {this}
     */
    setBigInt(value: bigint): this;
    /**
     * Returns the Date content of the element.
     * @param {TinyElement} el - Target element.
     * @returns {Date|null} The Date content or null if invalid.
     */
    static toDate(el: TinyElement): Date | null;
    /**
     * Returns the Date content of the element.
     * @returns {Date|null}
     */
    toDate(): Date | null;
    /**
     * Set Date content of elements.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {Date} value
     * @returns {T}
     */
    static setDate<T extends TinyElement | TinyElement[]>(el: T, value: Date): T;
    /**
     * Set Date content of the element.
     * @param {Date} value
     * @returns {this}
     */
    setDate(value: Date): this;
    /**
     * Returns the JSON content of the element.
     * @param {TinyElement} el - Target element.
     * @returns {any|null} The parsed JSON content or null if invalid.
     */
    static toJson(el: TinyElement): any | null;
    /**
     * Returns the JSON content of the element.
     * @returns {any|null}
     */
    toJson(): any | null;
    /**
     * Set JSON content of elements.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {any} value - A JavaScript value, usually an object or array, to be converted.
     * @param {(this: any, key: string, value: any) => any} [replacer] - A function that transforms the results.
     * @param {number|string} [space] - Indentation level or string for formatting.
     * @returns {T}
     */
    static setJson<T extends TinyElement | TinyElement[]>(el: T, value: any, replacer?: (this: any, key: string, value: any) => any, space?: number | string): T;
    /**
     * Set JSON content of the element.
     * @param {any} value - A JavaScript value, usually an object or array, to be converted.
     * @param {(this: any, key: string, value: any) => any} [replacer] - A function that transforms the results.
     * @param {number|string} [space] - Indentation level or string for formatting.
     * @returns {this}
     */
    setJson(value: any, replacer?: (this: any, key: string, value: any) => any, space?: number | string): this;
    /**
     * Returns the number content of the element.
     * @param {TinyElement} el - Target element.
     * @returns {number|null} The text content or null if none.
     */
    static toNumber(el: TinyElement): number | null;
    /**
     * Returns the number content of the element.
     * @returns {number|null} The text content or null if none.
     */
    toNumber(): number | null;
    /**
     * Set number content of elements.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {number} value
     * @returns {T}
     */
    static setNumber<T extends TinyElement | TinyElement[]>(el: T, value: number): T;
    /**
     * Set number content of the element.
     * @param {number} value
     * @returns {this}
     */
    setNumber(value: number): this;
    /**
     * Returns the boolean content of the element.
     * @param {TinyElement} el - Target element.
     * @returns {boolean|null} The boolean value or null if empty.
     */
    static toBoolean(el: TinyElement): boolean | null;
    /**
     * Returns the boolean content of the element.
     * @returns {boolean|null}
     */
    toBoolean(): boolean | null;
    /**
     * Set boolean content of elements.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {boolean} value
     * @returns {T}
     */
    static setBoolean<T extends TinyElement | TinyElement[]>(el: T, value: boolean): T;
    /**
     * Set boolean content of the element.
     * @param {boolean} value
     * @returns {this}
     */
    setBoolean(value: boolean): this;
    /**
     * Returns the string content of the element.
     * @param {TinyElement} el - Target element.
     * @returns {string|null} The string content or null if none.
     */
    static toString(el: TinyElement): string | null;
    /**
     * Returns the string content of the element.
     * @returns {string|null} The string content or null if none.
     */
    toString(): string | null;
    /**
     * Set string content of elements.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {string} value
     * @returns {T}
     */
    static setString<T extends TinyElement | TinyElement[]>(el: T, value: string): T;
    /**
     * Set string content of the element.
     * @param {string} value
     * @returns {this}
     */
    setString(value: string): this;
    /**
     * Returns the text content of the element.
     * @param {TinyElement} el - Target element.
     * @returns {string|null} The text content or null if none.
     */
    static text(el: TinyElement): string | null;
    /**
     * Returns the text content of the element.
     * @returns {string|null} The text content or null if none.
     */
    text(): string | null;
    /**
     * Set text content of elements.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {*} value
     * @returns {T}
     */
    static setText<T extends TinyElement | TinyElement[]>(el: T, value: any): T;
    /**
     * Set text content of the element.
     * @param {*} value
     * @returns {this}
     */
    setText(value: any): this;
    /**
     * Remove all child nodes from each element.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @returns {T}
     */
    static empty<T extends TinyElement | TinyElement[]>(el: T): T;
    /**
     * Remove all child nodes of the element.
     * @returns {this}
     */
    empty(): this;
    /**
     * Get the innerHTML of the element.
     * @param {TinyElement} el
     * @param {GetHTMLOptions} [ops]
     * @returns {string}
     */
    static html(el: TinyElement, ops?: GetHTMLOptions): string;
    /**
     * Get the innerHTML of the element.
     * @param {GetHTMLOptions} [ops]
     * @returns {string}
     */
    html(ops?: GetHTMLOptions): string;
    /**
     * Set the innerHTML of each element.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {string} value
     * @returns {T}
     */
    static setHtml<T extends TinyElement | TinyElement[]>(el: T, value: string): T;
    /**
     * Set the innerHTML of the element.
     * @param {string} value
     * @returns {this}
     */
    setHtml(value: string): this;
    static _valHooks: {
        option: {
            /**
             * @param {HTMLOptionElement} elem
             * @returns {string|null}
             */
            get: (elem: HTMLOptionElement) => string | null;
        };
        select: {
            /**
             * @param {HTMLSelectElement} elem
             * @returns {(string | null)[] | string | null}
             */
            get: (elem: HTMLSelectElement) => (string | null)[] | string | null;
            /**
             * @param {HTMLSelectElement} elem
             * @param {string[]|string} value
             */
            set: (elem: HTMLSelectElement, value: string[] | string) => string[];
        };
        radio: {
            /**
             * @param {HTMLInputElement} elem
             * @returns {string}
             */
            get(elem: HTMLInputElement): string;
            /**
             * @param {HTMLInputElement} elem
             * @param {string[]} value
             */
            set(elem: HTMLInputElement, value: string[]): undefined;
        };
        checkbox: {
            /**
             * @param {HTMLInputElement} elem
             * @returns {string}
             */
            get(elem: HTMLInputElement): string;
            /**
             * @param {HTMLInputElement} elem
             * @param {boolean} value
             */
            set(elem: HTMLInputElement, value: boolean): boolean | undefined;
        };
    };
    /**
     * Sets the value of the current HTML value element (input, select, textarea, etc.).
     * Accepts strings, numbers, booleans or arrays of these values, or a callback function that computes them.
     *
     * @template {TinyInputElement|TinyInputElement[]} T
     * @param {T} el - Target element.
     * @param {SetValueList|((el: InputElement, val: SetValueList) => SetValueList)} value - The value to assign or a function that returns it.
     * @throws {Error} If the computed value is not a valid string or boolean.
     * @returns {T}
     */
    static setVal<T extends TinyInputElement | TinyInputElement[]>(el: T, value: SetValueList | ((el: InputElement, val: SetValueList) => SetValueList)): T;
    /**
     * Sets the value of the current HTML value element (input, select, textarea, etc.).
     * Accepts strings, numbers, booleans or arrays of these values, or a callback function that computes them.
     *
     * @param {SetValueList|((el: InputElement, val: SetValueList) => SetValueList)} value - The value to assign or a function that returns it.
     * @returns {this}
     * @throws {Error} If the computed value is not a valid string or boolean.
     */
    setVal(value: SetValueList | ((el: InputElement, val: SetValueList) => SetValueList)): this;
    /**
     * Maps value types to their corresponding getter functions.
     * Each function extracts a value of a specific type from a compatible HTMLInputElement.
     */
    static _valTypes: {
        /**
         * Gets the string value from any HTMLInputElement.
         * @type {(elem: HTMLInputElement) => string}
         */
        string: (elem: HTMLInputElement) => string;
        /**
         * Gets the value as a Date object from supported input types.
         * Valid only for types: "date", "datetime-local", "month", "time", "week".
         * Returns `null` if the field is empty or invalid.
         * @type {(elem: HTMLInputElement & { type: "date" | "datetime-local" | "month" | "time" | "week" }) => Date | null}
         */
        date: (elem: HTMLInputElement & {
            type: "date" | "datetime-local" | "month" | "time" | "week";
        }) => Date | null;
        /**
         * Gets the numeric value from supported input types.
         * Valid for types: "number", "range", "date", "time".
         * Returns `NaN` if the value is invalid or empty.
         * @type {(elem: HTMLInputElement & { type: "number" | "range" | "date" | "time" }) => number}
         */
        number: (elem: HTMLInputElement & {
            type: "number" | "range" | "date" | "time";
        }) => number;
    };
    /**
     * Gets the value of an input element according to the specified type.
     *
     * @param {InputElement} elem - The input element to extract the value from.
     * @param {GetValueTypes} type - The type of value to retrieve ("string", "date", or "number").
     * @param {string} where - The context/method name using this validation.
     * @returns {any} The extracted value, depending on the type.
     * @throws {Error} If the element is not an HTMLInputElement or if the type handler is invalid.
     */
    static _getValByType(elem: InputElement, type: GetValueTypes, where: string): any;
    /**
     * Retrieves the raw value from the HTML input element.
     * If a custom value hook exists, it will be used first.
     *
     * @param {TinyInputElement} el - Target element.
     * @param {GetValueTypes} type - The type of value to retrieve ("string", "date", or "number").
     * @param {string} where - The context/method name using this validation.
     * @returns {any} The raw value retrieved from the element or hook.
     */
    static _val(el: TinyInputElement, where: string, type: GetValueTypes): any;
    /**
     * Retrieves the raw value from the HTML input element.
     * If a custom value hook exists, it will be used first.
     *
     * @param {GetValueTypes} type - The type of value to retrieve ("string", "date", or "number").
     * @param {string} where - The context/method name using this validation.
     * @returns {any} The raw value retrieved from the element or hook.
     */
    _val(where: string, type: GetValueTypes): any;
    /**
     * Gets the value of the current HTML value element.
     *
     * @param {TinyInputElement} el - Target element.
     * @returns {SetValueList} The normalized value, with carriage returns removed.
     */
    static val(el: TinyInputElement): SetValueList;
    /**
     * Gets the value of the current HTML value element.
     *
     * @returns {SetValueList} The normalized value, with carriage returns removed.
     */
    val(): SetValueList;
    /**
     * Gets the text of the current HTML value element (for text).
     *
     * @param {TinyInputElement} el - Target element.
     * @returns {string} The text value.
     * @throws {Error} If the element is not a string value.
     */
    static valTxt(el: TinyInputElement): string;
    /**
     * Gets the text of the current HTML value element (for text).
     *
     * @returns {string} The text value.
     * @throws {Error} If the element is not a string value.
     */
    valTxt(): string;
    /**
     * Internal helper to get a value from an input expected to return an array.
     *
     * @param {TinyInputElement} el - Target element.
     * @param {string} where - The method name or context using this validation (for error reporting).
     * @param {GetValueTypes} type - The type of value to retrieve ("string", "date", or "number").
     * @returns {SetValueBase[]} - The validated value as an array.
     * @throws {Error} If the returned value is not an array.
     */
    static _valArr(el: TinyInputElement, where: string, type: GetValueTypes): SetValueBase[];
    /**
     * Internal helper to get a value from an input expected to return an array.
     *
     * @param {string} where - The method name or context using this validation (for error reporting).
     * @param {GetValueTypes} type - The type of value to retrieve ("string", "date", or "number").
     * @returns {SetValueBase[]} - The validated value as an array.
     * @throws {Error} If the returned value is not an array.
     */
    _valArr(where: string, type: GetValueTypes): SetValueBase[];
    /**
     * Gets the raw value as a generic array of the current HTML value element (for select).
     *
     * @param {TinyInputElement} el - Target element.
     * @returns {SetValueBase[]} - The value cast as a generic array.
     * @throws {Error} If the value is not a valid array.
     */
    static valArr(el: TinyInputElement): SetValueBase[];
    /**
     * Gets the raw value as a generic array of the current HTML value element (for select).
     *
     * @returns {SetValueBase[]} - The value cast as a generic array.
     * @throws {Error} If the value is not a valid array.
     */
    valArr(): SetValueBase[];
    /**
     * Gets the current value parsed as a number (for number/text).
     *
     * @param {TinyInputElement} el - Target element.
     * @returns {number} The numeric value.
     * @throws {Error} If the element is not a number-compatible input or value is NaN.
     */
    static valNb(el: TinyInputElement): number;
    /**
     * Gets the current value parsed as a number (for number/text).
     *
     * @returns {number} The numeric value.
     * @throws {Error} If the element is not a number-compatible input or value is NaN.
     */
    valNb(): number;
    /**
     * Gets the current value parsed as a Date (for time/date).
     *
     * @param {TinyInputElement} el - Target element.
     * @returns {Date} The date value.
     * @throws {Error} If the element is not a date-compatible input.
     */
    static valDate(el: TinyInputElement): Date;
    /**
     * Gets the current value parsed as a Date (for time/date).
     *
     * @returns {Date} The date value.
     * @throws {Error} If the element is not a date-compatible input.
     */
    valDate(): Date;
    /**
     * Checks if the input element is boolean (for checkboxes/radios).
     *
     * @param {TinyInputElement} el - Target element.
     * @returns {boolean} True if the input is considered checked (value === "on"), false otherwise.
     * @throws {Error} If the element is not a checkbox/radio input.
     */
    static valBool(el: TinyInputElement): boolean;
    /**
     * Checks if the input element is boolean (for checkboxes/radios).
     *
     * @returns {boolean} True if the input is considered checked (value === "on"), false otherwise.
     * @throws {Error} If the element is not a checkbox/radio input.
     */
    valBool(): boolean;
    /**
     * Registers a listener for the "paste" event to extract files and text from the clipboard (e.g., when the user presses Ctrl+V).
     *
     * This method allows reacting to pasted content by providing separate callbacks for files and plain text.
     * Useful for building file upload areas, rich-text editors, or input enhancements.
     *
     * @param {TinyElementWithDoc|TinyElementWithDoc[]} el - The target element(s) where the "paste" event will be listened.
     * @param {Object} [settings={}] - Optional callbacks to handle clipboard content.
     * @param {(data: DataTransferItem, file: File) => void} [settings.onFilePaste] - Called for each file pasted from the clipboard (e.g., images).
     * @param {(data: DataTransferItem, text: string) => void} [settings.onTextPaste] - Called when plain text is pasted from the clipboard.
     * @returns {EventListenerOrEventListenerObject} The internal "paste" event handler used.
     */
    static listenForPaste(el: TinyElementWithDoc | TinyElementWithDoc[], { onFilePaste, onTextPaste }?: {
        onFilePaste?: (data: DataTransferItem, file: File) => void;
        onTextPaste?: (data: DataTransferItem, text: string) => void;
    }): EventListenerOrEventListenerObject;
    /**
     * Registers a listener for the "paste" event to extract files and text from the clipboard (e.g., when the user presses Ctrl+V).
     *
     * This method allows reacting to pasted content by providing separate callbacks for files and plain text.
     * Useful for building file upload areas, rich-text editors, or input enhancements.
     *
     * @param {Object} [settings={}] - Optional callbacks to handle clipboard content.
     * @param {(data: DataTransferItem, file: File) => void} [settings.onFilePaste] - Called for each file pasted from the clipboard (e.g., images).
     * @param {(data: DataTransferItem, text: string) => void} [settings.onTextPaste] - Called when plain text is pasted from the clipboard.
     * @returns {EventListenerOrEventListenerObject} The internal "paste" event handler used.
     */
    listenForPaste({ onFilePaste, onTextPaste }?: {
        onFilePaste?: (data: DataTransferItem, file: File) => void;
        onTextPaste?: (data: DataTransferItem, text: string) => void;
    }): EventListenerOrEventListenerObject;
    /**
     * Checks if the element has a listener for a specific event.
     *
     * @param {TinyEventTarget} el - The element to check.
     * @param {string} event - The event name to check.
     * @returns {boolean}
     */
    static hasEventListener(el: TinyEventTarget, event: string): boolean;
    /**
     * Checks if the element has a listener for a specific event.
     *
     * @param {string} event - The event name to check.
     * @returns {boolean}
     */
    hasEventListener(event: string): boolean;
    /**
     * Checks if the element has the exact handler registered for a specific event.
     *
     * @param {TinyEventTarget} el - The element to check.
     * @param {string} event - The event name to check.
     * @param {EventListenerOrEventListenerObject} handler - The handler function to check.
     * @returns {boolean}
     */
    static hasExactEventListener(el: TinyEventTarget, event: string, handler: EventListenerOrEventListenerObject): boolean;
    /**
     * Checks if the element has the exact handler registered for a specific event.
     *
     * @param {string} event - The event name to check.
     * @param {EventListenerOrEventListenerObject} handler - The handler function to check.
     * @returns {boolean}
     */
    hasExactEventListener(event: string, handler: EventListenerOrEventListenerObject): boolean;
    /**
     * Hover event shortcut.
     *
     * Adds `mouseenter` and `mouseleave` event listeners to the target.
     *
     * @template {TinyEventTarget|TinyEventTarget[]} T
     * @param {T} el - The target element(s) to attach the hover handlers.
     * @param {HoverEventCallback} fnOver - Callback executed when the mouse enters the target.
     * @param {HoverEventCallback|null} [fnOut] - Optional callback executed when the mouse leaves
     * the target. If not provided, `fnOver` will be used for both events.
     * @param {EventRegistryOptions} [options] - Optional event listener options.
     * @returns {T}
     */
    static hover<T extends TinyEventTarget | TinyEventTarget[]>(el: T, fnOver: HoverEventCallback, fnOut?: HoverEventCallback | null, options?: EventRegistryOptions): T;
    /**
     * Hover event shortcut.
     *
     * Adds `mouseenter` and `mouseleave` event listeners to the target.
     *
     * @param {HoverEventCallback} fnOver - Callback executed when the mouse enters the target.
     * @param {HoverEventCallback|null} [fnOut] - Optional callback executed when the mouse leaves
     * the target. If not provided, `fnOver` will be used for both events.
     * @param {EventRegistryOptions} [options] - Optional event listener options.
     * @returns {this}
     */
    hover(fnOver: HoverEventCallback, fnOut?: HoverEventCallback | null, options?: EventRegistryOptions): this;
    /**
     * Registers an event listener on the specified element.
     *
     * @template {TinyEventTarget|TinyEventTarget[]} T
     * @param {T} el - The target to listen on.
     * @param {string|string[]} events - The event type (e.g. 'click', 'keydown').
     * @param {EventListenerOrEventListenerObject|null} handler - The callback function to run on event.
     * @param {EventRegistryOptions} [options] - Optional event listener options.
     * @returns {T}
     */
    static on<T extends TinyEventTarget | TinyEventTarget[]>(el: T, events: string | string[], handler: EventListenerOrEventListenerObject | null, options?: EventRegistryOptions): T;
    /**
     * Registers an event listener on the specified element.
     *
     * @param {string|string[]} events - The event type (e.g. 'click', 'keydown').
     * @param {EventListenerOrEventListenerObject|null} handler - The callback function to run on event.
     * @param {EventRegistryOptions} [options] - Optional event listener options.
     * @returns {this}
     */
    on(events: string | string[], handler: EventListenerOrEventListenerObject | null, options?: EventRegistryOptions): this;
    /**
     * Registers an event listener that runs only once, then is removed.
     *
     * @template {TinyEventTarget|TinyEventTarget[]} T
     * @param {T} el - The target to listen on.
     * @param {string|string[]} events - The event type (e.g. 'click', 'keydown').
     * @param {EventListenerOrEventListenerObject} handler - The callback function to run on event.
     * @param {EventRegistryOptions} [options={}] - Optional event listener options.
     * @returns {T}
     */
    static once<T extends TinyEventTarget | TinyEventTarget[]>(el: T, events: string | string[], handler: EventListenerOrEventListenerObject, options?: EventRegistryOptions): T;
    /**
     * Registers an event listener that runs only once, then is removed.
     *
     * @param {string|string[]} events - The event type (e.g. 'click', 'keydown').
     * @param {EventListenerOrEventListenerObject} handler - The callback function to run on event.
     * @param {EventRegistryOptions} [options={}] - Optional event listener options.
     * @returns {this}
     */
    once(events: string | string[], handler: EventListenerOrEventListenerObject, options?: EventRegistryOptions): this;
    /**
     * Removes a specific event listener from an element.
     *
     * @template {TinyEventTarget|TinyEventTarget[]} T
     * @param {T} el - The target element.
     * @param {string|string[]} events - The event type.
     * @param {EventListenerOrEventListenerObject|null} handler - The function originally bound to the event.
     * @param {boolean|EventListenerOptions} [options] - Optional listener options.
     * @returns {T}
     */
    static off<T extends TinyEventTarget | TinyEventTarget[]>(el: T, events: string | string[], handler: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): T;
    /**
     * Removes a specific event listener from an element.
     *
     * @param {string|string[]} events - The event type.
     * @param {EventListenerOrEventListenerObject|null} handler - The function originally bound to the event.
     * @param {boolean|EventListenerOptions} [options] - Optional listener options.
     * @returns {this}
     */
    off(events: string | string[], handler: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): this;
    /**
     * Removes all event listeners of a specific type from the element.
     *
     * @template {TinyEventTarget|TinyEventTarget[]} T
     * @param {T} el - The target element.
     * @param {string|string[]} events - The event type to remove (e.g. 'click').
     * @returns {T}
     */
    static offAll<T extends TinyEventTarget | TinyEventTarget[]>(el: T, events: string | string[]): T;
    /**
     * Removes all event listeners of a specific type from the element.
     *
     * @param {string|string[]} events - The event type to remove (e.g. 'click').
     * @returns {this}
     */
    offAll(events: string | string[]): this;
    /**
     * Removes all event listeners of all types from the element.
     *
     * @template {TinyEventTarget|TinyEventTarget[]} T
     * @param {T} el - The target element.
     * @param {((handler: EventListenerOrEventListenerObject|null, event: string) => boolean)|null} [filterFn=null] -
     *        Optional filter function to selectively remove specific handlers.
     * @returns {T}
     */
    static offAllTypes<T extends TinyEventTarget | TinyEventTarget[]>(el: T, filterFn?: ((handler: EventListenerOrEventListenerObject | null, event: string) => boolean) | null): T;
    /**
     * Removes all event listeners of all types from the element.
     *
     * @param {((handler: EventListenerOrEventListenerObject|null, event: string) => boolean)|null} [filterFn=null] -
     *        Optional filter function to selectively remove specific handlers.
     * @returns {this}
     */
    offAllTypes(filterFn?: ((handler: EventListenerOrEventListenerObject | null, event: string) => boolean) | null): this;
    /**
     * Triggers all handlers associated with a specific event on the given element.
     *
     * @template {TinyEventTarget|TinyEventTarget[]} T
     * @param {T} el - Target element where the event should be triggered.
     * @param {string|string[]} events - Name of the event to trigger.
     * @param {Event|CustomEvent|CustomEventInit} [payload] - Optional event object or data to pass.
     * @returns {T}
     */
    static trigger<T extends TinyEventTarget | TinyEventTarget[]>(el: T, events: string | string[], payload?: Event | CustomEvent | CustomEventInit): T;
    /**
     * Triggers all handlers associated with a specific event on the given element.
     *
     * @param {string|string[]} events - Name of the event to trigger.
     * @param {Event|CustomEvent|CustomEventInit} [payload] - Optional event object or data to pass.
     * @returns {this}
     */
    trigger(events: string | string[], payload?: Event | CustomEvent | CustomEventInit): this;
    /**
     * Public proxy for normalized DOM property names.
     *
     * Setting a new entry here will also automatically update the reverse map in `TinyHtml.attrFix`.
     *
     * @type {Record<string | symbol, string>}
     */
    static propFix: Record<string | symbol, string>;
    /**
     * Reverse map of `propFix`, mapping property names back to their attribute equivalents.
     *
     * Used when converting DOM property names into HTML attribute names.
     *
     * @type {Record<string | symbol, string>}
     */
    static attrFix: Record<string | symbol, string>;
    /**
     * Normalizes an attribute name to its corresponding DOM property name.
     *
     * Example: `'class'` ➝ `'className'`, `'for'` ➝ `'htmlFor'`.
     * If the name is not mapped, it returns the original name.
     *
     * @param {string} name - The attribute name to normalize.
     * @returns {string} - The corresponding property name.
     */
    static getPropName(name: string): string;
    /**
     * Converts a DOM property name back to its corresponding attribute name.
     *
     * Example: `'className'` ➝ `'class'`, `'htmlFor'` ➝ `'for'`.
     * If the name is not mapped, it returns the original name.
     *
     * @param {string} name - The property name to convert.
     * @returns {string} - The corresponding attribute name.
     */
    static getAttrName(name: string): string;
    /**
     * Returns the BigInt value of an attribute.
     * @param {TinyElement} el
     * @param {string} name
     * @returns {bigint|null}
     */
    static attrBigInt(el: TinyElement, name: string): bigint | null;
    /**
     * Returns the BigInt value of an attribute.
     * @param {string} name
     * @returns {bigint|null}
     */
    attrBigInt(name: string): bigint | null;
    /**
     * Set a BigInt attribute.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {string} name
     * @param {bigint} value
     * @returns {T}
     */
    static setAttrBigInt<T extends TinyElement | TinyElement[]>(el: T, name: string, value: bigint): T;
    /**
     * Set a BigInt attribute.
     * @param {string} name
     * @param {bigint} value
     * @returns {this}
     */
    setAttrBigInt(name: string, value: bigint): this;
    /**
     * Returns the Date value of an attribute.
     * @param {TinyElement} el
     * @param {string} name
     * @returns {Date|null}
     */
    static attrDate(el: TinyElement, name: string): Date | null;
    /**
     * Returns the Date value of an attribute.
     * @param {string} name
     * @returns {Date|null}
     */
    attrDate(name: string): Date | null;
    /**
     * Set a Date attribute.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {string} name
     * @param {Date} value
     * @returns {T}
     */
    static setAttrDate<T extends TinyElement | TinyElement[]>(el: T, name: string, value: Date): T;
    /**
     * Set a Date attribute.
     * @param {string} name
     * @param {Date} value
     * @returns {this}
     */
    setAttrDate(name: string, value: Date): this;
    /**
     * Returns the JSON value of an attribute.
     * @param {TinyElement} el
     * @param {string} name
     * @returns {any|null}
     */
    static attrJson(el: TinyElement, name: string): any | null;
    /**
     * Returns the JSON value of an attribute.
     * @param {string} name
     * @returns {any|null}
     */
    attrJson(name: string): any | null;
    /**
     * Set a JSON attribute.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {string} name
     * @param {any} value
     * @param {(this: any, key: string, value: any) => any} [replacer]
     * @param {number|string} [space]
     * @returns {T}
     */
    static setAttrJson<T extends TinyElement | TinyElement[]>(el: T, name: string, value: any, replacer?: (this: any, key: string, value: any) => any, space?: number | string): T;
    /**
     * Set a JSON attribute.
     * @param {string} name
     * @param {any} value
     * @param {(this: any, key: string, value: any) => any} [replacer]
     * @param {number|string} [space]
     * @returns {this}
     */
    setAttrJson(name: string, value: any, replacer?: (this: any, key: string, value: any) => any, space?: number | string): this;
    /**
     * Returns the number value of an attribute.
     * @param {TinyElement} el
     * @param {string} name
     * @returns {number|null}
     */
    static attrNumber(el: TinyElement, name: string): number | null;
    /**
     * Returns the number value of an attribute.
     * @param {string} name
     * @returns {number|null}
     */
    attrNumber(name: string): number | null;
    /**
     * Set a number attribute.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {string} name
     * @param {number} value
     * @returns {T}
     */
    static setAttrNumber<T extends TinyElement | TinyElement[]>(el: T, name: string, value: number): T;
    /**
     * Set a number attribute.
     * @param {string} name
     * @param {number} value
     * @returns {this}
     */
    setAttrNumber(name: string, value: number): this;
    /**
     * Returns the boolean value of an attribute.
     * @param {TinyElement} el
     * @param {string} name
     * @returns {boolean|null}
     */
    static attrBoolean(el: TinyElement, name: string): boolean | null;
    /**
     * Returns the boolean value of an attribute.
     * @param {string} name
     * @returns {boolean|null}
     */
    attrBoolean(name: string): boolean | null;
    /**
     * Set a boolean attribute.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {string} name
     * @param {boolean} value
     * @returns {T}
     */
    static setAttrBoolean<T extends TinyElement | TinyElement[]>(el: T, name: string, value: boolean): T;
    /**
     * Set a boolean attribute.
     * @param {string} name
     * @param {boolean} value
     * @returns {this}
     */
    setAttrBoolean(name: string, value: boolean): this;
    /**
     * Returns the string value of an attribute.
     * @param {TinyElement} el
     * @param {string} name
     * @returns {string|null}
     */
    static attrString(el: TinyElement, name: string): string | null;
    /**
     * Returns the string value of an attribute.
     * @param {string} name
     * @returns {string|null}
     */
    attrString(name: string): string | null;
    /**
     * Set a string attribute.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {string} name
     * @param {string} value
     * @returns {T}
     */
    static setAttrString<T extends TinyElement | TinyElement[]>(el: T, name: string, value: string): T;
    /**
     * Set a string attribute.
     * @param {string} name
     * @param {string} value
     * @returns {this}
     */
    setAttrString(name: string, value: string): this;
    /**
     * Get an attribute on an element.
     * @param {TinyElement} el
     * @param {string} name
     * @returns {string|null}
     */
    static attr(el: TinyElement, name: string): string | null;
    /**
     * Get an attribute on an element.
     * @param {string} name
     * @returns {string|null}
     */
    attr(name: string): string | null;
    /**
     * Set one or multiple attributes on an element.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el - Target element(s).
     * @param {string|Record<string, any>} name - Attribute name or an object of attributes.
     * @param {any} [value=null] - Attribute value (ignored if "name" is an object).
     * @returns {T}
     */
    static setAttr<T extends TinyElement | TinyElement[]>(el: T, name: string | Record<string, any>, value?: any): T;
    /**
     * Set one or multiple attributes on an element.
     * @param {string|Record<string, any>} name - Attribute name or an object of attributes.
     * @param {any} [value=null] - Attribute value (ignored if "name" is an object).
     * @returns {this}
     */
    setAttr(name: string | Record<string, any>, value?: any): this;
    /**
     * Remove attribute(s) from an element.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el
     * @param {string} name Space-separated list of attributes.
     * @returns {T}
     */
    static removeAttr<T extends TinyElement | TinyElement[]>(el: T, name: string): T;
    /**
     * Remove attribute(s) from an element.
     * @param {string} name Space-separated list of attributes.
     * @returns {this}
     */
    removeAttr(name: string): this;
    /**
     * Check if an attribute exists on an element.
     * @param {TinyElement} el
     * @param {string} name
     * @returns {boolean}
     */
    static hasAttr(el: TinyElement, name: string): boolean;
    /**
     * Check if an attribute exists on an element.
     * @param {string} name
     * @returns {boolean}
     */
    hasAttr(name: string): boolean;
    /**
     * Check if a property exists.
     * @param {TinyElement} el
     * @param {string} name
     * @returns {boolean}
     */
    static hasProp(el: TinyElement, name: string): boolean;
    /**
     * Check if a property exists.
     * @param {string} name
     * @returns {boolean}
     */
    hasProp(name: string): boolean;
    /**
     * Set one or multiple properties on an element.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el - Target element(s).
     * @param {...string} names - Property name(s).
     * @returns {T}
     */
    static addProp<T extends TinyElement | TinyElement[]>(el: T, ...names: string[]): T;
    /**
     * Set a property on an element.
     * @param {...string} names - Property name(s).
     * @returns {this}
     */
    addProp(...names: string[]): this;
    /**
     * Remove one or multiple properties from an element.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el - Target element(s).
     * @param {...string} names - Property name(s).
     * @returns {T}
     */
    static removeProp<T extends TinyElement | TinyElement[]>(el: T, ...names: string[]): T;
    /**
     * Remove a property from an element.
     * @param {...string} names - Property name(s).
     * @returns {this}
     */
    removeProp(...names: string[]): this;
    /**
     * Toggle one or multiple boolean properties.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el - Target element(s).
     * @param {string|string[]} name - Property name or a list of property names.
     * @param {boolean} [force] - Force true/false instead of toggling.
     * @returns {T}
     */
    static toggleProp<T extends TinyElement | TinyElement[]>(el: T, name: string | string[], force?: boolean): T;
    /**
     * Toggle one or multiple boolean properties.
     * @param {string|string[]} name - Property name or a list of property names.
     * @param {boolean} [force] - Force true/false instead of toggling.
     * @returns {this}
     */
    toggleProp(name: string | string[], force?: boolean): this;
    /**
     * Get properties on an element.
     *
     * @param {TinyHtmlElement} el - Target element.
     * @param {string} name - Property name.
     * @returns {any} - Property value if getting, otherwise `undefined`.
     */
    static prop(el: TinyHtmlElement, name: string): any;
    /**
     * Get properties on an element.
     *
     * @param {string} name - Property name.
     * @returns {any} - Property value if getting, otherwise `undefined`.
     */
    prop(name: string): any;
    /**
     * Set a property on elements.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el - Target element(s).
     * @param {string} name - Property name.
     * @param {any} value - Value to set.
     * @returns {T}
     */
    static setProp<T extends TinyElement | TinyElement[]>(el: T, name: string, value: any): T;
    /**
     * Set a property on this element.
     * @param {string} name - Property name.
     * @param {any} value - Value to set.
     * @returns {this} The same element.
     */
    setProp(name: string, value: any): this;
    /**
     * Removes an element from the DOM.
     * @template {TinyElement|TinyElement[]} T
     * @param {T} el - The DOM element or selector to remove.
     * @returns {T}
     */
    static remove<T extends TinyElement | TinyElement[]>(el: T): T;
    /**
     * Removes the element from the DOM.
     * @returns {this}
     */
    remove(): this;
    /**
     * Returns the index of the first element within its parent or relative to a selector/element.
     *
     * @param {TinyElement} el - The element target
     * @param {string|TinyElement|null} [el2] - Optional target to compare index against.
     * @returns {number}
     */
    static index(el: TinyElement, el2?: string | TinyElement | null): number;
    /**
     * Returns the index of the first element within its parent or relative to a selector/element.
     *
     * @param {string|TinyElement|null} [elem] - Optional target to compare index against.
     * @returns {number}
     */
    index(elem?: string | TinyElement | null): number;
    /**
     * Creates a new DOMRect object by copying the base rect and applying optional additional dimensions.
     *
     * @param {DOMRect} rect - The base rectangle to be cloned and extended.
     * @param {Partial<DOMRect>} extraRect - Additional dimensions to apply to the base rect (e.g., extra padding or offset).
     * @returns {DOMRect} - A new DOMRect object with the combined dimensions.
     */
    static _getCustomRect(rect: DOMRect, extraRect: Partial<DOMRect>): DOMRect;
    /**
     * Determines if two HTML elements are colliding, using a simple bounding box comparison.
     *
     * @param {TinyElement} el1 - The first element to compare.
     * @param {TinyElement} el2 - The second element to compare.
     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
     * @returns {boolean} - `true` if the elements are colliding, `false` otherwise.
     */
    static isCollWith(el1: TinyElement, el2: TinyElement, extraRect?: Partial<ObjRect>): boolean;
    /**
     * Determines if two HTML elements are colliding, using a simple bounding box comparison.
     *
     * @param {TinyElement} el2 - The second element to compare.
     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
     * @returns {boolean} - `true` if the elements are colliding, `false` otherwise.
     */
    isCollWith(el2: TinyElement, extraRect?: Partial<ObjRect>): boolean;
    /**
     * Determines if two HTML elements are colliding using a pixel-perfect collision algorithm.
     *
     * @param {TinyElement} el1 - The first element to compare.
     * @param {TinyElement} el2 - The second element to compare.
     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
     * @returns {boolean} - `true` if the elements are colliding with higher precision, `false` otherwise.
     */
    static isCollPerfWith(el1: TinyElement, el2: TinyElement, extraRect?: Partial<ObjRect>): boolean;
    /**
     * Determines if two HTML elements are colliding using a pixel-perfect collision algorithm.
     *
     * @param {TinyElement} el2 - The second element to compare.
     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
     * @returns {boolean} - `true` if the elements are colliding with higher precision, `false` otherwise.
     */
    isCollPerfWith(el2: TinyElement, extraRect?: Partial<ObjRect>): boolean;
    /**
     * Determines whether two elements are colliding with a directional lock mechanism.
     *
     * This function tracks the direction from which an element (`elem1`) initially collided with another,
     * and keeps the collision "locked" until the element exits the collision from the same direction.
     *
     * - If `isColliding` is true and no lock is stored yet, it saves the direction of entry.
     * - If `isColliding` is false but a previous lock exists, it checks if the element has exited
     *   in the same direction it entered to remove the lock.
     *
     * @param {boolean} isColliding - Indicates whether `rect1` and `rect2` are currently colliding.
     * @param {DOMRect} rect1 - The bounding box of the first element.
     * @param {DOMRect} rect2 - The bounding box of the second element.
     * @param {Element} elem1 - The element to track collision state for.
     * @param {CollisionDirLock} lockDirection - The direction from which the collision was first detected.
     * @returns {boolean} Returns `true` if the element is still considered colliding (locked), otherwise `false`.
     */
    static _isCollWithLock(isColliding: boolean, rect1: DOMRect, rect2: DOMRect, elem1: Element, lockDirection: CollisionDirLock): boolean;
    /**
     * Checks if two DOM elements are colliding on the screen, and locks the collision
     * until the element exits through the same side it entered.
     *
     * @param {TinyElement} el1 - First DOM element (e.g. draggable or moving element).
     * @param {TinyElement} el2 - Second DOM element (e.g. a container or boundary element).
     * @param {CollisionDirLock} lockDirection - Direction that must be respected to unlock the collision.
     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
     * @returns {boolean} True if collision is still active.
     */
    static isCollWithLock(el1: TinyElement, el2: TinyElement, lockDirection: CollisionDirLock, extraRect?: Partial<ObjRect>): boolean;
    /**
     * Checks if two DOM elements are colliding on the screen, and locks the collision
     * until the element exits through the same side it entered.
     *
     * @param {TinyElement} el2 - Second DOM element (e.g. a container or boundary element).
     * @param {CollisionDirLock} lockDirection - Direction that must be respected to unlock the collision.
     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
     * @returns {boolean} True if collision is still active.
     */
    isCollWithLock(el2: TinyElement, lockDirection: CollisionDirLock, extraRect?: Partial<ObjRect>): boolean;
    /**
     * Checks if two DOM elements are colliding on the screen, and locks the collision
     * until the element exits through the same side it entered.
     *
     * @param {TinyElement} el1 - First DOM element (e.g. draggable or moving element).
     * @param {TinyElement} el2 - Second DOM element (e.g. a container or boundary element).
     * @param {CollisionDirLock} lockDirection - Direction that must be respected to unlock the collision.
     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
     * @returns {boolean} True if collision is still active.
     */
    static isCollPerfWithLock(el1: TinyElement, el2: TinyElement, lockDirection: CollisionDirLock, extraRect?: Partial<ObjRect>): boolean;
    /**
     * Checks if two DOM elements are colliding on the screen, and locks the collision
     * until the element exits through the same side it entered.
     *
     * @param {TinyElement} el2 - Second DOM element (e.g. a container or boundary element).
     * @param {CollisionDirLock} lockDirection - Direction that must be respected to unlock the collision.
     * @param {Partial<ObjRect>} [extraRect] - Optional values to expand the size of the first element's rect.
     * @returns {boolean} True if collision is still active.
     */
    isCollPerfWithLock(el2: TinyElement, lockDirection: CollisionDirLock, extraRect?: Partial<ObjRect>): boolean;
    /**
     * Resets all collision locks for a specific element (for all directions).
     *
     * @param {TinyElement} el - The element whose locks should be removed.
     * @returns {boolean} True if at least one lock was removed.
     */
    static resetCollLock(el: TinyElement): boolean;
    /**
     * Resets the collision lock for a specific element.
     *
     * This removes any previously stored collision direction for the given element,
     * effectively unlocking its collision state.
     *
     * @returns {boolean} Returns `true` if a lock was removed, `false` if no lock was present.
     */
    resetCollLock(): boolean;
    /**
     * Resets the collision lock for a specific element and direction.
     *
     * @param {TinyElement} el - The element whose lock should be removed.
     * @param {CollisionDirLock} direction - The direction to clear the lock from.
     * @returns {boolean} True if the lock was removed.
     */
    static resetCollLockDir(el: TinyElement, direction: CollisionDirLock): boolean;
    /**
     * Resets the collision lock for a specific element and direction.
     *
     * @param {CollisionDirLock} direction - The direction to clear the lock from.
     * @returns {boolean} True if the lock was removed.
     */
    resetCollLockDir(direction: CollisionDirLock): boolean;
    /**
     * Checks if the given element is at least partially visible in the viewport.
     *
     * @param {TinyElement} el - The DOM element to check.
     * @returns {boolean} True if the element is partially in the viewport, false otherwise.
     */
    static isInViewport(el: TinyElement): boolean;
    /**
     * Checks if the given element is at least partially visible in the viewport.
     *
     * @returns {boolean} True if the element is partially in the viewport, false otherwise.
     */
    isInViewport(): boolean;
    /**
     * Checks if the given element is fully visible in the viewport (top and bottom).
     *
     * @param {TinyElement} el - The DOM element to check.
     * @returns {boolean} True if the element is fully visible in the viewport, false otherwise.
     */
    static isScrolledIntoView(el: TinyElement): boolean;
    /**
     * Checks if the given element is fully visible in the viewport (top and bottom).
     *
     * @returns {boolean} True if the element is fully visible in the viewport, false otherwise.
     */
    isScrolledIntoView(): boolean;
    /**
     * Checks if the given element is at least partially visible within the boundaries of a container.
     *
     * @param {TinyElement} el - The DOM element to check.
     * @param {TinyElement} cont - The container element acting as the viewport.
     * @returns {boolean} True if the element is partially visible within the container, false otherwise.
     */
    static isInContainer(el: TinyElement, cont: TinyElement): boolean;
    /**
     * Checks if the given element is at least partially visible within the boundaries of a container.
     *
     * @param {TinyElement} cont - The container element acting as the viewport.
     * @returns {boolean} True if the element is partially visible within the container, false otherwise.
     */
    isInContainer(cont: TinyElement): boolean;
    /**
     * Checks if the given element is fully visible within the boundaries of a container (top and bottom).
     *
     * @param {TinyElement} el - The DOM element to check.
     * @param {TinyElement} cont - The container element acting as the viewport.
     * @returns {boolean} True if the element is fully visible within the container, false otherwise.
     */
    static isFullyInContainer(el: TinyElement, cont: TinyElement): boolean;
    /**
     * Checks if the given element is fully visible within the boundaries of a container (top and bottom).
     *
     * @param {TinyElement} cont - The container element acting as the viewport.
     * @returns {boolean} True if the element is fully visible within the container, false otherwise.
     */
    isFullyInContainer(cont: TinyElement): boolean;
    /**
     * Checks if an element has scrollable content.
     *
     * @param {TinyElement} el - The DOM element to check.
     * @returns {{ v: boolean, h: boolean }} - True if scroll is needed in that direction.
     */
    static hasScroll(el: TinyElement): {
        v: boolean;
        h: boolean;
    };
    /**
     * Checks if an element has scrollable content.
     *
     * @returns {{ v: boolean, h: boolean }} - True if scroll is needed in that direction.
     */
    hasScroll(): {
        v: boolean;
        h: boolean;
    };
}
export default TinyHtml;
//# sourceMappingURL=TinyHtml.d.mts.map