@rebasepro/admin 0.8.0 → 0.9.1-canary.09aaf62

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

@@ -1,4 +1,4 @@
-import type { EntityCollection } from "@rebasepro/types";
+import type { CollectionConfig } from "@rebasepro/types";
 import { Entity, FilterValues } from "@rebasepro/types";
 /**
  * Data state for a single board column
@@ -40,7 +40,7 @@ export interface UseBoardDataControllerProps<M extends Record<string, unknown> =
     /** Full path to the collection */
     fullPath: string;
     /** The entity collection configuration */
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
     /** Property key used for column assignment */
     columnProperty: string;
     /** Array of column values (enum values from columnProperty) */

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 → RebaseAdmin.d.ts}

@@ -1,4 +1,4 @@
-import type { RebaseCMSConfig } from "@rebasepro/types";
+import type { RebaseAdminConfig } from "@rebasepro/types";
 /**
  * Declarative component to configure the CMS in Rebase.
  * Renders nothing — purely registers config into the RebaseRegistry.
@@ -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 RebaseAdmin({ collections, views, homePage, entityViews, entityActions, collectionEditor, navigationGroupMappings, basePath }: RebaseAdminConfig): null;

package/dist/components/RebaseLayout.d.ts

@@ -3,7 +3,7 @@ import type { AppView } from "@rebasepro/types";
 export interface RebaseLayoutProps {
     /** Title shown in the drawer. */
     title?: string;
-    /** Custom AppBar to override the default. */
+    /** Top bar. Only rendered if provided — pass `<AppBar/>` for the default one. */
     appBar?: React.ReactNode;
     /** Custom Drawer to override the default. */
     drawer?: React.ReactNode;
@@ -13,17 +13,18 @@ export interface RebaseLayoutProps {
     devViews?: AppView[];
 }
 /**
- * Layout layer — provides the Scaffold, AppBar, Drawer, and SideDialogs.
+ * Layout layer — provides the Scaffold, Drawer, and SideDialogs.
  *
  * Wraps the route outlet with the standard Rebase admin layout.
- * Override individual pieces (appBar, drawer) via props.
+ * Override the drawer via props; pass `appBar` to add a top bar (there is
+ * none by default — the drawer owns navigation and user actions).
  *
  * **Independently usable**: Use this when you want the Rebase layout
  * without its default route definitions.
  *
  * @example
  * ```tsx
- * <RebaseLayout title="My Admin">
+ * <RebaseLayout title="My Admin" appBar={<AppBar/>}>
  *   <Route path="/" element={<MyHomePage />} />
  *   <Route path="/custom" element={<CustomView />} />
  * </RebaseLayout>

package/dist/components/RebaseNavigation.d.ts

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

package/dist/components/RebaseShell.d.ts

@@ -1,6 +1,7 @@
 import React from "react";
 export interface RebaseShellProps {
     title?: string;
+    /** Top bar. Only rendered if provided — pass `<AppBar/>` for the default one. */
     appBar?: React.ReactNode;
     drawer?: React.ReactNode;
     autoOpenDrawer?: boolean;

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

@@ -1,7 +1,7 @@
 import React from "react";
 import { CollectionSize, Entity, EntityTableController, FilterValues } from "@rebasepro/types";
 import { CellRendererParams, VirtualTableColumn } from "@rebasepro/ui";
-import { OnCellValueChange, OnColumnResizeParams } from "@rebasepro/core";
+import { OnCellValueChange, OnColumnResizeParams } from "@rebasepro/app";
 export type SelectableTableProps<M extends Record<string, unknown>> = {
     /**
      * Callback when a cell value changes.
@@ -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/app";
+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/app.
  *
- * 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;