@types/react-beautiful-dnd

draggableId: DraggableId;

mode: MovementMode;

border: Spacing;

borderBox: Rect;

contentBox: Rect;

margin: Spacing;

marginBox: Rect;

padding: Spacing;

paddingBox: Rect;

borderBoxCenter: Position;

offset: Position;

selection: Position;

phase: 'COLLECTING';

draggableId: DraggableId;

droppableId: DroppableId;

combine: Combine;

type: 'COMBINE';

afterCritical: LiftEffect;

critical: Critical;

impact: DragImpact;

result: DropResult;

draggable: DraggableDescriptor;

droppable: DroppableDescriptor;

draggables: DraggableDimensionMap;

droppables: DroppableDimensionMap;

backwards: DisplacementGroups;

forwards: DisplacementGroups;

point: Position;

value: number;

draggableId: DraggableId;

shouldAnimate: boolean;

all: DraggableId[];

invisible: DraggableIdMap;

visible: DisplacementMap;

[key: string]: Displacement;

cancel: (args?: StopDragOptions) => void;

drop: (args?: StopDragOptions) => void;

isActive: () => boolean;

shouldRespectForcePress: () => boolean;

children: React.ReactNode | null;

dragHandleUsageInstructions?: string | undefined;

enableDefaultSensors?: boolean | undefined;

nonce?: string | undefined;

sensors?: Sensor[] | undefined;

droppableId: DroppableId;

id: DraggableId;

index: number;

type: TypeId;

client: BoxModel;

descriptor: DraggableDescriptor;

displaceBy: Position;

page: BoxModel;

placeholder: Placeholder;

[key: string]: DraggableDimension;

[id: string]: true;

droppableId: DroppableId;

index: number;

canDragInteractiveElements: boolean;

isEnabled: boolean;

shouldRespectForcePress: boolean;

children: DraggableChildrenFn;

disableInteractiveElementBlocking?: boolean | undefined;

draggableId: DraggableId;

index: number;

isDragDisabled?: boolean | undefined;

shouldRespectForcePress?: boolean | undefined;

draggableProps: DraggableProvidedDraggableProps;

dragHandleProps: DraggableProvidedDragHandleProps | null | undefined;

innerRef: (element: HTMLElement | null) => void;

'data-rbd-draggable-context-id': string;

'data-rbd-draggable-id': string;

onTransitionEnd?: React.TransitionEventHandler<any> | undefined;

style?: DraggingStyle | NotDraggingStyle | undefined;

'aria-describedby': ElementId;

'data-rbd-drag-handle-context-id': ContextId;

'data-rbd-drag-handle-draggable-id': DraggableId;

draggable: boolean;

onDragStart: React.DragEventHandler<any>;

role: string;

tabIndex: number;

draggableId: DraggableId;

source: DraggableLocation;

type: TypeId;

combineTargetFor: DraggableId | null | undefined;

combineWith: DraggableId | null | undefined;

draggingOver: DroppableId | null | undefined;

dropAnimation: DropAnimation | null | undefined;

isClone: boolean;

isDragging: boolean;

isDropAnimating: boolean;

mode: MovementMode | null | undefined;

afterCritical: LiftEffect;

critical: Critical;

current: DragPositions;

dimensions: DimensionMap;

forceShouldAnimate: boolean | null | undefined;

impact: DragImpact;

initial: DragPositions;

isDragging: true;

isWindowScrollAllowed: boolean;

movementMode: MovementMode;

onLiftImpact: DragImpact;

phase: 'DRAGGING';

scrollJumpRequest: Position | null | undefined;

viewport: Viewport;

boxSizing: 'border-box';

height: number;

left: number;

opacity: number | undefined;

pointerEvents: 'none';

position: 'fixed';

top: number;

transform: string | undefined;

transition: string;

width: number;

zIndex: number;

at: ImpactLocation | null | undefined;

displaced: DisplacementGroups;

displacedBy: DisplacedBy;

client: ClientPositions;

page: PagePositions;

mode: MovementMode;

combine: Combine | null | undefined;

destination: DraggableLocation | null | undefined;

completed: CompletedDrag;

dimensions: DimensionMap;

dropDuration: number;

newHomeClientOffset: Position;

phase: 'DROP_ANIMATING';

curve: string;

duration: number;

moveTo: Position;

opacity: number | undefined;

scale: number | undefined;

id: DroppableId;

mode: DroppableMode;

type: TypeId;

axis: Axis;

client: BoxModel;

descriptor: DroppableDescriptor;

frame: Scrollable | null | undefined;

isCombineEnabled: boolean;

isEnabled: boolean;

isFixedOnPage: boolean;

page: BoxModel;

subject: DroppableSubject;

[key: string]: DroppableDimension;

[id: string]: true;

direction?: Direction | undefined;

droppableId: DroppableId;

getContainerForClone?: (() => HTMLElement) | undefined;

ignoreContainerClipping?: boolean | undefined;

isCombineEnabled?: boolean | undefined;

isDropDisabled?: boolean | undefined;

mode?: DroppableMode | undefined;

renderClone?: DraggableChildrenFn | undefined;

type?: TypeId | undefined;

children: (
    provided: DroppableProvided,
    snapshot: DroppableStateSnapshot
) => React.ReactElement<HTMLElement>;

droppableProps: DroppableProvidedProps;

innerRef: (element: HTMLElement | null) => void;

placeholder: React.ReactNode;

'data-rbd-droppable-context-id': ContextId;

'data-rbd-droppable-id': DroppableId;

droppableId: DroppableId;

scroll: Position;

draggingFromThisWith: DraggableId | null | undefined;

draggingOverWith: DraggableId | null | undefined;

isDraggingOver: boolean;

isUsingPlaceholder: boolean;

active: Rect | null | undefined;

page: BoxModel;

withPlaceholder: PlaceholderInSubject | null | undefined;

isWaiting: boolean;

phase: 'DROP_PENDING';

reason: DropReason;

reason: DropReason;

move: (clientSelection: Position) => void;

crossAxisEnd: 'bottom';

crossAxisLine: 'y';

crossAxisSize: 'height';

crossAxisStart: 'top';

direction: 'horizontal';

end: 'right';

line: 'x';

size: 'width';

start: 'left';

completed: CompletedDrag | null | undefined;

phase: 'IDLE';

shouldFlush: boolean;

displacedBy: DisplacedBy;

effected: DraggableIdMap;

inVirtualList: boolean;

draggableId: DraggableId;

scrollOptions: ScrollOptions;

transform: string | undefined;

transition: 'none' | undefined;

borderBoxCenter: Position;

offset: Position;

selection: Position;

client: BoxModel;

display: string;

tagName: string;

increasedBy: Position | null | undefined;

oldFrameMaxScroll: Position | null | undefined;

placeholderSize: Position;

x: number;

y: number;

abort: () => void;

fluidLift: (clientSelection: Position) => FluidDragActions;

isActive: () => boolean;

shouldRespectForcePress: () => boolean;

snapLift: () => SnapDragActions;

additions: DraggableDimension[];

modified: DroppablePublish[];

removals: DraggableId[];

bottom: number;

center: Position;

height: number;

left: number;

right: number;

top: number;

width: number;

x: number;

y: number;

destination: DraggableLocation;

type: 'REORDER';

announce: Announce;

onBeforeCapture?: OnBeforeCaptureResponder | undefined;

onBeforeDragStart?: OnBeforeDragStartResponder | undefined;

onDragEnd: OnDragEndResponder;

onDragStart?: OnDragStartResponder | undefined;

onDragUpdate?: OnDragUpdateResponder | undefined;

frameClient: BoxModel;

pageMarginBox: Rect;

scroll: ScrollDetails;

scrollSize: ScrollSize;

shouldClipSubject: boolean;

current: Position;

diff: ScrollDifference;

initial: Position;

max: Position;

displacement: Position;

value: Position;

shouldPublishImmediately: boolean;

scrollHeight: number;

scrollWidth: number;

canGetLock: (id: DraggableId) => boolean;

findClosestDraggableId: (event: Event) => DraggableId | null;

findOptionsForDraggable: (id: DraggableId) => DraggableOptions | null;

isLockClaimed: () => boolean;

tryGetLock: TryGetLock;

tryReleaseLock: () => void;

moveDown: () => void;

moveLeft: () => void;

moveRight: () => void;

moveUp: () => void;

bottom: number;

left: number;

right: number;

top: number;

shouldBlockNextClick: boolean;