forty-cdk 0.2.0 → 0.3.0

package/types/forty-cdk-drag-drop.d.ts

@@ -0,0 +1,456 @@
+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;
+    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. */
+    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_DRAG_DROP_CONTEXT: InjectionToken<ForDropListContext>;
+/** Emitted by the **source** `ForDropList` on a committed drop (keyboard or pointer). */
+interface ForDragDropEvent<T = unknown> {
+    readonly item: T;
+    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 (the #806 behaviour). 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. This is purely visual — the committed drop
+     * index emitted by `dragDrop` is resolved separately and unaffected.
+     */
+    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.
+     */
+    readonly dragDrop: _angular_core.OutputEmitterRef<ForDragDropEvent<unknown>>;
+    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. */
+    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;
+    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 currently lifted draggable. Reflected as `data-dragging`. */
+    readonly lifted: _angular_core.Signal<boolean>;
+    /** `true` when this item is the roving-tabindex active candidate. */
+    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.
+ *
+ * Pointer-only: there is no WAI-ARIA APG pattern for "freely reposition an element", so this is
+ * a documented headless exception (see `.claude/rules/conventions.md`). 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 dragStart: _angular_core.OutputEmitterRef<{
+        x: number;
+        y: number;
+    }>;
+    /**
+     * Emitted on every armed move with the live position. (Non-native verb — `dragMove`, not
+     * `drag` / `dragMoved` — so `@angular-eslint/no-output-native` stays clear.)
+     */
+    readonly dragMove: _angular_core.OutputEmitterRef<{
+        x: number;
+        y: number;
+    }>;
+    /** Emitted when the drag ends, with the final position. */
+    readonly dragEnd: _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"; "dragStart": "dragStart"; "dragMove": "dragMove"; "dragEnd": "dragEnd"; }, 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.
+ */
+interface ForDragDropDefaults {
+    /**
+     * `aria-roledescription` applied to each draggable item. Empty string disables
+     * the attribute.
+     */
+    itemRoleDescription: string;
+    /**
+     * Announcement when an item is lifted. `index` and `total` describe the source
+     * list and are 1-based.
+     */
+    announceLift: (label: string, index: number, total: number) => string;
+    /**
+     * Announcement when the drop target position changes. `index` and `total`
+     * describe the target list and are 1-based.
+     */
+    announceMove: (label: string, index: number, total: number) => string;
+    /**
+     * Announcement on a committed drop. `index` and `total` describe the
+     * destination list and are 1-based.
+     */
+    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_DRAG_DROP_CONTEXT, FOR_DRAG_DROP_DEFAULTS, FOR_DROP_LIST_DEFAULT_ORIENTATION, FOR_DROP_LIST_GROUP, ForDragHandle, ForDragPlaceholder, ForDragPreview, ForDraggable, ForDropList, ForDropListGroup, ForFreeDrag, moveItemInArray, provideForDragDropDefaults, transferArrayItem };
+export type { ForDragDropDefaults, ForDragDropEvent, ForDragEndEvent, ForDragStartEvent, ForDraggableContext, ForDraggableHandle, ForDropListContext };