@cube-dev/ui-kit 0.113.1 → 0.114.0

package/types/components/overlays/Notifications/Notification.d.ts

@@ -0,0 +1,32 @@
+import type { NotificationProps } from './types';
+/**
+ * Declarative Notification component that shows a notification while mounted.
+ * Only supports `mode: 'overlay'` (the default).
+ *
+ * Duration defaults are the same as for imperative `notify()`:
+ * - 3000ms for non-persistent, 5000ms for persistent notifications
+ * - Pass `duration={null}` explicitly to disable auto-dismiss.
+ *
+ * Semantics:
+ * - mount → show or update by `id`
+ * - unmount → remove from overlay and persistent list
+ *
+ * @example
+ * ```tsx
+ * <Notification
+ *   id="release:new-version"
+ *   theme="warning"
+ *   title="New release available"
+ *   description="2.0.0 can be installed now."
+ *   actions={
+ *     <>
+ *       <Notification.Action>Later</Notification.Action>
+ *       <Notification.Action onPress={() => openUpgradeDialog()}>
+ *         Upgrade
+ *       </Notification.Action>
+ *     </>
+ *   }
+ * />
+ * ```
+ */
+export declare function Notification(props: NotificationProps): null;

package/types/components/overlays/Notifications/NotificationAction.d.ts

@@ -0,0 +1,27 @@
+import { Key, ReactNode } from 'react';
+import type { NotificationActionProps } from './types';
+/**
+ * Optional callback invoked BEFORE any action's onPress handler.
+ * Provided by PersistentNotificationsList so the parent (e.g. popover)
+ * can close itself when an action is triggered.
+ */
+declare const NotificationActionInterceptorContext: import("react").Context<(() => void) | null>;
+export { NotificationActionInterceptorContext };
+export interface NotificationDismissProviderProps {
+    notificationId: Key;
+    onDismiss: (id: Key, reason: 'action' | 'close') => void;
+    children: ReactNode;
+}
+export declare function NotificationDismissProvider({ notificationId, onDismiss, children, }: NotificationDismissProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare const DismissActionDetectedContext: import("react").Context<import("react").RefObject<boolean | undefined> | null>;
+/**
+ * Action button for use inside Notification components.
+ * Wraps ItemAction with auto-dismiss behavior.
+ *
+ * - `closeOnPress` (default: true) — auto-dismisses the notification after `onPress`.
+ * - An action with no `onPress` and `closeOnPress: true` acts as a dismiss-only action.
+ * - `isDismiss` — marks this action as the dismiss button; when present, the default
+ *   "Dismiss" button is auto-suppressed via context detection.
+ * - Type (primary/secondary/etc.) is set automatically via ItemActionProvider context.
+ */
+export declare function NotificationAction({ children, onPress, closeOnPress, isDisabled, isDismiss, }: NotificationActionProps): import("react/jsx-runtime").JSX.Element;

package/types/components/overlays/Notifications/NotificationCard.d.ts

@@ -0,0 +1,37 @@
+import { Key, ReactNode } from 'react';
+import type { DismissReason, NotificationType } from './types';
+export interface NotificationCardProps {
+    qa?: string;
+    /** Notification theme */
+    theme?: NotificationType;
+    /** Primary text */
+    title?: ReactNode;
+    /** Secondary text */
+    description?: ReactNode;
+    /** Custom icon override (theme default used if omitted) */
+    icon?: ReactNode;
+    /** Action buttons rendered below description */
+    actions?: ReactNode;
+    /**
+     * Whether the notification shows the default dismiss UI (auto-appended
+     * "Dismiss" button and Escape key). Default: true.
+     *
+     * When false, no default "Dismiss" button is rendered and Escape does
+     * nothing, but actions with `closeOnPress` (default) can still close
+     * the notification.
+     */
+    isDismissible?: boolean;
+    /** When false the card drops its shadow (e.g. inside a list). Default: true. */
+    elevated?: boolean;
+    /** Notification id */
+    notificationId?: Key;
+    /** Called when the notification is dismissed */
+    onDismiss?: (id: Key, reason: DismissReason) => void;
+    /** Suffix content (e.g. timestamp) */
+    suffix?: ReactNode;
+}
+/**
+ * Shared presentational card used by both overlay NotificationItem
+ * and PersistentNotificationListItem.
+ */
+export declare function NotificationCard({ qa, theme, title, description, icon: providedIcon, actions, isDismissible, elevated, notificationId, onDismiss, suffix, }: NotificationCardProps): import("react/jsx-runtime").JSX.Element;

package/types/components/overlays/Notifications/NotificationContext.d.ts

@@ -0,0 +1,16 @@
+import type { ToastContextValue } from '../Toast/types';
+import type { InternalNotificationContextValue, PersistentNotificationsContextValue } from './types';
+export declare const ToastContext: import("react").Context<ToastContextValue | null>;
+/**
+ * Internal context for overlay notification machinery.
+ * Not exported publicly — consumers should use `useNotifications` hook.
+ */
+export declare const NotificationContext: import("react").Context<InternalNotificationContextValue | null>;
+/**
+ * Public context for persistent notifications.
+ * Used by `usePersistentNotifications` and `useNotificationsCount` hooks.
+ */
+export declare const PersistentNotificationsContext: import("react").Context<PersistentNotificationsContextValue | null>;
+export declare function useToastContext(): ToastContextValue;
+export declare function useNotificationContext(): InternalNotificationContextValue;
+export declare function usePersistentNotificationsContext(): PersistentNotificationsContextValue;

package/types/components/overlays/Notifications/NotificationItem.d.ts

@@ -0,0 +1,7 @@
+import { Key } from 'react';
+import type { DismissReason, InternalNotification } from './types';
+export interface NotificationItemProps {
+    notification: InternalNotification;
+    onDismiss: (id: Key, reason: DismissReason) => void;
+}
+export declare function NotificationItem({ notification, onDismiss, }: NotificationItemProps): import("react/jsx-runtime").JSX.Element;

package/types/components/overlays/Notifications/OverlayContainer.d.ts

@@ -0,0 +1,12 @@
+import { Key } from 'react';
+import type { InternalToast } from '../Toast/types';
+import type { DismissReason, InternalNotification } from './types';
+export interface OverlayContainerProps {
+    toasts: InternalToast[];
+    notifications: InternalNotification[];
+    onToastExitComplete: (internalId: string) => void;
+    onNotificationExitComplete: (internalId: string) => void;
+    onNotificationDismiss: (id: Key, reason: DismissReason) => void;
+    onPauseChange: (paused: boolean) => void;
+}
+export declare function OverlayContainer({ toasts, notifications, onToastExitComplete, onNotificationExitComplete, onNotificationDismiss, onPauseChange, }: OverlayContainerProps): import("react/jsx-runtime").JSX.Element | null;

package/types/components/overlays/Notifications/OverlayProvider.d.ts

@@ -0,0 +1,3 @@
+import type { OverlayProviderProps } from './types';
+export { useToastContext, useNotificationContext } from './NotificationContext';
+export declare function OverlayProvider({ children, maxPersistentNotifications, }: OverlayProviderProps): import("react/jsx-runtime").JSX.Element;

package/types/components/overlays/Notifications/PersistentNotificationsList.d.ts

@@ -0,0 +1,19 @@
+import type { PersistentNotificationsListProps } from './types';
+/**
+ * Standardized rendering for archived/persistent notifications.
+ * Always reads items from the notification context.
+ * Composable with app-specific shells (popover, dialog, page section).
+ *
+ * Marks all items as read after being visible for 2 seconds.
+ * Relative timestamps refresh every 10 seconds while the list is mounted.
+ *
+ * Items are always dismissible. Dismissing an item removes it from the
+ * persistent list and marks its ID as "fully dismissed" — subsequent triggers
+ * with the same ID will be completely ignored (no overlay, no re-archival).
+ *
+ * @example
+ * ```tsx
+ * <PersistentNotificationsList emptyState="No notifications" />
+ * ```
+ */
+export declare function PersistentNotificationsList({ onDismissItem, onAction, emptyState, }: PersistentNotificationsListProps): import("react/jsx-runtime").JSX.Element;

package/types/components/overlays/Notifications/format-relative-time.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Lightweight relative time formatter.
+ * No external dependencies.
+ *
+ * Output format:
+ * - `just now` (< 1 minute)
+ * - `N min ago` (1–59 minutes)
+ * - `N h ago` (1–23 hours)
+ * - `N d ago` (1–6 days)
+ * - `N w ago` (1–4 weeks)
+ * - `N mo ago` (1–11 months)
+ * - `N y ago` (1+ years)
+ */
+export declare function formatRelativeTime(timestamp: number): string;

package/types/components/overlays/Notifications/index.d.ts

@@ -0,0 +1,40 @@
+import { Notification as NotificationBase } from './Notification';
+import { NotificationAction } from './NotificationAction';
+export { NotificationAction } from './NotificationAction';
+export { NotificationCard } from './NotificationCard';
+export type { NotificationCardProps } from './NotificationCard';
+export { NotificationItem } from './NotificationItem';
+export type { NotificationItemProps } from './NotificationItem';
+export { PersistentNotificationsList } from './PersistentNotificationsList';
+export { OverlayProvider } from './OverlayProvider';
+export { useToastContext } from './NotificationContext';
+export { useNotifications } from './use-notifications';
+export { usePersistentNotifications, useNotificationsCount, } from './use-persistent-notifications';
+export { formatRelativeTime } from './format-relative-time';
+export type { NotificationType, DismissReason, NotificationBaseOptions, OverlayNotificationOptions, StoredNotificationOptions, NotificationOptions, NotificationActionProps, NotificationHandle, NotificationsApi, PersistentNotificationItem, PersistentNotificationsListProps, OverlayProviderProps, NotificationProps, } from './types';
+/**
+ * Declarative Notification component with compound API.
+ *
+ * @example
+ * ```tsx
+ * // Declarative usage
+ * <Notification
+ *   id="release:new-version"
+ *   theme="warning"
+ *   title="New release available"
+ *   description="2.0.0 can be installed now."
+ *   actions={
+ *     <>
+ *       <Notification.Action>Later</Notification.Action>
+ *       <Notification.Action onPress={() => openUpgradeDialog()}>
+ *         Upgrade
+ *       </Notification.Action>
+ *     </>
+ *   }
+ * />
+ * ```
+ */
+export declare const Notification: typeof NotificationBase & {
+    Action: typeof NotificationAction;
+};
+export type NotificationComponent = typeof Notification;

package/types/components/overlays/Notifications/types.d.ts

@@ -0,0 +1,154 @@
+import type { Key, ReactNode } from 'react';
+export type NotificationType = 'default' | 'success' | 'danger' | 'warning' | 'note';
+export interface NotificationBaseOptions {
+    id?: Key;
+    theme?: NotificationType;
+    title?: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+}
+export interface OverlayNotificationOptions extends NotificationBaseOptions {
+    mode?: 'overlay';
+    /**
+     * Action buttons rendered below the notification description.
+     * A default "Dismiss" button is auto-appended unless any action has
+     * `isDismiss` set (detected automatically via context).
+     * When omitted, only the default "Dismiss" button is shown (if `isDismissible`).
+     */
+    actions?: ReactNode;
+    /**
+     * Whether the notification shows the default dismiss UI:
+     * - Auto-appended "Dismiss" button (suppressed when false)
+     * - Escape key dismissal (disabled when false)
+     *
+     * Actions with `closeOnPress` (default `true`) can still close the
+     * notification regardless of this setting.
+     *
+     * Default: true
+     */
+    isDismissible?: boolean;
+    /**
+     * Duration in ms before auto-dismiss.
+     * Default: 3000ms (non-persistent) or 5000ms (persistent).
+     * null = no auto-dismiss.
+     */
+    duration?: number | null;
+    /**
+     * Whether to retain in persistent list when dismissed.
+     * All user-visible dismissals (timeout, action, close) move the notification
+     * to the persistent list. Only programmatic cleanup (`'api'`, e.g. component
+     * unmount) skips persistence.
+     *
+     * Once archived, subsequent calls with the same `id` skip the overlay and
+     * update the persistent list directly.
+     *
+     * Default: false
+     */
+    persistent?: boolean;
+}
+export interface StoredNotificationOptions extends NotificationBaseOptions {
+    mode: 'stored';
+    /** Action buttons (same ReactNode format as overlay notifications) */
+    actions?: ReactNode;
+    /**
+     * Timestamp (epoch ms) for when the notification was originally created.
+     * Use this when restoring server-sourced notifications to preserve the original time.
+     * Defaults to `Date.now()` if omitted.
+     */
+    createdAt?: number;
+}
+export type NotificationOptions = OverlayNotificationOptions | StoredNotificationOptions;
+export type DismissReason = 'close' | 'timeout' | 'action' | 'api';
+export interface NotificationActionProps {
+    /** Action label */
+    children?: ReactNode;
+    /**
+     * Called when the action is pressed.
+     * Return `false` to prevent the auto-dismiss that would normally follow.
+     * Useful for async flows where the user may cancel (e.g. confirmation dialogs).
+     */
+    onPress?: () => void | false | Promise<void | false>;
+    /** Whether to auto-dismiss the notification after onPress. Default: true */
+    closeOnPress?: boolean;
+    /** Whether the action is disabled */
+    isDisabled?: boolean;
+    /**
+     * Marks this action as the notification's dismiss button.
+     * Detected automatically via context — when any action in the notification
+     * has `isDismiss` set, the auto-appended default "Dismiss" button is suppressed.
+     */
+    isDismiss?: boolean;
+}
+export interface NotificationHandle {
+    id: Key;
+    dismiss: () => void;
+}
+export interface NotificationsApi {
+    notify: (options: NotificationOptions) => NotificationHandle;
+    /**
+     * Shorthand for `notify({ mode: 'stored', ... })`.
+     * Stores a notification directly to the persistent list without showing an overlay.
+     * Kept as a separate method to make the "stored-only" intent explicit at call sites.
+     */
+    record: (options: Omit<StoredNotificationOptions, 'mode'>) => NotificationHandle;
+    dismiss: (id: Key) => void;
+}
+export interface InternalNotification extends OverlayNotificationOptions {
+    internalId: string;
+    createdAt: number;
+    updatedAt: number;
+    isExiting?: boolean;
+    ownerId?: string;
+}
+export interface PersistentNotificationItem {
+    id: Key;
+    theme?: NotificationType;
+    title?: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+    /** Action buttons (ReactNode) */
+    actions?: ReactNode;
+    createdAt: number;
+    updatedAt: number;
+    /** Whether the notification has been seen in the persistent list */
+    isRead?: boolean;
+    /** Owner ID for cleanup on hook/component unmount */
+    ownerId?: string;
+}
+export interface PersistentNotificationsListProps {
+    onDismissItem?: (item: PersistentNotificationItem) => void;
+    /** Called before any action's onPress handler fires. Useful for closing a parent popover. */
+    onAction?: () => void;
+    emptyState?: ReactNode;
+}
+/**
+ * Internal context for overlay notification machinery.
+ * Not exported publicly — consumers should use `useNotifications` hook instead.
+ */
+export interface InternalNotificationContextValue {
+    addNotification: (options: OverlayNotificationOptions, ownerId?: string) => Key;
+    removeNotification: (id: Key, reason?: DismissReason) => void;
+    updateNotification: (id: Key, options: Partial<OverlayNotificationOptions>) => void;
+    notifications: InternalNotification[];
+    addPersistentItem: (item: PersistentNotificationItem) => void;
+    removePersistentItem: (id: Key) => void;
+    removePersistentItemsByOwner: (ownerId: string) => void;
+    removeByOwner: (ownerId: string) => void;
+}
+/**
+ * Public context for persistent notifications.
+ * Used by `usePersistentNotifications` and `useNotificationsCount`.
+ */
+export interface PersistentNotificationsContextValue {
+    persistentItems: PersistentNotificationItem[];
+    removePersistentItem: (id: Key) => void;
+    clearPersistentItems: () => void;
+    markAllAsRead: () => void;
+}
+export interface OverlayProviderProps {
+    children: ReactNode;
+    /** Maximum number of persistent notifications to keep. Default: 200 */
+    maxPersistentNotifications?: number;
+}
+export interface NotificationProps extends OverlayNotificationOptions {
+}

package/types/components/overlays/Notifications/use-notification-state.d.ts

@@ -0,0 +1,23 @@
+import { Key, useRef } from 'react';
+import type { DismissReason, InternalNotification, OverlayNotificationOptions, PersistentNotificationItem } from './types';
+import type { OverlayTimers } from './use-overlay-timers';
+export interface PersistentCallbacks {
+    addPersistentItem: (item: PersistentNotificationItem) => void;
+    removePersistentItem: (id: Key) => void;
+    hasDismissedPersistentId: (id: Key) => boolean;
+    isFullyDismissedId: (id: Key) => boolean;
+}
+export interface NotificationState {
+    notifications: InternalNotification[];
+    notificationsRef: ReturnType<typeof useRef<InternalNotification[]>>;
+    addNotification: (options: OverlayNotificationOptions, ownerId?: string) => Key;
+    removeNotification: (id: Key, reason?: DismissReason) => void;
+    updateNotification: (id: Key, options: Partial<OverlayNotificationOptions>) => void;
+    finalizeNotificationRemoval: (internalId: string) => void;
+    removeByOwner: (ownerId: string) => void;
+}
+/**
+ * @param timersRef - Ref to the shared OverlayTimers instance. Accessed only
+ *   inside callbacks (never during render), so it is guaranteed to be populated.
+ */
+export declare function useNotificationState(timersRef: ReturnType<typeof useRef<OverlayTimers>>, persistent: PersistentCallbacks): NotificationState;

package/types/components/overlays/Notifications/use-notifications.d.ts

@@ -0,0 +1,36 @@
+import type { NotificationsApi } from './types';
+/**
+ * Hook to display and manage notifications.
+ *
+ * Each hook instance acts as an owner scope:
+ * - `notify()` created from this instance attaches ownership metadata.
+ * - On unmount, all attached visible overlay notifications are dismissed.
+ * - On unmount, all attached persistent records are also removed.
+ * - `notify()`/`dismiss()` calls from stale closures after unmount are no-ops.
+ *
+ * @example
+ * ```tsx
+ * const { notify, record, dismiss } = useNotifications();
+ *
+ * notify({
+ *   id: 'deploy:123',
+ *   theme: 'success',
+ *   title: 'Deployment completed',
+ *   description: 'Version 1.4.2 is live.',
+ *   actions: (
+ *     <>
+ *       <Notification.Action onPress={() => openLogs()}>View logs</Notification.Action>
+ *       <Notification.Action onPress={() => openDeployment()}>Open</Notification.Action>
+ *     </>
+ *   ),
+ * });
+ *
+ * // Store directly to persistent list (no overlay)
+ * record({
+ *   id: 'server:alert-1',
+ *   theme: 'warning',
+ *   title: 'Server alert',
+ * });
+ * ```
+ */
+export declare function useNotifications(): NotificationsApi;

package/types/components/overlays/Notifications/use-overlay-timers.d.ts

@@ -0,0 +1,26 @@
+import { Key, useRef } from 'react';
+import type { InternalToast } from '../Toast/types';
+import type { DismissReason, InternalNotification } from './types';
+export interface OverlayTimers {
+    /** Start a toast auto-dismiss timer */
+    startToastTimer: (internalId: string, id: Key, duration: number) => void;
+    /** Clear a toast timer */
+    clearToastTimer: (internalId: string) => void;
+    /** Start a notification auto-dismiss timer */
+    startNotificationTimer: (internalId: string, id: Key, duration: number) => void;
+    /** Clear a notification timer */
+    clearNotificationTimer: (internalId: string) => void;
+    /** Handle pause/resume of all timers (e.g. on hover/focus) */
+    handlePauseChange: (paused: boolean) => void;
+}
+export interface OverlayTimersDeps {
+    /** Ref to current toasts (for resume lookup) */
+    toastsRef: ReturnType<typeof useRef<InternalToast[]>>;
+    /** Ref to current notifications (for resume lookup) */
+    notificationsRef: ReturnType<typeof useRef<InternalNotification[]>>;
+    /** Remove a toast by id */
+    removeToast: (id: Key) => void;
+    /** Remove a notification by id with reason (also invokes onDismiss callback) */
+    removeNotification: (id: Key, reason: DismissReason) => void;
+}
+export declare function useOverlayTimers(deps: OverlayTimersDeps): OverlayTimers;

package/types/components/overlays/Notifications/use-persistent-notifications.d.ts

@@ -0,0 +1,48 @@
+import { Key } from 'react';
+import type { PersistentNotificationItem } from './types';
+/**
+ * Hook to access the persistent notifications list.
+ *
+ * Items are ordered newest first (by `createdAt`, descending).
+ *
+ * @example
+ * ```tsx
+ * const { items, count, remove, clear } = usePersistentNotifications();
+ *
+ * return (
+ *   <div>
+ *     <span>Notifications ({count})</span>
+ *     {items.map(item => (
+ *       <div key={item.id}>
+ *         {item.title}
+ *         <button onClick={() => remove(item.id)}>Remove</button>
+ *       </div>
+ *     ))}
+ *     <button onClick={clear}>Clear all</button>
+ *   </div>
+ * );
+ * ```
+ */
+export declare function usePersistentNotifications(): {
+    items: PersistentNotificationItem[];
+    count: number;
+    remove: (id: Key) => void;
+    clear: () => void;
+    markAllAsRead: () => void;
+};
+/**
+ * Hook to get total and unread counts for persistent notifications.
+ *
+ * - `total` — number of items in the persistent list.
+ * - `unread` — items that haven't been seen in `PersistentNotificationsList` yet.
+ *
+ * @example
+ * ```tsx
+ * const { total, unread } = useNotificationsCount();
+ * return <Badge count={unread} />;
+ * ```
+ */
+export declare function useNotificationsCount(): {
+    total: number;
+    unread: number;
+};

package/types/components/overlays/Notifications/use-persistent-state.d.ts

@@ -0,0 +1,23 @@
+import { Key } from 'react';
+import type { PersistentNotificationItem } from './types';
+export interface PersistentState {
+    persistentItems: PersistentNotificationItem[];
+    addPersistentItem: (item: PersistentNotificationItem) => void;
+    removePersistentItem: (id: Key) => void;
+    removePersistentItemsByOwner: (ownerId: string) => void;
+    clearPersistentItems: () => void;
+    markAllAsRead: () => void;
+    /**
+     * Returns true if the given id was previously moved to the persistent list
+     * and has NOT been explicitly removed from it (i.e. still archived, or was
+     * auto-dismissed but not yet user-dismissed from the persistent list).
+     */
+    hasDismissedPersistentId: (id: Key) => boolean;
+    /**
+     * Returns true if the given id was explicitly removed from the persistent
+     * list by the user. Such notifications should be completely ignored on
+     * subsequent triggers (no overlay, no persistent storage).
+     */
+    isFullyDismissedId: (id: Key) => boolean;
+}
+export declare function usePersistentState(maxItems: number): PersistentState;

package/types/components/overlays/Notifications/use-toast-state.d.ts

@@ -0,0 +1,16 @@
+import { Key, useRef } from 'react';
+import type { InternalToast, ToastData } from '../Toast/types';
+import type { OverlayTimers } from './use-overlay-timers';
+export interface ToastState {
+    toasts: InternalToast[];
+    toastsRef: ReturnType<typeof useRef<InternalToast[]>>;
+    addToast: (data: ToastData, isProgress?: boolean) => Key;
+    removeToast: (id: Key) => void;
+    updateToast: (id: Key, data: Partial<ToastData>) => void;
+    finalizeToastRemoval: (internalId: string) => void;
+}
+/**
+ * @param timersRef - Ref to the shared OverlayTimers instance. Accessed only
+ *   inside callbacks (never during render), so it is guaranteed to be populated.
+ */
+export declare function useToastState(timersRef: ReturnType<typeof useRef<OverlayTimers>>): ToastState;

package/types/components/overlays/Toast/ToastItem.d.ts

@@ -1,7 +1,7 @@
 import { ReactNode } from 'react';
 import { CubeItemProps } from '../../content/Item/Item';
 import type { ToastType } from './types';
-export interface ToastItemProps extends Partial<Omit<CubeItemProps, 'type'>> {
+export interface ToastItemProps extends Partial<Omit<CubeItemProps, 'type' | 'icon'>> {
     /** Primary content (→ Item children). Also supports description-only for migration. */
     title?: ReactNode;
     /** Secondary content (or primary if no title/children) */
@@ -10,5 +10,7 @@ export interface ToastItemProps extends Partial<Omit<CubeItemProps, 'type'>> {
     theme?: ToastType;
     /** Whether the toast is in loading state */
     isLoading?: boolean;
+    /** Icon to display (resolved ReactNode, not a dynamic icon function) */
+    icon?: ReactNode;
 }
 export declare const ToastItem: import("react").ForwardRefExoticComponent<ToastItemProps & import("react").RefAttributes<HTMLElement>>;

package/types/components/overlays/Toast/ToastProvider.d.ts

@@ -1,8 +1,5 @@
-import { ReactNode } from 'react';
-import type { ToastContextValue } from './types';
-export declare function useToastContext(): ToastContextValue;
-interface ToastProviderProps {
-    children: ReactNode;
-}
-export declare function ToastProvider({ children }: ToastProviderProps): import("react/jsx-runtime").JSX.Element;
-export {};
+/**
+ * Toast context is now provided by OverlayProvider.
+ * This module re-exports useToastContext for backward compatibility.
+ */
+export { useToastContext } from '../Notifications/NotificationContext';

package/types/components/overlays/Toast/index.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
 import { ProgressToastOptions, ToastData } from './types';
-export { ToastProvider, useToastContext } from './ToastProvider';
+export { useToastContext } from './ToastProvider';
 export { ToastItem } from './ToastItem';
 export type { ToastItemProps } from './ToastItem';
 export { useToast, getThemeIcon } from './useToast';

package/types/components/overlays/Toast/types.d.ts

@@ -1,6 +1,8 @@
 import type { Key, ReactNode } from 'react';
 import type { CubeItemProps } from '../../content/Item/Item';
-export type ToastType = 'default' | 'success' | 'danger' | 'warning' | 'note';
+import type { NotificationType } from '../Notifications/types';
+/** @deprecated Use `NotificationType` instead. Kept as alias for backward compatibility. */
+export type ToastType = NotificationType;
 export interface ToastData {
     /** Unique identifier for deduplication (auto-generated if not provided) */
     id?: Key;

package/types/index.d.ts

@@ -105,8 +105,6 @@ export { StatsCard } from './components/organisms/StatsCard/StatsCard';
 export type { CubeStatsCard } from './components/organisms/StatsCard/StatsCard';
 export { AlertDialog, useAlertDialogAPI, } from './components/overlays/AlertDialog';
 export type { CubeAlertDialogProps } from './components/overlays/AlertDialog';
-export { notification } from './services/notification';
-export type { CubeNotificationOptions } from './services/notification';
 export * from './tasty';
 export declare const Typography: {
     Text: import("./components/content/Text").TextComponent;
@@ -128,8 +126,8 @@ export * from './utils';
 export * from './tasty';
 export { default as copy } from 'clipboard-copy';
 export * from '@react-aria/ssr';
-export * from './components/overlays/NewNotifications';
 export * from './components/overlays/Toast';
+export * from './components/overlays/Notifications';
 export * from './shared';
 export * from './icons';
 export * from './components/form';