import type { ComponentInterface, EventEmitter } from '../../stencil-public-runtime';
/**
 * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
 * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
 */
export declare class InfiniteScroll implements ComponentInterface {
    private thrPx;
    private thrPc;
    private scrollEl?;
    private minHeightLocked;
    /**
     * didFire exists so that ionInfinite
     * does not fire multiple times if
     * users continue to scroll after
     * scrolling into the infinite
     * scroll threshold.
     */
    private didFire;
    private isBusy;
    el: HTMLElement;
    isLoading: boolean;
    /**
     * The threshold distance from the bottom
     * of the content to call the `infinite` output event when scrolled.
     * The threshold value can be either a percent, or
     * in pixels. For example, use the value of `10%` for the `infinite`
     * output event to get called when the user has scrolled 10%
     * from the bottom of the page. Use the value `100px` when the
     * scroll is within 100 pixels from the bottom of the page.
     */
    threshold: string;
    protected thresholdChanged(): void;
    /**
     * If `true`, the infinite scroll will be hidden and scroll event listeners
     * will be removed.
     *
     * Set this to true to disable the infinite scroll from actively
     * trying to receive new data while scrolling. This is useful
     * when it is known that there is no more data that can be added, and
     * the infinite scroll is no longer needed.
     */
    disabled: boolean;
    protected disabledChanged(): void;
    /**
     * The position of the infinite scroll element.
     * The value can be either `top` or `bottom`.
     */
    position: 'top' | 'bottom';
    /**
     * If `true`, the infinite scroll will preserve the scroll position
     * when the content is re-rendered. This is useful when the content is
     * re-rendered with new keys, and the scroll position should be preserved.
     */
    preserveRerenderScrollPosition: boolean;
    /**
     * Emitted when the scroll reaches
     * the threshold distance. From within your infinite handler,
     * you must call the infinite scroll's `complete()` method when
     * your async operation has completed.
     */
    ionInfinite: EventEmitter<void>;
    connectedCallback(): Promise<void>;
    disconnectedCallback(): void;
    private onScroll;
    /**
     * Loop through our sibling elements and lock or unlock their min height.
     * This keeps our siblings, for example `ion-list`, the same height as their
     * content currently is, so when it loads new data and the DOM removes the old
     * data, the height of the container doesn't change and we don't lose our scroll position.
     *
     * We preserve existing min-height values, if they're set, so we don't erase what
     * has been previously set by the user when we restore after complete is called.
     */
    private lockSiblingMinHeight;
    /**
     * Call `complete()` within the `ionInfinite` output event handler when
     * your async operation has completed. For example, the `loading`
     * state is while the app is performing an asynchronous operation,
     * such as receiving more data from an AJAX request to add more items
     * to a data list. Once the data has been received and UI updated, you
     * then call this method to signify that the loading has completed.
     * This method will change the infinite scroll's state from `loading`
     * to `enabled`.
     */
    complete(): Promise<void>;
    private canStart;
    private enableScrollEvents;
    render(): any;
}
