@rebasepro/plugin-insights 0.0.1-canary.4f204c2

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

@@ -0,0 +1,34 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { Entity, RebaseContext, SaveEntityProps } from "@rebasepro/types";
+import { RebaseData } from "@rebasepro/types";
+/**
+ * @group Hooks and utilities
+ */
+export type SaveEntityWithCallbacksProps<M extends Record<string, any>> = SaveEntityProps<M> & {
+    afterSave?: (updatedEntity: Entity<M>) => void;
+    afterSaveError?: (e: Error) => void;
+};
+/**
+ * This function is in charge of saving an entity.
+ * It will run all the save callbacks specified in the collection.
+ * It is also possible to attach callbacks on save success or error, and callback
+ * errors.
+ *
+ * @param collection
+ * @param path
+ * @param entityId
+ * @param callbacks
+ * @param values
+ * @param previousValues
+ * @param status
+ * @param data
+ * @param context
+ * @param afterSave
+ * @param afterSaveError
+ * @group Hooks and utilities
+ */
+export declare function saveEntityWithCallbacks<M extends Record<string, any>>({ collection, path, entityId, values, previousValues, status, data, context, afterSave, afterSaveError }: SaveEntityWithCallbacksProps<M> & {
+    collection: EntityCollection;
+    data: RebaseData;
+    context: RebaseContext;
+}): Promise<Entity<M>>;

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

@@ -0,0 +1,51 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { Entity, FilterValues, User } from "@rebasepro/types";
+/**
+ * @group Hooks and utilities
+ */
+export interface CollectionFetchProps<M extends Record<string, any>> {
+    /**
+     * Absolute collection path
+     */
+    path: string;
+    /**
+     * collection of the entity displayed by this collection
+     */
+    collection: EntityCollection<M>;
+    /**
+     * Number of entities to fetch
+     */
+    itemCount?: number;
+    /**
+     * Filter the fetched data by the property
+     */
+    filterValues?: FilterValues<Extract<keyof M, string>>;
+    /**
+     * Sort the results by
+     */
+    sortBy?: [Extract<keyof M, string>, "asc" | "desc"];
+    /**
+     * Search string
+     */
+    searchString?: string;
+}
+/**
+ * @group Hooks and utilities
+ */
+export interface CollectionFetchResult<M extends Record<string, any>> {
+    data: Entity<M>[];
+    dataLoading: boolean;
+    noMoreToLoad: boolean;
+    dataLoadingError?: Error;
+}
+/**
+ * This hook is used to fetch collections using a given collection
+ * @param path
+ * @param collection
+ * @param filterValues
+ * @param sortBy
+ * @param itemCount
+ * @param searchString
+ * @group Hooks and utilities
+ */
+export declare function useCollectionFetch<M extends Record<string, any>, USER extends User>({ path, collection, filterValues, sortBy, itemCount, searchString }: CollectionFetchProps<M>): CollectionFetchResult<M>;

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

@@ -0,0 +1,13 @@
+import { RebaseData } from "@rebasepro/types";
+/**
+ * Use this hook to access the unified data API.
+ *
+ * ```ts
+ * const data = useData();
+ * const { data: products } = await data.products.find({ where: { status: "eq.published" } });
+ * await data.products.create({ name: "Camera", price: 299 });
+ * ```
+ *
+ * @group Hooks and utilities
+ */
+export declare const useData: () => RebaseData;

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

@@ -0,0 +1,12 @@
+import { Entity } from "@rebasepro/types";
+export interface DataOrderProps<M extends Record<string, any>> {
+    data: Entity<M>[];
+    entitiesDisplayedFirst?: Entity<M>[];
+}
+/**
+ * This hook is used to have some entities at the beginning of data.
+ * @param path
+ * @param entitiesDisplayedFirst
+ * @group Hooks and utilities
+ */
+export declare function useDataOrder<M extends Record<string, any>>({ data, entitiesDisplayedFirst }: DataOrderProps<M>): Entity<M>[];

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

@@ -0,0 +1,38 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { Entity, User } from "@rebasepro/types";
+/**
+ * @group Hooks and utilities
+ */
+export interface EntityFetchProps<M extends Record<string, any>, USER extends User = User> {
+    path: string;
+    entityId?: string | number;
+    databaseId?: string;
+    collection: EntityCollection<M, USER>;
+    useCache?: boolean;
+}
+/**
+ * @group Hooks and utilities
+ */
+export interface EntityFetchResult<M extends Record<string, any>> {
+    entity?: Entity<M>;
+    dataLoading: boolean;
+    dataLoadingError?: Error;
+}
+/**
+ * Pre-populate the entity fetch cache with entities loaded from a collection.
+ * This allows entity detail views to render instantly using cached data,
+ * while the background fetch/listener brings in fresh data.
+ * @param path - The collection path (e.g. "products")
+ * @param entities - Array of entities to cache
+ */
+export declare function populateEntityFetchCache<M extends Record<string, any>>(path: string, entities: Entity<M>[]): void;
+/**
+ * This hook is used to fetch an entity.
+ * It gives real time updates if the driver supports it.
+ * @param path
+ * @param collection
+ * @param entityId
+ * @param useCache
+ * @group Hooks and utilities
+ */
+export declare function useEntityFetch<M extends Record<string, any>, USER extends User = User>({ path, entityId, collection, databaseId, useCache }: EntityFetchProps<M, USER>): EntityFetchResult<M>;

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

@@ -0,0 +1,52 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { Entity, EntityRelation, FilterValues } from "@rebasepro/types";
+export interface RelationItem {
+    id: string | number;
+    label: string;
+    description?: string;
+    data: Entity<any>;
+    relation: EntityRelation;
+}
+export interface UseRelationSelectorProps<M extends Record<string, any> = any> {
+    /**
+     * Full path where the relation data is located
+     */
+    path: string;
+    /**
+     * The collection that represents the relation entities
+     */
+    collection: EntityCollection<M>;
+    /**
+     * Force filter to be applied to the relation search
+     */
+    forceFilter?: FilterValues<string>;
+    /**
+     * Page size for pagination
+     */
+    pageSize?: number;
+    /**
+     * Function to extract the label from an entity
+     */
+    getLabelFromEntity?: (entity: Entity<M>) => string;
+    /**
+     * Function to extract the description from an entity
+     */
+    getDescriptionFromEntity?: (entity: Entity<M>) => string | undefined;
+    /**
+     * Property name to use as the secondary display field
+     */
+    descriptionProperty?: keyof M;
+}
+export interface RelationSelectorController {
+    items: RelationItem[];
+    isLoading: boolean;
+    error: Error | undefined;
+    search: (searchString: string) => void;
+    loadMore: () => void;
+    hasMore: boolean;
+    entityToRelationItem: (entity: Entity<any>, relation: EntityRelation) => RelationItem;
+}
+/**
+ * Hook to manage relation selection with data fetching from Rebase data source
+ */
+export declare function useRelationSelector<M extends Record<string, any> = any>({ path, collection, forceFilter, pageSize, getLabelFromEntity, getDescriptionFromEntity, descriptionProperty }: UseRelationSelectorProps<M>): RelationSelectorController;

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

@@ -0,0 +1,31 @@
+import { User } from "@rebasepro/types";
+export interface UserSelectorItem {
+    uid: string;
+    label: string;
+    description?: string;
+    user: User;
+}
+export interface UseUserSelectorProps {
+    /**
+     * Page size for pagination. Defaults to 10.
+     */
+    pageSize?: number;
+}
+export interface UserSelectorController {
+    items: UserSelectorItem[];
+    isLoading: boolean;
+    error: Error | undefined;
+    search: (searchString: string) => void;
+    loadMore: () => void;
+    hasMore: boolean;
+    getUser: (uid: string) => User | null;
+}
+/**
+ * Hook to manage user selection with server-side search and pagination.
+ * Similar to useRelationSelector but for the UserManagementDelegate.
+ *
+ * If the delegate provides `searchUsers`, this hook uses server-side
+ * search/pagination. Otherwise it falls back to client-side filtering
+ * over the in-memory `users` array.
+ */
+export declare function useUserSelector({ pageSize }?: UseUserSelectorProps): UserSelectorController;

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

@@ -0,0 +1,37 @@
+export * from "./data/useData";
+export * from "./data/useCollectionFetch";
+export * from "./data/useEntityFetch";
+export * from "./data/useRelationSelector";
+export * from "./data/useUserSelector";
+export * from "./data/save";
+export * from "./data/delete";
+export * from "./useUnsavedChangesDialog";
+export * from "./useStorageSource";
+export * from "./useAuthController";
+export * from "./useAuthSubscription";
+export * from "./useDialogsController";
+export * from "./useAdminModeController";
+export * from "./useBuildAdminModeController";
+export * from "./useEffectiveRoleController";
+export * from "./useBuildEffectiveRoleController";
+export * from "./useRebaseContext";
+export * from "./useSnackbarController";
+export * from "./useModeController";
+export * from "./useClipboard";
+export * from "./useLargeLayout";
+export * from "./useCollapsedGroups";
+export * from "./useInternalUserManagementController";
+export * from "./useBrowserTitleAndIcon";
+export * from "./useSlot";
+export * from "./useCustomizationController";
+export * from "./useBuildLocalConfigurationPersistence";
+export * from "./useBuildModeController";
+export * from "./useValidateAuthenticator";
+export * from "./useRebaseRegistry";
+export * from "./useBackendStorageSource";
+export * from "./usePermissions";
+export * from "./ApiConfigContext";
+export * from "./useTranslation";
+export * from "./useRebaseClient";
+export * from "./useAnalyticsController";
+export * from "./useUserConfigurationPersistence";

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

@@ -0,0 +1,19 @@
+/**
+ * Use this controller to change the admin mode (developer vs editor)
+ * @group Hooks and utilities
+ */
+export interface AdminModeController {
+    mode: "content" | "studio" | "settings";
+    setMode: (mode: "content" | "studio" | "settings") => void;
+}
+/**
+ * Hook to retrieve the current admin mode ("developer" | "editor"), and `setMode`
+ * to change it.
+ *
+ * Consider that in order to use this hook you need to have a parent
+ * `Rebase`
+ *
+ * @see AdminModeController
+ * @group Hooks and utilities
+ */
+export declare const useAdminModeController: () => AdminModeController;

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

@@ -0,0 +1,5 @@
+import { AnalyticsController } from "@rebasepro/types";
+/**
+ * @group Hooks and utilities
+ */
+export declare const useAnalyticsController: () => AnalyticsController;

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

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

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

@@ -0,0 +1,2 @@
+import { AuthClient, AuthController } from "@rebasepro/types";
+export declare function useAuthSubscription(authClient?: AuthClient): AuthController;

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

@@ -0,0 +1,30 @@
+/**
+ * React hook for using backend storage API as a StorageSource
+ */
+import { StorageSource } from "@rebasepro/types";
+export interface BackendStorageSourceProps {
+    /**
+     * Backend API URL (e.g., 'http://localhost:3001')
+     */
+    apiUrl: string;
+    /**
+     * Function to get the current auth token
+     */
+    getAuthToken: () => Promise<string>;
+}
+/**
+ * Hook to create a StorageSource that uses the backend storage REST API.
+ * Use this for self-hosted Rebase with local or S3 storage.
+ *
+ * @example
+ * ```tsx
+ * const storageSource = useBackendStorageSource({
+ *     apiUrl: 'http://localhost:3001',
+ *     getAuthToken: authController.getAuthToken
+ * });
+ *
+ * // Then pass to Rebase:
+ * <Rebase storageSource={storageSource} ... />
+ * ```
+ */
+export declare function useBackendStorageSource({ apiUrl, getAuthToken }: BackendStorageSourceProps): StorageSource;

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

@@ -0,0 +1,18 @@
+import type { StudioBridge } from "./useStudioBridge";
+/**
+ * Registers a value into the self-assembling Studio bridge.
+ *
+ * Each controller (collectionRegistry, sideEntity, url, navigation, breadcrumbs)
+ * calls this hook on mount to inject its real implementation into the bridge.
+ * On unmount the slice is automatically removed, reverting to the noop default.
+ *
+ * Usage:
+ * ```tsx
+ * function SomeProvider({ children }) {
+ *     const controller = useBuildSomeController();
+ *     useBridgeRegistration("sideEntityController", controller);
+ *     return <SomeContext.Provider value={controller}>{children}</SomeContext.Provider>;
+ * }
+ * ```
+ */
+export declare function useBridgeRegistration<K extends keyof StudioBridge>(key: K, value: StudioBridge[K]): void;

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

@@ -0,0 +1,6 @@
+/**
+ * Internal hook to handle the browser title and icon
+ * @param name
+ * @param logo
+ */
+export declare function useBrowserTitleAndIcon(name: string, logo?: string): void;

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

@@ -0,0 +1,6 @@
+import { AdminModeController } from "./index";
+/**
+ * Use this hook to build an admin mode controller that determines
+ * whether the UI shows Developer or Editor tools.
+ */
+export declare function useBuildAdminModeController(): AdminModeController;

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

@@ -0,0 +1,8 @@
+import type { EffectiveRoleController } from "@rebasepro/types";
+/**
+ * Use this hook to build an effective role controller that determines
+ * what role is simulated in Editor mode when Dev mode is active.
+ *
+ * It uses localStorage to persist the simulated role across reloads.
+ */
+export declare function useBuildEffectiveRoleController(): EffectiveRoleController;

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

@@ -0,0 +1,2 @@
+import { UserConfigurationPersistence } from "@rebasepro/types";
+export declare function useBuildLocalConfigurationPersistence(): UserConfigurationPersistence;

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