/// <reference types="react" />
import * as React$1 from 'react';
import React__default, { PointerEvent, MutableRefObject } from 'react';

declare type Coordinates = {
    x: number;
    y: number;
};

declare type Transform = {
    x: number;
    y: number;
    scaleX: number;
    scaleY: number;
};

declare type Without<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

declare type DistanceMeasurement = number | Coordinates | Pick<Coordinates, 'x'> | Pick<Coordinates, 'y'>;
declare type Translate = Coordinates;

interface Collision {
    id: UniqueIdentifier;
    data?: Data;
}
declare type CollisionDetection = (args: {
    active: Active;
    collisionRect: ClientRect;
    droppableRects: RectMap;
    droppableContainers: DroppableContainer[];
    pointerCoordinates: Coordinates | null;
}) => Collision[];

/**
 * Returns the closest rectangles from an array of rectangles to the center of a given
 * rectangle.
 */
declare const closestCenter: CollisionDetection;

interface DistanceConstraint {
    distance: DistanceMeasurement;
    tolerance?: DistanceMeasurement;
}
interface DelayConstraint {
    delay: number;
    tolerance: DistanceMeasurement;
}
interface EventDescriptor {
    name: keyof DocumentEventMap;
    passive?: boolean;
}
interface PointerEventHandlers {
    cancel?: EventDescriptor;
    move: EventDescriptor;
    end: EventDescriptor;
}
declare type PointerActivationConstraint = DelayConstraint | DistanceConstraint | (DelayConstraint & DistanceConstraint);
interface AbstractPointerSensorOptions extends SensorOptions {
    activationConstraint?: PointerActivationConstraint;
    bypassActivationConstraint?(props: Pick<AbstractPointerSensorProps, 'activeNode' | 'event' | 'options'>): boolean;
    onActivation?({ event }: {
        event: Event;
    }): void;
}
declare type AbstractPointerSensorProps = SensorProps<AbstractPointerSensorOptions>;
declare class AbstractPointerSensor implements SensorInstance {
    private props;
    private events;
    autoScrollEnabled: boolean;
    private document;
    private activated;
    private initialCoordinates;
    private timeoutId;
    private listeners;
    private documentListeners;
    private windowListeners;
    constructor(props: AbstractPointerSensorProps, events: PointerEventHandlers, listenerTarget?: Document | EventTarget);
    private attach;
    private detach;
    private handlePending;
    private handleStart;
    private handleMove;
    private handleEnd;
    private handleCancel;
    private handleKeydown;
    private removeTextSelection;
}

interface PointerSensorOptions extends AbstractPointerSensorOptions {
}
declare type PointerSensorProps = SensorProps<PointerSensorOptions>;
declare class PointerSensor extends AbstractPointerSensor {
    constructor(props: PointerSensorProps);
    static activators: {
        eventName: "onPointerDown";
        handler: ({ nativeEvent: event }: PointerEvent, { onActivation }: PointerSensorOptions) => boolean;
    }[];
}

declare type SensorContext = {
    activatorEvent: Event | null;
    active: Active | null;
    activeNode: HTMLElement | null;
    collisionRect: ClientRect | null;
    collisions: Collision[] | null;
    draggableNodes: DraggableNodes;
    draggingNode: HTMLElement | null;
    draggingNodeRect: ClientRect | null;
    droppableRects: RectMap;
    droppableContainers: DroppableContainers;
    over: Over | null;
    scrollableAncestors: Element[];
    scrollAdjustedTranslate: Translate | null;
};
declare type SensorOptions = {};
interface SensorProps<T> {
    active: UniqueIdentifier;
    activeNode: DraggableNode;
    event: Event;
    context: MutableRefObject<SensorContext>;
    options: T;
    onAbort(id: UniqueIdentifier): void;
    onPending(id: UniqueIdentifier, constraint: PointerActivationConstraint, initialCoordinates: Coordinates, offset?: Coordinates | undefined): void;
    onStart(coordinates: Coordinates): void;
    onCancel(): void;
    onMove(coordinates: Coordinates): void;
    onEnd(): void;
}
declare type SensorInstance = {
    autoScrollEnabled: boolean;
};
declare type SensorActivatorFunction<T> = (event: any, options: T, context: {
    active: DraggableNode;
}) => boolean | undefined;
declare type Activator<T> = {
    eventName: SyntheticEventName;
    handler: SensorActivatorFunction<T>;
};
declare type Activators<T> = Activator<T>[];
declare type Teardown = () => void;
interface Sensor<T extends Object> {
    new (props: SensorProps<T>): SensorInstance;
    activators: Activators<T>;
    setup?(): Teardown | undefined;
}
declare type SensorDescriptor<T extends Object> = {
    sensor: Sensor<T>;
    options: T;
};

declare function useSensor<T extends SensorOptions>(sensor: Sensor<T>, options?: T): SensorDescriptor<T>;

declare function useSensors(...sensors: (SensorDescriptor<any> | undefined | null)[]): SensorDescriptor<SensorOptions>[];

declare type KeyboardCodes = {
    start: KeyboardEvent['code'][];
    cancel: KeyboardEvent['code'][];
    end: KeyboardEvent['code'][];
};
declare type KeyboardCoordinateGetter = (event: KeyboardEvent, args: {
    active: UniqueIdentifier;
    currentCoordinates: Coordinates;
    context: SensorContext;
}) => Coordinates | void;

interface KeyboardSensorOptions extends SensorOptions {
    keyboardCodes?: KeyboardCodes;
    coordinateGetter?: KeyboardCoordinateGetter;
    scrollBehavior?: ScrollBehavior;
    onActivation?({ event }: {
        event: KeyboardEvent;
    }): void;
}
declare type KeyboardSensorProps = SensorProps<KeyboardSensorOptions>;
declare class KeyboardSensor implements SensorInstance {
    private props;
    autoScrollEnabled: boolean;
    private referenceCoordinates;
    private listeners;
    private windowListeners;
    constructor(props: KeyboardSensorProps);
    private attach;
    private handleStart;
    private handleKeyDown;
    private handleMove;
    private handleEnd;
    private handleCancel;
    private detach;
    static activators: Activators<KeyboardSensorOptions>;
}

interface DragEvent {
    activatorEvent: Event;
    active: Active;
    collisions: Collision[] | null;
    delta: Translate;
    over: Over | null;
}
/**
 * Fired if a pending drag was aborted before it started.
 * Only meaningful in the context of activation constraints.
 **/
interface DragAbortEvent {
    id: UniqueIdentifier;
}
/**
 * Fired when a drag is about to start pending activation constraints.
 * @note For pointer events, it will be fired repeatedly with updated
 * coordinates when pointer is moved until the drag starts.
 */
interface DragPendingEvent {
    id: UniqueIdentifier;
    constraint: PointerActivationConstraint;
    initialCoordinates: Coordinates;
    offset?: Coordinates | undefined;
}
interface DragStartEvent extends Pick<DragEvent, 'active' | 'activatorEvent'> {
}
interface DragMoveEvent extends DragEvent {
}
interface DragOverEvent extends DragMoveEvent {
}
interface DragEndEvent extends DragEvent {
}
interface DragCancelEvent extends DragEndEvent {
}

declare type UniqueIdentifier = string | number;

declare type SyntheticEventName = keyof Without<React.DOMAttributes<any>, 'children' | 'dangerouslySetInnerHTML'>;

interface ClientRect {
    width: number;
    height: number;
    top: number;
    left: number;
    right: number;
    bottom: number;
}

declare enum AutoScrollActivator {
    Pointer = 0,
    DraggableRect = 1
}
interface Options {
    acceleration?: number;
    activator?: AutoScrollActivator;
    canScroll?: CanScroll;
    enabled?: boolean;
    interval?: number;
    layoutShiftCompensation?: boolean | {
        x: boolean;
        y: boolean;
    };
    order?: TraversalOrder;
    threshold?: {
        x: number;
        y: number;
    };
}
declare type CanScroll = (element: Element) => boolean;
declare enum TraversalOrder {
    TreeOrder = 0,
    ReversedTreeOrder = 1
}

declare enum MeasuringStrategy {
    Always = 0,
    BeforeDragging = 1,
    WhileDragging = 2
}
declare enum MeasuringFrequency {
    Optimized = "optimized"
}
declare type MeasuringFunction$1 = (element: HTMLElement) => ClientRect;
interface DroppableMeasuring {
    measure: MeasuringFunction$1;
    strategy: MeasuringStrategy;
    frequency: MeasuringFrequency | number;
}

declare type Identifier = UniqueIdentifier | null | undefined;
declare class DroppableContainersMap extends Map<UniqueIdentifier, DroppableContainer> {
    get(id: Identifier): DroppableContainer | undefined;
    toArray(): DroppableContainer[];
    getEnabled(): DroppableContainer[];
    getNodeFor(id: Identifier): HTMLElement | undefined;
}

declare type AnyData = Record<string, any>;
declare type Data<T = AnyData> = T & AnyData;
declare type DataRef<T = AnyData> = MutableRefObject<Data<T> | undefined>;
interface DroppableContainer {
    id: UniqueIdentifier;
    key: UniqueIdentifier;
    data: DataRef;
    disabled: boolean;
    node: MutableRefObject<HTMLElement | null>;
    rect: MutableRefObject<ClientRect | null>;
}
interface Active {
    id: UniqueIdentifier;
    data: DataRef;
    rect: MutableRefObject<{
        initial: ClientRect | null;
        translated: ClientRect | null;
    }>;
}
interface Over {
    id: UniqueIdentifier;
    rect: ClientRect;
    disabled: boolean;
    data: DataRef;
}
declare type DraggableNode = {
    id: UniqueIdentifier;
    key: UniqueIdentifier;
    node: MutableRefObject<HTMLElement | null>;
    activatorNode: MutableRefObject<HTMLElement | null>;
    data: DataRef;
};
declare type DraggableNodes = Map<UniqueIdentifier, DraggableNode | undefined>;
declare type DroppableContainers = DroppableContainersMap;
declare type RectMap = Map<UniqueIdentifier, ClientRect>;

interface Arguments {
    active: Active;
    over: Over | null;
}
interface Announcements {
    onDragStart({ active }: Pick<Arguments, 'active'>): string | undefined;
    onDragMove?({ active, over }: Arguments): string | undefined;
    onDragOver({ active, over }: Arguments): string | undefined;
    onDragEnd({ active, over }: Arguments): string | undefined;
    onDragCancel({ active, over }: Arguments): string | undefined;
}
interface ScreenReaderInstructions {
    draggable: string;
}

declare type Modifier = (args: {
    activatorEvent: Event | null;
    active: Active | null;
    activeNodeRect: ClientRect | null;
    draggingNodeRect: ClientRect | null;
    containerNodeRect: ClientRect | null;
    over: Over | null;
    overlayNodeRect: ClientRect | null;
    scrollableAncestors: Element[];
    scrollableAncestorRects: ClientRect[];
    transform: Transform;
    windowRect: ClientRect | null;
}) => Transform;
declare type Modifiers = Modifier[];

declare type MeasuringFunction = (node: HTMLElement) => ClientRect;
interface Measuring {
    measure: MeasuringFunction;
}
interface DraggableMeasuring extends Measuring {
}
interface DragOverlayMeasuring extends Measuring {
}
interface MeasuringConfiguration {
    draggable?: Partial<DraggableMeasuring>;
    droppable?: Partial<DroppableMeasuring>;
    dragOverlay?: Partial<DragOverlayMeasuring>;
}

interface Props {
    id?: string;
    accessibility?: {
        announcements?: Announcements;
        container?: Element;
        restoreFocus?: boolean;
        screenReaderInstructions?: ScreenReaderInstructions;
    };
    autoScroll?: boolean | Options;
    cancelDrop?: CancelDrop;
    children?: React__default.ReactNode;
    collisionDetection?: CollisionDetection;
    measuring?: MeasuringConfiguration;
    modifiers?: Modifiers;
    sensors?: SensorDescriptor<any>[];
    onDragAbort?(event: DragAbortEvent): void;
    onDragPending?(event: DragPendingEvent): void;
    onDragStart?(event: DragStartEvent): void;
    onDragMove?(event: DragMoveEvent): void;
    onDragOver?(event: DragOverEvent): void;
    onDragEnd?(event: DragEndEvent): void;
    onDragCancel?(event: DragCancelEvent): void;
}
interface CancelDropArguments extends DragEndEvent {
}
declare type CancelDrop = (args: CancelDropArguments) => boolean | Promise<boolean>;
declare const DndContext: React__default.NamedExoticComponent<Props>;

interface ResizeObserverConfig {
    /** Whether the ResizeObserver should be disabled entirely */
    disabled?: boolean;
    /** Resize events may affect the layout and position of other droppable containers.
     * Specify an array of `UniqueIdentifier` of droppable containers that should also be re-measured
     * when this droppable container resizes. Specifying an empty array re-measures all droppable containers.
     */
    updateMeasurementsFor?: UniqueIdentifier[];
    /** Represents the debounce timeout between when resize events are observed and when elements are re-measured */
    timeout?: number;
}
interface UseDroppableArguments {
    id: UniqueIdentifier;
    disabled?: boolean;
    data?: Data;
    resizeObserverConfig?: ResizeObserverConfig;
}
declare function useDroppable({ data, disabled, id, resizeObserverConfig, }: UseDroppableArguments): {
    active: Active | null;
    rect: React$1.MutableRefObject<ClientRect | null>;
    isOver: boolean;
    node: React$1.MutableRefObject<HTMLElement | null>;
    over: Over | null;
    setNodeRef: (element: HTMLElement | null) => void;
};

export { DndContext, KeyboardSensor, PointerSensor, closestCenter, useDroppable, useSensor, useSensors };
export type { DragEndEvent };