@rebasepro/plugin-data-enhancement 0.1.2 → 0.2.3

package/dist/admin/src/form/useClearRestoreValue.d.ts

@@ -0,0 +1,13 @@
+import type { Property } from "@rebasepro/types";
+/**
+ * Hook we use to restore a value after it has been cleared
+ * @param property
+ * @param value
+ * @param setValue
+ * @ignore
+ */
+export declare function useClearRestoreValue<T>({ property, value, setValue }: {
+    property: Property;
+    value: T | null;
+    setValue: (value: T | null, shouldValidate?: boolean) => void;
+}): void;

package/dist/admin/src/form/validation.d.ts

@@ -0,0 +1,21 @@
+import type { Properties } from "@rebasepro/types";
+import type { ArrayProperty, MapProperty, Property } from "@rebasepro/types";
+import { z, ZodTypeAny } from "zod";
+export type CustomFieldValidator = (props: {
+    name: string;
+    value: any;
+    property: Property;
+    entityId?: string | number;
+    parentProperty?: MapProperty | ArrayProperty;
+}) => Promise<boolean>;
+interface PropertyContext<P extends Property> {
+    property: P;
+    parentProperty?: MapProperty | ArrayProperty;
+    entityId?: string | number;
+    customFieldValidator?: CustomFieldValidator;
+    name?: any;
+}
+export declare function getEntitySchema<M extends Record<string, unknown>>(entityId: string | number | undefined, properties: Properties, customFieldValidator?: CustomFieldValidator): z.ZodObject<any>;
+export declare function mapPropertyToZod(propertyContext: PropertyContext<Property>): ZodTypeAny;
+export declare function getZodMapObjectSchema({ property, entityId, customFieldValidator, name }: PropertyContext<MapProperty>): ZodTypeAny;
+export {};

package/dist/admin/src/hooks/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./useSideEntityController";
+export * from "./useEntitySelectionDialog";
+export * from "./useBuildSideEntityController";
+export * from "./useResolvedNavigationFrom";
+export * from "./useEntityHistory";
+export * from "./navigation/contexts";
+export * from "./navigation/useBuildCollectionRegistryController";
+export * from "./navigation/useBuildNavigationStateController";
+export * from "./navigation/useBuildUrlController";
+export * from "./navigation/useResolvedCollections";
+export * from "./navigation/useResolvedViews";
+export * from "./navigation/useTopLevelNavigation";
+export * from "./useSideDialogsController";
+export * from "./useBreadcrumbsController";
+export * from "./useCMSContext";

package/dist/admin/src/hooks/navigation/contexts/CollectionRegistryContext.d.ts

@@ -0,0 +1,5 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { CollectionRegistryController } from "@rebasepro/types";
+export declare const CollectionRegistryContext: React.Context<CollectionRegistryController>;
+export declare function useCollectionRegistryController<DB = Record<string, unknown>, EC extends EntityCollection = EntityCollection<any>>(): CollectionRegistryController<DB, EC>;

package/dist/admin/src/hooks/navigation/contexts/NavigationStateContext.d.ts

@@ -0,0 +1,4 @@
+import type { NavigationStateController } from "@rebasepro/types";
+import React from "react";
+export declare const NavigationStateContext: React.Context<NavigationStateController>;
+export declare function useNavigationStateController(): NavigationStateController;

package/dist/admin/src/hooks/navigation/contexts/UrlContext.d.ts

@@ -0,0 +1,4 @@
+import type { UrlController } from "@rebasepro/types";
+import React from "react";
+export declare const UrlContext: React.Context<UrlController>;
+export declare function useUrlController(): UrlController;

package/dist/admin/src/hooks/navigation/contexts/index.d.ts

@@ -0,0 +1,3 @@
+export { CollectionRegistryContext, useCollectionRegistryController } from "./CollectionRegistryContext";
+export { NavigationStateContext, useNavigationStateController } from "./NavigationStateContext";
+export { UrlContext, useUrlController } from "./UrlContext";

package/dist/admin/src/hooks/navigation/useBuildCollectionRegistryController.d.ts

@@ -0,0 +1,7 @@
+import { CollectionRegistry } from "@rebasepro/common";
+import { UserConfigurationPersistence, CollectionRegistryController } from "@rebasepro/types";
+export declare function useBuildCollectionRegistryController(props: {
+    userConfigPersistence?: UserConfigurationPersistence;
+}): CollectionRegistryController & {
+    collectionRegistryRef: React.MutableRefObject<CollectionRegistry>;
+};

package/dist/admin/src/hooks/navigation/useBuildNavigationStateController.d.ts

@@ -0,0 +1,34 @@
+import type { AppView, EntityCollection, RebasePlugin, NavigationStateController, UrlController, NavigationGroupMapping } from "@rebasepro/types";
+import { AuthController, RebaseData, CollectionRegistryController, User } from "@rebasepro/types";
+import type { EntityCollectionsBuilder, AppViewsBuilder, EffectiveRoleController } from "@rebasepro/types";
+import { CollectionRegistry } from "@rebasepro/common";
+import { UserManagementDelegate } from "@rebasepro/types";
+export type BuildNavigationStateProps<EC extends EntityCollection, USER extends User> = {
+    authController: AuthController<USER>;
+    collections?: EC[] | EntityCollectionsBuilder<EC>;
+    views?: AppView[] | AppViewsBuilder;
+    adminViews?: AppView[] | AppViewsBuilder;
+    data: RebaseData;
+    plugins?: RebasePlugin[];
+    navigationGroupMappings?: NavigationGroupMapping[];
+    disabled?: boolean;
+    viewsOrder?: string[];
+    collectionRegistryController: CollectionRegistryController<EC> & {
+        collectionRegistryRef: React.MutableRefObject<CollectionRegistry>;
+    };
+    urlController: UrlController;
+    adminMode?: "content" | "studio" | "settings";
+    effectiveRoleController?: EffectiveRoleController;
+    userManagement?: UserManagementDelegate<USER>;
+};
+/**
+ * Main hook that resolves collections, views, and admin views into a
+ * NavigationStateController. This is a thin composition of three focused hooks:
+ *
+ * - useResolvedCollections: resolves collection props and registers with CollectionRegistry
+ * - useResolvedViews: resolves view/admin view props and injects Users/Roles views
+ * - useTopLevelNavigation: computes the NavigationResult from resolved data
+ *
+ * The NavigationStateController type is preserved as a public API.
+ */
+export declare function useBuildNavigationStateController<EC extends EntityCollection, USER extends User>(props: BuildNavigationStateProps<EC, USER>): NavigationStateController;

package/dist/admin/src/hooks/navigation/useBuildUrlController.d.ts

@@ -0,0 +1,7 @@
+import type { UrlController } from "@rebasepro/types";
+import { CollectionRegistryController } from "@rebasepro/types";
+export declare function useBuildUrlController(props: {
+    basePath: string;
+    baseCollectionPath: string;
+    collectionRegistryController: CollectionRegistryController;
+}): UrlController;

package/dist/admin/src/hooks/navigation/useNavigationResolution.d.ts

@@ -0,0 +1,7 @@
+import type { AppView, AppViewsBuilder, EntityCollection, RebasePlugin } from "@rebasepro/types";
+import { AuthController, User, RebaseData } from "@rebasepro/types";
+import type { EntityCollectionsBuilder } from "@rebasepro/types";
+export declare function filterOutNotAllowedCollections(resolvedCollections: EntityCollection[], authController: AuthController<User>): EntityCollection[];
+export declare function applyPluginModifyCollection(resolvedCollections: EntityCollection[], modifyCollection: (collection: EntityCollection) => EntityCollection): EntityCollection[];
+export declare function resolveCollections<U extends User, EC extends EntityCollection>(collections: undefined | EC[] | EntityCollectionsBuilder<EC>, authController: AuthController<U>, data: RebaseData, plugins: RebasePlugin[] | undefined): Promise<EntityCollection[]>;
+export declare function resolveAppViews<U extends User>(baseViews: AppView[] | AppViewsBuilder | undefined, authController: AuthController<U>, data: RebaseData, plugins?: RebasePlugin[]): Promise<AppView[]>;

package/dist/admin/src/hooks/navigation/useResolvedCollections.d.ts

@@ -0,0 +1,28 @@
+import type { EntityCollection, RebasePlugin } from "@rebasepro/types";
+import { AuthController, CollectionRegistryController, RebaseData, User } from "@rebasepro/types";
+import type { EntityCollectionsBuilder } from "@rebasepro/types";
+import { CollectionRegistry } from "@rebasepro/common";
+export type UseResolvedCollectionsProps<EC extends EntityCollection, USER extends User> = {
+    authController: AuthController<USER>;
+    collections?: EC[] | EntityCollectionsBuilder<EC>;
+    data: RebaseData;
+    plugins?: RebasePlugin[];
+    disabled?: boolean;
+    collectionRegistryController: CollectionRegistryController<EC> & {
+        collectionRegistryRef: React.MutableRefObject<CollectionRegistry>;
+    };
+};
+export type UseResolvedCollectionsResult = {
+    collections: EntityCollection[];
+    loading: boolean;
+    error: Error | undefined;
+    refresh: () => void;
+};
+/**
+ * Hook that resolves collection props (which may be async builders or arrays)
+ * into concrete EntityCollection[], and registers them with the CollectionRegistry.
+ *
+ * Uses refs for potentially-unstable dependencies (driver, authController,
+ * plugins) to avoid re-triggering effects when their object identity changes.
+ */
+export declare function useResolvedCollections<EC extends EntityCollection, USER extends User>(props: UseResolvedCollectionsProps<EC, USER>): UseResolvedCollectionsResult;

package/dist/admin/src/hooks/navigation/useResolvedViews.d.ts

@@ -0,0 +1,30 @@
+import type { AppView, AppViewsBuilder, EffectiveRoleController, EntityCollection, RebasePlugin } from "@rebasepro/types";
+import { AuthController, RebaseData, User } from "@rebasepro/types";
+import { UserManagementDelegate } from "@rebasepro/types";
+export type UseResolvedViewsProps<USER extends User> = {
+    authController: AuthController<USER>;
+    views?: AppView[] | AppViewsBuilder;
+    adminViews?: AppView[] | AppViewsBuilder;
+    data: RebaseData;
+    plugins?: RebasePlugin[];
+    adminMode?: "content" | "studio" | "settings";
+    effectiveRoleController?: EffectiveRoleController;
+    userManagement?: UserManagementDelegate<USER>;
+    collections?: EntityCollection[];
+};
+export type UseResolvedViewsResult = {
+    views: AppView[] | undefined;
+    adminViews: AppView[] | undefined;
+    loading: boolean;
+    error: Error | undefined;
+    refresh: () => void;
+};
+/**
+ * Hook that resolves view and admin view props (which may be async builders or arrays)
+ * into concrete AppView[]. Also injects Users/Roles admin views when userManagement
+ * is provided.
+ *
+ * Uses refs for potentially-unstable dependencies (driver, authController,
+ * plugins) to avoid re-triggering effects when their object identity changes.
+ */
+export declare function useResolvedViews<USER extends User>(props: UseResolvedViewsProps<USER>): UseResolvedViewsResult;

package/dist/admin/src/hooks/navigation/useTopLevelNavigation.d.ts

@@ -0,0 +1,27 @@
+import type { AppView, UrlController, EntityCollection, RebasePlugin, NavigationGroupMapping, NavigationResult } from "@rebasepro/types";
+import { CollectionRegistryController } from "@rebasepro/types";
+import { CollectionRegistry } from "@rebasepro/common";
+export type UseTopLevelNavigationProps = {
+    collections: EntityCollection[];
+    views: AppView[] | undefined;
+    adminViews: AppView[] | undefined;
+    plugins?: RebasePlugin[];
+    navigationGroupMappings?: NavigationGroupMapping[];
+    viewsOrder?: string[];
+    urlController: UrlController;
+    adminMode?: "content" | "studio" | "settings";
+    collectionRegistryController: CollectionRegistryController<any> & {
+        collectionRegistryRef: React.MutableRefObject<CollectionRegistry>;
+    };
+};
+export type UseTopLevelNavigationResult = {
+    topLevelNavigation: NavigationResult | undefined;
+};
+/**
+ * Hook that computes the top-level NavigationResult from resolved collections,
+ * views, and admin views. Pure computation — no async, no effects.
+ *
+ * The `onNavigationEntriesUpdate` callback is embedded in the result for API
+ * compatibility, but its reference is stable via useCallback.
+ */
+export declare function useTopLevelNavigation(props: UseTopLevelNavigationProps): UseTopLevelNavigationResult;

package/dist/admin/src/hooks/navigation/utils.d.ts

@@ -0,0 +1,12 @@
+import type { AppView, EntityCollection, RebasePlugin, NavigationGroupMapping } from "@rebasepro/types";
+export declare const NAVIGATION_DEFAULT_GROUP_NAME = "Views";
+export declare const NAVIGATION_ADMIN_GROUP_NAME = "Admin";
+export declare function getGroup(collectionOrView: EntityCollection<any, any> | AppView): string;
+export declare function computeNavigationGroups({ navigationGroupMappings, collections, views, plugins }: {
+    navigationGroupMappings?: NavigationGroupMapping[];
+    collections?: EntityCollection[];
+    views?: AppView[];
+    plugins?: RebasePlugin[];
+}): NavigationGroupMapping[];
+export declare function areCollectionListsEqual(a: EntityCollection[], b: EntityCollection[], visitedSlugs?: string[]): boolean;
+export declare function areCollectionsEqual(a: EntityCollection, b: EntityCollection, visitedSlugs?: string[]): boolean;

package/dist/admin/src/hooks/useBreadcrumbsController.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @group Hooks and utilities
+ */
+export interface BreadcrumbsController {
+    breadcrumbs: BreadcrumbEntry[];
+    set: (props: {
+        breadcrumbs: BreadcrumbEntry[];
+    }) => void;
+    /**
+     * Update the count for a specific breadcrumb by ID.
+     */
+    updateCount: (id: string, count: number | null | undefined) => void;
+}
+/**
+ * @group Hooks and utilities
+ */
+export interface BreadcrumbEntry {
+    title: string;
+    url: string;
+    /**
+     * Optional entity count for collection breadcrumbs.
+     * - undefined: not applicable (e.g., entity breadcrumb, custom view)
+     * - null: loading
+     * - number: loaded count
+     */
+    count?: number | null;
+    /**
+     * Unique identifier for this breadcrumb (e.g., collection path).
+     * Used to update count without replacing entire breadcrumb array.
+     */
+    id?: string;
+}
+/**
+ * Hook to retrieve the BreadcrumbsController.
+ *
+ * Consider that in order to use this hook you need to have a parent
+ * `Rebase`
+ *
+ * @see BreadcrumbsController
+ * @group Hooks and utilities
+ */
+export declare const useBreadcrumbsController: () => BreadcrumbsController;

package/dist/admin/src/hooks/useBuildSideDialogsController.d.ts

@@ -0,0 +1,2 @@
+import type { SideDialogsController } from "../hooks/useSideDialogsController";
+export declare function useBuildSideDialogsController(): SideDialogsController;

package/dist/admin/src/hooks/useBuildSideEntityController.d.ts

@@ -0,0 +1,6 @@
+import type { EntityCollection } from "@rebasepro/types";
+import type { CustomizationController, EntitySidePanelProps, SideDialogsController, SideEntityController, UrlController, NavigationStateController } from "@rebasepro/types";
+import { AuthController, CollectionRegistryController } from "@rebasepro/types";
+export declare function getEntityViewWidth(props: EntitySidePanelProps<any>, small: boolean, customizationController: CustomizationController): string;
+export declare const useBuildSideEntityController: (collectionRegistryController: CollectionRegistryController, urlController: UrlController, navigationStateController: NavigationStateController, sideDialogsController: SideDialogsController, authController: AuthController) => SideEntityController;
+export declare function buildSidePanelsFromUrl(path: string, collections: EntityCollection[], newFlag: boolean): EntitySidePanelProps<any>[];

package/dist/admin/src/hooks/useCMSContext.d.ts

@@ -0,0 +1,27 @@
+import type { AuthController, RebaseContext, SideDialogsController, SideEntityController, User } from "@rebasepro/types";
+import type { CollectionRegistryController, NavigationStateController, UrlController } from "@rebasepro/types";
+/**
+ * The CMS context extends the core RebaseContext with CMS-specific
+ * controllers that are only available inside the CMS routing tree.
+ *
+ * Use {@link useCMSContext} to obtain an instance.
+ * @group Hooks and utilities
+ */
+export type CMSContext<DB = Record<string, unknown>, USER extends User = User, AuthControllerType extends AuthController<USER> = AuthController<USER>> = RebaseContext<USER, AuthControllerType> & {
+    sideEntityController: SideEntityController;
+    sideDialogsController: SideDialogsController;
+    urlController: UrlController;
+    navigationStateController: NavigationStateController;
+    collectionRegistryController: CollectionRegistryController<DB>;
+};
+/**
+ * Hook that builds a fully-populated CMS context by combining the
+ * core {@link RebaseContext} with CMS-specific controllers.
+ *
+ * Use this instead of `useRebaseContext()` in CMS components that
+ * need to pass context to entity action callbacks, plugin slots,
+ * or any consumer that expects CMS controllers on the context object.
+ *
+ * @group Hooks and utilities
+ */
+export declare function useCMSContext<DB = Record<string, unknown>, USER extends User = User, AuthControllerType extends AuthController<USER> = AuthController<USER>>(): CMSContext<DB, USER, AuthControllerType>;

package/dist/admin/src/hooks/useEntityHistory.d.ts

@@ -0,0 +1,30 @@
+export interface HistoryEntryData {
+    id: string;
+    table_name: string;
+    entity_id: string;
+    action: "create" | "update" | "delete";
+    changed_fields: string[] | null;
+    values: Record<string, unknown> | null;
+    previous_values: Record<string, unknown> | null;
+    updated_by: string | null;
+    updated_at: string;
+}
+export interface UseEntityHistoryResult {
+    entries: HistoryEntryData[];
+    total: number;
+    isLoading: boolean;
+    hasMore: boolean;
+    error?: Error;
+    loadMore: () => void;
+    revert: (historyId: string) => Promise<Record<string, unknown>>;
+}
+/**
+ * Hook to fetch entity history from the backend REST API.
+ * Replaces the old subcollection-based approach with a proper API call.
+ */
+export declare function useEntityHistory(params: {
+    slug: string;
+    entityId: string | number | undefined;
+    enabled?: boolean;
+    pageSize?: number;
+}): UseEntityHistoryResult;

package/dist/admin/src/hooks/useEntitySelectionDialog.d.ts

@@ -0,0 +1,18 @@
+import { EntitySelectionProps } from "../components";
+/**
+ * This hook is used to open a side dialog that allows the selection
+ * of entities under a given path.
+ * You can use it in custom views for selecting entities.
+ * You need to specify the path of the target collection at least.
+ * If your collection is not defined in your  top collection configuration
+ * (in your `Rebase` component), you need to specify explicitly.
+ * This is the same hook used internally when a reference property is defined.
+ * @group Hooks and utilities
+ */
+export declare function useEntitySelectionDialog<M extends Record<string, unknown>>(referenceDialogProps: Omit<EntitySelectionProps<M>, "path"> & {
+    path?: string | false;
+    onClose?: () => void;
+}): {
+    open: () => void;
+    close: () => void;
+};

package/dist/admin/src/hooks/useResolvedNavigationFrom.d.ts

@@ -0,0 +1,73 @@
+import type { EntityCollection, EntityCustomView } from "@rebasepro/types";
+import { Entity, RebaseContext, User } from "@rebasepro/types";
+/**
+ * @see resolveNavigationFrom
+ * @group Hooks and utilities
+ */
+export type ResolvedNavigationEntry<M extends Record<string, unknown>> = ResolvedNavigationEntity<M> | ResolvedNavigationCollection<M> | ResolvedNavigationEntityCustom<M>;
+/**
+ * @see resolveNavigationFrom
+ * @group Hooks and utilities
+ */
+export interface ResolvedNavigationEntity<M extends Record<string, unknown>> {
+    type: "entity";
+    entity: Entity<M>;
+    entityId: string | number;
+    path: string;
+    parentCollection: EntityCollection<M>;
+}
+/**
+ * @see resolveNavigationFrom
+ * @group Hooks and utilities
+ */
+export interface ResolvedNavigationCollection<M extends Record<string, unknown>> {
+    type: "collection";
+    path: string;
+    collection: EntityCollection<M>;
+}
+/**
+ * @see resolveNavigationFrom
+ * @group Hooks and utilities
+ */
+interface ResolvedNavigationEntityCustom<M extends Record<string, unknown>> {
+    type: "custom_view";
+    path: string;
+    view: EntityCustomView<M>;
+}
+/**
+ * Use this function to retrieve an array of navigation entries (resolved
+ * collection, entity or entity custom_view) for the given path. You need to pass the app context
+ * that you receive in different callbacks, such as the save hooks.
+ *
+ * It will take into account the `navigation` provided at the `Rebase` level.
+ *
+ * @param path
+ * @param context
+ * @group Hooks and utilities
+ */
+export declare function resolveNavigationFrom<M extends Record<string, unknown>, USER extends User>({ path, context }: {
+    path: string;
+    context: RebaseContext<USER>;
+}): Promise<ResolvedNavigationEntry<M>[]>;
+/**
+ * @group Hooks and utilities
+ */
+export interface NavigationFromProps {
+    path: string;
+}
+/**
+ * @group Hooks and utilities
+ */
+export interface NavigationFrom<M extends Record<string, unknown>> {
+    data?: ResolvedNavigationEntry<M>[];
+    dataLoading: boolean;
+    dataLoadingError?: Error;
+}
+/**
+ * Use this hook to retrieve an array of navigation entries (resolved
+ * collection or entity) for the given path. You can use this hook
+ * in any React component that lives under `Rebase`
+ * @group Hooks and utilities
+ */
+export declare function useResolvedNavigationFrom<M extends Record<string, unknown>>({ path }: NavigationFromProps): NavigationFrom<M>;
+export {};

package/dist/admin/src/hooks/useSideDialogsController.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Hook to retrieve the side dialogs' controller.
+ *
+ * This hook allows you to open and close side dialogs. This is the mechanism
+ * used when open a side entity dialog, or when selecting a reference.
+ *
+ * If you want to open a side entity dialog, you can use the {@link useSideEntityController}
+ * hook.
+ *
+ * If you want to select a reference, you can use the {@link useReferenceDialog}
+ *
+ * Consider that in order to use this hook you need to have a parent
+ * `Rebase`
+ *
+ * @group Hooks and utilities
+ */
+import { SideDialogPanelProps, SideDialogsController } from "@rebasepro/types";
+export type { SideDialogPanelProps, SideDialogsController };
+export declare const useSideDialogsController: () => SideDialogsController;

package/dist/admin/src/hooks/useSideEntityController.d.ts

@@ -0,0 +1,11 @@
+import type { SideEntityController } from "@rebasepro/types";
+import React from "react";
+export declare const SideEntityControllerContext: React.Context<SideEntityController>;
+/**
+ * Use this hook to retrieve an entity controller that allows you to open
+ * a side dialog to edit an entity.
+ *
+ * @see SideEntityController
+ * @group Hooks and utilities
+ */
+export declare const useSideEntityController: () => SideEntityController;

package/dist/admin/src/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./types";
+export type { RebaseEditorProps, JSONContent, EditorAIController } from "./editor";
+export * from "./form";
+export * from "./preview";
+export * from "./routes";
+export { EntityView, EntitySelectionTable, SelectableTable, SelectableTableContext, EntityCollectionView, EntityCollectionViewActions, EntityCollectionCardView, EntityCard, useSelectionController, PropertyConfigBadge, PropertyIdCopyTooltip, EntityCollectionTable, EntityCollectionRowActions, VirtualTableInput, ArrayContainer, type ArrayEntryParams, ReferenceWidget, SearchIconsView, FieldCaption, EntityPreview, getFieldConfig, getFieldId, getDefaultFieldConfig, getDefaultFieldId, DEFAULT_FIELD_CONFIGS, editEntityAction, copyEntityAction, deleteEntityAction, resetPasswordAction, SideEntityProvider, Scaffold, AppBar, Drawer, AdminModeSyncer, RebaseCMS, RebaseShell, RebaseAuthGate, RebaseNavigation, RebaseLayout, RebaseRouteDefs, SideDialogs, useApp } from "./components";
+export type { EntityViewProps, EntitySelectionProps, SelectableTableProps } from "./components";
+export * from "./hooks";
+export { addInitialSlash, removeInitialSlash, removeTrailingSlash, removeInitialAndTrailingSlashes, getLastSegment, getCollectionBySlugWithin, getCollectionPathsCombinations, resolveCollectionPathIds, mergeEntityActions, resolveEntityAction, resolveEntityView, isReferenceProperty, isRelationProperty, getIconForWidget, getIconForProperty, getPropertyInPath, getResolvedPropertyInPath, getBracketNotation, getPropertiesWithPropertiesOrder, getDefaultPropertiesOrder, getEntityPreviewKeys, getEntityTitlePropertyKey } from "./util";
+export * from "./data_import";
+export * from "./data_export";
+export * from "./collection_editor";
+export { RolesFilterSelect } from "./components/admin/RolesFilterSelect";
+export { UserRolesSelectField } from "./components/admin/UserRolesSelectField";
+export { CreationResultDialog } from "./components/admin/CreationResultDialog";

package/dist/admin/src/preview/PropertyPreview.d.ts

@@ -0,0 +1,7 @@
+import type { Property } from "@rebasepro/types";
+import React from "react";
+import type { PropertyPreviewProps } from "../types/components/PropertyPreviewProps";
+/**
+ * @group Preview components
+ */
+export declare const PropertyPreview: React.MemoExoticComponent<(<P extends Property>(props: PropertyPreviewProps<P>) => any)>;

package/dist/admin/src/preview/components/ArrayEnumPreview.d.ts

@@ -0,0 +1,11 @@
+import { EnumValueConfig } from "@rebasepro/types";
+import type { PreviewSize } from "../../types/components/PropertyPreviewProps";
+/**
+ * @group Preview components
+ */
+export declare function ArrayEnumPreview({ name, value, enumValues, size }: {
+    value: string[] | number[];
+    name: string | undefined;
+    enumValues: EnumValueConfig[];
+    size: PreviewSize;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/preview/components/BooleanPreview.d.ts

@@ -0,0 +1,11 @@
+import type { Property } from "@rebasepro/types";
+import React from "react";
+import { PreviewSize } from "../../types/components/PropertyPreviewProps";
+/**
+ * @group Preview components
+ */
+export declare function BooleanPreview({ value, size, property }: {
+    value: boolean;
+    size: PreviewSize;
+    property: Property;
+}): React.ReactElement;

package/dist/admin/src/preview/components/DatePreview.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+export interface DatePreviewProps {
+    date: Date;
+    /**
+     * Display mode: "date" for date-only, "date_time" for date and time
+     */
+    mode?: "date" | "date_time";
+    /**
+     * IANA timezone identifier (e.g., "America/New_York")
+     * When specified, the date will be displayed in this timezone
+     */
+    timezone?: string;
+}
+/**
+ * @group Preview components
+ */
+export declare function DatePreview({ date, mode, timezone }: DatePreviewProps): React.ReactElement;

package/dist/admin/src/preview/components/EmptyValue.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @group Preview components
+ */
+export declare function EmptyValue({ className }: {
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/preview/components/EnumValuesChip.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { EnumValues } from "@rebasepro/types";
+export interface EnumValuesChipProps {
+    enumValues?: EnumValues;
+    enumKey: string | number;
+    size: "small" | "medium" | "large";
+    className?: string;
+    children?: React.ReactNode;
+}
+/**
+ * @group Preview components
+ */
+export declare function EnumValuesChip({ enumValues, enumKey, size, className, children }: EnumValuesChipProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/admin/src/preview/components/ImagePreview.d.ts

@@ -0,0 +1,16 @@
+import { PreviewSize } from "../../types/components/PropertyPreviewProps";
+/**
+ * @group Preview components
+ */
+export interface ImagePreviewProps {
+    size: PreviewSize;
+    url: string;
+    /**
+     * If true, image fills its container completely with object-fit cover
+     */
+    fill?: boolean;
+}
+/**
+ * @group Preview components
+ */
+export declare function ImagePreview({ size, url, fill }: ImagePreviewProps): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/preview/components/ReferencePreview.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { EntityReference } from "@rebasepro/types";
+import type { PreviewSize } from "../../types/components/PropertyPreviewProps";
+export type ReferencePreviewProps = {
+    disabled?: boolean;
+    reference: EntityReference;
+    size?: PreviewSize;
+    previewProperties?: string[];
+    onClick?: (e: React.SyntheticEvent) => void;
+    hover?: boolean;
+    includeEntityLink?: boolean;
+    includeId?: boolean;
+};
+/**
+ * @group Preview components
+ */
+export declare const ReferencePreview: (props: ReferencePreviewProps) => import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/preview/components/RelationPreview.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { EntityRelation } from "@rebasepro/types";
+import type { PreviewSize } from "../../types/components/PropertyPreviewProps";
+export type RelationPreviewProps = {
+    disabled?: boolean;
+    relation: EntityRelation;
+    size?: PreviewSize;
+    previewProperties?: string[];
+    onClick?: (e: React.SyntheticEvent) => void;
+    hover?: boolean;
+    includeEntityLink?: boolean;
+    includeId?: boolean;
+};
+/**
+ * @group Preview components
+ */
+export declare const RelationPreview: (props: RelationPreviewProps) => import("react/jsx-runtime").JSX.Element;