import TinyHtml from '../TinyHtml.mjs';
import * as TinyCollision from '../../../basics/collision.mjs';
export type NodeSizes = {
    /**
     * - The height of the element in pixels.
     */
    height: number;
    /**
     * - The width of the element in pixels.
     */
    width: number;
};
export type NodeSizesEvent = (elem: Element, sizes: {
    old: NodeSizes;
    now: NodeSizes;
}, elemAmount: {
    old: number;
    now: number;
}) => NodeSizes | undefined;
export type ScrollListenersFunc = (payload: any) => void;
export type TinySmartScrollerEvents = {
    /**
     * - Emitted when the scroll boundary state changes.
     */
    onScrollBoundary: (data: any) => void;
    /**
     * - Emitted when the custom scroll boundary state changes.
     */
    onExtraScrollBoundary: (data: any) => void;
    /**
     * - Emitted when an auto-scroll occurs.
     */
    onAutoScroll: (data: any) => void;
    /**
     * - Emitted when auto-scroll is paused.
     */
    onScrollPause: (data: any) => void;
};
/**
 * Represents the dimensions of a DOM element.
 *
 * @typedef {Object} NodeSizes
 * @property {number} height - The height of the element in pixels.
 * @property {number} width - The width of the element in pixels.
 */
/**
 * A callback function that receives node size change data and optionally returns a modified NodeSizes object.
 *
 * @callback NodeSizesEvent
 * @param {Element} elem - The DOM element whose size is being tracked.
 * @param {{ old: NodeSizes, now: NodeSizes }} sizes - The old and new size measurements of the element.
 * @param {{ old: number, now: number }} elemAmount - The number of matching elements before and after the update.
 * @returns {NodeSizes|undefined} A modified NodeSizes object to override the default measurement, or undefined to use the original.
 */
/**
 * A generic scroll-related event listener callback function.
 *
 * @callback ScrollListenersFunc
 * @param {any} payload - The data payload passed when the scroll event is triggered. The type may vary depending on the event.
 * @returns {void}
 */
/**
 * Event map for {@link TinySmartScroller}.
 * @typedef {Object} TinySmartScrollerEvents
 * @property {(data: any) => void} onScrollBoundary - Emitted when the scroll boundary state changes.
 * @property {(data: any) => void} onExtraScrollBoundary - Emitted when the custom scroll boundary state changes.
 * @property {(data: any) => void} onAutoScroll - Emitted when an auto-scroll occurs.
 * @property {(data: any) => void} onScrollPause - Emitted when auto-scroll is paused.
 */
/** @type {new (...args: any[]) => import('../../../jsdoc/EventEmitter.mjs').ICustomEventEmitter<TinySmartScrollerEvents>} */
declare const TypedEventEmitter: new (...args: any[]) => import('../../../jsdoc/EventEmitter.mjs').ICustomEventEmitter<TinySmartScrollerEvents>;
/**
 * TinySmartScroller is a utility class designed to enhance and manage scroll behaviors within containers or the window.
 *
 * It enables advanced scroll monitoring, auto-scrolling to bottom, preserving scroll position during DOM changes,
 * and detecting visibility changes of elements. This is particularly useful for dynamic UIs like chat applications,
 * feed viewers, or live content containers.
 *
 * Features:
 * - Detects when the scroll reaches the top, bottom, or custom boundaries
 * - Supports automatic scrolling to the bottom unless the user scrolls away
 * - Observes DOM mutations and resizes, and adapts scroll position accordingly
 * - Emits scroll-related events such as 'onScrollBoundary', 'onAutoScroll', and 'onScrollPause'
 * - Includes customizable scroll correction filters for layout shift mitigation
 * - Handles media element load events (e.g. `<img>`, `<iframe>`, `<video>`) to prevent sudden scroll jumps
 *
 * This class is **not framework-dependent** and works with vanilla DOM elements and the window object.
 * @template {Element|Window} HTMLTarget
 */
declare class TinySmartScroller<HTMLTarget extends Element | Window> extends TypedEventEmitter {
    #private;
    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;
        };
        TinyHtml: typeof TinyHtml;
    };
    /**
     * Creates a new instance of TinySmartScroller, attaching scroll and resize observers to manage
     * automatic scroll behaviors, layout shift correction, and visibility tracking.
     *
     * @param {HTMLTarget} target - The scroll container to monitor. Can be an element or `window`.
     * @param {Object} [options={}] - Optional settings to configure scroll behavior.
     * @param {number} [options.extraScrollBoundary=0] - Extra margin in pixels to extend scroll boundary detection.
     * @param {boolean} [options.autoScrollBottom=true] - Whether to auto-scroll to bottom on layout updates.
     * @param {boolean} [options.observeMutations=true] - Enables MutationObserver to detect DOM changes.
     * @param {boolean} [options.preserveScrollOnLayoutShift=true] - Prevents scroll jumps when layout changes.
     * @param {number} [options.debounceTime=100] - Debounce time in milliseconds for scroll events.
     * @param {string|null} [options.querySelector=null] - Optional CSS selector to filter observed child nodes.
     * @param {string[]|Set<string>|null} [options.attributeFilter=['class', 'style', 'src', 'data-*', 'height', 'width']]
     *     - Which attributes to observe for changes.
     */
    constructor(target: HTMLTarget, { extraScrollBoundary, autoScrollBottom, observeMutations, preserveScrollOnLayoutShift, debounceTime, querySelector, attributeFilter, }?: {
        extraScrollBoundary?: number;
        autoScrollBottom?: boolean;
        observeMutations?: boolean;
        preserveScrollOnLayoutShift?: boolean;
        debounceTime?: number;
        querySelector?: string | null;
        attributeFilter?: string[] | Set<string> | null;
    });
    /**
     * Returns a size difference callback that only reacts when height changes, filtered by tag name.
     *
     * @param {string[]} filter - List of tag names to allow. If empty, all tags are accepted.
     * @returns {NodeSizesEvent} A function that compares previous and current height, returning height delta.
     */
    getSimpleOnHeight(filter?: string[]): NodeSizesEvent;
    /**
     * Adds a height difference callback to the size filter system.
     *
     * @param {string[]} filter - List of tag names to allow.
     * @returns {NodeSizesEvent} The added size difference callback.
     */
    addSimpleOnHeight(filter: string[]): NodeSizesEvent;
    /**
     * Returns a list of all currently tracked load tags.
     *
     * @returns {string[]} Array of tag names.
     */
    getLoadTags(): string[];
    /**
     * Adds a new tag to the set of load tags.
     *
     * @param {string} tag - The tag name to add (e.g., 'IMG').
     */
    addLoadTag(tag: string): void;
    /**
     * Removes a tag from the set of load tags.
     *
     * @param {string} tag - The tag name to remove.
     */
    removeLoadTag(tag: string): void;
    /**
     * Checks whether a tag is tracked as a load tag.
     *
     * @param {string} tag - The tag name to check.
     * @returns {boolean} True if the tag is being tracked.
     */
    hasLoadTag(tag: string): boolean;
    /**
     * Clears the set of load tags. If `addDefault` is true, it will reset to the default tags: 'IMG', 'IFRAME', and 'VIDEO'.
     *
     * @param {boolean} [addDefault=false] - Whether to restore the default tags after clearing.
     * @throws {TypeError} If `addDefault` is not a boolean.
     */
    resetLoadTags(addDefault?: boolean): void;
    /**
     * Returns a list of all currently tracked attribute filters.
     *
     * @returns {string[]} Array of attribute names.
     */
    getAttributeFilters(): string[];
    /**
     * Adds an attribute to the filter list.
     *
     * @param {string} attr - The attribute name to add.
     */
    addAttributeFilter(attr: string): void;
    /**
     * Removes an attribute from the filter list.
     *
     * @param {string} attr - The attribute name to remove.
     */
    removeAttributeFilter(attr: string): void;
    /**
     * Checks whether a specific attribute is being filtered.
     *
     * @param {string} attr - The attribute name to check.
     * @returns {boolean} True if the attribute is being filtered.
     */
    hasAttributeFilter(attr: string): boolean;
    /**
     * Clears the set of observed attribute filters. If `addDefault` is true, it will reset to the default attributes:
     * 'class', 'style', 'src', 'data-*', 'height', and 'width'.
     *
     * @param {boolean} [addDefault=false] - Whether to restore the default attribute filters after clearing.
     * @throws {TypeError} If `addDefault` is not a boolean.
     */
    resetAttributeFilters(addDefault?: boolean): void;
    /**
     * Registers a custom node size change handler to the internal size filter set.
     *
     * @param {NodeSizesEvent} handler - Function that compares old and new sizes.
     */
    onSize(handler: NodeSizesEvent): void;
    /**
     * Unregisters a previously registered size handler from the internal filter set.
     *
     * @param {NodeSizesEvent} handler - The handler function to remove.
     */
    offSize(handler: NodeSizesEvent): void;
    /**
     * Checks which elements inside the target are currently visible and updates internal maps.
     *
     * @returns {Map<Element, { oldIsVisible: boolean; isVisible: boolean }>} Visibility comparison results.
     * @private
     */
    private _scrollDataUpdater;
    /**
     * Handles scroll events, calculates position-related statuses, and emits appropriate events.
     * @private
     */
    private _onScroll;
    /**
     * Attempts to correct the scroll position when layout shifts happen, preserving the user position if needed.
     *
     * @param {Element[]} [targets=[]] - List of elements involved in the size change.
     * @private
     */
    private _fixScroll;
    /**
     * Sets up a MutationObserver to watch for DOM changes and react accordingly to maintain scroll consistency.
     * @private
     */
    private _observeMutations;
    /**
     * Adds a ResizeObserver to monitor elements' size changes and trigger layout adjustments.
     *
     * @param {NodeListOf<Element>|Element[]|HTMLCollection} elements - Elements to observe.
     * @private
     */
    private _observeResizes;
    /**
     * Listens for media/content load events (e.g., images, iframes, videos) to trigger scroll updates.
     *
     * @param {NodeListOf<Element>|Element} elements - Target element(s) to listen on.
     * @private
     */
    private _listenLoadEvents;
    get target(): HTMLTarget;
    /**
     * Returns the internal scroll container element being monitored.
     */
    get targetElement(): Element;
    /**
     * Returns the previous size of a given element, or undefined if not tracked.
     *
     * @param {Element} el - The DOM element to query.
     * @returns {NodeSizes|null} The old size, or undefined.
     */
    getOldSize(el: Element): NodeSizes | null;
    /**
     * Returns the current size of a given element, or undefined if not tracked.
     *
     * @param {Element} el - The DOM element to query.
     * @returns {NodeSizes|null} The new size, or undefined.
     */
    getNewSize(el: Element): NodeSizes | null;
    /**
     * Returns whether the given element was visible in the last scroll update.
     *
     * @param {Element} el - The DOM element to check.
     * @returns {boolean} True if visible, false if not, or undefined if not tracked.
     */
    wasVisible(el: Element): boolean;
    /**
     * Returns whether the given element is currently visible.
     *
     * @param {Element} el - The DOM element to check.
     * @returns {boolean} True if visible, false if not, or undefined if not tracked.
     */
    isVisible(el: Element): boolean;
    /**
     * Returns whether the element was visible in the last time-based visibility check.
     *
     * @param {Element} el - The DOM element to check.
     * @returns {boolean} Visibility state from the previous timed check.
     */
    wasTimedVisible(el: Element): boolean;
    /**
     * Returns whether the element is currently visible in the time-based check.
     *
     * @param {Element} el - The DOM element to check.
     * @returns {boolean} Visibility state from the current timed check.
     */
    isTimedVisible(el: Element): boolean;
    /**
     * Sets the extra scroll boundary margin used when determining if the user is at a "custom" bottom or top.
     *
     * @param {number} value - Pixels of additional margin to use.
     */
    setExtraScrollBoundary(value: number): void;
    /**
     * Returns the current extra scroll boundary setting.
     *
     * @returns {number}
     */
    getExtraScrollBoundary(): number;
    /**
     * Returns the last known distance (in pixels) from the bottom of the scroll container.
     *
     * @returns {number}
     */
    getLastKnownScrollBottomOffset(): number;
    /**
     * Forces the scroll position to move to the very bottom of the target.
     */
    scrollToBottom(): void;
    /**
     * Forces the scroll position to move to the very top of the target.
     */
    scrollToTop(): void;
    /**
     * Checks if the user is within the defined extra scroll boundary from the bottom.
     *
     * @returns {boolean}
     */
    isAtCustomBottom(): boolean;
    /**
     * Checks if the user is within the defined extra scroll boundary from the top.
     *
     * @returns {boolean}
     */
    isAtCustomTop(): boolean;
    /**
     * Returns true if the user is currently scrolled to the bottom of the element.
     *
     * @returns {boolean}
     */
    isAtBottom(): boolean;
    /**
     * Returns true if the user is currently scrolled to the top of the element.
     *
     * @returns {boolean}
     */
    isAtTop(): boolean;
    /**
     * Returns true if the user has already passed beyond the bottom boundary at some point.
     *
     * @returns {boolean}
     */
    isPastAtBottom(): boolean;
    /**
     * Returns true if the user has already passed beyond the top boundary at some point.
     *
     * @returns {boolean}
     */
    isPastAtTop(): boolean;
    /**
     * Returns true if the user has passed beyond the defined extra scroll boundary from the top at some point.
     *
     * @returns {boolean}
     */
    isPastAtCustomTop(): boolean;
    /**
     * Returns true if the user has passed beyond the defined extra scroll boundary from the bottom at some point.
     *
     * @returns {boolean}
     */
    isPastAtCustomBottom(): boolean;
    /**
     * Returns true if automatic scrolling is currently paused.
     *
     * @returns {boolean}
     */
    isScrollPaused(): boolean;
    /**
     * Returns whether the target is the window object.
     *
     * @returns {boolean} True if the scroll target is window, false otherwise.
     */
    isWindow(): boolean;
    /**
     * Returns whether the instance has been destroyed.
     *
     * @returns {boolean} True if the instance is destroyed, false otherwise.
     */
    isDestroyed(): boolean;
    /**
     * Returns whether auto-scroll-to-bottom is enabled.
     *
     * @returns {boolean} True if auto-scroll is active, false otherwise.
     */
    getAutoScrollBottom(): boolean;
    /**
     * Returns whether MutationObserver is enabled.
     *
     * @returns {boolean} True if mutation observation is active, false otherwise.
     */
    getObserveMutations(): boolean;
    /**
     * Returns whether layout shift protection is enabled.
     *
     * @returns {boolean} True if scroll preservation is active, false otherwise.
     */
    getPreserveScrollOnLayoutShift(): boolean;
    /**
     * Returns the debounce delay in milliseconds used for scroll events.
     *
     * @returns {number} Debounce delay time.
     */
    getDebounceTime(): number;
    /**
     * Returns the current number of matching elements observed inside the scroll target.
     *
     * @returns {number} Current count of matching elements.
     */
    getElemAmount(): number;
    /**
     * Returns the previous known count of matching elements from the last update.
     *
     * @returns {number} Previous count of matching elements.
     */
    getPrevElemAmount(): number;
    /**
     * Returns the query selector string used to filter observed elements.
     *
     * @returns {string} The CSS selector string, or an empty string if none was provided.
     */
    getQuerySelector(): string;
    /**
     * Disconnects all listeners, observers, and clears memory structures.
     * Once destroyed, this instance should no longer be used.
     */
    destroy(): void;
}
export default TinySmartScroller;
//# sourceMappingURL=TinySmartScroller.d.mts.map