import * as _angular_core from '@angular/core';
import { InjectionToken, Signal, TemplateRef, Provider } from '@angular/core';
import { WritingDirection, ListNavigationAction, DragPreview, RovingTabindex } from 'forty-cdk/core';

/** A registered draggable item, as seen by its drop list. */
interface ForDraggableHandle {
    readonly host: HTMLElement;
    /** The consumer-supplied data payload for this item. */
    readonly data: Signal<unknown>;
    /** Effective disabled (item's own `dragDisabled` OR the list being disabled). */
    readonly disabled: Signal<boolean>;
}
/**
 * Coordination contract owned by `ForDropList` and consumed by each `ForDraggable`. Also the
 * public handle type used by `[connectedTo]` and the `dragDrop` event's
 * `previousContainer` / `container` — advanced consumers may read `host` / `items`; the
 * interaction methods exist for the directive pieces.
 */
interface ForDropListContext {
    readonly host: HTMLElement;
    readonly orientation: Signal<'horizontal' | 'vertical' | 'mixed'>;
    readonly dir: Signal<WritingDirection>;
    /** Effective disabled of the whole list. */
    readonly disabled: Signal<boolean>;
    readonly items: Signal<readonly ForDraggableHandle[]>;
    /** Insertion index this list is the current drop target at, else `null`. */
    readonly dragOverIndex: Signal<number | null>;
    setDragOver(index: number | null): void;
    registerItem(handle: ForDraggableHandle): void;
    unregisterItem(handle: ForDraggableHandle): void;
    /** Roving tab-stop value for `el` before/after roving engages (mirror Listbox's pattern). */
    itemTabindex(el: HTMLElement): -1 | 0 | null;
    isFirstFocusableItem(el: HTMLElement): boolean;
    isItemHighlighted(el: HTMLElement): boolean;
    /**
     * Whether a live drag of `el` is in progress — this list's own keyboard / pointer lift, or a
     * lift a composing coordinator owns and drives itself (`ForDropList.setCoordinatorLift`).
     * Drives `[forDraggable]`'s `data-dragging`.
     *
     * Broader than {@link isLifted}, which answers only for the list's own lift —
     * the state {@link moveLifted} / {@link drop} / {@link cancel} act on.
     */
    isItemDragging(el: HTMLElement): boolean;
    setActiveItem(el: HTMLElement): void;
    /** Idle roving focus move from `el`. */
    navigate(el: HTMLElement, action: ListNavigationAction): void;
    /** Start a keyboard drag for `el`; returns its source index, or `-1` if it could not lift. */
    lift(el: HTMLElement): number;
    /** Whether `el` is the currently lifted item. */
    isLifted(el: HTMLElement): boolean;
    /** Step the logical drop target while lifted. */
    moveLifted(action: ListNavigationAction): void;
    /**
     * Commit the current drag (emits `dragDrop` on the source list). No-op if nothing lifted.
     *
     * After a **keyboard** drop whose lifted item held document focus, focus is restored to the
     * item at `currentIndex` in the target container on the next render — so a cross-list transfer
     * or a `@for` re-render that detaches the lifted element does not strand the keyboard user on
     * `<body>`. The restore is skipped when focus already sits somewhere other than `<body>`, so a
     * consumer who moves focus inside their `(dragDrop)` handler keeps it. Pointer drops never
     * move focus.
     */
    drop(): void;
    /** Abort the current drag without emitting `dragDrop`. */
    cancel(): void;
    /**
     * Begin a pointer drag for `el` at viewport point `point`. Sets up the same session state as a
     * keyboard lift. `preview` is the floating element supplied by the draggable (a consumer
     * `[forDragPreview]` template) — either a full {@link DragPreview} or the minimal
     * `{ moveTo, destroy }` shape; when omitted, the list creates the default cloned preview.
     * Returns the source index, or `-1` if it could not lift.
     */
    pointerLift(el: HTMLElement, point: {
        x: number;
        y: number;
    }, preview?: DragPreview | {
        moveTo(x: number, y: number): void;
        destroy(): void;
    } | null): number;
    /** Update the live pointer drop target + preview position. No-op if nothing is lifted. */
    pointerMove(point: {
        x: number;
        y: number;
    }): void;
    /**
     * Register the rendered placeholder's root nodes with the source list so it can reposition
     * them to the live drop index during a `liveSort` pointer drag. Pass `null` to clear. The
     * list ignores the nodes when `liveSort` is off. Called by `ForDraggable`.
     */
    setLivePlaceholder(nodes: readonly Node[] | null): void;
}
declare const FOR_DROP_LIST_CONTEXT: InjectionToken<ForDropListContext>;
/**
 * Optional external authority for a `[forDropList]`'s roving tab order, provided on the
 * list host by a wrapper that composes the list into a larger roving model. When present,
 * the list defers each item's roving `tabindex` to the delegate instead of its own
 * `RovingTabindex`, so the composed list shares one tab stop with the surrounding widget
 * rather than exposing a second one.
 *
 * `ForTableColumnReorder` provides one backed by the table's composite grid roving so a
 * sortable + column-reorderable grid exposes a single tab stop across header and body,
 * per the WAI-ARIA Data Grid pattern. The same composed roving can also govern each item's
 * `data-highlighted` styling hook via {@link isItemHighlighted}.
 *
 * Both members return `null` to defer to the list's own roving — a wrapper hands control
 * back for states where the composed model does not apply (e.g. a `mode="table"` header row
 * that is not part of any composite grid).
 */
interface ForDropListRovingDelegate {
    /** Roving `tabindex` for `el` (`0` for the single tab stop, `-1` otherwise), or `null` to defer to the list's own roving. */
    itemTabindex(el: HTMLElement): -1 | 0 | null;
    /**
     * Whether `el` is the current keyboard-highlighted candidate — drives its `data-highlighted`
     * styling hook — or `null` to defer to the list's own roving highlight. Optional: a delegate
     * that governs only the tab order omits it, and each item's `data-highlighted` follows the
     * list's own roving.
     */
    isItemHighlighted?(el: HTMLElement): boolean | null;
}
declare const FOR_DROP_LIST_ROVING_DELEGATE: InjectionToken<ForDropListRovingDelegate>;
/**
 * Optional DI seam, provided on an ancestor of the draggables, that restricts
 * which keys may start a keyboard lift on a `[forDraggable]`. When present,
 * `ForDraggable` consults it before lifting on Enter / Space and skips the lift
 * for any key the guard rejects, leaving that key to a co-located affordance
 * that owns it. Absent for a plain `[forDropList]`, where both keys lift.
 *
 * `ForTableColumnReorder` provides one so a header cell that is both sortable and
 * column-reorderable splits the two keyboard activations along WAI-ARIA lines —
 * `Space` lifts the column for reordering, `Enter` is left to the sort header —
 * detecting the co-location by DOM marker rather than importing any table symbol.
 */
interface ForDraggableLiftGuard {
    /**
     * Whether a keyboard `Enter` / `Space` on `host` may start a lift. Return
     * `false` to defer that key to a co-located affordance; `true` to lift.
     */
    canLiftOnKey(event: KeyboardEvent, host: HTMLElement): boolean;
}
declare const FOR_DRAGGABLE_LIFT_GUARD: InjectionToken<ForDraggableLiftGuard>;
/** Emitted by the **source** `ForDropList` on a committed drop (keyboard or pointer). */
interface ForDragDropEvent {
    /**
     * The dropped item's `[dragData]` payload. Typed `unknown` because a
     * `[forDropList]` owns no item data (bring-your-own-data), so there is no
     * input for Angular to infer an item type from. Narrow it against your own
     * model when you need it, or reorder purely by `previousIndex` /
     * `currentIndex` and ignore it.
     */
    readonly item: unknown;
    readonly previousContainer: ForDropListContext;
    readonly container: ForDropListContext;
    readonly previousIndex: number;
    readonly currentIndex: number;
}
/** Emitted by `ForDraggable` when a drag (keyboard or pointer) starts. */
interface ForDragStartEvent {
    readonly source: ForDropListContext;
    readonly index: number;
}
/** Emitted by `ForDraggable` when a drag ends (committed or cancelled). */
interface ForDragEndEvent {
    /** `true` on a committed drop, `false` on cancel. */
    readonly dropped: boolean;
}
/**
 * Internal coordination surface a `ForDraggable` / `ForFreeDrag` exposes to its
 * `[forDragHandle]` children.
 */
interface ForDraggableContext {
    /** Register a handle element; while any handle is registered, pointer drags may only start on one. */
    registerHandle(el: HTMLElement): void;
    unregisterHandle(el: HTMLElement): void;
}
declare const FOR_DRAGGABLE_CONTEXT: InjectionToken<ForDraggableContext>;

/**
 * Optional DI seam overriding the fallback `orientation` of every `[forDropList]` in scope.
 * `ForDropList`'s `orientation` input falls back to this token's value (`'vertical'` when the
 * token is not provided); a consumer `orientation` binding always wins over it. Wrappers
 * compose a horizontal list without leaking `orientation="horizontal"` boilerplate into the
 * consumer's template — `ForTableColumnReorder` provides `'horizontal'` so column reordering
 * resolves along the row axis out of the box.
 */
declare const FOR_DROP_LIST_DEFAULT_ORIENTATION: InjectionToken<"horizontal" | "vertical" | "mixed">;
/**
 * Root directive of the drag-drop primitive. Apply on any container element to
 * create a reorderable list. Items inside are declared with `[forDraggable]`.
 *
 * Supports both keyboard dragging and pointer (mouse / touch / pen) dragging.
 */
declare class ForDropList implements ForDropListContext {
    #private;
    /**
     * Layout orientation of the list. Affects which arrow keys move focus and the lifted item, and
     * how a pointer drag resolves the live drop index. Defaults to `'vertical'`, or to
     * `FOR_DROP_LIST_DEFAULT_ORIENTATION` when an in-scope provider sets it (e.g.
     * `ForTableColumnReorder` defaults it to `'horizontal'`).
     *
     * `'mixed'` is for wrapping grids (`flex-wrap` / CSS grid) of uniformly-sized items: the drop
     * index is resolved in 2D so an item flowing across rows lands in the slot under the pointer's
     * row and column, and every arrow key steps the lifted item linearly in DOM order. A `'mixed'`
     * list that happens to render as a single row or single column resolves identically to
     * `'horizontal'` / `'vertical'`.
     */
    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical" | "mixed">;
    /**
     * Writing direction. When unset (default `null`), the inherited ambient direction is
     * resolved from the nearest ancestor carrying a `dir` attribute (or `<html dir>`),
     * defaulting to `'ltr'`.
     */
    readonly _dirInput: _angular_core.InputSignal<WritingDirection | null>;
    readonly dir: _angular_core.Signal<WritingDirection>;
    /** When true, the entire list and all its items are disabled. */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Other lists this one can transfer items into. Union'd with any `[forDropListGroup]`
     * members. Disabled lists are excluded from the effective connected set.
     */
    readonly connectedTo: _angular_core.InputSignal<readonly ForDropListContext[]>;
    /**
     * When true (the default), a pointer drag that nears the edge of the nearest scrollable
     * container (the list, a scrollable ancestor, or the viewport) auto-scrolls it toward that
     * edge so off-screen drop targets become reachable. Set `false` to opt out. Edge size and
     * max speed are configured via `provideForDragDropDefaults`. Keyboard dragging is unaffected.
     */
    readonly autoScroll: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * When true, the `[forDragPlaceholder]` follows the live resolved drop index during a
     * **pointer** drag — within this list and across connected lists — so siblings part to
     * reveal where the item will land. When false (the default), the placeholder stays in the
     * dragged item's source slot. Has no effect without a `[forDragPlaceholder]`
     * template, and none on keyboard dragging.
     *
     * A `dragDisabled` sibling acts as a hard fence: the placeholder stops at the first
     * pinned item instead of travelling past it. Live sorting is purely visual: the drop index
     * is resolved from the container geometry measured at lift — before the placeholder is
     * rendered — so the placeholder's live position never feeds back into resolution and a given
     * pointer path commits the same index whether `liveSort` is on or off.
     */
    readonly liveSort: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * When true, a committed drop (keyboard or pointer) animates: displaced sibling items
     * transition from their old positions to their new ones (FLIP), and — on a pointer drag — the
     * floating preview settles into the final slot before it is removed. Opt-in and default off.
     * Duration / easing are styled by the consumer via CSS on the published hooks
     * (`[data-drag-animating]` on items, `[data-settling]` on the preview); the library imposes
     * none. Fully skipped under `prefers-reduced-motion: reduce` (teardown stays instant).
     */
    readonly animateReorder: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Confine the pointer-drag preview within a boundary during a pointer drag. Accepts an
     * `HTMLElement`, or a selector string resolved via `closest()` from the list host. `null`
     * (the default) leaves the preview unbounded. Affects the visual preview only — the resolved
     * drop index is unchanged. Has no effect on keyboard dragging (no floating preview).
     */
    readonly boundary: _angular_core.InputSignal<string | HTMLElement | null>;
    /**
     * Constrain pointer-drag preview movement to one axis. `'x'` keeps the preview at its lift-time
     * `y` (horizontal movement); `'y'` keeps it at its lift-time `x` (vertical movement). `null`
     * (the default) is free movement. Independent of `orientation` (which drives the drop index);
     * this is a purely visual constraint, and has no effect on keyboard dragging.
     */
    readonly lockAxis: _angular_core.InputSignal<"x" | "y" | null>;
    /**
     * Emitted by the **source** list when a drop commits (keyboard or pointer) — whether
     * the item stays in this list (reorder) or moves to a connected list (transfer). Apply
     * `moveItemInArray` or `transferArrayItem` to your data signal inside the handler.
     *
     * After a **keyboard** drop whose lifted item held document focus, the list restores focus
     * to the item at `currentIndex` in the target container on the next render, so a re-render
     * that detaches the lifted element does not strand the keyboard user on `<body>`. Focus
     * something else inside this handler to keep it; pointer drops never move focus.
     */
    readonly dragDrop: _angular_core.OutputEmitterRef<ForDragDropEvent>;
    readonly host: HTMLElement;
    /** Effective disabled — the list's own `disabled` input (fieldset wiring deferred to v2). */
    readonly effectiveDisabled: _angular_core.Signal<boolean>;
    readonly roving: RovingTabindex;
    readonly items: _angular_core.Signal<readonly ForDraggableHandle[]>;
    /** Insertion index this list is the current drop target at, else `null`. */
    readonly dragOverIndex: _angular_core.Signal<number | null>;
    /**
     * `true` while a drag originating from this list is in progress — its own keyboard / pointer
     * lift, or one a composing coordinator owns (see {@link setCoordinatorLift}). Reflected as
     * `data-dragging` on the list host.
     */
    readonly isDragging: _angular_core.Signal<boolean>;
    constructor();
    registerItem(handle: ForDraggableHandle): void;
    unregisterItem(handle: ForDraggableHandle): void;
    itemTabindex(el: HTMLElement): -1 | 0 | null;
    isFirstFocusableItem(el: HTMLElement): boolean;
    isItemHighlighted(el: HTMLElement): boolean;
    isItemDragging(el: HTMLElement): boolean;
    /**
     * Mark `el` as the item of a drag a **coordinator** composing this list owns end to end —
     * `[forVirtualReorder]`, and the virtualized branch of `[forTableRowReorder]`. Those wrap the
     * list via `hostDirectives` and intercept the lift key in the capture phase, so `ForDraggable`
     * never reaches {@link lift} and the list holds no lift state of its own for the gesture. The
     * mark is what keeps {@link isItemDragging} and {@link isDragging} — and therefore the
     * `data-dragging` hook on both the item and the list host — true for the whole gesture.
     *
     * It is **not** folded into the list's own lift state: `moveLifted` / `drop` /
     * `cancel` still act on nothing, because the coordinator owns the target index, the
     * announcements and the teardown. Pass `null` on drop, cancel, or destroy.
     */
    setCoordinatorLift(el: HTMLElement | null): void;
    setActiveItem(el: HTMLElement): void;
    navigate(el: HTMLElement, action: ListNavigationAction): void;
    lift(el: HTMLElement): number;
    pointerLift(el: HTMLElement, point: {
        x: number;
        y: number;
    }, preview?: DragPreview | {
        moveTo(x: number, y: number): void;
        destroy(): void;
    } | null): number;
    pointerMove(point: {
        x: number;
        y: number;
    }): void;
    isLifted(el: HTMLElement): boolean;
    moveLifted(action: ListNavigationAction): void;
    drop(): void;
    cancel(): void;
    setDragOver(index: number | null): void;
    setLivePlaceholder(nodes: readonly Node[] | null): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDropList, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDropList, "[forDropList]", ["forDropList"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "_dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "connectedTo": { "alias": "connectedTo"; "required": false; "isSignal": true; }; "autoScroll": { "alias": "autoScroll"; "required": false; "isSignal": true; }; "liveSort": { "alias": "liveSort"; "required": false; "isSignal": true; }; "animateReorder": { "alias": "animateReorder"; "required": false; "isSignal": true; }; "boundary": { "alias": "boundary"; "required": false; "isSignal": true; }; "lockAxis": { "alias": "lockAxis"; "required": false; "isSignal": true; }; }, { "dragDrop": "dragDrop"; }, never, never, true, never>;
}

/**
 * Optional custom drag preview. Apply `[forDragPreview]` on an `<ng-template>` inside a
 * `[forDraggable]`; its content renders as the floating element that follows the pointer during a
 * pointer drag, replacing the default cloned preview. Has no effect on keyboard dragging.
 */
declare class ForDragPreview {
    /** The template rendered as the floating pointer-drag preview. */
    readonly templateRef: TemplateRef<unknown>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDragPreview, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDragPreview, "ng-template[forDragPreview]", ["forDragPreview"], {}, {}, never, never, true, never>;
}

/**
 * Optional custom drag placeholder. Apply `[forDragPlaceholder]` on an `<ng-template>` inside a
 * `[forDraggable]`; during a **pointer** drag the dragged item's host is hidden and this template
 * renders in its slot, preserving the gap. Keyboard dragging keeps the default (the lifted item
 * stays in place, reflecting `data-dragging`).
 */
declare class ForDragPlaceholder {
    /** The template rendered in the dragged item's slot during a pointer drag. */
    readonly templateRef: TemplateRef<unknown>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDragPlaceholder, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDragPlaceholder, "ng-template[forDragPlaceholder]", ["forDragPlaceholder"], {}, {}, never, never, true, never>;
}

/**
 * Marks an element as a draggable item inside a `[forDropList]`. Handles
 * keyboard and pointer interaction for lift, move, drop, and cancel.
 */
declare class ForDraggable implements ForDraggableContext {
    #private;
    protected readonly previewTpl: _angular_core.Signal<ForDragPreview | undefined>;
    protected readonly placeholderTpl: _angular_core.Signal<ForDragPlaceholder | undefined>;
    /** `true` while a pointer-drag placeholder template occupies this item's slot (host hidden). */
    protected readonly placeholderActive: _angular_core.WritableSignal<boolean>;
    /** Data payload handed back in the `dragDrop` event when this item is dropped. */
    readonly dragData: _angular_core.InputSignal<unknown>;
    /**
     * When true, this item cannot be lifted. The item remains focusable. It also acts as a
     * hard fence for the `liveSort` placeholder: a sibling being dragged cannot move its
     * placeholder across a pinned item (the committed drop index is unaffected).
     */
    readonly dragDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Emitted when a drag (keyboard or pointer) starts from this item. */
    readonly dragStart: _angular_core.OutputEmitterRef<ForDragStartEvent>;
    /** Emitted when a drag originating from this item ends (committed or cancelled). */
    readonly dragEnd: _angular_core.OutputEmitterRef<ForDragEndEvent>;
    readonly effectiveDisabled: _angular_core.Signal<boolean>;
    /**
     * `true` when this item is the draggable the list itself lifted, and therefore the one its
     * `moveLifted` / `drop` / `cancel` act on. A drag a composing coordinator owns does not set it
     * — read `data-dragging` (or the context's `isItemDragging`) for "a drag of this item is live".
     */
    readonly lifted: _angular_core.Signal<boolean>;
    /**
     * `true` while a drag of this item is live — the list's own lift, or one owned by a
     * coordinator composing the list (`[forVirtualReorder]`, the virtualized branch of
     * `[forTableRowReorder]`). Reflected as `data-dragging`.
     */
    protected readonly dragging: _angular_core.Signal<boolean>;
    /** `true` when this item is the roving-tabindex active candidate. Reflected as `data-highlighted`. */
    protected readonly highlighted: _angular_core.Signal<boolean>;
    /** `aria-roledescription` value from defaults. */
    protected readonly roleDescription: _angular_core.Signal<string>;
    protected readonly tabindex: _angular_core.Signal<0 | -1>;
    protected readonly touchAction: _angular_core.Signal<"none" | null>;
    constructor();
    registerHandle(el: HTMLElement): void;
    unregisterHandle(el: HTMLElement): void;
    protected onNativeDragStart(event: Event): void;
    protected onFocus(): void;
    protected onBlur(): void;
    protected onKeyDown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDraggable, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDraggable, "[forDraggable]", ["forDraggable"], { "dragData": { "alias": "dragData"; "required": true; "isSignal": true; }; "dragDisabled": { "alias": "dragDisabled"; "required": false; "isSignal": true; }; }, { "dragStart": "dragStart"; "dragEnd": "dragEnd"; }, ["previewTpl", "placeholderTpl"], never, true, never>;
}

/**
 * Standalone free-drag directive: repositions its host (or a resolved `rootElement`) by pointer
 * drag via a CSS `transform: translate(...)`, with **no** `[forDropList]` dependency. Unlike
 * `[forDraggable]`, it never commits a reorder — it only moves an arbitrary element around,
 * optionally confined to a `boundary` and locked to one axis. Composes the shared
 * `createPointerDragSession` transport and accepts `[forDragHandle]` children.
 *
 * Its outputs are the `moveStart` / `moveMove` / `moveEnd` trio carrying `{ x, y }` positions —
 * A different vocabulary from `[forDraggable]`'s `dragStart` / `dragEnd`, which carry
 * reorder payloads (`{ source, index }` / `{ dropped }`). Free drag repositions; it never reorders.
 *
 * Pointer-only: there is no WAI-ARIA APG pattern for "freely reposition an element", so this is
 * a documented headless exception. It owns no role or ARIA
 * state and must not destroy the moved element's semantics — the consumer keeps the moved
 * element operable at its default position (e.g. a repositionable dialog stays usable by
 * keyboard); dragging is a pointer convenience, not the only way to use it.
 */
declare class ForFreeDrag implements ForDraggableContext {
    #private;
    /** When true, the element can't be dragged (it stays focusable; the transform doesn't change). */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * The element actually moved: an `HTMLElement`, or a selector resolved via `closest()` from the
     * host. `null` (the default) moves the host itself. Mirrors CDK's `cdkDragRootElement` — drag a
     * child handle, move an ancestor (e.g. drag a whole dialog by its header).
     */
    readonly rootElement: _angular_core.InputSignal<string | HTMLElement | null>;
    /**
     * Confine movement within an `HTMLElement`, a `closest()` selector resolved from the host, or
     * `null` (the default) for unbounded movement. Unlike `[forDropList]`'s boundary (which clamps a
     * floating clone), this clamps the **real moved element** so its box stays fully inside.
     */
    readonly boundary: _angular_core.InputSignal<string | HTMLElement | null>;
    /**
     * Constrain movement to one axis. `'x'` pins the element at its lift-time `y` (horizontal-only);
     * `'y'` pins it at its lift-time `x` (vertical-only). `null` (the default) is free.
     */
    readonly lockAxis: _angular_core.InputSignal<"x" | "y" | null>;
    /** Two-way translate offset (px) from the element's natural position. Controllable / restorable. */
    readonly position: _angular_core.ModelSignal<{
        x: number;
        y: number;
    }>;
    /** Emitted when a pointer drag starts, with the lift-time position. */
    readonly moveStart: _angular_core.OutputEmitterRef<{
        x: number;
        y: number;
    }>;
    /** Emitted on every armed move with the live position. */
    readonly moveMove: _angular_core.OutputEmitterRef<{
        x: number;
        y: number;
    }>;
    /** Emitted when the drag ends, with the final position. */
    readonly moveEnd: _angular_core.OutputEmitterRef<{
        x: number;
        y: number;
    }>;
    /** True while a pointer drag is armed. Reflected as `data-dragging`. */
    readonly dragging: _angular_core.Signal<boolean>;
    protected readonly touchAction: _angular_core.Signal<"none" | null>;
    constructor();
    registerHandle(el: HTMLElement): void;
    unregisterHandle(el: HTMLElement): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForFreeDrag, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForFreeDrag, "[forFreeDrag]", ["forFreeDrag"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "rootElement": { "alias": "rootElement"; "required": false; "isSignal": true; }; "boundary": { "alias": "boundary"; "required": false; "isSignal": true; }; "lockAxis": { "alias": "lockAxis"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, { "position": "positionChange"; "moveStart": "moveStart"; "moveMove": "moveMove"; "moveEnd": "moveEnd"; }, never, never, true, never>;
}

/**
 * Optional drag handle inside a `[forDraggable]`. When at least one handle is present on an item, a pointer
 * drag may only start from within a handle (keyboard dragging is unaffected). Apply on a child element.
 */
declare class ForDragHandle {
    #private;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDragHandle, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDragHandle, "[forDragHandle]", ["forDragHandle"], {}, {}, never, never, true, never>;
}

declare const FOR_DROP_LIST_GROUP: InjectionToken<ForDropListGroup>;
/**
 * Groups sibling `[forDropList]` elements so items can be transferred between
 * them without hand-wiring `[connectedTo]` on each list. Every list nested
 * under `[forDropListGroup]` automatically becomes a connected transfer target
 * for every other member of the group.
 */
declare class ForDropListGroup {
    #private;
    /** All registered drop lists in this group, in registration order. */
    readonly members: Signal<readonly ForDropListContext[]>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForDropListGroup, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForDropListGroup, "[forDropListGroup]", ["forDropListGroup"], {}, {}, never, never, true, never>;
}

/**
 * Returns a copy of `array` with the item at `from` moved to `to`. Indices are clamped to
 * the array bounds; an out-of-range or no-op move returns a shallow copy unchanged.
 */
declare function moveItemInArray<T>(array: readonly T[], from: number, to: number): T[];
/**
 * Moves the item at `fromIndex` of `from` into `to` at `toIndex`, returning new arrays for
 * both. Does not mutate the inputs. Indices are clamped (`toIndex` may equal `to.length`,
 * i.e. append).
 */
declare function transferArrayItem<T>(from: readonly T[], to: readonly T[], fromIndex: number, toIndex: number): {
    from: T[];
    to: T[];
};

/**
 * Defaults inherited by descendant drag-drop lists in the surrounding injector
 * scope. Configure with `provideForDragDropDefaults` either at the application
 * root or in any component's `providers` array; partial overrides merge with
 * the parent scope.
 *
 * The three positional announcement builders share one contract: `label` is the
 * dragged item's accessible text, `index` is the 1-based position being
 * announced, and `total` is the number of **valid drop positions** in the list
 * the announcement describes — never a bare item count. For a reorder inside
 * one list that is its item count (the item is re-inserted among the existing
 * ones); for a transfer into a connected list it is one more than the target's
 * item count, because the append gap past the last item is also a valid
 * position. `index` therefore never exceeds `total`, and an empty transfer
 * target announces `1 of 1` rather than `1 of 0`.
 */
interface ForDragDropDefaults {
    /**
     * `aria-roledescription` applied to each draggable item. Empty string disables
     * the attribute.
     */
    itemRoleDescription: string;
    /**
     * Announcement when an item is lifted. `index` / `total` describe the source
     * list, per the positional contract above.
     */
    announceLift: (label: string, index: number, total: number) => string;
    /**
     * Announcement when the drop target position changes. `index` / `total`
     * describe the target list (the list under the resolved drop position, which
     * may be a connected list), per the positional contract above.
     */
    announceMove: (label: string, index: number, total: number) => string;
    /**
     * Announcement on a committed drop. `index` / `total` describe the destination
     * list, per the positional contract above.
     */
    announceDrop: (label: string, index: number, total: number) => string;
    /** Announcement when a drag is cancelled. */
    announceCancel: (label: string) => string;
    /** Distance in px from a scroll edge that arms auto-scroll during a pointer drag. */
    autoScrollEdgeSize: number;
    /** Maximum scroll delta in px applied per animation frame while auto-scrolling. */
    autoScrollMaxSpeed: number;
}
/** Token holding the resolved drag-drop defaults for the current scope. */
declare const FOR_DRAG_DROP_DEFAULTS: _angular_core.InjectionToken<ForDragDropDefaults>;
/**
 * Configures forty-cdk drag-drop defaults for this injector scope. Partial
 * overrides inherit unspecified keys from the parent scope (or library
 * defaults at the root).
 */
declare function provideForDragDropDefaults(defaults?: Partial<ForDragDropDefaults>): Provider[];

export { FOR_DRAGGABLE_CONTEXT, FOR_DRAGGABLE_LIFT_GUARD, FOR_DRAG_DROP_DEFAULTS, FOR_DROP_LIST_CONTEXT, FOR_DROP_LIST_DEFAULT_ORIENTATION, FOR_DROP_LIST_GROUP, FOR_DROP_LIST_ROVING_DELEGATE, ForDragHandle, ForDragPlaceholder, ForDragPreview, ForDraggable, ForDropList, ForDropListGroup, ForFreeDrag, moveItemInArray, provideForDragDropDefaults, transferArrayItem };
export type { ForDragDropDefaults, ForDragDropEvent, ForDragEndEvent, ForDragStartEvent, ForDraggableContext, ForDraggableHandle, ForDraggableLiftGuard, ForDropListContext, ForDropListRovingDelegate };