@rebasepro/studio 0.0.1-canary.09e5ec5

package/dist/core/src/hooks/useBuildModeController.d.ts

@@ -0,0 +1,6 @@
+import { ModeController } from "./index";
+/**
+ * Use this hook to build a color mode controller that determines
+ * the theme of the CMS
+ */
+export declare function useBuildModeController(): ModeController;

package/dist/core/src/hooks/useClipboard.d.ts

@@ -0,0 +1,57 @@
+import { MutableRefObject } from "react";
+export interface UseClipboardProps {
+    /**
+     * It's callback function that is called after the `copy` command
+     * is executed.
+     *
+     * @param text: The selected clipboard text.
+     */
+    onSuccess?: (text: string) => void;
+    /**
+     * Triggers when the hook encounters an error.
+     * If passed hook won't throw an error.
+     *
+     * @param error: cause of the error
+     */
+    onError?: (error: string) => void;
+    /**
+     * Disables the new clipboard API `navigator.clipboard` even if
+     * it is supported.
+     */
+    disableClipboardAPI?: boolean;
+    /**
+     * revert back the isCopied flag to false again if a value is set.
+     */
+    copiedDuration?: number;
+}
+export interface useClipboardReturnType {
+    /**
+     * Use ref to pull the text content from.
+     */
+    ref: MutableRefObject<any>;
+    /**
+     * Use it to perform the copy operation
+     */
+    copy: (text?: string) => void;
+    /**
+     * Use it to perform the cut operation
+     */
+    cut: () => void;
+    /**
+     * Indicates wheater the content was successfully copied or not.
+     */
+    isCoppied: boolean;
+    /**
+     * Current selected clipboard content.
+     */
+    clipboard: string;
+    /**
+     * Clears the user clipboard.
+     */
+    clearClipboard: () => void;
+    /**
+     * Check to see if the browser supports the new `navigator.clipboard` API.
+     */
+    isSupported: () => boolean;
+}
+export declare const useClipboard: (options?: UseClipboardProps) => useClipboardReturnType;

package/dist/core/src/hooks/useCollapsedGroups.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Custom hook for managing collapsed/expanded state of navigation groups
+ * with localStorage persistence. Automatically cleans up stale group entries
+ * when groups are removed from the navigation.
+ *
+ * @param groupNames - Array of group names to track
+ * @param namespace - Namespace for localStorage key (e.g., "home", "drawer") to allow independent state
+ */
+export declare function useCollapsedGroups(groupNames: string[], namespace?: string): {
+    isGroupCollapsed: (name: string) => boolean;
+    toggleGroupCollapsed: (name: string) => void;
+};

package/dist/core/src/hooks/useCustomizationController.d.ts

@@ -0,0 +1,11 @@
+import type { CustomizationController } from "@rebasepro/types";
+/**
+ * Use this hook to retrieve the customization controller.
+ * This hook includes all the customization options that can be used
+ * to customize the CMS.
+ *
+ * You will likely not need to use this hook directly.
+ *
+ * @group Hooks and utilities
+ */
+export declare const useCustomizationController: () => CustomizationController;

package/dist/core/src/hooks/useDialogsController.d.ts

@@ -0,0 +1,11 @@
+import type { DialogsController } from "@rebasepro/types";
+/**
+ * Use this hook to open a dialog imperatively.
+ * Alternatively, you can use dialogs declaratively using the `Dialog` component.
+ *
+ * Consider that in order to use this hook you need to have a parent
+ * `Rebase`
+ *
+ * @group Hooks and utilities
+ */
+export declare const useDialogsController: () => DialogsController;

package/dist/core/src/hooks/useEffectiveRoleController.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hook to retrieve the {@link EffectiveRoleController}
+ *
+ * @see EffectiveRoleController
+ * @category Hooks and utilities
+ */
+export declare const useEffectiveRoleController: () => import("@rebasepro/types").EffectiveRoleController;

package/dist/core/src/hooks/useInternalUserManagementController.d.ts

@@ -0,0 +1,12 @@
+import { User, UserManagementDelegate } from "@rebasepro/types";
+/**
+ * Use this hook to get the internal user management of the app.
+ * Note that this is different from the user management plugin controller.
+ * This controller will be eventually replaced by the one provided
+ * by the user management plugin.
+ *
+ * Use at your own risk!
+ *
+ * @group Hooks and utilities
+ */
+export declare function useInternalUserManagementController<USER extends User>(): UserManagementDelegate<USER> | undefined;

package/dist/core/src/hooks/useLargeLayout.d.ts

@@ -0,0 +1 @@
+export declare const useLargeLayout: () => boolean;

package/dist/core/src/hooks/useModeController.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Use this controller to change color mode
+ * @group Hooks and utilities
+ */
+export interface ModeController {
+    mode: "light" | "dark";
+    setMode: (mode: "light" | "dark" | "system") => void;
+}
+/**
+ * Hook to retrieve the current mode ("light" | "dark"), and `setMode`
+ * or `toggle` functions to change it.
+ *
+ * Consider that in order to use this hook you need to have a parent
+ * `Rebase`
+ *
+ * @see ModeController
+ * @group Hooks and utilities
+ */
+export declare const useModeController: () => ModeController;

package/dist/core/src/hooks/usePermissions.d.ts

@@ -0,0 +1,12 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { Entity } from "@rebasepro/types";
+/**
+ * Hook to evaluate roles and permissions for the current user.
+ * It abstracts away the need to pass `authController` to permission evaluation functions.
+ */
+export declare function usePermissions(): {
+    canCreate: (collection: EntityCollection<any>, path: string) => boolean;
+    canEdit: (collection: EntityCollection<any>, path: string, entity: Entity<any> | null) => boolean;
+    canDelete: (collection: EntityCollection<any>, path: string, entity: Entity<any> | null) => boolean;
+    canRead: (collection: EntityCollection<any>) => boolean;
+};

package/dist/core/src/hooks/useRebaseClient.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hook to retrieve the full RebaseClient instance from context.
+ * Returns `undefined` if no client was provided to `<Rebase>`.
+ */
+export declare function useRebaseClient<T = any>(): T | undefined;

package/dist/core/src/hooks/useRebaseContext.d.ts

@@ -0,0 +1,11 @@
+import { AuthController, RebaseContext, User } from "@rebasepro/types";
+/**
+ * Hook to retrieve the {@link RebaseContext}.
+ *
+ * Consider that in order to use this hook you need to have a parent
+ * `Rebase` component.
+ *
+ * @see RebaseContext
+ * @group Hooks and utilities
+ */
+export declare const useRebaseContext: <USER extends User = User, AuthControllerType extends AuthController<USER> = AuthController<USER>>() => RebaseContext<USER, AuthControllerType>;

package/dist/core/src/hooks/useRebaseRegistry.d.ts

@@ -0,0 +1,34 @@
+import React from "react";
+import type { RebaseRegistryController, RebaseCMSConfig, RebaseStudioConfig, RebaseAuthConfig } from "@rebasepro/types";
+/**
+ * Split into two contexts to prevent infinite re-render loops:
+ * - DispatchContext: stable register/unregister functions (never changes identity)
+ * - StateContext: the current config values (changes when modules register)
+ *
+ * Feature components (RebaseAuth, RebaseCMS, RebaseStudio) only consume
+ * the dispatch context, so registering does NOT cause them to re-render.
+ * RebaseShell consumes state context to read the collected configs.
+ */
+interface RegistryDispatch {
+    registerCMS: (config: RebaseCMSConfig) => void;
+    unregisterCMS: () => void;
+    registerStudio: (config: RebaseStudioConfig) => void;
+    unregisterStudio: () => void;
+    registerAuth: (config: RebaseAuthConfig) => void;
+    unregisterAuth: () => void;
+}
+export declare function RebaseRegistryProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Returns the full registry (state + dispatch).
+ * Use this in RebaseShell where you need to read configs.
+ */
+export declare function useRebaseRegistry(): RebaseRegistryController;
+/**
+ * Returns only the stable dispatch functions.
+ * Use this in feature components (RebaseAuth, RebaseCMS, RebaseStudio)
+ * to avoid re-render loops.
+ */
+export declare function useRebaseRegistryDispatch(): RegistryDispatch;
+export {};

package/dist/core/src/hooks/useSlot.d.ts

@@ -0,0 +1,18 @@
+import type { SlotName, SlotRegistry } from "@rebasepro/types";
+import React from "react";
+/**
+ * Hook that retrieves and renders all slot contributions for a given slot name.
+ *
+ * @param slot - The slot name to render contributions for.
+ * @param props - Props passed to each slot component.
+ * @returns An array of rendered React nodes, each wrapped in an ErrorBoundary.
+ *
+ * @example
+ * ```tsx
+ * const actions = useSlot("home.actions", { context });
+ * return <div>{actions}</div>;
+ * ```
+ *
+ * @group Hooks
+ */
+export declare function useSlot<K extends SlotName>(slot: K, props: SlotRegistry[K]): React.ReactNode[];

package/dist/core/src/hooks/useSnackbarController.d.ts

@@ -0,0 +1,20 @@
+import type { SnackbarMessageType } from "@rebasepro/types";
+import React from "react";
+/**
+ * Hook to retrieve the SnackbarContext.
+ *
+ * Consider that in order to use this hook you need to have a parent
+ * `Rebase`
+ *
+ * @see SnackbarController
+ * @group Hooks and utilities
+ */
+export declare const useSnackbarController: () => {
+    open: (props: {
+        type: SnackbarMessageType;
+        title?: string;
+        message: React.ReactNode;
+        autoHideDuration?: number;
+    }) => void;
+    close: () => void;
+};

package/dist/core/src/hooks/useStorageSource.d.ts

@@ -0,0 +1,7 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { StorageSource } from "@rebasepro/types";
+/**
+ * Use this hook to get the storage source being used
+ * @group Hooks and utilities
+ */
+export declare const useStorageSource: (collection?: EntityCollection) => StorageSource;

package/dist/core/src/hooks/useStudioBridge.d.ts

@@ -0,0 +1,91 @@
+import React from "react";
+import type { CollectionRegistryController, SideEntityController, UrlController, NavigationStateController } from "@rebasepro/types";
+export interface BreadcrumbEntry {
+    title: string;
+    url: string;
+    count?: number | null;
+    id?: string;
+}
+export interface BreadcrumbsController {
+    breadcrumbs: BreadcrumbEntry[];
+    set: (props: {
+        breadcrumbs: BreadcrumbEntry[];
+    }) => void;
+    updateCount: (id: string, count: number | null | undefined) => void;
+}
+/**
+ * StudioBridge provides optional CMS capabilities to Studio components.
+ * When CMS is present, a bridge provider injects real implementations.
+ * When CMS is absent, noop defaults ensure Studio works standalone.
+ */
+export interface StudioBridge {
+    collectionRegistry: CollectionRegistryController;
+    sideEntityController: SideEntityController;
+    urlController: UrlController;
+    navigationState: NavigationStateController;
+    breadcrumbs: BreadcrumbsController;
+}
+export declare const StudioBridgeContext: React.Context<StudioBridge>;
+/**
+ * Provider that injects CMS capabilities into Studio.
+ * Accepts partial overrides — any field not provided falls back to noop.
+ *
+ * Usage (in app wiring, when CMS is present):
+ * ```tsx
+ * <StudioBridgeProvider value={{
+ *     collectionRegistry: useCollectionRegistryController(),
+ *     sideEntityController: useSideEntityController(),
+ *     urlController: useUrlController(),
+ *     navigationState: useNavigationStateController(),
+ *     breadcrumbs: useBreadcrumbsController(),
+ * }}>
+ *     <RebaseStudio ... />
+ * </StudioBridgeProvider>
+ * ```
+ */
+export declare function StudioBridgeProvider({ value, children }: {
+    value: Partial<StudioBridge>;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/** Collection registry — returns noop if CMS is not present. */
+export declare function useStudioCollectionRegistry(): CollectionRegistryController;
+/** Side entity controller — returns noop if CMS is not present. */
+export declare function useStudioSideEntityController(): SideEntityController;
+/** URL controller — returns noop if CMS is not present. */
+export declare function useStudioUrlController(): UrlController;
+/** Navigation state — returns noop if CMS is not present. */
+export declare function useStudioNavigationState(): NavigationStateController;
+/** Breadcrumbs controller — returns noop if CMS is not present. */
+export declare function useStudioBreadcrumbs(): BreadcrumbsController;
+/**
+ * Registry that controllers use to self-register their implementations
+ * into the Studio bridge. Each controller calls `register(key, value)`
+ * on mount and `unregister(key)` on unmount.
+ */
+export interface StudioBridgeRegistry {
+    register: <K extends keyof StudioBridge>(key: K, value: StudioBridge[K]) => void;
+    unregister: (key: keyof StudioBridge) => void;
+}
+export declare const StudioBridgeRegistryContext: React.Context<StudioBridgeRegistry | null>;
+/**
+ * Provider that creates a self-assembling bridge.
+ *
+ * Mount this above the controller providers. Each controller calls
+ * `useBridgeRegistration(key, value)` to inject its implementation.
+ * The bridge context value is automatically kept in sync.
+ *
+ * ```tsx
+ * <StudioBridgeRegistryProvider>
+ *     <CollectionRegistryProvider>   // auto-registers
+ *     <SideEntityProvider>           // auto-registers
+ *     <UrlProvider>                  // auto-registers
+ *         <RebaseStudio />           // consumes bridge
+ *     </UrlProvider>
+ *     </SideEntityProvider>
+ *     </CollectionRegistryProvider>
+ * </StudioBridgeRegistryProvider>
+ * ```
+ */
+export declare function StudioBridgeRegistryProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/core/src/hooks/useTranslation.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Internal hook for translating Rebase UI strings.
+ *
+ * Uses the `rebase_core` i18next namespace that is initialised by
+ * `RebaseI18nProvider`. Do NOT use `react-i18next` directly in internal
+ * components — always go through this hook so the namespace is consistent.
+ *
+ * @example
+ * const { t } = useTranslation();
+ * <Button>{t("save")}</Button>
+ *
+ * @internal
+ */
+export declare function useTranslation(): {
+    t: (key: string, vars?: Record<string, string>) => string;
+    i18n: import("i18next").i18n;
+};

package/dist/core/src/hooks/useUnsavedChangesDialog.d.ts

@@ -0,0 +1,12 @@
+import { UnsavedChangesDialogProps } from "../components/UnsavedChangesDialog";
+/**
+ * A single, unified hook to prevent navigation when there are unsaved changes.
+ *
+ * It automatically handles:
+ * 1. Internal React Router navigation using `useBlocker`.
+ * 2. External browser navigation (page refresh, tab close) using `beforeunload`.
+ */
+export declare function useUnsavedChangesDialog(when: boolean, onOk: () => void): {
+    dialogProps: UnsavedChangesDialogProps;
+    triggerDialog: () => void;
+};

package/dist/core/src/hooks/useUserConfigurationPersistence.d.ts

@@ -0,0 +1,8 @@
+import { UserConfigurationPersistence } from "@rebasepro/types";
+/**
+ * Use this controller to access the configuration that is stored externally,
+ * and not defined in code
+ *
+ * @group Hooks and utilities
+ */
+export declare const useUserConfigurationPersistence: () => UserConfigurationPersistence | undefined;

package/dist/core/src/hooks/useValidateAuthenticator.d.ts

@@ -0,0 +1,21 @@
+import { AuthController, Authenticator, RebaseData, StorageSource, User } from "@rebasepro/types";
+/**
+ * This hook is used internally for validating an authenticator.
+ *
+ * @param authController
+ * @param authentication
+ * @param storageSource
+ * @param data
+ */
+export declare function useValidateAuthenticator<USER extends User = any>({ disabled, authController, authenticator, storageSource, data }: {
+    disabled?: boolean;
+    authController: AuthController<USER>;
+    authenticator?: boolean | Authenticator<USER>;
+    data: RebaseData;
+    storageSource: StorageSource;
+}): {
+    canAccessMainView: boolean;
+    authLoading: boolean;
+    notAllowedError: any;
+    authVerified: boolean;
+};

package/dist/core/src/i18n/RebaseI18nProvider.d.ts

@@ -0,0 +1,33 @@
+import { PropsWithChildren } from "react";
+import { RebaseTranslations } from "@rebasepro/types";
+export declare const REBASE_LOCALE_STORAGE_KEY = "rebase_locale";
+/** DeepPartial helper — allows partial overrides at any nesting level */
+type DeepPartial<T> = T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+export interface RebaseI18nProviderProps {
+    /** BCP-47 locale tag, e.g. "en", "es", "fr". Defaults to "en". */
+    locale?: string;
+    /**
+     * Override or extend any Rebase UI string, keyed by locale.
+     *
+     * @example
+     * translations={{
+     *   en: { save: "Publish" },
+     *   es: { save: "Publicar", discard: "Descartar" }
+     * }}
+     */
+    translations?: {
+        [locale: string]: DeepPartial<RebaseTranslations>;
+    };
+}
+/**
+ * Initialises a dedicated i18next instance for Rebase's internal UI strings.
+ *
+ * This instance is isolated from any app-level i18next configuration the
+ * consumer may have. Mount this at the top of the Rebase component tree.
+ *
+ * @internal
+ */
+export declare function RebaseI18nProvider({ locale, translations, children }: PropsWithChildren<RebaseI18nProviderProps>): import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,15 @@
+export * from "./core";
+export * from "./hooks";
+export * from "./components";
+export * from "./util";
+export * from "./contexts";
+export * from "./internal/common";
+export * from "./internal/useRestoreScroll";
+export { useUnsavedChangesDialog } from "./hooks/useUnsavedChangesDialog";
+export type { UnsavedChangesDialogProps } from "./components/UnsavedChangesDialog";
+export { UnsavedChangesDialog } from "./components/UnsavedChangesDialog";
+export * from "./i18n/RebaseI18nProvider";
+export * from "./locales/en";
+export * from "./locales/es";
+export * from "./hooks/useStudioBridge";
+export { useBridgeRegistration } from "./hooks/useBridgeRegistration";

package/dist/core/src/internal/common.d.ts

@@ -0,0 +1,3 @@
+export declare const CONTAINER_FULL_WIDTH = "100vw";
+export declare const ADDITIONAL_TAB_WIDTH = "55vw";
+export declare const FORM_CONTAINER_WIDTH = "768px";

package/dist/core/src/internal/useRestoreScroll.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+export declare function useRestoreScroll(): {
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    scroll: number;
+    direction: "up" | "down";
+};

package/dist/core/src/locales/de.d.ts

@@ -0,0 +1,2 @@
+import { RebaseTranslations } from "@rebasepro/types";
+export declare const de: RebaseTranslations;

package/dist/core/src/locales/en.d.ts

@@ -0,0 +1,10 @@
+import { RebaseTranslations } from "@rebasepro/types";
+/**
+ * English baseline translations for @rebasepro/core.
+ *
+ * This is the single source of truth for all default UI strings.
+ * Override any key via the `translations` prop on Rebase entry-point components.
+ *
+ * @group Core
+ */
+export declare const en: RebaseTranslations;

package/dist/core/src/locales/es.d.ts

@@ -0,0 +1,10 @@
+import { RebaseTranslations } from "@rebasepro/types";
+/**
+ * Spanish baseline translations for @rebasepro/core.
+ *
+ * This is the single source of truth for all default UI strings in Spanish.
+ * Override any key via the `translations` prop on Rebase entry-point components.
+ *
+ * @group Core
+ */
+export declare const es: RebaseTranslations;

package/dist/core/src/locales/fr.d.ts

@@ -0,0 +1,2 @@
+import { RebaseTranslations } from "@rebasepro/types";
+export declare const fr: RebaseTranslations;

package/dist/core/src/locales/hi.d.ts

@@ -0,0 +1,2 @@
+import { RebaseTranslations } from "@rebasepro/types";
+export declare const hi: RebaseTranslations;

package/dist/core/src/locales/it.d.ts

@@ -0,0 +1,2 @@
+import { RebaseTranslations } from "@rebasepro/types";
+export declare const it: RebaseTranslations;

package/dist/core/src/locales/pt.d.ts

@@ -0,0 +1,7 @@
+import { RebaseTranslations } from "@rebasepro/types";
+/**
+ * Portuguese (pt) translations for @rebasepro/core.
+ *
+ * @group Core
+ */
+export declare const pt: RebaseTranslations;

package/dist/core/src/util/constants.d.ts

@@ -0,0 +1 @@
+export declare const STUDIO_NAVIGATION_GROUPS: string[];

package/dist/core/src/util/createFormexStub.d.ts

@@ -0,0 +1,2 @@
+import { FormexController } from "@rebasepro/formex";
+export declare function createFormexStub<T extends object>(values: T): FormexController<T>;

package/dist/core/src/util/entity_cache.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Saves data to the in-memory cache and persists it individually in `sessionStorage`.
+ * @param path - The unique path/key for the data.
+ * @param data - The data to cache and persist.
+ */
+export declare function saveEntityToCache(path: string, data: object): void;
+export declare function removeEntityFromMemoryCache(path: string): void;
+export declare function saveEntityToMemoryCache(path: string, data: object): void;
+export declare function getEntityFromMemoryCache(path: string): object | undefined;
+export declare function hasEntityInCache(path: string): boolean;
+/**
+ * Retrieves an entity from the in-memory cache or `sessionStorage`.
+ * If the entity is not in the cache but exists in `sessionStorage`, it loads it into the cache.
+ * @param path - The unique path/key for the entity.
+ * @returns The cached entity or `undefined` if not found.
+ */
+export declare function getEntityFromCache(path: string): object | undefined;
+/**
+ * Removes an entity from both the in-memory cache and `sessionStorage`.
+ * @param path - The unique path/key for the entity to remove.
+ */
+export declare function removeEntityFromCache(path: string): void;
+/**
+ * Clears the entire in-memory cache and removes all related entities from `sessionStorage`.
+ */
+export declare function clearEntityCache(): void;
+export declare function flattenKeys(obj: Record<string, unknown> | unknown[], prefix?: string, result?: string[]): string[];

package/dist/core/src/util/enums.d.ts

@@ -0,0 +1,5 @@
+import { EnumValueConfig } from "@rebasepro/types";
+import { ChipColorScheme } from "@rebasepro/ui";
+export declare function getColorScheme(enumValues: EnumValueConfig[], key: string | number): ChipColorScheme | undefined;
+export declare function isEnumValueDisabled(labelOrConfig?: string | EnumValueConfig): boolean | undefined;
+export declare function buildEnumLabel(labelOrConfig?: string | EnumValueConfig): string | undefined;

package/dist/core/src/util/icon_list.d.ts

@@ -0,0 +1,5 @@
+import Fuse from "fuse.js";
+export declare const iconsSearch: Fuse<{
+    key: string;
+    synonyms: string;
+}>;

package/dist/core/src/util/icon_synonyms.d.ts

@@ -0,0 +1 @@
+export declare const iconSynonyms: Record<string, string>;

package/dist/core/src/util/icons.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import { IconColor } from "@rebasepro/ui";
+/**
+ * Render an icon element from a string key or existing React element.
+ * This resolves the icon from the lucide-react icons map directly.
+ */
+export declare function getIcon(iconKey?: string | React.ReactNode, className?: string, color?: IconColor, size?: "smallest" | "small" | "medium" | "large" | number): React.ReactElement | undefined;
+export type IconViewProps = {
+    slug: string;
+    name: string;
+    singularName?: string;
+    group?: string;
+    icon?: string | React.ReactNode;
+};
+export declare const IconForView: React.NamedExoticComponent<{
+    collectionOrView?: IconViewProps;
+    color?: IconColor;
+    className?: string;
+    size?: "smallest" | "small" | "medium" | "large" | number;
+}>;

package/dist/core/src/util/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./icon_list";
+export * from "./icon_synonyms";
+export * from "./icons";
+export * from "./createFormexStub";
+export * from "./entity_cache";
+export * from "./useStorageUploadController";
+export * from "./useTraceUpdate";
+export * from "./previews";
+export * from "./enums";
+export * from "./constants";

package/dist/core/src/util/previews.d.ts

@@ -0,0 +1,4 @@
+import type { EntityCollection, PropertyConfig } from "@rebasepro/types";
+import { AuthController } from "@rebasepro/types";
+export declare function getEntityPreviewKeys(authController: AuthController, targetCollection: EntityCollection<any>, fields: Record<string, PropertyConfig>, previewProperties?: string[], limit?: number): string[];
+export declare function getEntityTitlePropertyKey<M extends Record<string, any>>(collection: EntityCollection<M>, propertyConfigs: Record<string, PropertyConfig>): string | undefined;