@almadar/ui 2.0.0 → 2.0.1

package/dist/providers/OrbitalProvider.d.ts

@@ -0,0 +1,101 @@
+/**
+ * OrbitalProvider
+ *
+ * Unified provider that combines all required contexts for Orbital applications.
+ * Provides a single import for both Builder preview and compiled shell.
+ *
+ * Combines:
+ * - ThemeProvider - Theme and color mode management
+ * - EventBusProvider - Page-scoped event pub/sub
+ * - SelectionProvider - Selected entity tracking
+ * - FetchedDataProvider - Server-fetched entity data
+ *
+ * @packageDocumentation
+ */
+import React, { type ReactNode } from 'react';
+import { type ThemeDefinition } from '../context/ThemeContext';
+export interface OrbitalProviderProps {
+    children: ReactNode;
+    /** Custom themes (merged with built-in themes) */
+    themes?: ThemeDefinition[];
+    /** Default theme name */
+    defaultTheme?: string;
+    /** Default color mode */
+    defaultMode?: 'light' | 'dark' | 'system';
+    /** Optional target element ref for scoped theme application */
+    targetRef?: React.RefObject<HTMLElement>;
+    /** Skip ThemeProvider (use when already inside a themed container like shadow DOM) */
+    skipTheme?: boolean;
+    /** Enable debug logging for all providers */
+    debug?: boolean;
+    /** Initial fetched data */
+    initialData?: Record<string, unknown[]>;
+    /**
+     * Enable Suspense mode. When true, UISlotRenderer wraps each slot in
+     * `<ErrorBoundary><Suspense>` with Skeleton fallbacks.
+     * Opt-in — existing isLoading prop pattern still works when false/absent.
+     */
+    suspense?: boolean;
+    /**
+     * Enable verification wiring for visual testing.
+     * When true, lifecycle events are recorded and exposed via
+     * `window.__orbitalVerification` for Playwright/automation.
+     * Default: true in development, false in production.
+     */
+    verification?: boolean;
+}
+/**
+ * OrbitalProvider - Unified context provider for Orbital applications
+ *
+ * Wraps your application with all required providers in the correct order.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * function App() {
+ *   return (
+ *     <OrbitalProvider>
+ *       <Router>
+ *         <Routes />
+ *       </Router>
+ *     </OrbitalProvider>
+ *   );
+ * }
+ *
+ * // With configuration
+ * function App() {
+ *   return (
+ *     <OrbitalProvider
+ *       defaultTheme="minimalist"
+ *       defaultMode="dark"
+ *       debug={process.env.NODE_ENV === 'development'}
+ *     >
+ *       <Router>
+ *         <Routes />
+ *       </Router>
+ *     </OrbitalProvider>
+ *   );
+ * }
+ *
+ * // With custom themes from schema
+ * import { THEMES } from './generated/theme-manifest';
+ *
+ * function App() {
+ *   return (
+ *     <OrbitalProvider themes={THEMES} defaultTheme="ocean">
+ *       <Router>
+ *         <Routes />
+ *       </Router>
+ *     </OrbitalProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare function OrbitalProvider({ children, themes, defaultTheme, defaultMode, targetRef, skipTheme, debug, initialData, suspense, verification, }: OrbitalProviderProps): React.ReactElement;
+export declare namespace OrbitalProvider {
+    var displayName: string;
+}
+export { ThemeProvider } from '../context/ThemeContext';
+export { EventBusProvider } from './EventBusProvider';
+export { SelectionProvider } from './SelectionProvider';
+export { FetchedDataProvider } from './FetchedDataProvider';

package/dist/providers/SelectionProvider.d.ts

@@ -0,0 +1,81 @@
+/**
+ * SelectionProvider - Manages selected entity state
+ *
+ * Separates selection state from the EventBusProvider to maintain
+ * clean architecture (event bus stays pure pub/sub).
+ *
+ * This provider:
+ * - Listens to UI:VIEW and UI:SELECT events to track selected entity
+ * - Listens to UI:CLOSE, UI:DESELECT, UI:CANCEL to clear selection
+ * - Provides the selected entity to any component that needs it
+ *
+ * @packageDocumentation
+ */
+import React, { type ReactNode } from 'react';
+export interface SelectionContextType<T = unknown> {
+    /** The currently selected entity */
+    selected: T | null;
+    /** Manually set the selected entity */
+    setSelected: (entity: T | null) => void;
+    /** Clear the selection */
+    clearSelection: () => void;
+    /** Check if an entity is selected */
+    isSelected: (entity: T) => boolean;
+}
+declare const SelectionContext: React.Context<SelectionContextType<unknown> | null>;
+interface SelectionProviderProps {
+    children: ReactNode;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom comparison function for isSelected */
+    compareEntities?: (a: unknown, b: unknown) => boolean;
+}
+/**
+ * Provider component for selection state.
+ *
+ * Must be used within an EventBusProvider.
+ *
+ * @example
+ * ```tsx
+ * function OrderListPage() {
+ *   return (
+ *     <EventBusProvider>
+ *       <SelectionProvider debug={process.env.NODE_ENV === 'development'}>
+ *         <OrderTable />
+ *         <OrderDetailDrawer />
+ *       </SelectionProvider>
+ *     </EventBusProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare function SelectionProvider({ children, debug, compareEntities, }: SelectionProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access selection state.
+ *
+ * @throws Error if used outside SelectionProvider
+ *
+ * @example
+ * ```tsx
+ * function OrderDetailDrawer() {
+ *   const { selected, clearSelection } = useSelection<Order>();
+ *
+ *   if (!selected) return null;
+ *
+ *   return (
+ *     <Drawer onClose={clearSelection}>
+ *       <OrderDetail order={selected} />
+ *     </Drawer>
+ *   );
+ * }
+ * ```
+ */
+export declare function useSelection<T = unknown>(): SelectionContextType<T>;
+/**
+ * Hook to access selection state with fallback for components
+ * that may be used outside SelectionProvider.
+ *
+ * Returns null if no SelectionProvider is found.
+ */
+export declare function useSelectionOptional<T = unknown>(): SelectionContextType<T> | null;
+export { SelectionContext };

package/dist/providers/VerificationProvider.d.ts

@@ -0,0 +1,63 @@
+/**
+ * VerificationProvider
+ *
+ * Wires the verification registry to both compiled and runtime execution paths.
+ *
+ * **Compiled apps**: Intercepts event bus lifecycle events
+ *   (`{traitName}:DISPATCH`, `{traitName}:{event}:SUCCESS`, `{traitName}:{event}:ERROR`)
+ *   emitted by `useOrbitalBridge` and records transitions via `recordTransition()`.
+ *
+ * **Runtime apps**: Accepts an optional `StateMachineManager` and wires its
+ *   `TransitionObserver` to `recordTransition()`.
+ *
+ * **Both**: Calls `bindEventBus()` and `bindTraitStateGetter()` to populate
+ *   `window.__orbitalVerification` for Playwright/automation.
+ *
+ * @packageDocumentation
+ */
+import React, { type ReactNode } from 'react';
+/**
+ * Observer interface compatible with `StateMachineManager.setObserver()`.
+ * Defined locally to avoid hard dependency on `@almadar/runtime`.
+ */
+interface TransitionObserver {
+    onTransition(trace: {
+        traitName: string;
+        from: string;
+        to: string;
+        event: string;
+        guardResult?: boolean;
+        effects: Array<{
+            type: string;
+            args: unknown[];
+            status: 'executed' | 'failed' | 'skipped';
+            error?: string;
+            durationMs?: number;
+        }>;
+    }): void;
+}
+/**
+ * Minimal interface for StateMachineManager — avoids importing the full runtime.
+ */
+interface StateMachineManagerLike {
+    setObserver(observer: TransitionObserver): void;
+    getState?(traitName: string): string | undefined;
+}
+export interface VerificationProviderProps {
+    children: ReactNode;
+    /** Enable verification wiring (default: true in dev, false in prod) */
+    enabled?: boolean;
+    /** Optional runtime StateMachineManager for interpreted mode */
+    runtimeManager?: StateMachineManagerLike;
+    /** Optional trait state getter for compiled apps (maps traitName → currentState) */
+    traitStateGetter?: (traitName: string) => string | undefined;
+}
+/**
+ * VerificationProvider — wires the verification registry to the event bus
+ * and optional runtime manager. Renders children unchanged.
+ */
+export declare function VerificationProvider({ children, enabled, runtimeManager, traitStateGetter, }: VerificationProviderProps): React.ReactElement;
+export declare namespace VerificationProvider {
+    var displayName: string;
+}
+export {};

package/dist/providers/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Providers barrel export
+ *
+ * Unified providers for Orbital applications.
+ * Use OrbitalProvider for most cases - it combines all required providers.
+ */
+export { OrbitalProvider, type OrbitalProviderProps } from './OrbitalProvider';
+export type { ThemeDefinition } from '../context/ThemeContext';
+export { EventBusProvider, EventBusContext } from './EventBusProvider';
+export { SelectionProvider, SelectionContext, useSelection, useSelectionOptional } from './SelectionProvider';
+export type { SelectionContextType } from './SelectionProvider';
+export { FetchedDataProvider, FetchedDataContext, useFetchedDataContext, useFetchedData, useFetchedEntity, } from './FetchedDataProvider';
+export type { FetchedDataProviderProps, FetchedDataContextValue, FetchedDataState, EntityRecord, } from './FetchedDataProvider';
+export { VerificationProvider } from './VerificationProvider';
+export type { VerificationProviderProps } from './VerificationProvider';
+export { OfflineModeProvider, useOfflineMode, useOptionalOfflineMode, } from './OfflineModeProvider';
+export type { OfflineModeContextValue, OfflineModeProviderProps, } from './OfflineModeProvider';

package/dist/providers/index.js

@@ -1,12 +1,12 @@
-import { SuspenseConfigProvider } from '../chunk-YNP2OBK4.js';
+import { SuspenseConfigProvider } from '../chunk-RIZ76XRF.js';
+import { recordTransition, registerCheck, bindEventBus, bindTraitStateGetter } from '../chunk-45CTDYBT.js';
+import '../chunk-KKCVDUK7.js';
 import { ThemeProvider } from '../chunk-BTXQJGFB.js';
 import { SelectionProvider, EntityDataProvider } from '../chunk-PE2H3NAW.js';
 export { SelectionContext, SelectionProvider, useSelection, useSelectionOptional } from '../chunk-PE2H3NAW.js';
 import { useEventBus, EventBusProvider } from '../chunk-YXZM3WCF.js';
 export { EventBusContext, EventBusProvider } from '../chunk-YXZM3WCF.js';
 import '../chunk-7NEWMNNU.js';
-import { recordTransition, registerCheck, bindEventBus, bindTraitStateGetter } from '../chunk-45CTDYBT.js';
-import '../chunk-KKCVDUK7.js';
 import { useOfflineExecutor } from '../chunk-PL7MD6GF.js';
 import '../chunk-PKBMQBKP.js';
 import { createContext, useState, useCallback, useMemo, useContext, useRef, useEffect } from 'react';

package/dist/renderer/client-effect-executor.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Client Effect Executor
+ *
+ * Executes client effects returned from the server.
+ * This is the core of the dual execution model - the server processes
+ * events and returns client effects, which this module executes.
+ *
+ * Used by both Builder preview and compiled shells.
+ *
+ * @packageDocumentation
+ */
+import type { ClientEffect, ClientEffectExecutorConfig, PatternConfig, NotifyOptions } from './types';
+/**
+ * Execute an array of client effects.
+ *
+ * Effects are executed sequentially in order.
+ * Errors in one effect don't prevent subsequent effects from executing.
+ *
+ * @param effects - Array of client effects to execute
+ * @param config - Configuration providing implementations for each effect type
+ *
+ * @example
+ * ```typescript
+ * executeClientEffects(
+ *   [
+ *     ['render-ui', 'main', { type: 'entity-table', entity: 'Task' }],
+ *     ['notify', 'Tasks loaded!', { type: 'success' }]
+ *   ],
+ *   {
+ *     renderToSlot: (slot, pattern) => slotManager.render(slot, pattern),
+ *     navigate: (path) => router.push(path),
+ *     notify: (message, opts) => toast.show(message, opts),
+ *     eventBus: { emit: (event, payload) => bus.emit(event, payload) }
+ *   }
+ * );
+ * ```
+ */
+export declare function executeClientEffects(effects: ClientEffect[], config: ClientEffectExecutorConfig): void;
+/**
+ * Parse a raw effect array into a typed ClientEffect.
+ * Handles unknown effect formats gracefully.
+ */
+export declare function parseClientEffect(raw: unknown[]): ClientEffect | null;
+/**
+ * Parse an array of raw effects into typed ClientEffects.
+ * Filters out invalid effects.
+ */
+export declare function parseClientEffects(raw: unknown[] | undefined): ClientEffect[];
+/**
+ * Filter effects by type.
+ */
+export declare function filterEffectsByType<T extends ClientEffect[0]>(effects: ClientEffect[], type: T): Extract<ClientEffect, [T, ...unknown[]]>[];
+/**
+ * Get all render-ui effects.
+ */
+export declare function getRenderUIEffects(effects: ClientEffect[]): Array<['render-ui', string, PatternConfig | null]>;
+/**
+ * Get all navigate effects.
+ */
+export declare function getNavigateEffects(effects: ClientEffect[]): Array<['navigate', string, Record<string, unknown>?]>;
+/**
+ * Get all notify effects.
+ */
+export declare function getNotifyEffects(effects: ClientEffect[]): Array<['notify', string, NotifyOptions?]>;
+/**
+ * Get all emit effects.
+ */
+export declare function getEmitEffects(effects: ClientEffect[]): Array<['emit', string, unknown?]>;

package/dist/renderer/data-resolver.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Data Resolver
+ *
+ * Resolves entity data for pattern rendering.
+ * Supports multiple data sources with priority:
+ * 1. Server-provided data (from EventResponse.data)
+ * 2. Entity store (Builder in-memory mock data)
+ * 3. Empty array (fallback)
+ *
+ * Used by both Builder's PatternRenderer and compiled shell's UISlotRenderer.
+ *
+ * @packageDocumentation
+ */
+import type { DataContext, DataResolution } from './types';
+/**
+ * Resolve entity data from available sources.
+ *
+ * Priority:
+ * 1. fetchedData (from server response) - highest priority
+ * 2. entityStore (Builder mock data)
+ * 3. Empty array (fallback)
+ *
+ * @param entityName - Name of the entity to resolve data for
+ * @param context - Data context with available sources
+ * @returns Resolved data with loading state
+ *
+ * @example
+ * ```typescript
+ * const { data, loading } = resolveEntityData('Task', {
+ *   fetchedData: response.data,
+ *   entityStore: mockStore
+ * });
+ * ```
+ */
+export declare function resolveEntityData(entityName: string, context: DataContext): DataResolution;
+/**
+ * Resolve entity data with query filtering.
+ *
+ * Applies query singleton filters if available.
+ *
+ * @param entityName - Name of the entity
+ * @param queryRef - Optional query reference for filtering
+ * @param context - Data context
+ * @returns Filtered resolved data
+ */
+export declare function resolveEntityDataWithQuery(entityName: string, queryRef: string | undefined, context: DataContext): DataResolution;
+/**
+ * Get a single entity record by ID.
+ */
+export declare function resolveEntityById(entityName: string, id: string | number, context: DataContext): unknown | null;
+/**
+ * Get the count of entities matching criteria.
+ */
+export declare function resolveEntityCount(entityName: string, context: DataContext, filters?: Record<string, unknown>): number;
+/**
+ * Check if any entities exist for a given entity name.
+ */
+export declare function hasEntities(entityName: string, context: DataContext): boolean;
+/**
+ * Create a data context from fetched data only.
+ * Convenience function for compiled shells.
+ */
+export declare function createFetchedDataContext(data: Record<string, unknown[]>): DataContext;
+/**
+ * Merge multiple data contexts.
+ * Later contexts take precedence.
+ */
+export declare function mergeDataContexts(...contexts: DataContext[]): DataContext;

package/dist/renderer/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared Renderer Module
+ *
+ * Provides unified rendering logic for both Builder preview and compiled shells.
+ * This is the core of the runtime unification - both systems use this same code.
+ *
+ * Key components:
+ * - Types: Shared type definitions for effects, patterns, responses
+ * - Pattern Resolver: Pattern → Component resolution
+ * - Client Effect Executor: Execute clientEffects from server
+ * - useClientEffects: React hook for effect execution
+ * - Data Resolver: Entity data resolution with filtering
+ * - Slot Definitions: Inline vs portal slot configuration
+ *
+ * @packageDocumentation
+ */
+export type { ClientEffect, NotifyOptions, ClientEffectExecutorConfig, PatternConfig, ResolvedPattern, EventResponse, UISlot, SlotType, SlotDefinition, DataContext, DataResolution, } from './types';
+export { resolvePattern, isKnownPattern, getKnownPatterns, getPatternsByCategory, getPatternMapping, getPatternDefinition, initializePatternResolver, setComponentMapping, setPatternRegistry, } from './pattern-resolver';
+export { executeClientEffects, parseClientEffect, parseClientEffects, filterEffectsByType, getRenderUIEffects, getNavigateEffects, getNotifyEffects, getEmitEffects, } from './client-effect-executor';
+export { useClientEffects, useClientEffectConfig, useClientEffectConfigOptional, ClientEffectConfigProvider, ClientEffectConfigContext, } from './useClientEffects';
+export type { UseClientEffectsOptions, UseClientEffectsResult, } from './useClientEffects';
+export { resolveEntityData, resolveEntityDataWithQuery, resolveEntityById, resolveEntityCount, hasEntities, createFetchedDataContext, mergeDataContexts, } from './data-resolver';
+export { SLOT_DEFINITIONS, getSlotDefinition, isPortalSlot, isInlineSlot, getSlotsByType, getInlineSlots, getPortalSlots, ALL_SLOTS, } from './slot-definitions';
+export { OfflineExecutor, createOfflineExecutor, useOfflineExecutor, } from './offline-executor';
+export type { PendingSyncEffect, OfflineExecutorConfig, OfflineExecutorState, UseOfflineExecutorOptions, UseOfflineExecutorResult, } from './offline-executor';
+export { NavigationProvider, useNavigation, useNavigateTo, useNavigationState, useInitPayload, useActivePage, useNavigationId, matchPath, extractRouteParams, pathMatches, findPageByPath, findPageByName, getDefaultPage, getAllPages, } from './navigation';
+export type { NavigationState, NavigationContextValue, NavigationProviderProps, } from './navigation';
+export { initializePatterns } from './init';

package/dist/renderer/index.js

@@ -126,7 +126,7 @@ function useClientEffects(effects, options) {
     }
     execute(effects);
   }, [effects, enabled, execute]);
-  const prevEffectsRef = useRef();
+  const prevEffectsRef = useRef(void 0);
   useEffect(() => {
     if (effects !== prevEffectsRef.current) {
       prevEffectsRef.current = effects;

package/dist/renderer/init.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Pattern Resolver Initialization
+ *
+ * Loads pattern registry and component mapping from orbital-shared/patterns/
+ * and initializes the pattern resolver at app startup.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Initialize the pattern resolver with shared pattern data.
+ * Must be called once at app startup before any pattern rendering.
+ * @returns The number of patterns initialized
+ */
+export declare function initializePatterns(): number;

package/dist/renderer/navigation.d.ts

@@ -0,0 +1,142 @@
+/**
+ * NavigationContext - Schema-Driven Navigation for Orbital Runtime
+ *
+ * Provides navigation within the orbital schema without react-router dependency.
+ * Navigation works by:
+ * 1. Matching path to a page in the schema
+ * 2. Extracting route params (e.g., /inspection/:id → { id: "123" })
+ * 3. Switching active page
+ * 4. Triggering INIT with merged payload
+ *
+ * This approach works whether OrbitalRuntime is standalone or embedded in another app.
+ *
+ * Used by both:
+ * - Builder runtime (interpreted execution)
+ * - Compiled shells (generated applications)
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { OrbitalSchema, OrbitalPage } from '@almadar/core';
+/**
+ * Match a concrete path against a pattern with :param placeholders.
+ * Returns null if no match, or the extracted params if match.
+ *
+ * @example
+ * matchPath('/inspection/:id', '/inspection/123') // { id: '123' }
+ * matchPath('/users/:userId/posts/:postId', '/users/42/posts/7') // { userId: '42', postId: '7' }
+ * matchPath('/about', '/about') // {}
+ * matchPath('/about', '/contact') // null
+ */
+export declare function matchPath(pattern: string, path: string): Record<string, string> | null;
+/**
+ * Extract route params from a path given its pattern.
+ * Wrapper around matchPath for explicit use.
+ */
+export declare function extractRouteParams(pattern: string, path: string): Record<string, string>;
+/**
+ * Check if a path matches a pattern.
+ */
+export declare function pathMatches(pattern: string, path: string): boolean;
+/**
+ * Find a page in the schema by matching its path pattern against a concrete path.
+ * Returns the page and extracted route params.
+ */
+export declare function findPageByPath(schema: OrbitalSchema, path: string): {
+    page: OrbitalPage;
+    params: Record<string, string>;
+    orbitalName: string;
+} | null;
+/**
+ * Find a page by name.
+ */
+export declare function findPageByName(schema: OrbitalSchema, pageName: string): {
+    page: OrbitalPage;
+    orbitalName: string;
+} | null;
+/**
+ * Get the first page in the schema (default page).
+ */
+export declare function getDefaultPage(schema: OrbitalSchema): {
+    page: OrbitalPage;
+    orbitalName: string;
+} | null;
+/**
+ * Get all pages from the schema.
+ */
+export declare function getAllPages(schema: OrbitalSchema): Array<{
+    page: OrbitalPage;
+    orbitalName: string;
+}>;
+export interface NavigationState {
+    /** Current active page name */
+    activePage: string;
+    /** Current path (for URL sync) */
+    currentPath: string;
+    /** Payload to pass to INIT when page loads */
+    initPayload: Record<string, unknown>;
+    /** Navigation counter (increments on each navigation) */
+    navigationId: number;
+}
+export interface NavigationContextValue {
+    /** Current navigation state */
+    state: NavigationState;
+    /** Navigate to a path with optional payload */
+    navigateTo: (path: string, payload?: Record<string, unknown>) => void;
+    /** Navigate to a page by name with optional payload */
+    navigateToPage: (pageName: string, payload?: Record<string, unknown>) => void;
+    /** The schema being navigated */
+    schema: OrbitalSchema;
+    /** Whether navigation is ready (schema loaded) */
+    isReady: boolean;
+}
+export interface NavigationProviderProps {
+    /** The schema to navigate within */
+    schema: OrbitalSchema;
+    /** Initial page name (optional, defaults to first page) */
+    initialPage?: string;
+    /** Whether to update browser URL on navigation (default: true) */
+    updateUrl?: boolean;
+    /** Callback when navigation occurs */
+    onNavigate?: (pageName: string, path: string, payload: Record<string, unknown>) => void;
+    /** Children */
+    children: React.ReactNode;
+}
+/**
+ * NavigationProvider - Provides schema-driven navigation context
+ *
+ * @example
+ * ```tsx
+ * <NavigationProvider schema={mySchema}>
+ *   <OrbitalRuntimeContent />
+ * </NavigationProvider>
+ * ```
+ */
+export declare function NavigationProvider({ schema, initialPage, updateUrl, onNavigate, children, }: NavigationProviderProps): React.ReactElement;
+/**
+ * Hook to access navigation context.
+ * Returns null if not within NavigationProvider.
+ */
+export declare function useNavigation(): NavigationContextValue | null;
+/**
+ * Hook to get the navigateTo function.
+ * Returns a no-op function if not within NavigationProvider.
+ */
+export declare function useNavigateTo(): (path: string, payload?: Record<string, unknown>) => void;
+/**
+ * Hook to get current navigation state.
+ */
+export declare function useNavigationState(): NavigationState | null;
+/**
+ * Hook to get the current INIT payload (for passing to trait INIT events).
+ */
+export declare function useInitPayload(): Record<string, unknown>;
+/**
+ * Hook to get current active page name.
+ */
+export declare function useActivePage(): string | null;
+/**
+ * Hook to get navigation ID (changes on each navigation, useful for triggering effects).
+ */
+export declare function useNavigationId(): number;
+export default NavigationProvider;