@elevasis/ui 1.2.1 → 1.3.1

package/dist/index.d.ts

@@ -44,8 +44,10 @@ declare function getPreset(name: PresetName | (string & {})): ThemePreset;
  */
 interface ApiClientContextValue {
     getAccessToken: () => Promise<string | undefined>;
+    /** @deprecated Read via getOrganizationId() instead. Kept for downstream context consumers during migration. */
     organizationId: string | null;
     isOrganizationReady: boolean;
+    getOrganizationId: () => string | null;
     onError?: (endpoint: string, error: Error, details?: ApiErrorDetails) => void;
 }
 interface ApiErrorDetails {
@@ -56,11 +58,70 @@ interface ApiErrorDetails {
 interface ApiClientProviderProps {
     children: React.ReactNode;
     getAccessToken: () => Promise<string | undefined>;
-    organizationId: string | null;
+    /**
+     * Static org ID. Used when org ID is stable at render time.
+     * Cannot reflect org switches without re-rendering the provider.
+     * Prefer getOrganizationId for dynamic org context.
+     * @deprecated Pass getOrganizationId instead for dynamic org resolution.
+     */
+    organizationId?: string | null;
+    /**
+     * Callback invoked on every request to read the current org ID.
+     * Takes precedence over organizationId when provided.
+     * Allows org switching without re-rendering the provider tree.
+     */
+    getOrganizationId?: () => string | null;
     isOrganizationReady: boolean;
     onError?: (endpoint: string, error: Error, details?: ApiErrorDetails) => void;
 }
 
+/**
+ * Pluggable notification adapter interface.
+ *
+ * Implement this to connect any notification library (Mantine, react-toastify, etc.)
+ * to the Elevasis UI hooks.
+ */
+interface NotificationAdapter {
+    success(title: string, message: string): void;
+    error(title: string, message: string): void;
+    info(title: string, message: string): void;
+    warning(title: string, message: string): void;
+    /** Formats and displays an API error using structured error-utils helpers. */
+    apiError(error: unknown): void;
+}
+/**
+ * Provides a notification adapter to all descendant components.
+ *
+ * Pass a `MantineNotificationAdapter` for Command Center, or any custom
+ * adapter for other consumers (template, tests, etc.).
+ *
+ * When omitted, hooks fall back to the console adapter automatically.
+ *
+ * @example
+ * ```tsx
+ * import { NotificationProvider } from '@repo/ui/provider'
+ * import { mantineNotificationAdapter } from '@repo/ui/provider'
+ *
+ * <NotificationProvider adapter={mantineNotificationAdapter}>
+ *   <App />
+ * </NotificationProvider>
+ * ```
+ */
+declare function NotificationProvider({ adapter, children }: {
+    adapter: NotificationAdapter;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Returns the active notification adapter.
+ *
+ * Falls back to the console adapter when used outside a NotificationProvider,
+ * so hooks remain functional in template environments without Mantine.
+ *
+ * Named `useNotificationAdapter` to avoid collision with the data-fetching
+ * `useNotifications` hook exported from `hooks/monitoring`.
+ */
+declare function useNotificationAdapter(): NotificationAdapter;
+
 /** Flat + per-scheme override pattern. Flat values apply to both; `light`/`dark` win over flat. */
 type WithSchemes<T> = T & {
     light?: T;
@@ -121,10 +182,10 @@ interface ElevasisThemeConfig extends ElevasisCoreThemeConfig {
 }
 /**
  * Auth configuration union.
- * 'authkit' (WorkOS AuthKit) and 'oauth' (WorkOS Connect) are implemented.
+ * 'authkit' (WorkOS AuthKit) is the supported mode.
  * 'apiKey' is defined for forward type compatibility but will throw at runtime.
  */
-type AuthConfig = AuthKitConfig | OAuthConfig | ApiKeyConfig;
+type AuthConfig = AuthKitConfig | ApiKeyConfig;
 interface AuthKitConfig {
     mode: 'authkit';
     clientId: string;
@@ -135,25 +196,13 @@ interface AuthKitConfig {
     /** Keep refresh tokens in localStorage. Defaults to false. */
     devMode?: boolean;
 }
-/** OAuth config for "Sign in with Elevasis" via WorkOS Connect. */
-interface OAuthConfig {
-    mode: 'oauth';
-    clientId: string;
-    redirectUri: string;
-    /** Persist tokens in sessionStorage. Default is memory-only. */
-    tokenStorage?: 'session';
-    /** Pre-select organization in WorkOS flow. */
-    organizationId?: string;
-    /** Auth provider for the authorize request. Defaults to 'authkit' (hosted login UI). */
-    provider?: 'authkit' | 'GoogleOAuth' | 'MicrosoftOAuth' | 'GitHubOAuth' | 'AppleOAuth';
-}
 /** Deferred -- will throw at runtime. */
 interface ApiKeyConfig {
     mode: 'apiKey';
     key: string;
 }
 interface ElevasisCoreProviderProps {
-    /** Auth configuration. Supports 'authkit' and 'oauth' modes. */
+    /** Auth configuration. Supports 'authkit' mode. */
     auth: AuthConfig;
     /**
      * Elevasis core theme configuration (Mantine-free).
@@ -162,16 +211,18 @@ interface ElevasisCoreProviderProps {
      */
     theme?: ElevasisCoreThemeConfig;
     /**
-     * Override organization ID resolution.
-     * Command-center passes Zustand-managed org ID here.
-     * SDK consumers typically omit this (auto-resolved from JWT/API key).
+     * @deprecated Organization ID is now resolved automatically via OrganizationProvider.
+     * This prop is accepted for backwards compatibility during migration but is no longer
+     * used when the full provider stack is active (apiUrl provided).
      */
     organizationId?: string | null;
     /** Custom QueryClient. If omitted, a default is created internally. */
     queryClient?: QueryClient;
     /**
      * API base URL (e.g., 'https://api.elevasis.com' or 'http://localhost:5170').
-     * When provided, ElevasisCoreProvider composes ApiClientProvider + ElevasisServiceProvider internally.
+     * When provided, ElevasisCoreProvider composes the full provider stack:
+     * ApiClientProvider + ElevasisServiceProvider + ProfileProvider +
+     * OrganizationProvider + NotificationProvider + InitializationProvider.
      * When omitted, no service context is provided (theme-only mode).
      */
     apiUrl?: string;
@@ -181,11 +232,19 @@ interface ElevasisCoreProviderProps {
      */
     onError?: (endpoint: string, error: Error, details?: ApiErrorDetails) => void;
     /**
-     * Override organization readiness check.
-     * Defaults to `!!organizationId` if not provided.
-     * Command-center passes `!!currentMembership` for its stricter readiness requirement.
+     * @deprecated Organization readiness is now managed internally by OrganizationProvider.
+     * Accepted for backwards compatibility but ignored when apiUrl is provided.
      */
     isOrganizationReady?: boolean;
+    /**
+     * Notification adapter for displaying success/error/info messages.
+     * When provided, wraps the subtree in a NotificationProvider with this adapter.
+     * When omitted, the console fallback adapter is used automatically.
+     *
+     * ElevasisUIProvider (Mantine variant) passes mantineNotificationAdapter here automatically.
+     * Headless/SDK consumers can pass a custom adapter or omit for console output.
+     */
+    notifications?: NotificationAdapter;
     /**
      * Whether to inject CSS variables, `data-elevasis-scheme` attribute, and font links.
      * Set to `false` when the consumer has its own complete design system and only
@@ -195,7 +254,7 @@ interface ElevasisCoreProviderProps {
     children: ReactNode;
 }
 interface ElevasisProviderProps {
-    /** Auth configuration. Supports 'authkit' and 'oauth' modes. */
+    /** Auth configuration. Supports 'authkit' mode. */
     auth: AuthConfig;
     /**
      * Elevasis theme configuration.
@@ -204,16 +263,15 @@ interface ElevasisProviderProps {
      */
     theme?: ElevasisThemeConfig;
     /**
-     * Override organization ID resolution.
-     * Command-center passes Zustand-managed org ID here.
-     * SDK consumers typically omit this (auto-resolved from JWT/API key).
+     * @deprecated Organization ID is now resolved automatically via OrganizationProvider.
+     * Accepted for backwards compatibility during migration but no longer used internally.
      */
     organizationId?: string | null;
     /** Custom QueryClient. If omitted, a default is created internally. */
     queryClient?: QueryClient;
     /**
      * API base URL (e.g., 'https://api.elevasis.com' or 'http://localhost:5170').
-     * When provided, ElevasisProvider composes ApiClientProvider + ElevasisServiceProvider internally.
+     * When provided, ElevasisUIProvider composes the full provider stack via ElevasisCoreProvider.
      * When omitted, no service context is provided (theme-only mode).
      */
     apiUrl?: string;
@@ -223,9 +281,8 @@ interface ElevasisProviderProps {
      */
     onError?: (endpoint: string, error: Error, details?: ApiErrorDetails) => void;
     /**
-     * Override organization readiness check.
-     * Defaults to `!!organizationId` if not provided.
-     * Command-center passes `!!currentMembership` for its stricter readiness requirement.
+     * @deprecated Organization readiness is now managed internally by OrganizationProvider.
+     * Accepted for backwards compatibility but ignored when apiUrl is provided.
      */
     isOrganizationReady?: boolean;
     children: ReactNode;
@@ -3684,6 +3741,34 @@ interface OrgFeatureConfig {
  * Overrides org-level feature config for specific users
  */
 type MembershipFeatureConfig = OrgFeatureConfig;
+/**
+ * User-global config (stored in users.config)
+ * Training and theme are user-specific, NOT org-specific
+ */
+interface UserConfig {
+    training?: {
+        enabled?: boolean;
+        allowed_courses?: string[];
+        allowed_course_groups?: CourseGroup[];
+    };
+    theme?: {
+        preset?: 'default' | 'tactical' | 'regal' | 'cyber-volt' | 'aurora' | 'rose-gold' | 'midnight' | 'ember' | 'obsidian' | 'honey' | 'abyss' | 'canopy' | 'slate' | 'cyber-strike' | 'cyber-flux' | 'cyber-void';
+        colorScheme?: 'light' | 'dark' | 'auto';
+    };
+    onboarding?: {
+        completed?: boolean;
+        completedAt?: string;
+        role?: string;
+        primaryUseCase?: string[];
+        experienceLevel?: string;
+        /** Onboarding guide system state (set by checklist/tour system) */
+        guides?: {
+            completedIds?: string[];
+            dismissed?: boolean;
+            completedAt?: string;
+        };
+    };
+}
 
 /**
  * Organization Membership types based on WorkOS API
@@ -5766,18 +5851,19 @@ declare function TanStackRouterBridge({ children }: {
 /**
  * UI provider for Elevasis-powered applications. Includes Mantine theme integration.
  *
- * Composes: MantineThemeProvider + QueryClientProvider + auth provider +
- * auth bridge. When apiUrl is provided, also composes
- * ApiClientProvider + ElevasisServiceProvider.
+ * A thin Mantine shell around ElevasisCoreProvider. Handles:
+ * - MantineProvider with theme resolution (presets, token overrides, color scheme)
+ * - Google Font injection for preset fonts
+ * - CSS variables resolver
+ * - Mantine notification adapter (wired into NotificationProvider automatically)
  *
- * Supports authkit and oauth modes. apiKey mode will throw until implemented.
+ * All auth, API, profile, organization, and initialization composition is
+ * delegated to ElevasisCoreProvider.
  *
  * @example Command-center (dogfooding)
  * ```tsx
  * <ElevasisUIProvider
  *   auth={{ mode: 'authkit', clientId: '...', redirectUri: '/auth-redirect' }}
- *   organizationId={currentWorkOSOrganizationId}
- *   isOrganizationReady={!!currentMembership}
  *   apiUrl={import.meta.env.VITE_API_SERVER}
  *   onError={handleApiError}
  *   queryClient={queryClient}
@@ -5803,7 +5889,7 @@ declare function TanStackRouterBridge({ children }: {
  * </ElevasisUIProvider>
  * ```
  */
-declare function ElevasisUIProvider({ auth, theme, organizationId, queryClient, apiUrl, onError, isOrganizationReady, children }: ElevasisProviderProps): react_jsx_runtime.JSX.Element;
+declare function ElevasisUIProvider({ theme, children, ...coreProps }: ElevasisProviderProps): react_jsx_runtime.JSX.Element;
 /** @deprecated Use ElevasisUIProvider instead. Alias kept for backwards compatibility. */
 declare const ElevasisProvider: typeof ElevasisUIProvider;
 
@@ -5814,21 +5900,36 @@ declare const ElevasisProvider: typeof ElevasisUIProvider;
  * variables, set `data-elevasis-scheme`, or load fonts. Consumers that need
  * Elevasis theming should use `ElevasisProvider` (Mantine) instead.
  *
- * Composes: QueryClientProvider + auth provider + auth bridge.
- * When apiUrl is provided, also composes ApiClientProvider + ElevasisServiceProvider.
+ * When `apiUrl` is provided, composes the full provider stack:
+ *   QueryClientProvider -> AuthProvider -> ApiClientProvider ->
+ *   ElevasisServiceProvider -> ProfileProvider -> OrganizationProvider ->
+ *   NotificationProvider -> InitializationProvider
+ *
+ * The `notifications` prop wires a custom adapter (e.g. mantineNotificationAdapter)
+ * into the NotificationProvider. When omitted, the console fallback is used.
  *
  * @example Headless SDK consumer
  * ```tsx
  * <ElevasisCoreProvider
  *   auth={{ mode: 'authkit', clientId: '...', redirectUri: '/' }}
- *   theme={{ colorScheme: 'dark', preset: 'default' }}
  *   apiUrl="https://api.elevasis.com"
  * >
  *   <Dashboard />
  * </ElevasisCoreProvider>
  * ```
+ *
+ * @example With custom notification adapter
+ * ```tsx
+ * <ElevasisCoreProvider
+ *   auth={{ mode: 'authkit', clientId: '...', redirectUri: '/' }}
+ *   apiUrl="https://api.elevasis.com"
+ *   notifications={myNotificationAdapter}
+ * >
+ *   <Dashboard />
+ * </ElevasisCoreProvider>
+ * ```
  */
-declare function ElevasisCoreProvider({ auth, organizationId, queryClient, apiUrl, onError, isOrganizationReady, children }: ElevasisCoreProviderProps): react_jsx_runtime.JSX.Element;
+declare function ElevasisCoreProvider({ auth, queryClient, apiUrl, onError, notifications, children }: ElevasisCoreProviderProps): react_jsx_runtime.JSX.Element;
 
 /**
  * Hook to access the ElevasisServiceProvider context.
@@ -5859,6 +5960,20 @@ declare function useElevasisServices(): ElevasisServiceContextValue;
  */
 declare function ElevasisServiceProvider({ apiRequest, organizationId, isReady, children }: ElevasisServiceProviderProps): react_jsx_runtime.JSX.Element;
 
+/**
+ * Mantine-backed notification adapter.
+ *
+ * Wraps `@mantine/notifications` with the same defaults as `notify.tsx`
+ * (`autoClose: 5000`, `position: 'top-right'`). The `apiError()` method
+ * replicates `showApiErrorNotification` behavior including retryAfter-based
+ * autoClose.
+ *
+ * Use this adapter in Command Center (Mantine-powered) consumers.
+ * Template consumers should omit the NotificationProvider and rely on the
+ * console fallback, or supply their own adapter.
+ */
+declare const mantineNotificationAdapter: NotificationAdapter;
+
 declare function useCommandQueue({ status, limit, offset, humanCheckpoint, timeRange, priorityMin, priorityMax, }?: {
     status?: TaskStatus;
     limit?: number;
@@ -6529,6 +6644,43 @@ declare function useMarkAllAsRead(): _tanstack_react_query.UseMutationResult<voi
  */
 declare function useNotificationCount(): _tanstack_react_query.UseQueryResult<number, Error>;
 
+/**
+ * Hook that provides a standardized error notification handler
+ * for use in React Query mutation hooks.
+ *
+ * Delegates to the active NotificationAdapter so it works in any
+ * consumer (Mantine, Sonner, console fallback, etc.)
+ *
+ * @example
+ * ```typescript
+ * const mutation = useMutation({
+ *   mutationFn: deleteApiKey,
+ *   onError: useErrorNotification()
+ * })
+ * ```
+ */
+declare function useErrorNotification(): (error: unknown) => void;
+
+/**
+ * Hook that provides a standardized success notification handler.
+ * Delegates to the active NotificationAdapter.
+ */
+declare function useSuccessNotification(): (title: string, message: string) => void;
+
+/**
+ * Hook that provides a standardized warning notification handler.
+ * Delegates to the active NotificationAdapter.
+ */
+declare function useWarningNotification(): (title: string, message: string) => void;
+
+/**
+ * Generic batch delete hook. Deletes multiple rows from a Supabase table by ID.
+ *
+ * @param tableName - Supabase table name (e.g. 'acq_social_posts')
+ * @param invalidateQueryKeys - Array of query key prefixes to invalidate on success
+ */
+declare function useBatchDelete(tableName: string, invalidateQueryKeys: readonly (readonly unknown[])[]): _tanstack_react_query.UseMutationResult<void, Error, string[], unknown>;
+
 /**
  * Query key factories for observability hooks.
  * Scoped by organizationId for cache isolation between tenants.
@@ -6732,7 +6884,7 @@ declare function useGetExecutionHistory(scheduleId: string | undefined, options?
     executions: {
         id: string;
         createdAt: string;
-        status: "running" | "completed" | "failed" | "cancelled";
+        status: "completed" | "failed" | "running" | "cancelled";
         step: number | null;
         itemLabel: string | null;
         duration: number | null;
@@ -6915,43 +7067,394 @@ declare class OperationsService {
     archiveSession(sessionId: string): Promise<void>;
 }
 
-interface AuthAdapter {
-    user: {
-        id: string;
-    } | null;
+/**
+ * Shared hook for pagination state management.
+ * Encapsulates page state, offset calculation, and reset-on-filter-change.
+ *
+ * @param pageSize - Number of items per page
+ * @param resetDeps - When any dependency changes, page resets to 1. Omit to disable auto-reset.
+ * @param total - When provided, automatically retreats to the last valid page if the current page becomes empty (e.g., after bulk deletion).
+ */
+declare function usePaginationState(pageSize: number, resetDeps?: unknown[], total?: number): {
+    page: number;
+    setPage: react.Dispatch<react.SetStateAction<number>>;
+    offset: number;
+    totalPages: (total: number) => number;
+};
+
+/**
+ * Generic table row selection hook.
+ * Tracks selected IDs, provides toggle/toggleAll/clear, and computes selection state.
+ *
+ * @param items - Current page items (must have `id: string`)
+ * @param allItems - All items across all pages (for "select all" to work across pages). Defaults to `items`.
+ */
+declare function useTableSelection<T extends {
+    id: string;
+}>(items: T[], allItems?: T[]): {
+    selectedIds: Set<string>;
+    toggle: (id: string) => void;
+    togglePage: () => void;
+    clear: () => void;
+    isPageAllSelected: boolean;
+    isPagePartiallySelected: boolean;
+    selectedCount: number;
+    isSelected: (id: string) => boolean;
+};
+
+type SortDirection = 'asc' | 'desc';
+interface SortState {
+    column: string;
+    direction: SortDirection;
+}
+/**
+ * Generic table sorting hook.
+ * Manages sort column + direction, and provides a sort utility for client-side data.
+ */
+declare function useTableSort(defaultColumn: string, defaultDirection?: SortDirection): {
+    sort: SortState;
+    toggleSort: (column: string) => void;
+};
+/**
+ * Sort an array of items by a column using accessor functions.
+ *
+ * @param data - Array to sort (not mutated)
+ * @param sort - Current sort state
+ * @param accessors - Map of column name → accessor function
+ */
+declare function sortData<T>(data: T[], sort: SortState, accessors: Record<string, (item: T) => string | number | boolean | null | undefined>): T[];
+/**
+ * Hook that combines useTableSort with memoized sortData.
+ * Returns the sort state, toggle function, and a memoized sort function.
+ */
+declare function useSortedData<T>(data: T[], defaultColumn: string, accessors: Record<string, (item: T) => string | number | boolean | null | undefined>, defaultDirection?: SortDirection): {
+    sorted: T[];
+    sort: SortState;
+    toggleSort: (column: string) => void;
+};
+
+/**
+ * Type for the useOrganizations hook return value
+ */
+interface UseOrganizationsReturn {
+    currentWorkOSOrganizationId: string | null;
+    currentMembership: MembershipWithDetails | null;
+    setCurrentWorkOSOrganizationId: (id: string | null) => void;
+    setCurrentMembership: (membership: MembershipWithDetails | null) => void;
+    setOrganizationsInitializing: (initializing: boolean) => void;
+    setOrganizationsLoading: (loading: boolean) => void;
+    setOrganizationsError: (error: string | null) => void;
+    organizations: {
+        isInitializing: boolean;
+        isOrgRefreshing: boolean;
+        error: string | null;
+    };
+}
+/**
+ * Type for the useApiClient hook return value
+ */
+interface UseApiClientReturn {
+    apiRequest: <T = unknown>(path: string, options?: RequestInit) => Promise<T>;
+}
+/**
+ * Return type for useOrgInitialization hook
+ */
+interface UseOrgInitializationReturn {
+    memberships: MembershipWithDetails[];
+    isInitializing: boolean;
     isLoading: boolean;
-    getAccessToken: () => Promise<string>;
-    organizationId?: string | null;
+    isInitialized: boolean;
+    error: string | null;
+    currentOrganization: MembershipWithDetails['organization'] | null;
+    retry: () => Promise<void>;
 }
-declare function useAuthContext(): AuthAdapter;
-declare function AuthProvider({ value, children }: {
-    value: AuthAdapter;
-    children: ReactNode;
-}): react.FunctionComponentElement<react.ProviderProps<AuthAdapter | null>>;
+/**
+ * Factory function to create a useOrgInitialization hook for your app.
+ *
+ * Usage in app:
+ * ```typescript
+ * import { createUseOrgInitialization } from '@repo/ui/organization'
+ * import { useOrganizations } from './hooks/useOrganizations'
+ * import { useApiClient } from './api/hooks/useApiClient'
+ *
+ * export const useOrgInitialization = createUseOrgInitialization(
+ *   useOrganizations,
+ *   useApiClient
+ * )
+ * ```
+ *
+ * This pattern allows the shared package to provide the hook logic
+ * while each app provides its own hook instances.
+ */
+declare function createUseOrgInitialization(useOrganizations: () => UseOrganizationsReturn, useApiClient: () => UseApiClientReturn): () => UseOrgInitializationReturn;
 
+interface InitializationError {
+    layer: 'auth' | 'profile' | 'organization';
+    message: string;
+    originalError?: Error;
+}
+interface AppInitializationState {
+    userReady: boolean;
+    organizationReady: boolean;
+    allReady: boolean;
+    isInitializing: boolean;
+    error: InitializationError | null;
+    retry: () => void;
+    profile: SupabaseUserProfile | null;
+}
 /**
- * Bridge component that reads WorkOS AuthKit state and provides it
- * via the generic AuthContext. Place inside AuthKitProvider.
+ * Factory function to create a useAppInitialization hook for your app.
  *
- * Narrows WorkOS User to { id: string } -- @repo/ui hooks only need the ID.
- * Uses useMemo to stabilize the user object and prevent unnecessary
- * useEffect re-runs in downstream hooks.
+ * Usage in app:
+ * ```typescript
+ * import { createUseAppInitialization } from '@repo/ui/initialization'
+ * import { useOrgInitialization } from './organization/hooks/useOrgInitialization'
+ *
+ * export const useAppInitialization = createUseAppInitialization(useOrgInitialization)
+ * ```
+ *
+ * This pattern allows the shared package to provide the hook logic
+ * while each app provides its own hook instances.
  */
-declare function WorkOSAuthBridge({ children }: {
-    children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
+declare function createUseAppInitialization(useOrgInitialization: () => UseOrgInitializationReturn): () => AppInitializationState;
+
+/**
+ * The value exposed by OrganizationProvider to all consumers.
+ */
+interface OrganizationContextValue {
+    /** WorkOS organization ID of the currently selected organization. */
+    currentWorkOSOrganizationId: string | null;
+    /** Supabase (UUID) organization ID of the currently selected organization. */
+    currentSupabaseOrganizationId: string | null;
+    /** Full membership record for the currently selected organization. */
+    currentMembership: MembershipWithDetails | null;
+    /** All memberships for the authenticated user. */
+    memberships: MembershipWithDetails[];
+    /** True while the initial membership list is being fetched. */
+    isInitializing: boolean;
+    /** True while a subsequent org switch / refresh is in flight. */
+    isOrgRefreshing: boolean;
+    /** Error message if the membership fetch or org switch failed. */
+    error: string | null;
+    /**
+     * Switch the active organization.
+     *
+     * Persists the selection to `last_visited_org` on the user profile and
+     * invalidates all org-scoped TanStack Query cache entries.
+     *
+     * @param workosOrgId - WorkOS organization ID to switch to.
+     */
+    switchOrganization: (workosOrgId: string) => void;
+    /**
+     * Re-fetch memberships and retry org selection after an error.
+     */
+    retry: () => Promise<void>;
+}
+/**
+ * Consumes the nearest OrganizationProvider.
+ *
+ * @throws {Error} If called outside of an OrganizationProvider tree.
+ */
+declare function useOrganization(): OrganizationContextValue;
+
+type RestrictionSource = 'org' | 'membership' | null;
+interface FeatureAccessResult {
+    allowed: boolean;
+    restrictedBy: RestrictionSource;
+}
+/**
+ * Factory that creates a `useFeatureAccess` hook scoped to the consumer's
+ * feature configuration.
+ *
+ * @param useInitialization - Initialization hook providing `profile` and `organizationReady`
+ * @param useOrganization   - Organization hook providing `currentMembership`
+ * @param optInFeatures     - Feature keys that are disabled by default (must be explicitly enabled)
+ * @param getCoursesByGroup - Resolver that maps a course group name to its course slugs
+ *
+ * @example
+ * ```typescript
+ * // In your app's feature-access module
+ * import { createUseFeatureAccess } from '@repo/ui/hooks'
+ * import { useInitialization } from '@repo/ui/initialization'
+ * import { useOrganization } from '@repo/ui/organization'
+ * import { getCoursesByGroup } from './training/registry'
+ *
+ * export const useFeatureAccess = createUseFeatureAccess({
+ *   useInitialization,
+ *   useOrganization,
+ *   optInFeatures: ['acquisition', 'calibration'],
+ *   getCoursesByGroup,
+ * })
+ * ```
+ */
+declare function createUseFeatureAccess({ useInitialization, useOrganization, optInFeatures, getCoursesByGroup }: {
+    useInitialization: () => Pick<AppInitializationState, 'profile' | 'organizationReady'>;
+    useOrganization: () => Pick<OrganizationContextValue, 'currentMembership'>;
+    optInFeatures?: string[];
+    getCoursesByGroup?: (group: CourseGroup) => string[];
+}): () => {
+    orgConfig: OrgFeatureConfig | undefined;
+    membershipConfig: OrgFeatureConfig | undefined;
+    userConfig: UserConfig | undefined;
+    hasFeature: (featureKey: string) => boolean;
+    checkFeature: (featureKey: string) => FeatureAccessResult;
+    hasTrainingAccess: () => boolean;
+    getAllowedCourses: () => string[] | null;
+    getResolvedCourseAccess: () => string[] | null;
+    hasAccessToCourse: (courseSlug: string) => boolean;
+    getEnabledGroups: () => CourseGroup[];
+    isReady: boolean;
+};
 
-interface OAuthContextValue {
+interface EventSourceMessage {
+    id: string;
+    event: string;
+    data: string;
+    retry?: number;
+}
+
+interface FetchEventSourceWithTokenRefreshOptions {
+    url: string;
+    getToken: () => Promise<string | undefined>;
+    headers?: Record<string, string>;
+    signal: AbortSignal;
+    /** Delay in ms before reconnecting after token refresh. Defaults to 2000. */
+    tokenRefreshDelayMs?: number;
+    onopen?: (response: Response) => void | Promise<void>;
+    onmessage?: (event: EventSourceMessage) => void;
+    onerror?: (error: unknown) => void;
+    onclose?: () => void;
+}
+
+interface SSEConnectionManagerOptions {
+    /** Grace period in ms before closing idle connections. Defaults to 5000. */
+    closeGracePeriodMs?: number;
+}
+/**
+ * SSE Connection Manager
+ *
+ * Ensures only ONE SSE connection exists per endpoint, preventing duplicate
+ * connections when components re-render or remount.
+ *
+ * Benefits:
+ * - Prevents resource waste from duplicate connections
+ * - Eliminates race conditions from overlapping connections
+ * - Automatically manages connection lifecycle
+ * - Shares single connection across multiple subscribers
+ */
+declare class SSEConnectionManager {
+    private connections;
+    private closeGracePeriodMs;
+    constructor(options?: SSEConnectionManagerOptions);
+    /**
+     * Subscribe to an SSE endpoint
+     *
+     * If a connection already exists for this endpoint, reuses it.
+     * Otherwise, creates a new connection.
+     *
+     * @param key - Unique identifier for the connection (e.g., 'notifications', 'resource-executive-agent')
+     * @param subscriberId - Unique identifier for this subscriber (usually component instance)
+     * @param options - SSE connection options
+     * @returns Unsubscribe function to call when component unmounts
+     */
+    subscribe(key: string, subscriberId: string, options: Omit<FetchEventSourceWithTokenRefreshOptions, 'signal'>): () => void;
+    /**
+     * Unsubscribe from an SSE endpoint
+     *
+     * If this is the last subscriber, closes the connection after grace period.
+     */
+    private unsubscribe;
+    /**
+     * Force close a connection and all its subscribers
+     */
+    closeConnection(key: string): void;
+    /**
+     * Get current connection status
+     */
+    getConnectionInfo(): Map<string, {
+        url: string;
+        subscribers: number;
+    }>;
+}
+
+interface UseSSEConnectionOptions {
+    manager: SSEConnectionManager;
+    /** Shared connection key — all subscribers with the same key share ONE connection. */
+    connectionKey: string;
+    url: string;
+    /** When false the subscription is skipped. Defaults to true. */
+    enabled?: boolean;
+    headers?: Record<string, string>;
+    /** Called for each non-empty SSE message with the raw `event.data` string. */
+    onmessage: (data: string) => void;
+    /**
+     * Called when the connection opens. Return a non-empty string to set it as
+     * the error state (e.g. `response.status === 403 ? 'Access denied' : undefined`).
+     */
+    onopen?: (response: Response) => string | void;
+    onerror?: (err: Error) => void;
+    onclose?: () => void;
+}
+/**
+ * Generic SSE subscription hook.
+ *
+ * Handles token refresh, connection state, subscriber ID generation, and
+ * subscribe/cleanup lifecycle via the shared SSEConnectionManager.
+ *
+ * Domain-specific event parsing (e.g. `ExecutionSSEEvent`) stays in the
+ * caller's `onmessage` handler.
+ *
+ * @example
+ * ```typescript
+ * const { connected, error } = useSSEConnection({
+ *   manager: sseConnectionManager,
+ *   connectionKey: `resource-${resourceId}`,
+ *   url: `${API_URL}/api/execution-engine/sse/${resourceId}`,
+ *   enabled: isOrganizationReady,
+ *   headers: { [HTTP_HEADERS.WORKOS_ORGANIZATION_ID]: orgId },
+ *   onmessage: (data) => {
+ *     const event = JSON.parse(data)
+ *     // handle domain-specific event
+ *   },
+ * })
+ * ```
+ */
+declare function useSSEConnection({ manager, connectionKey, url, enabled, headers, onmessage, onopen, onerror, onclose }: UseSSEConnectionOptions): {
+    connected: boolean;
+    error: string | null;
+};
+
+interface AuthContextValue {
     user: {
         id: string;
     } | null;
     isLoading: boolean;
-    organizationId: string | null;
     getAccessToken: () => Promise<string>;
-    error: string | null;
-    initiateOAuthFlow: () => void;
+    organizationId?: string | null;
+    /**
+     * Trigger WorkOS AuthKit's sign-in flow (redirect to WorkOS hosted auth page).
+     * Used by ProtectedRoute for auto-recovery when `canRecover()` returns true.
+     */
+    signIn: (options?: {
+        state?: {
+            returnTo?: string;
+        };
+    }) => void;
+    /**
+     * Returns true when a previous session can be recovered (refresh token
+     * exists in storage). ProtectedRoute calls `signIn()` only when this returns
+     * true; otherwise it navigates to the login page.
+     *
+     * Explicit logout clears the stored token, so canRecover() returns false
+     * and the user sees the login page as expected.
+     */
+    canRecover: () => boolean;
 }
-declare function useOAuthContext(): OAuthContextValue;
+declare function useAuthContext(): AuthContextValue;
+declare function AuthProvider({ value, children }: {
+    value: AuthContextValue;
+    children: ReactNode;
+}): react.FunctionComponentElement<react.ProviderProps<AuthContextValue | null>>;
 
 /**
  * Returns a stable reference to getAccessToken that won't change between renders
@@ -6996,6 +7499,120 @@ declare function useStableAccessToken(): () => Promise<string>;
  */
 declare function useSessionCheck(): void;
 
+interface ProtectedRouteProps {
+    children: ReactNode;
+    /**
+     * Path to redirect to when user is unauthenticated and the auth adapter
+     * does not provide a `signIn` function.
+     * @default '/login'
+     */
+    redirectTo?: string;
+    /**
+     * Rendered while initialization is in progress.
+     * When not provided, nothing is rendered during initialization.
+     */
+    fallback?: ReactNode;
+    /**
+     * Rendered when initialization fails with a non-organization error.
+     * Receives the error and a retry callback.
+     * When not provided, the error is silently swallowed (children not rendered).
+     */
+    errorFallback?: (error: InitializationError, retry: () => void) => ReactNode;
+    /**
+     * When true (default), waits for both user AND organization to be ready
+     * before rendering children. When false, only waits for user readiness.
+     * @default true
+     */
+    waitForOrganization?: boolean;
+}
+/**
+ * Headless route guard for authenticated pages.
+ *
+ * Reads initialization state from the nearest InitializationProvider.
+ *
+ * When `canRecover()` returns true (refresh token exists), unauthenticated users
+ * are sent directly to WorkOS AuthKit via `signIn()`. WorkOS checks its
+ * server-side session and either signs the user in immediately (page-reload case)
+ * or shows a login form (logged-out case). Explicit logout destroys the
+ * server-side session, so the next auto-signIn correctly presents a login form
+ * rather than looping.
+ *
+ * When `canRecover()` returns false, falls back to navigating to `redirectTo`
+ * (default: '/login') with a `returnTo` search param.
+ *
+ * Organization-layer errors are allowed through -- routes like /invitations
+ * must be accessible even when the user has no org membership.
+ *
+ * @example
+ * // With custom fallback (your Mantine loader):
+ * <ProtectedRoute fallback={<AppShellLoader />}>
+ *   <DashboardPage />
+ * </ProtectedRoute>
+ *
+ * @example
+ * // Wait only for user, not org (e.g. /invitations route):
+ * <ProtectedRoute waitForOrganization={false}>
+ *   <InvitationsPage />
+ * </ProtectedRoute>
+ */
+declare function ProtectedRoute({ children, redirectTo, fallback, errorFallback, waitForOrganization }: ProtectedRouteProps): react_jsx_runtime.JSX.Element | null;
+
+interface AdminGuardProps {
+    children: ReactNode;
+    /**
+     * Path to redirect non-admin users to.
+     * @default '/'
+     */
+    redirectTo?: string;
+    /**
+     * Rendered while user readiness is being determined.
+     * When not provided, nothing is rendered during initialization.
+     */
+    fallback?: ReactNode;
+}
+/**
+ * Headless route guard for platform admin pages.
+ *
+ * Reads `profile.is_platform_admin` from the nearest InitializationProvider.
+ * Non-admin users are redirected to `redirectTo` (default: '/').
+ *
+ * Must be nested inside a ProtectedRoute (or equivalent) so that
+ * `userReady` is guaranteed to be true when this guard runs.
+ *
+ * @example
+ * <ProtectedRoute>
+ *   <AdminGuard fallback={<AppShellLoader />}>
+ *     <AdminDashboard />
+ *   </AdminGuard>
+ * </ProtectedRoute>
+ */
+declare function AdminGuard({ children, redirectTo, fallback }: AdminGuardProps): react_jsx_runtime.JSX.Element | null;
+
+interface ProfileContextValue {
+    profile: SupabaseUserProfile | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Consumes the nearest ProfileProvider.
+ *
+ * @throws {Error} If called outside of a ProfileProvider tree.
+ */
+declare function useProfile(): ProfileContextValue;
+/**
+ * Provides shared profile state to its subtree via React Context.
+ *
+ * Wraps useUserProfile so that all consumers share one profile fetch
+ * instead of each triggering an independent sync call.
+ *
+ * Must be rendered inside the auth and service provider layers so that
+ * the underlying hook can access useAuthContext and useElevasisServices.
+ */
+declare function ProfileProvider({ children }: {
+    children: ReactNode;
+}): react.FunctionComponentElement<react.ProviderProps<ProfileContextValue | null>>;
+
 interface UseUserProfileOptions {
     /**
      * Optional error handler for profile sync failures
@@ -7053,6 +7670,24 @@ declare class UserProfileService {
     }>): Promise<SupabaseUserProfile | null>;
 }
 
+/**
+ * Provides organization state to its subtree via React Context.
+ *
+ * Must be rendered inside:
+ * - ElevasisServiceProvider (needs apiRequest)
+ * - ProfileProvider (needs useProfile for last_visited_org preference)
+ * - A TanStack QueryClientProvider (needs useQueryClient for cache invalidation)
+ *
+ * Behaviors:
+ * - Fetches all memberships for the authenticated user via GET /memberships/my-memberships
+ * - Selects the active org by priority: saved preference > WorkOS org ID > first membership
+ * - Persists org switches to PATCH /users/me { last_visited_org }
+ * - Clears all state when the user signs out (user becomes null)
+ */
+declare function OrganizationProvider({ children }: {
+    children: ReactNode;
+}): react.FunctionComponentElement<react.ProviderProps<OrganizationContextValue | null>>;
+
 interface OrganizationsState {
     currentWorkOSOrganizationId: string | null;
     currentSupabaseOrganizationId: string | null;
@@ -7135,61 +7770,6 @@ declare function createUseOrganizations<TStore extends OrganizationsSlice>(useSt
     error: string | null;
 };
 
-/**
- * Type for the useOrganizations hook return value
- */
-interface UseOrganizationsReturn$1 {
-    currentWorkOSOrganizationId: string | null;
-    currentMembership: MembershipWithDetails | null;
-    setCurrentWorkOSOrganizationId: (id: string | null) => void;
-    setCurrentMembership: (membership: MembershipWithDetails | null) => void;
-    setOrganizationsInitializing: (initializing: boolean) => void;
-    setOrganizationsLoading: (loading: boolean) => void;
-    setOrganizationsError: (error: string | null) => void;
-    organizations: {
-        isInitializing: boolean;
-        isOrgRefreshing: boolean;
-        error: string | null;
-    };
-}
-/**
- * Type for the useApiClient hook return value
- */
-interface UseApiClientReturn {
-    apiRequest: <T = unknown>(path: string, options?: RequestInit) => Promise<T>;
-}
-/**
- * Return type for useOrgInitialization hook
- */
-interface UseOrgInitializationReturn {
-    memberships: MembershipWithDetails[];
-    isInitializing: boolean;
-    isLoading: boolean;
-    isInitialized: boolean;
-    error: string | null;
-    currentOrganization: MembershipWithDetails['organization'] | null;
-    retry: () => Promise<void>;
-}
-/**
- * Factory function to create a useOrgInitialization hook for your app.
- *
- * Usage in app:
- * ```typescript
- * import { createUseOrgInitialization } from '@repo/ui/organization'
- * import { useOrganizations } from './hooks/useOrganizations'
- * import { useApiClient } from './api/hooks/useApiClient'
- *
- * export const useOrgInitialization = createUseOrgInitialization(
- *   useOrganizations,
- *   useApiClient
- * )
- * ```
- *
- * This pattern allows the shared package to provide the hook logic
- * while each app provides its own hook instances.
- */
-declare function createUseOrgInitialization(useOrganizations: () => UseOrganizationsReturn$1, useApiClient: () => UseApiClientReturn): () => UseOrgInitializationReturn;
-
 type Organization = NonNullable<MembershipWithDetails['organization']>;
 interface OrganizationSwitcherProps {
     currentOrganization: Organization | undefined;
@@ -7229,66 +7809,81 @@ declare function useApiClientContext(): ApiClientContextValue;
  * }
  * ```
  */
-declare function ApiClientProvider({ children, getAccessToken, organizationId, isOrganizationReady, onError }: ApiClientProviderProps): react_jsx_runtime.JSX.Element;
+declare function ApiClientProvider({ children, getAccessToken, organizationId, getOrganizationId: getOrganizationIdProp, isOrganizationReady, onError }: ApiClientProviderProps): react_jsx_runtime.JSX.Element;
 
 /**
- * Return type of useOrganizations hook (subset needed by useApiClient)
- */
-interface UseOrganizationsReturn {
-    isInitializing: boolean;
-    isOrgRefreshing: boolean;
-}
-/**
- * Factory function to create a useApiClient hook for your app.
+ * Hook that returns apiRequest and deferredApiRequest bound to the current
+ * ApiClientContext. apiUrl is the only parameter because org ID is resolved
+ * at call time via getOrganizationId() from context.
  *
- * This pattern allows the shared package to provide the hook logic
- * while each app provides its own useOrganizations hook and API URL.
+ * When OrganizationProvider is present in the tree, isOrganizationReady and
+ * isInitializing reflect the live org state (currentWorkOSOrganizationId,
+ * isInitializing, isOrgRefreshing). When OrganizationProvider is absent
+ * (e.g. theme-only mode, testing), the hook falls back to the values from
+ * ApiClientContext.
  *
- * Usage in app:
+ * Usage:
  * ```typescript
- * import { createUseApiClient } from '@repo/ui/api'
- * import { useOrganizations } from './organization/hooks/useOrganizations'
+ * import { useApiClient } from '@repo/ui/api'
  *
  * const API_URL = import.meta.env.VITE_API_SERVER || 'http://localhost:5170'
- * export const useApiClient = createUseApiClient(useOrganizations, API_URL)
+ *
+ * function useMyClient() {
+ *   return useApiClient(API_URL)
+ * }
  * ```
  */
-declare function createUseApiClient(useOrganizations: () => UseOrganizationsReturn, apiUrl: string): () => {
+declare function useApiClient(apiUrl: string): {
     apiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
     deferredApiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
     isOrganizationReady: boolean;
     isInitializing: boolean;
 };
 
-interface InitializationError {
-    layer: 'auth' | 'profile' | 'organization';
-    message: string;
-    originalError?: Error;
-}
-interface AppInitializationState {
-    userReady: boolean;
-    organizationReady: boolean;
-    allReady: boolean;
-    isInitializing: boolean;
-    error: InitializationError | null;
-    retry: () => void;
-    profile: SupabaseUserProfile | null;
-}
+declare const InitializationContext: react.Context<AppInitializationState | null>;
 /**
- * Factory function to create a useAppInitialization hook for your app.
+ * Consumes the nearest InitializationProvider.
  *
- * Usage in app:
- * ```typescript
- * import { createUseAppInitialization } from '@repo/ui/initialization'
- * import { useOrgInitialization } from './organization/hooks/useOrgInitialization'
+ * @throws {Error} If called outside of an InitializationProvider tree.
+ */
+declare function useInitialization(): AppInitializationState;
+/**
+ * Aggregates auth, profile, and organization state into a single initialization context.
  *
- * export const useAppInitialization = createUseAppInitialization(useOrgInitialization)
- * ```
+ * Must be rendered inside:
+ * - An AuthProvider (needs useAuthContext)
+ * - A ProfileProvider (needs useProfile)
+ * - An OrganizationProvider (needs useOrganization)
  *
- * This pattern allows the shared package to provide the hook logic
- * while each app provides its own hook instances.
+ * Initialization Layers (Sequential):
+ * 1. WorkOS Auth (useAuthContext)
+ * 2. User Profile Sync (useProfile)
+ * 3. Organization Context (useOrganization)
+ *
+ * @example
+ * // Org-scoped pages with data queries (most common)
+ * const { organizationReady } = useInitialization()
+ * const { data, isLoading } = useResources()
+ * if (!organizationReady || isLoading) return <SubshellLoader />
+ *
+ * @example
+ * // Pages accessible without org (invitations, pending)
+ * const { userReady, error } = useInitialization()
+ * if (!userReady) return <SubshellLoader />
+ * if (error?.layer === 'organization') {
+ *   return <PendingInvitationPage message={error.message} />
+ * }
+ *
+ * @example
+ * // Pages with error handling
+ * const { organizationReady, error, retry } = useInitialization()
+ * if (error?.layer === 'organization') return <NoOrgError error={error} />
+ * if (error) return <ErrorCard error={error} onRetry={retry} />
+ * if (!organizationReady) return <SubshellLoader />
  */
-declare function createUseAppInitialization(useOrgInitialization: () => UseOrgInitializationReturn): () => AppInitializationState;
+declare function InitializationProvider({ children }: {
+    children: ReactNode;
+}): react.FunctionComponentElement<react.ProviderProps<AppInitializationState | null>>;
 
-export { AGENT_CONSTANTS, APIClientError, APIErrorAlert, ActionModal, AgentDefinitionDisplay, AgentExecutionTimeline, AgentExecutionVisualizer, AgentIterationEdge, AgentIterationNode, ApiClientProvider, AuthProvider, BaseEdge, BaseNode, CONTAINER_CONSTANTS, ChatHeader, ChatInputArea, ChatInterface, ChatSidebar, CollapsibleJsonSection, CollapsibleSection, ConfigCard, ConfirmationInputModal, ConfirmationModal, ContextViewer, ContractDisplay, CustomModal, CustomSelector, DetailCardSkeleton, ElevasisCoreProvider, ElevasisProvider, ElevasisServiceProvider, ElevasisUIProvider, EmptyState, EmptyVisualizer, ExecutionLogsTable, ExecutionStats, ExecutionStatusBadge, FormFieldRenderer, GRAPH_CONSTANTS, GlowingHandle, GraphBackground, GraphContainer, GraphFitViewButton, GraphFitViewHandler, GraphLegend, JsonViewer, ListSkeleton, MessageBubble, NavigationButton, NewKnowledgeMapEdge, NewKnowledgeMapGraph, NewKnowledgeMapNode, NotificationBell, NotificationItem, NotificationList, NotificationPanel, OperationsService, OrganizationSwitcher, PageNotFound, PageTitleCaption, ResourceCard, ResourceDefinitionSection, ResourceHealthChart, RouterProvider, SHARED_VIZ_CONSTANTS, STATUS_COLORS, StatCard, StatCardSkeleton, StatsCardSkeleton, StyledMarkdown, TIMELINE_CONSTANTS, TabCountBadge, TanStackRouterBridge, TaskCard, TimeRangeSelector, TimelineAxis, TimelineBar, TimelineContainer, TimelineRow, ToolsListDisplay, TrendIndicator, UnifiedWorkflowEdge, UnifiedWorkflowGraph, UnifiedWorkflowNode, UserProfileService, VisualizerContainer, WORKFLOW_CONSTANTS, WorkOSAuthBridge, WorkflowDefinitionDisplay, WorkflowExecutionTimeline, calculateBarPosition, calculateGraphHeight, catalogItemToResourceDefinition, createCssVariablesResolver, createOrganizationsSlice, createUseApiClient, createUseAppInitialization, createUseOrgInitialization, createUseOrganizations, executionsKeys, formatDate, formatDuration, formatErrorMessage, generateShades, getEdgeColor, getEdgeOpacity, getErrorInfo, getErrorTitle, getGraphBackgroundStyles, getHealthColor, getIcon, getPreset, getResourceColor, getResourceIcon, getResourceStatusColor, getStatusColors, getStatusIcon, iconMap, isAPIClientError, mantineThemeOverride, observabilityKeys, scheduleKeys, shouldAnimateEdge, showApiErrorNotification, showErrorNotification, showInfoNotification, showSuccessNotification, showWarningNotification, useActivities, useActivityTrend, useAgentIterationData, useApiClientContext, useAuthContext, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCommandQueue, useCommandQueueTotals, useConnectionHighlight, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useDeleteTask, useDirectedChainHighlighting, useElevasisServices, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorTrends, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogs, useExecutionPath, useExecutions, useFitViewTrigger, useGetExecutionHistory, useGetSchedule, useGraphBackgroundStyles, useGraphHighlighting, useGraphTheme, useListSchedules, useMarkAllAsRead, useMarkAsRead, useMergedExecution, useNewKnowledgeMapLayout, useNodeSelection, useNotificationCount, useNotifications, useOAuthContext, usePatchTask, usePauseSchedule, useReactFlowAgent, useSessionCheck as useRefocusSessionCheck, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResources, useResumeSchedule, useRetryExecution, useRouterContext, useSessionCheck, useStableAccessToken, useSubmitAction, useTimelineData, useTopFailingResources, useUnifiedWorkflowLayout, useUnresolveError, useUpdateAnchor, useUpdateSchedule, useUserProfile, useWorkflowStepsLayout, validateEmail };
-export type { ActivityTrendResponse, AgentIterationEdgeData, AgentIterationNodeData, AgentStatus, ApiClientContextValue, ApiClientProviderProps, ApiErrorDetails, ApiKeyConfig, AppInitializationState, AuthAdapter, AuthConfig, AuthKitConfig, BulkDeleteExecutionsParams, BulkDeleteExecutionsResult, BusinessImpactMetrics, CancelExecutionParams, CancelExecutionResult, ContextViewerProps, CostBreakdownItem, CreateScheduleInput, CreateSessionResponse, DeleteExecutionParams, DirectedChainHighlightingOptions, DirectedChainHighlightingResult, EdgeColorOptions, EdgeOpacityOptions, ElevasisCoreProviderProps, ElevasisCoreThemeConfig, ElevasisProviderProps, ElevasisServiceContextValue, ElevasisServiceProviderProps, ElevasisThemeConfig, ElevasisTokenOverrides, ErrorDistributionItem, ErrorDistributionParams, ErrorFilters, ErrorTrendsParams, ExecuteAsyncParams, ExecuteAsyncResult, ExecutionErrorDetails, ExecutionHistoryItem, ExecutionHistoryResponse, ExecutionLogEntry, ExecutionLogsPageResponse, ExecutionLogsTableProps, ExecutionPathState, ExecutionStatus$1 as ExecutionStatus, FailingResource, FitViewButtonVariant, GlowIntensity, GraphFitViewHandlerProps, GraphHeightOptions, GraphHighlightingResult, GraphMode, GraphThemeColors, InitializationError, JsonViewerProps, KnowledgeMapEdgeData, KnowledgeMapNodeData, LinkProps, ListActivitiesResponse, ListSchedulesFilters, ListSchedulesResponse, NavigationButtonProps, NodeColorType, OAuthConfig, OAuthContextValue, OrganizationsActions, OrganizationsSlice, OrganizationsState, PresetName, ResourcesResponse, RetryExecutionParams, RouterAdapter, SerializedKnowledgeMap, SerializedKnowledgeNode, SessionListItem, StatCardProps, StatusColorScheme, StatusIconColors, StepExecutionData, StyledMarkdownProps, SubmitActionRequest, SubmitActionResponse, TablerIcon, TaskSchedule, ThemePreset, TimelineBarProps, TimelineContainerProps, TimelineRowProps, TopFailingResourcesParams, TrendIndicatorProps, UnifiedWorkflowEdgeData, UnifiedWorkflowNodeData, UpdateScheduleInput, UseActivitiesParams, UseActivityTrendParams, UseApiClientReturn, UseExecutionHealthParams, UseExecutionLogsParams, UseOrgInitializationReturn, UseOrganizationsReturn$1 as UseOrganizationsReturn, UseUserProfileReturn, WithSchemes, WorkflowEdgeType, WorkflowStepEdgeData, WorkflowStepNodeData, WorkflowStepsLayoutInput };
+export { AGENT_CONSTANTS, APIClientError, APIErrorAlert, ActionModal, AdminGuard, AgentDefinitionDisplay, AgentExecutionTimeline, AgentExecutionVisualizer, AgentIterationEdge, AgentIterationNode, ApiClientProvider, AuthProvider, BaseEdge, BaseNode, CONTAINER_CONSTANTS, ChatHeader, ChatInputArea, ChatInterface, ChatSidebar, CollapsibleJsonSection, CollapsibleSection, ConfigCard, ConfirmationInputModal, ConfirmationModal, ContextViewer, ContractDisplay, CustomModal, CustomSelector, DetailCardSkeleton, ElevasisCoreProvider, ElevasisProvider, ElevasisServiceProvider, ElevasisUIProvider, EmptyState, EmptyVisualizer, ExecutionLogsTable, ExecutionStats, ExecutionStatusBadge, FormFieldRenderer, GRAPH_CONSTANTS, GlowingHandle, GraphBackground, GraphContainer, GraphFitViewButton, GraphFitViewHandler, GraphLegend, InitializationContext, InitializationProvider, JsonViewer, ListSkeleton, MessageBubble, NavigationButton, NewKnowledgeMapEdge, NewKnowledgeMapGraph, NewKnowledgeMapNode, NotificationBell, NotificationItem, NotificationList, NotificationPanel, NotificationProvider, OperationsService, OrganizationProvider, OrganizationSwitcher, PageNotFound, PageTitleCaption, ProfileProvider, ProtectedRoute, ResourceCard, ResourceDefinitionSection, ResourceHealthChart, RouterProvider, SHARED_VIZ_CONSTANTS, STATUS_COLORS, StatCard, StatCardSkeleton, StatsCardSkeleton, StyledMarkdown, TIMELINE_CONSTANTS, TabCountBadge, TanStackRouterBridge, TaskCard, TimeRangeSelector, TimelineAxis, TimelineBar, TimelineContainer, TimelineRow, ToolsListDisplay, TrendIndicator, UnifiedWorkflowEdge, UnifiedWorkflowGraph, UnifiedWorkflowNode, UserProfileService, VisualizerContainer, WORKFLOW_CONSTANTS, WorkflowDefinitionDisplay, WorkflowExecutionTimeline, calculateBarPosition, calculateGraphHeight, catalogItemToResourceDefinition, createCssVariablesResolver, createOrganizationsSlice, createUseAppInitialization, createUseFeatureAccess, createUseOrgInitialization, createUseOrganizations, executionsKeys, formatDate, formatDuration, formatErrorMessage, generateShades, getEdgeColor, getEdgeOpacity, getErrorInfo, getErrorTitle, getGraphBackgroundStyles, getHealthColor, getIcon, getPreset, getResourceColor, getResourceIcon, getResourceStatusColor, getStatusColors, getStatusIcon, iconMap, isAPIClientError, mantineNotificationAdapter, mantineThemeOverride, observabilityKeys, scheduleKeys, shouldAnimateEdge, showApiErrorNotification, showErrorNotification, showInfoNotification, showSuccessNotification, showWarningNotification, sortData, useActivities, useActivityTrend, useAgentIterationData, useApiClient, useApiClientContext, useAuthContext, useBatchDelete, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCommandQueue, useCommandQueueTotals, useConnectionHighlight, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useDeleteTask, useDirectedChainHighlighting, useElevasisServices, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorNotification, useErrorTrends, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogs, useExecutionPath, useExecutions, useFitViewTrigger, useGetExecutionHistory, useGetSchedule, useGraphBackgroundStyles, useGraphHighlighting, useGraphTheme, useInitialization, useListSchedules, useMarkAllAsRead, useMarkAsRead, useMergedExecution, useNewKnowledgeMapLayout, useNodeSelection, useNotificationAdapter, useNotificationCount, useNotifications, useOrganization, usePaginationState, usePatchTask, usePauseSchedule, useProfile, useReactFlowAgent, useSessionCheck as useRefocusSessionCheck, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResources, useResumeSchedule, useRetryExecution, useRouterContext, useSSEConnection, useSessionCheck, useSortedData, useStableAccessToken, useSubmitAction, useSuccessNotification, useTableSelection, useTableSort, useTimelineData, useTopFailingResources, useUnifiedWorkflowLayout, useUnresolveError, useUpdateAnchor, useUpdateSchedule, useUserProfile, useWarningNotification, useWorkflowStepsLayout, validateEmail };
+export type { ActivityTrendResponse, AdminGuardProps, AgentIterationEdgeData, AgentIterationNodeData, AgentStatus, ApiClientContextValue, ApiClientProviderProps, ApiErrorDetails, ApiKeyConfig, AppInitializationState, AuthConfig, AuthContextValue, AuthKitConfig, BulkDeleteExecutionsParams, BulkDeleteExecutionsResult, BusinessImpactMetrics, CancelExecutionParams, CancelExecutionResult, ContextViewerProps, CostBreakdownItem, CreateScheduleInput, CreateSessionResponse, DeleteExecutionParams, DirectedChainHighlightingOptions, DirectedChainHighlightingResult, EdgeColorOptions, EdgeOpacityOptions, ElevasisCoreProviderProps, ElevasisCoreThemeConfig, ElevasisProviderProps, ElevasisServiceContextValue, ElevasisServiceProviderProps, ElevasisThemeConfig, ElevasisTokenOverrides, ErrorDistributionItem, ErrorDistributionParams, ErrorFilters, ErrorTrendsParams, ExecuteAsyncParams, ExecuteAsyncResult, ExecutionErrorDetails, ExecutionHistoryItem, ExecutionHistoryResponse, ExecutionLogEntry, ExecutionLogsPageResponse, ExecutionLogsTableProps, ExecutionPathState, ExecutionStatus$1 as ExecutionStatus, FailingResource, FitViewButtonVariant, GlowIntensity, GraphFitViewHandlerProps, GraphHeightOptions, GraphHighlightingResult, GraphMode, GraphThemeColors, InitializationError, JsonViewerProps, KnowledgeMapEdgeData, KnowledgeMapNodeData, LinkProps, ListActivitiesResponse, ListSchedulesFilters, ListSchedulesResponse, NavigationButtonProps, NodeColorType, NotificationAdapter, OrganizationContextValue, OrganizationsActions, OrganizationsSlice, OrganizationsState, PresetName, ProfileContextValue, ProtectedRouteProps, ResourcesResponse, RetryExecutionParams, RouterAdapter, SerializedKnowledgeMap, SerializedKnowledgeNode, SessionListItem, SortDirection, SortState, StatCardProps, StatusColorScheme, StatusIconColors, StepExecutionData, StyledMarkdownProps, SubmitActionRequest, SubmitActionResponse, TablerIcon, TaskSchedule, ThemePreset, TimelineBarProps, TimelineContainerProps, TimelineRowProps, TopFailingResourcesParams, TrendIndicatorProps, UnifiedWorkflowEdgeData, UnifiedWorkflowNodeData, UpdateScheduleInput, UseActivitiesParams, UseActivityTrendParams, UseApiClientReturn, UseExecutionHealthParams, UseExecutionLogsParams, UseOrgInitializationReturn, UseOrganizationsReturn, UseSSEConnectionOptions, UseUserProfileReturn, WithSchemes, WorkflowEdgeType, WorkflowStepEdgeData, WorkflowStepNodeData, WorkflowStepsLayoutInput };