@rebasepro/admin 0.8.0 → 0.9.0

package/dist/components/{EntityCollectionView/useEntityPreviewSlots.d.ts → CollectionViewBinding/usePreviewSlots.d.ts}

@@ -1,10 +1,10 @@
-import type { EntityCollection, Property, RelationProperty } from "@rebasepro/types";
+import type { CollectionConfig, Property, RelationProperty } from "@rebasepro/types";
 import type { Entity, PropertyConfig } from "@rebasepro/types";
 import type { AuthController } from "@rebasepro/types";
 import { ChipColorScheme } from "@rebasepro/ui";
 /**
  * A resolved "slot" containing the property definition, key, and the
- * concrete value extracted from an entity.
+ * concrete value extracted from a entity.
  */
 export interface PreviewSlot {
     property: Property;
@@ -84,7 +84,7 @@ export interface CollectionSlotKeys {
  * Resolve which property key fills each slot for a given collection.
  * Pure function — call inside `useMemo`.
  */
-export declare function resolveCollectionSlotKeys(collection: EntityCollection<Record<string, unknown>>, authController: AuthController, propertyConfigs: Record<string, PropertyConfig>): CollectionSlotKeys;
+export declare function resolveCollectionSlotKeys(collection: CollectionConfig<Record<string, unknown>>, authController: AuthController, propertyConfigs: Record<string, PropertyConfig>): CollectionSlotKeys;
 /**
  * Resolves which property key fills each preview slot for a collection.
  * Memoized — only recomputes when the collection definition changes.
@@ -92,10 +92,10 @@ export declare function resolveCollectionSlotKeys(collection: EntityCollection<R
  * Use this in the parent list/grid component, then pass the result to
  * `resolveEntitySlots` for each entity row.
  */
-export declare function useCollectionSlotKeys(collection: EntityCollection<Record<string, unknown>>, authController: AuthController, propertyConfigs: Record<string, PropertyConfig>): CollectionSlotKeys;
+export declare function useCollectionSlotKeys(collection: CollectionConfig<Record<string, unknown>>, authController: AuthController, propertyConfigs: Record<string, PropertyConfig>): CollectionSlotKeys;
 /**
  * Resolve concrete slot values for a single entity.
  * This is a pure function (no hooks) so it can be called inside
  * `React.memo` render functions or loops without violating hook rules.
  */
-export declare function resolveEntitySlots(entity: Entity<Record<string, unknown>>, collection: EntityCollection<Record<string, unknown>>, slotKeys: CollectionSlotKeys): EntityPreviewSlots;
+export declare function resolveEntitySlots(entity: Entity<Record<string, unknown>>, collection: CollectionConfig<Record<string, unknown>>, slotKeys: CollectionSlotKeys): EntityPreviewSlots;

package/dist/components/DeleteEntityDialog.d.ts

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

package/dist/components/{EntityDetailView.d.ts → DetailViewBinding.d.ts}

@@ -1,4 +1,4 @@
-import type { EntityCollection } from "@rebasepro/types";
+import type { CollectionConfig } from "@rebasepro/types";
 import React from "react";
 import { EntityStatus } from "@rebasepro/types";
 export type BarActionsParams = {
@@ -11,11 +11,11 @@ export type OnTabChangeParams<M extends Record<string, unknown>> = {
     path: string;
     entityId?: string | number;
     selectedTab?: string;
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
 };
-export interface EntityDetailViewProps<M extends Record<string, unknown> = Record<string, unknown>> {
+export interface DetailViewBindingProps<M extends Record<string, unknown> = Record<string, unknown>> {
     path: string;
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
     entityId: string | number;
     selectedTab?: string;
     parentCollectionSlugs: string[];
@@ -25,4 +25,4 @@ export interface EntityDetailViewProps<M extends Record<string, unknown> = Recor
     layout?: "side_panel" | "full_screen" | "split" | "dialog";
     barActions?: (params: BarActionsParams) => React.ReactNode;
 }
-export declare function EntityDetailView<M extends Record<string, unknown>>({ entityId, ...props }: EntityDetailViewProps<M>): React.JSX.Element;
+export declare function DetailViewBinding<M extends Record<string, unknown>>({ entityId, ...props }: DetailViewBindingProps<M>): React.JSX.Element;

package/dist/components/EditFormActions.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { EntityFormActionsProps } from "../types/components/EntityFormActionsProps";
+export declare function EditFormActions({ collection, path, entity, layout, savingError, formex, disabled, status, pluginActions, openEntityMode, showDefaultActions, navigateBack, formContext }: EntityFormActionsProps): React.JSX.Element;

package/dist/components/{EntityEditView.d.ts → EditViewBinding.d.ts}

@@ -1,9 +1,9 @@
-import type { EntityCollection } from "@rebasepro/types";
+import type { CollectionConfig } from "@rebasepro/types";
 import React from "react";
 import { Entity, EntityStatus } from "@rebasepro/types";
 import type { EntityFormBindingProps } from "../form";
 import type { OnUpdateParams } from "../types/components/EntityFormProps";
-import { MAIN_TAB_VALUE, JSON_TAB_VALUE, HISTORY_TAB_VALUE } from "../util/entity_view_constants";
+import { MAIN_TAB_VALUE, JSON_TAB_VALUE, HISTORY_TAB_VALUE } from "../util/view_constants";
 export { MAIN_TAB_VALUE, JSON_TAB_VALUE, HISTORY_TAB_VALUE };
 export type BarActionsParams = {
     values: object;
@@ -15,14 +15,14 @@ export type OnTabChangeParams<M extends Record<string, unknown>> = {
     path: string;
     entityId?: string | number;
     selectedTab?: string;
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
 };
-export interface EntityEditViewProps<M extends Record<string, unknown> = Record<string, unknown>> {
+export interface EditViewBindingProps<M extends Record<string, unknown> = Record<string, unknown>> {
     /**
      * The CMS path of the entity, e.g. "users" or "products".
      */
     path: string;
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
     entityId?: string | number;
     databaseId?: string;
     copy?: boolean;
@@ -39,16 +39,16 @@ export interface EntityEditViewProps<M extends Record<string, unknown> = Record<
     /**
      * Pre-populate the form with these values when creating a new entity.
      * Only applied when the form is in "new" mode (no entityId).
-     * Sourced from EntitySidePanelProps (side panel) or location.state (full screen).
+     * Sourced from SidePanelBindingProps (side panel) or location.state (full screen).
      */
     defaultValues?: Partial<M>;
 }
 /**
  * This is the default view that is used as the content of a side panel when
- * an entity is opened.
+ * a record is opened.
  */
-export declare function EntityEditView<M extends Record<string, unknown>>({ entityId, ...props }: EntityEditViewProps<M>): React.JSX.Element;
-export declare function EntityEditViewInner<M extends Record<string, unknown>>({ path, entityId, selectedTab: selectedTabProp, collection, parentCollectionSlugs, parentEntityIds, onValuesModified, onSaved, onTabChange, navigateBack, entity, initialDirtyValues, dataLoading, layout, barActions, status, setStatus, formProps, canEdit }: EntityEditViewProps<M> & {
+export declare function EditViewBinding<M extends Record<string, unknown>>({ entityId, ...props }: EditViewBindingProps<M>): React.JSX.Element;
+export declare function EditViewBindingInner<M extends Record<string, unknown>>({ path, entityId, selectedTab: selectedTabProp, collection, parentCollectionSlugs, parentEntityIds, onValuesModified, onSaved, onTabChange, navigateBack, entity, initialDirtyValues, dataLoading, layout, barActions, status, setStatus, formProps, canEdit }: EditViewBindingProps<M> & {
     entity?: Entity<M>;
     initialDirtyValues?: Partial<M>;
     dataLoading: boolean;

package/dist/components/{EntityPreview.d.ts → EntityPreviewBinding.d.ts}

@@ -1,11 +1,11 @@
-import type { EntityCollection } from "@rebasepro/types";
+import type { CollectionConfig } from "@rebasepro/types";
 import * as React from "react";
 import { Entity } from "@rebasepro/types";
 import type { PreviewSize } from "../types/components/PropertyPreviewProps";
-export type EntityPreviewProps = {
+export type EntityPreviewBindingProps = {
     size?: PreviewSize;
     actions?: React.ReactNode;
-    collection?: EntityCollection;
+    collection?: CollectionConfig;
     hover?: boolean;
     previewKeys?: string[];
     disabled?: boolean;
@@ -15,35 +15,35 @@ export type EntityPreviewProps = {
     includeEntityLink?: boolean;
     includeImage?: boolean;
     onClick?: (e: React.SyntheticEvent) => void;
-    onSideEntityClick?: (entity: Entity) => void;
+    onSidePanelClick?: (entity: Entity) => void;
 };
-export type EntityPreviewDataProps = {
+export type EntityPreviewBindingDataProps = {
     size?: "smallest" | "small" | "medium" | "large";
     actions?: React.ReactNode;
-    collection?: EntityCollection;
+    collection?: CollectionConfig;
     previewKeys?: string[];
     entity: Entity<any>;
-    onSideEntityClick?: (entity: Entity) => void;
+    onSidePanelClick?: (entity: Entity) => void;
     includeId?: boolean;
     includeTitle?: boolean;
     includeEntityLink?: boolean;
     includeImage?: boolean;
 };
 /**
- * This component contains the main logic and content for displaying an entity preview,
- * without any container wrapper. Used internally by EntityPreview.
+ * This component contains the main logic and content for displaying a entity preview,
+ * without any container wrapper. Used internally by EntityPreviewBinding.
  */
-export declare function EntityPreviewData({ actions, collection: collectionProp, previewKeys, size, includeId, onSideEntityClick, includeTitle, includeEntityLink, includeImage, entity }: EntityPreviewDataProps): React.JSX.Element;
-export declare function EntityPreviewWithId({ entityId, path, ...props }: Omit<EntityPreviewProps, "entity"> & {
+export declare function EntityPreviewBindingData({ actions, collection: collectionProp, previewKeys, size, includeId, onSidePanelClick, includeTitle, includeEntityLink, includeImage, entity }: EntityPreviewBindingDataProps): React.JSX.Element;
+export declare function EntityPreviewBindingWithId({ entityId, path, ...props }: Omit<EntityPreviewBindingProps, "entity"> & {
     entityId: string | number;
     path: string;
     databaseId?: string;
 }): React.JSX.Element;
 /**
- * This view is used to display a preview of an entity.
+ * This view is used to display a preview of a entity.
  * It is used by default in reference fields and whenever a reference is displayed.
  */
-export declare function EntityPreview({ actions, disabled, hover, collection, previewKeys, onClick, size, includeId, includeTitle, includeEntityLink, includeImage, onSideEntityClick, entity }: EntityPreviewProps): React.JSX.Element;
+export declare function EntityPreviewBinding({ actions, disabled, hover, collection, previewKeys, onClick, size, includeId, includeTitle, includeEntityLink, includeImage, onSidePanelClick, entity }: EntityPreviewBindingProps): React.JSX.Element;
 export type EntityPreviewContainerProps = {
     children: React.ReactNode;
     hover?: boolean;

package/dist/components/EntityViewBinding.d.ts

@@ -0,0 +1,13 @@
+import type { CollectionConfig } from "@rebasepro/types";
+import React from "react";
+import { Entity } from "@rebasepro/types";
+/**
+ * @group Components
+ */
+export interface EntityViewBindingProps<M extends Record<string, unknown>> {
+    entity: Entity<M>;
+    collection: CollectionConfig<M>;
+    path: string;
+    className?: string;
+}
+export declare function EntityViewBinding<M extends Record<string, unknown>>({ entity, collection, path, className }: EntityViewBindingProps<M>): React.JSX.Element;

package/dist/components/{EntityJsonPreview.d.ts → JsonPreviewBinding.d.ts}

@@ -1,4 +1,4 @@
 import React from "react";
-export declare function EntityJsonPreview({ values }: {
+export declare function JsonPreviewBinding({ values }: {
     values: object;
 }): React.JSX.Element;

package/dist/components/RebaseCMS.d.ts

@@ -7,4 +7,4 @@ import type { RebaseCMSConfig } from "@rebasepro/types";
  * is auto-wired as a native feature (slots, provider, Studio view) without
  * needing any external plugin.
  */
-export declare function RebaseCMS({ collections, views, homePage, entityViews, entityActions, collectionEditor, navigationGroupMappings }: RebaseCMSConfig): null;
+export declare function RebaseCMS({ collections, views, homePage, entityViews, entityActions, collectionEditor, navigationGroupMappings, basePath }: RebaseCMSConfig): null;

package/dist/components/RebaseNavigation.d.ts

@@ -16,7 +16,7 @@ export interface RebaseNavigationProps {
  * ```tsx
  * <RebaseNavigation>
  *   <MyCustomLayout>
- *     <EntityCollectionView ... />
+ *     <CollectionViewBinding ... />
  *   </MyCustomLayout>
  * </RebaseNavigation>
  * ```

package/dist/components/ReferenceTable/{EntitySelectionTable.d.ts → SelectionTableBinding.d.ts}

@@ -1,10 +1,10 @@
-import type { EntityCollection } from "@rebasepro/types";
+import type { CollectionConfig } from "@rebasepro/types";
 import React from "react";
 import { Entity, FilterValues } from "@rebasepro/types";
 /**
  * @group Components
  */
-export interface EntitySelectionProps<M extends Record<string, unknown>> {
+export interface SelectionProps<M extends Record<string, unknown>> {
     /**
      * Allow multiple selection of values
      */
@@ -12,7 +12,7 @@ export interface EntitySelectionProps<M extends Record<string, unknown>> {
     /**
      * Entity collection config
      */
-    collection?: EntityCollection<M>;
+    collection?: CollectionConfig<M>;
     /**
      * Absolute path of the collection.
      * May be not set if this hook is being used in a component and the path is
@@ -53,7 +53,7 @@ export interface EntitySelectionProps<M extends Record<string, unknown>> {
 }
 /**
  * This component allows to select entities from a given collection.
- * You probably want to open this dialog as a side view using {@link useEntitySelectionTable}
+ * You probably want to open this dialog as a side view using {@link useSelectionTableBinding}
  * @group Components
  */
-export declare function EntitySelectionTable<M extends Record<string, unknown>>(props: EntitySelectionProps<M>): React.JSX.Element;
+export declare function SelectionTableBinding<M extends Record<string, unknown>>(props: SelectionProps<M>): React.JSX.Element;

package/dist/components/SelectableTable/SelectableTable.d.ts

@@ -72,23 +72,23 @@ export type SelectableTableProps<M extends Record<string, unknown>> = {
  * 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
+ * This component is used internally by {@link CollectionViewBinding} 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
+ * If you want to bind a {@link CollectionConfig} to a table with the default
  * options you see in collections in the top level navigation, you can
- * check {@link EntityCollectionView}.
+ * check {@link CollectionViewBinding}.
  *
  * 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 CollectionTableBindingProps
+ * @see CollectionViewBinding
  * @see VirtualTable
  * @group Components
  */

package/dist/components/SelectableTable/SelectableTableContext.d.ts

@@ -1,4 +1,4 @@
 import React from "react";
-import { EntityCollectionTableController } from "@rebasepro/core";
-export declare const SelectableTableContext: React.Context<EntityCollectionTableController<Record<string, unknown>>>;
-export declare const useSelectableTableController: <M extends Record<string, unknown> = Record<string, unknown>>() => EntityCollectionTableController<M>;
+import { DataCollectionTableController } from "@rebasepro/core";
+export declare const SelectableTableContext: React.Context<DataCollectionTableController<Record<string, unknown>>>;
+export declare const useSelectableTableController: <M extends Record<string, unknown> = Record<string, unknown>>() => DataCollectionTableController<M>;

package/dist/components/SelectableTable/SelectionStore.d.ts

@@ -9,12 +9,12 @@ export interface AdminSelectedCell extends SelectedCell {
     height: number;
 }
 export declare function createSelectionStore(): {
-    getSnapshot: () => AdminSelectedCell | undefined;
+    getEntity: () => AdminSelectedCell | undefined;
     subscribe: (listener: () => void) => () => void;
     select: (cell: AdminSelectedCell | undefined) => void;
 };
 export type SelectionStore = VirtualTableSelectionStore<AdminSelectedCell>;
 export declare function useCellSelected(store: {
-    getSnapshot: () => SelectedCellProps | undefined;
+    getEntity: () => SelectedCellProps | undefined;
     subscribe: (listener: () => void) => () => void;
 }, propertyKey: string, entityPath: string, entityId: string | number): boolean;

package/dist/components/SelectableTable/filters/BooleanFilterField.d.ts

@@ -5,6 +5,11 @@ interface BooleanFieldProps {
     value?: [op: VirtualTableWhereFilterOp, fieldValue: unknown];
     setValue: (value?: [op: VirtualTableWhereFilterOp, newValue: unknown]) => void;
     title?: string;
+    /**
+     * Restrict the offered operators. This field only ever emits `["==", …]`,
+     * so it renders nothing when `==` is not allowed.
+     */
+    operators?: readonly VirtualTableWhereFilterOp[];
 }
-export declare function BooleanFilterField({ name, title, value, setValue }: BooleanFieldProps): React.JSX.Element;
+export declare function BooleanFilterField({ name, title, value, setValue, operators }: BooleanFieldProps): React.JSX.Element | null;
 export {};

package/dist/components/SelectableTable/filters/DateTimeFilterField.d.ts

@@ -8,6 +8,12 @@ interface DateTimeFilterFieldProps {
     isArray?: boolean;
     title?: string;
     timezone?: string;
+    /**
+     * Restrict the offered operators (already resolved against engine
+     * capabilities and property config). When omitted, all operators this
+     * field can render are offered.
+     */
+    operators?: readonly VirtualTableWhereFilterOp[];
 }
-export declare function DateTimeFilterField({ name, isArray, mode, value, setValue, title, timezone }: DateTimeFilterFieldProps): React.JSX.Element;
+export declare function DateTimeFilterField({ name, isArray, mode, value, setValue, title, timezone, operators }: DateTimeFilterFieldProps): React.JSX.Element | null;
 export {};

package/dist/components/SelectableTable/filters/FilterFieldBinding.d.ts

@@ -0,0 +1,40 @@
+import React from "react";
+import { Property, WhereFilterOp } from "@rebasepro/types";
+export interface FilterFieldBindingInput {
+    /** Key of the property being filtered (the column id). */
+    propertyKey: string;
+    /** The raw property — array properties are unwrapped internally. */
+    property: Property;
+    /**
+     * Engine backing the collection (`collection.engine`). Drives which
+     * operators the engine can execute. Usually omitted — it is read from
+     * the surrounding {@link CollectionScopeProvider}; pass it explicitly
+     * only when rendering outside any collection scope.
+     */
+    engine?: string;
+    value?: [WhereFilterOp, unknown];
+    setValue: (value?: [WhereFilterOp, unknown]) => void;
+    /** Coordination flags for fields that open their own dialogs. */
+    hidden?: boolean;
+    setHidden?: (hidden: boolean) => void;
+}
+/**
+ * The single entry point for rendering a collection filter field.
+ * Used by both the table header filters ({@link SelectableTable}) and the
+ * Filters dialog.
+ *
+ * Resolution order:
+ * 1. `property.ui.Filter` — per-property replacement (rendered even when the
+ *    resolved operator list is empty; the component owns filterability).
+ * 2. `components["Collection.FilterField"]` — collection-level or app-level
+ *    override (wrap mode supported via `OriginalComponent`).
+ * 3. Built-in field dispatched by property type.
+ *
+ * The operators handed to the field are the intersection of the engine's
+ * capabilities, the property-type defaults, and `property.ui.filterOperators`
+ * (see `resolveFilterOperators`). When that intersection is empty and no
+ * per-property `Filter` is set, nothing is rendered.
+ *
+ * @group Components
+ */
+export declare function FilterFieldBinding({ propertyKey, property, engine, value, setValue, hidden, setHidden }: FilterFieldBindingInput): React.ReactNode;

package/dist/components/SelectableTable/filters/ReferenceFilterField.d.ts

@@ -11,6 +11,12 @@ interface ReferenceFilterFieldProps {
     previewProperties?: string[];
     hidden: boolean;
     setHidden: (hidden: boolean) => void;
+    /**
+     * Restrict the offered operators (already resolved against engine
+     * capabilities and property config). When omitted, all operators this
+     * field can render are offered.
+     */
+    operators?: readonly VirtualTableWhereFilterOp[];
 }
-export declare function ReferenceFilterField({ value, setValue, isArray, path, includeId, previewProperties, setHidden }: ReferenceFilterFieldProps): React.JSX.Element;
+export declare function ReferenceFilterField({ value, setValue, isArray, path, includeId, previewProperties, setHidden, operators }: ReferenceFilterFieldProps): React.JSX.Element | null;
 export {};

package/dist/components/SelectableTable/filters/RelationFilterField.d.ts

@@ -8,6 +8,12 @@ interface RelationFilterFieldProps {
     relation: Relation;
     hidden: boolean;
     setHidden: (value: boolean) => void;
+    /**
+     * Restrict the offered operators (already resolved against engine
+     * capabilities and property config). When omitted, all operators this
+     * field can render are offered.
+     */
+    operators?: readonly VirtualTableWhereFilterOp[];
 }
-export declare function RelationFilterField({ value, setValue, relation, name: _name, hidden: _hidden, setHidden: _setHidden }: RelationFilterFieldProps): React.JSX.Element;
+export declare function RelationFilterField({ value, setValue, relation, name: _name, hidden: _hidden, setHidden: _setHidden, operators }: RelationFilterFieldProps): React.JSX.Element | null;
 export {};

package/dist/components/SelectableTable/filters/StringNumberFilterField.d.ts

@@ -9,6 +9,12 @@ interface StringNumberFilterFieldProps {
     isArray?: boolean;
     enumValues?: EnumValueConfig[];
     title?: string;
+    /**
+     * Restrict the offered operators (already resolved against engine
+     * capabilities and property config). When omitted, all operators this
+     * field can render are offered.
+     */
+    operators?: readonly VirtualTableWhereFilterOp[];
 }
-export declare function StringNumberFilterField({ name, value, setValue, type, isArray, enumValues, title }: StringNumberFilterFieldProps): React.JSX.Element;
+export declare function StringNumberFilterField({ name, value, setValue, type, isArray, enumValues, title, operators }: StringNumberFilterFieldProps): React.JSX.Element | null;
 export {};

package/dist/components/SideDialogs.d.ts

@@ -16,7 +16,7 @@ export type SideDialogController = {
 export declare const useSideDialogContext: () => SideDialogController;
 /**
  * This is the component in charge of rendering the side dialogs used
- * for editing entities. Use the {@link useSideEntityController} to open
+ * for editing entities. Use the {@link useSidePanel} to open
  * and control the dialogs.
  * This component needs a parent {@link Rebase}
  * {@link useSideDialogsController}

package/dist/components/SidePanelBinding.d.ts

@@ -0,0 +1,11 @@
+import type { SidePanelBindingProps } from "@rebasepro/types";
+import React from "react";
+/**
+ * This is the component in charge of rendering the side dialog used
+ * for editing entities. Use the {@link useSidePanel} to open
+ * and control the dialogs.
+ * This component needs a parent {@link Rebase}
+ * {@link useSidePanel}
+ * @group Components
+ */
+export declare function SidePanelBinding(props: SidePanelBindingProps): React.JSX.Element;

package/dist/components/{SideEntityProvider.d.ts → SidePanelProvider.d.ts}

@@ -1,12 +1,12 @@
 import React from "react";
 /**
- * Provider that builds the SideEntityController and makes it available
- * via the SideEntityControllerContext from @rebasepro/core.
+ * Provider that builds the SidePanelController and makes it available
+ * via the SidePanelControllerContext from @rebasepro/core.
  *
- * After the CMS extraction refactor, `useBuildSideEntityController` lives
+ * After the CMS extraction refactor, `useBuildSidePanel` lives
  * in the CMS package while the context it feeds into lives in core.
  * This provider bridges the two: place it inside the `<Rebase>` tree and
- * above any component that calls `useSideEntityController()`.
+ * above any component that calls `useSidePanel()`.
  *
  * Also auto-registers the side entity controller and breadcrumbs into the
  * self-assembling Studio bridge (when a StudioBridgeRegistryProvider is
@@ -16,17 +16,17 @@ import React from "react";
  * ```tsx
  * <Rebase ...>
  *   {({ loading }) => (
- *     <SideEntityProvider>
+ *     <SidePanelProvider>
  *       <RebaseRoutes>
  *         ...
  *       </RebaseRoutes>
- *     </SideEntityProvider>
+ *     </SidePanelProvider>
  *   )}
  * </Rebase>
  * ```
  *
  * @group Components
  */
-export declare function SideEntityProvider({ children }: {
+export declare function SidePanelProvider({ children }: {
     children: React.ReactNode;
 }): React.JSX.Element;

package/dist/components/history/EntityHistoryEntry.d.ts

@@ -1,11 +1,11 @@
-import type { EntityCollection } from "@rebasepro/types";
+import type { CollectionConfig } from "@rebasepro/types";
 import * as React from "react";
 import { PreviewSize } from "../../types/components/PropertyPreviewProps";
 import { HistoryEntryData } from "../../hooks";
 export type EntityHistoryEntryProps = {
     size: PreviewSize;
     actions?: React.ReactNode;
-    collection?: EntityCollection;
+    collection?: CollectionConfig;
     hover?: boolean;
     entry: HistoryEntryData;
     onClick?: (e: React.SyntheticEvent) => void;

package/dist/components/history/LastEditedByIndicator.d.ts

@@ -1,4 +1,4 @@
-import type { EntityCollection } from "@rebasepro/types";
+import type { CollectionConfig } from "@rebasepro/types";
 import React from "react";
 /**
  * Fetches the latest history entry from the backend API and displays
@@ -7,5 +7,5 @@ import React from "react";
 export declare function LastEditedByIndicator({ path, entityId, collection }: {
     path: string;
     entityId: string;
-    collection: EntityCollection;
+    collection: CollectionConfig;
 }): React.JSX.Element | null;

package/dist/components/index.d.ts

@@ -1,26 +1,27 @@
-export type { EntityViewProps } from "./EntityView";
-export { EntityView } from "./EntityView";
-export * from "./EntityDetailView";
-export type { EntitySelectionProps } from "./ReferenceTable/EntitySelectionTable";
-export { EntitySelectionTable } from "./ReferenceTable/EntitySelectionTable";
+export type { EntityViewBindingProps } from "./EntityViewBinding";
+export { EntityViewBinding } from "./EntityViewBinding";
+export * from "./DetailViewBinding";
+export type { SelectionProps } from "./ReferenceTable/SelectionTableBinding";
+export { SelectionTableBinding } from "./ReferenceTable/SelectionTableBinding";
 export * from "./SelectableTable/SelectableTable";
 export * from "./SelectableTable/SelectableTableContext";
-export * from "./EntityCollectionView/EntityCollectionView";
-export * from "./EntityCollectionView/EntityCollectionViewActions";
-export * from "./EntityCollectionView/EntityCollectionCardView";
-export * from "./EntityCollectionView/EntityCard";
-export * from "./EntityCollectionView/useSelectionController";
+export * from "./SelectableTable/filters/FilterFieldBinding";
+export * from "./CollectionViewBinding/CollectionViewBinding";
+export * from "./CollectionViewBinding/CollectionViewActions";
+export * from "./CollectionViewBinding/CollectionCardViewBinding";
+export * from "./CollectionViewBinding/EntityCardBinding";
+export * from "./CollectionViewBinding/useSelectionController";
 export * from "./PropertyConfigBadge";
 export * from "./PropertyIdCopyTooltip";
-export * from "./EntityCollectionTable";
+export * from "./CollectionTableBinding";
 export * from "./ArrayContainer";
 export * from "./ReferenceWidget";
 export * from "./SearchIconsView";
 export * from "./FieldCaption";
-export * from "./EntityPreview";
+export * from "./EntityPreviewBinding";
 export * from "./common";
 export * from "./field_configs";
-export * from "./SideEntityProvider";
+export * from "./SidePanelProvider";
 export * from "./AdminModeSyncer";
 export * from "./app/AppBar";
 export * from "./app/Drawer";

package/dist/contexts/SidePanelControllerContext.d.ts

@@ -0,0 +1,3 @@
+import type { SidePanelController } from "@rebasepro/types";
+import React from "react";
+export declare const SidePanelControllerContext: React.Context<SidePanelController>;

package/dist/data_export/export/ExportCollectionAction.d.ts

@@ -1,10 +1,10 @@
 import React from "react";
-import { CollectionActionsProps, EntityCollection, User } from "@rebasepro/types";
-export declare function ExportCollectionAction<M extends Record<string, unknown>, USER extends User>({ collection, path, collectionEntitiesCount, onAnalyticsEvent, exportAllowed, notAllowedView }: CollectionActionsProps<M, USER, EntityCollection<M>> & {
+import { CollectionActionsProps, CollectionConfig, User } from "@rebasepro/types";
+export declare function ExportCollectionAction<M extends Record<string, unknown>, USER extends User>({ collection, path, collectionEntitiesCount, onAnalyticsEvent, exportAllowed, notAllowedView }: CollectionActionsProps<M, USER, CollectionConfig<M>> & {
     exportAllowed?: (props: {
         collectionEntitiesCount: number;
         path: string;
-        collection: EntityCollection;
+        collection: CollectionConfig;
     }) => boolean;
     notAllowedView?: React.ReactNode;
     onAnalyticsEvent?: (event: string, params?: any) => void;

package/dist/data_import/components/ImportSaveInProgress.d.ts

@@ -1,6 +1,6 @@
-import { EntityCollection } from "@rebasepro/types";
+import { CollectionConfig } from "@rebasepro/types";
 import { ImportConfig } from "../types";
-export declare function ImportSaveInProgress<C extends EntityCollection<any>>({ path, importConfig, collection, onImportSuccess }: {
+export declare function ImportSaveInProgress<C extends CollectionConfig<any>>({ path, importConfig, collection, onImportSuccess }: {
     path: string;
     importConfig: ImportConfig;
     collection: C;

package/dist/form/EntityForm.d.ts

@@ -3,7 +3,7 @@ import type { EntityFormProps } from "../types/components/EntityFormProps";
 /**
  * Headless entity form component.
  *
- * Renders a form for an entity collection without any CMS or backend dependencies.
+ * Renders a form for a entity collection without any CMS or backend dependencies.
  * All backend concerns (save, caching, analytics, plugin slots) are provided via
  * callback props. For CMS-connected usage, use {@link EntityFormBinding} instead.
  *

package/dist/form/PropertyFieldBinding.d.ts

@@ -12,7 +12,7 @@ import { ReactElement } from "react";
  *
  * Please note that if you build a custom field in a component, the
  * **validation** passed in the property will have no effect. You need to set
- * the validation in the `EntityCollection` definition.
+ * the validation in the `CollectionConfig` definition.
  *
  * @param propertyKey You can use nested names such as `address.street` or `friends[2]`
  * @param property