@rebasepro/plugin-data-enhancement 0.2.1 → 0.2.3

package/dist/admin/src/components/EntityCollectionView/useBoardDataController.d.ts

@@ -0,0 +1,61 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { Entity, FilterValues } from "@rebasepro/types";
+/**
+ * Data state for a single board column
+ */
+export interface BoardColumnData<M extends Record<string, unknown> = Record<string, unknown>> {
+    /** Entities loaded for this column */
+    entities: Entity<M>[];
+    /** Whether the column is currently loading data */
+    loading: boolean;
+    /** Whether there are more items to load */
+    hasMore: boolean;
+    /** Error if loading failed */
+    error?: Error;
+    /** Total count of entities in this column */
+    totalCount?: number;
+}
+/**
+ * Controller for managing per-column data in a Kanban board
+ */
+export interface BoardDataController<M extends Record<string, unknown> = any, COLUMN extends string = string> {
+    /** Data state for each column */
+    columnData: Record<COLUMN, BoardColumnData<M>>;
+    /** Load more items for a specific column */
+    loadMoreColumn: (column: COLUMN) => void;
+    /** Refresh data for a specific column */
+    refreshColumn: (column: COLUMN) => void;
+    /** Refresh all columns */
+    refreshAll: () => void;
+    /** Update column counts and optionally move item optimistically */
+    moveItemOptimistically: (itemId: string, sourceColumn: COLUMN, targetColumn: COLUMN, newValues?: Record<string, any>, newIndex?: number) => void;
+    /** Decrement column counts (for optimistic updates when deleting items) */
+    decrementColumnCounts: (columnDeltas: Record<COLUMN, number>) => void;
+    /** Whether any column is loading */
+    loading: boolean;
+    /** Any error from any column */
+    error?: Error;
+}
+export interface UseBoardDataControllerProps<M extends Record<string, unknown> = Record<string, unknown>> {
+    /** Full path to the collection */
+    fullPath: string;
+    /** The entity collection configuration */
+    collection: EntityCollection<M>;
+    /** Property key used for column assignment */
+    columnProperty: string;
+    /** Array of column values (enum values from columnProperty) */
+    columns: string[];
+    /** Property key used for ordering within columns */
+    orderProperty?: string;
+    /** Number of items to load per page per column */
+    pageSize?: number;
+    /** Text search string to filter entities */
+    searchString?: string;
+    /** Additional filter values */
+    filterValues?: FilterValues<string>;
+}
+/**
+ * Hook that manages per-column data loading for the Kanban board.
+ * Each column gets its own independent query to the data source.
+ */
+export declare function useBoardDataController<M extends Record<string, unknown> = any, COLUMN extends string = string>({ fullPath, collection, columnProperty, columns, orderProperty, pageSize, searchString, filterValues }: UseBoardDataControllerProps<M>): BoardDataController<M, COLUMN>;

package/dist/admin/src/components/EntityCollectionView/useEntityPreviewSlots.d.ts

@@ -0,0 +1,101 @@
+import type { EntityCollection, 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.
+ */
+export interface PreviewSlot {
+    property: Property;
+    propertyKey: string;
+    value: unknown;
+}
+/**
+ * Date slot extends the base with a pre-formatted string.
+ */
+export interface DatePreviewSlot extends PreviewSlot {
+    formatted: string;
+}
+/**
+ * A single resolved relation chip — one item to render as a compact chip.
+ * For cardinality:"one" relations there will be one chip.
+ * For cardinality:"many" there can be several (capped for layout stability).
+ */
+export interface RelationChipItem {
+    /** Human-readable display text for the chip */
+    displayName: string;
+    /** Relation ID */
+    id: string | number;
+}
+/**
+ * A resolved relation slot — groups all chips for one relation property.
+ */
+export interface RelationChipSlot {
+    /** The relation property definition */
+    property: RelationProperty;
+    /** The property key on this entity (e.g. "author", "tags") */
+    propertyKey: string;
+    /** The relation property's user-facing name (e.g. "Author", "Tags") */
+    label: string;
+    /** Resolved chip items (display names extracted from eagerly-loaded data) */
+    items: RelationChipItem[];
+    /** Total count (for "many" relations that exceed the chip cap) */
+    totalCount: number;
+    /** Deterministic color for this relation property */
+    colorScheme: ChipColorScheme;
+}
+/**
+ * Fixed set of preview slots resolved from any entity + collection.
+ *
+ * Every view (list, card, board) consumes these same slots and decides
+ * which ones to render and how.  This eliminates duplicated inference
+ * logic across view components.
+ */
+export interface EntityPreviewSlots {
+    /** MEDIA — image thumbnail or `undefined` (view falls back to icon) */
+    image: PreviewSlot | undefined;
+    /** PRIMARY — title / name field */
+    title: PreviewSlot | undefined;
+    /** SECONDARY — subtitle or short description (first non-title text field) */
+    subtitle: PreviewSlot | undefined;
+    /** RELATIONS — compact chips for all relation properties (one + many) */
+    relations: RelationChipSlot[];
+    /** STATUS — enum chip (first enum field that isn't the title) */
+    status: PreviewSlot | undefined;
+    /** META — date / timestamp */
+    date: DatePreviewSlot | undefined;
+    /** Entity ID (always available) */
+    entityId: string | number;
+}
+/**
+ * Resolved property keys per slot.  This is the expensive part (walks
+ * all properties) so we memoize it at the collection level, not per entity.
+ */
+export interface CollectionSlotKeys {
+    titleKey: string | undefined;
+    imageKey: string | undefined;
+    subtitleKey: string | undefined;
+    relationKeys: string[];
+    statusKey: string | undefined;
+    dateKey: string | undefined;
+}
+/**
+ * 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;
+/**
+ * Resolves which property key fills each preview slot for a collection.
+ * Memoized — only recomputes when the collection definition changes.
+ *
+ * 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;
+/**
+ * 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;

package/dist/admin/src/components/EntityCollectionView/useSelectionController.d.ts

@@ -0,0 +1,2 @@
+import { Entity, SelectionController } from "@rebasepro/types";
+export declare function useSelectionController<M extends Record<string, unknown> = Record<string, unknown>>(onSelectionChange?: (entity: Entity<M>, selected: boolean) => void): SelectionController<M>;

package/dist/admin/src/components/EntityCollectionView/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function addRecentId(collectionId: string, id: string | number): (string | number)[];
+export declare function saveSearchedIdsLocally(collectionId: string, ids: (string | number)[]): void;
+export declare function getRecentIds(collectionId: string): (string | number)[];

package/dist/admin/src/components/EntityDetailView.d.ts

@@ -0,0 +1,31 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { EntityStatus } from "@rebasepro/types";
+export declare const MAIN_TAB_VALUE = "__main_##Q$SC^#S6";
+export declare const JSON_TAB_VALUE = "__json";
+export declare const HISTORY_TAB_VALUE = "__rebase_history";
+export type BarActionsParams = {
+    values: object;
+    status: EntityStatus;
+    path: string;
+    entityId?: string | number;
+};
+export type OnTabChangeParams<M extends Record<string, unknown>> = {
+    path: string;
+    entityId?: string | number;
+    selectedTab?: string;
+    collection: EntityCollection<M>;
+};
+export interface EntityDetailViewProps<M extends Record<string, unknown> = Record<string, unknown>> {
+    path: string;
+    collection: EntityCollection<M>;
+    entityId: string | number;
+    selectedTab?: string;
+    parentCollectionSlugs: string[];
+    parentEntityIds: string[];
+    onTabChange?: (props: OnTabChangeParams<M>) => void;
+    onEditClick?: () => void;
+    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>): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/EntityEditView.d.ts

@@ -0,0 +1,57 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { Entity, EntityStatus } from "@rebasepro/types";
+import type { EntityFormProps, OnUpdateParams } from "../types/components/EntityFormProps";
+export declare const MAIN_TAB_VALUE = "__main_##Q$SC^#S6";
+export declare const JSON_TAB_VALUE = "__json";
+export declare const HISTORY_TAB_VALUE = "__rebase_history";
+export type BarActionsParams = {
+    values: object;
+    status: EntityStatus;
+    path: string;
+    entityId?: string | number;
+};
+export type OnTabChangeParams<M extends Record<string, unknown>> = {
+    path: string;
+    entityId?: string | number;
+    selectedTab?: string;
+    collection: EntityCollection<M>;
+};
+export interface EntityEditViewProps<M extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * The CMS path of the entity, e.g. "users" or "products".
+     */
+    path: string;
+    collection: EntityCollection<M>;
+    entityId?: string | number;
+    databaseId?: string;
+    copy?: boolean;
+    selectedTab?: string;
+    parentCollectionSlugs: string[];
+    parentEntityIds: string[];
+    onValuesModified?: (modified: boolean, values: M) => void;
+    onSaved?: (params: OnUpdateParams) => void;
+    onTabChange?: (props: OnTabChangeParams<M>) => void;
+    navigateBack?: () => void;
+    layout?: "side_panel" | "full_screen" | "split" | "dialog";
+    barActions?: (params: BarActionsParams) => any;
+    formProps?: Partial<EntityFormProps<M>>;
+    /**
+     * 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).
+     */
+    defaultValues?: Partial<M>;
+}
+/**
+ * This is the default view that is used as the content of a side panel when
+ * an entity is opened.
+ */
+export declare function EntityEditView<M extends Record<string, unknown>>({ entityId, ...props }: EntityEditViewProps<M>): import("react/jsx-runtime").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> & {
+    entity?: Entity<M>;
+    initialDirtyValues?: Partial<M>;
+    dataLoading: boolean;
+    status: EntityStatus;
+    setStatus: (status: EntityStatus) => void;
+    canEdit?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/EntityEditViewFormActions.d.ts

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

package/dist/admin/src/components/EntityJsonPreview.d.ts

@@ -0,0 +1,3 @@
+export declare function EntityJsonPreview({ values }: {
+    values: object;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/EntityPreview.d.ts

@@ -0,0 +1,56 @@
+import type { EntityCollection } from "@rebasepro/types";
+import * as React from "react";
+import { Entity } from "@rebasepro/types";
+import type { PreviewSize } from "../types/components/PropertyPreviewProps";
+export type EntityPreviewProps = {
+    size?: PreviewSize;
+    actions?: React.ReactNode;
+    collection?: EntityCollection;
+    hover?: boolean;
+    previewKeys?: string[];
+    disabled?: boolean;
+    entity: Entity<any>;
+    includeId?: boolean;
+    includeTitle?: boolean;
+    includeEntityLink?: boolean;
+    includeImage?: boolean;
+    onClick?: (e: React.SyntheticEvent) => void;
+    onSideEntityClick?: (entity: Entity) => void;
+};
+export type EntityPreviewDataProps = {
+    size?: "smallest" | "small" | "medium" | "large";
+    actions?: React.ReactNode;
+    collection?: EntityCollection;
+    previewKeys?: string[];
+    entity: Entity<any>;
+    onSideEntityClick?: (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.
+ */
+export declare function EntityPreviewData({ actions, collection: collectionProp, previewKeys, size, includeId, onSideEntityClick, includeTitle, includeEntityLink, includeImage, entity }: EntityPreviewDataProps): import("react/jsx-runtime").JSX.Element;
+export declare function EntityPreviewWithId({ entityId, path, ...props }: Omit<EntityPreviewProps, "entity"> & {
+    entityId: string | number;
+    path: string;
+    databaseId?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * This view is used to display a preview of an 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): import("react/jsx-runtime").JSX.Element;
+export type EntityPreviewContainerProps = {
+    children: React.ReactNode;
+    hover?: boolean;
+    fullwidth?: boolean;
+    size?: PreviewSize;
+    className?: string;
+    style?: React.CSSProperties;
+    onClick?: (e: React.SyntheticEvent) => void;
+};
+export declare const EntityPreviewContainer: React.ForwardRefExoticComponent<EntityPreviewContainerProps & React.RefAttributes<HTMLDivElement>>;

package/dist/admin/src/components/EntitySidePanel.d.ts

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

package/dist/admin/src/components/EntityView.d.ts

@@ -0,0 +1,12 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { Entity } from "@rebasepro/types";
+/**
+ * @group Components
+ */
+export interface EntityViewProps<M extends Record<string, unknown>> {
+    entity: Entity<M>;
+    collection: EntityCollection<M>;
+    path: string;
+    className?: string;
+}
+export declare function EntityView<M extends Record<string, unknown>>({ entity, collection, path, className }: EntityViewProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/FieldCaption.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export declare function FieldCaption({ error, children }: {
+    error?: boolean;
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/admin/src/components/HomePage/ContentHomePage.d.ts

@@ -0,0 +1,11 @@
+import type { HomePageSection } from "@rebasepro/types";
+import React from "react";
+export declare const DEFAULT_GROUP_NAME = "Views";
+export declare const ADMIN_GROUP_NAME = "Admin";
+export declare function ContentHomePage({ additionalActions, additionalChildrenStart, additionalChildrenEnd, sections, hiddenGroups }: {
+    additionalActions?: React.ReactNode;
+    additionalChildrenStart?: React.ReactNode;
+    additionalChildrenEnd?: React.ReactNode;
+    sections?: HomePageSection[];
+    hiddenGroups?: string[];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/HomePage/FavouritesView.d.ts

@@ -0,0 +1,3 @@
+export declare function FavouritesView({ hidden }: {
+    hidden: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/admin/src/components/HomePage/HomePageDnD.d.ts

@@ -0,0 +1,77 @@
+import type { NavigationEntry } from "@rebasepro/types";
+import React from "react";
+import { Active, CollisionDetection, DropAnimation, UniqueIdentifier } from "@dnd-kit/core";
+export declare function SortableNavigationCard({ entry, onClick }: {
+    entry: NavigationEntry;
+    onClick?: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function NavigationGroupDroppable({ id, itemIds, children, isPotentialCardDropTarget }: {
+    id: UniqueIdentifier;
+    itemIds: UniqueIdentifier[];
+    children: React.ReactNode;
+    isPotentialCardDropTarget?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SortableNavigationGroup({ groupName, children, disabled }: {
+    groupName: string;
+    children: React.ReactNode;
+    disabled?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useHomePageDnd({ items, setItems, disabled, onCardMovedBetweenGroups, onGroupMoved, onNewGroupDrop, onPersist }: {
+    items: {
+        name: string;
+        entries: NavigationEntry[];
+    }[];
+    setItems: (newItemsOrUpdater: {
+        name: string;
+        entries: NavigationEntry[];
+    }[] | ((currentItems: {
+        name: string;
+        entries: NavigationEntry[];
+    }[]) => {
+        name: string;
+        entries: NavigationEntry[];
+    }[])) => void;
+    disabled: boolean;
+    onCardMovedBetweenGroups?: (card: NavigationEntry) => void;
+    onGroupMoved?: (groupName: string, oldIndex: number, newIndex: number) => void;
+    onNewGroupDrop?: () => void;
+    onPersist?: (latest: {
+        name: string;
+        entries: NavigationEntry[];
+    }[]) => void;
+}): {
+    sensors: import("@dnd-kit/core").SensorDescriptor<import("@dnd-kit/core").SensorOptions>[];
+    collisionDetection: CollisionDetection;
+    onDragStart: ({ active }: {
+        active: Active;
+    }) => void;
+    onDragOver: ({ active, over }: {
+        active: Active;
+        over: any;
+    }) => void;
+    onDragEnd: ({ active, over }: {
+        active: Active;
+        over: any;
+    }) => void;
+    onDragCancel: () => void;
+    dropAnimation: DropAnimation;
+    activeItemForOverlay: NavigationEntry | null;
+    activeGroupData: {
+        name: string;
+        entries: NavigationEntry[];
+    } | null;
+    draggingGroupId: UniqueIdentifier | null;
+    containers: string[];
+    dndKitActiveNode: Active | null;
+    isDraggingCardOnly: boolean;
+    dialogOpenForGroup: string | null;
+    setDialogOpenForGroup: React.Dispatch<React.SetStateAction<string | null>>;
+    handleRenameGroup: (oldName: string, newName: string) => void;
+    handleDialogClose: () => void;
+    isHoveringNewGroupDropZone: boolean;
+    setIsHoveringNewGroupDropZone: React.Dispatch<React.SetStateAction<boolean>>;
+};
+export declare function NewGroupDropZone({ disabled, setIsHovering }: {
+    disabled: boolean;
+    setIsHovering: (v: boolean) => void;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/admin/src/components/HomePage/NavigationCard.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+export type NavigationCardProps = {
+    name: string;
+    description?: string;
+    actions: React.ReactNode;
+    icon: React.ReactNode;
+    additionalContent?: React.ReactNode;
+    onClick?: () => void;
+    shrink?: boolean;
+};
+export declare const NavigationCard: React.NamedExoticComponent<NavigationCardProps>;

package/dist/admin/src/components/HomePage/NavigationCardBinding.d.ts

@@ -0,0 +1,18 @@
+import type { NavigationEntry } from "@rebasepro/types";
+/**
+ * This is the component used in the home page to render a card for each
+ * collection or view.
+ * @group Components
+ * @param view
+ * @param path
+ * @param collection
+ * @param url
+ * @param name
+ * @param description
+ * @param onClick
+
+ */
+export declare function NavigationCardBinding({ slug, collection, view, url, name, description, onClick, type, shrink }: NavigationEntry & {
+    onClick?: () => void;
+    shrink?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/HomePage/NavigationGroup.d.ts

@@ -0,0 +1,11 @@
+import { PropsWithChildren } from "react";
+export declare function NavigationGroup({ children, group, minimised, isPreview, isPotentialCardDropTarget, onEditGroup, dndDisabled, collapsed, onToggleCollapsed }: PropsWithChildren<{
+    group: string | undefined;
+    minimised?: boolean;
+    isPreview?: boolean;
+    isPotentialCardDropTarget?: boolean;
+    onEditGroup?: (groupName: string) => void;
+    dndDisabled?: boolean;
+    collapsed?: boolean;
+    onToggleCollapsed?: () => void;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/HomePage/RenameGroupDialog.d.ts

@@ -0,0 +1,9 @@
+interface RenameGroupDialogProps {
+    open: boolean;
+    initialName: string;
+    existingGroupNames: string[];
+    onClose: () => void;
+    onRename: (newName: string) => void;
+}
+export declare function RenameGroupDialog({ open, initialName, existingGroupNames, onClose, onRename }: RenameGroupDialogProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/admin/src/components/HomePage/SmallNavigationCard.d.ts

@@ -0,0 +1,6 @@
+export type SmallNavigationCardProps = {
+    name: string;
+    url: string;
+    icon: React.ReactElement;
+};
+export declare function SmallNavigationCard({ name, url, icon }: SmallNavigationCardProps): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/PropertyCollectionView.d.ts

@@ -0,0 +1,24 @@
+import type { Properties } from "@rebasepro/types";
+import type { Property } from "@rebasepro/types";
+import { PreviewSize } from "../types/components/PropertyPreviewProps";
+/**
+ * Build a readable label for a path and resolve the property
+ * Supports map and array (including arrays of maps)
+ */
+export declare function buildPropertyLabelAndGetProperty(properties: Properties, key: string): {
+    label: string;
+    property: Property | undefined;
+};
+/**
+ * Improved simple layout for nested changes:
+ * - Map or Array-of-Map -> section header + indented rows
+ * - Leaf or Array-of-Primitives -> single row with label and value
+ */
+export declare const PropertyCollectionView: ({ data, properties, baseKey, suppressHeader, size }: {
+    data: any;
+    properties: Properties;
+    baseKey?: string;
+    suppressHeader?: boolean;
+    size?: PreviewSize;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export declare function buildDataFromPaths(values: object, paths: string[]): object;

package/dist/admin/src/components/PropertyConfigBadge.d.ts

@@ -0,0 +1,6 @@
+import type { PropertyConfig } from "@rebasepro/types";
+export declare function PropertyConfigBadge({ propertyConfig, disabled, size }: {
+    propertyConfig: PropertyConfig | undefined;
+    disabled?: boolean;
+    size?: "extraSmall" | "small" | "medium";
+}): React.ReactNode;

package/dist/admin/src/components/PropertyIdCopyTooltip.d.ts

@@ -0,0 +1,8 @@
+export declare function PropertyIdCopyTooltip({ propertyKey, className, children }: {
+    propertyKey: string;
+    className?: string;
+    children: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function PropertyIdCopyTooltipContent({ propertyKey }: {
+    propertyKey: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/RebaseAuthGate.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+/**
+ * Auth gate component that handles the authentication flow.
+ *
+ * - Shows a loading spinner while `authController.initialLoading` is true.
+ * - Shows the login view when no user is authenticated.
+ * - Renders `children` when a user is authenticated.
+ *
+ * **Independently usable**: Use this alone when you want auth gating
+ * without the full CMS layout or navigation.
+ *
+ * @example
+ * ```tsx
+ * <RebaseAuthGate>
+ *   <MyCustomApp />
+ * </RebaseAuthGate>
+ * ```
+ */
+export declare function RebaseAuthGate({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/RebaseCMS.d.ts

@@ -0,0 +1,10 @@
+import type { RebaseCMSConfig } from "@rebasepro/types";
+/**
+ * Declarative component to configure the CMS in Rebase.
+ * Renders nothing — purely registers config into the RebaseRegistry.
+ *
+ * When `collectionEditor` is provided, the built-in visual schema editor
+ * is auto-wired as a native feature (slots, provider, Studio view) without
+ * needing any external plugin.
+ */
+export declare function RebaseCMS({ collections, homePage, entityViews, entityActions, plugins, collectionEditor, navigationGroupMappings }: RebaseCMSConfig): null;

package/dist/admin/src/components/RebaseLayout.d.ts

@@ -0,0 +1,32 @@
+import React from "react";
+import type { AppView } from "@rebasepro/types";
+export interface RebaseLayoutProps {
+    /** Title shown in the drawer. */
+    title?: string;
+    /** Custom AppBar to override the default. */
+    appBar?: React.ReactNode;
+    /** Custom Drawer to override the default. */
+    drawer?: React.ReactNode;
+    /** Whether to auto-open the drawer on load. */
+    autoOpenDrawer?: boolean;
+    /** Dev views passed to AdminModeSyncer (resolved from RebaseNavigation). */
+    devViews?: AppView[];
+}
+/**
+ * Layout layer — provides the Scaffold, AppBar, Drawer, and SideDialogs.
+ *
+ * Wraps the route outlet with the standard Rebase admin layout.
+ * Override individual pieces (appBar, drawer) via props.
+ *
+ * **Independently usable**: Use this when you want the Rebase layout
+ * without its default route definitions.
+ *
+ * @example
+ * ```tsx
+ * <RebaseLayout title="My Admin">
+ *   <Route path="/" element={<MyHomePage />} />
+ *   <Route path="/custom" element={<CustomView />} />
+ * </RebaseLayout>
+ * ```
+ */
+export declare function RebaseLayout(props: RebaseLayoutProps): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/RebaseNavigation.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+export interface RebaseNavigationProps {
+    children: React.ReactNode;
+}
+/**
+ * Navigation layer — builds and provides all CMS navigation controllers:
+ * collection registry, URL controller, navigation state, side entity,
+ * and the self-assembling Studio bridge.
+ *
+ * Also handles the collection editor config controller when enabled.
+ *
+ * **Independently usable**: Use this when you need CMS navigation
+ * (entity tables, side panels) in a custom layout.
+ *
+ * @example
+ * ```tsx
+ * <RebaseNavigation>
+ *   <MyCustomLayout>
+ *     <EntityCollectionView ... />
+ *   </MyCustomLayout>
+ * </RebaseNavigation>
+ * ```
+ */
+export declare function RebaseNavigation({ children }: RebaseNavigationProps): import("react/jsx-runtime").JSX.Element;