@almadar/ui 5.111.0 → 5.113.0

package/dist/TraitProvider-YkK6tXDw.d.ts

@@ -0,0 +1,236 @@
+import * as React from 'react';
+import React__default, { ReactNode } from 'react';
+import { ResolvedEntity, EventPayload, EntityRow, OrbitalSchema, BusEventSource, SExpr, ResolvedTrait, ResolvedTraitBinding } from '@almadar/core';
+import { AnyPatternConfig } from '@almadar/core/patterns';
+
+/**
+ * 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
+ */
+
+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>;
+}
+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__default.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.
+ */
+declare function EntitySchemaProvider({ entities, traitLinkedEntities, orbitalsByTrait, children, }: EntitySchemaProviderProps): React__default.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.
+ */
+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).
+ */
+declare function useEntitySchemaOptional(): EntitySchemaContextValue | null;
+
+/** 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;
+}
+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 */
+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;
+}
+interface SendEventResult {
+    effects: ServerClientEffect[];
+    meta: ServerResponseMeta;
+}
+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.
+ */
+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.
+ */
+declare function useServerBridge(): ServerBridgeContextValue;
+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;
+}
+declare function ServerBridgeProvider({ schema, serverUrl, transport: customTransport, children, }: ServerBridgeProviderProps): React.JSX.Element;
+
+/**
+ * TraitProvider Component
+ *
+ * Provides trait state machines to child components via React context.
+ *
+ * @packageDocumentation
+ */
+
+interface TraitInstance {
+    /** Trait name */
+    name: string;
+    /** Current state */
+    currentState: string;
+    /** Available events (can be triggered) */
+    availableEvents: string[];
+    /** Dispatch an event to the state machine */
+    dispatch: (eventKey: string, payload?: EventPayload) => void;
+    /** Check if an event can be dispatched */
+    canDispatch: (eventKey: string) => boolean;
+    /** Get the full trait definition */
+    trait: ResolvedTrait;
+}
+interface TraitContextValue {
+    /** All trait instances on this page */
+    traits: Map<string, TraitInstance>;
+    /** Get a trait instance by name */
+    getTrait: (name: string) => TraitInstance | undefined;
+    /** Dispatch an event to a specific trait */
+    dispatchToTrait: (traitName: string, eventKey: string, payload?: EventPayload) => void;
+    /** Check if an event can be dispatched to a trait */
+    canDispatch: (traitName: string, eventKey: string) => boolean;
+}
+declare const TraitContext: React__default.Context<TraitContextValue | null>;
+interface TraitProviderProps {
+    /** Trait bindings for this page */
+    traits: ResolvedTraitBinding[];
+    /** Entity map for context */
+    entities: Map<string, ResolvedEntity>;
+    /** Children to render */
+    children: React__default.ReactNode;
+}
+declare function TraitProvider({ traits: traitBindings, children, }: TraitProviderProps): React__default.ReactElement;
+/**
+ * Access the trait context from within the TraitProvider.
+ */
+declare function useTraitContext(): TraitContextValue;
+/**
+ * Access a specific trait instance.
+ */
+declare function useTrait(traitName: string): TraitInstance | undefined;
+
+export { type EntitySchemaContextValue as E, type SendEventResult as S, TraitContext as T, EntitySchemaProvider as a, type EntitySchemaProviderProps as b, type ServerBridgeContextValue as c, ServerBridgeProvider as d, type ServerBridgeProviderProps as e, type ServerBridgeTransport as f, type ServerClientEffect as g, type ServerResponseMeta as h, type TraitContextValue as i, type TraitInstance as j, TraitProvider as k, type TraitProviderProps as l, useEntitySchemaOptional as m, useServerBridge as n, useTrait as o, useTraitContext as p, useEntitySchema as u };

package/dist/{providers/UISlotContext.d.ts → UISlotContext-C1FsU9GB.d.ts}

@@ -1,3 +1,7 @@
+import React__default from 'react';
+import { U as UISlotManager, b as SlotContent } from './useUISlots-BesZYMks.js';
+import { UISlot } from '@almadar/core';
+
 /**
  * UISlotContext
  *
@@ -18,21 +22,20 @@
  *
  * @packageDocumentation
  */
-import React from 'react';
-import { type UISlotManager, type UISlot, type SlotContent, type SlotProps, type SlotPropValue, type SlotCallback, type SlotRenderConfig, type SlotAnimation, type SlotChangeCallback } from '../hooks/useUISlots';
+
 /**
  * Context for the UI Slot Manager
  */
-declare const UISlotContext: React.Context<UISlotManager | null>;
-export interface UISlotProviderProps {
-    children: React.ReactNode;
+declare const UISlotContext: React__default.Context<UISlotManager | null>;
+interface UISlotProviderProps {
+    children: React__default.ReactNode;
 }
 /**
  * Provider component that creates and provides the UI Slot Manager.
  *
  * Must wrap any components that use traits with render_ui effects.
  */
-export declare function UISlotProvider({ children }: UISlotProviderProps): React.ReactElement;
+declare function UISlotProvider({ children }: UISlotProviderProps): React__default.ReactElement;
 /**
  * Hook to access the UI Slot Manager.
  *
@@ -61,15 +64,16 @@ export declare function UISlotProvider({ children }: UISlotProviderProps): React
  * }
  * ```
  */
-export declare function useUISlots(): UISlotManager;
+declare function useUISlots(): UISlotManager;
 /**
  * Hook to get content for a specific slot.
  *
  * Useful for components that only need to read slot state.
  */
-export declare function useSlotContent(slot: UISlot): SlotContent | null;
+declare function useSlotContent(slot: UISlot): SlotContent | null;
 /**
  * Hook to check if a slot has content.
  */
-export declare function useSlotHasContent(slot: UISlot): boolean;
-export { UISlotContext, type UISlotManager, type UISlot, type SlotContent, type SlotProps, type SlotPropValue, type SlotCallback, type SlotRenderConfig, type SlotAnimation, type SlotChangeCallback, };
+declare function useSlotHasContent(slot: UISlot): boolean;
+
+export { UISlotContext as U, UISlotProvider as a, useSlotHasContent as b, useUISlots as c, useSlotContent as u };

package/dist/UISlotContext-D8_SoDsD.d.cts

@@ -0,0 +1,79 @@
+import React__default from 'react';
+import { U as UISlotManager, b as SlotContent } from './useUISlots-BesZYMks.cjs';
+import { UISlot } from '@almadar/core';
+
+/**
+ * UISlotContext
+ *
+ * React context for providing the UI Slot Manager throughout the application.
+ * Traits use this context to render content into slots via render_ui effects.
+ *
+ * Usage:
+ * ```tsx
+ * // In App.tsx or layout
+ * <UISlotProvider>
+ *   <App />
+ * </UISlotProvider>
+ *
+ * // In trait hooks or components
+ * const { render, clear } = useUISlots();
+ * render({ target: 'modal', pattern: 'form-section', props: {...} });
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Context for the UI Slot Manager
+ */
+declare const UISlotContext: React__default.Context<UISlotManager | null>;
+interface UISlotProviderProps {
+    children: React__default.ReactNode;
+}
+/**
+ * Provider component that creates and provides the UI Slot Manager.
+ *
+ * Must wrap any components that use traits with render_ui effects.
+ */
+declare function UISlotProvider({ children }: UISlotProviderProps): React__default.ReactElement;
+/**
+ * Hook to access the UI Slot Manager.
+ *
+ * Must be used within a UISlotProvider.
+ *
+ * @throws Error if used outside of UISlotProvider
+ *
+ * @example
+ * ```tsx
+ * function MyTraitHook() {
+ *   const { render, clear } = useUISlots();
+ *
+ *   const showModal = () => {
+ *     render({
+ *       target: 'modal',
+ *       pattern: 'form-section',
+ *       props: { title: 'Create Item' },
+ *     });
+ *   };
+ *
+ *   const closeModal = () => {
+ *     clear('modal');
+ *   };
+ *
+ *   return { showModal, closeModal };
+ * }
+ * ```
+ */
+declare function useUISlots(): UISlotManager;
+/**
+ * Hook to get content for a specific slot.
+ *
+ * Useful for components that only need to read slot state.
+ */
+declare function useSlotContent(slot: UISlot): SlotContent | null;
+/**
+ * Hook to check if a slot has content.
+ */
+declare function useSlotHasContent(slot: UISlot): boolean;
+
+export { UISlotContext as U, UISlotProvider as a, useSlotHasContent as b, useUISlots as c, useSlotContent as u };

package/dist/UserContext-bziZwgFL.d.cts

@@ -0,0 +1,278 @@
+import * as React from 'react';
+import React__default, { ReactNode, ReactElement } from 'react';
+import { ThemeRef, FieldValue } from '@almadar/core';
+
+/**
+ * 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
+ */
+
+/** Color mode preference */
+type ColorMode = "light" | "dark" | "system";
+/** Resolved color mode (what's actually applied) */
+type ResolvedMode = "light" | "dark";
+/** Theme definition */
+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 */
+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__default.Context<ThemeContextValue | undefined>;
+interface ThemeProviderProps {
+    children: React__default.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__default.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>
+ * ```
+ */
+declare const ThemeProvider: React__default.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>
+ * ```
+ */
+declare function useTheme(): ThemeContextValue;
+type DesignTheme = UIThemeDefinition;
+
+/**
+ * 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>
+ * ```
+ */
+
+interface OrbitalThemeProviderProps {
+    /** The `OrbitalDefinition.theme` value (inline definition or string ref). */
+    theme?: ThemeRef;
+    children: ReactNode;
+}
+declare function OrbitalThemeProvider({ theme, children }: OrbitalThemeProviderProps): ReactElement;
+declare namespace OrbitalThemeProvider {
+    var displayName: string;
+}
+
+/**
+ * @deprecated Use ThemeProvider from ThemeContext instead
+ */
+declare const DesignThemeProvider: React.FC<ThemeProviderProps>;
+/**
+ * @deprecated Use useTheme from ThemeContext instead
+ *
+ * This wrapper provides backward compatibility with the old API.
+ */
+declare function useDesignTheme(): {
+    designTheme: string;
+    setDesignTheme: (theme: string) => void;
+    availableThemes: string[];
+};
+
+declare const CurrentPagePathContext: React__default.Context<string | undefined>;
+interface CurrentPagePathProviderProps {
+    value: string | undefined;
+    children: React__default.ReactNode;
+}
+declare const CurrentPagePathProvider: React__default.FC<CurrentPagePathProviderProps>;
+declare const useCurrentPagePath: () => string | undefined;
+
+/**
+ * UserContext
+ *
+ * React context for providing user data throughout the application.
+ * Enables @user bindings in S-expressions for role-based UI and permissions.
+ *
+ * Usage:
+ * ```tsx
+ * // In App.tsx or layout
+ * <UserProvider user={{ id: '123', role: 'admin', permissions: ['read', 'write'] }}>
+ *   <App />
+ * </UserProvider>
+ *
+ * // In components - access via hook
+ * const { user, hasRole, hasPermission } = useUser();
+ * if (hasRole('admin')) { ... }
+ * if (hasPermission('delete')) { ... }
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * User data for @user bindings.
+ * Matches UserContext type from evaluator/context.ts
+ */
+interface UserData {
+    /** User's unique ID */
+    id: string;
+    /** User's email */
+    email?: string;
+    /** User's display name */
+    name?: string;
+    /** User's role (for RBAC) */
+    role?: string;
+    /** User's permissions */
+    permissions?: string[];
+    /** Additional custom profile fields */
+    [key: string]: FieldValue | undefined;
+}
+/**
+ * User context value.
+ */
+interface UserContextValue {
+    /** Current user data (null if not logged in) */
+    user: UserData | null;
+    /** Check if user is logged in */
+    isLoggedIn: boolean;
+    /** Check if user has a specific role */
+    hasRole: (role: string) => boolean;
+    /** Check if user has a specific permission */
+    hasPermission: (permission: string) => boolean;
+    /** Check if user has any of the specified roles */
+    hasAnyRole: (roles: string[]) => boolean;
+    /** Check if user has all of the specified permissions */
+    hasAllPermissions: (permissions: string[]) => boolean;
+    /** Get a user field by path (for @user.field bindings) */
+    getUserField: (path: string) => FieldValue | undefined;
+}
+/**
+ * Anonymous user for when no user is logged in.
+ */
+declare const ANONYMOUS_USER: UserData;
+declare const UserContext: React__default.Context<UserContextValue | null>;
+interface UserProviderProps {
+    /** User data (null if not logged in) */
+    user?: UserData | null;
+    /** Children to render */
+    children: React__default.ReactNode;
+}
+/**
+ * Provider component that provides user context to the application.
+ *
+ * Provides RBAC helpers and field access for @user bindings.
+ */
+declare function UserProvider({ user, children, }: UserProviderProps): React__default.ReactElement;
+/**
+ * Hook to access the user context.
+ *
+ * Returns default values if used outside of UserProvider (for resilience).
+ *
+ * @example
+ * ```tsx
+ * function AdminPanel() {
+ *   const { user, hasRole, hasPermission } = useUser();
+ *
+ *   if (!hasRole('admin') && !hasPermission('admin:access')) {
+ *     return <AccessDenied />;
+ *   }
+ *
+ *   return <div>Welcome, {user?.name}</div>;
+ * }
+ * ```
+ */
+declare function useUser(): UserContextValue;
+/**
+ * Hook to check if user has a specific role.
+ * Convenience wrapper around useUser().hasRole().
+ */
+declare function useHasRole(role: string): boolean;
+/**
+ * Hook to check if user has a specific permission.
+ * Convenience wrapper around useUser().hasPermission().
+ */
+declare function useHasPermission(permission: string): boolean;
+/**
+ * Hook to get user data for @user bindings in S-expressions.
+ * Returns the user data object compatible with EvaluationContext.user
+ */
+declare function useUserForEvaluation(): UserData | undefined;
+
+export { ANONYMOUS_USER as A, BUILT_IN_THEMES as B, type ColorMode as C, type DesignTheme as D, OrbitalThemeProvider as O, type ResolvedMode as R, ThemeContext as T, type UIThemeDefinition as U, CurrentPagePathContext as a, CurrentPagePathProvider as b, type CurrentPagePathProviderProps as c, DesignThemeProvider as d, type OrbitalThemeProviderProps as e, ThemeProvider as f, type ThemeProviderProps as g, UserContext as h, type UserContextValue as i, type UserData as j, UserProvider as k, type UserProviderProps as l, useDesignTheme as m, useHasPermission as n, useHasRole as o, useTheme as p, useUser as q, useUserForEvaluation as r, useCurrentPagePath as u };