@rebasepro/admin 0.0.1-canary.4f204c2

package/dist/components/AdminModeSyncer.d.ts

@@ -0,0 +1,17 @@
+import type { AppView } from "@rebasepro/types";
+export interface AdminModeSyncerProps {
+    /**
+     * Map of views designated as 'Studio' views.
+     * Navigating to any of these views will automatically flag the admin mode as "studio".
+     */
+    devViews?: AppView[];
+}
+/**
+ * A highly customizable utility component that observes react-router routes and
+ * actively shifts the internal Rebase `adminModeController` context to match
+ * the user's active window segment (e.g., Content vs Studio mode).
+ *
+ * Placing this anywhere safely inside the Rebase layout automatically triggers
+ * UI mode synchronization.
+ */
+export declare function AdminModeSyncer({ devViews }: AdminModeSyncerProps): null;

package/dist/components/ArrayContainer.d.ts

@@ -0,0 +1,58 @@
+import React from "react";
+export type ArrayEntryParams = {
+    index: number;
+    internalId: number;
+    isDragging: boolean;
+    storedProps?: object;
+    storeProps: (props: object) => void;
+};
+export type ArrayEntryBuilder = (params: ArrayEntryParams) => React.ReactNode;
+export interface ArrayContainerProps<T> {
+    droppableId: string;
+    value: T[];
+    addLabel: string;
+    buildEntry: ArrayEntryBuilder;
+    disabled?: boolean;
+    size?: "small" | "medium";
+    onInternalIdAdded?: (id: number) => void;
+    canAddElements?: boolean;
+    sortable?: boolean;
+    newDefaultEntry: T;
+    onValueChange: (value: T[]) => void;
+    className?: string;
+    min?: number;
+    max?: number;
+}
+type ArrayContainerItemProps = {
+    nodeRef: (node: HTMLElement | null) => void;
+    style: React.CSSProperties;
+    dragHandleProps: any;
+    index: number;
+    internalId: number;
+    size?: "small" | "medium";
+    disabled: boolean;
+    buildEntry: ArrayEntryBuilder;
+    remove: (index: number) => void;
+    copy: (index: number) => void;
+    addInIndex?: (index: number) => void;
+    canAddElements?: boolean;
+    sortable: boolean;
+    isDragging: boolean;
+    storedProps?: object;
+    updateItemCustomProps: (internalId: number, props: object) => void;
+};
+export declare function ArrayContainerItem({ nodeRef, style, dragHandleProps, index, internalId, size, disabled, buildEntry, remove, copy, addInIndex, canAddElements, sortable, isDragging, storedProps, updateItemCustomProps }: ArrayContainerItemProps): import("react/jsx-runtime").JSX.Element;
+export declare function ArrayItemOptions({ dragHandleProps, direction, disabled, remove, index, copy, canAddElements, sortable, addInIndex }: {
+    dragHandleProps: any;
+    direction?: "row" | "column";
+    disabled: boolean;
+    remove: (index: number) => void;
+    index: number;
+    copy: (index: number) => void;
+    sortable: boolean;
+    canAddElements?: boolean;
+    addInIndex?: (index: number) => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ArrayContainer<T>({ droppableId, addLabel, value, disabled, buildEntry, size, onInternalIdAdded, canAddElements: canAddElementsProp, sortable, newDefaultEntry, onValueChange, className, min, max }: ArrayContainerProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function getRandomId(): number;
+export {};

package/dist/components/ClearFilterSortButton.d.ts

@@ -0,0 +1,5 @@
+import { EntityTableController } from "@rebasepro/types";
+export declare function ClearFilterSortButton({ tableController, enabled }: {
+    enabled: boolean;
+    tableController: EntityTableController;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/CollectionEditorDialogs.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Renders the CollectionEditorDialog and PropertyFormDialog inside
+ * the RebaseShell tree where CMS-internal contexts
+ * (CollectionRegistryContext, NavigationStateContext, UrlContext)
+ * are available.
+ *
+ * Both dialog components are loaded dynamically via React.lazy so that
+ * production CMS bundles that never open the collection editor don't pay
+ * the download/parse cost up-front.
+ *
+ * The dialog state (open/close, props) is managed by ConfigControllerProvider
+ * (a root-scope plugin provider that wraps the shell) and exposed via
+ * CollectionEditorDialogsContext.
+ */
+export declare function CollectionEditorDialogs(): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/DefaultAppBar.d.ts

@@ -0,0 +1,29 @@
+import React from "react";
+import { User } from "@rebasepro/types";
+export type DefaultAppBarProps<ADDITIONAL_PROPS = object> = {
+    /**
+     * The content of the app bar, usually a title or logo. This includes a link to the home page.
+     */
+    title?: React.ReactNode;
+    /**
+     * A component that gets rendered on the upper side to the end of the main toolbar
+     */
+    endAdornment?: React.ReactNode;
+    /**
+     * A component that gets rendered on the upper side to the start of the main toolbar
+     */
+    startAdornment?: React.ReactNode;
+    dropDownActions?: React.ReactNode;
+    includeModeToggle?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    logo?: string;
+    user?: User;
+} & ADDITIONAL_PROPS;
+/**
+ * This component renders the main app bar of Rebase.
+ * You will likely not need to use this component directly.
+ *
+
+ */
+export declare const DefaultAppBar: ({ title, endAdornment, startAdornment, dropDownActions, includeModeToggle, className, style, user: userProp, logo: logoProp }: DefaultAppBarProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/DefaultDrawer.d.ts

@@ -0,0 +1,29 @@
+import React from "react";
+/**
+ * Default drawer used in the CMS
+ * @group Core
+ */
+export declare function DefaultDrawer({ title, logo, logoDestination, className, style }: {
+    title?: React.ReactNode;
+    logo?: string;
+    logoDestination?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function DrawerLogo({ logo, title, logoDestination, drawerOpen, drawerHovered }: {
+    logo?: string;
+    title?: React.ReactNode;
+    logoDestination?: string;
+    drawerOpen: boolean;
+    drawerHovered: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Toggle button at the bottom of the drawer.
+ * Uses double-chevron icons to indicate collapse/expand direction.
+ */
+export declare function DrawerToggle({ drawerOpen, drawerHovered, openDrawer, closeDrawer }: {
+    drawerOpen: boolean;
+    drawerHovered: boolean;
+    openDrawer: () => void;
+    closeDrawer: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/DeleteEntityDialog.d.ts

@@ -0,0 +1,13 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { Entity, EntityCallbacks } from "@rebasepro/types";
+export interface DeleteEntityDialogProps<M extends Record<string, unknown>> {
+    entityOrEntitiesToDelete?: Entity<M> | Entity<M>[];
+    path: string;
+    collection: EntityCollection<M>;
+    open: boolean;
+    onClose: () => void;
+    callbacks?: EntityCallbacks<M>;
+    onEntityDelete?(path: string, entity: Entity<M>): void;
+    onMultipleEntitiesDelete?(path: string, entities: Entity<M>[]): void;
+}
+export declare function DeleteEntityDialog<M extends Record<string, unknown>>({ entityOrEntitiesToDelete, collection, onClose, open, callbacks, onEntityDelete, onMultipleEntitiesDelete, path }: DeleteEntityDialogProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/components/DrawerNavigationGroup.d.ts

@@ -0,0 +1,49 @@
+import type { NavigationEntry } from "@rebasepro/types";
+import React from "react";
+export interface DrawerNavigationGroupProps {
+    /**
+     * Group name to display in header
+     */
+    group: string;
+    /**
+     * Navigation entries in this group
+     */
+    entries: NavigationEntry[];
+    /**
+     * Whether the group is collapsed
+     */
+    collapsed: boolean;
+    /**
+     * Callback when collapse state should toggle
+     */
+    onToggleCollapsed: () => void;
+    /**
+     * Whether the drawer is in open (expanded) state
+     */
+    drawerOpen: boolean;
+    /**
+     * Whether tooltips should be shown (drawer closed + hovered)
+     */
+    tooltipsOpen: boolean;
+    /**
+     * Whether admin menu is open (used to control tooltip visibility)
+     */
+    adminMenuOpen?: boolean;
+    /**
+     * Optional actions to render in the group header (e.g., "Add collection" button)
+     */
+    headerActions?: React.ReactNode;
+    /**
+     * Optional callback when a navigation item is clicked
+     */
+    onItemClick?: (entry: NavigationEntry) => void;
+    /**
+     * Hide the group header (title and expandable panel)
+     */
+    hideHeader?: boolean;
+}
+/**
+ * Shared drawer navigation group component used by both DefaultDrawer and RebaseCloudDrawer.
+ * Renders a collapsible group with header and navigation items.
+ */
+export declare function DrawerNavigationGroup({ group, entries, collapsed, onToggleCollapsed, drawerOpen, tooltipsOpen, adminMenuOpen, headerActions, onItemClick, hideHeader }: DrawerNavigationGroupProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/DrawerNavigationItem.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+export declare function DrawerNavigationItem({ name, icon, drawerOpen, adminMenuOpen, tooltipsOpen, url, onClick }: {
+    icon: React.ReactElement;
+    name: string;
+    tooltipsOpen: boolean;
+    drawerOpen: boolean;
+    adminMenuOpen?: boolean;
+    url: string;
+    onClick?: () => void;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,39 @@
+import type { EntityCollection } from "@rebasepro/types";
+import type { EntityAction } from "@rebasepro/types";
+import React from "react";
+import { CollectionSize, Entity, SelectionController } from "@rebasepro/types";
+/**
+ *
+ * @param entity
+ * @param width
+ * @param frozen
+ * @param isSelected
+ * @param selectionEnabled
+ * @param size
+ * @param toggleEntitySelection
+ * @param hideId
+ *
+ * @group Collection components
+ */
+export declare const EntityCollectionRowActions: ({ entity, collection, path, width, frozen, isSelected, selectionEnabled, size, highlightEntity, onCollectionChange, unhighlightEntity, actions, hideId, selectionController, openEntityMode, sortableNodeRef, sortableStyle, sortableAttributes, isDragging, isDraggable }: {
+    entity: Entity<any>;
+    collection?: EntityCollection<any>;
+    path?: string;
+    width: number;
+    frozen?: boolean;
+    size: CollectionSize;
+    isSelected?: boolean;
+    selectionEnabled?: boolean;
+    actions?: EntityAction[];
+    hideId?: boolean;
+    onCollectionChange?: () => void;
+    selectionController?: SelectionController;
+    highlightEntity?: (entity: Entity<any>) => void;
+    unhighlightEntity?: (entity: Entity<any>) => void;
+    openEntityMode: "side_panel" | "full_screen" | "split";
+    sortableNodeRef?: (node: HTMLElement | null) => void;
+    sortableStyle?: React.CSSProperties;
+    sortableAttributes?: Record<string, any>;
+    isDragging?: boolean;
+    isDraggable?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,27 @@
+import { User } from "@rebasepro/types";
+import { EntityCollectionTableProps } from "./EntityCollectionTableProps";
+/**
+ * This component is in charge of rendering a collection table with a high
+ * degree of customization.
+ *
+ * This component is used internally by {@link EntityCollectionView} and
+ * {@link useReferenceDialog}
+ *
+ * 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 want to bind a {@link EntityCollection} to a table with the default
+ * options you see in collections in the top level navigation, you can
+ * check {@link EntityCollectionView}.
+ *
+ * The data displayed in the table is managed by a {@link EntityTableController}.
+ * You can build the default, bound to a path in the driver, by using the hook
+ * {@link useDataTableController}
+ *
+ * @see EntityCollectionTableProps
+ * @see EntityCollectionView
+ * @see VirtualTable
+ * @group Components
+ */
+export declare const EntityCollectionTable: <M extends Record<string, unknown> = any, USER extends User = any>({ className, style, forceFilter, actionsStart, actions, viewModeToggle, title, tableRowActionsBuilder, uniqueFieldValidator, getPropertyFor, onValueChange, selectionController, highlightedEntities, onEntityClick, onColumnResize, initialScroll, onScroll, onSizeChanged, hoverRow, inlineEditing, additionalFields, displayedColumnIds, defaultSize, properties, tableController, filterable, sortable, endAdornment, AddColumnComponent, AdditionalHeaderWidget, additionalIDHeaderWidget, emptyComponent, getIdColumnWidth, enablePopupIcon, openEntityMode, onColumnsOrderChange, hideToolbar }: EntityCollectionTableProps<M>) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,129 @@
+import type { Properties } from "@rebasepro/types";
+import type { AdditionalFieldDelegate } from "@rebasepro/types";
+import type { Property } from "@rebasepro/types";
+import React from "react";
+import { CollectionSize, Entity, EntityTableController, FilterValues, SelectionController, User } from "@rebasepro/types";
+import { OnCellValueChange, OnColumnResizeParams, UniqueFieldValidator } from "@rebasepro/core";
+import { VirtualTableColumn } from "@rebasepro/ui";
+/**
+ * @group Collection components
+ */
+export type EntityCollectionTableProps<M extends Record<string, unknown>, USER extends User = User> = {
+    className?: string;
+    style?: React.CSSProperties;
+    /**
+     * Display these entities as selected
+     */
+    selectionController: SelectionController<M>;
+    /**
+     * List of entities that will be displayed as selected;
+     */
+    highlightedEntities?: Entity<M>[];
+    /**
+     * Override the title in the toolbar
+     */
+    title?: React.ReactNode;
+    /**
+     * Additional component that renders actions such as buttons in the
+     * collection toolbar, displayed on the left side
+     */
+    actionsStart?: React.ReactNode;
+    /**
+     * Callback when a cell value changes.
+     */
+    onValueChange?: OnCellValueChange<any, M>;
+    uniqueFieldValidator?: UniqueFieldValidator;
+    /**
+     * Builder for creating the buttons in each row
+     * @param entity
+     * @param size
+     */
+    tableRowActionsBuilder?: (params: {
+        entity: Entity<M>;
+        size: CollectionSize;
+        width: number;
+        frozen?: boolean;
+    }) => React.ReactNode;
+    /**
+     * Callback when anywhere on the table is clicked
+     */
+    onEntityClick?(entity: Entity<M>): void;
+    /**
+     * Callback when a column is resized
+     */
+    onColumnResize?(params: OnColumnResizeParams): void;
+    /**
+     * Initial scroll position
+     */
+    initialScroll?: number;
+    /**
+     * Callback when the table is scrolled
+     * @param props
+     */
+    onScroll?: (props: {
+        scrollDirection: "forward" | "backward";
+        scrollOffset: number;
+        scrollUpdateWasRequested: boolean;
+    }) => void;
+    /**
+     * Callback when the selected size of the table is changed
+     */
+    onSizeChanged?(size: CollectionSize): void;
+    /**
+     * Should apply a different style to a row when hovering
+     */
+    hoverRow?: boolean;
+    /**
+     * Additional component that renders actions such as buttons in the
+     * collection toolbar, displayed on the right side
+     */
+    actions?: React.ReactNode;
+    /**
+     * View mode toggle button, positioned left of the search bar.
+     */
+    viewModeToggle?: React.ReactNode;
+    /**
+     * Controller holding the logic for the table
+     * {@link useDataTableController}
+     * {@link EntityTableController}
+     */
+    tableController: EntityTableController<M>;
+    displayedColumnIds?: PropertyColumnConfig[];
+    forceFilter?: FilterValues<Extract<keyof M, string>>;
+    inlineEditing?: boolean;
+    additionalFields?: AdditionalFieldDelegate<M, USER>[];
+    defaultSize?: CollectionSize;
+    properties: Properties;
+    getPropertyFor?: (props: GetPropertyForProps<M>) => Property | null;
+    filterable?: boolean;
+    sortable?: boolean;
+    endAdornment?: React.ReactNode;
+    AdditionalHeaderWidget?: React.ComponentType<{
+        property: Property;
+        propertyKey: string;
+        onHover: boolean;
+    }>;
+    AddColumnComponent?: React.ComponentType;
+    additionalIDHeaderWidget?: React.ReactNode;
+    emptyComponent?: React.ReactNode;
+    getIdColumnWidth?: () => number;
+    enablePopupIcon: boolean;
+    openEntityMode?: "side_panel" | "full_screen" | "split";
+    /**
+     * Callback when columns are reordered via drag-and-drop
+     */
+    onColumnsOrderChange?: (columns: VirtualTableColumn[]) => void;
+    /**
+     * If true, the internal toolbar will not be rendered.
+     * Used when the parent component renders its own toolbar.
+     */
+    hideToolbar?: boolean;
+};
+export type GetPropertyForProps<M extends Record<string, unknown>> = {
+    propertyKey: string;
+    entity: Entity<M>;
+};
+export type PropertyColumnConfig = {
+    key: string;
+    disabled?: boolean;
+};

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

@@ -0,0 +1,26 @@
+import type { Property } from "@rebasepro/types";
+import React from "react";
+import { Entity } from "@rebasepro/types";
+import { CustomFieldValidator } from "../../form/validation";
+export interface PropertyTableCellProps<T> {
+    propertyKey: string;
+    columnIndex: number;
+    align: "right" | "left" | "center";
+    customFieldValidator?: CustomFieldValidator;
+    value: T;
+    readonly: boolean;
+    property: Property;
+    height: number;
+    width: number;
+    entity: Entity<any>;
+    path: string;
+    disabled: boolean;
+    enablePopupIcon?: boolean;
+    sortableNodeRef?: (node: HTMLElement | null) => void;
+    sortableStyle?: React.CSSProperties;
+    sortableAttributes?: Record<string, any>;
+    isDragging?: boolean;
+    isDraggable?: boolean;
+    frozen?: boolean;
+}
+export declare const PropertyTableCell: React.FunctionComponent<PropertyTableCellProps<any>>;

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

@@ -0,0 +1,16 @@
+import type { Properties, Property } from "@rebasepro/types";
+import React from "react";
+import { FilterValues } from "@rebasepro/types";
+import { VirtualTableColumn } from "@rebasepro/ui";
+export declare function buildIdColumn(largeLayout?: boolean): VirtualTableColumn;
+export interface PropertiesToColumnsParams<M extends Record<string, unknown>> {
+    properties: Properties;
+    sortable?: boolean;
+    forceFilter?: FilterValues<keyof M extends string ? keyof M : never>;
+    AdditionalHeaderWidget?: React.ComponentType<{
+        property: Property;
+        propertyKey: string;
+        onHover: boolean;
+    }>;
+}
+export declare function propertiesToColumns<M extends Record<string, unknown>>({ properties, sortable, forceFilter, AdditionalHeaderWidget }: PropertiesToColumnsParams<M>): VirtualTableColumn[];

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

@@ -0,0 +1,21 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { CollectionSize, 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,22 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { CollectionSize, 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,22 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { CollectionSize, 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,35 @@
+import type { ArrayProperty, StringProperty } from "@rebasepro/types";
+import * as React from "react";
+import { Entity } from "@rebasepro/types";
+import { PreviewSize } from "../../../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 {
+    propertyKey: string;
+    property: StringProperty;
+    value: string;
+    size: PreviewSize;
+    entity: Entity<any>;
+}
+export declare function TableStorageItemPreview({ propertyKey, property, value, size, entity }: TableStorageItemPreviewProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,9 @@
+export declare function VirtualTableInput(props: {
+    error: Error | undefined;
+    value: string;
+    multiline: boolean;
+    focused: boolean;
+    disabled: boolean;
+    updateValue: (newValue: (string | null)) => void;
+    onBlur?: () => void;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,8 @@
+export declare function VirtualTableNumberInput(props: {
+    error: Error | undefined;
+    value: number;
+    align: "right" | "left" | "center";
+    updateValue: (newValue: (number | null)) => void;
+    focused: boolean;
+    disabled: boolean;
+}): import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1,7 @@
+export declare function VirtualTableSwitch(props: {
+    error: Error | undefined;
+    internalValue?: boolean;
+    focused: boolean;
+    disabled: boolean;
+    updateValue: (newValue: (boolean | null)) => void;
+}): import("react/jsx-runtime").JSX.Element;