@rebasepro/admin 0.0.1-canary.4f204c2

package/dist/components/EntityCollectionTable/fields/VirtualTableUserSelect.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+export declare function VirtualTableUserSelect(props: {
+    name: string;
+    error: Error | undefined;
+    multiple: boolean;
+    disabled: boolean;
+    small: boolean;
+    internalValue: string | string[] | undefined;
+    updateValue: (newValue: (string | string[] | null)) => void;
+    focused: boolean;
+    onBlur?: React.FocusEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/EntityCollectionTable/index.d.ts

@@ -0,0 +1,6 @@
+export { EntityCollectionTable } from "./EntityCollectionTable";
+export type { EntityCollectionTableProps } from "./EntityCollectionTableProps";
+export * from "./PropertyTableCell";
+export * from "./EntityCollectionRowActions";
+export * from "./column_utils";
+export { VirtualTableInput } from "./fields/VirtualTableInput";

package/dist/components/EntityCollectionTable/internal/CollectionTableToolbar.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+interface CollectionTableToolbarProps {
+    loading: boolean;
+    actionsStart?: React.ReactNode;
+    actions?: React.ReactNode;
+    /**
+     * View mode toggle button, positioned left of the search bar.
+     */
+    viewModeToggle?: React.ReactNode;
+    title?: React.ReactNode;
+    onTextSearch?: (searchString?: string) => void;
+    /**
+     * When true the toolbar is in "compact" mode for the split-view left panel.
+     * - Search bar, loading spinner, and view-mode toggle are hidden.
+     * - Secondary actions remain inline (displayed horizontally).
+     * - Only `actionsStart` (filters) and the add button (last child of `actions`) remain visible.
+     */
+    compact?: boolean;
+}
+export declare function CollectionTableToolbar({ actions, actionsStart, loading, onTextSearch, title, viewModeToggle, compact }: CollectionTableToolbarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/EntityCollectionTable/internal/EntityTableCell.d.ts

@@ -0,0 +1,32 @@
+import React from "react";
+import { TableSize } from "@rebasepro/core";
+interface EntityTableCellProps {
+    children: React.ReactNode;
+    actions?: React.ReactNode;
+    /**
+     * The value is used only to check changes and force re-renders
+     */
+    value?: any;
+    disabled: boolean;
+    savedTimestamp?: number;
+    error?: Error;
+    allowScroll?: boolean;
+    align: "right" | "left" | "center";
+    size: TableSize;
+    disabledTooltip?: string;
+    width: number;
+    showExpandIcon?: boolean;
+    removePadding?: boolean;
+    fullHeight?: boolean;
+    selected?: boolean;
+    hideOverflow?: boolean;
+    onSelect?: (cellRect: DOMRect | undefined) => void;
+    sortableNodeRef?: (node: HTMLElement | null) => void;
+    sortableStyle?: React.CSSProperties;
+    sortableAttributes?: Record<string, any>;
+    isDragging?: boolean;
+    isDraggable?: boolean;
+    frozen?: boolean;
+}
+export declare const EntityTableCell: React.FunctionComponent<EntityTableCellProps>;
+export {};

package/dist/components/EntityCollectionTable/internal/EntityTableCellActions.d.ts

@@ -0,0 +1,9 @@
+export interface EntityTableCellActionsProps {
+    showError: false | Error | undefined;
+    disabled: boolean;
+    showExpandIcon: boolean | undefined;
+    selected: boolean | undefined;
+    openPopup?: (cellRect: DOMRect | undefined) => void;
+    children?: React.ReactNode;
+}
+export declare function EntityTableCellActions({ showError, disabled, showExpandIcon, selected, openPopup, children }: EntityTableCellActionsProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/EntityCollectionTable/internal/common.d.ts

@@ -0,0 +1,5 @@
+import type { EntityCollection } from "@rebasepro/types";
+import type { Property } from "@rebasepro/types";
+export declare function getTableCellAlignment(property: Property): "right" | "left" | "center";
+export declare function getTablePropertyColumnWidth(property: Property): number;
+export declare function getSubcollectionColumnId(collection: EntityCollection): string;

package/dist/components/EntityCollectionTable/internal/popup_field/PopupFormField.d.ts

@@ -0,0 +1,27 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { Entity } from "@rebasepro/types";
+import { CustomFieldValidator } from "../../../../form/validation";
+import type { OnCellValueChangeParams } from "@rebasepro/core";
+interface PopupFormFieldProps<M extends Record<string, unknown>> {
+    customFieldValidator?: CustomFieldValidator;
+    path: string;
+    entityId: string | number;
+    tableKey: string;
+    propertyKey?: Extract<keyof M, string>;
+    collection?: EntityCollection<any>;
+    cellRect?: DOMRect;
+    open: boolean;
+    onClose: () => void;
+    container: HTMLElement | null;
+    /**
+     * Callback when the value of a cell has been edited
+     * @param params
+     */
+    onCellValueChange?: (params: OnCellValueChangeParams<any, any>) => Promise<void> | void;
+}
+export declare function PopupFormField<M extends Record<string, unknown>>(props: PopupFormFieldProps<M>): import("react/jsx-runtime").JSX.Element | null;
+export declare function PopupFormFieldLoading<M extends Record<string, unknown>>({ tableKey, entityId, customFieldValidator, propertyKey, collection: inputCollection, path, cellRect, open, onClose, onCellValueChange, container }: PopupFormFieldProps<M>): import("react/jsx-runtime").JSX.Element | null;
+export declare function PopupFormFieldInternal<M extends Record<string, unknown>>({ tableKey, entityId, customFieldValidator, propertyKey, collection, path, cellRect, open, onClose, onCellValueChange, container, entity }: PopupFormFieldProps<M> & {
+    entity?: Entity<M>;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/EntityCollectionTable/internal/popup_field/useDraggable.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+interface DraggableProps {
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    innerRef: React.RefObject<HTMLDivElement | null>;
+    x?: number;
+    y?: number;
+    onMove: (params: {
+        x: number;
+        y: number;
+    }) => void;
+}
+export declare function useDraggable({ containerRef, innerRef, x, y, onMove }: DraggableProps): void;
+export {};

package/dist/components/EntityCollectionTable/internal/popup_field/useWindowSize.d.ts

@@ -0,0 +1,6 @@
+interface WindowSize {
+    width: number;
+    height: number;
+}
+export declare function useWindowSize(): WindowSize;
+export {};

package/dist/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/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/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/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/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/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/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/components/EntityCollectionView/EntityCollectionBoardView.d.ts

@@ -0,0 +1,21 @@
+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;
+    parentCollectionIds?: 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, parentCollectionIds, columnProperty, onEntityClick, selectionController, selectionEnabled, highlightedEntities, emptyComponent, deletedEntities }: EntityCollectionBoardViewProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/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/components/EntityCollectionView/EntityCollectionListView.d.ts

@@ -0,0 +1,34 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { CollectionSize, Entity, 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;
+};
+/**
+ * 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 }: EntityCollectionListViewProps<M>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,64 @@
+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.
+     */
+    parentCollectionIds?: 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/components/EntityCollectionView/EntityCollectionViewActions.d.ts

@@ -0,0 +1,18 @@
+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;
+    parentCollectionIds: string[];
+    selectionEnabled: boolean;
+    onNewClick: () => void;
+    onMultipleDeleteClick: () => void;
+    selectionController: SelectionController<M>;
+    tableController: EntityTableController<M>;
+    collectionEntitiesCount?: number;
+    compact?: boolean;
+    children?: React.ReactNode;
+};
+export declare function EntityCollectionViewActions<M extends Record<string, unknown>>({ collection, relativePath, parentCollectionIds, onNewClick, onMultipleDeleteClick, selectionEnabled, path, selectionController, tableController, collectionEntitiesCount, compact, children }: EntityCollectionViewActionsProps<M>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,18 @@
+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;
+    parentCollectionIds: string[];
+    selectionController: SelectionController<M>;
+    tableController: EntityTableController<M>;
+    collectionEntitiesCount?: number;
+    /**
+     * Resolved properties from the collection for the filters dialog
+     */
+    resolvedProperties?: Properties;
+    compact?: boolean;
+};
+export declare function EntityCollectionViewStartActions<M extends Record<string, unknown>>({ collection, relativePath, parentCollectionIds, path, selectionController, tableController, collectionEntitiesCount, resolvedProperties, compact }: EntityCollectionViewStartActionsProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/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;
+    forceFilter?: 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, forceFilter }: FiltersDialogProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,57 @@
+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;
+    parentCollectionIds?: 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, parentCollectionIds, selectedEntityId, selectedTab, toolbar, children }: SplitListViewProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/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;