@object-ui/react 0.5.0 → 3.0.0

package/dist/components/form/FormRenderer.js

@@ -9,6 +9,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
 import { useForm, FormProvider } from 'react-hook-form';
 import { FieldFactory } from './FieldFactory';
+import { ExpressionEvaluator } from '@object-ui/core';
+import { resolveI18nLabel } from '../../utils/i18n';
 /**
  * FormRenderer component that renders forms based on FormViewSchema
  * from @objectstack/spec
@@ -58,6 +60,33 @@ const COL_SPAN = {
     3: 'col-span-3',
     4: 'col-span-4',
 };
+/**
+ * Evaluate whether a field should be visible based on visibleOn expression
+ * and dependsOn parent field value.
+ */
+function evaluateFieldVisibility(fieldConfig, formValues) {
+    // If explicitly hidden, skip
+    if (fieldConfig.hidden) {
+        return false;
+    }
+    // Evaluate visibleOn expression
+    if (fieldConfig.visibleOn) {
+        try {
+            const evaluator = new ExpressionEvaluator({ data: formValues, form: formValues });
+            return evaluator.evaluateCondition(fieldConfig.visibleOn);
+        }
+        catch {
+            // On error, default to visible
+            return true;
+        }
+    }
+    // Evaluate dependsOn: field is hidden if parent field has no value
+    if (fieldConfig.dependsOn) {
+        const parentValue = formValues[fieldConfig.dependsOn];
+        return parentValue !== undefined && parentValue !== null && parentValue !== '';
+    }
+    return true;
+}
 /**
  * Renders a form section with grid layout
  */
@@ -65,17 +94,30 @@ const FormSectionRenderer = ({ section, methods, disabled = false, }) => {
     const [isCollapsed, setIsCollapsed] = React.useState(section.collapsed || false);
     // Determine grid columns based on section.columns
     const gridCols = GRID_COLS[section.columns || 1];
+    // Collect whether there are any conditional fields
+    const hasConditionalFields = React.useMemo(() => {
+        return section.fields.some((field) => {
+            if (typeof field === 'string')
+                return false;
+            return !!field.dependsOn || !!field.visibleOn;
+        });
+    }, [section.fields]);
+    // Watch form values for conditional field evaluation
+    // Only watch when there are fields with dependsOn or visibleOn to avoid
+    // unnecessary re-renders in forms without conditional fields.
+    const allFormValues = methods.watch();
+    const formValues = hasConditionalFields ? allFormValues : undefined;
     const handleToggleCollapse = () => {
         if (section.collapsible) {
             setIsCollapsed(!isCollapsed);
         }
     };
-    return (_jsxs("div", { className: "border rounded-lg p-4", children: [section.label && (_jsxs("div", { className: `flex items-center justify-between mb-4 ${section.collapsible ? 'cursor-pointer' : ''}`, onClick: handleToggleCollapse, children: [_jsx("h3", { className: "text-lg font-semibold", children: section.label }), section.collapsible && (_jsx("span", { className: "text-sm text-gray-500", children: isCollapsed ? '▶' : '▼' }))] })), !isCollapsed && (_jsx("div", { className: `grid ${gridCols} gap-4`, children: section.fields.map((field, index) => {
+    return (_jsxs("div", { className: "border rounded-lg p-4", children: [section.label && (_jsxs("div", { className: `flex items-center justify-between mb-4 ${section.collapsible ? 'cursor-pointer' : ''}`, onClick: handleToggleCollapse, children: [_jsx("h3", { className: "text-lg font-semibold", children: resolveI18nLabel(section.label) }), section.collapsible && (_jsx("span", { className: "text-sm text-gray-500", children: isCollapsed ? '▶' : '▼' }))] })), !isCollapsed && (_jsx("div", { className: `grid ${gridCols} gap-4`, children: section.fields.map((field, index) => {
                     // Handle both string fields (legacy) and FormFieldSchema objects
                     const fieldName = typeof field === 'string' ? field : field.field;
                     const fieldConfig = typeof field === 'string' ? { field: fieldName } : field;
-                    // Skip hidden fields
-                    if (fieldConfig.hidden) {
+                    // Evaluate visibility: static hidden, visibleOn expression, dependsOn parent
+                    if (!evaluateFieldVisibility(fieldConfig, formValues || {})) {
                         return null;
                     }
                     // Calculate colSpan for grid

package/dist/context/ActionContext.d.ts

@@ -0,0 +1,76 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @object-ui/react - Action Context
+ *
+ * Provides a shared ActionRunner instance and handlers to the component tree.
+ * Components can consume actions without creating their own runner instances.
+ */
+import React from 'react';
+import { ActionRunner, type ActionContext as ActionCtx, type ActionDef, type ActionResult, type ConfirmationHandler, type ToastHandler, type ModalHandler, type NavigationHandler, type ParamCollectionHandler } from '@object-ui/core';
+export interface ActionProviderProps {
+    children: React.ReactNode;
+    /** Initial action context (record, user, data, etc.) */
+    context?: ActionCtx;
+    /** Custom confirmation handler (e.g., Shadcn AlertDialog) */
+    onConfirm?: ConfirmationHandler;
+    /** Custom toast handler (e.g., Sonner) */
+    onToast?: ToastHandler;
+    /** Custom modal handler — render modals in response to modal actions */
+    onModal?: ModalHandler;
+    /** Custom navigation handler — SPA-aware routing (e.g., React Router navigate) */
+    onNavigate?: NavigationHandler;
+    /** Custom param collection handler — show dialog to collect ActionParam values */
+    onParamCollection?: ParamCollectionHandler;
+    /** Pre-registered custom action handlers */
+    handlers?: Record<string, (action: ActionDef, ctx: ActionCtx) => Promise<ActionResult>>;
+}
+interface ActionContextValue {
+    /** Execute an action */
+    execute: (action: ActionDef) => Promise<ActionResult>;
+    /** Execute multiple actions in chain */
+    executeChain: (actions: ActionDef[], mode?: 'sequential' | 'parallel') => Promise<ActionResult>;
+    /** Whether an action is currently being executed */
+    loading: boolean;
+    /** Last error message */
+    error: string | null;
+    /** Last action result */
+    result: ActionResult | null;
+    /** The underlying ActionRunner instance */
+    runner: ActionRunner;
+    /** Update context data */
+    updateContext: (ctx: Partial<ActionCtx>) => void;
+}
+/**
+ * ActionProvider — Provides a shared ActionRunner to the tree.
+ *
+ * @example
+ * ```tsx
+ * <ActionProvider
+ *   context={{ record: currentRecord, user }}
+ *   onToast={(msg, opts) => toast[opts?.type ?? 'info'](msg)}
+ *   onConfirm={async (msg) => showConfirmDialog(msg)}
+ *   onNavigate={(url) => router.push(url)}
+ * >
+ *   <SchemaRenderer schema={pageSchema} />
+ * </ActionProvider>
+ * ```
+ */
+export declare const ActionProvider: React.FC<ActionProviderProps>;
+/**
+ * Hook to consume the ActionProvider context.
+ * Returns the shared ActionRunner execute function, loading state, and more.
+ *
+ * Falls back to a local ActionRunner if no ActionProvider is present.
+ */
+export declare function useAction(): ActionContextValue;
+/**
+ * Hook to check if an ActionProvider is available.
+ */
+export declare function useHasActionProvider(): boolean;
+export {};

package/dist/context/ActionContext.js

@@ -0,0 +1,139 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @object-ui/react - Action Context
+ *
+ * Provides a shared ActionRunner instance and handlers to the component tree.
+ * Components can consume actions without creating their own runner instances.
+ */
+import { createContext, useCallback, useContext, useMemo, useState } from 'react';
+import { ActionRunner, } from '@object-ui/core';
+const ActionCtxReact = createContext(null);
+/**
+ * ActionProvider — Provides a shared ActionRunner to the tree.
+ *
+ * @example
+ * ```tsx
+ * <ActionProvider
+ *   context={{ record: currentRecord, user }}
+ *   onToast={(msg, opts) => toast[opts?.type ?? 'info'](msg)}
+ *   onConfirm={async (msg) => showConfirmDialog(msg)}
+ *   onNavigate={(url) => router.push(url)}
+ * >
+ *   <SchemaRenderer schema={pageSchema} />
+ * </ActionProvider>
+ * ```
+ */
+export const ActionProvider = ({ children, context = {}, onConfirm, onToast, onModal, onNavigate, onParamCollection, handlers, }) => {
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [result, setResult] = useState(null);
+    const runner = useMemo(() => {
+        const r = new ActionRunner(context);
+        if (onConfirm)
+            r.setConfirmHandler(onConfirm);
+        if (onToast)
+            r.setToastHandler(onToast);
+        if (onModal)
+            r.setModalHandler(onModal);
+        if (onNavigate)
+            r.setNavigationHandler(onNavigate);
+        if (onParamCollection)
+            r.setParamCollectionHandler(onParamCollection);
+        if (handlers) {
+            Object.entries(handlers).forEach(([name, handler]) => {
+                r.registerHandler(name, handler);
+            });
+        }
+        return r;
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [JSON.stringify(context)]);
+    const execute = useCallback(async (action) => {
+        setLoading(true);
+        setError(null);
+        setResult(null);
+        try {
+            const actionResult = await runner.execute(action);
+            setResult(actionResult);
+            if (!actionResult.success) {
+                setError(actionResult.error || 'Action failed');
+            }
+            return actionResult;
+        }
+        catch (err) {
+            const errorMessage = err.message;
+            setError(errorMessage);
+            const failureResult = { success: false, error: errorMessage };
+            setResult(failureResult);
+            return failureResult;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [runner]);
+    const executeChain = useCallback(async (actions, mode) => {
+        setLoading(true);
+        setError(null);
+        setResult(null);
+        try {
+            const actionResult = await runner.executeChain(actions, mode);
+            setResult(actionResult);
+            if (!actionResult.success) {
+                setError(actionResult.error || 'Chain failed');
+            }
+            return actionResult;
+        }
+        catch (err) {
+            const errorMessage = err.message;
+            setError(errorMessage);
+            const failureResult = { success: false, error: errorMessage };
+            setResult(failureResult);
+            return failureResult;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [runner]);
+    const updateContext = useCallback((newContext) => {
+        runner.updateContext(newContext);
+    }, [runner]);
+    const value = useMemo(() => ({ execute, executeChain, loading, error, result, runner, updateContext }), [execute, executeChain, loading, error, result, runner, updateContext]);
+    return (_jsx(ActionCtxReact.Provider, { value: value, children: children }));
+};
+ActionProvider.displayName = 'ActionProvider';
+/**
+ * Hook to consume the ActionProvider context.
+ * Returns the shared ActionRunner execute function, loading state, and more.
+ *
+ * Falls back to a local ActionRunner if no ActionProvider is present.
+ */
+export function useAction() {
+    const ctx = useContext(ActionCtxReact);
+    if (!ctx) {
+        // Graceful fallback: create a local runner
+        // This allows action components to work even without an ActionProvider
+        const runner = new ActionRunner();
+        return {
+            execute: (action) => runner.execute(action),
+            executeChain: (actions, mode) => runner.executeChain(actions, mode),
+            loading: false,
+            error: null,
+            result: null,
+            runner,
+            updateContext: (ctx) => runner.updateContext(ctx),
+        };
+    }
+    return ctx;
+}
+/**
+ * Hook to check if an ActionProvider is available.
+ */
+export function useHasActionProvider() {
+    return useContext(ActionCtxReact) !== null;
+}

package/dist/context/DndContext.d.ts

@@ -0,0 +1,135 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @object-ui/react - Drag and Drop Context
+ *
+ * Provides a unified DnD configuration system to the component tree.
+ * Implements DndConfigSchema, DragItemSchema, DropZoneSchema,
+ * DragConstraintSchema, and DropEffectSchema from @objectstack/spec v2.0.7.
+ */
+import React from 'react';
+/** Drop effect types aligned with DropEffectSchema */
+export type DropEffectType = 'move' | 'copy' | 'link' | 'none';
+/** Drag constraint axis aligned with DragConstraintSchema */
+export type DragAxis = 'x' | 'y' | 'both';
+/** Drag item metadata */
+export interface DragItemData {
+    /** Unique identifier for the dragged item */
+    id: string;
+    /** Type of the dragged item (for drop zone filtering) */
+    type: string;
+    /** Arbitrary data associated with the drag */
+    data?: Record<string, unknown>;
+    /** Source container/zone identifier */
+    sourceId?: string;
+}
+/** Drop zone configuration */
+export interface DropZoneConfig {
+    /** Unique identifier for the drop zone */
+    id: string;
+    /** Accepted drag item types */
+    acceptTypes: string[];
+    /** Drop effect to apply */
+    effect?: DropEffectType;
+    /** Whether the zone is currently disabled */
+    disabled?: boolean;
+    /** Maximum number of items this zone can hold */
+    maxItems?: number;
+}
+/** Drag constraints configuration */
+export interface DragConstraintConfig {
+    /** Constrain movement to an axis */
+    axis?: DragAxis;
+    /** Minimum distance before drag starts (in pixels) */
+    activationDistance?: number;
+    /** Whether to show a drag handle */
+    showHandle?: boolean;
+    /** Container bounds (CSS selector) */
+    containerId?: string;
+}
+/** Overall DnD configuration aligned with DndConfigSchema */
+export interface DndSystemConfig {
+    /** Whether DnD is enabled */
+    enabled?: boolean;
+    /** Default drag constraints */
+    defaultConstraints?: DragConstraintConfig;
+    /** Whether to show drag overlay/preview */
+    showPreview?: boolean;
+    /** Auto-scroll when dragging near edges */
+    autoScroll?: boolean;
+}
+/** Drag event information */
+export interface DragEvent {
+    /** The dragged item */
+    item: DragItemData;
+    /** Target drop zone (null if not over a zone) */
+    targetZoneId: string | null;
+    /** The applied drop effect */
+    effect: DropEffectType;
+}
+export interface DndProviderProps {
+    children: React.ReactNode;
+    /** System-wide DnD configuration */
+    config?: DndSystemConfig;
+    /** Called when a drag starts */
+    onDragStart?: (event: DragEvent) => void;
+    /** Called when an item is dropped */
+    onDrop?: (event: DragEvent) => void;
+    /** Called when a drag is cancelled */
+    onDragCancel?: (event: DragEvent) => void;
+}
+interface DndContextValue {
+    /** System-wide DnD configuration */
+    config: DndSystemConfig;
+    /** Whether DnD is enabled */
+    enabled: boolean;
+    /** Currently dragging item (null if not dragging) */
+    activeItem: DragItemData | null;
+    /** Registered drop zones */
+    dropZones: Map<string, DropZoneConfig>;
+    /** Start a drag operation */
+    startDrag: (item: DragItemData) => void;
+    /** End the current drag operation */
+    endDrag: (targetZoneId?: string) => void;
+    /** Cancel the current drag */
+    cancelDrag: () => void;
+    /** Register a drop zone */
+    registerDropZone: (zone: DropZoneConfig) => void;
+    /** Unregister a drop zone */
+    unregisterDropZone: (zoneId: string) => void;
+    /** Check if a drop zone accepts a drag item type */
+    canDrop: (zoneId: string, itemType: string) => boolean;
+}
+/**
+ * DndProvider — Provides a unified DnD system aligned with @objectstack/spec v2.0.7.
+ *
+ * This is a coordination layer; actual drag mechanics are delegated to
+ * libraries like @dnd-kit/core or react-grid-layout in individual plugins.
+ *
+ * @example
+ * ```tsx
+ * <DndProvider
+ *   config={{ enabled: true, showPreview: true, autoScroll: true }}
+ *   onDrop={(event) => handleDrop(event.item, event.targetZoneId)}
+ * >
+ *   <KanbanBoard />
+ * </DndProvider>
+ * ```
+ */
+export declare const DndProvider: React.FC<DndProviderProps>;
+/**
+ * Hook to consume the DnD context.
+ *
+ * @throws Error if used outside a DndProvider
+ */
+export declare function useDnd(): DndContextValue;
+/**
+ * Hook to check if a DndProvider is available.
+ */
+export declare function useHasDndProvider(): boolean;
+export {};

package/dist/context/DndContext.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @object-ui/react - Drag and Drop Context
+ *
+ * Provides a unified DnD configuration system to the component tree.
+ * Implements DndConfigSchema, DragItemSchema, DropZoneSchema,
+ * DragConstraintSchema, and DropEffectSchema from @objectstack/spec v2.0.7.
+ */
+import { createContext, useCallback, useContext, useMemo, useState } from 'react';
+const DndCtx = createContext(null);
+/**
+ * DndProvider — Provides a unified DnD system aligned with @objectstack/spec v2.0.7.
+ *
+ * This is a coordination layer; actual drag mechanics are delegated to
+ * libraries like @dnd-kit/core or react-grid-layout in individual plugins.
+ *
+ * @example
+ * ```tsx
+ * <DndProvider
+ *   config={{ enabled: true, showPreview: true, autoScroll: true }}
+ *   onDrop={(event) => handleDrop(event.item, event.targetZoneId)}
+ * >
+ *   <KanbanBoard />
+ * </DndProvider>
+ * ```
+ */
+export const DndProvider = ({ children, config: userConfig = {}, onDragStart, onDrop, onDragCancel, }) => {
+    const config = useMemo(() => ({
+        enabled: true,
+        showPreview: true,
+        autoScroll: true,
+        ...userConfig,
+    }), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(userConfig)]);
+    const [activeItem, setActiveItem] = useState(null);
+    const [dropZones] = useState(() => new Map());
+    const startDrag = useCallback((item) => {
+        if (!config.enabled)
+            return;
+        setActiveItem(item);
+        onDragStart?.({ item, targetZoneId: null, effect: 'move' });
+    }, [config.enabled, onDragStart]);
+    const endDrag = useCallback((targetZoneId) => {
+        if (!activeItem)
+            return;
+        const zone = targetZoneId ? dropZones.get(targetZoneId) : undefined;
+        const effect = zone?.effect ?? 'move';
+        onDrop?.({ item: activeItem, targetZoneId: targetZoneId ?? null, effect });
+        setActiveItem(null);
+    }, [activeItem, dropZones, onDrop]);
+    const cancelDrag = useCallback(() => {
+        if (!activeItem)
+            return;
+        onDragCancel?.({ item: activeItem, targetZoneId: null, effect: 'none' });
+        setActiveItem(null);
+    }, [activeItem, onDragCancel]);
+    const registerDropZone = useCallback((zone) => {
+        dropZones.set(zone.id, zone);
+    }, [dropZones]);
+    const unregisterDropZone = useCallback((zoneId) => {
+        dropZones.delete(zoneId);
+    }, [dropZones]);
+    const canDrop = useCallback((zoneId, itemType) => {
+        const zone = dropZones.get(zoneId);
+        if (!zone || zone.disabled)
+            return false;
+        return zone.acceptTypes.includes(itemType);
+    }, [dropZones]);
+    const value = useMemo(() => ({
+        config,
+        enabled: config.enabled ?? true,
+        activeItem,
+        dropZones,
+        startDrag,
+        endDrag,
+        cancelDrag,
+        registerDropZone,
+        unregisterDropZone,
+        canDrop,
+    }), [
+        config,
+        activeItem,
+        dropZones,
+        startDrag,
+        endDrag,
+        cancelDrag,
+        registerDropZone,
+        unregisterDropZone,
+        canDrop,
+    ]);
+    return _jsx(DndCtx.Provider, { value: value, children: children });
+};
+DndProvider.displayName = 'DndProvider';
+/**
+ * Hook to consume the DnD context.
+ *
+ * @throws Error if used outside a DndProvider
+ */
+export function useDnd() {
+    const ctx = useContext(DndCtx);
+    if (!ctx) {
+        throw new Error('useDnd must be used within a <DndProvider>. ' +
+            'Wrap your app with <DndProvider> to use the drag and drop system.');
+    }
+    return ctx;
+}
+/**
+ * Hook to check if a DndProvider is available.
+ */
+export function useHasDndProvider() {
+    return useContext(DndCtx) !== null;
+}

package/dist/context/NotificationContext.d.ts

@@ -0,0 +1,113 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @object-ui/react - Notification Context
+ *
+ * Provides a spec-driven notification system to the component tree.
+ * Implements NotificationSchema, NotificationConfigSchema, and
+ * NotificationActionSchema from @objectstack/spec v2.0.7.
+ */
+import React from 'react';
+/** Notification severity levels aligned with NotificationSeveritySchema */
+export type NotificationSeverityLevel = 'info' | 'success' | 'warning' | 'error';
+/** Notification display type aligned with NotificationTypeSchema */
+export type NotificationDisplayType = 'toast' | 'banner' | 'snackbar' | 'modal';
+/** Notification position aligned with NotificationPositionSchema */
+export type NotificationPositionValue = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+/** Action button on a notification */
+export interface NotificationActionButton {
+    label: string;
+    onClick: () => void;
+    variant?: 'default' | 'destructive' | 'outline';
+}
+/** A single notification item */
+export interface NotificationItem {
+    id: string;
+    title: string;
+    message?: string;
+    severity: NotificationSeverityLevel;
+    displayType?: NotificationDisplayType;
+    actions?: NotificationActionButton[];
+    /** Duration in ms (0 = persistent). Default: 5000 */
+    duration?: number;
+    /** Whether the notification has been read */
+    read?: boolean;
+    /** Timestamp */
+    createdAt: Date;
+    /** Optional icon name (lucide icon) */
+    icon?: string;
+}
+/** Configuration for the notification system */
+export interface NotificationSystemConfig {
+    /** Default position for toast notifications */
+    position?: NotificationPositionValue;
+    /** Default duration in ms */
+    defaultDuration?: number;
+    /** Maximum number of visible notifications */
+    maxVisible?: number;
+    /** Whether to stack notifications */
+    stacking?: boolean;
+}
+export interface NotificationProviderProps {
+    children: React.ReactNode;
+    /** System configuration */
+    config?: NotificationSystemConfig;
+    /** External toast handler (e.g., Sonner) for rendering toasts */
+    onToast?: (notification: NotificationItem) => void;
+}
+interface NotificationContextValue {
+    /** All notifications (including history) */
+    notifications: NotificationItem[];
+    /** Unread notification count */
+    unreadCount: number;
+    /** Add a notification */
+    notify: (notification: Omit<NotificationItem, 'id' | 'createdAt' | 'read'>) => string;
+    /** Convenience: show info notification */
+    info: (title: string, message?: string) => string;
+    /** Convenience: show success notification */
+    success: (title: string, message?: string) => string;
+    /** Convenience: show warning notification */
+    warning: (title: string, message?: string) => string;
+    /** Convenience: show error notification */
+    error: (title: string, message?: string) => string;
+    /** Mark a notification as read */
+    markAsRead: (id: string) => void;
+    /** Mark all notifications as read */
+    markAllAsRead: () => void;
+    /** Dismiss a notification */
+    dismiss: (id: string) => void;
+    /** Clear all notifications */
+    clearAll: () => void;
+    /** System configuration */
+    config: NotificationSystemConfig;
+}
+/**
+ * NotificationProvider — Provides a spec-driven notification system.
+ *
+ * @example
+ * ```tsx
+ * <NotificationProvider
+ *   config={{ position: 'top-right', defaultDuration: 5000, maxVisible: 5 }}
+ *   onToast={(n) => toast[n.severity](n.title, { description: n.message })}
+ * >
+ *   <App />
+ * </NotificationProvider>
+ * ```
+ */
+export declare const NotificationProvider: React.FC<NotificationProviderProps>;
+/**
+ * Hook to consume the NotificationProvider context.
+ *
+ * @throws Error if used outside a NotificationProvider
+ */
+export declare function useNotifications(): NotificationContextValue;
+/**
+ * Hook to check if a NotificationProvider is available.
+ */
+export declare function useHasNotificationProvider(): boolean;
+export {};