@rebasepro/core 0.0.1-canary.0

package/dist/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, any> = any> {
+    id: string;
+    entity: Entity<M>;
+}
+/**
+ * Map of column keys to arrays of board items
+ */
+export interface BoardItemMap<M extends Record<string, any> = any> {
+    [columnKey: string]: BoardItem<M>[];
+}
+/**
+ * Props passed to custom item render components
+ */
+export interface BoardItemViewProps<M extends Record<string, any> = any> {
+    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, any>, 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/components/EntityCollectionView/useBoardDataController.d.ts

@@ -0,0 +1,60 @@
+import { Entity, EntityCollection, FilterValues } from "@rebasepro/types";
+/**
+ * Data state for a single board column
+ */
+export interface BoardColumnData<M extends Record<string, any> = any> {
+    /** 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, any> = 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, any> = any> {
+    /** 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, any> = 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, any> = any>(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/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,54 @@
+import * as React from "react";
+import { Entity, EntityCollection, PreviewSize } from "@rebasepro/types";
+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/EntityView.d.ts

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

package/dist/components/ErrorBoundary.d.ts

@@ -0,0 +1,11 @@
+import React, { ErrorInfo, PropsWithChildren } from "react";
+export declare class ErrorBoundary extends React.Component<PropsWithChildren<Record<string, unknown>>, {
+    error: Error | null;
+}> {
+    constructor(props: any);
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}

package/dist/components/ErrorTooltip.d.ts

@@ -0,0 +1,2 @@
+import { TooltipProps } from "@rebasepro/ui";
+export declare function ErrorTooltip(props: TooltipProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ErrorView.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+/**
+ * @group Components
+ */
+export interface ErrorViewProps {
+    title?: string;
+    error: Error | React.ReactElement | string;
+    tooltip?: string;
+    onRetry?: () => void;
+}
+/**
+ * Generic error view. Displayed for example when an unexpected value comes
+ * from the datasource in a collection view.
+ * @param title
+ * @param error
+ * @param tooltip
+ * @param onRetry
+
+ * @group Components
+ */
+export declare function ErrorView({ title, error, tooltip, onRetry }: ErrorViewProps): React.ReactElement;

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 React from "react";
+import { HomePageSection } from "@rebasepro/types";
+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 React from "react";
+import { Active, CollisionDetection, DropAnimation, UniqueIdentifier } from "@dnd-kit/core";
+import { NavigationEntry } from "@rebasepro/types";
+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 { 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/StudioHomePage.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { HomePageSection } from "@rebasepro/types";
+export declare function StudioHomePage({ 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/index.d.ts

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

package/dist/components/NotFoundPage.d.ts

@@ -0,0 +1 @@
+export declare function NotFoundPage(): import("react/jsx-runtime").JSX.Element;

package/dist/components/PropertyCollectionView.d.ts

@@ -0,0 +1,22 @@
+import { PreviewSize, Properties, Property } from "@rebasepro/types";
+/**
+ * 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 { 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/RebaseLogo.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+export declare function RebaseLogo({ width, height, className, style }: {
+    width?: string;
+    height?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,58 @@
+import React from "react";
+import { Entity, EntityCollection, FilterValues } from "@rebasepro/types";
+/**
+ * @group Components
+ */
+export interface EntitySelectionProps<M extends Record<string, any>> {
+    /**
+     * 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, any>>({ onSingleEntitySelected, onMultipleEntitiesSelected, multiselect, collection, path: pathInput, selectedEntityIds: selectedEntityIdsProp, description, forceFilter, maxSelection, }: EntitySelectionProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/components/ReferenceWidget.d.ts

@@ -0,0 +1,29 @@
+import { Entity, EntityReference, FilterValues, PreviewSize } from "@rebasepro/types";
+export type ReferenceWidgetProps<M extends Record<string, any>> = {
+    name?: string;
+    multiselect?: boolean;
+    value: EntityReference | EntityReference[] | null;
+    onReferenceSelected?: (params: {
+        reference: EntityReference | null;
+        entity: Entity<M> | null;
+    }) => void;
+    onMultipleReferenceSelected?: (params: {
+        references: EntityReference[] | null;
+        entities: Entity<M>[] | null;
+    }) => void;
+    path: string;
+    disabled?: boolean;
+    previewProperties?: string[];
+    /**
+     * Allow selection of entities that pass the given filter only.
+     */
+    forceFilter?: FilterValues<string>;
+    size: PreviewSize;
+    className?: string;
+    includeId?: boolean;
+    includeEntityLink?: boolean;
+};
+/**
+ * This field allows selecting reference/s.
+ */
+export declare function ReferenceWidget<M extends Record<string, any>>({ name, multiselect, path, disabled, value, onReferenceSelected, onMultipleReferenceSelected, previewProperties, forceFilter, size, className, includeId, includeEntityLink }: ReferenceWidgetProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/components/RelationSelector.d.ts

@@ -0,0 +1,32 @@
+import * as React from "react";
+import { Entity, EntityRelation, FilterValues, Relation } from "@rebasepro/types";
+export interface RelationItem {
+    id: string | number;
+    label: string;
+    description?: string;
+    data?: Entity;
+    relation: EntityRelation;
+}
+export interface RelationSelectorProps {
+    className?: string;
+    name?: string;
+    id?: string;
+    value?: EntityRelation | EntityRelation[] | null;
+    /** Callback returning selected EntityRelation(s) */
+    onValueChange?: (updatedValue: EntityRelation | EntityRelation[] | undefined) => void;
+    placeholder?: React.ReactNode;
+    size?: "small" | "medium";
+    useChips?: boolean;
+    disabled?: boolean;
+    error?: boolean;
+    padding?: boolean;
+    invisible?: boolean;
+    relation: Relation;
+    forceFilter?: FilterValues<string>;
+    pageSize?: number;
+    emptyPlaceholder?: string;
+    searchPlaceholder?: string;
+    noResultsText?: string;
+    loadingText?: string;
+}
+export declare const RelationSelector: React.ForwardRefExoticComponent<RelationSelectorProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/SearchIconsView.d.ts

@@ -0,0 +1,5 @@
+export interface SearchIconsProps {
+    selectedIcon?: string;
+    onIconSelected?: (icon: string) => void;
+}
+export declare function SearchIconsView({ selectedIcon, onIconSelected }: SearchIconsProps): import("react/jsx-runtime").JSX.Element;