@rebasepro/plugin-data-enhancement 0.1.2 → 0.2.3

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

@@ -0,0 +1,44 @@
+import { CollectionSize, ViewMode } from "@rebasepro/types";
+export type KanbanPropertyOption = {
+    key: string;
+    label: string;
+};
+export type ViewModeToggleProps = {
+    viewMode?: ViewMode;
+    onViewModeChange?: (mode: ViewMode) => void;
+    /**
+     * Which view modes are enabled for this collection.
+     * Only these modes will appear in the toggle.
+     * Defaults to all three: ["table", "cards", "kanban"].
+     */
+    enabledViews?: ViewMode[];
+    /**
+     * Current size for card/table views
+     */
+    size?: CollectionSize;
+    /**
+     * Callback when size changes
+     */
+    onSizeChanged?: (size: CollectionSize) => void;
+    /**
+     * Controlled open state for the popover
+     */
+    open?: boolean;
+    /**
+     * Callback when popover open state changes
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Available properties that can be used for kanban columns (enum properties)
+     */
+    kanbanPropertyOptions?: KanbanPropertyOption[];
+    /**
+     * Currently selected property for kanban columns
+     */
+    selectedKanbanProperty?: string;
+    /**
+     * Callback when the kanban column property changes
+     */
+    onKanbanPropertyChange?: (property: string) => void;
+};
+export declare function ViewModeToggle({ viewMode, onViewModeChange, enabledViews, size, onSizeChanged, open, onOpenChange, kanbanPropertyOptions, selectedKanbanProperty, onKanbanPropertyChange }: ViewModeToggleProps): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,105 @@
+import { CSSProperties } from "react";
+import { ChipColorKey, ChipColorScheme } from "@rebasepro/ui";
+import { Entity } from "@rebasepro/types";
+/**
+ * Item wrapper for entities in the Board component
+ */
+export interface BoardItem<M extends Record<string, unknown> = Record<string, unknown>> {
+    id: string;
+    entity: Entity<M>;
+}
+/**
+ * Map of column keys to arrays of board items
+ */
+export interface BoardItemMap<M extends Record<string, unknown> = Record<string, unknown>> {
+    [columnKey: string]: BoardItem<M>[];
+}
+/**
+ * Props passed to custom item render components
+ */
+export interface BoardItemViewProps<M extends Record<string, unknown> = Record<string, unknown>> {
+    item: BoardItem<M>;
+    isDragging: boolean;
+    isClone?: boolean;
+    isGroupedOver?: boolean;
+    style?: CSSProperties;
+    index?: number;
+}
+/**
+ * Per-column loading state
+ */
+export interface ColumnLoadingState {
+    [columnKey: string]: {
+        loading: boolean;
+        hasMore: boolean;
+        itemCount: number;
+        /** Total count of entities in column (may differ from itemCount if some lack orderProperty) */
+        totalCount?: number;
+    };
+}
+/**
+ * Props for the Board component
+ */
+export interface BoardProps<M extends Record<string, unknown>, COLUMN extends string> {
+    /**
+     * Array of board items (entities wrapped with id)
+     */
+    data: BoardItem<M>[];
+    /**
+     * Array of column keys/identifiers
+     */
+    columns: COLUMN[];
+    /**
+     * Labels for each column (optional, uses column key if not provided)
+     */
+    columnLabels?: Record<COLUMN, string>;
+    /**
+     * Colors for each column from enum values (optional)
+     */
+    columnColors?: Record<COLUMN, ChipColorKey | ChipColorScheme | undefined>;
+    /**
+     * CSS class name for the board container
+     */
+    className?: string;
+    /**
+     * Function to determine which column an item belongs to
+     */
+    assignColumn: (item: BoardItem<M>) => COLUMN;
+    /**
+     * Whether column reordering is allowed.
+     * Set to true only when a plugin provides persistence for column order.
+     */
+    allowColumnReorder?: boolean;
+    /**
+     * Callback when columns are reordered
+     */
+    onColumnReorder?: (columns: COLUMN[]) => void;
+    /**
+     * Callback when items are reordered or moved between columns
+     */
+    onItemsReorder?: (items: BoardItem<M>[], moveInfo?: {
+        itemId: string;
+        sourceColumn: COLUMN;
+        targetColumn: COLUMN;
+    }) => void;
+    /**
+     * Component to render individual items
+     */
+    ItemComponent: React.ComponentType<BoardItemViewProps<M>>;
+    /**
+     * Per-column loading state for pagination
+     */
+    columnLoadingState?: ColumnLoadingState;
+    /**
+     * Callback to load more items for a column
+     */
+    onLoadMoreColumn?: (column: COLUMN) => void;
+    /**
+     * Callback to add a new item to a specific column
+     */
+    onAddItemToColumn?: (column: COLUMN) => void;
+    /**
+     * Optional component to render at the end of the board for adding new columns
+     */
+    AddColumnComponent?: React.ReactNode;
+}

package/dist/admin/src/components/EntityCollectionView/hooks/useCollectionInlineEditor.d.ts

@@ -0,0 +1,12 @@
+import { EntityCollection, RebaseData, RebaseContext } from "@rebasepro/types";
+import { OnCellValueChange, UniqueFieldValidator } from "@rebasepro/core";
+export interface UseCollectionInlineEditorParams<M extends Record<string, unknown>> {
+    path: string;
+    collection: EntityCollection<M>;
+    dataClient: RebaseData;
+    context: RebaseContext;
+}
+export declare function useCollectionInlineEditor<M extends Record<string, unknown>>({ path, collection, dataClient, context }: UseCollectionInlineEditorParams<M>): {
+    onValueChange: OnCellValueChange<any, any>;
+    uniqueFieldValidator: UniqueFieldValidator;
+};

package/dist/admin/src/components/EntityCollectionView/hooks/useKanbanDragAndDrop.d.ts

@@ -0,0 +1,19 @@
+import { EntityCollection, RebaseData, RebaseContext } from "@rebasepro/types";
+import { BoardItem } from "../board_types";
+export interface UseKanbanDragAndDropParams<M extends Record<string, unknown>> {
+    collection: EntityCollection<M>;
+    fullPath: string;
+    columnProperty: string;
+    orderProperty?: string;
+    dataClient: RebaseData;
+    context: RebaseContext;
+    boardDataController: any;
+    analyticsController: any;
+}
+export declare function useKanbanDragAndDrop<M extends Record<string, unknown>>({ collection, fullPath, columnProperty, orderProperty, dataClient, context, boardDataController, analyticsController }: UseKanbanDragAndDropParams<M>): {
+    handleItemsReorder: (items: BoardItem<M>[], moveInfo?: {
+        itemId: string;
+        sourceColumn: string;
+        targetColumn: string;
+    }) => Promise<void>;
+};

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>;