@cube-dev/ui-kit 0.114.0 → 0.116.0

package/types/components/overlays/Dialog/DialogTrigger.d.ts

@@ -1,50 +0,0 @@
-import { ReactElement, RefObject } from 'react';
-import { OverlayTriggerProps, Placement, PositionProps } from 'react-aria';
-import { OverlayTriggerState } from 'react-stately';
-import { Styles } from '../../../tasty';
-import { WithCloseBehavior } from '../Modal';
-export type CubeDialogClose = (close: () => void) => ReactElement;
-export interface CubeDialogTriggerProps extends OverlayTriggerProps, PositionProps, WithCloseBehavior {
-    /** The Dialog and its trigger element. See the DialogTrigger [Content section](#content) for more information on what to provide as children. */
-    children: [
-        ReactElement | ((state: OverlayTriggerState) => ReactElement),
-        CubeDialogClose | ReactElement
-    ];
-    /**
-     * The type of Dialog that should be rendered. See the DialogTrigger [types section](#dialog-types) for an explanation on each.
-     * @default 'modal'
-     */
-    type?: 'modal' | 'popover' | 'tray' | 'fullscreen' | 'fullscreenTakeover' | 'panel';
-    /** The type of Dialog that should be rendered when on a mobile device. See DialogTrigger [types section](#dialog-types) for an explanation on each. */
-    mobileType?: 'modal' | 'tray' | 'fullscreen' | 'fullscreenTakeover' | 'panel' | 'popover';
-    placement?: Placement;
-    /**
-     * Whether a popover type Dialog's arrow should be hidden.
-     */
-    hideArrow?: boolean;
-    /** The ref of the element the Dialog should visually attach itself to. Defaults to the trigger button if not defined. */
-    targetRef?: RefObject<HTMLElement | null>;
-    /** Whether a modal type Dialog should be dismissable. */
-    isDismissable?: boolean;
-    /** Whether pressing the escape key to close the dialog should be disabled. */
-    isKeyboardDismissDisabled?: boolean;
-    /** The screen breakpoint for the mobile type */
-    mobileViewport?: number;
-    /** The style map for the overlay **/
-    styles?: Styles;
-    shouldCloseOnInteractOutside?: (element: Element) => boolean;
-    onDismiss?: (action?: string) => void;
-    isOpen?: boolean;
-    onOpenChange?: (isOpen: boolean) => void;
-    defaultOpen?: boolean;
-    shouldFlip?: boolean;
-    shouldUpdatePosition?: boolean;
-    /** Minimum padding in pixels between the popover and viewport edges */
-    containerPadding?: number;
-}
-/**
- * DialogTrigger serves as a wrapper around a Dialog and its associated trigger, linking the Dialog's
- * open state with the trigger's press state. Additionally, it allows you to customize the type and
- * positioning of the Dialog.
- */
-export declare function DialogTrigger(props: CubeDialogTriggerProps): import("react/jsx-runtime").JSX.Element;

package/types/components/overlays/Dialog/context.d.ts

@@ -1,9 +0,0 @@
-import { HTMLAttributes } from 'react';
-export interface DialogContextValue extends HTMLAttributes<HTMLElement> {
-    type?: 'modal' | 'popover' | 'tray' | 'fullscreen' | 'fullscreenTakeover' | 'panel';
-    isDismissable?: boolean;
-    onClose?: (arg?: string) => void;
-    isOpen?: boolean;
-}
-export declare const DialogContext: import("react").Context<DialogContextValue | null>;
-export declare function useDialogContext(): DialogContextValue;

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

@@ -1,5 +0,0 @@
-export * from './DialogContainer';
-export * from './DialogForm';
-export * from './DialogTrigger';
-export * from './Dialog';
-export * from './use-dialog-container';

package/types/components/overlays/Dialog/use-dialog-container.d.ts

@@ -1,15 +0,0 @@
-import { ComponentProps, ComponentType } from 'react';
-import { DialogContainer } from './DialogContainer';
-/**
- * Generic hook to manage a dialog component.
- *
- * @param Component - A React component that represents the dialog content. It must accept props of type P.
- * @param defaultContainerProps - Default props to pass to the DialogContainer.
- * @returns An object with `open` function to open the dialog with provided props and `rendered` JSX element to include in your component tree.
- */
-export declare function useDialogContainer<P, E = ComponentProps<typeof DialogContainer>>(Component: ComponentType<P>, defaultContainerProps?: ComponentProps<typeof DialogContainer>): {
-    open: (props: P, containerProps?: E | undefined) => void;
-    update: (props: P, containerProps?: E | undefined) => void;
-    close: () => void;
-    readonly rendered: import("react/jsx-runtime").JSX.Element | null;
-};

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

@@ -1,13 +0,0 @@
-import { BaseProps, Styles } from '../../../tasty';
-import { ModalProps, WithCloseBehavior } from './types';
-export declare const OVERLAY_WRAPPER_STYLES: Styles;
-export interface CubeModalProps extends Omit<ModalProps, 'container' | 'type' | 'nodeRef'>, WithCloseBehavior {
-    container?: HTMLElement;
-    qa?: BaseProps['qa'];
-    onClose?: (action?: string) => void;
-    type?: 'modal' | 'fullscreen' | 'fullscreenTakeover' | 'panel';
-    styles?: Styles;
-    shouldCloseOnInteractOutside?: (element: Element) => boolean;
-}
-declare let _Modal: import("react").ForwardRefExoticComponent<Omit<CubeModalProps, "ref"> & import("react").RefAttributes<unknown>>;
-export { _Modal as Modal };

package/types/components/overlays/Modal/OpenTransition.d.ts

@@ -1,7 +0,0 @@
-import { TransitionStatus } from './types';
-import type { TimeoutProps } from 'react-transition-group/Transition';
-export type OpenTransitionProps = Omit<TimeoutProps<undefined>, 'timeout'>;
-export declare function useOpenTransitionContext(): {
-    transitionState: TransitionStatus;
-} | null;
-export declare function OpenTransition(props: OpenTransitionProps): import("react/jsx-runtime").JSX.Element;

package/types/components/overlays/Modal/Overlay.d.ts

@@ -1,7 +0,0 @@
-import { WithCloseBehavior } from './types';
-import type { OverlayProps } from 'react-aria';
-export interface CubeOverlayProps extends Omit<OverlayProps, 'container' | 'nodeRef'>, WithCloseBehavior {
-    container?: HTMLElement | null;
-}
-declare let _Overlay: import("react").ForwardRefExoticComponent<Omit<CubeOverlayProps, "ref"> & import("react").RefAttributes<unknown>>;
-export { _Overlay as Overlay };

package/types/components/overlays/Modal/Popover.d.ts

@@ -1,20 +0,0 @@
-import { HTMLAttributes } from 'react';
-import { OverlayProps } from 'react-aria';
-import { PlacementAxis } from '../../../shared';
-import { BaseProps } from '../../../tasty';
-import { TransitionState, WithCloseBehavior } from './types';
-export interface CubePopoverProps extends BaseProps, Omit<OverlayProps, 'children' | 'nodeRef'>, WithCloseBehavior, TransitionState {
-    container?: HTMLElement;
-    placement?: PlacementAxis;
-    arrowProps?: HTMLAttributes<HTMLElement>;
-    hideArrow?: boolean;
-    isOpen?: boolean;
-    onClose?: () => void;
-    shouldCloseOnBlur?: boolean;
-    isNonModal?: boolean;
-    isDismissable?: boolean;
-    updatePosition?: () => void;
-    shouldCloseOnInteractOutside?: (element: Element) => boolean;
-}
-declare const _Popover: import("react").ForwardRefExoticComponent<Omit<CubePopoverProps, "ref"> & import("react").RefAttributes<unknown>>;
-export { _Popover as Popover };

package/types/components/overlays/Modal/Tray.d.ts

@@ -1,19 +0,0 @@
-import { ReactNode } from 'react';
-import { OverlayProps } from 'react-aria';
-import { BaseProps, Styles } from '../../../tasty';
-import { WithCloseBehavior } from './types';
-export interface CubeTrayProps extends OverlayProps, WithCloseBehavior {
-    container?: HTMLElement;
-    qa?: BaseProps['qa'];
-    onClose?: (action?: string) => void;
-    isFixedHeight?: boolean;
-    isNonModal?: boolean;
-    styles?: Styles;
-    children?: ReactNode;
-    isKeyboardDismissDisabled?: boolean;
-    isOpen?: boolean;
-    onOpenChange?: (isOpen: boolean) => void;
-    defaultOpen?: boolean;
-}
-declare let _Tray: import("react").ForwardRefExoticComponent<CubeTrayProps & import("react").RefAttributes<unknown>>;
-export { _Tray as Tray };

package/types/components/overlays/Modal/Underlay.d.ts

@@ -1,8 +0,0 @@
-import { HTMLAttributes } from 'react';
-import { TransitionState } from './types';
-export interface CubeUnderlayProps extends HTMLAttributes<HTMLElement> {
-    isOpen?: boolean;
-    transitionState?: TransitionState;
-}
-declare let _Underlay: import("react").ForwardRefExoticComponent<CubeUnderlayProps & import("react").RefAttributes<HTMLElement>>;
-export { _Underlay as Underlay };

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

@@ -1,6 +0,0 @@
-export { Tray } from './Tray';
-export { Modal } from './Modal';
-export { Overlay } from './Overlay';
-export { Underlay } from './Underlay';
-export { Popover } from './Popover';
-export * from './types';

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

@@ -1,18 +0,0 @@
-import { ReactElement } from 'react';
-import { OverlayProps } from 'react-aria';
-import { TransitionStatus as ReactTransitionStatus } from 'react-transition-group';
-export type CloseBehavior = 'remove' | 'hide';
-export type TransitionStatus = ReactTransitionStatus;
-export interface WithCloseBehavior {
-    hideOnClose?: boolean;
-}
-export interface TransitionState {
-    transitionState?: TransitionStatus;
-}
-export interface ModalProps extends Omit<OverlayProps, 'nodeRef'> {
-    children: ReactElement;
-    isOpen?: boolean;
-    onClose?: () => void;
-    type?: 'modal' | 'fullscreen' | 'fullscreenTakeover' | 'panel';
-    isDismissable?: boolean;
-}

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

@@ -1,32 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,14 +0,0 @@
-/**
- * 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

@@ -1,40 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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;