@rebasepro/core 0.0.1-canary.0

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

@@ -0,0 +1,20 @@
+import React from "react";
+import { CollectionSize, EntityCollection, EntityRelation, FilterValues, Relation } from "@rebasepro/types";
+type TableMultipleRelationFieldProps = {
+    name: string;
+    disabled: boolean;
+    internalValue: EntityRelation[] | undefined | null;
+    updateValue: (newValue: EntityRelation[] | null) => void;
+    size: CollectionSize;
+    previewProperties?: string[];
+    title?: string;
+    relation: Relation;
+    forceFilter?: FilterValues<string>;
+    includeId?: boolean;
+    includeEntityLink?: boolean;
+};
+export declare function TableMultipleRelationField(props: TableMultipleRelationFieldProps): import("react/jsx-runtime").JSX.Element;
+export declare const TableMultipleRelationFieldInternal: React.NamedExoticComponent<TableMultipleRelationFieldProps & {
+    collection: EntityCollection;
+}>;
+export {};

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

@@ -0,0 +1,21 @@
+import React from "react";
+import { CollectionSize, EntityCollection, EntityReference, FilterValues } from "@rebasepro/types";
+type TableReferenceFieldProps = {
+    name: string;
+    disabled: boolean;
+    internalValue: EntityReference | EntityReference[] | undefined | null;
+    updateValue: (newValue: (EntityReference | EntityReference[] | null)) => void;
+    size: CollectionSize;
+    multiselect: boolean;
+    previewProperties?: string[];
+    title?: string;
+    path: string;
+    forceFilter?: FilterValues<string>;
+    includeId?: boolean;
+    includeEntityLink?: boolean;
+};
+export declare function TableReferenceField(props: TableReferenceFieldProps): import("react/jsx-runtime").JSX.Element;
+export declare const TableReferenceFieldInternal: React.NamedExoticComponent<TableReferenceFieldProps & {
+    collection: EntityCollection;
+}>;
+export {};

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

@@ -0,0 +1,21 @@
+import React from "react";
+import { CollectionSize, EntityCollection, EntityRelation, FilterValues, Relation } from "@rebasepro/types";
+type TableRelationFieldProps = {
+    name: string;
+    disabled: boolean;
+    internalValue: EntityRelation | EntityRelation[] | undefined | null;
+    updateValue: (newValue: (EntityRelation | EntityRelation[] | null)) => void;
+    size: CollectionSize;
+    multiselect: boolean;
+    previewProperties?: string[];
+    title?: string;
+    relation: Relation;
+    forceFilter?: FilterValues<string>;
+    includeId?: boolean;
+    includeEntityLink?: boolean;
+};
+export declare function TableRelationField(props: TableRelationFieldProps): import("react/jsx-runtime").JSX.Element;
+export declare const TableRelationFieldInternal: React.NamedExoticComponent<TableRelationFieldProps & {
+    collection: EntityCollection;
+}>;
+export {};

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

@@ -0,0 +1,20 @@
+import { EntityRelation, FilterValues, Relation } from "@rebasepro/types";
+interface RelationSelectorFieldProps {
+    /** Field name */
+    name: string;
+    /** Whether the field is disabled */
+    disabled?: boolean;
+    /** Current value - can be single EntityRelation or array for multiple selection */
+    internalValue: EntityRelation | EntityRelation[] | undefined | null;
+    /** Callback when value changes */
+    updateValue: (newValue: EntityRelation | EntityRelation[] | null) => void;
+    /** The relation configuration */
+    relation: Relation;
+    /** Force filter to be applied to the relation search */
+    forceFilter?: FilterValues<string>;
+    /** Collection size for display */
+    size?: "small" | "medium";
+}
+/** Thin wrapper around RelationSelector for table cells */
+export declare function TableRelationSelectorField({ disabled, internalValue, updateValue, relation, forceFilter, size, }: RelationSelectorFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,32 @@
+import * as React from "react";
+import { ArrayProperty, Entity, PreviewSize, StringProperty } from "@rebasepro/types";
+/**
+ * Field that allows to upload files to Google Cloud Storage.
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function TableStorageUpload(props: {
+    propertyKey: string;
+    error: Error | undefined;
+    disabled: boolean;
+    value: string | string[] | null;
+    updateValue: (newValue: (string | string[] | null)) => void;
+    selected: boolean;
+    focused: boolean;
+    property: StringProperty | ArrayProperty;
+    entity: Entity<any>;
+    path: string;
+    previewSize: PreviewSize;
+    openPopup?: (cellRect?: DOMRect) => void;
+    onBlur?: React.FocusEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+}): import("react/jsx-runtime").JSX.Element;
+interface TableStorageItemPreviewProps {
+    property: StringProperty;
+    value: string;
+    size: PreviewSize;
+    entity: Entity<any>;
+}
+export declare function TableStorageItemPreview({ property, value, size, entity }: TableStorageItemPreviewProps): import("react/jsx-runtime").JSX.Element;
+export {};

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 "../common/useDataSourceTableController";
+export * from "./column_utils";

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

@@ -0,0 +1,16 @@
+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;
+    onTextSearchClick?: () => void;
+    onTextSearch?: (searchString?: string) => void;
+    textSearchLoading?: boolean;
+}
+export declare function CollectionTableToolbar({ actions, actionsStart, loading, onTextSearch, onTextSearchClick, textSearchLoading, title, viewModeToggle }: 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 "../../common/table_height";
+interface EntityTableCellProps {
+    children: React.ReactNode;
+    actions?: React.ReactNode;
+    /**
+     * The value is used only to check changes and force re-renders
+     */
+    value?: any;
+    disabled: boolean;
+    saved?: boolean;
+    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,4 @@
+import { EntityCollection, 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,26 @@
+import { Entity, EntityCollection } from "@rebasepro/types";
+import { CustomFieldValidator } from "../../../../form/validation";
+import { OnCellValueChangeParams } from "../../../common";
+interface PopupFormFieldProps<M extends Record<string, any>> {
+    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, any>>(props: PopupFormFieldProps<M>): import("react/jsx-runtime").JSX.Element | null;
+export declare function PopupFormFieldLoading<M extends Record<string, any>>({ 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, any>>({ 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/EntityCollectionView/Board.d.ts

@@ -0,0 +1,2 @@
+import { BoardProps } from "./board_types";
+export declare function Board<M extends Record<string, any>, 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, any>> {
+    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, any>>(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, any>> {
+    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, any>>({ 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,26 @@
+import React from "react";
+import { Entity, EntityCollection } from "@rebasepro/types";
+import { BoardItemViewProps } from "./board_types";
+export type EntityBoardCardProps<M extends Record<string, any> = any> = 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.
+ * Shows thumbnail, title, and optional selection checkbox.
+ */
+declare function EntityBoardCardInner<M extends Record<string, any> = any>({ 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, any>>(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,19 @@
+import { CollectionSize, Entity, EntityCollection } from "@rebasepro/types";
+export type EntityCardProps<M extends Record<string, any> = any> = {
+    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.
+ */
+export declare function EntityCard<M extends Record<string, any> = any>({ 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,20 @@
+import React from "react";
+import { Entity, EntityCollection, EntityTableController, SelectionController } from "@rebasepro/types";
+export type EntityCollectionBoardViewProps<M extends Record<string, any> = any> = {
+    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, any> = any>({ 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,31 @@
+import React from "react";
+import { CollectionSize, Entity, EntityCollection, EntityTableController, SelectionController } from "@rebasepro/types";
+export type EntityCollectionCardViewProps<M extends Record<string, any> = any> = {
+    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, any> = any>({ collection, tableController, onEntityClick, selectionController, selectionEnabled, highlightedEntities, emptyComponent, onScroll, initialScroll, size }: EntityCollectionCardViewProps<M>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,54 @@
+import React from "react";
+import { EntityCollection } from "@rebasepro/types";
+/**
+ * @group Components
+ */
+export type EntityCollectionViewProps<M extends Record<string, any>> = {
+    /**
+     * 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;
+} & EntityCollection<M>;
+/**
+ * This component is in charge of binding a datasource 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 datasource 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,14 @@
+import { EntityCollection, EntityTableController, SelectionController } from "@rebasepro/types";
+export type EntityCollectionViewActionsProps<M extends Record<string, any>> = {
+    collection: EntityCollection<M>;
+    path: string;
+    relativePath: string;
+    parentCollectionIds: string[];
+    selectionEnabled: boolean;
+    onNewClick: () => void;
+    onMultipleDeleteClick: () => void;
+    selectionController: SelectionController<M>;
+    tableController: EntityTableController<M>;
+    collectionEntitiesCount?: number;
+};
+export declare function EntityCollectionViewActions<M extends Record<string, any>>({ collection, relativePath, parentCollectionIds, onNewClick, onMultipleDeleteClick, selectionEnabled, path, selectionController, tableController, collectionEntitiesCount, }: EntityCollectionViewActionsProps<M>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,15 @@
+import { EntityCollection, EntityTableController, Properties, SelectionController } from "@rebasepro/types";
+export type EntityCollectionViewStartActionsProps<M extends Record<string, any>> = {
+    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;
+};
+export declare function EntityCollectionViewStartActions<M extends Record<string, any>>({ collection, relativePath, parentCollectionIds, path, selectionController, tableController, collectionEntitiesCount, resolvedProperties }: EntityCollectionViewStartActionsProps<M>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,14 @@
+import { FilterValues, Property } 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/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;