@stll/ui 0.38.0 → 0.39.0

package/dist/kanban/subgroup-board.d.ts

@@ -27,11 +27,7 @@ export type KanbanSubgroupCellContext<TRow> = {
   /** Number of rows in this lane/column intersection, including zero. */
   count: number;
   laneValue: string | null;
-  /**
-   * The band this cell's column belongs to, or `null` outside any band. Lets
-   * a host that drives its own drag-and-drop (see `dragOverBandId` on the
-   * board) map a cell's droppable id back to the band it should report.
-   */
+  /** The band this cell's column belongs to, or `null` outside any band. */
   band: KanbanColumnBand | null;
 };
 export type KanbanSubgroupBandHeaderContext = {
@@ -114,27 +110,6 @@ export type KanbanSubgroupBoardProps<TRow> = {
   formatCount?: ((count: number) => ReactNode) | undefined;
   footer?: ReactNode;
   className?: string | undefined;
-  /**
-   * The band whose folded slot (or, for a peeked band, whose open part) the
-   * host's own drag is currently over, or `null` when it is over neither.
-   * Omit (`undefined`) when the host does not drive drags itself — the
-   * board's native `dragover`/`dragenter`/`dragleave` listeners already feed
-   * the peek controller in that case. A host drives its own drag when it
-   * builds the drop targets itself (for example a `KanbanSortableBoard`,
-   * whose `onDragOver` reports the active `over` droppable); it maps that
-   * droppable back to a band id — a folded cell's context and an open
-   * cell's context (see `KanbanSubgroupCellContext.band`) both carry the
-   * band — and passes it here. The controller treats "over the band" as
-   * entering the open band when it is already peeked, and as hovering its
-   * folded slot otherwise; leaving it is reported the same way.
-   */
-  dragOverBandId?: string | null | undefined;
-  /**
-   * Whether the host's own drag (see `dragOverBandId`) is in progress.
-   * Flipping to `false` ends any peek immediately, mirroring the native
-   * `dragend`/`drop` listeners the board installs for its own drags.
-   */
-  isDragging?: boolean | undefined;
 } & KanbanSubgroupCollapseControl;
 /**
  * Reusable swimlane layout over the canonical two-axis Kanban matrix.
@@ -153,5 +128,5 @@ export type KanbanSubgroupBoardProps<TRow> = {
  * in every state; the caption line never grows past its own height, so a
  * folded band costs no vertical space.
  */
-export declare const KanbanSubgroupBoard: <TRow>({ scrollRef, matrix, renderColumnHeader, renderLaneIdentity, renderCell, renderLaneColumnSummary, renderLaneColumnAction, renderBandHeader, renderCollapsedBandCell, formatBandToggleLabel, formatCount, isLaneCollapsed, onLaneCollapsedChange, isBandCollapsed, onBandCollapsedChange, footer, className, dragOverBandId, isDragging }: KanbanSubgroupBoardProps<TRow>) => import("react").JSX.Element;
+export declare const KanbanSubgroupBoard: <TRow>({ scrollRef, matrix, renderColumnHeader, renderLaneIdentity, renderCell, renderLaneColumnSummary, renderLaneColumnAction, renderBandHeader, renderCollapsedBandCell, formatBandToggleLabel, formatCount, isLaneCollapsed, onLaneCollapsedChange, isBandCollapsed, onBandCollapsedChange, footer, className }: KanbanSubgroupBoardProps<TRow>) => import("react").JSX.Element;
 //#endregion

package/dist/kanban/subgroup-board.js

@@ -42,7 +42,7 @@ const rowsIn = (cells) => cells.reduce((sum, cell) => sum + cell.rows.length, 0)
 * in every state; the caption line never grows past its own height, so a
 * folded band costs no vertical space.
 */
-const KanbanSubgroupBoard = ({ scrollRef, matrix, renderColumnHeader, renderLaneIdentity, renderCell, renderLaneColumnSummary, renderLaneColumnAction, renderBandHeader, renderCollapsedBandCell, formatBandToggleLabel, formatCount = String, isLaneCollapsed, onLaneCollapsedChange, isBandCollapsed, onBandCollapsedChange, footer, className, dragOverBandId, isDragging }) => {
+const KanbanSubgroupBoard = ({ scrollRef, matrix, renderColumnHeader, renderLaneIdentity, renderCell, renderLaneColumnSummary, renderLaneColumnAction, renderBandHeader, renderCollapsedBandCell, formatBandToggleLabel, formatCount = String, isLaneCollapsed, onLaneCollapsedChange, isBandCollapsed, onBandCollapsedChange, footer, className }) => {
 	const [collapsedLaneValues, setCollapsedLaneValues] = useState(() => /* @__PURE__ */ new Set());
 	const [expandedEmptyLaneValues, setExpandedEmptyLaneValues] = useState(() => /* @__PURE__ */ new Set());
 	const [collapsedBandIds, setCollapsedBandIds] = useState(() => /* @__PURE__ */ new Set());
@@ -69,30 +69,6 @@ const KanbanSubgroupBoard = ({ scrollRef, matrix, renderColumnHeader, renderLane
 			window.removeEventListener("drop", end);
 		};
 	}, [peek]);
-	const previousDragOverBandId = useRef(null);
-	useEffect(() => {
-		if (dragOverBandId === void 0 || dragOverBandId === previousDragOverBandId.current) return;
-		const previous = previousDragOverBandId.current;
-		previousDragOverBandId.current = dragOverBandId;
-		if (previous !== null) {
-			if (peekingBandId === previous) peek.openDragLeave(previous);
-			else peek.slotDragLeave(previous);
-		}
-		if (dragOverBandId !== null) {
-			if (peekingBandId === dragOverBandId) peek.openDragEnter(dragOverBandId);
-			else peek.slotDragOver(dragOverBandId);
-		}
-	}, [
-		dragOverBandId,
-		peek,
-		peekingBandId
-	]);
-	useEffect(() => {
-		if (isDragging === false) {
-			previousDragOverBandId.current = null;
-			peek.dragEnded();
-		}
-	}, [isDragging, peek]);
 	const { cellsByLaneValue, countByColumnValue, ungroupedCells } = useMemo(() => {
 		const laneCells = /* @__PURE__ */ new Map();
 		const columnCounts = /* @__PURE__ */ new Map();

package/dist/kanban/virtual-cell.d.ts

@@ -1,8 +1,5 @@
 import { OptionColor } from "../lib/option-color.js";
-import { UseKanbanDropTargetOptions } from "./sortable-interactions.js";
 import { Key, ReactNode, RefObject } from "react";
-import { UniqueIdentifier } from "@dnd-kit/core";
-import { SortableContextProps, SortingStrategy } from "@dnd-kit/sortable";
 //#region src/kanban/virtual-cell.d.ts
 export declare const KANBAN_VIRTUAL_CELL_PAGINATION: {
   readonly NONE: "none";
@@ -17,25 +14,11 @@ export type KanbanVirtualCellPagination = {
   pageKey: string | number;
   onRequestMore: () => void;
 };
-/**
- * Makes a virtual cell the canonical sortable context for its rendered rows.
- *
- * `getRowKey` remains responsible for React and virtualizer identity. A
- * separate sortable identifier avoids narrowing an existing React key contract
- * merely to support dnd-kit consumers.
- */
-export type KanbanVirtualCellSortableContext<TRow> = {
-  dropTarget: Omit<UseKanbanDropTargetOptions, "itemIds" | "navigation">;
-  getRowId: (row: TRow) => UniqueIdentifier;
-  disabled?: SortableContextProps["disabled"] | undefined;
-  strategy?: SortingStrategy | undefined;
-};
 export type KanbanVirtualCellProps<TRow> = {
   rows: readonly TRow[];
   getRowKey: (row: TRow) => Key;
   renderRow: (row: TRow) => ReactNode;
   pagination: KanbanVirtualCellPagination;
-  sortable?: KanbanVirtualCellSortableContext<TRow> | undefined;
   containerRef?: RefObject<HTMLDivElement | null> | undefined;
   active?: boolean | undefined;
   backgroundColor?: string | undefined;
@@ -71,5 +54,5 @@ export type KanbanVirtualCellProps<TRow> = {
   className?: string | undefined;
 };
 /** Bounded, virtualized Kanban cell with cursor-page request deduplication. */
-export declare const KanbanVirtualCell: <TRow>({ rows, getRowKey, renderRow, pagination, sortable, containerRef, active, backgroundColor, accent, footer, footerPlacement, estimateSize, overscan, loadMoreThreshold, className }: KanbanVirtualCellProps<TRow>) => import("react").JSX.Element;
+export declare const KanbanVirtualCell: <TRow>({ rows, getRowKey, renderRow, pagination, containerRef, active, backgroundColor, accent, footer, footerPlacement, estimateSize, overscan, loadMoreThreshold, className }: KanbanVirtualCellProps<TRow>) => import("react").JSX.Element;
 //#endregion

package/dist/kanban/virtual-cell.js

@@ -1,12 +1,9 @@
 import { cn } from "../lib/utils.js";
 import { KANBAN_CARD_STICKY_TOP_VAR, KANBAN_STICKY_TOP_CLASS, resolveKanbanCardStickyTop } from "./sticky-lane.js";
-import { useKanbanDropTarget } from "./sortable-interactions.js";
 import { resolveOptionColor } from "../lib/option-color.js";
 import { jsx, jsxs } from "react/jsx-runtime";
-import { useId, useLayoutEffect, useRef, useState } from "react";
-import { useDndContext } from "@dnd-kit/core";
-import { SortableContext, verticalListSortingStrategy } from "@dnd-kit/sortable";
-import { defaultRangeExtractor, useVirtualizer } from "@tanstack/react-virtual";
+import { useLayoutEffect, useRef, useState } from "react";
+import { useVirtualizer } from "@tanstack/react-virtual";
 //#region src/kanban/virtual-cell.tsx
 const DEFAULT_ESTIMATE_SIZE_PX = 128;
 const DEFAULT_OVERSCAN = 8;
@@ -29,26 +26,15 @@ const KANBAN_CELL_SURFACE_CLASS = "bg-muted/20";
 /** A caller's own surface (an explicit colour, or the accent wash), published
 *  so a pinned action can repaint that one instead. */
 const KANBAN_CELL_SURFACE_VAR = "--kanban-cell-surface";
-const retainActiveSortableIndex = (range, activeIndex) => {
-	const indexes = defaultRangeExtractor(range);
-	if (activeIndex < 0 || indexes.includes(activeIndex)) return indexes;
-	indexes.push(activeIndex);
-	indexes.sort((left, right) => left - right);
-	return indexes;
-};
 const KANBAN_VIRTUAL_CELL_PAGINATION = {
 	NONE: "none",
 	CURSOR: "cursor"
 };
 /** Bounded, virtualized Kanban cell with cursor-page request deduplication. */
-const KanbanVirtualCell = ({ rows, getRowKey, renderRow, pagination, sortable, containerRef, active = false, backgroundColor, accent, footer, footerPlacement = "end", estimateSize = DEFAULT_ESTIMATE_SIZE_PX, overscan = DEFAULT_OVERSCAN, loadMoreThreshold = DEFAULT_LOAD_MORE_THRESHOLD_PX, className }) => {
+const KanbanVirtualCell = ({ rows, getRowKey, renderRow, pagination, containerRef, active = false, backgroundColor, accent, footer, footerPlacement = "end", estimateSize = DEFAULT_ESTIMATE_SIZE_PX, overscan = DEFAULT_OVERSCAN, loadMoreThreshold = DEFAULT_LOAD_MORE_THRESHOLD_PX, className }) => {
 	const internalRef = useRef(null);
-	const fallbackDropTargetId = useId();
 	const scrollRef = internalRef;
 	const requestedPageKeyRef = useRef(null);
-	const itemIds = sortable ? rows.map(sortable.getRowId) : [];
-	const { active: activeDrag } = useDndContext();
-	const activeSortableIndex = activeDrag === null ? -1 : itemIds.indexOf(activeDrag.id);
 	const virtualizer = useVirtualizer({
 		count: rows.length,
 		estimateSize: () => estimateSize,
@@ -57,25 +43,7 @@ const KanbanVirtualCell = ({ rows, getRowKey, renderRow, pagination, sortable, c
 			return row === void 0 ? index : getRowKey(row);
 		},
 		getScrollElement: () => scrollRef.current,
-		overscan,
-		rangeExtractor: (range) => retainActiveSortableIndex(range, activeSortableIndex)
-	});
-	const requestScroll = ({ itemId }) => {
-		const index = itemIds.indexOf(itemId);
-		if (index !== -1) virtualizer.scrollToIndex(index, { align: "auto" });
-	};
-	const dropTarget = useKanbanDropTarget({
-		disabled: sortable?.dropTarget.disabled ?? sortable === void 0,
-		id: sortable?.dropTarget.id ?? fallbackDropTargetId,
-		itemIds,
-		navigation: sortable === void 0 ? { type: "static" } : {
-			requestScroll,
-			type: "virtual"
-		},
-		position: sortable?.dropTarget.position ?? {
-			column: -1,
-			lane: -1
-		}
+		overscan
 	});
 	const handleScroll = ({ currentTarget }) => {
 		if (pagination.type !== "cursor" || !pagination.hasMore || pagination.loading) return;
@@ -87,7 +55,6 @@ const KanbanVirtualCell = ({ rows, getRowKey, renderRow, pagination, sortable, c
 	const setScrollElement = (element) => {
 		internalRef.current = element;
 		if (containerRef) containerRef.current = element;
-		dropTarget.setNodeRef(element);
 	};
 	const accentVariants = accent === void 0 ? void 0 : resolveOptionColor(accent);
 	const accentBackground = accentVariants === void 0 ? void 0 : `color-mix(in srgb, var(${KANBAN_CELL_ACCENT_VAR}) ${active ? KANBAN_CELL_ACCENT_ACTIVE_ALPHA : KANBAN_CELL_ACCENT_RESTING_ALPHA}%, var(--background))`;
@@ -127,9 +94,8 @@ const KanbanVirtualCell = ({ rows, getRowKey, renderRow, pagination, sortable, c
 			children: footer
 		})
 	}) : null;
-	const content = /* @__PURE__ */ jsxs("div", {
+	return /* @__PURE__ */ jsxs("div", {
 		className: cn(KANBAN_CELL_SURFACE_CLASS, "min-h-20 rounded-xl p-2", rows.length === 0 ? "overflow-visible" : "max-h-[min(60vh,40rem)] overflow-y-auto overscroll-y-contain", active && accentVariants === void 0 && "bg-primary/5 ring-primary/50 ring-2", className),
-		"data-kanban-cell": sortable?.dropTarget.id,
 		"data-kanban-cell-accent": accentVariants === void 0 ? void 0 : "true",
 		onScroll: handleScroll,
 		ref: setScrollElement,
@@ -161,14 +127,6 @@ const KanbanVirtualCell = ({ rows, getRowKey, renderRow, pagination, sortable, c
 			footerPlacement === "end" ? footer : null
 		]
 	});
-	if (sortable === void 0) return content;
-	return /* @__PURE__ */ jsx(SortableContext, {
-		...sortable.disabled === void 0 ? {} : { disabled: sortable.disabled },
-		id: sortable.dropTarget.id,
-		items: itemIds,
-		strategy: sortable.strategy ?? verticalListSortingStrategy,
-		children: content
-	});
 };
 //#endregion
 export { KANBAN_VIRTUAL_CELL_PAGINATION, KanbanVirtualCell };

package/dist/lib/control-size.d.ts

@@ -5,6 +5,6 @@ declare const CONTROL_SIZE: Readonly<{
   readonly lg: "lg";
 }>;
 type ControlSize = (typeof CONTROL_SIZE)[keyof typeof CONTROL_SIZE];
-declare const CONTROL_SIZES: readonly ("default" | "sm" | "lg")[];
+declare const CONTROL_SIZES: readonly ("sm" | "default" | "lg")[];
 //#endregion
 export { CONTROL_SIZE, CONTROL_SIZES, type ControlSize };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/ui",
-  "version": "0.38.0",
+  "version": "0.39.0",
   "description": "Stella's design system: bidi-aware React primitives built on Base UI, the dockable inspector pane, and the Tailwind v4 theme they are styled with.",
   "keywords": [
     "base-ui",
@@ -105,6 +105,10 @@
       "types": "./dist/lib/control-size.d.ts",
       "import": "./dist/lib/control-size.js"
     },
+    "./copy-button": {
+      "types": "./dist/components/copy-button.d.ts",
+      "import": "./dist/components/copy-button.js"
+    },
     "./calendar": {
       "types": "./dist/calendar/index.d.ts",
       "import": "./dist/calendar/index.js"
@@ -645,8 +649,6 @@
     "@atlaskit/pragmatic-drag-and-drop": "^3.1.0",
     "@atlaskit/pragmatic-drag-and-drop-auto-scroll": "^3.2.0",
     "@base-ui/react": "1.8.0",
-    "@dnd-kit/core": "^6.3.1",
-    "@dnd-kit/sortable": "^10.0.0",
     "@playwright/test": "^1.63.0",
     "@stll/typescript-config": "0.0.0",
     "@tailwindcss/vite": "4.3.3",
@@ -664,8 +666,6 @@
     "@atlaskit/pragmatic-drag-and-drop": "^3.1.0",
     "@atlaskit/pragmatic-drag-and-drop-auto-scroll": "^3.2.0",
     "@base-ui/react": "^1.7.0",
-    "@dnd-kit/core": "^6.3.1",
-    "@dnd-kit/sortable": "^10.0.0",
     "@tanstack/react-virtual": "^3.14.13",
     "react": ">=19",
     "react-dom": ">=19",

package/dist/kanban/sortable-edge.d.ts

@@ -1,38 +0,0 @@
-import { ClientRect } from "@dnd-kit/core";
-//#region src/kanban/sortable-edge.d.ts
-export declare const KANBAN_HORIZONTAL_EDGES: {
-  readonly before: "before";
-  readonly after: "after";
-};
-export type KanbanHorizontalEdge = (typeof KANBAN_HORIZONTAL_EDGES)[keyof typeof KANBAN_HORIZONTAL_EDGES];
-export declare const KANBAN_DIRECTIONS: {
-  readonly ltr: "ltr";
-  readonly rtl: "rtl";
-};
-export type KanbanDirection = (typeof KANBAN_DIRECTIONS)[keyof typeof KANBAN_DIRECTIONS];
-type KanbanPointerHorizontalEdgeOptions = {
-  input: "pointer";
-  /** The drag's current viewport x coordinate for mouse or touch input. */
-  currentClientX: number;
-  overRect: ClientRect;
-  /** Maps physical mouse and touch positions to the board's logical order. */
-  direction?: KanbanDirection | undefined;
-};
-type KanbanKeyboardHorizontalEdgeOptions = {
-  input: "keyboard";
-  /** The source item's position in logical board order. */
-  sourceIndex: number;
-  /** The target item's position in logical board order. */
-  targetIndex: number;
-};
-export type KanbanHorizontalEdgeOptions = KanbanPointerHorizontalEdgeOptions | KanbanKeyboardHorizontalEdgeOptions;
-/**
- * Resolves a horizontal insertion edge without consulting application data.
- *
- * Mouse and touch callers pass their current viewport coordinate. Keyboard
- * callers pass source and target indices, making every logical move
- * unambiguous. This deliberately avoids drag deltas, which include scroll
- * reconciliation and are not viewport coordinates.
- */
-export declare const getKanbanHorizontalEdge: ({ ...options }: KanbanHorizontalEdgeOptions) => KanbanHorizontalEdge;
-//#endregion

package/dist/kanban/sortable-edge.js

@@ -1,27 +0,0 @@
-//#region src/kanban/sortable-edge.ts
-const KANBAN_HORIZONTAL_EDGES = {
-	before: "before",
-	after: "after"
-};
-const KANBAN_DIRECTIONS = {
-	ltr: "ltr",
-	rtl: "rtl"
-};
-/**
-* Resolves a horizontal insertion edge without consulting application data.
-*
-* Mouse and touch callers pass their current viewport coordinate. Keyboard
-* callers pass source and target indices, making every logical move
-* unambiguous. This deliberately avoids drag deltas, which include scroll
-* reconciliation and are not viewport coordinates.
-*/
-const getKanbanHorizontalEdge = ({ ...options }) => {
-	if (options.input === "keyboard") return options.sourceIndex < options.targetIndex ? KANBAN_HORIZONTAL_EDGES.after : KANBAN_HORIZONTAL_EDGES.before;
-	const { currentClientX, direction = KANBAN_DIRECTIONS.ltr, overRect } = options;
-	const physicalEdge = currentClientX < getRectCenterX(overRect) ? KANBAN_HORIZONTAL_EDGES.before : KANBAN_HORIZONTAL_EDGES.after;
-	if (direction === KANBAN_DIRECTIONS.rtl) return physicalEdge === KANBAN_HORIZONTAL_EDGES.before ? KANBAN_HORIZONTAL_EDGES.after : KANBAN_HORIZONTAL_EDGES.before;
-	return physicalEdge;
-};
-const getRectCenterX = ({ left, width }) => left + width / 2;
-//#endregion
-export { KANBAN_DIRECTIONS, KANBAN_HORIZONTAL_EDGES, getKanbanHorizontalEdge };

package/dist/kanban/sortable-interactions.d.ts

@@ -1,151 +0,0 @@
-import { Button } from "../components/button.js";
-import { KANBAN_BOARD_COLLISION_DETECTION, KanbanCellVirtualNavigation, KanbanSortableCellPosition, KanbanVirtualScrollRequest, kanbanKeyboardCoordinates } from "./sortable-interactions.logic.js";
-import * as React$1 from "react";
-import { AutoScrollActivator, AutoScrollOptions, CollisionDetection, DndContextProps, DragCancelEvent, DragEndEvent, DragOverEvent, DragOverlayProps, DragStartEvent, KeyboardCoordinateGetter, UniqueIdentifier } from "@dnd-kit/core";
-import { SortableContextProps, useSortable } from "@dnd-kit/sortable";
-//#region src/kanban/sortable-interactions.d.ts
-export declare const KANBAN_MOUSE_ACTIVATION_DISTANCE = 8;
-/** Above sticky board chrome, below app-level floating surfaces. */
-export declare const KANBAN_DRAG_OVERLAY_Z_INDEX = 75;
-export declare const KANBAN_BOARD_AUTO_SCROLL_OPTIONS: {
-  readonly acceleration: 10;
-  readonly activator: AutoScrollActivator.Pointer;
-  readonly threshold: {
-    readonly x: 0.15;
-    readonly y: 0.15;
-  };
-};
-export declare const KANBAN_SORTABLE_ACTIVATION_MODES: {
-  readonly CARD: "card";
-  readonly HANDLE: "handle";
-  readonly ITEM: "item";
-};
-export declare const KANBAN_TOUCH_ACTIVATION_CONSTRAINT: {
-  readonly delay: 150;
-  readonly tolerance: 8;
-};
-export type KanbanDragCancelEvent = DragCancelEvent;
-export type KanbanDragEndEvent = DragEndEvent;
-export type KanbanDragOverEvent = DragOverEvent;
-export type KanbanDragStartEvent = DragStartEvent;
-export type KanbanSortableBoardProps = {
-  children: React$1.ReactNode;
-  onDragEnd: (event: KanbanDragEndEvent) => void;
-  /** Minimum pointer movement before a mouse drag activates. */
-  mouseActivationDistance?: number | undefined;
-  collisionDetection?: CollisionDetection | undefined;
-  keyboardCoordinates?: KeyboardCoordinateGetter | undefined;
-  autoScroll?: boolean | AutoScrollOptions | undefined;
-  /** Replaces the default mouse, touch, and keyboard sensors when supplied. */
-  sensors?: DndContextProps["sensors"] | undefined;
-  /** Overrides dnd-kit's screen-reader announcements when supplied. */
-  accessibility?: DndContextProps["accessibility"] | undefined;
-  /**
-   * Fires on drag start and on every drag end or cancel; a board over a
-   * `KanbanSubgroupBoard` combines the two into that board's `isDragging`
-   * (`true` here, `false` on `onDragEnd`/`onDragCancel`).
-   */
-  onDragStart?: ((event: KanbanDragStartEvent) => void) | undefined;
-  /**
-   * Fires whenever dnd-kit's collision detection changes the drop target
-   * the drag is over, `event.over` included when it becomes none. A board
-   * over a `KanbanSubgroupBoard` maps `event.over?.id ?? null` to a band id
-   * (via `KanbanSubgroupCellContext.band`, or a droppable registered for a
-   * folded band's slot) to drive that board's `dragOverBandId`.
-   */
-  onDragOver?: ((event: KanbanDragOverEvent) => void) | undefined;
-  onDragCancel?: ((event: KanbanDragCancelEvent) => void) | undefined;
-  /** Called once mounted child drop targets can safely receive input. */
-  onInteractionReady?: (() => void) | undefined;
-  /** Rendered in document.body while an item is active. */
-  overlay?: ((activeId: UniqueIdentifier | null) => React$1.ReactNode) | undefined;
-  overlayProps?: Omit<DragOverlayProps, "children"> | undefined;
-};
-export type UseKanbanDropTargetOptions = {
-  disabled?: boolean | undefined;
-  id: string;
-  itemIds: readonly UniqueIdentifier[];
-  navigation: KanbanCellVirtualNavigation;
-  position: KanbanSortableCellPosition;
-};
-/**
- * Register a board-level drop target such as an empty cell or terminal lane.
- *
- * Board consumers should not need to couple their presentation code to the
- * underlying drag-and-drop library just to receive an item from a sortable
- * context.
- */
-export declare const useKanbanDropTarget: ({ disabled, id, itemIds, navigation, position }: UseKanbanDropTargetOptions) => {
-  isOver: boolean;
-  setNodeRef: (element: HTMLElement | null) => void;
-};
-/**
- * Input-complete drag context for sortable boards.
- *
- * The consumer owns identifiers and the result of a drop; this component owns
- * the sensor activation rules, keyboard navigation, auto-scroll configuration,
- * and overlay lifecycle shared by sortable board UIs.
- */
-export declare const KanbanSortableBoard: ({ children, onDragEnd, mouseActivationDistance, collisionDetection, keyboardCoordinates, autoScroll, sensors, accessibility, onDragStart, onDragOver, onDragCancel, onInteractionReady, overlay, overlayProps }: KanbanSortableBoardProps) => React$1.JSX.Element;
-export declare const useKanbanSortableSensors: (keyboardCoordinates?: KeyboardCoordinateGetter, mouseActivationDistance?: number) => import("@dnd-kit/core").SensorDescriptor<import("@dnd-kit/core").SensorOptions>[];
-export type KanbanSortableListProps = SortableContextProps & React$1.ComponentProps<"div">;
-/** A vertical card list that preserves native vertical touch scrolling. */
-export declare const KanbanSortableList: ({ className, children, id, items, strategy, disabled, ...props }: KanbanSortableListProps) => React$1.JSX.Element;
-export type KanbanSortableColumnsProps = SortableContextProps & React$1.ComponentProps<"div">;
-/** A horizontal column list that keeps the board pan gesture available. */
-export declare const KanbanSortableColumns: ({ className, children, id, items, strategy, disabled, ...props }: KanbanSortableColumnsProps) => React$1.JSX.Element;
-export type KanbanSortableBindings = Pick<ReturnType<typeof useSortable>, "attributes" | "listeners" | "setActivatorNodeRef">;
-export type KanbanSortableActivationMode = {
-  type: "card";
-} | {
-  type: "handle";
-} | {
-  type: "item";
-};
-export type UseKanbanSortableOptions = {
-  activation: KanbanSortableActivationMode;
-  id: UniqueIdentifier;
-  disabled?: boolean | undefined;
-};
-type KanbanSortableActivator = {
-  bindings: KanbanSortableBindings;
-  type: typeof KANBAN_SORTABLE_ACTIVATION_MODES.HANDLE;
-} | {
-  bindings: KanbanSortableBindings;
-  type: typeof KANBAN_SORTABLE_ACTIVATION_MODES.CARD;
-} | {
-  attributes: ReturnType<typeof useSortable>["attributes"];
-  listeners: ReturnType<typeof useSortable>["listeners"];
-  type: typeof KANBAN_SORTABLE_ACTIVATION_MODES.ITEM;
-};
-/**
- * Connect a sortable item and its separate drag handle without making the
- * item's content a touch-none activation surface.
- */
-export declare const useKanbanSortable: ({ activation, id, disabled }: UseKanbanSortableOptions) => {
-  activator: KanbanSortableActivator;
-  isDragging: boolean;
-  setNodeRef: (element: HTMLElement | null) => void;
-  style: {
-    touchAction: string | undefined;
-    transform: string | undefined;
-    transition: string | undefined;
-  };
-};
-export type KanbanDragHandleProps = {
-  bindings: KanbanSortableBindings;
-  label: string;
-} & Omit<React$1.ComponentProps<typeof Button>, "aria-label" | "children" | "ref" | "tooltip" | "type">;
-/**
- * A 44px keyboard-accessible drag activator. The handle is the only board
- * surface that disables touch panning, leaving cards and scroll regions free
- * for ordinary scrolling.
- */
-export declare const KanbanDragHandle: ({ bindings, label, className, ...props }: KanbanDragHandleProps) => React$1.JSX.Element;
-export type KanbanCardDragSurfaceProps = {
-  bindings: KanbanSortableBindings;
-} & Omit<React$1.ComponentProps<"div">, "ref">;
-/** A whole-card drag activator that preserves descendant controls and scrolling. */
-export declare const KanbanCardDragSurface: ({ bindings, className, ...props }: KanbanCardDragSurfaceProps) => React$1.JSX.Element;
-//#endregion
-export { KANBAN_BOARD_COLLISION_DETECTION, type KanbanCellVirtualNavigation, type KanbanSortableCellPosition, type KanbanVirtualScrollRequest, kanbanKeyboardCoordinates };