import { CSSProperties, ReactNode } from 'react';
import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
export interface KanbanColumnDef {
    id: string;
    title: string;
    itemIds: string[];
    /**
     * Optional work-in-progress limit. When set, the column header shows a `count/maxItems`
     * badge, and the column gets a warning style once `itemIds.length` exceeds it. This is
     * display-only — `KanbanBoard` doesn't block drops on its own. To enforce a hard limit,
     * check it in `onChange` and skip updating your state when a drop would push a column over.
     */
    maxItems?: number;
    /**
     * Freezes the column: cards inside it can't be picked up, and nothing can be dropped into it.
     * Use for a workflow rule like "cards in Done can't be moved back out."
     */
    disabled?: boolean;
    /**
     * Whether more items exist for this column beyond what's currently in `itemIds` — enables the
     * scroll-triggered `onLoadMore` request. Only meaningful alongside `KanbanBoardProps.onLoadMore`;
     * a column without it never asks for more regardless of this flag. Set `false` (or omit) once
     * the column's source is exhausted to stop asking.
     */
    hasMore?: boolean;
}
export type KanbanBoardSlots = 'dragOverlay';
export interface KanbanBoardProps<T = unknown> extends Omit<HtmlProps, 'onChange'> {
    /** Ordered list of column definitions. Each column owns its itemIds. */
    columns: KanbanColumnDef[];
    /** Flat map of all items keyed by their id. */
    items: Record<string, T>;
    /** Render function for each item. Receives the item data and its id. */
    renderItem: (item: T, id: string) => ReactNode;
    /**
     * Called after every drop that changes column or order.
     * Receives the full updated columns array — replace your state with this value.
     */
    onChange: (columns: KanbanColumnDef[]) => void;
    /**
     * Drag a card only by the element marked `data-drag-handle` inside it, with the mouse, touch
     * and the keyboard, instead of by the whole card. The handle is made focusable and named with
     * `getItemLabel` unless it has a name, and the card stops being a button. Use when `renderItem`
     * includes controls (buttons, inputs): inside a card that is itself the button, a screen reader
     * reads them as plain text.
     */
    dragHandle?: boolean;
    /**
     * Produce an accessible label for a card, announced to screen-reader users while dragging
     * (e.g. "Picked up <label>."), and naming a `dragHandle` handle that has no name of its own.
     * Defaults to the card's id when omitted.
     */
    getItemLabel?: (item: T, id: string) => string;
    /**
     * Returns whether a specific card can't be picked up. Defaults to every card being draggable.
     * Independent of a column's own `disabled` — a card can be pinned even in an otherwise
     * unrestricted column.
     */
    getItemDisabled?: (item: T, id: string) => boolean;
    /**
     * Custom content shown inside a column when it has no cards, instead of leaving it blank.
     * Receives the column definition.
     */
    renderEmptyColumn?: (column: KanbanColumnDef) => ReactNode;
    /**
     * Custom actions rendered in a column's header, next to its title (e.g. an "add card"
     * button, a column menu). Receives the column definition.
     */
    renderColumnActions?: (column: KanbanColumnDef) => ReactNode;
    /**
     * Allow whole columns to be reordered by dragging their header, alongside the existing
     * card dragging. Defaults to `false`.
     */
    reorderableColumns?: boolean;
    /**
     * Shrink a column to a narrow strip while it has no cards. Defaults to `false`. Widths hold
     * still during a drag: a column the drag empties or fills changes width after the drop. The
     * collapsed width is set via the `--kanban-empty-column-width` CSS variable (falls back to
     * `140px`): override it theme-wide via `ThemeProvider`'s `variables`, or per board via `style`.
     */
    collapseEmptyColumns?: boolean;
    /**
     * Caps each column's card list at a length (any CSS length, e.g. `'70vh'`, `'600px'`), so a
     * long column scrolls on its own instead of growing the page. To fill the space your layout
     * gives the board instead, give the board a height (`style={{ height: '100%' }}` in a parent
     * with one): its columns then scroll the same way.
     */
    columnMaxHeight?: string;
    /**
     * Called with a column's `id` when that column has `hasMore` set and its card list is scrolled
     * within `loadMoreThreshold` of the bottom: fetch and append the next page of items for it.
     * `KanbanColumn` tracks its own in-flight state per column (shown as a spinner at the bottom of
     * the list), so overlapping calls for the same column are never made concurrently. Also called
     * while the column's cards leave empty space below them, since a column that doesn't overflow
     * can't be scrolled. Paging all the way needs a column that scrolls: `columnMaxHeight`, or a
     * board with a height. On a board that grows with its cards, a short column only fills up to
     * the tallest one.
     */
    onLoadMore?: (columnId: string) => void | Promise<void>;
    /**
     * Distance in px from the bottom of a column's scroll area that triggers `onLoadMore` (default
     * `100`, matching `VirtualList`'s `loadMoreThreshold`).
     */
    loadMoreThreshold?: number;
    className?: string;
    style?: CSSProperties;
    classNames?: SlotClassNames<KanbanBoardSlots>;
    styles?: SlotStyles<KanbanBoardSlots>;
}
export type KanbanColumnSlots = 'header' | 'items' | 'count' | 'placeholder' | 'actions' | 'loadingIndicator';
export interface KanbanColumnProps extends HtmlProps {
    id: string;
    title: string;
    children?: ReactNode;
    className?: string;
    style?: CSSProperties;
    classNames?: SlotClassNames<KanbanColumnSlots>;
    styles?: SlotStyles<KanbanColumnSlots>;
}
export interface KanbanItemProps {
    id: string;
    /** Names the card's `[data-drag-handle]` when it has no `aria-label` of its own. */
    label?: string;
    dragHandle?: boolean;
    /** Whether this card can't be picked up (column frozen, or the card itself is pinned). */
    disabled?: boolean;
    /**
     * Whether this card also can't be a drop target for other cards — i.e. other cards can't be
     * reordered relative to it either. Only true when the *column* is frozen (nothing should be
     * dropped into it at all); a card pinned individually via `getItemDisabled` stays droppable, so
     * other cards can still land before/after it normally.
     */
    preventAsDropTarget?: boolean;
    children?: ReactNode;
}