@rebasepro/plugin-data-enhancement 0.2.1 → 0.2.3

package/dist/admin/src/components/EntityCollectionTable/table_bindings.d.ts

@@ -0,0 +1,28 @@
+import React from "react";
+import { Entity, Property } from "@rebasepro/types";
+export interface TableFieldBindingProps<T = any> {
+    propertyKey: string;
+    property: Property;
+    internalValue: T;
+    updateValue: (newValue: T | null) => void;
+    error?: Error;
+    validationError?: Error;
+    disabled: boolean;
+    selected: boolean;
+    size: any;
+    align: "left" | "center" | "right";
+    entity: Entity<any>;
+    path: string;
+    openPopup?: (cellRect: DOMRect | undefined) => void;
+}
+export interface TableFieldConfig {
+    Component: React.ComponentType<TableFieldBindingProps>;
+    fullHeight?: boolean;
+    allowScroll?: boolean;
+    removePadding?: boolean;
+    showExpandIcon?: boolean;
+    hideOverflow?: boolean;
+    includeActions?: boolean;
+}
+export declare function isStorageProperty(property: Property): boolean | import("@rebasepro/types").StorageConfig | undefined;
+export declare function getTableBindingForProperty(property: Property, selected: boolean): TableFieldConfig | undefined;

package/dist/admin/src/components/EntityCollectionView/Board.d.ts

@@ -0,0 +1,2 @@
+import { BoardProps } from "./board_types";
+export declare function Board<M extends Record<string, unknown>, COLUMN extends string>({ data, columns: columnsProp, columnLabels, columnColors, className, assignColumn, allowColumnReorder, onColumnReorder, onItemsReorder, ItemComponent, columnLoadingState, onLoadMoreColumn, onAddItemToColumn, AddColumnComponent }: BoardProps<M, COLUMN>): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/EntityCollectionView/BoardColumn.d.ts

@@ -0,0 +1,42 @@
+import React from "react";
+import { BoardItem, BoardItemViewProps } from "./board_types";
+import { ChipColorKey, ChipColorScheme } from "@rebasepro/ui";
+export interface BoardColumnProps<M extends Record<string, unknown>> {
+    id: string;
+    title: string;
+    items: BoardItem<M>[];
+    index: number;
+    ItemComponent: React.ComponentType<BoardItemViewProps<M>>;
+    isDragging: boolean;
+    isDragOverColumn: boolean;
+    /**
+     * Whether column reordering is allowed (shows drag handle)
+     */
+    allowReorder?: boolean;
+    /**
+     * Whether items are loading for this column
+     */
+    loading?: boolean;
+    /**
+     * Whether there are more items to load
+     */
+    hasMore?: boolean;
+    /**
+     * Callback to load more items
+     */
+    onLoadMore?: () => void;
+    /**
+     * Callback to add a new item to this column
+     */
+    onAddItem?: () => void;
+    /**
+     * Total count of entities in this column
+     */
+    totalCount?: number;
+    /**
+     * Color of the column header indicator
+     */
+    color?: ChipColorKey | ChipColorScheme;
+    style?: React.CSSProperties;
+}
+export declare const BoardColumn: <M extends Record<string, unknown>>(props: BoardColumnProps<M>) => React.ReactElement;

package/dist/admin/src/components/EntityCollectionView/BoardColumnTitle.d.ts

@@ -0,0 +1,9 @@
+import { ChipColorKey, ChipColorScheme } from "@rebasepro/ui";
+import React from "react";
+export interface BoardColumnTitleProps {
+    children: React.ReactNode;
+    className?: string;
+    "aria-label"?: string;
+    color?: ChipColorKey | ChipColorScheme;
+}
+export declare function BoardColumnTitle({ children, className, color, ...props }: BoardColumnTitleProps): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/EntityCollectionView/BoardSortableList.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { BoardItem, BoardItemViewProps } from "./board_types";
+interface BoardSortableListProps<M extends Record<string, unknown>> {
+    columnId: string;
+    items: BoardItem<M>[];
+    ItemComponent: React.ComponentType<BoardItemViewProps<M>>;
+    isDragging: boolean;
+    isDragOverColumn: boolean;
+    loading?: boolean;
+    hasMore?: boolean;
+    onLoadMore?: () => void;
+}
+export declare function BoardSortableList<M extends Record<string, unknown>>({ columnId, items, ItemComponent, isDragging, isDragOverColumn, loading, hasMore, onLoadMore }: BoardSortableListProps<M>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/EntityCollectionView/EntityBoardCard.d.ts

@@ -0,0 +1,31 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { Entity } from "@rebasepro/types";
+import { BoardItemViewProps } from "./board_types";
+export type EntityBoardCardProps<M extends Record<string, unknown> = Record<string, unknown>> = BoardItemViewProps<M> & {
+    collection: EntityCollection<M>;
+    onClick?: (entity: Entity<M>) => void;
+    selected?: boolean;
+    onSelectionChange?: (entity: Entity<M>, selected: boolean) => void;
+    selectionEnabled?: boolean;
+};
+/**
+ * Compact card component for displaying an entity in a Kanban board.
+ * Uses the shared slot system for consistent preview rendering.
+ *
+ * Selection UX: The checkbox overlays on top of the image/icon thumbnail area,
+ * revealed on card hover or when the card is selected. This keeps the card
+ * layout clean while providing intuitive selection affordance.
+ */
+declare function EntityBoardCardInner<M extends Record<string, unknown> = Record<string, unknown>>({ item, isDragging, isGroupedOver, style, collection, onClick, selected, onSelectionChange, selectionEnabled }: EntityBoardCardProps<M>): import("react/jsx-runtime").JSX.Element;
+export declare const EntityBoardCard: typeof EntityBoardCardInner;
+/**
+ * Wrapper component that adapts EntityBoardCard to BoardItemViewProps interface
+ */
+export declare function createEntityBoardCardComponent<M extends Record<string, unknown>>(collection: EntityCollection<M>, options: {
+    onClick?: (entity: Entity<M>) => void;
+    isEntitySelected?: (entity: Entity<M>) => boolean;
+    onSelectionChange?: (entity: Entity<M>, selected: boolean) => void;
+    selectionEnabled?: boolean;
+}): React.ComponentType<BoardItemViewProps<M>>;
+export {};

package/dist/admin/src/components/EntityCollectionView/EntityCard.d.ts

@@ -0,0 +1,20 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { CollectionSize, Entity } from "@rebasepro/types";
+export type EntityCardProps<M extends Record<string, unknown> = Record<string, unknown>> = {
+    entity: Entity<M>;
+    collection: EntityCollection<M>;
+    onClick?: (entity: Entity<M>) => void;
+    selected?: boolean;
+    highlighted?: boolean;
+    onSelectionChange?: (entity: Entity<M>, selected: boolean) => void;
+    selectionEnabled?: boolean;
+    /**
+     * Size of the card - affects checkbox styling
+     */
+    size?: CollectionSize;
+};
+/**
+ * Card component for displaying an entity in a grid view.
+ * Shows thumbnail, title, and preview properties via the shared slot system.
+ */
+export declare function EntityCard<M extends Record<string, unknown> = Record<string, unknown>>({ entity, collection, onClick, selected, highlighted, onSelectionChange, selectionEnabled, size }: EntityCardProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/EntityCollectionView/EntityCollectionBoardView.d.ts

@@ -0,0 +1,22 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { Entity, EntityTableController, SelectionController } from "@rebasepro/types";
+export type EntityCollectionBoardViewProps<M extends Record<string, unknown> = Record<string, unknown>> = {
+    collection: EntityCollection<M>;
+    tableController: EntityTableController<M>;
+    fullPath: string;
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
+    columnProperty: string;
+    onEntityClick?: (entity: Entity<M>) => void;
+    selectionController?: SelectionController<M>;
+    selectionEnabled?: boolean;
+    highlightedEntities?: Entity<M>[];
+    emptyComponent?: React.ReactNode;
+    /** Called when entities are deleted - used for optimistic count updates */
+    deletedEntities?: Entity<M>[];
+};
+/**
+ * Kanban board view for displaying entities grouped by a string enum property.
+ */
+export declare function EntityCollectionBoardView<M extends Record<string, unknown> = Record<string, unknown>>({ collection, tableController, fullPath, parentCollectionSlugs, parentEntityIds, columnProperty, onEntityClick, selectionController, selectionEnabled, highlightedEntities, emptyComponent, deletedEntities }: EntityCollectionBoardViewProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/EntityCollectionView/EntityCollectionCardView.d.ts

@@ -0,0 +1,32 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { CollectionSize, Entity, EntityTableController, SelectionController } from "@rebasepro/types";
+export type EntityCollectionCardViewProps<M extends Record<string, unknown> = Record<string, unknown>> = {
+    collection: EntityCollection<M>;
+    tableController: EntityTableController<M>;
+    onEntityClick?: (entity: Entity<M>) => void;
+    selectionController?: SelectionController<M>;
+    selectionEnabled?: boolean;
+    highlightedEntities?: Entity<M>[];
+    emptyComponent?: React.ReactNode;
+    onScroll?: (props: {
+        scrollDirection: "forward" | "backward";
+        scrollOffset: number;
+        scrollUpdateWasRequested: boolean;
+    }) => void;
+    initialScroll?: number;
+    /**
+     * Size of the cards in the grid view.
+     * - "xs": Extra small cards, most cards per row
+     * - "s": Small cards
+     * - "m": Medium cards (default)
+     * - "l": Large cards
+     * - "xl": Extra large cards, fewest cards per row
+     */
+    size?: CollectionSize;
+};
+/**
+ * Card grid view for displaying entities with infinite scroll.
+ * Alternative to the EntityCollectionTable for visual browsing.
+ */
+export declare function EntityCollectionCardView<M extends Record<string, unknown> = Record<string, unknown>>({ collection, tableController, onEntityClick, selectionController, selectionEnabled, highlightedEntities, emptyComponent, onScroll, initialScroll, size }: EntityCollectionCardViewProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/EntityCollectionView/EntityCollectionListView.d.ts

@@ -0,0 +1,50 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { CollectionSize, Entity, EntityAction, EntityTableController, SelectionController } from "@rebasepro/types";
+export type EntityCollectionListViewProps<M extends Record<string, unknown> = Record<string, unknown>> = {
+    collection: EntityCollection<M>;
+    tableController: EntityTableController<M>;
+    onEntityClick?: (entity: Entity<M>) => void;
+    selectionController?: SelectionController<M>;
+    selectionEnabled?: boolean;
+    highlightedEntities?: Entity<M>[];
+    emptyComponent?: React.ReactNode;
+    /**
+     * Size of the list rows.
+     * - "xs": Most compact, single-line rows
+     * - "s": Compact with minimal info
+     * - "m": Balanced (default) — title + subtitle
+     * - "l": Spacious with more preview fields
+     * - "xl": Full detail with all preview fields
+     */
+    size?: CollectionSize;
+    /**
+     * ID of the currently selected/active entity. When set, the matching
+     * row is visually highlighted with a primary accent.
+     */
+    selectedEntityId?: string | number;
+    /**
+     * Callback to get entity actions for a given entity.
+     * Only actions with `showActionsInListView: true` will be rendered.
+     */
+    getActionsForEntity?: (params: {
+        entity?: Entity<M>;
+        customEntityActions?: EntityAction[];
+    }) => EntityAction[];
+    /**
+     * Full path of the collection, used as context for action handlers.
+     */
+    path?: string;
+    /**
+     * How entities open when an action triggers navigation.
+     */
+    openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
+};
+/**
+ * Classic CMS list view for displaying entities.
+ * Designed to be the most familiar, stereotypical CMS content management view:
+ * - Clean rows with checkbox, icon/avatar, title, metadata, and actions
+ * - Column-sortable headers
+ * - Infinite scroll
+ */
+export declare function EntityCollectionListView<M extends Record<string, unknown> = Record<string, unknown>>({ collection, tableController, onEntityClick, selectionController, selectionEnabled, highlightedEntities, emptyComponent, size, selectedEntityId, getActionsForEntity, path, openEntityMode }: EntityCollectionListViewProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/EntityCollectionView/EntityCollectionView.d.ts

@@ -0,0 +1,65 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+/**
+ * @group Components
+ */
+export type EntityCollectionViewProps<M extends Record<string, unknown>> = {
+    /**
+     * Complete path where this collection is located.
+     * It defaults to the collection path if not provided.
+     */
+    path?: string;
+    /**
+     * Full path using navigation ids.
+     */
+    idPath?: string;
+    /**
+     * If this is a subcollection, specify the parent collection ids.
+     */
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
+    /**
+     * Whether this is a subcollection or not.
+     */
+    isSubCollection?: boolean;
+    className?: string;
+    /**
+     * If true, this view will store its filter and sorting status in the url params
+     */
+    updateUrl?: boolean;
+    /**
+     * When provided, the split view will render this entity's detail panel.
+     * Used by the router to pass the entity ID from the URL path.
+     */
+    selectedEntityId?: string | number;
+    /**
+     * When provided, the split view will open this tab (e.g. a subcollection slug)
+     * in the entity detail panel. Used by the router to pass the subcollection from the URL.
+     */
+    selectedTab?: string;
+} & EntityCollection<M>;
+/**
+ * This component is in charge of binding a driver path with an {@link EntityCollection}
+ * where it's configuration is defined. It includes an infinite scrolling table
+ * and a 'Add' new entities button,
+ *
+ * This component is the default one used for displaying entity collections
+ * and is in charge of generating all the specific actions and customization
+ * of the lower level {@link EntityCollectionTable}
+ *
+ * Please **note** that you only need to use this component if you are building
+ * a custom view. If you just need to create a default view you can do it
+ * exclusively with config options.
+ *
+ * If you need a lower level implementation with more granular options, you
+ * can use {@link EntityCollectionTable}.
+ *
+ * If you need a generic table that is not bound to the driver or entities and
+ * properties at all, you can check {@link VirtualTable}
+ *
+ * @param path
+ * @param collection
+
+ * @group Components
+ */
+export declare const EntityCollectionView: React.FunctionComponent<EntityCollectionViewProps<any>>;

package/dist/admin/src/components/EntityCollectionView/EntityCollectionViewActions.d.ts

@@ -0,0 +1,20 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { EntityTableController, SelectionController } from "@rebasepro/types";
+export type EntityCollectionViewActionsProps<M extends Record<string, unknown>> = {
+    collection: EntityCollection<M>;
+    path: string;
+    relativePath: string;
+    parentCollectionSlugs: string[];
+    parentEntityIds: string[];
+    selectionEnabled: boolean;
+    onNewClick: () => void;
+    onMultipleDeleteClick: () => void;
+    selectionController: SelectionController<M>;
+    tableController: EntityTableController<M>;
+    collectionEntitiesCount?: number;
+    compact?: boolean;
+    children?: React.ReactNode;
+    openNewDocument: (defaultValues?: Record<string, unknown>) => void;
+};
+export declare function EntityCollectionViewActions<M extends Record<string, unknown>>({ collection, relativePath, parentCollectionSlugs, parentEntityIds, onNewClick, onMultipleDeleteClick, selectionEnabled, path, selectionController, tableController, collectionEntitiesCount, compact, children, openNewDocument }: EntityCollectionViewActionsProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/EntityCollectionView/EntityCollectionViewStartActions.d.ts

@@ -0,0 +1,20 @@
+import type { Properties } from "@rebasepro/types";
+import type { EntityCollection } from "@rebasepro/types";
+import { EntityTableController, SelectionController } from "@rebasepro/types";
+export type EntityCollectionViewStartActionsProps<M extends Record<string, unknown>> = {
+    collection: EntityCollection<M>;
+    path: string;
+    relativePath: string;
+    parentCollectionSlugs: string[];
+    parentEntityIds: string[];
+    selectionController: SelectionController<M>;
+    tableController: EntityTableController<M>;
+    collectionEntitiesCount?: number;
+    /**
+     * Resolved properties from the collection for the filters dialog
+     */
+    resolvedProperties?: Properties;
+    compact?: boolean;
+    openNewDocument: (defaultValues?: Record<string, unknown>) => void;
+};
+export declare function EntityCollectionViewStartActions<M extends Record<string, unknown>>({ collection, relativePath, parentCollectionSlugs, parentEntityIds, path, selectionController, tableController, collectionEntitiesCount, resolvedProperties, compact, openNewDocument }: EntityCollectionViewStartActionsProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/EntityCollectionView/FilterPresetsButton.d.ts

@@ -0,0 +1,21 @@
+import type { EntityTableController, FilterPreset } from "@rebasepro/types";
+export interface FilterPresetsButtonProps<M extends Record<string, unknown>> {
+    filterPresets: FilterPreset<Extract<keyof M, string> | (string & {})>[];
+    tableController: EntityTableController<M>;
+    compact?: boolean;
+}
+/**
+ * Filter Presets — displayed as inline toggle chips in the collection toolbar.
+ *
+ * Active state is **derived** from the controller's actual filter values,
+ * not tracked locally. A chip is "active" when ALL of its filter entries
+ * match the current controller state (deep value comparison, no JSON.stringify).
+ *
+ * This means:
+ * - Toggling a preset on adds its filters to the controller.
+ * - Toggling it off removes its filter keys.
+ * - Changing filters via the dialog automatically deactivates unmatched chips.
+ * - Clearing all filters deactivates all chips.
+ * - Multiple presets can be active simultaneously.
+ */
+export declare function FilterPresetsButton<M extends Record<string, unknown>>({ filterPresets, tableController, compact }: FilterPresetsButtonProps<M>): import("react/jsx-runtime").JSX.Element | null;

package/dist/admin/src/components/EntityCollectionView/FiltersDialog.d.ts

@@ -0,0 +1,15 @@
+import type { Property } from "@rebasepro/types";
+import { FilterValues } from "@rebasepro/types";
+export interface FiltersDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    properties: Record<string, Property>;
+    filterValues: FilterValues<any> | undefined;
+    setFilterValues: (filterValues?: FilterValues<any>) => void;
+    fixedFilter?: FilterValues<any>;
+}
+/**
+ * Dialog that displays all filterable properties from a collection
+ * and allows setting filter values for each.
+ */
+export declare function FiltersDialog({ open, onOpenChange, properties, filterValues, setFilterValues, fixedFilter }: FiltersDialogProps): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/EntityCollectionView/SplitListView.d.ts

@@ -0,0 +1,58 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { CollectionSize, Entity, EntityTableController, SelectionController } from "@rebasepro/types";
+export type SplitListViewProps<M extends Record<string, unknown> = Record<string, unknown>> = {
+    collection: EntityCollection<M>;
+    tableController: EntityTableController<M>;
+    onEntityClick?: (entity: Entity<M>) => void;
+    onNewClick?: () => void;
+    selectionController?: SelectionController<M>;
+    selectionEnabled?: boolean;
+    highlightedEntities?: Entity<M>[];
+    emptyComponent?: React.ReactNode;
+    onScroll?: (props: {
+        scrollDirection: "forward" | "backward";
+        scrollOffset: number;
+        scrollUpdateWasRequested: boolean;
+    }) => void;
+    initialScroll?: number;
+    size?: CollectionSize;
+    path: string;
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
+    /**
+     * The entity ID to show in the detail panel.
+     * Comes from the URL path (e.g. /c/authors/14 → selectedEntityId = "14").
+     * When undefined, no detail panel is shown.
+     */
+    selectedEntityId?: string | number;
+    /**
+     * When provided, the detail panel will open this tab (e.g. a subcollection slug).
+     * Used by the router to pass the subcollection tab from the URL.
+     */
+    selectedTab?: string;
+    /**
+     * Toolbar to render above the content in the left panel.
+     */
+    toolbar?: React.ReactNode;
+    /**
+     * The collection view to render on the left side.
+     */
+    children: React.ReactNode;
+};
+/**
+ * Master-detail split view.
+ * Shows the list on the left and the entity edit view on the right.
+ *
+ * Animation approach:
+ * - The list always renders at full width.
+ * - When a detail opens, the list shrinks to `panelSize%` and the detail slides in.
+ * - On close, the reverse plays.
+ *
+ * State management:
+ * - The selected entity is driven by the URL path (e.g. /c/authors/14).
+ *   `selectedEntityId` comes from props via RebaseRoute, NOT from internal state.
+ * - Clicking an entity navigates to /c/authors/{id} via the standard onEntityClick handler.
+ * - Closing the detail navigates back to /c/authors.
+ */
+export declare function SplitListView<M extends Record<string, unknown> = Record<string, unknown>>({ collection, tableController, onEntityClick: externalOnEntityClick, onNewClick: externalOnNewClick, selectionController, selectionEnabled, highlightedEntities, emptyComponent, onScroll, initialScroll, size, path, parentCollectionSlugs, parentEntityIds, selectedEntityId, selectedTab, toolbar, children }: SplitListViewProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/EntityCollectionView/ViewModeToggle.d.ts

@@ -0,0 +1,44 @@
+import { CollectionSize, ViewMode } from "@rebasepro/types";
+export type KanbanPropertyOption = {
+    key: string;
+    label: string;
+};
+export type ViewModeToggleProps = {
+    viewMode?: ViewMode;
+    onViewModeChange?: (mode: ViewMode) => void;
+    /**
+     * Which view modes are enabled for this collection.
+     * Only these modes will appear in the toggle.
+     * Defaults to all three: ["table", "cards", "kanban"].
+     */
+    enabledViews?: ViewMode[];
+    /**
+     * Current size for card/table views
+     */
+    size?: CollectionSize;
+    /**
+     * Callback when size changes
+     */
+    onSizeChanged?: (size: CollectionSize) => void;
+    /**
+     * Controlled open state for the popover
+     */
+    open?: boolean;
+    /**
+     * Callback when popover open state changes
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Available properties that can be used for kanban columns (enum properties)
+     */
+    kanbanPropertyOptions?: KanbanPropertyOption[];
+    /**
+     * Currently selected property for kanban columns
+     */
+    selectedKanbanProperty?: string;
+    /**
+     * Callback when the kanban column property changes
+     */
+    onKanbanPropertyChange?: (property: string) => void;
+};
+export declare function ViewModeToggle({ viewMode, onViewModeChange, enabledViews, size, onSizeChanged, open, onOpenChange, kanbanPropertyOptions, selectedKanbanProperty, onKanbanPropertyChange }: ViewModeToggleProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/admin/src/components/EntityCollectionView/board_types.d.ts

@@ -0,0 +1,105 @@
+import { CSSProperties } from "react";
+import { ChipColorKey, ChipColorScheme } from "@rebasepro/ui";
+import { Entity } from "@rebasepro/types";
+/**
+ * Item wrapper for entities in the Board component
+ */
+export interface BoardItem<M extends Record<string, unknown> = Record<string, unknown>> {
+    id: string;
+    entity: Entity<M>;
+}
+/**
+ * Map of column keys to arrays of board items
+ */
+export interface BoardItemMap<M extends Record<string, unknown> = Record<string, unknown>> {
+    [columnKey: string]: BoardItem<M>[];
+}
+/**
+ * Props passed to custom item render components
+ */
+export interface BoardItemViewProps<M extends Record<string, unknown> = Record<string, unknown>> {
+    item: BoardItem<M>;
+    isDragging: boolean;
+    isClone?: boolean;
+    isGroupedOver?: boolean;
+    style?: CSSProperties;
+    index?: number;
+}
+/**
+ * Per-column loading state
+ */
+export interface ColumnLoadingState {
+    [columnKey: string]: {
+        loading: boolean;
+        hasMore: boolean;
+        itemCount: number;
+        /** Total count of entities in column (may differ from itemCount if some lack orderProperty) */
+        totalCount?: number;
+    };
+}
+/**
+ * Props for the Board component
+ */
+export interface BoardProps<M extends Record<string, unknown>, COLUMN extends string> {
+    /**
+     * Array of board items (entities wrapped with id)
+     */
+    data: BoardItem<M>[];
+    /**
+     * Array of column keys/identifiers
+     */
+    columns: COLUMN[];
+    /**
+     * Labels for each column (optional, uses column key if not provided)
+     */
+    columnLabels?: Record<COLUMN, string>;
+    /**
+     * Colors for each column from enum values (optional)
+     */
+    columnColors?: Record<COLUMN, ChipColorKey | ChipColorScheme | undefined>;
+    /**
+     * CSS class name for the board container
+     */
+    className?: string;
+    /**
+     * Function to determine which column an item belongs to
+     */
+    assignColumn: (item: BoardItem<M>) => COLUMN;
+    /**
+     * Whether column reordering is allowed.
+     * Set to true only when a plugin provides persistence for column order.
+     */
+    allowColumnReorder?: boolean;
+    /**
+     * Callback when columns are reordered
+     */
+    onColumnReorder?: (columns: COLUMN[]) => void;
+    /**
+     * Callback when items are reordered or moved between columns
+     */
+    onItemsReorder?: (items: BoardItem<M>[], moveInfo?: {
+        itemId: string;
+        sourceColumn: COLUMN;
+        targetColumn: COLUMN;
+    }) => void;
+    /**
+     * Component to render individual items
+     */
+    ItemComponent: React.ComponentType<BoardItemViewProps<M>>;
+    /**
+     * Per-column loading state for pagination
+     */
+    columnLoadingState?: ColumnLoadingState;
+    /**
+     * Callback to load more items for a column
+     */
+    onLoadMoreColumn?: (column: COLUMN) => void;
+    /**
+     * Callback to add a new item to a specific column
+     */
+    onAddItemToColumn?: (column: COLUMN) => void;
+    /**
+     * Optional component to render at the end of the board for adding new columns
+     */
+    AddColumnComponent?: React.ReactNode;
+}

package/dist/admin/src/components/EntityCollectionView/hooks/useCollectionInlineEditor.d.ts

@@ -0,0 +1,12 @@
+import { EntityCollection, RebaseData, RebaseContext } from "@rebasepro/types";
+import { OnCellValueChange, UniqueFieldValidator } from "@rebasepro/core";
+export interface UseCollectionInlineEditorParams<M extends Record<string, unknown>> {
+    path: string;
+    collection: EntityCollection<M>;
+    dataClient: RebaseData;
+    context: RebaseContext;
+}
+export declare function useCollectionInlineEditor<M extends Record<string, unknown>>({ path, collection, dataClient, context }: UseCollectionInlineEditorParams<M>): {
+    onValueChange: OnCellValueChange<any, any>;
+    uniqueFieldValidator: UniqueFieldValidator;
+};

package/dist/admin/src/components/EntityCollectionView/hooks/useKanbanDragAndDrop.d.ts

@@ -0,0 +1,19 @@
+import { EntityCollection, RebaseData, RebaseContext } from "@rebasepro/types";
+import { BoardItem } from "../board_types";
+export interface UseKanbanDragAndDropParams<M extends Record<string, unknown>> {
+    collection: EntityCollection<M>;
+    fullPath: string;
+    columnProperty: string;
+    orderProperty?: string;
+    dataClient: RebaseData;
+    context: RebaseContext;
+    boardDataController: any;
+    analyticsController: any;
+}
+export declare function useKanbanDragAndDrop<M extends Record<string, unknown>>({ collection, fullPath, columnProperty, orderProperty, dataClient, context, boardDataController, analyticsController }: UseKanbanDragAndDropParams<M>): {
+    handleItemsReorder: (items: BoardItem<M>[], moveInfo?: {
+        itemId: string;
+        sourceColumn: string;
+        targetColumn: string;
+    }) => Promise<void>;
+};