@rebasepro/plugin-insights 0.0.1-canary.09e5ec5

package/dist/core/src/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/core/src/components/UnsavedChangesDialog.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+export interface UnsavedChangesDialogProps {
+    open: boolean;
+    body?: React.ReactNode;
+    title?: string;
+    handleOk: () => void;
+    handleCancel: () => void;
+}
+export declare function UnsavedChangesDialog({ open, handleOk, handleCancel, body, title }: UnsavedChangesDialogProps): import("react/jsx-runtime").JSX.Element;

package/dist/core/src/components/UserDisplay.d.ts

@@ -0,0 +1,7 @@
+import { User } from "@rebasepro/types";
+/**
+ * Component to render a single user with name and email
+ */
+export declare function UserDisplay({ user }: {
+    user: User | null;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/core/src/components/UserSelectPopover.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Represents a selectable user item with optional role information.
+ */
+export interface SelectableUser {
+    uid: string;
+    displayName?: string | null;
+    email?: string | null;
+    photoURL?: string | null;
+    roles?: string[];
+}
+export interface UserSelectPopoverProps {
+    /**
+     * The currently selected user, or `null` for "self"/default.
+     */
+    selectedUser: SelectableUser | null;
+    /**
+     * Called when the user selection changes.
+     * `null` means "reset to self/default".
+     */
+    onUserSelected: (user: SelectableUser | null) => void;
+    /**
+     * Full list of users to display.
+     * The component handles client-side search/filter internally.
+     */
+    users: SelectableUser[];
+    /**
+     * Whether users are currently loading.
+     */
+    loading?: boolean;
+    /**
+     * The current user (displayed as the "self" option at the top).
+     */
+    currentUser?: SelectableUser | null;
+    /**
+     * Label to display when no user is selected.
+     * @default "Current user"
+     */
+    defaultLabel?: string;
+    /**
+     * Maximum number of users to render at a time (for performance).
+     * Users can still be found via search.
+     * @default 100
+     */
+    renderLimit?: number;
+    /**
+     * Additional class name for the trigger button.
+     */
+    className?: string;
+    /**
+     * Size variant.
+     * @default "small"
+     */
+    size?: "small" | "medium";
+}
+/**
+ * A reusable user picker popover with search support.
+ * Designed to handle very large user lists (100k+) by filtering
+ * client-side and limiting the rendered set.
+ *
+ * @group Components
+ */
+export declare function UserSelectPopover({ selectedUser, onUserSelected, users, loading, currentUser, defaultLabel, renderLimit, className, size }: UserSelectPopoverProps): import("react/jsx-runtime").JSX.Element;

package/dist/core/src/components/UserSettingsView.d.ts

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

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

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./useDebouncedData";
+export * from "./useColumnsIds";
+export * from "./useDataTableController";
+export * from "./useScrollRestoration";
+export * from "./table_height";

package/dist/core/src/components/common/table_height.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @group Components
+ */
+export type TableSize = "xs" | "s" | "m" | "l" | "xl";
+export declare function getRowHeight(size: TableSize): number;

package/dist/core/src/components/common/types.d.ts

@@ -0,0 +1,63 @@
+import type { Property } from "@rebasepro/types";
+import { CollectionSize, SelectedCellProps } from "@rebasepro/types";
+export type EntityCollectionTableController<M extends Record<string, any>> = {
+    /**
+     * This cell is displayed as selected
+     */
+    selectedCell?: SelectedCellProps<any>;
+    /**
+     * Store used to sync selection state across cells efficiently.
+     */
+    selectionStore?: any;
+    /**
+     * Select a table cell
+     * @param cell
+     */
+    select: (cell?: SelectedCellProps<M>) => void;
+    /**
+     * The cell that is displayed as a popup view.
+     * @param cell
+     */
+    setPopupCell?: (cell?: SelectedCellProps<M>) => void;
+    /**
+     * Callback used when the value of a cell has changed.
+     * @param params
+     */
+    onValueChange?: (params: OnCellValueChangeParams<any, M>) => void;
+    /**
+     * Size of the elements in the collection
+     */
+    size: CollectionSize;
+};
+/**
+ * Props passed in a callback when the content of a cell in a table has been edited
+ * @group Collection components
+ */
+export interface OnCellValueChangeParams<T = any, D = any> {
+    value: T;
+    propertyKey: string;
+    data?: D;
+    onValueUpdated: () => void;
+    setError: (e: Error | undefined) => void;
+}
+/**
+ * @group Collection components
+ */
+export type UniqueFieldValidator = (props: {
+    name: string;
+    value: any;
+    property: Property;
+    entityId?: string | number;
+}) => Promise<boolean>;
+/**
+ * Callback when a cell has changed in a table
+ * @group Collection components
+ */
+export type OnCellValueChange<T, M extends Record<string, any>> = (params: OnCellValueChangeParams<T, M>) => Promise<void> | void;
+/**
+ * @group Collection components
+ */
+export type OnColumnResizeParams = {
+    width: number;
+    key: string;
+};

package/dist/core/src/components/common/useColumnsIds.d.ts

@@ -0,0 +1,9 @@
+import type { EntityCollection, Property } from "@rebasepro/types";
+export type PropertyColumnConfig = {
+    key: string;
+    disabled: boolean;
+};
+export declare function getSubcollectionColumnId(collection: EntityCollection<any>): string;
+export declare function useColumnIds<M extends Record<string, any>>(collection: EntityCollection<M>, includeSubcollections: boolean): PropertyColumnConfig[];
+export declare function getColumnKeysForProperty(property: Property, key: string, disabled?: boolean): PropertyColumnConfig[];
+export declare function getFormFieldKeys(collection: EntityCollection): string[];

package/dist/core/src/components/common/useDataTableController.d.ts

@@ -0,0 +1,45 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { Entity, EntityTableController, FilterValues, User } from "@rebasepro/types";
+import { ScrollRestorationController } from "./useScrollRestoration";
+export declare const DEFAULT_PAGE_SIZE = 50;
+export type DataTableControllerProps<M extends Record<string, any> = any> = {
+    /**
+     * Full path where the data of this table is located
+     */
+    path: string;
+    /**
+     * The collection that is represented by this config.
+     */
+    collection: EntityCollection<M>;
+    /**
+     * List of entities that will be displayed on top, no matter the ordering.
+     * This is used for reference fields selection
+     */
+    entitiesDisplayedFirst?: Entity<M>[];
+    lastDeleteTimestamp?: number;
+    /**
+     * Force filter to be applied to the table.
+     */
+    forceFilter?: FilterValues<string>;
+    scrollRestoration?: ScrollRestorationController;
+    /**
+     * When set to true the filters and sort will be updated in the URL
+     */
+    updateUrl?: boolean;
+};
+/**
+ * Use this hook to build a controller for the {@link EntityCollectionTable}.
+ * This controller is bound to data in a path in your specified driver.
+ *
+ * Note that you can build your own hook returning a {@link EntityTableController}
+ * if you would like to display different data.
+ *
+ * @param path
+ * @param collection
+ * @param scrollRestoration
+ * @param entitiesDisplayedFirst
+ * @param lastDeleteTimestamp
+ * @param forceFilterFromProps
+ * @param updateUrl
+ */
+export declare function useDataTableController<M extends Record<string, any> = any, USER extends User = User>({ path, collection, scrollRestoration, entitiesDisplayedFirst, lastDeleteTimestamp: _lastDeleteTimestamp, forceFilter: forceFilterFromProps, updateUrl }: DataTableControllerProps<M>): EntityTableController<M>;

package/dist/core/src/components/common/useDebouncedData.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hack to prevent data updates for incomplete callbacks from Firestore
+ * triggers.
+ * If any deps change, the update is immediate
+ * @param data
+ * @param deps
+ * @param timeoutMs
+ */
+export declare function useDebouncedData<T>(data: T[], deps: any, timeoutMs?: number): T[];

package/dist/core/src/components/common/useScrollRestoration.d.ts

@@ -0,0 +1,14 @@
+import { Entity, FilterValues } from "@rebasepro/types";
+export type ScrollRestorationController = {
+    getCollectionScroll: (path: string, filters?: FilterValues<any>) => {
+        scrollOffset: number;
+        data: Entity<any>[];
+    } | undefined;
+    updateCollectionScroll: (props: {
+        path: string;
+        scrollOffset: number;
+        filters?: FilterValues<any>;
+        data: Entity<any>[];
+    }) => void;
+};
+export declare function useScrollRestoration(): ScrollRestorationController;

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

@@ -0,0 +1,16 @@
+export type { ErrorViewProps } from "./ErrorView";
+export { ErrorView } from "./ErrorView";
+export * from "./common";
+export * from "./NotFoundPage";
+export * from "./ConfirmationDialog";
+export * from "./ErrorTooltip";
+export * from "./RebaseLogo";
+export * from "./AIIcon";
+export * from "./Debug/UIStyleGuide";
+export * from "./Debug/UIReferenceView";
+export * from "./UserSettingsView";
+export * from "./LanguageToggle";
+export * from "./UserSelectPopover";
+export * from "./UserDisplay";
+export * from "./LoginView";
+export * from "./RebaseAuth";

package/dist/core/src/contexts/AdminModeController.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { AdminModeController } from "../hooks";
+export declare const AdminModeControllerContext: React.Context<AdminModeController>;
+export declare const AdminModeControllerProvider: React.Provider<AdminModeController>;

package/dist/core/src/contexts/AnalyticsContext.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { AnalyticsController } from "@rebasepro/types";
+export declare const AnalyticsContext: React.Context<AnalyticsController>;

package/dist/core/src/contexts/AuthControllerContext.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { AuthController } from "@rebasepro/types";
+export declare const AuthControllerContext: React.Context<AuthController<any, any>>;

package/dist/core/src/contexts/CustomizationControllerContext.d.ts

@@ -0,0 +1,3 @@
+import type { CustomizationController } from "@rebasepro/types";
+import React from "react";
+export declare const CustomizationControllerContext: React.Context<CustomizationController>;

package/dist/core/src/contexts/DataDriverContext.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { DataDriver } from "@rebasepro/types";
+export declare const DataDriverContext: React.Context<DataDriver>;

package/dist/core/src/contexts/DatabaseAdminContext.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { DatabaseAdmin } from "@rebasepro/types";
+export declare const DatabaseAdminContext: React.Context<DatabaseAdmin | undefined>;

package/dist/core/src/contexts/DialogsProvider.d.ts

@@ -0,0 +1,4 @@
+import type { DialogsController } from "@rebasepro/types";
+import React, { PropsWithChildren } from "react";
+export declare const DialogsControllerContext: React.Context<DialogsController>;
+export declare const DialogsProvider: React.FC<PropsWithChildren>;

package/dist/core/src/contexts/EffectiveRoleController.d.ts

@@ -0,0 +1,4 @@
+import type { EffectiveRoleController } from "@rebasepro/types";
+import React from "react";
+export declare const EffectiveRoleControllerContext: React.Context<EffectiveRoleController>;
+export declare const EffectiveRoleControllerProvider: React.Provider<EffectiveRoleController>;

package/dist/core/src/contexts/InternalUserManagementContext.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { UserManagementDelegate } from "@rebasepro/types";
+export declare const InternalUserManagementContext: React.Context<UserManagementDelegate<any> | undefined>;

package/dist/core/src/contexts/ModeController.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { ModeController } from "../hooks";
+export declare const ModeControllerContext: React.Context<ModeController>;
+export declare const ModeControllerProvider: React.Provider<ModeController>;

package/dist/core/src/contexts/RebaseClientInstanceContext.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+/**
+ * Context that exposes the full RebaseClient instance (from `@rebasepro/client`).
+ * Used by the JS Editor to give developer scripts access to `client.data`, `client.auth`, etc.
+ */
+export declare const RebaseClientInstanceContext: React.Context<any>;

package/dist/core/src/contexts/RebaseDataContext.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { RebaseData } from "@rebasepro/types";
+export declare const RebaseDataContext: React.Context<RebaseData>;

package/dist/core/src/contexts/SnackbarProvider.d.ts

@@ -0,0 +1,2 @@
+import React, { PropsWithChildren } from "react";
+export declare const SnackbarProvider: React.FC<PropsWithChildren<{}>>;

package/dist/core/src/contexts/StorageSourceContext.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { StorageSource } from "@rebasepro/types";
+export declare const StorageSourceContext: React.Context<StorageSource>;

package/dist/core/src/contexts/UserConfigurationPersistenceContext.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { UserConfigurationPersistence } from "@rebasepro/types";
+export declare const UserConfigurationPersistenceContext: React.Context<UserConfigurationPersistence | undefined>;

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

@@ -0,0 +1,13 @@
+export * from "./SnackbarProvider";
+export * from "./ModeController";
+export * from "./AdminModeController";
+export * from "./EffectiveRoleController";
+export * from "./AuthControllerContext";
+export * from "./DataDriverContext";
+export * from "./AnalyticsContext";
+export * from "./StorageSourceContext";
+export * from "./UserConfigurationPersistenceContext";
+export * from "./DialogsProvider";
+export * from "./InternalUserManagementContext";
+export * from "./RebaseClientInstanceContext";
+export * from "./CustomizationControllerContext";

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

@@ -0,0 +1,17 @@
+import type { RebasePlugin, RebaseContext } from "@rebasepro/types";
+/**
+ * Render-less component that manages plugin lifecycle hooks.
+ *
+ * - Calls `lifecycle.onMount(context)` when plugins mount.
+ * - Calls `lifecycle.onUnmount()` when plugins unmount.
+ * - Subscribes to auth state changes and calls `lifecycle.onAuthStateChange`.
+ *
+ * Mount this component inside the Rebase tree, below PluginProviderStack,
+ * so that the RebaseContext is fully available.
+ *
+ * @internal
+ */
+export declare function PluginLifecycleManager({ plugins, context }: {
+    plugins: RebasePlugin[];
+    context: RebaseContext;
+}): null;

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

@@ -0,0 +1,21 @@
+import type { RebasePlugin } from "@rebasepro/types";
+import React from "react";
+/**
+ * Wraps children with all provider components from plugins that match the given scope.
+ *
+ * Replaces the 3 copy-pasted `plugins.forEach(plugin => { if (plugin.form?.provider) ... })` patterns
+ * in Rebase.tsx, EntityEditView.tsx, and PopupFormField.tsx.
+ *
+ * @param plugins - Array of plugins to extract providers from.
+ * @param scope - `"root"` or `"form"` — which providers to apply.
+ * @param scopeProps - Additional props passed to each provider component.
+ * @param children - The content to wrap.
+ *
+ * @group Core
+ */
+export declare function PluginProviderStack({ plugins, scope, scopeProps, children }: {
+    plugins: RebasePlugin[];
+    scope: "root" | "form";
+    scopeProps?: Record<string, unknown>;
+    children: React.ReactNode;
+}): React.ReactNode;

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

@@ -0,0 +1,14 @@
+import type { RebaseProps } from "./RebaseProps";
+import { User } from "@rebasepro/types";
+/**
+ * If you are using independent components of the CMS
+ * you need to wrap them with this main component, so the internal hooks work.
+ *
+ * This is the main component of Rebase. It acts as the provider of all the
+ * internal contexts and hooks.
+ *
+ * You only need to use this component if you are building a custom app.
+ *
+ * @group Core
+ */
+export declare function Rebase<USER extends User>(props: RebaseProps<USER>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,136 @@
+import React from "react";
+import { Locale, User, AuthController, AnalyticsEvent, DataDriver, StorageSource, UserConfigurationPersistence, DatabaseAdmin, RebaseData, RebaseClient, RebaseContext, UserManagementDelegate, EntityLinkBuilder, RebasePlugin, SlotContribution, PropertyConfig, EntityCustomView, EntityAction } from "@rebasepro/types";
+/**
+ * Controller to simulate different roles when dev mode is active.
+ * @group Models
+ */
+export interface EffectiveRoleController {
+    effectiveRole: string | null;
+    setEffectiveRole: (role: string | null) => void;
+}
+/**
+ * @group Models
+ */
+export type RebaseProps<USER extends User> = {
+    /**
+     * The root components of your application. Use RebaseCMS, RebaseStudio, and RebaseShell.
+     * Alternatively, pass a render function that receives { context, loading }.
+     */
+    children: React.ReactNode | ((props: {
+        context: RebaseContext;
+        loading: boolean;
+    }) => React.ReactNode);
+    /**
+     * Optional base path for the entire Rebase app.
+     * Defaults to "/"
+     */
+    basePath?: string;
+    /**
+     * Optional base path for the CMS collections.
+     * Defaults to "/c"
+     */
+    baseCollectionPath?: string;
+    /**
+     * If you have a custom API key, you can use it here.
+     */
+    apiKey?: string;
+    /**
+     * Base URL for the backend API (e.g. "http://localhost:3001").
+     * When provided, this is available via `useApiConfig()` to any hook
+     * in the tree, reducing repetitive `apiUrl` threading.
+     */
+    apiUrl?: string;
+    /**
+     * Format of the dates in the CMS.
+     * Defaults to 'MMMM dd, yyyy, HH:mm:ss'
+     */
+    dateTimeFormat?: string;
+    /**
+     * Locale of the CMS, currently only affecting dates
+     */
+    locale?: Locale;
+    /**
+     * Unified RebaseClient for data, auth, and storage.
+     */
+    client?: RebaseClient;
+    /**
+     * Optional override for RebaseData if not using `client`
+     */
+    data?: RebaseData;
+    /**
+     * Optional override for DataDriver if not using `client`
+     */
+    driver?: DataDriver;
+    /**
+     * Optional override for AuthController if not using `client`
+     */
+    authController?: AuthController<USER>;
+    /**
+     * Optional override for StorageSource if not using `client`
+     */
+    storageSource?: StorageSource;
+    /**
+     * Administrative database operations (SQL, schema discovery).
+     * Only needed when the studio/admin features are enabled.
+     */
+    databaseAdmin?: DatabaseAdmin;
+    /**
+     * Use this controller to access the configuration that is stored locally,
+     * and not defined in code
+     */
+    userConfigPersistence?: UserConfigurationPersistence;
+    /**
+     * Callback used to get analytics events from the CMS
+     */
+    onAnalyticsEvent?: (event: AnalyticsEvent, data?: object) => void;
+    /**
+     * Optional link builder you can add to generate a button in your entity forms.
+     * The function must return a URL that gets opened when the button is clicked
+     */
+    entityLinkBuilder?: EntityLinkBuilder;
+    /**
+     * You can use this props to provide your own user management implementation.
+     * Note that this will not affect the UI, but it will be used to show user information
+     * in various places of the CMS, for example, to show who created or modified an entity,
+     * or to assign ownership of an entity.
+     *
+     * You can also use this data to be retrieved in your custom properties,
+     * for example, to show a list of users in a dropdown.
+     *
+     * If you are using the Rebase user management plugin, this
+     * prop will be implemented automatically.
+     */
+    userManagement?: UserManagementDelegate<USER>;
+    /**
+     * Plugins loaded in the CMS
+     */
+    plugins?: RebasePlugin[];
+    /**
+     * Extra slots for the CMS
+     */
+    slots?: SlotContribution[];
+    /**
+     * Property configs (widgets)
+     */
+    propertyConfigs?: Record<string, PropertyConfig>;
+    /**
+     * Entity Views
+     */
+    entityViews?: EntityCustomView<any>[];
+    /**
+     * Entity Actions
+     */
+    entityActions?: EntityAction[];
+    components?: {
+        /**
+         * Component to render when a reference is missing
+         */
+        missingReference?: React.ComponentType<{
+            path: string;
+        }>;
+    };
+    /**
+     * Controller to simulate different roles when dev mode is active.
+     */
+    effectiveRoleController?: EffectiveRoleController;
+};

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

@@ -0,0 +1,4 @@
+export declare function RebaseRouter({ children, basePath }: {
+    children: any;
+    basePath?: string;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,17 @@
+import React from "react";
+/**
+ * A drop-in replacement for react-router's `<Routes>` that preserves the
+ * underlying view when a side dialog navigates the URL to a different path.
+ *
+ * When opening a side dialog from e.g. `/posts` to `authors/123#side`,
+ * the `base_location` stored in router state is used so the route tree
+ * keeps rendering the original `/posts` view underneath the dialog overlay.
+ *
+ * Additionally, registered views from `useNavigationStateController()` are
+ * automatically routed — no need to manually map them to `<Route>` elements.
+ * Views with `nestedRoutes: true` get a wildcard route (slug/*) as well.
+ * Explicitly declared `children` routes take priority.
+ */
+export declare function RebaseRoutes({ children }: {
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,4 @@
+export * from "./Rebase";
+export * from "./PluginProviderStack";
+export * from "./RebaseRouter";
+export * from "./RebaseRoutes";

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

@@ -0,0 +1,24 @@
+import React from "react";
+/**
+ * Configuration for API connectivity. Passed once at the top level
+ * and available to any hook that needs `apiUrl` or `getAuthToken`.
+ *
+ * Individual hooks can still accept explicit overrides — this context
+ * serves as a fallback to eliminate repetitive threading.
+ */
+export interface ApiConfig {
+    apiUrl: string;
+    getAuthToken?: () => Promise<string | null>;
+}
+/**
+ * Read the API config from context. Returns `undefined` if no provider is present,
+ * allowing hooks to fall back to their own props.
+ */
+export declare function useApiConfig(): ApiConfig | undefined;
+/**
+ * Provide API configuration (apiUrl, getAuthToken) to the entire subtree.
+ * Typically rendered inside `<Rebase>` or at the app root.
+ */
+export declare function ApiConfigProvider({ apiUrl, getAuthToken, children }: ApiConfig & {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/core/src/hooks/data/delete.d.ts

@@ -0,0 +1,31 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { DeleteEntityProps, Entity, EntityCallbacks, RebaseContext, User } from "@rebasepro/types";
+import { RebaseData } from "@rebasepro/types";
+/**
+ * @group Hooks and utilities
+ */
+export type DeleteEntityWithCallbacksProps<M extends Record<string, any>, USER extends User = User> = DeleteEntityProps<M> & {
+    callbacks?: EntityCallbacks<M, USER>;
+    onDeleteSuccess?: (entity: Entity<M>) => void;
+    onDeleteFailure?: (entity: Entity<M>, e: Error) => void;
+};
+/**
+ * This function is in charge of deleting an entity.
+ * It will run all the delete callbacks specified in the collection.
+ * It is also possible to attach callbacks on save success or error, and callback
+ * errors.
+ *
+ * @param data
+ * @param entity
+ * @param collection
+ * @param callbacks
+ * @param onDeleteSuccess
+ * @param onDeleteFailure
+ * @param context
+ * @group Hooks and utilities
+ */
+export declare function deleteEntityWithCallbacks<M extends Record<string, any>, USER extends User>({ data, entity, collection, callbacks, onDeleteSuccess, onDeleteFailure, context }: DeleteEntityWithCallbacksProps<M> & {
+    collection: EntityCollection<M>;
+    data: RebaseData;
+    context: RebaseContext<USER>;
+}): Promise<boolean>;