@1771technologies/lytenyte-pro/dist/components/external/floating-ui.d.ts

Blazingly fast headless React data grid with 100s of features.

/**
 * Provides data to position an inner element of the floating element so that it
 * appears centered to the reference element.
 * @see https://floating-ui.com/docs/arrow
 */
export function arrow(options: any): {
    name: string;
    options: any;
    fn(state: any): Promise<{
        data?: undefined;
        reset?: undefined;
    } | {
        [x: string]: any;
        data: {
            alignmentOffset?: number | undefined;
            centerOffset: number;
        };
        reset: boolean;
    }>;
};
/**
 * Optimizes the visibility of the floating element by choosing the placement
 * that has the most space available automatically, without needing to specify a
 * preferred placement. Alternative to `flip`.
 * @see https://floating-ui.com/docs/autoPlacement
 */
export function autoPlacement(options: any): {
    name: string;
    options: any;
    fn(state: any): Promise<{
        reset?: undefined;
        data?: undefined;
    } | {
        reset: {
            placement: any;
        };
        data?: undefined;
    } | {
        data: {
            index: any;
            overflows: any[];
        };
        reset: {
            placement: any;
        };
    }>;
};
/**
 * Automatically updates the position of the floating element when necessary.
 * Should only be called when the floating element is mounted on the DOM or
 * visible on the screen.
 * @returns cleanup function that should be invoked when the floating element is
 * removed from the DOM or hidden from the screen.
 * @see https://floating-ui.com/docs/autoUpdate
 */
export function autoUpdate(reference: any, floating: any, update: any, options: any): () => void;
/**
 * Computes the `x` and `y` coordinates that will place the floating element
 * next to a given reference element.
 */
export function computePosition(reference: any, floating: any, options: any): Promise<{
    x: any;
    y: any;
    placement: any;
    strategy: any;
    middlewareData: {};
}>;
/**
 * Resolves with an object of overflow side offsets that determine how much the
 * element is overflowing a given clipping boundary on each side.
 * - positive = overflowing the boundary by that number of pixels
 * - negative = how many pixels left before it will overflow
 * - 0 = lies flush with the boundary
 * @see https://floating-ui.com/docs/detectOverflow
 */
export function detectOverflow(state: any, options: any): Promise<{
    top: number;
    bottom: number;
    left: number;
    right: number;
}>;
/**
 * Optimizes the visibility of the floating element by flipping the `placement`
 * in order to keep it in view when the preferred placement(s) will overflow the
 * clipping boundary. Alternative to `autoPlacement`.
 * @see https://floating-ui.com/docs/flip
 */
export function flip(options: any): {
    name: string;
    options: any;
    fn(state: any): Promise<{
        data?: undefined;
        reset?: undefined;
    } | {
        data: {
            index: any;
            overflows: any;
        };
        reset: {
            placement: any;
        };
    } | {
        reset: {
            placement: any;
        };
        data?: undefined;
    }>;
};
export function getOverflowAncestors(node: any, list: any, traverseIframes: any): any;
/**
 * Provides data to hide the floating element in applicable situations, such as
 * when it is not in the same clipping context as the reference element.
 * @see https://floating-ui.com/docs/hide
 */
export function hide(options: any): {
    name: string;
    options: any;
    fn(state: any): Promise<{
        data: {
            referenceHiddenOffsets: {
                top: number;
                right: number;
                bottom: number;
                left: number;
            };
            referenceHidden: boolean;
            escapedOffsets?: undefined;
            escaped?: undefined;
        };
    } | {
        data: {
            escapedOffsets: {
                top: number;
                right: number;
                bottom: number;
                left: number;
            };
            escaped: boolean;
            referenceHiddenOffsets?: undefined;
            referenceHidden?: undefined;
        };
    } | {
        data?: undefined;
    }>;
};
/**
 * Provides improved positioning for inline reference elements that can span
 * over multiple lines, such as hyperlinks or range selections.
 * @see https://floating-ui.com/docs/inline
 */
export function inline(options: any): {
    name: string;
    options: any;
    fn(state: any): Promise<{
        reset: {
            rects: any;
        };
    } | {
        reset?: undefined;
    }>;
};
/**
 * Built-in `limiter` that will stop `shift()` at a certain point.
 */
export function limitShift(options: any): {
    options: any;
    fn(state: any): {
        [x: string]: any;
    };
};
/**
 * Modifies the placement by translating the floating element along the
 * specified axes.
 * A number (shorthand for `mainAxis` or distance), or an axes configuration
 * object may be passed.
 * @see https://floating-ui.com/docs/offset
 */
export function offset(options: any): {
    name: string;
    options: any;
    fn(state: any): Promise<{
        x?: undefined;
        y?: undefined;
        data?: undefined;
    } | {
        x: any;
        y: any;
        data: {
            placement: any;
            x: number;
            y: number;
        };
    }>;
};
export namespace platform {
    export { convertOffsetParentRelativeRectToViewportRelativeRect };
    export { getDocumentElement };
    export { getClippingRect };
    export { getOffsetParent };
    export { getElementRects };
    export { getClientRects };
    export { getDimensions };
    export { getScale };
    export { isElement };
    export { isRTL };
}
/**
 * Optimizes the visibility of the floating element by shifting it in order to
 * keep it in view when it will overflow the clipping boundary.
 * @see https://floating-ui.com/docs/shift
 */
export function shift(options: any): {
    name: string;
    options: any;
    fn(state: any): Promise<any>;
};
/**
 * Provides data that allows you to change the size of the floating element —
 * for instance, prevent it from overflowing the clipping boundary or match the
 * width of the reference element.
 * @see https://floating-ui.com/docs/size
 */
export function size(options: any): {
    name: string;
    options: any;
    fn(state: any): Promise<{
        reset: {
            rects: boolean;
        };
    } | {
        reset?: undefined;
    }>;
};
declare function convertOffsetParentRelativeRectToViewportRelativeRect(_ref: any): any;
declare function getDocumentElement(node: any): any;
declare function getClippingRect(_ref: any): {
    width: number;
    height: number;
    x: any;
    y: any;
};
declare function getOffsetParent(element: any, polyfill: any): any;
declare function getElementRects(data: any): Promise<{
    reference: {
        x: number;
        y: number;
        width: any;
        height: any;
    };
    floating: {
        x: number;
        y: number;
        width: any;
        height: any;
    };
}>;
declare function getClientRects(element: any): any[];
declare function getDimensions(element: any): {
    width: number;
    height: number;
};
declare function getScale(element: any): {
    x: any;
    y: any;
};
declare function isElement(value: any): boolean;
declare function isRTL(element: any): boolean;
export {};