import React from "react";
import { FlatListProps, ViewStyle, FlatList as RNFlatList } from "react-native";
import { State as GestureState } from "react-native-gesture-handler";
import Animated from "react-native-reanimated";
declare const defaultProps: {
    autoscrollThreshold: number;
    autoscrollSpeed: number;
    animationConfig: Animated.SpringConfig;
    scrollEnabled: boolean;
    activationDistance: number;
    refreshControlOffset: number;
};
declare type DefaultProps = Readonly<typeof defaultProps>;
declare type AnimatedFlatListType<T> = {
    getNode: () => RNFlatList<T>;
};
export declare type DragEndParams<T> = {
    data: T[];
    from: number;
    to: number;
};
export declare type RenderItemParams<T> = {
    item: T;
    index?: number;
    drag: () => void;
    isActive: boolean;
};
declare type Modify<T, R> = Omit<T, keyof R> & R;
declare type Props<T> = Modify<FlatListProps<T>, {
    autoscrollSpeed?: number;
    autoscrollThreshold?: number;
    data: T[];
    onRef?: (ref: React.RefObject<AnimatedFlatListType<T>>) => void;
    onDragBegin?: (index: number) => void;
    onRelease?: (index: number) => void;
    onDragEnd?: (params: DragEndParams<T>) => void;
    renderItem: (params: RenderItemParams<T>) => React.ReactNode;
    animationConfig: Partial<Animated.SpringConfig>;
    activationDistance?: number;
    debug?: boolean;
    layoutInvalidationKey?: string;
    onScrollOffsetChange?: (scrollOffset: number) => void;
    refreshing?: boolean;
    onRefresh?: () => void;
    refreshControlOffset?: number;
} & Partial<DefaultProps>>;
declare type State = {
    activeKey: string | null;
    hoverComponent: React.ReactNode | null;
    isLoaderActive: boolean | false;
};
declare type CellData = {
    size: Animated.Value<number>;
    offset: Animated.Value<number>;
    measurements: {
        size: number;
        offset: number;
    };
    style: Animated.AnimateProps<ViewStyle, {}>;
    currentIndex: Animated.Value<number>;
    onLayout: () => void;
    onUnmount: () => void;
};
declare class DraggableFlatList<T> extends React.Component<Props<T>, State> {
    state: State;
    containerRef: any;
    flatlistRef: any;
    panGestureHandlerRef: any;
    containerSize: Animated.Value<number>;
    activationDistance: Animated.Value<number>;
    touchAbsolute: Animated.Value<number>;
    touchCellOffset: Animated.Value<number>;
    panGestureState: Animated.Value<GestureState>;
    isPressedIn: {
        native: Animated.Value<number>;
        js: boolean;
    };
    hasMoved: Animated.Value<0>;
    disabled: Animated.Value<0>;
    activeIndex: Animated.Value<number>;
    isHovering: Animated.Node<0 | 1>;
    spacerIndex: Animated.Value<number>;
    activeCellSize: Animated.Value<number>;
    scrollOffset: Animated.Value<number>;
    scrollViewSize: Animated.Value<number>;
    isScrolledUp: Animated.Node<0 | 1>;
    isScrolledDown: Animated.Node<0 | 1>;
    hoverAnim: Animated.Node<number>;
    hoverMid: Animated.Node<number>;
    hoverOffset: Animated.Node<number>;
    hoverTo: Animated.Value<0>;
    hoverClock: Animated.Clock;
    hoverAnimState: {
        finished: Animated.Value<0>;
        velocity: Animated.Value<0>;
        position: Animated.Value<0>;
        time: Animated.Value<0>;
    };
    hoverAnimConfig: any;
    distToTopEdge: Animated.Node<number>;
    distToBottomEdge: Animated.Node<number>;
    cellAnim: Map<string, {
        config: Animated.SpringConfig;
        state: Animated.PhysicsAnimationState;
        clock: Animated.Clock;
    }>;
    cellData: Map<string, CellData>;
    cellRefs: Map<string, any>;
    moveEndParams: Animated.Value<number>[];
    resetHoverSpring: Animated.Node<any>[];
    keyToIndex: Map<string, number>;
    isAutoscrolling: {
        native: Animated.Value<number>;
        js: boolean;
    };
    queue: (() => void | Promise<void>)[];
    isLoading: Animated.Value<0>;
    isNotFirstLoad: Animated.Value<0>;
    static getDerivedStateFromProps(props: Props<any>): {
        extraData: any;
    };
    static defaultProps: {
        autoscrollThreshold: number;
        autoscrollSpeed: number;
        animationConfig: Animated.SpringConfig;
        scrollEnabled: boolean;
        activationDistance: number;
        refreshControlOffset: number;
    };
    constructor(props: Props<T>);
    dataKeysHaveChanged: (a: T[], b: T[]) => boolean;
    componentDidUpdate: (prevProps: Modify<any, {
        autoscrollSpeed?: number | undefined;
        autoscrollThreshold?: number | undefined;
        data: T[];
        onRef?: ((ref: any) => void) | undefined;
        onDragBegin?: ((index: number) => void) | undefined;
        onRelease?: ((index: number) => void) | undefined;
        onDragEnd?: ((params: DragEndParams<T>) => void) | undefined;
        renderItem: (params: RenderItemParams<T>) => any;
        animationConfig: Partial<Animated.SpringConfig>;
        activationDistance?: number | undefined;
        debug?: boolean | undefined;
        layoutInvalidationKey?: string | undefined;
        onScrollOffsetChange?: ((scrollOffset: number) => void) | undefined;
        refreshing?: boolean | undefined;
        onRefresh?: (() => void) | undefined;
        refreshControlOffset?: number | undefined;
    } & Partial<Readonly<{
        autoscrollThreshold: number;
        autoscrollSpeed: number;
        animationConfig: Animated.SpringConfig;
        scrollEnabled: boolean;
        activationDistance: number;
        refreshControlOffset: number;
    }>>>, prevState: State) => Promise<void>;
    flushQueue: () => Promise<void>;
    resetHoverState: () => void;
    drag: (hoverComponent: any, activeKey: string) => void;
    onRelease: ([index]: readonly number[]) => void;
    onDragEnd: ([from, to]: readonly number[]) => void;
    updateCellData: (data?: T[]) => void;
    setCellData: (key: string, index: number) => void;
    measureAll: (data: T[]) => void;
    measureCell: (key: string) => Promise<void>;
    keyExtractor: (item: T, index: number) => any;
    onContainerLayout: () => void;
    onListContentSizeChange: (w: number, h: number) => void;
    targetScrollOffset: Animated.Value<number>;
    resolveAutoscroll?: (scrollParams: readonly number[]) => void;
    onAutoscrollComplete: (params: readonly number[]) => void;
    scrollToAsync: (offset: number) => Promise<readonly number[]>;
    getScrollTargetOffset: (distFromTop: number, distFromBottom: number, scrollOffset: number, isScrolledUp: boolean, isScrolledDown: boolean) => number;
    autoscroll: ([distFromTop, distFromBottom, scrollOffset, isScrolledUp, isScrolledDown]: readonly number[]) => Promise<void>;
    isAtTopEdge: Animated.Node<0 | 1>;
    isAtBottomEdge: Animated.Node<0 | 1>;
    isAtEdge: Animated.Node<0 | 1>;
    autoscrollParams: Animated.Node<number>[];
    checkAutoscroll: Animated.Node<number>;
    onScroll: (...args: any[]) => void;
    scrollToContent: (animated?: boolean) => void;
    onGestureRelease: Animated.Node<number>[];
    onPanStateChange: (...args: any[]) => void;
    onPanGestureEvent: (...args: any[]) => void;
    hoverComponentTranslate: Animated.Node<number>;
    hoverComponentOpacity: Animated.Node<0 | 1>;
    renderHoverComponent: () => any;
    renderItem: ({ item, index }: {
        item: T;
        index: number;
    }) => any;
    CellRendererComponent: (cellProps: any) => any;
    renderDebug(): any;
    onContainerTouchEnd: () => void;
    componentDidMount(): void;
    render(): any;
}
export default DraggableFlatList;