interface PluginContext {
    delta: {
        x: number;
        y: number;
    };
    proposed: {
        x: number | null;
        y: number | null;
    };
    offset: {
        x: number;
        y: number;
    };
    initial: {
        x: number;
        y: number;
    };
    isDragging: boolean;
    isInteracting: boolean;
    rootNode: HTMLElement | SVGElement;
    lastEvent: PointerEvent | null;
    cachedRootNodeRect: DOMRect;
    currentlyDraggedNode: HTMLElement | SVGElement;
    effect: {
        immediate: (fn: () => void) => void;
        paint: (fn: () => void) => void;
    };
    propose: (x: number | null, y: number | null) => void;
    cancel: () => void;
    preventStart: () => void;
    setForcedPosition: (x: number, y: number) => void;
}
interface Plugin<State = any> {
    name: string;
    priority?: number;
    liveUpdate?: boolean;
    cancelable?: boolean;
    setup?: (ctx: PluginContext) => State;
    shouldStart?: (ctx: PluginContext, state: State, event: PointerEvent) => boolean;
    start?: (ctx: PluginContext, state: State, event: PointerEvent) => void;
    drag?: (ctx: PluginContext, state: State, event: PointerEvent) => void;
    end?: (ctx: PluginContext, state: State, event: PointerEvent) => void;
    cleanup?: (ctx: PluginContext, state: State) => void;
}
type PluginResolver = () => (Plugin | Compartment<any>)[];
type PluginInput = Plugin[] | PluginResolver;
declare class Compartment<T extends Plugin = Plugin> {
    #private;
    constructor(initial?: () => T);
    get current(): T | undefined;
    set current(plugin: T | undefined);
    subscribe(callback: (plugin: T | undefined) => void): () => boolean;
}
declare function unstable_definePlugin<State, Args extends unknown[]>(fn: (...args: Args) => Plugin<State>): (...args: Args) => Plugin<State>;
declare const ignoreMultitouch: (value?: boolean | undefined) => Plugin<{
    active_pointers: Set<number>;
}>;
declare const stateMarker: () => Plugin<{
    count: number;
}>;
declare const axis: (value: "x" | "y" | null | undefined) => Plugin<unknown>;
declare const applyUserSelectHack: (value?: boolean | null | undefined) => Plugin<{
    body_user_select_val: string;
}>;
declare const grid: (values: [x: number | null | undefined, y: number | null | undefined] | null | undefined) => Plugin<unknown>;
declare const disabled: (value?: boolean | undefined) => Plugin<unknown>;
declare const transform: (func?: ((args: {
    offset: {
        x: number;
        y: number;
    };
    rootNode: HTMLElement | SVGElement;
}) => void) | undefined) => Plugin<void>;
type BoundFromFunction = (data: {
    root_node: HTMLElement | SVGElement;
}) => [[x1: number, y1: number], [x2: number, y2: number]];
declare const BoundsFrom: {
    element(element: HTMLElement, padding?: {
        top?: number;
        left?: number;
        right?: number;
        bottom?: number;
    }): BoundFromFunction;
    selector(selector: string, padding?: {
        top?: number;
        left?: number;
        right?: number;
        bottom?: number;
    }, root?: HTMLElement): BoundFromFunction;
    viewport(padding?: {
        top?: number;
        left?: number;
        right?: number;
        bottom?: number;
    }): BoundFromFunction;
    parent(padding?: {
        top?: number;
        left?: number;
        right?: number;
        bottom?: number;
    }): BoundFromFunction;
};
declare const bounds: (value?: BoundFromFunction | undefined, shouldRecompute?: ((ctx: {
    readonly hook: "dragStart" | "drag" | "dragEnd";
}) => boolean) | undefined) => Plugin<{
    bounds: [[x1: number, y1: number], [x2: number, y2: number]];
    initialElementPosition: {
        x: number;
        y: number;
    };
}>;
declare const threshold: (options?: {
    delay?: number;
    distance?: number;
} | null | undefined) => Plugin<{
    enabled: false;
    start_time?: undefined;
    start_position?: undefined;
    options?: undefined;
} | {
    enabled: true;
    start_time: number;
    start_position: {
        x: number;
        y: number;
    };
    options: {
        delay: number;
        distance: number;
    };
}>;
type DragEventData = Readonly<{
    /** How much element moved from its original position horizontally */
    offset: Readonly<{
        x: number;
        y: number;
    }>;
    /** The node on which the draggable is applied */
    rootNode: HTMLElement | SVGElement;
    /** The element being dragged */
    currentNode: HTMLElement | SVGElement;
    /** The pointer event that triggered the drag */
    event: PointerEvent;
}>;
declare const events: (events?: {
    onDragStart?: (data: Readonly<{
        /** How much element moved from its original position horizontally */
        offset: Readonly<{
            x: number;
            y: number;
        }>;
        /** The node on which the draggable is applied */
        rootNode: HTMLElement | SVGElement;
        /** The element being dragged */
        currentNode: HTMLElement | SVGElement;
        /** The pointer event that triggered the drag */
        event: PointerEvent;
    }>) => void;
    onDrag?: (data: Readonly<{
        /** How much element moved from its original position horizontally */
        offset: Readonly<{
            x: number;
            y: number;
        }>;
        /** The node on which the draggable is applied */
        rootNode: HTMLElement | SVGElement;
        /** The element being dragged */
        currentNode: HTMLElement | SVGElement;
        /** The pointer event that triggered the drag */
        event: PointerEvent;
    }>) => void;
    onDragEnd?: (data: Readonly<{
        /** How much element moved from its original position horizontally */
        offset: Readonly<{
            x: number;
            y: number;
        }>;
        /** The node on which the draggable is applied */
        rootNode: HTMLElement | SVGElement;
        /** The element being dragged */
        currentNode: HTMLElement | SVGElement;
        /** The pointer event that triggered the drag */
        event: PointerEvent;
    }>) => void;
} | undefined) => Plugin<{
    offset: {
        x: number;
        y: number;
    };
    rootNode: HTMLElement | SVGElement;
    currentNode: HTMLElement | SVGElement;
    event: PointerEvent;
}>;
type ControlZone = {
    element: Element;
    top: number;
    right: number;
    bottom: number;
    left: number;
    area: number;
};
declare const ControlFrom: {
    selector(selector: string): (root: Element) => ControlZone[];
    elements: (elements: NodeListOf<Element> | (Element | null | undefined)[]) => (root: Element) => ControlZone[];
};
declare const controls: (options?: {
    allow?: ReturnType<(typeof ControlFrom)[keyof typeof ControlFrom]>;
    block?: ReturnType<(typeof ControlFrom)[keyof typeof ControlFrom]>;
    priority?: "allow" | "block";
} | null | undefined) => Plugin<{
    allow_zones: ControlZone[];
    block_zones: ControlZone[];
    priority: "block" | "allow";
}>;
declare const position: (options?: {
    current?: {
        x: number;
        y: number;
    } | null;
    default?: {
        x: number;
        y: number;
    } | null;
} | null | undefined) => Plugin<void>;
type TouchActionMode = 'auto' | 'none' | 'pan-x' | 'pan-left' | 'pan-right' | 'pan-y' | 'pan-up' | 'pan-down' | 'pinch-zoom' | 'manipulation' | 'inherit' | 'initial' | 'revert' | 'revert-layer' | 'unset';
declare const touchAction: (mode?: false | TouchActionMode | null | undefined) => Plugin<void>;
declare const scrollLock: (options?: {
    lockAxis?: "x" | "y" | "both";
    container?: HTMLElement | (() => HTMLElement);
    allowScrollbar?: boolean;
} | null | undefined) => Plugin<{
    config: {
        lockAxis?: "x" | "y" | "both";
        container: HTMLElement | (() => HTMLElement);
        allowScrollbar?: boolean;
        lock_axis: string;
        allow_scrollbar: boolean;
    };
    original_styles: Map<HTMLElement, {
        user_select: string;
        touch_action: string;
        overflow: string;
    }>;
    container_rect: DOMRect | null;
    last_container_check: number;
}>;

export { BoundsFrom, Compartment, ControlFrom, type DragEventData, type Plugin, type PluginContext, type PluginInput, type PluginResolver, applyUserSelectHack, axis, bounds, controls, disabled, events, grid, ignoreMultitouch, position, scrollLock, stateMarker, threshold, touchAction, transform, unstable_definePlugin };