@lucasols/dnd-kit-core 0.1.4 → 0.2.0

package/dist/index.d.ts

@@ -1,12 +1,655 @@
-export { DndContext, DragOverlay, defaultAnnouncements, defaultScreenReaderInstructions, defaultDropAnimation, defaultDropAnimationSideEffects, useDndMonitor, } from './components';
-export type { Announcements, CancelDrop, DndContextProps, DndMonitorListener, DndMonitorListener as DndMonitorArguments, DragOverlayProps, DropAnimation, DropAnimationFunction, DropAnimationFunctionArguments, DropAnimationKeyframeResolver, DropAnimationSideEffects, DraggableMeasuring, MeasuringConfiguration, ScreenReaderInstructions, } from './components';
-export { AutoScrollActivator, MeasuringFrequency, MeasuringStrategy, TraversalOrder, useDraggable, useDndContext, useDroppable, } from './hooks';
-export type { AutoScrollOptions, DraggableAttributes, DraggableSyntheticListeners, DroppableMeasuring, UseDndContextReturnValue, UseDraggableArguments, UseDroppableArguments, } from './hooks';
-export { applyModifiers } from './modifiers';
-export type { Modifier, Modifiers } from './modifiers';
-export { KeyboardSensor, KeyboardCode, MouseSensor, PointerSensor, TouchSensor, useSensors, useSensor, } from './sensors';
-export type { Activator, Activators, PointerActivationConstraint, KeyboardCodes, KeyboardCoordinateGetter, KeyboardSensorOptions, KeyboardSensorProps, MouseSensorOptions, PointerEventHandlers, PointerSensorOptions, PointerSensorProps, Sensor, Sensors, SensorContext, SensorDescriptor, SensorHandler, SensorInstance, SensorOptions, SensorProps, SensorResponse, TouchSensorOptions, } from './sensors';
-export type { Active, Data, DataRef, PublicContextDescriptor as DndContextDescriptor, DraggableNode, DroppableContainers, DroppableContainer, Over, } from './store';
-export type { ClientRect, DistanceMeasurement, DragEndEvent, DragMoveEvent, DragOverEvent, DragStartEvent, DragCancelEvent, Translate, UniqueIdentifier, } from './types';
-export { defaultCoordinates, getClientRect, getFirstCollision, getScrollableAncestors, closestCenter, closestCorners, rectIntersection, pointerWithin, } from './utilities';
-export type { Collision, CollisionDescriptor, CollisionDetection, } from './utilities';
+import React$1, { ContextType, MouseEvent as MouseEvent$1, MutableRefObject, PointerEvent, TouchEvent as TouchEvent$1 } from "react";
+import { Coordinates, DeepRequired, FirstArgument, Transform, Without } from "@lucasols/dnd-kit-utilities";
+//#region src/types/coordinates.d.ts
+type DistanceMeasurement = number | Coordinates | Pick<Coordinates, 'x'> | Pick<Coordinates, 'y'>;
+type Translate = Coordinates;
+//#endregion
+//#region src/utilities/algorithms/types.d.ts
+interface Collision {
+  id: UniqueIdentifier;
+  data?: Data;
+}
+interface CollisionDescriptor extends Collision {
+  data: {
+    droppableContainer: DroppableContainer;
+    value: number;
+    [key: string]: any;
+  };
+}
+type CollisionDetection = (args: {
+  active: Active;
+  collisionRect: ClientRect;
+  droppableRects: RectMap;
+  droppableContainers: DroppableContainer[];
+  pointerCoordinates: Coordinates | null;
+}) => Collision[];
+//#endregion
+//#region src/utilities/algorithms/closestCenter.d.ts
+/**
+ * Returns the closest rectangles from an array of rectangles to the center of a given
+ * rectangle.
+ */
+export declare const closestCenter: CollisionDetection;
+//#endregion
+//#region src/utilities/algorithms/closestCorners.d.ts
+/**
+ * Returns the closest rectangles from an array of rectangles to the corners of
+ * another rectangle.
+ */
+export declare const closestCorners: CollisionDetection;
+//#endregion
+//#region src/utilities/algorithms/rectIntersection.d.ts
+/**
+ * Returns the rectangles that has the greatest intersection area with a given
+ * rectangle in an array of rectangles.
+ */
+export declare const rectIntersection: CollisionDetection;
+//#endregion
+//#region src/utilities/algorithms/pointerWithin.d.ts
+/**
+ * Returns the rectangles that the pointer is hovering over
+ */
+export declare const pointerWithin: CollisionDetection;
+//#endregion
+//#region src/utilities/algorithms/helpers.d.ts
+/**
+ * Returns the first collision, or null if there isn't one.
+ * If a property is specified, returns the specified property of the first collision.
+ */
+export declare function getFirstCollision(collisions: Collision[] | null | undefined): Collision | null;
+export declare function getFirstCollision<T extends keyof Collision>(collisions: Collision[] | null | undefined, property: T): Collision[T] | null;
+//#endregion
+//#region src/types/events.d.ts
+interface DragEvent {
+  activatorEvent: Event;
+  active: Active;
+  collisions: Collision[] | null;
+  delta: Translate;
+  over: Over | null;
+}
+interface DragStartEvent extends Pick<DragEvent, 'active'> {}
+interface DragMoveEvent extends DragEvent {}
+interface DragOverEvent extends DragMoveEvent {}
+interface DragEndEvent extends DragEvent {}
+interface DragCancelEvent extends DragEndEvent {}
+//#endregion
+//#region src/types/other.d.ts
+type UniqueIdentifier = string | number;
+//#endregion
+//#region src/types/react.d.ts
+type SyntheticEventName = keyof Without<React.DOMAttributes<any>, 'children' | 'dangerouslySetInnerHTML'>;
+//#endregion
+//#region src/types/rect.d.ts
+interface ClientRect {
+  width: number;
+  height: number;
+  top: number;
+  left: number;
+  right: number;
+  bottom: number;
+}
+//#endregion
+//#region src/hooks/utilities/useAutoScroller.d.ts
+export 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;
+  };
+}
+type CanScroll = (element: Element) => boolean;
+export declare enum TraversalOrder {
+  TreeOrder = 0,
+  ReversedTreeOrder = 1
+}
+//#endregion
+//#region src/sensors/types.d.ts
+declare enum Response {
+  Start = "start",
+  Move = "move",
+  End = "end"
+}
+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;
+};
+type SensorOptions = {};
+interface SensorProps<T> {
+  active: UniqueIdentifier;
+  activeNode: DraggableNode;
+  event: Event;
+  context: MutableRefObject<SensorContext>;
+  options: T;
+  onStart(coordinates: Coordinates): void;
+  onCancel(): void;
+  onMove(coordinates: Coordinates): void;
+  onEnd(): void;
+}
+type SensorInstance = {
+  autoScrollEnabled: boolean;
+};
+type SensorActivatorFunction<T> = (event: any, options: T, context: {
+  active: DraggableNode;
+}) => boolean | undefined;
+type Activator<T> = {
+  eventName: SyntheticEventName;
+  handler: SensorActivatorFunction<T>;
+};
+type Activators<T> = Activator<T>[];
+type Teardown = () => void;
+interface Sensor<T extends Object> {
+  new (props: SensorProps<T>): SensorInstance;
+  activators: Activators<T>;
+  setup?(): Teardown | undefined;
+}
+type Sensors = Sensor<any>[];
+type SensorDescriptor<T extends Object> = {
+  sensor: Sensor<T>;
+  options: T;
+};
+type SensorHandler = (event: React.SyntheticEvent, active: UniqueIdentifier) => boolean | void;
+//#endregion
+//#region src/sensors/useSensor.d.ts
+export declare function useSensor<T extends SensorOptions>(sensor: Sensor<T>, options?: T): SensorDescriptor<T>;
+//#endregion
+//#region src/sensors/useSensors.d.ts
+export declare function useSensors(...sensors: (SensorDescriptor<any> | undefined | null)[]): SensorDescriptor<SensorOptions>[];
+//#endregion
+//#region src/sensors/pointer/AbstractPointerSensor.d.ts
+interface DistanceConstraint {
+  distance: DistanceMeasurement;
+  tolerance?: DistanceMeasurement;
+}
+interface DelayConstraint {
+  delay: number;
+  tolerance: DistanceMeasurement;
+}
+interface EventDescriptor {
+  name: keyof DocumentEventMap;
+  passive?: boolean;
+}
+interface PointerEventHandlers {
+  move: EventDescriptor;
+  end: EventDescriptor;
+}
+type PointerActivationConstraint = DistanceConstraint | DelayConstraint;
+interface AbstractPointerSensorOptions extends SensorOptions {
+  activationConstraint?: PointerActivationConstraint;
+  onActivation?({ event }: {
+    event: Event;
+  }): void;
+}
+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 handleStart;
+  private handleMove;
+  private handleEnd;
+  private handleCancel;
+  private handleKeydown;
+  private removeTextSelection;
+}
+//#endregion
+//#region src/sensors/pointer/PointerSensor.d.ts
+interface PointerSensorOptions extends AbstractPointerSensorOptions {}
+type PointerSensorProps = SensorProps<PointerSensorOptions>;
+export declare class PointerSensor extends AbstractPointerSensor {
+  constructor(props: PointerSensorProps);
+  static activators: {
+    eventName: 'onPointerDown';
+    handler: ({ nativeEvent: event }: PointerEvent, { onActivation }: PointerSensorOptions) => boolean;
+  }[];
+}
+//#endregion
+//#region src/sensors/mouse/MouseSensor.d.ts
+interface MouseSensorOptions extends AbstractPointerSensorOptions {}
+type MouseSensorProps = SensorProps<MouseSensorOptions>;
+export declare class MouseSensor extends AbstractPointerSensor {
+  constructor(props: MouseSensorProps);
+  static activators: {
+    eventName: 'onMouseDown';
+    handler: ({ nativeEvent: event }: MouseEvent$1, { onActivation }: MouseSensorOptions) => boolean;
+  }[];
+}
+//#endregion
+//#region src/sensors/touch/TouchSensor.d.ts
+interface TouchSensorOptions extends PointerSensorOptions {}
+export declare class TouchSensor extends AbstractPointerSensor {
+  constructor(props: PointerSensorProps);
+  static activators: {
+    eventName: 'onTouchStart';
+    handler: ({ nativeEvent: event }: TouchEvent$1, { onActivation }: TouchSensorOptions) => boolean;
+  }[];
+  static setup(): () => void;
+}
+//#endregion
+//#region src/sensors/keyboard/types.d.ts
+export declare enum KeyboardCode {
+  Space = "Space",
+  Down = "ArrowDown",
+  Right = "ArrowRight",
+  Left = "ArrowLeft",
+  Up = "ArrowUp",
+  Esc = "Escape",
+  Enter = "Enter"
+}
+type KeyboardCodes = {
+  start: KeyboardEvent['code'][];
+  cancel: KeyboardEvent['code'][];
+  end: KeyboardEvent['code'][];
+};
+type KeyboardCoordinateGetter = (event: KeyboardEvent, args: {
+  active: UniqueIdentifier;
+  currentCoordinates: Coordinates;
+  context: SensorContext;
+}) => Coordinates | void;
+//#endregion
+//#region src/sensors/keyboard/KeyboardSensor.d.ts
+interface KeyboardSensorOptions extends SensorOptions {
+  keyboardCodes?: KeyboardCodes;
+  coordinateGetter?: KeyboardCoordinateGetter;
+  scrollBehavior?: ScrollBehavior;
+  onActivation?({ event }: {
+    event: KeyboardEvent;
+  }): void;
+}
+type KeyboardSensorProps = SensorProps<KeyboardSensorOptions>;
+export 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>;
+}
+//#endregion
+//#region src/hooks/utilities/useSyntheticListeners.d.ts
+type SyntheticListenerMap = Record<string, Function>;
+//#endregion
+//#region src/hooks/utilities/useDroppableMeasuring.d.ts
+export declare enum MeasuringStrategy {
+  Always = 0,
+  BeforeDragging = 1,
+  WhileDragging = 2
+}
+export declare enum MeasuringFrequency {
+  Optimized = "optimized"
+}
+type MeasuringFunction$1 = (element: HTMLElement) => ClientRect;
+interface DroppableMeasuring {
+  measure: MeasuringFunction$1;
+  strategy: MeasuringStrategy;
+  frequency: MeasuringFrequency | number;
+}
+//#endregion
+//#region src/store/constructors.d.ts
+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;
+}
+//#endregion
+//#region src/store/types.d.ts
+type AnyData = Record<string, any>;
+type Data<T = AnyData> = T & AnyData;
+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;
+}
+type DraggableNode = {
+  id: UniqueIdentifier;
+  key: UniqueIdentifier;
+  node: MutableRefObject<HTMLElement | null>;
+  activatorNode: MutableRefObject<HTMLElement | null>;
+  data: DataRef;
+};
+type DraggableNodes = Map<UniqueIdentifier, DraggableNode | undefined>;
+type DroppableContainers = DroppableContainersMap;
+type RectMap = Map<UniqueIdentifier, ClientRect>;
+interface PublicContextDescriptor {
+  activatorEvent: Event | null;
+  active: Active | null;
+  activeNode: HTMLElement | null;
+  activeNodeRect: ClientRect | null;
+  collisions: Collision[] | null;
+  containerNodeRect: ClientRect | null;
+  draggableNodes: DraggableNodes;
+  droppableContainers: DroppableContainers;
+  droppableRects: RectMap;
+  over: Over | null;
+  dragOverlay: {
+    nodeRef: MutableRefObject<HTMLElement | null>;
+    rect: ClientRect | null;
+    setRef: (element: HTMLElement | null) => void;
+  };
+  scrollableAncestors: Element[];
+  scrollableAncestorRects: ClientRect[];
+  measuringConfiguration: DeepRequired<MeasuringConfiguration>;
+  measureDroppableContainers(ids: UniqueIdentifier[]): void;
+  measuringScheduled: boolean;
+  windowRect: ClientRect | null;
+}
+//#endregion
+//#region src/store/context.d.ts
+declare const PublicContext: import("react").Context<PublicContextDescriptor>;
+//#endregion
+//#region src/components/Accessibility/types.d.ts
+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;
+}
+//#endregion
+//#region src/components/Accessibility/defaults.d.ts
+export declare const defaultScreenReaderInstructions: ScreenReaderInstructions;
+export declare const defaultAnnouncements: Announcements;
+//#endregion
+//#region src/utilities/coordinates/constants.d.ts
+export declare const defaultCoordinates: Coordinates;
+//#endregion
+//#region src/utilities/rect/getRect.d.ts
+interface Options$1 {
+  ignoreTransform?: boolean;
+}
+/**
+ * Returns the bounding client rect of an element relative to the viewport.
+ */
+export declare function getClientRect(element: Element, options?: Options$1): {
+  top: number;
+  left: number;
+  width: number;
+  height: number;
+  bottom: number;
+  right: number;
+};
+//#endregion
+//#region src/utilities/scroll/getScrollableAncestors.d.ts
+export declare function getScrollableAncestors(element: Node | null, limit?: number): Element[];
+//#endregion
+//#region src/modifiers/types.d.ts
+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;
+type Modifiers = Modifier[];
+//#endregion
+//#region src/modifiers/applyModifiers.d.ts
+export declare function applyModifiers(modifiers: Modifiers | undefined, { transform, ...args }: FirstArgument<Modifier>): Transform;
+//#endregion
+//#region src/components/DndContext/types.d.ts
+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>;
+}
+//#endregion
+//#region src/components/DndContext/DndContext.d.ts
+interface Props {
+  id?: string;
+  accessibility?: {
+    announcements?: Announcements;
+    container?: Element;
+    restoreFocus?: boolean;
+    screenReaderInstructions?: ScreenReaderInstructions;
+  };
+  autoScroll?: boolean | Options;
+  cancelDrop?: CancelDrop;
+  children?: React$1.ReactNode;
+  collisionDetection?: CollisionDetection;
+  measuring?: MeasuringConfiguration;
+  modifiers?: Modifiers;
+  sensors?: SensorDescriptor<any>[];
+  onDragStart?(event: DragStartEvent): void;
+  onDragMove?(event: DragMoveEvent): void;
+  onDragOver?(event: DragOverEvent): void;
+  onDragEnd?(event: DragEndEvent): void;
+  onDragCancel?(event: DragCancelEvent): void;
+}
+interface CancelDropArguments extends DragEndEvent {}
+type CancelDrop = (args: CancelDropArguments) => boolean | Promise<boolean>;
+export declare const DndContext: React$1.MemoExoticComponent<({ id, accessibility, autoScroll, children, sensors, collisionDetection, measuring, modifiers, ...props }: Props) => React$1.JSX.Element>;
+//#endregion
+//#region src/components/DndMonitor/types.d.ts
+interface DndMonitorListener {
+  onDragStart?(event: DragStartEvent): void;
+  onDragMove?(event: DragMoveEvent): void;
+  onDragOver?(event: DragOverEvent): void;
+  onDragEnd?(event: DragEndEvent): void;
+  onDragCancel?(event: DragCancelEvent): void;
+}
+//#endregion
+//#region src/components/DndMonitor/useDndMonitor.d.ts
+export declare function useDndMonitor(listener: DndMonitorListener): void;
+//#endregion
+//#region src/components/DragOverlay/components/PositionedOverlay/PositionedOverlay.d.ts
+type TransitionGetter = (activatorEvent: Event | null) => React$1.CSSProperties['transition'] | undefined;
+interface Props$2 {
+  as: keyof React$1.JSX.IntrinsicElements;
+  activatorEvent: Event | null;
+  adjustScale?: boolean;
+  children?: React$1.ReactNode;
+  className?: string;
+  id: UniqueIdentifier;
+  rect: ClientRect | null;
+  style?: React$1.CSSProperties;
+  transition?: string | TransitionGetter;
+  transform: Transform;
+}
+//#endregion
+//#region src/components/DragOverlay/hooks/useDropAnimation.d.ts
+interface SharedParameters {
+  active: {
+    id: UniqueIdentifier;
+    data: Active['data'];
+    node: HTMLElement;
+    rect: ClientRect;
+  };
+  dragOverlay: {
+    node: HTMLElement;
+    rect: ClientRect;
+  };
+  draggableNodes: DraggableNodes;
+  droppableContainers: DroppableContainers;
+  measuringConfiguration: DeepRequired<MeasuringConfiguration>;
+}
+interface KeyframeResolverParameters extends SharedParameters {
+  transform: {
+    initial: Transform;
+    final: Transform;
+  };
+}
+type KeyframeResolver = (parameters: KeyframeResolverParameters) => Keyframe[];
+interface DropAnimationOptions {
+  keyframes?: KeyframeResolver;
+  duration?: number;
+  easing?: string;
+  sideEffects?: DropAnimationSideEffects | null;
+}
+type DropAnimation = DropAnimationFunction | DropAnimationOptions;
+interface DropAnimationFunctionArguments extends SharedParameters {
+  transform: Transform;
+}
+type DropAnimationFunction = (args: DropAnimationFunctionArguments) => Promise<void> | void;
+type CleanupFunction = () => void;
+interface DropAnimationSideEffectsParameters extends SharedParameters {}
+type DropAnimationSideEffects = (parameters: DropAnimationSideEffectsParameters) => CleanupFunction | void;
+type ExtractStringProperties<T> = { [K in keyof T]?: T[K] extends string ? string : never; };
+type Styles = ExtractStringProperties<CSSStyleDeclaration>;
+interface DefaultDropAnimationSideEffectsOptions {
+  className?: {
+    active?: string;
+    dragOverlay?: string;
+  };
+  styles?: {
+    active?: Styles;
+    dragOverlay?: Styles;
+  };
+}
+export declare const defaultDropAnimationSideEffects: (options: DefaultDropAnimationSideEffectsOptions) => DropAnimationSideEffects;
+declare const defaultDropAnimationConfiguration: Required<DropAnimationOptions>;
+//#endregion
+//#region src/components/DragOverlay/DragOverlay.d.ts
+interface Props$1 extends Pick<Props$2, 'adjustScale' | 'children' | 'className' | 'style' | 'transition'> {
+  dropAnimation?: DropAnimation | null | undefined;
+  modifiers?: Modifiers;
+  wrapperElement?: keyof React$1.JSX.IntrinsicElements;
+  zIndex?: number;
+}
+export declare const DragOverlay: React$1.MemoExoticComponent<({ adjustScale, children, dropAnimation: dropAnimationConfig, style, transition, modifiers, wrapperElement, className, zIndex }: Props$1) => React$1.JSX.Element>;
+//#endregion
+//#region src/hooks/useDraggable.d.ts
+interface UseDraggableArguments {
+  id: UniqueIdentifier;
+  data?: Data;
+  disabled?: boolean;
+  attributes?: {
+    role?: string;
+    roleDescription?: string;
+    tabIndex?: number;
+  };
+}
+interface DraggableAttributes {
+  role: string;
+  tabIndex: number;
+  'aria-disabled': boolean;
+  'aria-pressed': boolean | undefined;
+  'aria-roledescription': string;
+  'aria-describedby': string;
+}
+type DraggableSyntheticListeners = SyntheticListenerMap | undefined;
+export declare function useDraggable({ id, data, disabled, attributes }: UseDraggableArguments): {
+  active: Active | null;
+  activatorEvent: Event | null;
+  activeNodeRect: ClientRect | null;
+  attributes: DraggableAttributes;
+  isDragging: boolean;
+  listeners: DraggableSyntheticListeners;
+  node: import("react").RefObject<HTMLElement | null>;
+  over: Over | null;
+  setNodeRef: (element: HTMLElement | null) => void;
+  setActivatorNodeRef: (element: HTMLElement | null) => void;
+  transform: Transform | null;
+};
+//#endregion
+//#region src/hooks/useDndContext.d.ts
+export declare function useDndContext(): PublicContextDescriptor;
+type UseDndContextReturnValue = ContextType<typeof PublicContext>;
+//#endregion
+//#region src/hooks/useDroppable.d.ts
+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;
+}
+export declare function useDroppable({ data, disabled, id, resizeObserverConfig }: UseDroppableArguments): {
+  active: Active | null;
+  rect: import("react").RefObject<ClientRect | null>;
+  isOver: boolean;
+  node: import("react").RefObject<HTMLElement | null>;
+  over: Over | null;
+  setNodeRef: (element: HTMLElement | null) => void;
+};
+//#endregion
+export { type Activator, type Activators, type Active, type Announcements, type Options as AutoScrollOptions, type CancelDrop, type ClientRect, type Collision, type CollisionDescriptor, type CollisionDetection, type Data, type DataRef, type DistanceMeasurement, type PublicContextDescriptor as DndContextDescriptor, type Props as DndContextProps, type DndMonitorListener as DndMonitorArguments, type DndMonitorListener, type DragCancelEvent, type DragEndEvent, type DragMoveEvent, type DragOverEvent, type Props$1 as DragOverlayProps, type DragStartEvent, type DraggableAttributes, type DraggableMeasuring, type DraggableNode, type DraggableSyntheticListeners, type DropAnimation, type DropAnimationFunction, type DropAnimationFunctionArguments, type KeyframeResolver as DropAnimationKeyframeResolver, type DropAnimationSideEffects, type DroppableContainer, type DroppableContainers, type DroppableMeasuring, type KeyboardCodes, type KeyboardCoordinateGetter, type KeyboardSensorOptions, type KeyboardSensorProps, type MeasuringConfiguration, type Modifier, type Modifiers, type MouseSensorOptions, type Over, type PointerActivationConstraint, type PointerEventHandlers, type PointerSensorOptions, type PointerSensorProps, type ScreenReaderInstructions, type Sensor, type SensorContext, type SensorDescriptor, type SensorHandler, type SensorInstance, type SensorOptions, type SensorProps, type Response as SensorResponse, type Sensors, type TouchSensorOptions, type Translate, type UniqueIdentifier, type UseDndContextReturnValue, type UseDraggableArguments, type UseDroppableArguments, defaultDropAnimationConfiguration as defaultDropAnimation };
+//# sourceMappingURL=index.d.ts.map