@almadar/ui 5.78.0 → 5.79.1

package/dist/providers/CurrentPagePathContext.d.ts

@@ -1,9 +0,0 @@
-import React from 'react';
-declare const CurrentPagePathContext: React.Context<string | undefined>;
-export interface CurrentPagePathProviderProps {
-    value: string | undefined;
-    children: React.ReactNode;
-}
-export declare const CurrentPagePathProvider: React.FC<CurrentPagePathProviderProps>;
-export declare const useCurrentPagePath: () => string | undefined;
-export { CurrentPagePathContext };

package/dist/providers/DesignThemeContext.d.ts

@@ -1,21 +0,0 @@
-/** @deprecated Use ThemeDefinition from ThemeContext */
-export type DesignTheme = string;
-/**
- * @deprecated Use ThemeProvider from ThemeContext instead
- */
-export declare const DesignThemeProvider: import("react").FC<import("./ThemeContext").ThemeProviderProps>;
-/**
- * @deprecated Use useTheme from ThemeContext instead
- *
- * This wrapper provides backward compatibility with the old API.
- */
-export declare function useDesignTheme(): {
-    designTheme: string;
-    setDesignTheme: (theme: string) => void;
-    availableThemes: string[];
-};
-declare const _default: {
-    DesignThemeProvider: import("react").FC<import("./ThemeContext").ThemeProviderProps>;
-    useDesignTheme: typeof useDesignTheme;
-};
-export default _default;

package/dist/providers/EntitySchemaContext.d.ts

@@ -1,81 +0,0 @@
-/**
- * EntitySchemaContext
- *
- * Minimal context providing entity schema definitions (field metadata).
- * This is NOT a data store — actual entity rows flow through the state
- * machine's `@payload.data` binding on the emitting trait's fetch-success
- * transition and land on the rendering component's `entity` prop.
- *
- * Replaces EntityStore's schema functionality without the mock data generation.
- *
- * @packageDocumentation
- */
-import React from 'react';
-import type { ResolvedEntity } from '@almadar/core';
-export interface EntitySchemaContextValue {
-    /** Entity definitions (schema metadata only) */
-    entities: Map<string, ResolvedEntity>;
-    /**
-     * Per-trait linkedEntity name. `ResolvedTrait` itself doesn't carry
-     * linkedEntity (it lives on `ResolvedTraitBinding` at the page-binding
-     * level), so OrbPreview pre-projects every page's trait bindings into
-     * a flat `traitName → entityName` map for the slot renderer.
-     *
-     * Used by SlotContentRenderer to resolve `entityDef` via
-     * `traitLinkedEntities.get(sourceTrait) → entities.get(...)` when the
-     * rendered pattern's `entity:` prop is a resolved value (V2 path)
-     * rather than a string entity-name. Without this lookup, form-section
-     * can't enrich its fields with entity field metadata (values enum,
-     * etc.) and an enum field renders as a plain text input. Closes VR3.
-     */
-    traitLinkedEntities: ReadonlyMap<string, string>;
-    /**
-     * Per-trait owning-orbital name. Same shape as `traitLinkedEntities`,
-     * built from `schema.orbitals[].traits[]`. UISlotRenderer uses this
-     * to wrap each slot's rendered subtree in `TraitScopeProvider` so
-     * descendant pure components (Button, etc.) emit qualified
-     * `UI:Orbital.Trait.EVENT` keys via the scoped useEventBus.
-     */
-    orbitalsByTrait: ReadonlyMap<string, string>;
-}
-export interface EntitySchemaProviderProps {
-    /** Entity definitions from resolved schema */
-    entities: ResolvedEntity[];
-    /**
-     * Per-trait linkedEntity name, projected from every page's
-     * ResolvedTraitBinding. Optional for back-compat; when omitted,
-     * SlotContentRenderer's enrichment path can only follow the
-     * legacy V1 string-entity-name lookup.
-     */
-    traitLinkedEntities?: ReadonlyMap<string, string>;
-    /**
-     * Per-trait owning-orbital name. Required for the runtime path's
-     * trait-scoped event qualification (Button etc. emit qualified keys
-     * via TraitScopeProvider). Optional for back-compat with consumers
-     * that don't yet thread the orbital map through.
-     */
-    orbitalsByTrait?: ReadonlyMap<string, string>;
-    /** Children */
-    children: React.ReactNode;
-}
-/**
- * Provides entity schema definitions to the component tree.
- *
- * This is a lightweight provider that only holds schema metadata (field definitions).
- * Actual entity rows arrive via `@payload.data` on the rendering trait's
- * success transition — they do NOT live in this context.
- */
-export declare function EntitySchemaProvider({ entities, traitLinkedEntities, orbitalsByTrait, children, }: EntitySchemaProviderProps): React.ReactElement;
-/**
- * Access entity schema definitions.
- * Use this for field metadata (form building, filter enrichment).
- * Actual entity rows flow via `@payload.data` on the state machine's
- * success transition — never read them from a context.
- */
-export declare function useEntitySchema(): EntitySchemaContextValue;
-/**
- * Safe version of useEntitySchema that returns null when no provider is present.
- * Used by UISlotRenderer which may render outside an EntitySchemaProvider (compiled mode).
- */
-export declare function useEntitySchemaOptional(): EntitySchemaContextValue | null;
-export default EntitySchemaProvider;

package/dist/providers/EventBusProvider.d.ts

@@ -1,47 +0,0 @@
-/**
- * EventBusProvider - React context provider for the event bus
- *
- * Provides a page-scoped event bus for trait communication.
- * Each page has its own event bus instance.
- *
- * NOTE: Selection state has been moved to SelectionProvider.
- * Use SelectionProvider for tracking selected entities.
- *
- * @packageDocumentation
- */
-import React, { type ReactNode } from 'react';
-import type { EventBusContextType } from '../types/event-bus-types';
-import type { EntityRow } from '@almadar/core';
-/**
- * Extended context type for backward compatibility.
- *
- * @deprecated getSelectedEntity and clearSelectedEntity are deprecated.
- * Use SelectionProvider and useSelection hook instead.
- */
-export interface EventBusContextTypeExtended extends EventBusContextType {
-    /** @deprecated Use useSelection from SelectionProvider instead. */
-    getSelectedEntity: () => EntityRow | null;
-    /** @deprecated Use useSelection from SelectionProvider instead. */
-    clearSelectedEntity: () => void;
-}
-export declare const EventBusContext: React.Context<EventBusContextTypeExtended | null>;
-interface EventBusProviderProps {
-    children: ReactNode;
-    /**
-     * @deprecated No-op. Logging is now gated by `@almadar/logger` —
-     * use `setLogLevel('DEBUG')` or `setNamespaceLevel('almadar:eventbus', 'DEBUG')`
-     * from `@almadar/logger` to control verbosity. Kept for API compatibility.
-     */
-    debug?: boolean;
-    /**
-     * When true, this provider does NOT register itself as the global event bus
-     * (`window.__kflowEventBus`). Use for SANDBOXED subtrees — e.g. a studio
-     * preview (`BrowserPlayground`) embedded inside a host app — whose internal
-     * events must stay context-local and must NOT clobber the host's global bus.
-     * Children still get this bus via React context; only the global bridge is
-     * skipped. Default false (root/standalone providers own the global bridge).
-     */
-    isolated?: boolean;
-}
-export declare function EventBusProvider({ children, isolated }: EventBusProviderProps): import("react/jsx-runtime").JSX.Element;
-export type { EventBusContextType };

package/dist/providers/OfflineModeProvider.d.ts

@@ -1,79 +0,0 @@
-/**
- * OfflineModeProvider
- *
- * Context provider that wraps useOfflineExecutor with force-offline toggle support.
- * Enables testing offline behavior without actually disconnecting.
- *
- * @packageDocumentation
- */
-import React from 'react';
-import { type UseOfflineExecutorOptions, type UseOfflineExecutorResult } from '../lib/offline-executor';
-export interface OfflineModeContextValue extends UseOfflineExecutorResult {
-    /** Force offline mode for testing */
-    forceOffline: boolean;
-    /** Toggle force offline mode */
-    setForceOffline: (value: boolean) => void;
-    /** Whether effectively offline (real or forced) */
-    effectivelyOffline: boolean;
-}
-export interface OfflineModeProviderProps extends UseOfflineExecutorOptions {
-    children: React.ReactNode;
-}
-/**
- * OfflineModeProvider - Wraps offline executor with force-offline support.
- *
- * @example
- * ```tsx
- * function App() {
- *   return (
- *     <OfflineModeProvider
- *       serverUrl="/api/orbitals"
- *       authToken={token}
- *       autoSync={true}
- *       renderToSlot={slotManager.render}
- *       navigate={router.push}
- *       notify={toast.show}
- *       eventBus={{ emit: bus.emit }}
- *     >
- *       <PreviewPage />
- *     </OfflineModeProvider>
- *   );
- * }
- * ```
- */
-export declare function OfflineModeProvider({ children, ...executorOptions }: OfflineModeProviderProps): React.ReactElement;
-/**
- * Access offline mode context.
- *
- * @example
- * ```tsx
- * function OfflineToggle() {
- *   const {
- *     effectivelyOffline,
- *     forceOffline,
- *     setForceOffline,
- *     pendingCount,
- *     sync,
- *   } = useOfflineMode();
- *
- *   return (
- *     <div>
- *       <Toggle
- *         checked={forceOffline}
- *         onChange={setForceOffline}
- *       >
- *         Test Offline
- *       </Toggle>
- *       {pendingCount > 0 && <Badge>{pendingCount} pending</Badge>}
- *       <Button onClick={sync}>Sync Now</Button>
- *     </div>
- *   );
- * }
- * ```
- */
-export declare function useOfflineMode(): OfflineModeContextValue;
-/**
- * Check if offline mode provider is available (optional usage).
- */
-export declare function useOptionalOfflineMode(): OfflineModeContextValue | null;
-export default OfflineModeProvider;

package/dist/providers/OrbitalProvider.d.ts

@@ -1,110 +0,0 @@
-/**
- * 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
- *
- * Entity data flows through props (via enrichFromResponse in ServerBridge),
- * not through context. FetchedDataProvider has been removed.
- *
- * @packageDocumentation
- */
-import React, { type ReactNode } from 'react';
-import type { EntityRow } from '@almadar/core';
-import { type UIThemeDefinition } from './ThemeContext';
-export interface OrbitalProviderProps {
-    children: ReactNode;
-    /** Custom themes (merged with built-in themes) */
-    themes?: UIThemeDefinition[];
-    /** 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 */
-    /** @deprecated No longer used. Entity data flows through server response props. */
-    initialData?: Record<string, EntityRow[]>;
-    /**
-     * 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;
-    /**
-     * Sandbox mode: the event bus stays context-local and does NOT register as
-     * the global bus. Set for studio previews embedded in a host app (so the
-     * preview's events don't clobber the host's global bus). Default false.
-     */
-    isolated?: 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, isolated, }: OrbitalProviderProps): React.ReactElement;
-export declare namespace OrbitalProvider {
-    var displayName: string;
-}
-export { ThemeProvider } from './ThemeContext';
-export { EventBusProvider } from './EventBusProvider';
-export { SelectionProvider } from './SelectionProvider';

package/dist/providers/OrbitalThemeProvider.d.ts

@@ -1,37 +0,0 @@
-/**
- * OrbitalThemeProvider — runtime application of `OrbitalDefinition.theme`.
- *
- * Wraps an orbital's rendered subtree in a wrapping `<div>` that sets the
- * CSS variables derived from `theme.tokens` (and `variants.dark` when the
- * resolved color mode is dark). Inline custom-property declarations on the
- * wrapper override any `[data-theme]` selector rule for the same variable
- * within the subtree, while letting unset variables cascade from the parent.
- *
- * Mapping is delegated to `themeTokensToCssVars`, which mirrors the Rust
- * compiler's `generate_tokens_css`. Compile-time and runtime produce the
- * same CSS variable map for the same `ThemeDefinition` input, so a Studio
- * Design System edit and an `orbital compile` of the same schema render
- * identically.
- *
- * No-op when:
- * - `theme` is `undefined` (orbital declares no theme — parent cascades)
- * - `theme` is a string ref that didn't get inlined upstream
- *
- * @example
- * ```tsx
- * <OrbitalThemeProvider theme={orbital.theme}>
- *   <UISlotRenderer />
- * </OrbitalThemeProvider>
- * ```
- */
-import { type ReactElement, type ReactNode } from 'react';
-import type { ThemeRef } from '@almadar/core';
-export interface OrbitalThemeProviderProps {
-    /** The `OrbitalDefinition.theme` value (inline definition or string ref). */
-    theme?: ThemeRef;
-    children: ReactNode;
-}
-export declare function OrbitalThemeProvider({ theme, children }: OrbitalThemeProviderProps): ReactElement;
-export declare namespace OrbitalThemeProvider {
-    var displayName: string;
-}

package/dist/providers/SelectionProvider.d.ts

@@ -1,82 +0,0 @@
-/**
- * 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';
-import type { EntityRow } from '@almadar/core';
-export interface SelectionContextType<T = EntityRow> {
-    /** 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<EntityRow> | null>;
-interface SelectionProviderProps {
-    children: ReactNode;
-    /** Enable debug logging */
-    debug?: boolean;
-    /** Custom comparison function for isSelected */
-    compareEntities?: (a: EntityRow, b: EntityRow) => 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 = EntityRow>(): 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 = EntityRow>(): SelectionContextType<T> | null;
-export { SelectionContext };

package/dist/providers/ServerBridge.d.ts

@@ -1,102 +0,0 @@
-import type { ReactNode } from 'react';
-import type { BusEventSource, EntityRow, EventPayload, OrbitalSchema, SExpr } from '@almadar/core';
-import type { AnyPatternConfig } from '@almadar/patterns';
-/** Wire-format client effect tuple from the server response. */
-type ClientEffectTuple = ['render-ui', string, AnyPatternConfig | null, ...SExpr[]] | ['navigate', string, ...SExpr[]] | ['notify', string, ...SExpr[]];
-interface OrbitalEventResponse {
-    success: boolean;
-    transitioned: boolean;
-    states: Record<string, string>;
-    /**
-     * Server-cascade events carried back in the response. Each entry has a
-     * `source: BusEventSource` stamped by the compiled handler (`emit ...
-     * { source: __ORBITAL_SOURCE }`) so the client can re-broadcast on the
-     * qualified `UI:Orbital.Trait.EVENT` bus key (gap #13).
-     */
-    emittedEvents?: Array<{
-        event: string;
-        payload?: EventPayload;
-        source?: BusEventSource;
-    }>;
-    data?: Record<string, EntityRow[]>;
-    clientEffects?: ClientEffectTuple[];
-    /**
-     * Same effects as `clientEffects`, paired with the trait that produced
-     * each one. When present, prefer this for trait attribution. Falls back
-     * to legacy `clientEffects` parsing on older servers.
-     */
-    clientEffectsByTrait?: Array<{
-        traitName: string;
-        effect: ClientEffectTuple;
-    }>;
-    error?: string;
-}
-export interface ServerClientEffect {
-    type: 'render-ui' | 'navigate' | 'notify';
-    slot?: string;
-    pattern?: AnyPatternConfig;
-    route?: string;
-    params?: EventPayload;
-    message?: string;
-    /**
-     * Trait that emitted this effect. Used by `<TraitFrame>` to resolve
-     * `@trait.X` bindings. Undefined when the server didn't tag the effect
-     * (older servers that pre-date the per-trait sidecar).
-     */
-    traitName?: string;
-}
-/** Metadata about what the server returned, for debugger logging */
-export interface ServerResponseMeta {
-    success: boolean;
-    clientEffects: number;
-    dataEntities: Record<string, number>;
-    /** Raw entity data from server response (for EntityStore advancement) */
-    data?: Record<string, EntityRow[]>;
-    emittedEvents: string[];
-    error?: string;
-}
-export interface SendEventResult {
-    effects: ServerClientEffect[];
-    meta: ServerResponseMeta;
-}
-export interface ServerBridgeContextValue {
-    connected: boolean;
-    sendEvent: (orbitalName: string, event: string, payload?: EventPayload) => Promise<SendEventResult>;
-}
-/**
- * Transport adapter for ServerBridgeProvider. Decouples the bridge's
- * cascade-rebroadcast / effect-parsing logic from its wire format.
- *
- * - The `serverUrl` mode (default) uses an HTTP transport that POSTs to
- *   `/register`, `/unregister`, `/:orbital/events`. This is what canonical
- *   playground-runtime (`tools/runtime-verify`) and apps/builder-server
- *   speak.
- * - The `transport` mode lets a consumer plug in a direct function-call
- *   adapter — used by `<BrowserPlayground>` to invoke
- *   `OrbitalServerRuntime.processOrbitalEvent` in-process, no HTTP, no
- *   server. Both modes return the same `OrbitalEventResponse` shape so the
- *   cascade-rebroadcast logic is identical downstream.
- */
-export interface ServerBridgeTransport {
-    register: (schema: OrbitalSchema) => Promise<boolean>;
-    unregister: () => Promise<void>;
-    sendEvent: (orbitalName: string, event: string, payload?: EventPayload) => Promise<OrbitalEventResponse>;
-}
-/**
- * Access the server bridge. Returns a no-op stub when outside the provider.
- */
-export declare function useServerBridge(): ServerBridgeContextValue;
-export interface ServerBridgeProviderProps {
-    schema: OrbitalSchema;
-    /** HTTP server URL (canonical playground-runtime / apps/builder-server). */
-    serverUrl?: string;
-    /**
-     * Custom transport adapter. Use this for in-process execution (e.g.
-     * `<BrowserPlayground>` invokes `OrbitalServerRuntime.processOrbitalEvent`
-     * directly). Mutually exclusive with `serverUrl`.
-     */
-    transport?: ServerBridgeTransport;
-    children: ReactNode;
-}
-export declare function ServerBridgeProvider({ schema, serverUrl, transport: customTransport, children, }: ServerBridgeProviderProps): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/providers/ThemeContext.d.ts

@@ -1,104 +0,0 @@
-/**
- * Unified ThemeContext - Single provider for theme and color mode
- *
- * Combines design theme selection (ocean, wireframe, etc.) with
- * color mode (light/dark) into a single, simple system.
- *
- * Uses a single data attribute: data-theme="ocean-light" or data-theme="ocean-dark"
- *
- * @packageDocumentation
- */
-import React from "react";
-/** Color mode preference */
-export type ColorMode = "light" | "dark" | "system";
-/** Resolved color mode (what's actually applied) */
-export type ResolvedMode = "light" | "dark";
-/** Theme definition */
-export interface UIThemeDefinition {
-    /** Theme identifier (e.g., "ocean", "wireframe") */
-    name: string;
-    /** Display name for UI (e.g., "Ocean Blue") */
-    displayName?: string;
-    /** Whether this theme has light mode styles */
-    hasLightMode?: boolean;
-    /** Whether this theme has dark mode styles */
-    hasDarkMode?: boolean;
-}
-/** Built-in themes available in the design system */
-export declare const BUILT_IN_THEMES: UIThemeDefinition[];
-/** Theme context value */
-interface ThemeContextValue {
-    /** Current theme name */
-    theme: string;
-    /** Current color mode setting (may be 'system') */
-    mode: ColorMode;
-    /** Resolved color mode (always 'light' or 'dark') */
-    resolvedMode: ResolvedMode;
-    /** Set the theme */
-    setTheme: (theme: string) => void;
-    /** Set the color mode */
-    setMode: (mode: ColorMode) => void;
-    /** Toggle between light and dark modes */
-    toggleMode: () => void;
-    /** Available themes */
-    availableThemes: UIThemeDefinition[];
-    /** The full theme string applied to data-theme (e.g., "ocean-light") */
-    appliedTheme: string;
-}
-declare const ThemeContext: React.Context<ThemeContextValue | undefined>;
-export interface ThemeProviderProps {
-    children: React.ReactNode;
-    /** Available themes (will be merged with built-in themes) */
-    themes?: readonly UIThemeDefinition[] | UIThemeDefinition[];
-    /** Default theme name */
-    defaultTheme?: string;
-    /** Default color mode */
-    defaultMode?: ColorMode;
-    /** Optional target element ref — when provided, theme attributes are applied to this element instead of document.documentElement */
-    targetRef?: React.RefObject<HTMLElement>;
-}
-/**
- * Unified ThemeProvider component
- *
- * @example
- * ```tsx
- * // Basic usage with built-in themes
- * <ThemeProvider defaultTheme="wireframe" defaultMode="light">
- *   <App />
- * </ThemeProvider>
- *
- * // With custom themes from orbital schema
- * import { THEMES } from './generated/theme-manifest';
- * <ThemeProvider themes={THEMES} defaultTheme="ocean" defaultMode="system">
- *   <App />
- * </ThemeProvider>
- * ```
- */
-export declare const ThemeProvider: React.FC<ThemeProviderProps>;
-/**
- * Hook for accessing theme context
- *
- * @returns Theme context value
- *
- * @example
- * ```tsx
- * const { theme, resolvedMode, toggleMode, setTheme } = useTheme();
- *
- * // Toggle dark mode
- * <button onClick={toggleMode}>
- *   {resolvedMode === 'dark' ? 'Light' : 'Dark'}
- * </button>
- *
- * // Change theme
- * <select value={theme} onChange={(e) => setTheme(e.target.value)}>
- *   {availableThemes.map(t => (
- *     <option key={t.name} value={t.name}>{t.displayName || t.name}</option>
- *   ))}
- * </select>
- * ```
- */
-export declare function useTheme(): ThemeContextValue;
-export type Theme = ColorMode;
-export type ResolvedTheme = ResolvedMode;
-export type DesignTheme = UIThemeDefinition;
-export default ThemeContext;