@rebasepro/cms 0.0.1-canary.4d4fb3e

package/dist/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 counts for columns (for optimistic updates when moving items) */
+    updateColumnCounts: (sourceColumn: COLUMN, targetColumn: COLUMN) => 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/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/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/components/EntityEditView.d.ts

@@ -0,0 +1,48 @@
+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 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;
+    parentCollectionIds: string[];
+    onValuesModified?: (modified: boolean, values: M) => void;
+    onSaved?: (params: OnUpdateParams) => void;
+    onTabChange?: (props: OnTabChangeParams<M>) => void;
+    layout?: "side_panel" | "full_screen";
+    barActions?: (params: BarActionsParams) => any;
+    formProps?: Partial<EntityFormProps<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, parentCollectionIds, onValuesModified, onSaved, onTabChange, 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/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/components/EntityJsonPreview.d.ts

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

package/dist/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/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/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/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/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/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/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/components/HomePage/NavigationCard.d.ts

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

package/dist/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/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/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/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/components/HomePage/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ContentHomePage";
+export * from "./NavigationGroup";
+export * from "./NavigationCard";
+export * from "./SmallNavigationCard";

package/dist/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/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/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/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/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 }: RebaseCMSConfig): null;

package/dist/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/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;

package/dist/components/RebaseRouteDefs.d.ts

@@ -0,0 +1,30 @@
+import React from "react";
+export interface RebaseRouteDefsProps {
+    /** User-provided custom routes to include. */
+    children?: React.ReactNode;
+    /**
+     * Wrap function — receives the route tree and lets you wrap it in a layout.
+     * If provided, the routes are rendered inside this wrapper.
+     * If not provided, routes are rendered directly inside <RebaseRoutes>.
+     */
+    layout?: React.ReactElement;
+}
+/**
+ * Route definitions for the CMS.
+ *
+ * Defines all standard routes: home, studio home, collection view,
+ * settings, users, roles, debug, custom views, and a catch-all 404.
+ *
+ * **Independently usable**: Use this when you want Rebase routes
+ * inside your own layout/navigation setup.
+ *
+ * @example
+ * ```tsx
+ * <RebaseNavigation>
+ *   <RebaseRouteDefs layout={<MyCustomLayout />}>
+ *     <Route path="/my-custom" element={<MyView />} />
+ *   </RebaseRouteDefs>
+ * </RebaseNavigation>
+ * ```
+ */
+export declare function RebaseRouteDefs({ children, layout }: RebaseRouteDefsProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/RebaseShell.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+export interface RebaseShellProps {
+    title?: string;
+    appBar?: React.ReactNode;
+    drawer?: React.ReactNode;
+    autoOpenDrawer?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * Convenience component that composes all four CMS layers:
+ *
+ * ```
+ * <RebaseAuthGate>
+ *   <RebaseNavigation>
+ *     <RebaseRouteDefs layout={<RebaseLayout>}>
+ *       {children}
+ *     </RebaseRouteDefs>
+ *   </RebaseNavigation>
+ * </RebaseAuthGate>
+ * ```
+ *
+ * Each layer is independently usable — see their individual docs.
+ * RebaseShell is sugar that composes them all with sensible defaults.
+ */
+export declare function RebaseShell(props: RebaseShellProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ReferenceTable/EntitySelectionTable.d.ts

@@ -0,0 +1,59 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { Entity, FilterValues } from "@rebasepro/types";
+/**
+ * @group Components
+ */
+export interface EntitySelectionProps<M extends Record<string, unknown>> {
+    /**
+     * Allow multiple selection of values
+     */
+    multiselect?: boolean;
+    /**
+     * Entity collection config
+     */
+    collection?: EntityCollection<M>;
+    /**
+     * Absolute path of the collection.
+     * May be not set if this hook is being used in a component and the path is
+     * dynamic. If not set, the dialog won't open.
+     */
+    path: string;
+    /**
+     * If you are opening the dialog for the first time, you can select some
+     * entity ids to be displayed first.
+     */
+    selectedEntityIds?: (string | number)[];
+    /**
+     * If `multiselect` is set to `false`, you will get the selected entity
+     * in this callback.
+     * @param entity
+     * @callback
+     */
+    onSingleEntitySelected?(entity: Entity<any> | null): void;
+    /**
+     * If `multiselect` is set to `true`, you will get the selected entities
+     * in this callback.
+     * @param entities
+     * @callback
+     */
+    onMultipleEntitiesSelected?(entities: Entity<any>[]): void;
+    /**
+     * Allow selection of entities that pass the given filter only.
+     */
+    forceFilter?: FilterValues<string>;
+    /**
+     * Use this description to indicate the user what to do in this dialog.
+     */
+    description?: React.ReactNode;
+    /**
+     * Maximum number of entities that can be selected.
+     */
+    maxSelection?: number;
+}
+/**
+ * This component allows to select entities from a given collection.
+ * You probably want to open this dialog as a side view using {@link useEntitySelectionTable}
+ * @group Components
+ */
+export declare function EntitySelectionTable<M extends Record<string, unknown>>({ onSingleEntitySelected, onMultipleEntitiesSelected, multiselect, collection, path: pathInput, selectedEntityIds: selectedEntityIdsProp, description, forceFilter, maxSelection, }: EntitySelectionProps<M>): import("react/jsx-runtime").JSX.Element;