@semiont/react-ui 0.5.4 → 0.5.6

package/dist/index.d.ts

@@ -1,150 +1,3705 @@
+import * as _semiont_react_ui from '@semiont/react-ui';
+import { Annotation, ResourceId, Selector, components, ResourceDescriptor, ValidationResult, EventMap, AnnotationId, AnchorStrategy, AnchorConfidence, StoredEventLike, ConnectionState, GatheredContext, BackendDownload, ProgressEvent, AccessToken } from '@semiont/core';
+export { Annotation } from '@semiont/core';
+import * as React$1 from 'react';
+import React__default, { ComponentType, ReactNode, KeyboardEvent as KeyboardEvent$1, Component, ErrorInfo, Ref } from 'react';
+import * as _codemirror_state from '@codemirror/state';
+import { HighlightStyle } from '@codemirror/language';
+import { WidgetType } from '@codemirror/view';
+import { StateUnit, SemiontBrowser, SessionStorage, SessionFactory, SemiontSession, OpenResource, TagSchema, UploadProgress, SemiontClient, BeckonStateUnit, MarkStateUnit, GatherStateUnit, YieldStateUnit, ReferencedByEntry } from '@semiont/sdk';
+export { BeckonStateUnit, GatherStateUnit, GenerateDocumentOptions, HOVER_DELAY_MS, HoverHandlers, MarkStateUnit, MatchStateUnit, PendingAnnotation, SearchPipeline, SearchPipelineOptions, SearchState, TagSchema, YieldStateUnit, createBeckonStateUnit, createGatherStateUnit, createHoverHandlers, createMarkStateUnit, createMatchStateUnit, createSearchPipeline, createYieldStateUnit } from '@semiont/sdk';
+import { Observable } from 'rxjs';
+
 /**
- * @semiont/react-ui
- *
- * React components and hooks for Semiont applications
- */
-export * from './types/annotation-props';
-export * from './types/AnnotationManager';
-export * from './types/navigation';
-export * from './types/TranslationManager';
-export * from './types/resource-viewer';
-export * from './lib/annotation-registry';
-export * from './lib/button-styles';
-export * from './lib/codemirror-json-theme';
-export * from './lib/codemirror-widgets';
-export * from './lib/media-shapes';
-export { createSearchPipeline, type SearchPipeline, type SearchPipelineOptions, type SearchState } from '@semiont/sdk';
-export * from './lib/annotation-overlay';
-export * from './lib/resource-utils';
-export * from './lib/validation';
-export * from './hooks/useStateUnit';
-export * from './hooks/useDebounce';
-export * from './lib/formatTime';
-export * from './hooks/useKeyboardShortcuts';
-export * from './hooks/useLineNumbers';
-export * from './hooks/useHoverDelay';
-export * from './hooks/useObservableBrowse';
-export * from './hooks/usePanelWidth';
-export * from './hooks/useRovingTabIndex';
-export * from './hooks/useSessionExpiry';
-export * from './contexts/ThemeContext';
-export { useDropdown, useLoadingState, useLocalStorage } from './hooks/useUI';
-export * from './hooks/useResourceContent';
-export { SemiontProvider, useSemiont, type SemiontProviderProps } from './session/SemiontProvider';
-export { WebBrowserStorage } from './session/web-browser-storage';
-export * from './contexts/AnnotationContext';
-export * from './contexts/useEventSubscription';
-export * from './contexts/ResourceAnnotationsContext';
-export * from './contexts/RoutingContext';
-export * from './contexts/TranslationContext';
-export * from './components/CodeMirrorRenderer';
-export * from './components/AnnotateReferencesProgressWidget';
-export * from './components/ErrorBoundary';
-export * from './components/ProtectedErrorBoundary';
-export * from './components/LiveRegion';
-export * from './components/ResizeHandle';
-export * from './components/ResourceTagsInline';
-export * from './components/Toast';
-export * from './components/Toolbar';
-export * from './components/settings/SettingsPanel';
-export * from './components/annotation/AnnotateToolbar';
-export * from './components/annotation-popups/JsonLdView';
-export * from './components/annotation-popups/SharedPopupElements';
-export * from './components/image-annotation/AnnotationOverlay';
-export * from './components/image-annotation/SvgDrawingCanvas';
-export * from './components/modals/KeyboardShortcutsHelpModal';
-export * from './components/modals/PermissionDeniedModal';
-export * from './components/modals/SessionExpiredModal';
-export * from './components/resource/AnnotateView';
-export * from './components/resource/AnnotationHistory';
-export * from './components/resource/BrowseView';
-export * from './components/resource/HistoryEvent';
-export * from './components/resource/ResourceViewer';
-export * from './components/resource/panels/AssessmentEntry';
-export * from './components/resource/panels/AssessmentPanel';
-export * from './components/resource/panels/CollaborationPanel';
-export * from './components/resource/panels/CommentEntry';
-export * from './components/resource/panels/CommentsPanel';
-export * from './components/resource/panels/AssistSection';
-export * from './components/resource/panels/HighlightEntry';
-export * from './components/resource/panels/HighlightPanel';
-export * from './components/resource/panels/JsonLdPanel';
-export * from './components/resource/panels/PanelHeader';
-export * from './components/resource/panels/ReferenceEntry';
-export * from './components/resource/panels/ReferencesPanel';
-export * from './components/resource/panels/ResourceInfoPanel';
-export * from './components/resource/panels/StatisticsPanel';
-export * from './components/resource/panels/TagEntry';
-export * from './components/resource/panels/TaggingPanel';
-export * from './components/resource/panels/UnifiedAnnotationsPanel';
-export * from './components/viewers';
-export * from './components/navigation/Footer';
-export * from './components/navigation/NavigationMenu';
-export * from './components/navigation/ObservableLink';
-export * from './components/navigation/SimpleNavigation';
-export * from './components/navigation/CollapsibleResourceNavigation';
-export * from './components/navigation/SortableResourceTab';
-export type { CollapsibleResourceNavigationProps, SortableResourceTabProps } from './types/collapsible-navigation';
-export type { SimpleNavigationItem, SimpleNavigationProps } from './types/simple-navigation';
-export * from './components/modals/ReferenceWizardModal';
-export * from './components/modals/SearchModal';
-export * from './components/modals/ResourceSearchModal';
-export type { SearchModalProps, ResourceSearchModalProps, } from './types/modals';
-export * from './components/layout/SkipLinks';
-export * from './components/StatusDisplay';
-export * from './components/SessionTimer';
-export * from './components/SessionExpiryBanner';
-export * from './components/UserMenuSkeleton';
-export * from './components/branding/SemiontBranding';
-export * from './components/layout/UnifiedHeader';
-export * from './components/layout/LeftSidebar';
-export * from './components/layout/PageLayout';
-export { SemiontFavicon } from './assets/favicons/SemiontFavicon';
-export { faviconPaths } from './assets/favicons';
-export { Button, ButtonGroup } from './components/Button/Button';
-export type { ButtonProps, ButtonGroupProps } from './components/Button/Button';
-export { tokens, generateCSSVariables, cssVariables } from './design-tokens';
-export type { ColorToken, SpacingToken, TypographyToken, BorderRadiusToken, ShadowToken, TransitionToken } from './design-tokens';
-export * from './components/loading-states/ComposeLoadingState';
-export * from './components/loading-states/ResourceLoadingState';
-export * from './components/error-states/ResourceErrorState';
-export * from './features/admin-devops/components/AdminDevOpsPage';
-export * from './features/admin-exchange/components/AdminExchangePage';
-export * from './features/admin-exchange/components/ExportCard';
-export * from './features/admin-exchange/components/ImportCard';
-export * from './features/admin-exchange/components/ImportProgress';
-export * from './features/admin-security/components/AdminSecurityPage';
-export * from './features/moderation-linked-data/components/LinkedDataPage';
-export * from './features/admin-users/components/AdminUsersPage';
-export * from './features/auth/components/SignInForm';
-export * from './features/auth/components/SignUpForm';
-export * from './features/auth/components/AuthErrorDisplay';
-export * from './features/auth-welcome/components/WelcomePage';
-export * from './features/moderate-entity-tags/components/EntityTagsPage';
-export * from './features/moderate-recent/components/RecentDocumentsPage';
-export * from './features/moderate-tag-schemas/components/TagSchemasPage';
-export * from './features/resource-compose/components/ResourceComposePage';
-export * from './features/resource-compose/components/UploadProgressBar';
-export * from './features/resource-discovery/components/ResourceDiscoveryPage';
-export * from './features/resource-discovery/components/ResourceCard';
-export * from './features/resource-viewer/components/ResourceViewerPage';
-export * from './hooks/useHoverEmitter';
-export { createBeckonStateUnit, type BeckonStateUnit, createHoverHandlers, type HoverHandlers, HOVER_DELAY_MS } from '@semiont/sdk';
-export { createMarkStateUnit, type MarkStateUnit, type PendingAnnotation } from '@semiont/sdk';
-export { createYieldStateUnit, type YieldStateUnit, type GenerateDocumentOptions } from '@semiont/sdk';
-export { createGatherStateUnit, type GatherStateUnit } from '@semiont/sdk';
-export { createMatchStateUnit, type MatchStateUnit } from '@semiont/sdk';
-export { createShellStateUnit, type ShellStateUnit, type ShellStateUnitOptions, type ToolbarPanelType, COMMON_PANELS, RESOURCE_PANELS } from './state/shell-state-unit';
-export { createSessionStateUnit, type SessionStateUnit } from './state/session-state-unit';
-export { createComposePageStateUnit, type ComposePageStateUnit, type ComposeParams, type ComposeMode, type CloneData, type ReferenceData, type SaveResourceParams } from './features/resource-compose/state/compose-page-state-unit';
-export { createResourceViewerPageStateUnit, type ResourceViewerPageStateUnit, type WizardState, type AnnotationGroups } from './features/resource-viewer/state/resource-viewer-page-state-unit';
-export { createResourceLoaderStateUnit, type ResourceLoaderStateUnit } from './features/resource-viewer/state/resource-loader-state-unit';
-export { createAdminUsersStateUnit, type AdminUsersStateUnit } from './features/admin-users/state/admin-users-state-unit';
-export { createAdminSecurityStateUnit, type AdminSecurityStateUnit } from './features/admin-security/state/admin-security-state-unit';
-export { createExchangeStateUnit, type ExchangeStateUnit, type ImportPreview } from './features/admin-exchange/state/exchange-state-unit';
-export { createWelcomeStateUnit, type WelcomeStateUnit } from './features/auth-welcome/state/welcome-state-unit';
-export { createDiscoverStateUnit, type DiscoverStateUnit } from './features/resource-discovery/state/discover-state-unit';
-export { createEntityTagsStateUnit, type EntityTagsStateUnit } from './features/moderate-entity-tags/state/entity-tags-state-unit';
-export * from './hooks/useShellStateUnit';
-export * from './hooks/useObservable';
-//# sourceMappingURL=index.d.ts.map
+ * Collection of all annotation types for a resource.
+ * Replaces separate highlights, references, assessments, comments, tags props.
+ */
+interface AnnotationsCollection {
+    highlights: Annotation[];
+    references: Annotation[];
+    assessments: Annotation[];
+    comments: Annotation[];
+    tags: Annotation[];
+}
+/**
+ * Event handlers for annotation interactions.
+ * Groups multiple click and hover handlers into a single interface.
+ */
+interface AnnotationHandlers {
+    /** Unified click handler - routes based on annotation type and current mode */
+    onClick?: (annotation: Annotation, event?: React.MouseEvent) => void;
+    /** Unified hover handler for all annotation types */
+    onHover?: (annotationId: string | null) => void;
+    /** Hover handler specifically for comment panel highlighting */
+    onCommentHover?: (commentId: string | null) => void;
+}
+/**
+ * UI-level parameters for annotation creation.
+ * Works for both text selections and image shapes.
+ * Used by annotation UI components before converting to AnnotationManager params.
+ */
+interface UICreateAnnotationParams {
+    /** The motivation for creating this annotation */
+    motivation: _semiont_react_ui.SelectionMotivation;
+    /** Selector information - text, SVG, or fragment */
+    selector: {
+        /** Selector type */
+        type: 'TextQuoteSelector' | 'SvgSelector' | 'FragmentSelector';
+        /** For TextQuoteSelector: the exact text selected */
+        exact?: string;
+        /** For TextQuoteSelector: context before selection */
+        prefix?: string;
+        /** For TextQuoteSelector: context after selection */
+        suffix?: string;
+        /** For TextPositionSelector: start position in document */
+        start?: number;
+        /** For TextPositionSelector: end position in document */
+        end?: number;
+        /** For SvgSelector: the SVG shape string */
+        value?: string;
+        /** For FragmentSelector: conformsTo URI (RFC 3778 for PDF) */
+        conformsTo?: string;
+    };
+    /** Optional position for popup placement (text: near selection, image: shape center) */
+    position?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Unified creation handler for new annotations.
+ * Works for both text and image annotations.
+ *
+ * Behavior by motivation:
+ * - highlighting/assessing: Creates annotation immediately
+ * - commenting: Creates annotation, then opens Comment Panel
+ * - linking: Shows Quick Reference popup FIRST, creates when user confirms
+ */
+interface AnnotationCreationHandler {
+    onCreate?: (params: UICreateAnnotationParams) => void | Promise<void> | Promise<Annotation | undefined>;
+}
+/**
+ * UI state for annotation toolbar and interactions.
+ * Groups multiple UI state props into a single object.
+ */
+interface AnnotationUIState {
+    /** Currently selected annotation motivation (linking, highlighting, etc.) */
+    selectedMotivation: _semiont_react_ui.SelectionMotivation | null;
+    /** Currently selected click mode (detail, follow, delete, jsonld) */
+    selectedClick: _semiont_react_ui.ClickAction;
+    /** Currently selected shape for image annotations */
+    selectedShape: _semiont_react_ui.ShapeType;
+    /** ID of currently hovered annotation (optional - only set when hovering) */
+    hoveredAnnotationId?: string | null;
+    /** ID of annotation to scroll to (optional - only set when scrolling needed) */
+    scrollToAnnotationId?: string | null;
+}
+/**
+ * Configuration options for annotation views.
+ * Groups feature flags and settings.
+ */
+interface AnnotationConfig {
+    /** Whether content is editable */
+    editable?: boolean;
+    /** Whether to show annotation widgets (entity types, reference buttons) */
+    enableWidgets?: boolean;
+    /** Whether to show line numbers in code view */
+    showLineNumbers?: boolean;
+    /** Whether view is in annotate mode or browse mode */
+    annotateMode?: boolean;
+}
+
+/**
+ * Parameters for creating an annotation
+ */
+interface CreateAnnotationParams {
+    rUri: ResourceId;
+    motivation: 'highlighting' | 'linking' | 'assessing' | 'commenting' | 'tagging';
+    selector: Selector | Selector[];
+    body?: any[];
+}
+/**
+ * Parameters for deleting an annotation
+ */
+interface DeleteAnnotationParams {
+    annotationId: string;
+    rUri: ResourceId;
+}
+/**
+ * Annotation Manager Interface
+ *
+ * Framework-agnostic interface for annotation mutations.
+ * Apps provide implementations via AnnotationProvider.
+ *
+ * Example implementation:
+ * ```typescript
+ * function useAnnotationManager(client: SemiontClient): AnnotationManager {
+ *   return {
+ *     markAnnotation: async (params) => {
+ *       const result = await client.mark.annotation({ target: { source: params.rUri, ... }, ... });
+ *       return result.annotation;
+ *     },
+ *     deleteAnnotation: async (params) => {
+ *       await client.mark.delete(params.rUri, params.annotationId);
+ *     }
+ *   };
+ * }
+ * ```
+ */
+interface AnnotationManager {
+    /**
+     * Create a new annotation
+     * @param params - Creation parameters (rUri, motivation, selector, body)
+     * @returns Promise resolving to the created annotation, or undefined if creation fails
+     */
+    markAnnotation: (params: CreateAnnotationParams) => Promise<Annotation | undefined>;
+    /**
+     * Delete an annotation
+     * @param params - Deletion parameters (annotationId, rUri)
+     * @returns Promise resolving when deletion completes
+     */
+    deleteAnnotation: (params: DeleteAnnotationParams) => Promise<void>;
+}
+
+/**
+ * Represents a single navigation item
+ */
+interface NavigationItem {
+    /** Display name for the navigation item */
+    name: string;
+    /** Target URL/path for the navigation item */
+    href: string;
+    /** Icon component to display */
+    icon: ComponentType<any>;
+    /** Optional description/tooltip text */
+    description?: string;
+}
+/**
+ * Props for navigation components that need framework-specific routing
+ */
+interface NavigationProps {
+    /** List of navigation items to display */
+    items: NavigationItem[];
+    /** Current active path for highlighting */
+    currentPath: string;
+    /** Framework-specific Link component (e.g., Next.js Link) */
+    LinkComponent: ComponentType<{
+        href: string;
+        className?: string;
+        children: ReactNode;
+        title?: string;
+    }>;
+    /** Optional CSS class name */
+    className?: string;
+    /** Optional section title */
+    title?: string;
+}
+
+/**
+ * Translation management interface
+ * Apps implement this to provide translations using their preferred i18n library
+ */
+interface TranslationManager {
+    /**
+     * Translate a key within a namespace
+     * @param namespace - Translation namespace (e.g., 'Toolbar', 'ResourceViewer')
+     * @param key - Translation key within the namespace
+     * @param params - Optional parameters for interpolation
+     * @returns Translated string
+     */
+    t: (namespace: string, key: string, params?: Record<string, any>) => string;
+}
+
+/**
+ * Type definitions for resource viewer feature
+ */
+
+type SemiontResource$2 = ResourceDescriptor;
+type Motivation$8 = components['schemas']['Motivation'];
+/**
+ * Selection for creating annotations
+ */
+interface TextSelection {
+    exact: string;
+    start: number;
+    end: number;
+    prefix?: string;
+    suffix?: string;
+    svgSelector?: string;
+}
+
+/**
+ * Centralized annotation type registry
+ *
+ * Single source of truth for W3C annotation motivation metadata including:
+ * - Visual styling (CSS classes)
+ * - Behavior flags (clickable, hover, side panel)
+ * - Type guards (motivation matching)
+ * - Accessibility (screen reader announcements)
+ * - Runtime handlers (click, hover, detect, update, create)
+ *
+ * Per CLAUDE.md: This is the ONLY place to define annotation type metadata.
+ * No aliasing, wrappers, or compatibility layers elsewhere.
+ */
+
+type Motivation$7 = components['schemas']['Motivation'];
+/**
+ * Detection configuration for SSE-based annotation detection
+ */
+interface DetectionConfig {
+    sseMethod: 'detectReferences' | 'detectHighlights' | 'detectAssessments' | 'detectComments' | 'detectTags';
+    countField: 'foundCount' | 'createdCount' | 'tagsCreated';
+    displayNamePlural: string;
+    displayNameSingular: string;
+    formatRequestParams?: (args: unknown[]) => Array<{
+        label: string;
+        value: string;
+    }>;
+}
+/**
+ * Creation configuration - describes how to create annotations of this type
+ */
+interface CreateConfig {
+    bodyBuilder: 'empty' | 'text' | 'entityTag' | 'dualTag';
+    refetchAfter: boolean;
+    successMessage?: string;
+}
+/**
+ * Annotator: Encapsulates all motivation-specific behavior
+ * Handles clicks, hovers, detection, and other operations for one annotation type
+ */
+interface Annotator {
+    motivation: Motivation$7;
+    internalType: string;
+    displayName: string;
+    description: string;
+    className: string;
+    iconEmoji?: string;
+    isClickable: boolean;
+    hasHoverInteraction: boolean;
+    hasSidePanel: boolean;
+    matchesAnnotation: (annotation: Annotation) => boolean;
+    announceOnCreate: string;
+    detection?: DetectionConfig;
+    create: CreateConfig;
+}
+/**
+ * Static annotator definitions - single source of truth
+ */
+declare const ANNOTATORS: Record<string, Annotator>;
+
+/**
+ * Centralized button styles matching Figma design
+ * Two primary styles from authenticated home page:
+ * 1. Primary (cyan/blue gradient) - for main CTAs
+ * 2. Secondary (gray with black outline) - for secondary actions
+ */
+declare const buttonStyles: {
+    readonly primary: {
+        readonly base: "semiont-button semiont-button--primary";
+        readonly large: "semiont-button semiont-button--primary semiont-button--large";
+    };
+    readonly secondary: {
+        readonly base: "semiont-button semiont-button--secondary";
+        readonly withScale: "semiont-button semiont-button--secondary semiont-button--scale";
+    };
+    readonly tertiary: {
+        readonly base: "semiont-button semiont-button--tertiary";
+    };
+    readonly danger: {
+        readonly base: "semiont-button semiont-button--danger";
+    };
+    readonly warning: {
+        readonly base: "semiont-button semiont-button--warning";
+    };
+    readonly combine: (...classes: string[]) => string;
+};
+
+declare const jsonLightTheme: _codemirror_state.Extension;
+declare const jsonLightHighlightStyle: HighlightStyle;
+
+/**
+ * CodeMirror Inline Widgets
+ *
+ * Custom widgets for enhancing the document editing experience:
+ * - Reference resolution indicators (resolved 🔗, generating ✨, stub ❓)
+ *
+ * Event handling uses delegation — no per-widget listeners.
+ * Data attributes on the container enable CodeMirrorRenderer to handle
+ * clicks and hovers via a single set of delegated handlers.
+ */
+
+/**
+ * Reference Resolution Widget
+ * Shows a small indicator next to references with hover preview.
+ *
+ * All event handling is delegated — the widget sets data attributes
+ * and CodeMirrorRenderer handles events via container-level listeners.
+ */
+declare class ReferenceResolutionWidget extends WidgetType {
+    readonly annotation: Annotation;
+    readonly targetDocumentName?: string | undefined;
+    readonly isGenerating?: boolean | undefined;
+    constructor(annotation: Annotation, targetDocumentName?: string | undefined, isGenerating?: boolean | undefined);
+    eq(other: ReferenceResolutionWidget): boolean;
+    toDOM(): HTMLSpanElement;
+    ignoreEvent(event: Event): boolean;
+}
+/**
+ * Show a tooltip preview on a widget container.
+ * Called from delegated mouseenter handler in CodeMirrorRenderer.
+ */
+declare function showWidgetPreview(container: HTMLElement, documentName: string): void;
+/**
+ * Hide the tooltip preview from a widget container.
+ * Called from delegated mouseleave handler in CodeMirrorRenderer.
+ */
+declare function hideWidgetPreview(container: HTMLElement): void;
+
+type SelectionMotivation = 'linking' | 'highlighting' | 'assessing' | 'commenting' | 'tagging';
+type ClickAction = 'detail' | 'follow' | 'jsonld' | 'deleting';
+type ShapeType = 'rectangle' | 'circle' | 'polygon';
+interface AnnotateToolbarProps {
+    selectedMotivation: SelectionMotivation | null;
+    selectedClick: ClickAction;
+    showSelectionGroup?: boolean;
+    showDeleteButton?: boolean;
+    showShapeGroup?: boolean;
+    selectedShape?: ShapeType;
+    mediaType?: string | null;
+    annotateMode: boolean;
+    annotators: Record<string, Annotator>;
+}
+/**
+ * Toolbar for annotation controls with mode, selection, click, and shape options
+ *
+ * @emits mark:selection-changed - Selection motivation changed. Payload: { motivation: SelectionMotivation | null }
+ * @emits mark:click-changed - Click action mode changed. Payload: { action: ClickAction }
+ * @emits mark:shape-changed - Drawing shape changed. Payload: { shape: ShapeType }
+ * @emits mark:mode-toggled - View mode toggled between browse and annotate. Payload: undefined
+ */
+declare function AnnotateToolbar({ selectedMotivation, selectedClick, showSelectionGroup, showDeleteButton, showShapeGroup, selectedShape, mediaType, annotateMode, annotators }: AnnotateToolbarProps): React__default.JSX.Element;
+
+/**
+ * Media Type Shape Support
+ *
+ * Defines which annotation shapes are supported for each media type.
+ * Shapes are tracked per selector type (FragmentSelector, SvgSelector).
+ */
+
+/**
+ * Selector types that support shape selection
+ */
+type SelectorType = 'fragment' | 'svg' | 'text';
+/**
+ * Get supported annotation shapes for a given media type
+ *
+ * PDF: Only rectangles (FragmentSelector with RFC 3778 viewrect)
+ * Images: All shapes (SvgSelector supports rect, circle, polygon)
+ *
+ * @param mediaType - MIME type of the resource (e.g., 'application/pdf', 'image/png')
+ * @returns Array of supported shape types for annotation
+ */
+declare function getSupportedShapes(mediaType: string | undefined | null): ShapeType[];
+/**
+ * Check if a shape type is supported for a given media type
+ *
+ * @param mediaType - MIME type of the resource
+ * @param shape - Shape type to check
+ * @returns true if the shape is supported for this media type
+ */
+declare function isShapeSupported(mediaType: string | undefined | null, shape: ShapeType): boolean;
+/**
+ * Get the selector type used for a given media type
+ *
+ * @param mediaType - MIME type of the resource
+ * @returns Selector type (fragment, svg, or text)
+ */
+declare function getSelectorType(mediaType: string | undefined | null): SelectorType;
+/**
+ * Get the selected shape for a given selector type from localStorage
+ *
+ * @param selectorType - The selector type
+ * @returns The selected shape, or default for that selector type
+ */
+declare function getSelectedShapeForSelectorType(selectorType: SelectorType): ShapeType;
+/**
+ * Save the selected shape for a given selector type to localStorage
+ *
+ * @param selectorType - The selector type
+ * @param shape - The shape to save
+ */
+declare function saveSelectedShapeForSelectorType(selectorType: SelectorType, shape: ShapeType): void;
+
+/**
+ * Annotation overlay: decouples annotation highlighting from markdown rendering.
+ *
+ * Instead of weaving annotations into the markdown AST via remark/rehype plugins
+ * (which forces O(ASTnodes × annotations) work on every render), this module:
+ *
+ * 1. Builds a source→rendered offset map once after the markdown DOM paints
+ * 2. Resolves W3C TextPositionSelector offsets to DOM Ranges via binary search
+ * 3. Wraps matched ranges with <span> elements carrying data-annotation-* attributes
+ *
+ * Markdown renders once (cached by React.memo). Annotation changes only touch
+ * the overlay spans — no markdown re-parse, no AST walk.
+ */
+
+interface OverlayAnnotation {
+    id: string;
+    exact: string;
+    offset: number;
+    length: number;
+    type: string;
+    source: string | null;
+}
+interface TextNodeEntry {
+    node: Text;
+    start: number;
+    end: number;
+}
+/**
+ * Build a map from markdown source offsets to rendered text offsets.
+ * Character-by-character alignment: walks source and rendered text in parallel,
+ * matching characters and skipping markdown syntax in the source.
+ *
+ * Complexity: O(sourceLength) — runs once per content change.
+ */
+declare function buildSourceToRenderedMap(markdownSource: string, container: HTMLElement): Map<number, number>;
+/**
+ * Build a sorted array of text nodes with cumulative rendered offsets
+ * for efficient offset→node lookups via binary search.
+ *
+ * Complexity: O(textNodes) — runs once per overlay application.
+ */
+declare function buildTextNodeIndex(container: HTMLElement): TextNodeEntry[];
+/**
+ * Resolve annotations to DOM Ranges using the cached offset map.
+ *
+ * Complexity: O(annotations × log(textNodes)).
+ */
+declare function resolveAnnotationRanges(annotations: OverlayAnnotation[], offsetMap: Map<number, number>, textNodeIndex: TextNodeEntry[]): Map<string, {
+    range: Range;
+    annotation: OverlayAnnotation;
+}>;
+/**
+ * Wrap annotation Ranges with styled <span> elements.
+ * Handles cross-element ranges by splitting into per-text-node segments.
+ */
+declare function applyHighlights(ranges: Map<string, {
+    range: Range;
+    annotation: OverlayAnnotation;
+}>): void;
+/**
+ * Remove all annotation highlight spans, restoring the original DOM.
+ * Unwraps spans and merges adjacent text nodes.
+ */
+declare function clearHighlights(container: HTMLElement): void;
+/**
+ * Convert W3C Annotations to the simplified overlay format.
+ * Extracts TextPositionSelector offsets and annotation type.
+ */
+declare function toOverlayAnnotations(annotations: Annotation[]): OverlayAnnotation[];
+
+/**
+ * Resource utilities
+ * Shared helper functions for resource display and metadata
+ */
+/**
+ * Get icon emoji based on media type
+ */
+declare function getResourceIcon(mediaType: string | undefined): string;
+/**
+ * Check if a resource supports text-based AI detection features
+ *
+ * Currently returns true for any text/* media type.
+ * Future enhancements may include:
+ * - Checking resource language/locale compatibility
+ * - Validating content size limits
+ * - Checking for specific text format requirements
+ *
+ * @param mediaType - The media type string (e.g., 'text/plain', 'text/markdown')
+ * @returns true if the resource supports AI detection features
+ */
+declare function supportsDetection(mediaType: string | undefined): boolean;
+
+/**
+ * Frontend-specific validation utilities
+ *
+ * Browser and Next.js specific validation with security checks.
+ * For generic validation utilities, see @semiont/api-client/utils/validation
+ */
+
+/**
+ * Image URL validation with security checks (browser-specific)
+ *
+ * Validates image URLs for use in browser environments with XSS prevention.
+ * Only allows HTTPS for external images, blocks suspicious patterns.
+ */
+declare const ImageURLSchema: {
+    parse(url: unknown): string;
+    safeParse(url: unknown): ValidationResult<string>;
+};
+/**
+ * OAuth user validation (Next.js NextAuth specific)
+ *
+ * Validates user objects returned from OAuth providers.
+ * Includes domain validation for access control.
+ */
+interface OAuthUser {
+    id: string;
+    email: string;
+    name?: string | null;
+    image?: string | null;
+    domain: string;
+    isAdmin: boolean;
+    isModerator: boolean;
+}
+declare const OAuthUserSchema: {
+    parse(data: unknown): OAuthUser;
+    safeParse(data: unknown): ValidationResult<OAuthUser>;
+};
+/**
+ * URL sanitization for images (browser-specific security)
+ *
+ * Sanitizes image URLs by validating and reconstructing with only safe parts.
+ * Returns null if validation fails.
+ *
+ * @param url - Image URL to sanitize
+ * @returns Sanitized URL or null if invalid
+ */
+declare function sanitizeImageURL(url: string): string | null;
+
+declare function useStateUnit<T extends StateUnit>(factory: () => T): T;
+
+/**
+ * Creates a debounced version of a callback function
+ *
+ * @param callback - The function to debounce
+ * @param delay - Debounce delay in milliseconds
+ * @returns Debounced function
+ *
+ * @example
+ * const debouncedSearch = useDebouncedCallback(
+ *   (query) => performSearch(query),
+ *   500
+ * );
+ */
+declare function useDebouncedCallback<T extends (...args: any[]) => any>(callback: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * useDebounce Hook
+ *
+ * Custom hook for debouncing values (e.g., search input).
+ * Returns a debounced value that updates after the specified delay.
+ *
+ * @param value - The value to debounce
+ * @param delay - Debounce delay in milliseconds
+ * @returns Debounced value
+ *
+ * @example
+ * const debouncedQuery = useDebounce(searchQuery, 500);
+ */
+declare function useDebounce<T>(value: T, delay: number): T;
+
+declare function formatTime(milliseconds: number | null): string | null;
+
+interface KeyboardShortcut {
+    key: string;
+    ctrlOrCmd?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    handler: (event: KeyboardEvent) => void;
+    description?: string;
+    enabled?: boolean;
+}
+/**
+ * Hook for managing keyboard shortcuts
+ * Handles platform differences (Cmd on Mac, Ctrl on Windows/Linux)
+ * Prevents conflicts with browser shortcuts
+ */
+declare function useKeyboardShortcuts(shortcuts: KeyboardShortcut[]): void;
+/**
+ * Hook for double key press detection (e.g., double Escape)
+ */
+declare function useDoubleKeyPress(key: string, handler: () => void, timeout?: number): void;
+/**
+ * Get keyboard shortcut display text based on platform
+ */
+declare function getShortcutDisplay(shortcut: KeyboardShortcut): string;
+/**
+ * Hook to check if user is currently typing in an input field
+ * Keyboard shortcuts should generally be disabled when typing
+ */
+declare function useIsTyping(): boolean;
+
+/**
+ * Hook to manage line numbers display setting with localStorage persistence
+ */
+declare function useLineNumbers(): {
+    showLineNumbers: boolean;
+    toggleLineNumbers: () => void;
+};
+
+/**
+ * Hook to manage hover delay setting with localStorage persistence
+ */
+declare function useHoverDelay(): {
+    hoverDelayMs: number;
+    setHoverDelayMs: (delayMs: number) => void;
+};
+
+/**
+ * Generic router interface - works with any router that has push/replace methods
+ * (Next.js App Router, Next.js Pages Router, React Router, etc.)
+ */
+interface Router {
+    push: (path: string) => void;
+    replace?: (path: string) => void;
+    [key: string]: any;
+}
+/**
+ * Hook that wraps any router with event emission for observability
+ *
+ * Use this to wrap your router (Next.js, React Router, etc.) when you want
+ * navigation actions to be observable through the NavigationEventBus.
+ *
+ * @emits nav:push - Router navigation requested. Payload: { path: string, reason?: string }
+ *
+ * @example
+ * ```typescript
+ * // Next.js App Router
+ * import { useRouter } from 'next/navigation';
+ * const nextRouter = useRouter();
+ * const router = useObservableRouter(nextRouter);
+ * router.push('/know/discover', { reason: 'resource-closed' });
+ *
+ * // React Router
+ * import { useNavigate } from 'react-router-dom';
+ * const navigate = useNavigate();
+ * const router = useObservableRouter({ push: navigate });
+ * router.push('/know/discover', { reason: 'resource-closed' });
+ * ```
+ */
+declare function useObservableRouter<T extends Router>(baseRouter: T): T;
+/**
+ * Request navigation with event emission
+ *
+ * This hook emits a navigation request event. The app must subscribe to
+ * 'nav:external' and perform the actual navigation using
+ * its router (Next.js, React Router, etc.) to enable client-side routing.
+ *
+ * If no subscriber handles the event, falls back to window.location.href
+ * after a brief delay to allow for event handling.
+ *
+ * @emits nav:external - External navigation requested. Payload: { url: string, resourceId?: string, cancelFallback: () => void }
+ *
+ * The payload includes a `cancelFallback` function that subscribers must call to
+ * prevent the window.location fallback from firing. Subscribers that handle the
+ * navigation (e.g. via client-side routing) should always call cancelFallback().
+ *
+ * @example
+ * ```typescript
+ * // In component (react-ui package)
+ * const navigate = useObservableExternalNavigation();
+ * navigate('/know/resource/123', { resourceId: '123' });
+ *
+ * // In app (frontend package) - subscribe, cancel fallback, and handle with Next.js router
+ * const router = useRouter();
+ * useEventSubscriptions({
+ *   'nav:external': ({ url, cancelFallback }) => {
+ *     cancelFallback(); // Prevent window.location fallback
+ *     router.push(url); // Client-side navigation
+ *   },
+ * });
+ * ```
+ */
+declare function useObservableExternalNavigation(): (url: string, metadata?: {
+    resourceId?: string;
+}) => void;
+
+interface UsePanelWidthOptions {
+    defaultWidth?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    storageKey?: string;
+}
+/**
+ * Custom hook for managing resizable panel width with localStorage persistence
+ *
+ * @param options Configuration options for panel width behavior
+ * @param options.defaultWidth Default width in pixels (default: 384px / 24rem)
+ * @param options.minWidth Minimum allowed width in pixels (default: 256px / 16rem)
+ * @param options.maxWidth Maximum allowed width in pixels (default: 800px / 50rem)
+ * @param options.storageKey localStorage key for persistence (default: 'semiont-panel-width')
+ *
+ * @returns Object containing current width, setter function, and constraints
+ *
+ * @example
+ * ```tsx
+ * const { width, setWidth, minWidth, maxWidth } = usePanelWidth();
+ *
+ * <div style={{ width: `${width}px` }}>
+ *   <ResizeHandle onResize={setWidth} minWidth={minWidth} maxWidth={maxWidth} />
+ * </div>
+ * ```
+ */
+declare function usePanelWidth({ defaultWidth, // 24rem
+minWidth, // 16rem
+maxWidth, // 50rem
+storageKey }?: UsePanelWidthOptions): {
+    width: number;
+    setWidth: (newWidth: number) => void;
+    minWidth: number;
+    maxWidth: number;
+};
+
+interface UseRovingTabIndexOptions {
+    orientation?: 'horizontal' | 'vertical' | 'grid';
+    loop?: boolean;
+    cols?: number;
+}
+declare function useRovingTabIndex<T extends HTMLElement>(itemCount: number, options?: UseRovingTabIndexOptions): {
+    containerRef: React$1.RefObject<T | null>;
+    handleKeyDown: (event: KeyboardEvent$1) => void;
+    focusItem: (index: number) => void;
+};
+
+/**
+ * Tracks the time remaining on the active KB session's JWT and whether it's
+ * expiring soon (< 5 minutes). Reads the session's `expiresAt` getter (which
+ * derives from the current `token$` value) and re-derives once per second.
+ */
+declare function useSessionExpiry(): {
+    timeRemaining: number | null;
+    isExpiringSoon: boolean;
+};
+
+type Theme = 'light' | 'dark' | 'system';
+type ResolvedTheme = 'light' | 'dark';
+interface ThemeContextValue {
+    theme: Theme;
+    setTheme: (theme: Theme) => void;
+    resolvedTheme: ResolvedTheme;
+    systemTheme: ResolvedTheme;
+}
+declare function ThemeProvider({ children }: {
+    children: ReactNode;
+}): React$1.JSX.Element;
+declare function useTheme(): ThemeContextValue;
+
+/**
+ * Hook for managing dropdown/menu visibility with click outside handling
+ */
+declare function useDropdown(): {
+    isOpen: boolean;
+    toggle: () => void;
+    open: () => void;
+    close: () => void;
+    dropdownRef: React$1.RefObject<HTMLDivElement | null>;
+};
+/**
+ * Hook for managing loading states with minimum display time
+ */
+declare function useLoadingState(minLoadingTime?: number): {
+    isLoading: boolean;
+    showLoading: boolean;
+    startLoading: () => void;
+    stopLoading: () => void;
+};
+/**
+ * Hook for local storage with SSR safety
+ */
+declare function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T | ((val: T) => T)) => void];
+
+interface UseResourceContentResult {
+    content: string;
+    loading: boolean;
+}
+declare function useResourceContent(rUri: ResourceId, resource: ResourceDescriptor, enabled?: boolean): UseResourceContentResult;
+
+interface SemiontProviderProps {
+    /** Inject a fully-constructed browser (tests, embedded hosts that build their own). Omit to use the default. */
+    browser?: SemiontBrowser;
+    /** Override the default `WebBrowserStorage`. Useful for non-browser hosts (Electron/Tauri filesystem-backed adapters). */
+    storage?: SessionStorage;
+    /** Override the default HTTP session factory. Useful for in-process or future non-HTTP transports. */
+    sessionFactory?: SessionFactory;
+    children: ReactNode;
+}
+declare function SemiontProvider({ browser, storage, sessionFactory, children }: SemiontProviderProps): React$1.JSX.Element;
+declare function useSemiont(): SemiontBrowser;
+
+/**
+ * WebBrowserStorage — browser-backed `SessionStorage` implementation.
+ * Wraps `localStorage` for reads/writes and `window`'s `storage` event
+ * for cross-tab change notifications.
+ *
+ * Construction requires a browser context. The guard matches the
+ * existing registry behavior: server rendering that accidentally
+ * instantiates this gets a loud error rather than a silent no-op
+ * that would mask token leaks.
+ */
+
+declare class WebBrowserStorage implements SessionStorage {
+    constructor();
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    delete(key: string): void;
+    subscribe(handler: (key: string, newValue: string | null) => void): () => void;
+}
+
+interface AnnotationProviderProps {
+    annotationManager: AnnotationManager;
+    children: React__default.ReactNode;
+}
+/**
+ * Annotation Provider
+ *
+ * Provides annotation mutation capabilities (create, delete) via the Provider Pattern.
+ * Apps inject their own AnnotationManager implementation.
+ *
+ * Example usage:
+ * ```typescript
+ * function useAnnotationManager(client: SemiontClient): AnnotationManager {
+ *   return {
+ *     markAnnotation: async (params) => {
+ *       const result = await client.mark.annotation({
+ *         motivation: params.motivation,
+ *         target: { source: params.rUri, selector: params.selector },
+ *         body: params.body,
+ *       });
+ *       return result.annotation;
+ *     },
+ *     deleteAnnotation: async (params) => {
+ *       await client.mark.delete(params.rUri, params.annotationId);
+ *     }
+ *   };
+ * }
+ *
+ * // In app layout
+ * const annotationManager = useAnnotationManager();
+ * <AnnotationProvider annotationManager={annotationManager}>
+ *   <YourComponents />
+ * </AnnotationProvider>
+ * ```
+ */
+declare function AnnotationProvider({ annotationManager, children }: AnnotationProviderProps): React__default.JSX.Element;
+/**
+ * Hook to access the AnnotationManager
+ *
+ * @throws Error if used outside AnnotationProvider
+ * @returns AnnotationManager instance
+ */
+declare function useAnnotationManager(): AnnotationManager;
+
+/**
+ * Subscribe to a bus event with automatic cleanup.
+ *
+ * Two buses exist: the app-scoped bus on `SemiontBrowser` (panel, shell,
+ * tabs, nav, settings — events that must work without a KB session) and
+ * the per-session bus on `SemiontClient` (mark, beckon, gather,
+ * match, bind, yield, browse — events tied to a live KB). This hook
+ * subscribes to BOTH so components don't need to know which scope a
+ * channel is on. Each channel only fires on one bus, so there's no
+ * double-delivery.
+ *
+ * Stable-handler pattern: the ref-wrapped handler means `handler` itself
+ * can change on every render without causing a re-subscription.
+ *
+ * @example
+ * ```tsx
+ * useEventSubscription('mark:create-ok', ({ annotationId }) => {
+ *   triggerSparkleAnimation(annotationId);
+ * });
+ * ```
+ */
+declare function useEventSubscription<K extends keyof EventMap>(eventName: K, handler: (payload: EventMap[K]) => void): void;
+/**
+ * Subscribe to multiple bus events at once. Same semantics as
+ * `useEventSubscription`, batched — each channel is subscribed on both
+ * the app bus (`SemiontBrowser`) and the session bus
+ * (`SemiontClient`, when a session is active).
+ *
+ * @example
+ * ```tsx
+ * useEventSubscriptions({
+ *   'mark:create-ok': ({ annotationId }) => handleCreated(annotationId),
+ *   'panel:toggle': ({ panel }) => console.log('toggled', panel),
+ * });
+ * ```
+ */
+declare function useEventSubscriptions(subscriptions: {
+    [K in keyof EventMap]?: (payload: EventMap[K]) => void;
+}): void;
+
+interface ResourceAnnotationsContextType {
+    newAnnotationIds: Set<string>;
+    markAnnotation: (rUri: ResourceId, motivation: 'highlighting' | 'linking' | 'assessing' | 'commenting' | 'tagging', selector: Selector | Selector[], body?: any[]) => Promise<string | undefined>;
+    clearNewAnnotationId: (id: AnnotationId) => void;
+    triggerSparkleAnimation: (annotationId: string) => void;
+}
+declare function ResourceAnnotationsProvider({ children }: {
+    children: React__default.ReactNode;
+}): React__default.JSX.Element;
+declare function useResourceAnnotations(): ResourceAnnotationsContextType;
+
+/**
+ * Standard Link component interface
+ * Compatible with Next.js Link, React Router Link, etc.
+ *
+ * Components accept Link as a prop to remain framework-agnostic.
+ * Apps provide their framework-specific Link component (Next.js, React Router, etc.)
+ */
+interface LinkComponentProps {
+    href: string;
+    children: React__default.ReactNode;
+    className?: string;
+    title?: string;
+    onClick?: (e: React__default.MouseEvent) => void;
+    [key: string]: any;
+}
+/**
+ * Route builder interface
+ * Apps provide concrete implementations for their routing scheme
+ *
+ * Components accept routes as a prop to build URLs without framework dependencies.
+ *
+ * @example
+ * ```tsx
+ * // In app (e.g., frontend/src/lib/routing.ts)
+ * export const routes: RouteBuilder = {
+ *   resourceDetail: (id) => `/know/resource/${id}`,
+ *   userProfile: (id) => `/users/${id}`,
+ *   search: (query) => `/search?q=${query}`,
+ *   home: () => '/',
+ * };
+ *
+ * // Pass to components as props
+ * <MyComponent Link={Link} routes={routes} />
+ * ```
+ */
+interface RouteBuilder {
+    /** Resource detail page */
+    resourceDetail: (id: string) => string;
+    /** User profile page */
+    userProfile: (id: string) => string;
+    /** Search page with query */
+    search: (query: string) => string;
+    /** Home/root page */
+    home: () => string;
+    /** About page */
+    about?: () => string;
+    /** Privacy policy page */
+    privacy?: () => string;
+    /** Terms of service page */
+    terms?: () => string;
+    /** Knowledge base page */
+    knowledge?: () => string;
+    /** Moderation dashboard */
+    moderate?: () => string;
+    /** Admin dashboard */
+    admin?: () => string;
+}
+
+declare const AVAILABLE_LOCALES: readonly ["ar", "bn", "cs", "da", "de", "el", "en", "es", "fa", "fi", "fr", "he", "hi", "id", "it", "ja", "ko", "ms", "nl", "no", "pl", "pt", "ro", "sv", "th", "tr", "uk", "vi", "zh"];
+type AvailableLocale = typeof AVAILABLE_LOCALES[number];
+interface TranslationProviderProps {
+    /**
+     * Option 1: Provide a complete TranslationManager implementation
+     */
+    translationManager?: TranslationManager;
+    /**
+     * Option 2: Use built-in translations by specifying a locale
+     * When adding new locales, just add the JSON file and update AVAILABLE_LOCALES
+     */
+    locale?: string;
+    /**
+     * Loading component to show while translations are being loaded
+     * Only relevant when using dynamic locale loading
+     */
+    loadingComponent?: ReactNode;
+    children: ReactNode;
+}
+/**
+ * Provider for translation management with dynamic loading
+ *
+ * Three modes of operation:
+ * 1. No provider: Components use default English strings
+ * 2. With locale prop: Dynamically loads translations for that locale
+ * 3. With translationManager: Use custom translation implementation
+ */
+declare function TranslationProvider({ translationManager, locale, loadingComponent, children, }: TranslationProviderProps): React$1.JSX.Element;
+/**
+ * Hook to access translations within a namespace
+ *
+ * Works in three modes:
+ * 1. Without provider: Returns default English translations
+ * 2. With provider using locale: Returns dynamically loaded translations for that locale
+ * 3. With custom provider: Uses the custom translation manager
+ *
+ * @param namespace - Translation namespace (e.g., 'Toolbar', 'ResourceViewer')
+ * @returns Function to translate keys within the namespace
+ */
+declare function useTranslations(namespace: string): (key: string, params?: Record<string, any>) => string;
+/**
+ * Hook to preload translations for a locale
+ * Useful for preloading translations before navigation
+ */
+declare function usePreloadTranslations(): {
+    preload: (locale: string) => Promise<boolean>;
+    isLoaded: (locale: string) => boolean;
+};
+
+/**
+ * Pure logic extracted from CodeMirrorRenderer
+ *
+ * These functions have zero dependency on CodeMirror's DOM or React.
+ * They handle position conversion, tooltip generation, and decoration metadata.
+ */
+
+interface TextSegment {
+    exact: string;
+    annotation?: Annotation;
+    start: number;
+    end: number;
+    /** How `segmentTextWithAnnotations` resolved the anchor. Present only on
+     *  annotated segments — background text has no strategy. */
+    strategy?: AnchorStrategy;
+    /** Confidence of the anchor classification. `'high'` is the no-ambiguity
+     *  path; `'medium'` / `'low'` warrant the visual affordance and a one-
+     *  shot warning log. */
+    confidence?: AnchorConfidence;
+}
+
+interface Props$b {
+    content: string;
+    segments?: TextSegment[];
+    onTextSelect?: (exact: string, position: {
+        start: number;
+        end: number;
+    }) => void;
+    onChange?: (content: string) => void;
+    editable?: boolean;
+    newAnnotationIds?: Set<string>;
+    hoveredAnnotationId?: string | null;
+    scrollToAnnotationId?: string | null;
+    sourceView?: boolean;
+    showLineNumbers?: boolean;
+    enableWidgets?: boolean;
+    session?: SemiontSession | null | undefined;
+    getTargetResourceName?: (resourceId: string) => string | undefined;
+    generatingReferenceId?: string | null;
+    hoverDelayMs: number;
+}
+declare function CodeMirrorRenderer({ content, segments, onChange, editable, newAnnotationIds, hoveredAnnotationId, scrollToAnnotationId, sourceView, showLineNumbers, enableWidgets, session, getTargetResourceName, generatingReferenceId, hoverDelayMs }: Props$b): React$1.JSX.Element;
+
+type Motivation$6 = components['schemas']['Motivation'];
+type JobProgress$7 = components['schemas']['JobProgress'];
+interface AnnotateReferencesProgressWidgetProps {
+    progress: JobProgress$7 | null;
+    annotationType?: Motivation$6 | 'reference';
+}
+/**
+ * Widget for displaying reference annotation progress with cancel functionality
+ *
+ * @emits job:cancel-requested - User requested to cancel annotation job. Payload: { jobType: string }
+ */
+declare function AnnotateReferencesProgressWidget({ progress, annotationType }: AnnotateReferencesProgressWidgetProps): React$1.JSX.Element | null;
+
+interface Props$a {
+    children: ReactNode;
+    fallback?: (error: Error, reset: () => void) => ReactNode;
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+interface State {
+    hasError: boolean;
+    error: Error | null;
+}
+/**
+ * Generic Error Boundary component that catches JavaScript errors
+ * in child components and displays a fallback UI.
+ */
+declare class ErrorBoundary extends Component<Props$a, State> {
+    constructor(props: Props$a);
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    handleReset: () => void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | React$1.JSX.Element | null | undefined;
+}
+/**
+ * Specialized error boundary for async components
+ */
+declare function AsyncErrorBoundary({ children }: {
+    children: ReactNode;
+}): React$1.JSX.Element;
+
+interface ProtectedErrorBoundaryProps {
+    children: React__default.ReactNode;
+    /**
+     * Values that, when any change, reset the boundary back to its non-error
+     * state. Apps typically pass `[location.pathname]` so navigating away from
+     * a crashed page automatically recovers.
+     */
+    resetKeys?: unknown[];
+}
+/**
+ * Error boundary for protected (authenticated) routes.
+ *
+ * Catches unexpected render-time crashes inside the protected tree and
+ * shows a generic "something went wrong" fallback with a refresh option.
+ *
+ * NOT auth-specific. Auth state changes (sign-in, sign-out, expiry) flow
+ * through the KnowledgeBaseSession context, not exceptions — so this
+ * boundary will never catch an "auth error" in normal operation. Its job
+ * is purely to keep a render bug from blanking the screen.
+ *
+ * The optional `resetKeys` prop lets callers wire automatic recovery on
+ * navigation (e.g. `resetKeys={[location.pathname]}`).
+ */
+declare function ProtectedErrorBoundary({ children, resetKeys, }: ProtectedErrorBoundaryProps): React__default.JSX.Element;
+
+interface LiveRegionContextType {
+    announce: (message: string, priority?: 'polite' | 'assertive') => void;
+}
+declare function useLiveRegion(): LiveRegionContextType;
+interface LiveRegionProviderProps {
+    children: React__default.ReactNode;
+}
+declare function LiveRegionProvider({ children }: LiveRegionProviderProps): React__default.JSX.Element;
+declare function useSearchAnnouncements(): {
+    announceSearchResults: (count: number, query: string) => void;
+    announceSearching: () => void;
+};
+declare function useDocumentAnnouncements(annotators?: Record<string, Annotator>): {
+    announceDocumentSaved: () => void;
+    announceDocumentDeleted: () => void;
+    announceAnnotationCreated: (annotation: Annotation) => void;
+    announceAnnotationDeleted: () => void;
+    announceAnnotationUpdated: (annotation: Annotation) => void;
+    announceError: (message: string) => void;
+};
+declare function useResourceLoadingAnnouncements(): {
+    announceResourceLoading: (resourceName?: string) => void;
+    announceResourceLoaded: (resourceName: string) => void;
+    announceResourceLoadError: (resourceName?: string) => void;
+    announceResourceUpdating: (resourceName: string) => void;
+};
+declare function useFormAnnouncements(): {
+    announceFormSubmitting: () => void;
+    announceFormSuccess: (message?: string) => void;
+    announceFormError: (message?: string) => void;
+    announceFormValidationError: (fieldCount: number) => void;
+};
+declare function useLanguageChangeAnnouncements(): {
+    announceLanguageChanging: (newLanguage: string) => void;
+    announceLanguageChanged: (newLanguage: string) => void;
+};
+
+interface ResizeHandleProps {
+    /** Callback fired when resize occurs */
+    onResize: (newWidth: number) => void;
+    /** Minimum allowed width in pixels */
+    minWidth: number;
+    /** Maximum allowed width in pixels */
+    maxWidth: number;
+    /** Position of handle - left or right edge */
+    position?: 'left' | 'right';
+    /** Aria label for accessibility */
+    ariaLabel?: string;
+}
+/**
+ * Draggable resize handle for panels and sidebars
+ *
+ * Features:
+ * - Mouse drag to resize
+ * - Keyboard navigation (Arrow keys: ±10px, Shift+Arrow: ±50px)
+ * - Enforces min/max constraints
+ * - Visual feedback on hover and drag
+ * - Accessible (WCAG compliant)
+ *
+ * @example
+ * ```tsx
+ * <div className="panel" style={{ width: `${width}px` }}>
+ *   <ResizeHandle
+ *     onResize={setWidth}
+ *     minWidth={256}
+ *     maxWidth={800}
+ *     position="left"
+ *   />
+ *   <div>Panel content</div>
+ * </div>
+ * ```
+ */
+declare function ResizeHandle({ onResize, minWidth, maxWidth, position, ariaLabel }: ResizeHandleProps): React__default.JSX.Element;
+
+interface ResourceTagsInlineProps {
+    resourceId: string;
+    tags: string[];
+    isEditing: boolean;
+    onUpdate: (tags: string[]) => Promise<void>;
+    disabled?: boolean;
+}
+declare function ResourceTagsInline({ tags }: ResourceTagsInlineProps): React$1.JSX.Element | null;
+
+type ToastType = 'success' | 'error' | 'info' | 'warning';
+interface ToastMessage {
+    id: string;
+    message: string;
+    type: ToastType;
+    duration?: number;
+}
+interface ToastContainerProps {
+    toasts: ToastMessage[];
+    onClose: (id: string) => void;
+}
+declare function ToastContainer({ toasts, onClose }: ToastContainerProps): React__default.ReactPortal | null;
+interface ToastContextType {
+    showToast: (message: string, type?: ToastType, duration?: number) => void;
+    showSuccess: (message: string, duration?: number) => void;
+    showError: (message: string, duration?: number) => void;
+    showWarning: (message: string, duration?: number) => void;
+    showInfo: (message: string, duration?: number) => void;
+}
+declare function ToastProvider({ children }: {
+    children: React__default.ReactNode;
+}): React__default.JSX.Element;
+declare function useToast(): ToastContextType;
+
+type ToolbarContext = 'document' | 'simple';
+interface Props$9<T extends string = string> {
+    context: ToolbarContext;
+    activePanel: T | null;
+    isArchived?: boolean;
+}
+/**
+ * Toolbar component for panel navigation
+ *
+ * @emits panel:toggle - Toggle panel visibility. Payload: { panel: string }
+ */
+declare function Toolbar<T extends string = string>({ context, activePanel, isArchived }: Props$9<T>): React$1.JSX.Element;
+
+interface SettingsPanelProps {
+    showLineNumbers: boolean;
+    theme: 'light' | 'dark' | 'system';
+    locale: string;
+    isPendingLocaleChange?: boolean;
+    hoverDelayMs: number;
+}
+/**
+ * Settings panel for application preferences
+ *
+ * @emits settings:locale-changed - Locale changed by user. Payload: { locale: string }
+ * @emits settings:line-numbers-toggled - Line numbers toggled on/off. Payload: undefined
+ * @emits settings:theme-changed - Theme changed by user. Payload: { theme: 'light' | 'dark' | 'system' }
+ * @emits settings:hover-delay-changed - Hover delay changed by user. Payload: { hoverDelayMs: number }
+ */
+declare function SettingsPanel({ showLineNumbers, theme, locale, isPendingLocaleChange, hoverDelayMs }: SettingsPanelProps): React__default.JSX.Element;
+
+interface JsonLdViewProps {
+    annotation: Annotation;
+    onBack: () => void;
+}
+declare function JsonLdView({ annotation, onBack }: JsonLdViewProps): React$1.JSX.Element;
+
+interface SelectedTextDisplayProps {
+    exact: string;
+}
+declare function SelectedTextDisplay({ exact }: SelectedTextDisplayProps): React__default.JSX.Element;
+interface EntityTypeBadgesProps {
+    entityTypes: string;
+}
+declare function EntityTypeBadges({ entityTypes }: EntityTypeBadgesProps): React__default.JSX.Element | null;
+interface PopupHeaderProps {
+    title: string;
+    selectedText?: string;
+    onClose: () => void;
+}
+declare function PopupHeader({ title, selectedText, onClose }: PopupHeaderProps): React__default.JSX.Element;
+interface PopupContainerProps {
+    children: React__default.ReactNode;
+    position: {
+        x: number;
+        y: number;
+    };
+    onClose: () => void;
+    isOpen: boolean;
+    wide?: boolean;
+}
+declare function PopupContainer({ children, position, onClose, isOpen, wide }: PopupContainerProps): React__default.JSX.Element;
+
+interface AnnotationOverlayProps {
+    annotations: Annotation[];
+    imageWidth: number;
+    imageHeight: number;
+    displayWidth: number;
+    displayHeight: number;
+    session?: SemiontSession | null | undefined;
+    hoveredAnnotationId?: string | null;
+    selectedAnnotationId?: string | null;
+    hoverDelayMs: number;
+}
+/**
+ * Render annotation overlay - displays existing annotations as SVG shapes
+ *
+ * @emits beckon:hover - Annotation hovered or unhovered. Payload: { annotationId: string | null }
+ * @emits browse:click - Annotation clicked. Payload: { annotationId: string, motivation: Motivation }
+ */
+declare function AnnotationOverlay({ annotations, imageWidth, imageHeight, displayWidth, displayHeight, session, hoveredAnnotationId, selectedAnnotationId, hoverDelayMs }: AnnotationOverlayProps): React$1.JSX.Element;
+
+type DrawingMode = 'rectangle' | 'polygon' | 'circle' | 'freeform' | null;
+interface SvgDrawingCanvasProps {
+    imageUrl: string;
+    existingAnnotations?: Annotation[];
+    drawingMode: DrawingMode;
+    selectedMotivation?: SelectionMotivation | null;
+    session?: SemiontSession | null | undefined;
+    hoveredAnnotationId?: string | null;
+    selectedAnnotationId?: string | null;
+    hoverDelayMs?: number;
+}
+/**
+ * SVG-based drawing canvas for creating image annotations with shapes
+ *
+ * @emits browse:click - Annotation clicked on canvas. Payload: { annotationId: string, motivation: Motivation }
+ * @emits mark:requested - New annotation drawn on canvas. Payload: { selector: SvgSelector, motivation: SelectionMotivation }
+ */
+declare function SvgDrawingCanvas({ imageUrl, existingAnnotations, drawingMode, selectedMotivation, session, hoveredAnnotationId, selectedAnnotationId }: SvgDrawingCanvasProps): React__default.JSX.Element;
+
+interface KeyboardShortcutsHelpModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+}
+declare function KeyboardShortcutsHelpModal({ isOpen, onClose }: KeyboardShortcutsHelpModalProps): React__default.JSX.Element;
+
+/**
+ * Modal that surfaces when a 403 forbidden error is reported via
+ * the active session's `signals.notifyPermissionDenied(...)`.
+ *
+ * Reads `permissionDeniedAt$` and `permissionDeniedMessage$` from the
+ * active `SessionSignals`. The signals instance clears the
+ * flag when the user dismisses the modal. Modal state lives on
+ * signals (not the session itself) so headless sessions
+ * (workers/CLIs) don't carry dead observables.
+ */
+declare function PermissionDeniedModal(): React$1.JSX.Element;
+
+/**
+ * Modal that surfaces when the active KB's session expires (a 401
+ * surfaced by the session's own JWT validation or by the host's
+ * error-routing path).
+ *
+ * Reads `sessionExpiredAt$` from the active `SessionSignals`.
+ * When the user dismisses the modal, the signals instance clears the
+ * flag. Modal state lives on signals (not the session itself) so
+ * headless sessions (workers/CLIs) don't carry dead observables.
+ */
+declare function SessionExpiredModal(): React$1.JSX.Element;
+
+interface Props$8 {
+    content: string;
+    mimeType?: string;
+    resourceUri?: string;
+    annotations: AnnotationsCollection;
+    uiState: AnnotationUIState;
+    onUIStateChange?: (state: Partial<AnnotationUIState>) => void;
+    editable?: boolean;
+    enableWidgets?: boolean;
+    getTargetResourceName?: (resourceId: string) => string | undefined;
+    generatingReferenceId?: string | null;
+    showLineNumbers?: boolean;
+    hoverDelayMs?: number;
+    annotateMode: boolean;
+}
+/**
+ * View component for annotating resources with text selection and drawing
+ *
+ * @emits mark:requested - User requested to create annotation. Payload: { selector: Selector | Selector[], motivation: SelectionMotivation }
+ * @subscribes mark:selection-changed - Toolbar selection changed. Payload: { motivation: string | null }
+ * @subscribes mark:click-changed - Toolbar click action changed. Payload: { action: string }
+ * @subscribes mark:shape-changed - Toolbar shape changed. Payload: { shape: string }
+ * @subscribes beckon:hover - Annotation hovered. Payload: { annotationId: string | null }
+ */
+declare function AnnotateView({ content, mimeType, resourceUri, annotations, uiState, onUIStateChange, enableWidgets, getTargetResourceName, generatingReferenceId, showLineNumbers, hoverDelayMs, annotateMode }: Props$8): React$1.JSX.Element;
+
+interface Props$7 {
+    rUri: ResourceId;
+    hoveredAnnotationId?: string | null;
+    onEventHover?: (annotationId: string | null) => void;
+    onEventClick?: (annotationId: string | null) => void;
+    Link: React__default.ComponentType<LinkComponentProps>;
+    routes: RouteBuilder;
+}
+declare function AnnotationHistory({ rUri, hoveredAnnotationId, onEventHover, onEventClick, Link, routes }: Props$7): React__default.JSX.Element | null;
+
+interface Props$6 {
+    content: string;
+    mimeType: string;
+    resourceUri: string;
+    annotations: AnnotationsCollection;
+    hoveredAnnotationId?: string | null;
+    selectedClick?: ClickAction;
+    annotateMode: boolean;
+    hoverDelayMs?: number;
+}
+/**
+ * View component for browsing annotated resources in read-only mode.
+ *
+ * Two-layer rendering:
+ * - Layer 1: Markdown renders once (MemoizedMarkdown, cached by content)
+ * - Layer 2: Annotation overlay applied via DOM Range API after paint
+ *
+ * @emits browse:click - User clicked on annotation. Payload: { annotationId: string, motivation: Motivation }
+ * @emits beckon:hover - User hovered over annotation. Payload: { annotationId: string | null }
+ *
+ * @subscribes beckon:hover - Highlight annotation on hover. Payload: { annotationId: string | null }
+ * @subscribes beckon:focus - Scroll to and highlight annotation. Payload: { annotationId: string }
+ */
+declare const BrowseView: React$1.MemoExoticComponent<({ content, mimeType, resourceUri, annotations, selectedClick, annotateMode, hoverDelayMs }: Props$6) => React$1.JSX.Element>;
+
+type TranslateFn$4 = (key: string, params?: Record<string, string | number>) => string;
+interface Props$5 {
+    event: StoredEventLike;
+    annotations: any[];
+    allEvents: StoredEventLike[];
+    isRelated: boolean;
+    t: TranslateFn$4;
+    Link: React__default.ComponentType<LinkComponentProps>;
+    routes: RouteBuilder;
+    onEventRef?: (annotationId: string | null, element: HTMLElement | null) => void;
+    onEventClick?: (annotationId: string | null) => void;
+    onEventHover?: (annotationId: string | null) => void;
+}
+declare function HistoryEvent({ event, annotations, allEvents, isRelated, t, Link, routes, onEventRef, onEventClick, onEventHover }: Props$5): React__default.JSX.Element;
+
+/**
+ * ResourceViewer - Display and interact with resource content and annotations
+ *
+ * This component uses event-driven architecture for real-time updates:
+ * - Subscribes to make-meaning events (mark:added, mark:removed, mark:body-updated)
+ * - Automatically invalidates cache when annotations change
+ * - No manual refetch needed - events handle cache invalidation
+ *
+ * Requirements:
+ * - Must be wrapped in SemiontProvider (which owns the session's event bus)
+ * - Must be wrapped in CacheContext (provides cache manager)
+ *
+ * Event flow:
+ *   make-meaning → EventLog → SSE → EventBus → ResourceViewer → Cache invalidation
+ *
+ * Phase 2 complete: Event-based cache invalidation replaces manual refetch
+ * Phase 3 complete: Fully event-driven - all user interactions use unified event bus
+ */
+interface Props$4 {
+    resource: ResourceDescriptor & {
+        content: string;
+    };
+    annotations: AnnotationsCollection;
+    generatingReferenceId?: string | null;
+    showLineNumbers?: boolean;
+    hoverDelayMs?: number;
+    hoveredAnnotationId?: string | null;
+}
+/**
+ * @emits mark:delete - User requested to delete annotation. Payload: { annotationId: string }
+ * @emits panel:open - Request to open panel with annotation. Payload: { panel: string, scrollToAnnotationId?: string, motivation?: Motivation }
+ *
+ * @subscribes mark:mode-toggled - Toggles between browse and annotate mode. Payload: { mode: 'browse' | 'annotate' }
+ * @subscribes mark:added - New annotation was added. Payload: { annotation: Annotation }
+ * @subscribes mark:removed - Annotation was removed. Payload: { annotationId: string }
+ * @subscribes mark:body-updated - Annotation was updated. Payload: { annotation: Annotation }
+ * @subscribes mark:selection-changed - Text selection tool changed. Payload: { selection: boolean }
+ * @subscribes mark:click-changed - Click annotation tool changed. Payload: { click: 'detail' | 'scroll' | null }
+ * @subscribes mark:shape-changed - Drawing shape changed. Payload: { shape: string }
+ * @subscribes browse:click - User clicked on annotation. Payload: { annotationId: string }
+ */
+declare function ResourceViewer({ resource, annotations, generatingReferenceId, showLineNumbers, hoverDelayMs, hoveredAnnotationId: hoveredAnnotationIdProp }: Props$4): React__default.JSX.Element;
+
+interface AssessmentEntryProps {
+    assessment: Annotation;
+    isFocused: boolean;
+    isHovered?: boolean;
+    ref?: Ref<HTMLDivElement>;
+}
+declare function AssessmentEntry({ assessment, isFocused, isHovered, ref, }: AssessmentEntryProps): React$1.JSX.Element;
+
+type Motivation$5 = components['schemas']['Motivation'];
+type JobProgress$6 = components['schemas']['JobProgress'];
+interface PendingAnnotation$5 {
+    selector: Selector | Selector[];
+    motivation: Motivation$5;
+}
+interface AssessmentPanelProps {
+    annotations: Annotation[];
+    pendingAnnotation: PendingAnnotation$5 | null;
+    isAssisting?: boolean;
+    progress?: JobProgress$6 | null;
+    locale?: string;
+    /** BCP-47 tag of the resource being analyzed — forwarded to the assist call. */
+    sourceLanguage?: string;
+    annotateMode?: boolean;
+    scrollToAnnotationId?: string | null;
+    onScrollCompleted?: () => void;
+    hoveredAnnotationId?: string | null;
+}
+/**
+ * Panel for managing assessment annotations with text input
+ *
+ * @emits mark:create - Create new assessment annotation. Payload: { motivation: 'assessing', selector: Selector | Selector[], body: Body[] }
+ * @emits mark:cancel-pending - Cancel pending assessment annotation. Payload: undefined
+ * @subscribes browse:click - Annotation clicked. Payload: { annotationId: string }
+ */
+declare function AssessmentPanel({ annotations, pendingAnnotation, isAssisting, progress, locale, sourceLanguage, annotateMode, scrollToAnnotationId, onScrollCompleted, hoveredAnnotationId, }: AssessmentPanelProps): React$1.JSX.Element;
+
+interface Props$3 {
+    /**
+     * Connection state from `client.actor.state$`. See
+     * `packages/api-client/src/state/domain/actor-state-unit.ts`.
+     *
+     * UI mapping:
+     *   `open` | `reconnecting` | `initial` | `connecting`
+     *     → treated as "healthy" (green dot, "Live" label, event count visible).
+     *     `reconnecting` is specifically INCLUDED in healthy because a
+     *     brief reconnect (mount churn, channel-set change, quick blip)
+     *     shouldn't alarm the user. The 100 ms reconnect debounce and
+     *     sub-second fetch retry make `reconnecting` a transient state.
+     *   `degraded` | `closed`
+     *     → treated as "disconnected" (red dot, "Disconnected" label).
+     *     `degraded` is the 3 s threshold at which the state machine
+     *     decides the disconnect is sustained; this is the UI-banner
+     *     trigger the plan was designed around.
+     */
+    state: ConnectionState;
+    eventCount: number;
+    lastEventTimestamp?: string;
+    knowledgeBaseName?: string;
+}
+declare function CollaborationPanel({ state, eventCount, lastEventTimestamp, knowledgeBaseName }: Props$3): React$1.JSX.Element;
+
+interface CommentEntryProps {
+    comment: Annotation;
+    isFocused: boolean;
+    isHovered?: boolean;
+    annotateMode?: boolean;
+    ref?: Ref<HTMLDivElement>;
+}
+declare function CommentEntry({ comment, isFocused, isHovered, annotateMode, ref, }: CommentEntryProps): React$1.JSX.Element;
+
+type Motivation$4 = components['schemas']['Motivation'];
+type JobProgress$5 = components['schemas']['JobProgress'];
+interface PendingAnnotation$4 {
+    selector: Selector | Selector[];
+    motivation: Motivation$4;
+}
+interface CommentsPanelProps {
+    annotations: Annotation[];
+    pendingAnnotation: PendingAnnotation$4 | null;
+    annotateMode?: boolean;
+    isAssisting?: boolean;
+    progress?: JobProgress$5 | null;
+    locale?: string;
+    /** BCP-47 tag of the resource being analyzed — forwarded to the assist call. */
+    sourceLanguage?: string;
+    scrollToAnnotationId?: string | null;
+    onScrollCompleted?: () => void;
+    hoveredAnnotationId?: string | null;
+}
+/**
+ * Panel for managing comment annotations with text input
+ *
+ * @emits mark:create - Create new comment annotation. Payload: { motivation: 'commenting', selector: Selector | Selector[], body: Body[] }
+ * @emits mark:cancel-pending - Cancel pending comment annotation. Payload: undefined
+ * @subscribes browse:click - Annotation clicked. Payload: { annotationId: string }
+ */
+declare function CommentsPanel({ annotations, pendingAnnotation, annotateMode, isAssisting, progress, locale, sourceLanguage, scrollToAnnotationId, onScrollCompleted, hoveredAnnotationId, }: CommentsPanelProps): React$1.JSX.Element;
+
+type JobProgress$4 = components['schemas']['JobProgress'];
+interface AssistSectionProps {
+    annotationType: 'highlight' | 'assessment' | 'comment';
+    isAssisting: boolean;
+    /** User UI locale — written into the annotation body's `language` field for comment/assessment. */
+    locale?: string;
+    /** BCP-47 tag of the resource being analyzed. Forwarded to the prompt so the LLM analyzes non-English source correctly. */
+    sourceLanguage?: string;
+    progress?: JobProgress$4 | null | undefined;
+}
+/**
+ * Shared assist section for Highlight, Assessment, and Comment panels
+ *
+ * Provides:
+ * - Optional instructions textarea
+ * - Optional tone selector (for comments)
+ * - Assist button with sparkle animation
+ * - Progress display during annotation assist
+ *
+ * @emits mark:assist-request - Start assist for annotation type. Payload: { motivation: Motivation, options: { instructions?: string, tone?: string, density?: number } }
+ * @emits mark:progress-dismiss - Dismiss the annotation progress display
+ */
+declare function AssistSection({ annotationType, isAssisting, locale, sourceLanguage, progress, }: AssistSectionProps): React$1.JSX.Element;
+
+interface HighlightEntryProps {
+    highlight: Annotation;
+    isFocused: boolean;
+    isHovered?: boolean;
+    ref?: Ref<HTMLDivElement>;
+}
+declare function HighlightEntry({ highlight, isFocused, isHovered, ref, }: HighlightEntryProps): React$1.JSX.Element;
+
+type Motivation$3 = components['schemas']['Motivation'];
+type JobProgress$3 = components['schemas']['JobProgress'];
+interface PendingAnnotation$3 {
+    selector: Selector | Selector[];
+    motivation: Motivation$3;
+}
+interface HighlightPanelProps {
+    annotations: Annotation[];
+    pendingAnnotation: PendingAnnotation$3 | null;
+    isAssisting?: boolean;
+    progress?: JobProgress$3 | null;
+    annotateMode?: boolean;
+    scrollToAnnotationId?: string | null;
+    onScrollCompleted?: () => void;
+    hoveredAnnotationId?: string | null;
+    /** BCP-47 tag of the resource being analyzed — forwarded to the assist call so the LLM analyzes non-English source correctly. */
+    sourceLanguage?: string;
+}
+/**
+ * Panel for managing highlight annotations with auto-creation
+ *
+ * @emits mark:create - Create new highlight annotation (auto-triggered). Payload: { motivation: 'highlighting', selector: Selector | Selector[], body: Body[] }
+ * @subscribes browse:click - Annotation clicked. Payload: { annotationId: string }
+ */
+declare function HighlightPanel({ annotations, pendingAnnotation, isAssisting, progress, annotateMode, scrollToAnnotationId, onScrollCompleted, hoveredAnnotationId, sourceLanguage, }: HighlightPanelProps): React$1.JSX.Element;
+
+type SemiontResource$1 = components['schemas']['ResourceDescriptor'];
+interface Props$2 {
+    resource: SemiontResource$1;
+}
+declare function JsonLdPanel({ resource: semiontResource }: Props$2): React$1.JSX.Element;
+
+interface PanelHeaderProps {
+    annotationType: 'highlight' | 'reference' | 'assessment' | 'comment' | 'tag';
+    count: number;
+    title: string;
+}
+/**
+ * Shared header for annotation panels
+ *
+ * Displays the annotation icon, translated title, and count in a consistent format
+ */
+declare function PanelHeader({ count, title }: PanelHeaderProps): React$1.JSX.Element;
+
+interface ReferenceEntryProps {
+    reference: Annotation;
+    isFocused: boolean;
+    isHovered?: boolean;
+    routes: RouteBuilder;
+    annotateMode?: boolean;
+    isGenerating?: boolean;
+    ref?: Ref<HTMLDivElement>;
+}
+declare function ReferenceEntry({ reference, isFocused, isHovered, routes, annotateMode, isGenerating, ref, }: ReferenceEntryProps): React$1.JSX.Element;
+
+type JobProgress$2 = components['schemas']['JobProgress'];
+
+type Motivation$2 = components['schemas']['Motivation'];
+type ReferencedBy = components['schemas']['GetReferencedByResponse']['referencedBy'][number];
+interface PendingAnnotation$2 {
+    selector: Selector | Selector[];
+    motivation: Motivation$2;
+}
+interface Props$1 {
+    annotations?: Annotation[];
+    isAssisting: boolean;
+    progress: JobProgress$2 | null;
+    annotateMode?: boolean;
+    Link: React__default.ComponentType<LinkComponentProps>;
+    routes: RouteBuilder;
+    allEntityTypes: string[];
+    generatingReferenceId?: string | null;
+    referencedBy?: ReferencedBy[];
+    referencedByLoading?: boolean;
+    pendingAnnotation: PendingAnnotation$2 | null;
+    scrollToAnnotationId?: string | null;
+    onScrollCompleted?: () => void;
+    hoveredAnnotationId?: string | null;
+    /** User UI locale — stamped on the unresolved-reference body's `language` field. */
+    locale?: string;
+    /** BCP-47 tag of the resource being analyzed — fed into the prompt for source-aware analysis. */
+    sourceLanguage?: string;
+}
+/**
+ * Panel for managing reference annotations with entity type annotation
+ *
+ * @emits annotate:detect-request - Start reference annotation. Payload: { motivation: 'linking', options: { entityTypes: string[], includeDescriptiveReferences: boolean } }
+ * @emits mark:create - Create new reference annotation. Payload: { motivation: 'linking', selector: Selector | Selector[], body: Body[] }
+ * @emits mark:cancel-pending - Cancel pending reference annotation. Payload: undefined
+ * @subscribes browse:click - Annotation clicked. Payload: { annotationId: string }
+ */
+declare function ReferencesPanel({ annotations, isAssisting, progress, annotateMode, Link, routes, allEntityTypes, generatingReferenceId, referencedBy, referencedByLoading, pendingAnnotation, scrollToAnnotationId, onScrollCompleted, hoveredAnnotationId, locale, sourceLanguage, }: Props$1): React__default.JSX.Element;
+
+type Agent = components['schemas']['Agent'];
+interface Props {
+    resourceId: string;
+    documentEntityTypes: string[];
+    documentLocale?: string | undefined;
+    primaryMediaType?: string | undefined;
+    primaryByteSize?: number | undefined;
+    storageUri?: string | undefined;
+    isArchived?: boolean;
+    dateCreated?: string | undefined;
+    dateModified?: string | undefined;
+    wasAttributedTo?: Agent | Agent[] | undefined;
+    wasDerivedFrom?: string | string[] | undefined;
+    generator?: Agent | Agent[] | undefined;
+}
+/**
+ * Panel for displaying resource metadata and management actions
+ *
+ * @emits yield:clone - Clone this resource
+ * @emits mark:unarchive - Unarchive this resource
+ * @emits mark:archive - Archive this resource
+ */
+declare function ResourceInfoPanel({ resourceId, documentEntityTypes, documentLocale, primaryMediaType, primaryByteSize, storageUri, isArchived, dateCreated, dateModified, wasAttributedTo, wasDerivedFrom, generator, }: Props): React$1.JSX.Element;
+
+interface StatisticsPanelProps {
+    highlights: Annotation[];
+    comments: Annotation[];
+    assessments: Annotation[];
+    references: Annotation[];
+    tags: Annotation[];
+}
+declare function StatisticsPanel({ highlights, comments, assessments, references, tags }: StatisticsPanelProps): React$1.JSX.Element;
+
+interface TagEntryProps {
+    tag: Annotation;
+    isFocused: boolean;
+    isHovered?: boolean;
+    ref?: Ref<HTMLDivElement>;
+}
+declare function TagEntry({ tag, isFocused, isHovered, ref, }: TagEntryProps): React$1.JSX.Element;
+
+type Motivation$1 = components['schemas']['Motivation'];
+type JobProgress$1 = components['schemas']['JobProgress'];
+interface PendingAnnotation$1 {
+    selector: Selector | Selector[];
+    motivation: Motivation$1;
+}
+interface TaggingPanelProps {
+    annotations: Annotation[];
+    annotateMode?: boolean;
+    isAssisting?: boolean;
+    progress?: JobProgress$1 | null;
+    pendingAnnotation: PendingAnnotation$1 | null;
+    scrollToAnnotationId?: string | null;
+    onScrollCompleted?: () => void;
+    hoveredAnnotationId?: string | null;
+    /** User UI locale — stamped on the tagging body's `language` field. */
+    locale?: string;
+    /** BCP-47 tag of the resource being analyzed — fed into the prompt for source-aware analysis. */
+    sourceLanguage?: string;
+}
+/**
+ * Panel for managing tag annotations with schema-based annotation
+ *
+ * @emits annotate:detect-request - Start tag annotation. Payload: { motivation: 'tagging', options: { schemaId: string, categories: string[] } }
+ * @emits mark:cancel-pending - Cancel pending tag annotation. Payload: undefined
+ * @emits mark:create - Create new tag annotation. Payload: { motivation: 'tagging', selector: Selector | Selector[], body: Body[] }
+ * @subscribes browse:click - Annotation clicked. Payload: { annotationId: string }
+ */
+declare function TaggingPanel({ annotations, annotateMode, isAssisting, progress, pendingAnnotation, scrollToAnnotationId, onScrollCompleted, hoveredAnnotationId, locale, sourceLanguage, }: TaggingPanelProps): React$1.JSX.Element;
+
+type JobProgress = components['schemas']['JobProgress'];
+
+type Motivation = components['schemas']['Motivation'];
+type TabKey = 'statistics' | 'reference' | 'highlight' | 'assessment' | 'comment' | 'tag';
+interface PendingAnnotation {
+    selector: Selector | Selector[];
+    motivation: Motivation;
+}
+/**
+ * Simplified UnifiedAnnotationsPanel using event-driven architecture
+ *
+ * Key simplifications:
+ * - Single annotations array (grouped internally by motivation)
+ * - Single focusedAnnotationId (motivation-agnostic)
+ * - Hover state managed via event bus (no props needed)
+ * - All operations managed via event bus (no callback props)
+ */
+interface UnifiedAnnotationsPanelProps {
+    annotations: Annotation[];
+    annotators: Record<string, Annotator>;
+    annotateMode?: boolean;
+    assistingMotivation?: Motivation | null;
+    progress?: JobProgress | null;
+    pendingAnnotation: PendingAnnotation | null;
+    allEntityTypes?: string[];
+    generatingReferenceId?: string | null;
+    referencedBy?: any[];
+    referencedByLoading?: boolean;
+    resourceId?: string;
+    initialTab?: TabKey;
+    initialTabGeneration?: number;
+    scrollToAnnotationId?: string | null;
+    onScrollCompleted?: () => void;
+    hoveredAnnotationId?: string | null;
+    locale?: string;
+    /**
+     * BCP-47 tag of the resource being analyzed (source-resource locale).
+     * Independent from `locale` — a German user can analyze a French source
+     * and get German bodies back. Fed into detection prompts.
+     */
+    sourceLanguage?: string;
+    Link: React__default.ComponentType<LinkComponentProps>;
+    routes: RouteBuilder;
+}
+declare function UnifiedAnnotationsPanel(props: UnifiedAnnotationsPanelProps): React__default.JSX.Element;
+
+interface ImageViewerProps {
+    imageUrl: string;
+    mimeType: string;
+    alt?: string;
+}
+declare function ImageViewer({ imageUrl, alt }: ImageViewerProps): React$1.JSX.Element;
+
+type TranslateFn$3 = (key: string, params?: Record<string, any>) => string;
+interface FooterProps {
+    Link: React__default.ComponentType<LinkComponentProps>;
+    routes: RouteBuilder;
+    t: TranslateFn$3;
+    CookiePreferences?: React__default.ComponentType<{
+        isOpen: boolean;
+        onClose: () => void;
+    }>;
+    onOpenKeyboardHelp?: () => void;
+    sourceCodeUrl?: string;
+    /** Show About, Privacy Policy, Terms of Service, Cookie Preferences links. False for desktop apps. */
+    showPolicyLinks?: boolean;
+}
+declare function Footer({ Link, routes, t, CookiePreferences, onOpenKeyboardHelp, sourceCodeUrl, showPolicyLinks, }: FooterProps): React__default.JSX.Element;
+
+type TranslateFn$2 = (key: string, params?: Record<string, any>) => string;
+interface NavigationMenuProps {
+    Link: React__default.ComponentType<LinkComponentProps>;
+    routes: Partial<RouteBuilder>;
+    t: TranslateFn$2;
+    isAdmin?: boolean;
+    isModerator?: boolean;
+    brandingLink?: string;
+    onItemClick?: () => void;
+    className?: string;
+    currentPath?: string;
+}
+declare function NavigationMenu({ Link, routes, t, isAdmin, isModerator, onItemClick, className, currentPath }: NavigationMenuProps): React__default.JSX.Element;
+
+/**
+ * Props for ObservableLink component
+ *
+ * Accepts any props that a standard anchor element accepts,
+ * plus optional navigation metadata for event emission.
+ */
+interface ObservableLinkProps extends React__default.AnchorHTMLAttributes<HTMLAnchorElement> {
+    /** The URL to navigate to */
+    href: string;
+    /** Optional label for the link (used in event metadata) */
+    label?: string;
+    /** Children to render inside the link */
+    children: React__default.ReactNode;
+}
+/**
+ * Link component that emits navigation events for observability
+ *
+ * Use this instead of Next.js <Link> when you want link clicks to be
+ * observable through the NavigationEventBus. This is useful for:
+ * - Analytics tracking
+ * - State coordination before navigation
+ * - Logging navigation flows
+ *
+ * The component emits 'nav:link-clicked' event before allowing
+ * the browser to follow the link.
+ *
+ * @example
+ * ```typescript
+ * <ObservableLink
+ *   href="/know/discover"
+ *   label="Discover"
+ * >
+ *   Discover Resources
+ * </ObservableLink>
+ * ```
+ *
+ * @example With Next.js Link integration
+ * ```typescript
+ * import Link from 'next/link';
+ *
+ * <Link href="/know/discover" legacyBehavior passHref>
+ *   <ObservableLink label="Discover">
+ *     Discover Resources
+ *   </ObservableLink>
+ * </Link>
+ * ```
+ *
+ * @emits nav:link-clicked - Link clicked by user. Payload: { href: string, label?: string }
+ */
+declare function ObservableLink({ href, label, onClick, children, ...anchorProps }: ObservableLinkProps): React__default.JSX.Element;
+
+interface SimpleNavigationItem$1 {
+    name: string;
+    href: string;
+    icon: React__default.ComponentType<{
+        className?: string;
+    }>;
+    description?: string;
+}
+interface SimpleNavigationProps$1 {
+    title: string;
+    items: SimpleNavigationItem$1[];
+    currentPath: string;
+    LinkComponent: React__default.ComponentType<any>;
+    dropdownContent?: (onClose: () => void) => React__default.ReactNode;
+    isCollapsed: boolean;
+    icons: {
+        chevronLeft: React__default.ComponentType<{
+            className?: string;
+        }>;
+        bars: React__default.ComponentType<{
+            className?: string;
+        }>;
+    };
+    collapseSidebarLabel: string;
+    expandSidebarLabel: string;
+}
+/**
+ * Simple navigation component for Admin and Moderation modes.
+ * Renders a section header with optional dropdown and static navigation tabs.
+ *
+ * @emits shell:sidebar-toggle - Toggle sidebar collapsed/expanded state. Payload: undefined
+ */
+declare function SimpleNavigation({ title, items, currentPath, LinkComponent, dropdownContent, isCollapsed, icons, collapseSidebarLabel, expandSidebarLabel }: SimpleNavigationProps$1): React__default.JSX.Element;
+
+/**
+ * Props for the sortable resource tab component
+ */
+interface SortableResourceTabProps {
+    resource: OpenResource;
+    isCollapsed: boolean;
+    isActive: boolean;
+    href: string;
+    onClose: (id: string, e: React.MouseEvent) => void;
+    onReorder?: (resourceId: string, direction: 'up' | 'down') => void;
+    index?: number;
+    totalCount?: number;
+    LinkComponent: ComponentType<any>;
+    dragHandleProps?: any;
+    isDragging?: boolean;
+    translations: {
+        dragToReorder?: string;
+        dragToReorderDoc?: string;
+        closeResource?: string;
+        moveUp?: string;
+        moveDown?: string;
+    };
+}
+/**
+ * Props for the collapsible resource navigation component
+ */
+interface CollapsibleResourceNavigationProps {
+    fixedItems: Array<{
+        name: string;
+        href: string;
+        icon: ComponentType<any>;
+        description?: string;
+    }>;
+    resources: OpenResource[];
+    isCollapsed: boolean;
+    currentPath: string;
+    LinkComponent: ComponentType<any>;
+    onNavigate?: (path: string) => void;
+    getResourceHref: (resourceId: string) => string;
+    className?: string;
+    translations: {
+        title?: string;
+        collapseSidebar?: string;
+        expandSidebar?: string;
+        dragToReorder?: string;
+        dragToReorderDoc?: string;
+        closeResource?: string;
+        dragInstructions?: string;
+    };
+    icons: {
+        chevronLeft: ComponentType<any>;
+        bars: ComponentType<any>;
+        close: ComponentType<any>;
+    };
+    navigationMenu?: ((onClose: () => void) => ReactNode) | undefined;
+}
+
+/**
+ * A comprehensive collapsible navigation component with fixed items and dynamic resource tabs.
+ * Supports drag and drop for resource reordering when expanded.
+ * Platform-agnostic design for use across different React environments.
+ *
+ * @emits tabs:reorder - Resource tab reordered. Payload: { oldIndex: number, newIndex: number }
+ * @emits tabs:close - Resource tab closed. Payload: { resourceId: string }
+ * @emits shell:sidebar-toggle - Toggle sidebar collapsed/expanded state. Payload: undefined
+ */
+declare function CollapsibleResourceNavigation({ fixedItems, resources, isCollapsed, currentPath, LinkComponent, onNavigate, getResourceHref, className, translations, icons, navigationMenu }: CollapsibleResourceNavigationProps): React__default.JSX.Element;
+
+/**
+ * A sortable tab for an open resource in the navigation sidebar.
+ * Supports drag and drop when expanded, and compact icon-only view when collapsed.
+ */
+declare function SortableResourceTab({ resource, isCollapsed, isActive, href, onClose, onReorder, index, totalCount, LinkComponent, translations, isDragging }: SortableResourceTabProps): React__default.JSX.Element;
+
+interface SimpleNavigationItem {
+    name: string;
+    href: string;
+    icon: React.ComponentType<any>;
+    description?: string;
+}
+interface SimpleNavigationProps {
+    title: string;
+    items: SimpleNavigationItem[];
+    currentPath: string;
+    LinkComponent: React.ComponentType<any>;
+    dropdownContent?: ((onClose: () => void) => ReactNode) | undefined;
+}
+
+interface GenerationConfig {
+    title: string;
+    storagePath: string;
+    prompt?: string;
+    language: string;
+    temperature: number;
+    maxTokens: number;
+    context: GatheredContext;
+}
+
+interface ReferenceWizardModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    /** The annotation being resolved */
+    annotationId: string | null;
+    /** The resource containing the annotation */
+    resourceId: string | null;
+    /** Default title (selected text) */
+    defaultTitle: string;
+    /** Entity types from the annotation */
+    entityTypes: string[];
+    /** Current locale for generation defaults */
+    locale: string;
+    /** Gathered context state */
+    context: GatheredContext | null;
+    contextLoading: boolean;
+    contextError: Error | null;
+    /** Callbacks */
+    onGenerateSubmit: (referenceId: string, config: GenerationConfig) => void;
+    onLinkResource: (referenceId: string, targetResourceId: string) => void;
+    onComposeNavigate: (context: GatheredContext, annotationId: string, resourceId: string, title: string, entityTypes: string[]) => void;
+    /** Translation strings */
+    translations: {
+        gatherTitle: string;
+        configureGenerationTitle: string;
+        configureSearchTitle: string;
+        searchResultsTitle: string;
+        sourceContextLabel: string;
+        connectionsLabel: string;
+        citedByLabel: string;
+        userHintLabel: string;
+        userHintPlaceholder: string;
+        loadingContext: string;
+        failedContext: string;
+        cancel: string;
+        search: string;
+        searching: string;
+        generate: string;
+        compose: string;
+        resolutionStrategyLabel: string;
+        back: string;
+        link: string;
+        score: string;
+        noResults: string;
+        resourceTitle: string;
+        resourceTitlePlaceholder: string;
+        additionalInstructions: string;
+        additionalInstructionsPlaceholder: string;
+        language: string;
+        languageHelp: string;
+        creativity: string;
+        creativityFocused: string;
+        creativityCreative: string;
+        maxLength: string;
+        maxLengthHelp: string;
+        maxResults: string;
+        semanticScoring: string;
+        semanticScoringHelp: string;
+    };
+}
+declare function ReferenceWizardModal({ isOpen, onClose, annotationId, resourceId, defaultTitle, entityTypes, locale, context, contextLoading, contextError, onGenerateSubmit, onLinkResource, onComposeNavigate, translations: t, }: ReferenceWizardModalProps): React$1.JSX.Element;
+
+interface SearchModalProps$1 {
+    isOpen: boolean;
+    onClose: () => void;
+    onNavigate: (type: 'resource' | 'entity', id: string) => void;
+    translations?: {
+        placeholder?: string;
+        searching?: string;
+        noResults?: string;
+        startTyping?: string;
+        navigate?: string;
+        select?: string;
+        close?: string;
+        enter?: string;
+        esc?: string;
+    };
+}
+declare function SearchModal({ isOpen, onClose, onNavigate, translations }: SearchModalProps$1): React__default.JSX.Element;
+
+interface ResourceSearchModalProps$1 {
+    isOpen: boolean;
+    onClose: () => void;
+    onSelect: (resourceId: string) => void;
+    searchTerm?: string;
+    translations?: {
+        title?: string;
+        placeholder?: string;
+        searching?: string;
+        noResults?: string;
+        close?: string;
+    };
+}
+declare function ResourceSearchModal({ isOpen, onClose, onSelect, searchTerm, translations }: ResourceSearchModalProps$1): React$1.JSX.Element;
+
+/**
+ * Base modal props that all modals share
+ */
+interface BaseModalProps {
+    /** Whether the modal is open */
+    isOpen: boolean;
+    /** Callback when the modal should close */
+    onClose: () => void;
+    /** Optional CSS class name */
+    className?: string;
+}
+/**
+ * Props for modals that navigate
+ */
+interface NavigableModalProps {
+    /** Navigation function */
+    onNavigate: (path: string) => void;
+}
+/**
+ * Search modal specific props
+ */
+interface SearchModalProps extends BaseModalProps, NavigableModalProps {
+    /** Optional translation support */
+    translations?: {
+        placeholder?: string;
+        searching?: string;
+        noResults?: string;
+        startTyping?: string;
+        navigate?: string;
+        select?: string;
+        close?: string;
+    };
+}
+/**
+ * Resource search modal props
+ */
+interface ResourceSearchModalProps extends BaseModalProps {
+    /** Callback when a resource is selected */
+    onSelect: (resourceId: string) => void;
+    /** Initial search term */
+    searchTerm?: string;
+    /** Optional translation support */
+    translations?: {
+        title?: string;
+        placeholder?: string;
+        searching?: string;
+        noResults?: string;
+    };
+}
+
+/**
+ * Skip links for keyboard navigation accessibility
+ * These links are visually hidden but become visible when focused
+ * They allow keyboard users to quickly jump to main content areas
+ */
+declare function SkipLinks(): React$1.JSX.Element;
+
+interface StatusDisplayProps {
+    isFullyAuthenticated?: boolean;
+    isAuthenticated?: boolean;
+    hasValidBackendToken?: boolean;
+}
+declare function StatusDisplay({ isFullyAuthenticated, isAuthenticated, hasValidBackendToken }: StatusDisplayProps): React$1.JSX.Element;
+
+declare function SessionTimer(): React$1.JSX.Element | null;
+
+declare function SessionExpiryBanner(): React$1.JSX.Element | null;
+
+declare function UserMenuSkeleton(): React$1.JSX.Element;
+
+type TranslateFn$1 = (key: string) => string;
+interface SemiontBrandingProps {
+    t: TranslateFn$1;
+    className?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    showTagline?: boolean;
+    animated?: boolean;
+    compactTagline?: boolean;
+}
+declare function SemiontBranding({ t, className, size, showTagline, animated, compactTagline }: SemiontBrandingProps): React$1.JSX.Element;
+
+/**
+ * Translation function type for framework-agnostic components
+ */
+type TranslateFn = (key: string, params?: Record<string, any>) => string;
+
+interface UnifiedHeaderProps {
+    Link: React__default.ComponentType<LinkComponentProps>;
+    routes: RouteBuilder;
+    t: TranslateFn;
+    tHome: TranslateFn;
+    showBranding?: boolean;
+    showAuthLinks?: boolean;
+    brandingLink?: string;
+    variant?: 'standalone' | 'embedded' | 'floating';
+    isAuthenticated?: boolean;
+    isAdmin?: boolean;
+    isModerator?: boolean;
+    currentPath?: string;
+}
+declare function UnifiedHeader({ Link, routes, t, tHome, showBranding, brandingLink, variant, isAuthenticated, isAdmin, isModerator, currentPath }: UnifiedHeaderProps): React__default.JSX.Element;
+
+interface NavigationMenuHelper {
+    (onClose: () => void): React__default.ReactNode;
+}
+interface LeftSidebarProps {
+    Link: React__default.ComponentType<LinkComponentProps>;
+    routes: RouteBuilder;
+    t: TranslateFn;
+    tHome: TranslateFn;
+    children: React__default.ReactNode | ((isCollapsed: boolean, toggleCollapsed: () => void, navigationMenu: NavigationMenuHelper) => React__default.ReactNode);
+    brandingLink?: string;
+    collapsible?: boolean;
+    storageKey?: string;
+    isAuthenticated?: boolean;
+    isAdmin?: boolean;
+    isModerator?: boolean;
+    currentPath?: string;
+}
+declare function LeftSidebar({ Link, routes, t, tHome, children, brandingLink, collapsible, storageKey, isAdmin, isModerator, currentPath }: LeftSidebarProps): React__default.JSX.Element;
+
+interface PageLayoutProps {
+    Link: React__default.ComponentType<LinkComponentProps>;
+    routes: RouteBuilder;
+    t: TranslateFn;
+    tNav: TranslateFn;
+    tHome: TranslateFn;
+    children: React__default.ReactNode;
+    className?: string;
+    showAuthLinks?: boolean;
+    CookiePreferences?: React__default.ComponentType<{
+        isOpen: boolean;
+        onClose: () => void;
+    }>;
+    onOpenKeyboardHelp?: () => void;
+}
+declare function PageLayout({ Link, routes, t, tNav, tHome, children, className, showAuthLinks, CookiePreferences, onOpenKeyboardHelp }: PageLayoutProps): React__default.JSX.Element;
+
+interface SemiontFaviconProps {
+    size?: number;
+    className?: string;
+    variant?: 'gradient' | 'solid' | 'outline';
+    background?: boolean;
+}
+declare function SemiontFavicon({ size, className, variant, background }: SemiontFaviconProps): React$1.JSX.Element;
+
+declare const faviconPaths: {
+    readonly ico: "/favicons/favicon.ico";
+    readonly svg: "/favicons/favicon.svg";
+    readonly appleTouchIcon: "/favicons/apple-touch-icon.png";
+    readonly favicon32: "/favicons/favicon-32x32.png";
+    readonly favicon16: "/favicons/favicon-16x16.png";
+    readonly androidChrome192: "/favicons/android-chrome-192x192.png";
+    readonly androidChrome512: "/favicons/android-chrome-512x512.png";
+    readonly manifest: "/favicons/site.webmanifest";
+};
+
+/**
+ * CSS-Agnostic Button Component
+ *
+ * This button uses data attributes instead of hardcoded Tailwind classes,
+ * allowing users to style it with any CSS solution.
+ */
+
+interface ButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Ref forwarded to the underlying button element
+     */
+    ref?: React__default.Ref<HTMLButtonElement>;
+    /**
+     * The visual variant of the button
+     */
+    variant?: 'primary' | 'secondary' | 'tertiary' | 'danger' | 'warning' | 'ghost';
+    /**
+     * The size of the button
+     */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /**
+     * Whether the button should take full width of its container
+     */
+    fullWidth?: boolean;
+    /**
+     * Whether the button is in a loading state
+     */
+    loading?: boolean;
+    /**
+     * Icon to display before the button text
+     */
+    leftIcon?: React__default.ReactNode;
+    /**
+     * Icon to display after the button text
+     */
+    rightIcon?: React__default.ReactNode;
+    /**
+     * Whether the button should only show an icon (no text padding)
+     */
+    iconOnly?: boolean;
+    /**
+     * Whether to show the button in an active/pressed state
+     */
+    active?: boolean;
+}
+declare function Button({ variant, size, fullWidth, loading, leftIcon, rightIcon, iconOnly, active, className, disabled, children, type, ref, ...props }: ButtonProps): React__default.JSX.Element;
+/**
+ * Button Group Component
+ *
+ * Groups multiple buttons together
+ */
+interface ButtonGroupProps {
+    children: React__default.ReactNode;
+    /**
+     * How to arrange the buttons
+     */
+    orientation?: 'horizontal' | 'vertical';
+    /**
+     * Whether buttons should be connected (no gap between them)
+     */
+    attached?: boolean;
+    /**
+     * Size of the gap between buttons (when not attached)
+     */
+    spacing?: 'xs' | 'sm' | 'md' | 'lg';
+    className?: string;
+}
+declare const ButtonGroup: React__default.FC<ButtonGroupProps>;
+
+/**
+ * Semiont Design Tokens
+ *
+ * Core design tokens for the Semiont design system.
+ * These tokens provide the foundation for all component styling
+ * and can be consumed via JavaScript or CSS variables.
+ */
+declare const tokens: {
+    colors: {
+        primary: {
+            50: string;
+            100: string;
+            200: string;
+            300: string;
+            400: string;
+            500: string;
+            600: string;
+            700: string;
+            800: string;
+            900: string;
+        };
+        secondary: {
+            50: string;
+            100: string;
+            200: string;
+            300: string;
+            400: string;
+            500: string;
+            600: string;
+            700: string;
+            800: string;
+            900: string;
+        };
+        semantic: {
+            error: string;
+            errorLight: string;
+            errorDark: string;
+            warning: string;
+            warningLight: string;
+            warningDark: string;
+            success: string;
+            successLight: string;
+            successDark: string;
+            info: string;
+            infoLight: string;
+            infoDark: string;
+        };
+        neutral: {
+            0: string;
+            50: string;
+            100: string;
+            200: string;
+            300: string;
+            400: string;
+            500: string;
+            600: string;
+            700: string;
+            800: string;
+            900: string;
+            950: string;
+            1000: string;
+        };
+        background: {
+            primary: string;
+            secondary: string;
+            tertiary: string;
+            inverse: string;
+        };
+        text: {
+            primary: string;
+            secondary: string;
+            tertiary: string;
+            disabled: string;
+            inverse: string;
+        };
+    };
+    spacing: {
+        0: string;
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        '2xl': string;
+        '3xl': string;
+        '4xl': string;
+        '5xl': string;
+    };
+    typography: {
+        fontFamily: {
+            sans: string;
+            mono: string;
+        };
+        fontSize: {
+            xs: string;
+            sm: string;
+            base: string;
+            lg: string;
+            xl: string;
+            '2xl': string;
+            '3xl': string;
+            '4xl': string;
+            '5xl': string;
+        };
+        fontWeight: {
+            thin: number;
+            light: number;
+            normal: number;
+            medium: number;
+            semibold: number;
+            bold: number;
+            black: number;
+        };
+        lineHeight: {
+            none: number;
+            tight: number;
+            snug: number;
+            normal: number;
+            relaxed: number;
+            loose: number;
+        };
+    };
+    borderRadius: {
+        none: string;
+        sm: string;
+        base: string;
+        md: string;
+        lg: string;
+        xl: string;
+        '2xl': string;
+        '3xl': string;
+        full: string;
+    };
+    shadows: {
+        none: string;
+        xs: string;
+        sm: string;
+        base: string;
+        md: string;
+        lg: string;
+        xl: string;
+        inner: string;
+    };
+    transitions: {
+        duration: {
+            fast: string;
+            base: string;
+            slow: string;
+            slower: string;
+        };
+        timing: {
+            linear: string;
+            ease: string;
+            easeIn: string;
+            easeOut: string;
+            easeInOut: string;
+        };
+    };
+    breakpoints: {
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        '2xl': string;
+    };
+};
+/**
+ * Generate CSS custom properties from design tokens
+ */
+declare function generateCSSVariables(): string;
+declare const cssVariables: string;
+type ColorToken = keyof typeof tokens.colors;
+type SpacingToken = keyof typeof tokens.spacing;
+type TypographyToken = keyof typeof tokens.typography;
+type BorderRadiusToken = keyof typeof tokens.borderRadius;
+type ShadowToken = keyof typeof tokens.shadows;
+type TransitionToken = keyof typeof tokens.transitions;
+
+/**
+ * ComposeLoadingState Component
+ *
+ * Simple loading state display for the compose page.
+ */
+interface ComposeLoadingStateProps {
+    message: string;
+}
+declare function ComposeLoadingState({ message }: ComposeLoadingStateProps): React$1.JSX.Element;
+
+/**
+ * ResourceLoadingState - Loading state component for resource viewer
+ *
+ * Pure React component - no Next.js dependencies.
+ */
+declare function ResourceLoadingState(): React$1.JSX.Element;
+
+/**
+ * ResourceErrorState - Error state component for resource viewer
+ *
+ * Pure React component - no Next.js dependencies.
+ */
+interface ResourceErrorStateProps {
+    error: unknown;
+    onRetry: () => void;
+}
+declare function ResourceErrorState({ error, onRetry }: ResourceErrorStateProps): React$1.JSX.Element;
+
+/**
+ * AdminDevOpsPage Component
+ *
+ * Pure React component for the admin devops page.
+ * All dependencies passed as props - no Next.js hooks!
+ */
+
+interface DevOpsFeature {
+    title: string;
+    description: string;
+    icon: React__default.ComponentType<any>;
+    available: string;
+}
+interface AdminDevOpsPageProps {
+    suggestedFeatures: DevOpsFeature[];
+    theme: 'light' | 'dark' | 'system';
+    showLineNumbers: boolean;
+    activePanel: string | null;
+    translations: {
+        title: string;
+        subtitle: string;
+        systemStatus: string;
+        cliOperations: string;
+        cliOperationsDescription: string;
+        cliTitle: string;
+        cliDescription: string;
+    };
+    StatusDisplay: React__default.ComponentType<any>;
+    ToolbarPanels: React__default.ComponentType<any>;
+    Toolbar: React__default.ComponentType<any>;
+}
+declare function AdminDevOpsPage({ suggestedFeatures, theme, showLineNumbers, activePanel, translations: t, StatusDisplay, ToolbarPanels, Toolbar, }: AdminDevOpsPageProps): React__default.JSX.Element;
+
+/**
+ * ExportCard — Backup trigger
+ *
+ * Pure React component. All state and handlers passed as props.
+ */
+interface ExportCardTranslations {
+    title: string;
+    description: string;
+    exportButton: string;
+    exporting: string;
+}
+interface ExportCardProps {
+    onExport: () => void;
+    isExporting: boolean;
+    translations: ExportCardTranslations;
+}
+declare function ExportCard({ onExport, isExporting, translations: t }: ExportCardProps): React$1.JSX.Element;
+
+/**
+ * ShellStateUnit — app-shell state: which toolbar panel is open, tab-bar
+ * coordination helpers, scroll-to-annotation signals. Lives on
+ * `SemiontBrowser`'s app-scoped bus (not the per-session client bus)
+ * because panel toggles and shell chrome must work regardless of
+ * whether a KB session is active.
+ *
+ * Channels: `panel:toggle`, `panel:open`, `panel:close`.
+ */
+
+type ToolbarPanelType = 'history' | 'info' | 'annotations' | 'settings' | 'collaboration' | 'user' | 'jsonld' | 'knowledge-base';
+declare const COMMON_PANELS: readonly ToolbarPanelType[];
+declare const RESOURCE_PANELS: readonly ToolbarPanelType[];
+interface ShellStateUnit extends StateUnit {
+    activePanel$: Observable<ToolbarPanelType | null>;
+    scrollToAnnotationId$: Observable<string | null>;
+    panelInitialTab$: Observable<{
+        tab: string;
+        generation: number;
+    } | null>;
+    openPanel(panel: string): void;
+    closePanel(): void;
+    togglePanel(panel: string): void;
+    onScrollCompleted(): void;
+}
+interface ShellStateUnitOptions {
+    initialPanel?: ToolbarPanelType | null;
+    onPanelChange?: (panel: ToolbarPanelType | null) => void;
+}
+declare function createShellStateUnit(browser: SemiontBrowser, options?: ShellStateUnitOptions): ShellStateUnit;
+
+interface ImportPreview {
+    format: string;
+    version: number;
+    sourceUrl: string;
+    stats: Record<string, number>;
+}
+interface ExchangeStateUnit extends StateUnit {
+    browse: ShellStateUnit;
+    selectedFile$: Observable<File | null>;
+    preview$: Observable<ImportPreview | null>;
+    importPhase$: Observable<string | null>;
+    importMessage$: Observable<string | undefined>;
+    importResult$: Observable<Record<string, unknown> | undefined>;
+    isExporting$: Observable<boolean>;
+    isImporting$: Observable<boolean>;
+    selectFile(file: File): void;
+    cancelImport(): void;
+    doExport(): Promise<{
+        blob: Blob;
+        filename: string;
+    }>;
+    doImport(): Promise<void>;
+}
+declare function createExchangeStateUnit(browse: ShellStateUnit, exportFn: (params?: {
+    includeArchived?: boolean;
+}) => Promise<BackendDownload>, importFn: (file: File) => Observable<ProgressEvent>): ExchangeStateUnit;
+
+/**
+ * ImportCard — File drop zone, preview, and import trigger
+ *
+ * Pure React component. All state and handlers passed as props.
+ */
+
+interface ImportCardTranslations {
+    title: string;
+    description: string;
+    dropzoneLabel: string;
+    dropzoneActive: string;
+    detectedFormat: string;
+    statsPreview: string;
+    importButton: string;
+    importing: string;
+    importConfirmTitle: string;
+    importConfirmMessage: string;
+    confirmImport: string;
+    cancelImport: string;
+}
+interface ImportCardProps {
+    onFileSelected: (file: File) => void;
+    onImport: () => void;
+    onCancel: () => void;
+    selectedFile: File | null;
+    preview: ImportPreview | null;
+    isImporting: boolean;
+    translations: ImportCardTranslations;
+}
+declare function ImportCard({ onFileSelected, onImport, onCancel, selectedFile, preview, isImporting, translations: t, }: ImportCardProps): React__default.JSX.Element;
+
+/**
+ * ImportProgress — Shows SSE-driven progress during restore
+ *
+ * Pure React component. All state passed as props.
+ */
+interface ImportProgressTranslations {
+    phaseStarted: string;
+    phaseEntityTypes: string;
+    phaseResources: string;
+    phaseAnnotations: string;
+    phaseComplete: string;
+    phaseError: string;
+    hashChainValid: string;
+    hashChainInvalid: string;
+    streams: string;
+    events: string;
+    blobs: string;
+}
+interface ImportProgressProps {
+    phase: string;
+    message?: string;
+    result?: Record<string, unknown>;
+    translations: ImportProgressTranslations;
+}
+declare function ImportProgress({ phase, message, result, translations: t }: ImportProgressProps): React$1.JSX.Element;
+
+/**
+ * AdminExchangePage — Backup/Restore admin page
+ *
+ * Pure React component. All state and handlers passed as props.
+ */
+
+interface AdminExchangePageTranslations {
+    title: string;
+    subtitle: string;
+    export: ExportCardTranslations;
+    import: ImportCardTranslations;
+    progress: ImportProgressTranslations;
+}
+interface AdminExchangePageProps {
+    onExport: () => void;
+    isExporting: boolean;
+    onFileSelected: (file: File) => void;
+    onImport: () => void;
+    onCancelImport: () => void;
+    selectedFile: File | null;
+    preview: ImportCardProps['preview'];
+    isImporting: boolean;
+    importPhase: string | null;
+    importMessage?: string | undefined;
+    importResult?: Record<string, unknown> | undefined;
+    theme: 'light' | 'dark' | 'system';
+    showLineNumbers: boolean;
+    activePanel: string | null;
+    translations: AdminExchangePageTranslations;
+    ToolbarPanels: React__default.ComponentType<any>;
+    Toolbar: React__default.ComponentType<any>;
+}
+declare function AdminExchangePage({ onExport, isExporting, onFileSelected, onImport, onCancelImport, selectedFile, preview, isImporting, importPhase, importMessage, importResult, theme, showLineNumbers, activePanel, translations: t, ToolbarPanels, Toolbar, }: AdminExchangePageProps): React__default.JSX.Element;
+
+/**
+ * AdminSecurityPage Component
+ *
+ * Pure React component for the admin security configuration page.
+ * All dependencies passed as props - no Next.js hooks!
+ */
+
+interface OAuthProvider {
+    name: string;
+    clientId?: string;
+}
+interface AdminSecurityPageProps {
+    providers: OAuthProvider[];
+    allowedDomains: string[];
+    isLoading: boolean;
+    theme: 'light' | 'dark' | 'system';
+    showLineNumbers: boolean;
+    activePanel: string | null;
+    translations: {
+        title: string;
+        subtitle: string;
+        oauthProviders: string;
+        oauthProvidersDescription: string;
+        clientId: string;
+        configured: string;
+        noProvidersConfigured: string;
+        allowedDomains: string;
+        allowedDomainsDescription: string;
+        noDomainsConfigured: string;
+        configManagementTitle: string;
+        configManagementDescription: string;
+        configLocalDev: string;
+        configCloudDeploy: string;
+        configCloudDeployCommand: string;
+        configCloudDeployEnd: string;
+        configAWS: string;
+    };
+    ToolbarPanels: React__default.ComponentType<any>;
+    Toolbar: React__default.ComponentType<any>;
+}
+declare function AdminSecurityPage({ providers, allowedDomains, isLoading, theme, showLineNumbers, activePanel, translations: t, ToolbarPanels, Toolbar, }: AdminSecurityPageProps): React__default.JSX.Element;
+
+/**
+ * LinkedDataPage — JSON-LD Export/Import moderation page
+ *
+ * Pure React component. All state and handlers passed as props.
+ * Reuses ExportCard, ImportCard, and ImportProgress from admin-exchange.
+ */
+
+interface LinkedDataPageTranslations {
+    title: string;
+    subtitle: string;
+    export: ExportCardTranslations;
+    import: ImportCardTranslations;
+    progress: ImportProgressTranslations;
+}
+interface LinkedDataPageProps {
+    onExport: () => void;
+    isExporting: boolean;
+    onFileSelected: (file: File) => void;
+    onImport: () => void;
+    onCancelImport: () => void;
+    selectedFile: File | null;
+    preview: ImportCardProps['preview'];
+    isImporting: boolean;
+    importPhase: string | null;
+    importMessage?: string | undefined;
+    importResult?: Record<string, unknown> | undefined;
+    theme: 'light' | 'dark' | 'system';
+    showLineNumbers: boolean;
+    activePanel: string | null;
+    translations: LinkedDataPageTranslations;
+    ToolbarPanels: React__default.ComponentType<any>;
+    Toolbar: React__default.ComponentType<any>;
+}
+declare function LinkedDataPage({ onExport, isExporting, onFileSelected, onImport, onCancelImport, selectedFile, preview, isImporting, importPhase, importMessage, importResult, theme, showLineNumbers, activePanel, translations: t, ToolbarPanels, Toolbar, }: LinkedDataPageProps): React__default.JSX.Element;
+
+/**
+ * AdminUsersPage Component
+ *
+ * Pure React component for the admin users management page.
+ * All dependencies passed as props - no Next.js hooks!
+ */
+
+interface AdminUser {
+    id: string;
+    email: string;
+    name?: string | null;
+    domain: string;
+    isAdmin: boolean;
+    isActive: boolean;
+    lastLogin?: string | null;
+    created: string;
+}
+interface AdminUserStats {
+    totalUsers: number;
+    activeUsers: number;
+    adminUsers: number;
+    recentSignups: string[];
+}
+interface AdminUsersPageProps {
+    users: AdminUser[];
+    userStats: AdminUserStats | null;
+    isLoadingUsers: boolean;
+    isLoadingStats: boolean;
+    onUpdateUser: (id: string, data: {
+        isAdmin?: boolean;
+        isActive?: boolean;
+    }) => void;
+    onDeleteUser: (id: string) => void;
+    onAddUser: () => void;
+    onExportUsers: () => void;
+    theme: 'light' | 'dark' | 'system';
+    showLineNumbers: boolean;
+    activePanel: string | null;
+    translations: {
+        title: string;
+        subtitle: string;
+        addUser: string;
+        totalUsers: string;
+        activeUsers: string;
+        administrators: string;
+        recentUsers: string;
+        searchUsers: string;
+        searchPlaceholder: string;
+        role: string;
+        allRoles: string;
+        admin: string;
+        user: string;
+        status: string;
+        allStatus: string;
+        active: string;
+        inactive: string;
+        exportUsers: string;
+        loadingUsers: string;
+        userColumn: string;
+        domainColumn: string;
+        roleColumn: string;
+        statusColumn: string;
+        lastLoginColumn: string;
+        joinedColumn: string;
+        actionsColumn: string;
+        noUsersFound: string;
+        noUsersFoundDescription: string;
+        noName: string;
+        never: string;
+        removeAdmin: string;
+        makeAdmin: string;
+        deactivateUser: string;
+        activateUser: string;
+        deleteUser: string;
+    };
+    ToolbarPanels: React__default.ComponentType<any>;
+    Toolbar: React__default.ComponentType<any>;
+    buttonStyles: {
+        primary: {
+            base: string;
+        };
+        secondary: {
+            base: string;
+        };
+    };
+}
+declare function AdminUsersPage({ users, userStats, isLoadingUsers, isLoadingStats, onUpdateUser, onDeleteUser, onAddUser, onExportUsers, theme, showLineNumbers, activePanel, translations: t, ToolbarPanels, Toolbar, buttonStyles, }: AdminUsersPageProps): React__default.JSX.Element;
+
+/**
+ * SignInForm - Pure React component for authentication
+ *
+ * Supports both Google OAuth and email/password credentials.
+ * No Next.js dependencies - all data via props.
+ *
+ * When backendUrl is provided it is shown as a locked read-only field.
+ * When backendUrl is omitted the user must enter a backend URL to connect to.
+ */
+
+interface SignInFormProps {
+    /**
+     * Callback when user clicks Google sign-in.
+     * Receives the backend URL (either the locked one or what the user typed).
+     */
+    onGoogleSignIn: (backendUrl: string) => Promise<void>;
+    /**
+     * Callback when user submits email/password credentials.
+     * Receives the backend URL along with email and password.
+     */
+    onCredentialsSignIn?: ((backendUrl: string, email: string, password: string) => Promise<void>) | undefined;
+    /**
+     * Pre-filled backend URL. When provided the field is read-only (re-auth to known workspace).
+     * When omitted the user enters the URL themselves (new connection).
+     */
+    backendUrl?: string;
+    /**
+     * Error message to display (if any)
+     */
+    error?: string | null;
+    /**
+     * Whether to show email/password auth form
+     */
+    showCredentialsAuth?: boolean;
+    /**
+     * Whether the auth providers are still loading
+     */
+    isLoading?: boolean;
+    /**
+     * Link component for routing - passed from parent
+     */
+    Link: React__default.ComponentType<any>;
+    /**
+     * Translation strings
+     */
+    translations: {
+        pageTitle: string;
+        welcomeBack: string;
+        signInPrompt: string;
+        continueWithGoogle: string;
+        backendUrlLabel: string;
+        backendUrlPlaceholder: string;
+        emailLabel: string;
+        emailPlaceholder: string;
+        passwordLabel: string;
+        passwordPlaceholder: string;
+        signInWithCredentials: string;
+        or: string;
+        credentialsAuthEnabled: string;
+        approvedDomainsOnly: string;
+        backToHome: string;
+        learnMore: string;
+        signUpInstead: string;
+        errorBackendUrlRequired: string;
+        errorBackendUrlInvalid: string;
+        errorBackendUrlUnreachable: string;
+        errorEmailRequired: string;
+        errorPasswordRequired: string;
+        tagline: string;
+    };
+}
+/**
+ * SignInForm - Main sign-in / connect component.
+ *
+ * When backendUrl is provided (re-auth to known workspace) the URL field is locked.
+ * When backendUrl is omitted (new connection) the user enters the URL themselves.
+ */
+declare function SignInForm({ onGoogleSignIn, onCredentialsSignIn, backendUrl, error, showCredentialsAuth, isLoading, translations: t, }: SignInFormProps): React__default.JSX.Element;
+
+/**
+ * SignUpForm - Pure React component for Google OAuth sign-up
+ *
+ * This component is extracted from the page to enable easy testing.
+ * It has no Next.js dependencies and receives all data via props.
+ */
+
+interface SignUpFormProps {
+    /**
+     * Link component for routing - passed from parent
+     */
+    Link: React__default.ComponentType<any>;
+    /**
+     * Callback when user clicks the Google sign-up button
+     */
+    onSignUp: () => Promise<void>;
+    /**
+     * Translation strings for the form
+     */
+    translations: {
+        pageTitle: string;
+        signUpPrompt: string;
+        signUpWithGoogle: string;
+        creatingAccount: string;
+        approvedDomainsInfo: string;
+        termsAgreement: string;
+        alreadyHaveAccount: string;
+        tagline: string;
+        backToHome: string;
+    };
+}
+/**
+ * SignUpForm component
+ *
+ * Renders the sign-up form with Google OAuth button.
+ * Manages loading state internally.
+ */
+declare function SignUpForm({ onSignUp, Link, translations: t }: SignUpFormProps): React__default.JSX.Element;
+
+/**
+ * AuthErrorDisplay - Pure React component for displaying authentication errors
+ *
+ * No Next.js dependencies - receives error type and translations via props.
+ */
+
+interface AuthErrorDisplayProps {
+    /**
+     * Link component for routing - passed from parent
+     */
+    Link: React__default.ComponentType<any>;
+    /**
+     * Error type from URL parameter
+     */
+    errorType: string | null;
+    /**
+     * Translation strings
+     */
+    translations: {
+        pageTitle: string;
+        tryAgain: string;
+        errorConfiguration: string;
+        errorAccessDenied: string;
+        errorVerification: string;
+        errorGeneric: string;
+    };
+}
+/**
+ * AuthErrorDisplay component
+ *
+ * Displays authentication error messages with a link to try again.
+ */
+declare function AuthErrorDisplay({ errorType, Link, translations: t }: AuthErrorDisplayProps): React__default.JSX.Element;
+
+/**
+ * WelcomePage Component
+ *
+ * Pure React component for the welcome/terms acceptance page.
+ * All dependencies passed as props - no Next.js hooks!
+ */
+
+interface WelcomePageProps {
+    userName?: string;
+    termsAcceptedAt?: string | null;
+    isNewUser?: boolean;
+    status: 'loading' | 'accepted' | 'form';
+    isProcessing: boolean;
+    onAccept: () => void;
+    onDecline: () => void;
+    translations: {
+        loading: string;
+        welcomeTitle: string;
+        thanksForAccepting: string;
+        welcomeUser: string;
+        reviewTermsPrompt: string;
+        termsSummaryTitle: string;
+        termsSummaryIntro: string;
+        acceptableUseTitle: string;
+        acceptableUseResponsible: string;
+        acceptableUseRespect: string;
+        acceptableUseConduct: string;
+        prohibitedContentTitle: string;
+        prohibitedContentIntro: string;
+        prohibitedIllegal: string;
+        prohibitedAdult: string;
+        prohibitedHate: string;
+        prohibitedViolence: string;
+        prohibitedMisinformation: string;
+        prohibitedPrivacy: string;
+        prohibitedCopyright: string;
+        prohibitedMalware: string;
+        prohibitedSpam: string;
+        conductTitle: string;
+        conductDescription: string;
+        conductLink: string;
+        conductPromotion: string;
+        responsibilitiesTitle: string;
+        responsibilitiesSecure: string;
+        responsibilitiesReport: string;
+        responsibilitiesAccurate: string;
+        responsibilitiesComply: string;
+        violationsWarning: string;
+        readFullTerms: string;
+        termsOfService: string;
+        and: string;
+        privacyPolicy: string;
+        declineAndSignOut: string;
+        acceptAndContinue: string;
+        processing: string;
+        legallyBound: string;
+    };
+    PageLayout: React__default.ComponentType<any>;
+    Link: React__default.ComponentType<any>;
+}
+declare function WelcomePage({ userName, status, isProcessing, onAccept, onDecline, translations: t, PageLayout, Link, }: WelcomePageProps): React__default.JSX.Element;
+
+/**
+ * EntityTagsPage Component
+ *
+ * Pure React component for managing entity tags.
+ * All dependencies passed as props - no Next.js hooks!
+ */
+
+interface EntityTagsPageProps {
+    entityTypes: string[];
+    isLoading: boolean;
+    error: string;
+    newTag: string;
+    onNewTagChange: (value: string) => void;
+    onAddTag: () => void;
+    isAddingTag: boolean;
+    theme: 'light' | 'dark' | 'system';
+    showLineNumbers: boolean;
+    activePanel: string | null;
+    translations: {
+        pageTitle: string;
+        pageDescription: string;
+        sectionTitle: string;
+        sectionDescription: string;
+        inputPlaceholder: string;
+        addTag: string;
+        adding: string;
+    };
+    ToolbarPanels: React__default.ComponentType<any>;
+    Toolbar: React__default.ComponentType<any>;
+}
+declare function EntityTagsPage({ entityTypes, error, newTag, onNewTagChange, onAddTag, isAddingTag, theme, showLineNumbers, activePanel, translations: t, ToolbarPanels, Toolbar, }: EntityTagsPageProps): React__default.JSX.Element;
+
+/**
+ * RecentDocumentsPage Component
+ *
+ * Pure React component for viewing recent documents.
+ * All dependencies passed as props - no Next.js hooks!
+ */
+
+interface RecentDocumentsPageProps {
+    hasDocuments: boolean;
+    isLoading: boolean;
+    theme: 'light' | 'dark' | 'system';
+    showLineNumbers: boolean;
+    activePanel: string | null;
+    translations: {
+        pageTitle: string;
+        pageDescription: string;
+        sectionTitle: string;
+        sectionDescription: string;
+        noDocuments: string;
+        activityWillAppear: string;
+        loading: string;
+    };
+    ToolbarPanels: React__default.ComponentType<any>;
+    Toolbar: React__default.ComponentType<any>;
+}
+declare function RecentDocumentsPage({ isLoading, theme, showLineNumbers, activePanel, translations: t, ToolbarPanels, Toolbar, }: RecentDocumentsPageProps): React__default.JSX.Element;
+
+/**
+ * TagSchemasPage Component
+ *
+ * Pure React component for viewing tag schemas.
+ * All dependencies passed as props - no Next.js hooks!
+ */
+
+interface TagSchemasPageProps {
+    schemas: TagSchema[];
+    isLoading: boolean;
+    theme: 'light' | 'dark' | 'system';
+    showLineNumbers: boolean;
+    activePanel: string | null;
+    translations: {
+        pageTitle: string;
+        pageDescription: string;
+        categories: string;
+        loading: string;
+    };
+    ToolbarPanels: React__default.ComponentType<any>;
+    Toolbar: React__default.ComponentType<any>;
+}
+declare function TagSchemasPage({ schemas, isLoading, theme, showLineNumbers, activePanel, translations: t, ToolbarPanels, Toolbar, }: TagSchemasPageProps): React__default.JSX.Element;
+
+type ComposeMode = 'new' | 'clone' | 'reference';
+interface ComposeParams {
+    mode?: string | undefined;
+    token?: string | undefined;
+    annotationUri?: string | undefined;
+    sourceDocumentId?: string | undefined;
+    name?: string | undefined;
+    entityTypes?: string | undefined;
+    storedContext?: string | undefined;
+}
+interface CloneData {
+    sourceResource: ResourceDescriptor;
+    sourceContent: string;
+}
+interface ReferenceData {
+    annotationUri: string;
+    sourceDocumentId: string;
+    name: string;
+    entityTypes: string[];
+}
+interface SaveResourceParams$1 {
+    mode: ComposeMode;
+    name: string;
+    storageUri: string;
+    content?: string;
+    file?: File;
+    format?: string;
+    charset?: string;
+    entityTypes?: string[];
+    language: string;
+    archiveOriginal?: boolean;
+    annotationUri?: string;
+    sourceDocumentId?: string;
+}
+interface ComposePageStateUnit extends StateUnit {
+    browse: ShellStateUnit;
+    mode$: Observable<ComposeMode>;
+    loading$: Observable<boolean>;
+    cloneData$: Observable<CloneData | null>;
+    referenceData$: Observable<ReferenceData | null>;
+    gatheredContext$: Observable<GatheredContext | null>;
+    entityTypes$: Observable<string[]>;
+    /**
+     * Live upload-progress for the in-flight `save(...)` call. Emits the
+     * full `UploadProgress` lifecycle (started → finished) while a save is
+     * underway; resets to `null` between saves and after completion. UI
+     * components can subscribe to render an upload-in-progress indicator.
+     */
+    uploadProgress$: Observable<UploadProgress | null>;
+    save(params: SaveResourceParams$1): Promise<string>;
+}
+declare function createComposePageStateUnit(client: SemiontClient, browse: ShellStateUnit, params: ComposeParams, auth?: AccessToken): ComposePageStateUnit;
+
+/**
+ * ResourceComposePage Component
+ *
+ * Pure React component for creating and editing resources.
+ * Supports three modes: new resource, clone, and reference completion.
+ * All dependencies passed as props - no Next.js hooks!
+ */
+
+interface ResourceComposePageProps {
+    mode: 'new' | 'clone' | 'reference';
+    cloneData?: CloneData | null;
+    referenceData?: ReferenceData | null;
+    gatheredContext?: GatheredContext | null;
+    availableEntityTypes: string[];
+    initialLocale: string;
+    theme: 'light' | 'dark';
+    showLineNumbers: boolean;
+    hoverDelayMs: number;
+    activePanel: string | null;
+    onSaveResource: (params: SaveResourceParams) => Promise<void>;
+    onCancel: () => void;
+    /**
+     * Live upload-progress for the in-flight save. Resolved by the route
+     * shell from `composeVM.uploadProgress$`. `null` between saves and
+     * after completion. When non-null, the form disables Save and the
+     * inline `<UploadProgressBar />` below the action buttons renders.
+     */
+    uploadProgress?: UploadProgress | null;
+    translations: {
+        title: string;
+        titleEditClone: string;
+        titleCompleteReference: string;
+        subtitleClone: string;
+        subtitleReference: string;
+        linkedNoticePrefix: string;
+        resourceName: string;
+        resourceNamePlaceholder: string;
+        entityTypes: string;
+        language: string;
+        contentSource: string;
+        uploadFile: string;
+        uploadFileDescription: string;
+        writeContent: string;
+        writeContentDescription: string;
+        dropFileOrClick: string;
+        supportedFormats: string;
+        mediaType: string;
+        autoDetected: string;
+        format: string;
+        content: string;
+        resourceContent: string;
+        encoding: string;
+        archiveOriginal: string;
+        cancel: string;
+        saving: string;
+        creating: string;
+        creatingAndLinking: string;
+        saveClonedResource: string;
+        createAndLinkResource: string;
+        createResource: string;
+    };
+    ToolbarPanels: React__default.ComponentType<any>;
+    Toolbar: React__default.ComponentType<any>;
+}
+interface SaveResourceParams {
+    mode: 'new' | 'clone' | 'reference';
+    name: string;
+    storageUri: string;
+    content?: string;
+    file?: File;
+    format?: string;
+    charset?: string;
+    entityTypes?: string[];
+    language: string;
+    archiveOriginal?: boolean;
+    annotationUri?: string;
+    sourceDocumentId?: string;
+}
+declare function ResourceComposePage({ mode, cloneData, referenceData, gatheredContext, availableEntityTypes, initialLocale, theme, showLineNumbers, hoverDelayMs, activePanel, onSaveResource, onCancel, uploadProgress, translations: t, ToolbarPanels, Toolbar, }: ResourceComposePageProps): React__default.JSX.Element;
+
+/**
+ * Inline upload-progress affordance for the compose page.
+ *
+ * Subscribes (via prop) to a `UploadProgress | null` value derived from
+ * `composeVM.uploadProgress$`. Renders nothing when null; renders an
+ * indeterminate state on `started`; renders a labeled bar with byte
+ * counts on `progress`; renders a brief "Uploaded" success state on
+ * `finished` (cleared by the state unit's `null` push on complete).
+ *
+ * Designed to live below the Save button in the compose form so the
+ * visual association with the action that triggered the upload is
+ * direct. Uses the existing `.semiont-progress` styles in
+ * `packages/react-ui/src/styles/core/progress.css`.
+ */
+
+interface UploadProgressBarProps {
+    progress: UploadProgress | null;
+    /** Optional label for the "starting" / "uploaded" lines. Defaults to "Upload". */
+    label?: string;
+}
+declare function UploadProgressBar({ progress, label }: UploadProgressBarProps): React__default.ReactElement | null;
+
+/**
+ * ResourceDiscoveryPage Component
+ *
+ * Pure React component for resource discovery and search.
+ * All dependencies passed as props - no Next.js hooks!
+ */
+
+interface ResourceDiscoveryPageProps {
+    recentDocuments: ResourceDescriptor[];
+    searchDocuments: ResourceDescriptor[];
+    entityTypes: string[];
+    isLoadingRecent: boolean;
+    isSearching: boolean;
+    searchQuery: string;
+    onSearchQueryChange: (query: string) => void;
+    selectedEntityType: string;
+    onSelectedEntityTypeChange: (entityType: string) => void;
+    theme: 'light' | 'dark';
+    showLineNumbers: boolean;
+    activePanel: string | null;
+    onNavigateToResource: (resourceId: string) => void;
+    onNavigateToCompose: () => void;
+    translations: {
+        title: string;
+        subtitle: string;
+        searchPlaceholder: string;
+        searchButton: string;
+        searching: string;
+        filterByEntityType: string;
+        all: string;
+        recentResources: string;
+        searchResults: (count: number) => string;
+        documentsTaggedWith: (entityType: string) => string;
+        noResultsFound: (query: string) => string;
+        noResourcesAvailable: string;
+        composeFirstResource: string;
+        archived: string;
+        created: string;
+        loadingKnowledgeBase: string;
+    };
+    ToolbarPanels: React__default.ComponentType<any>;
+}
+declare function ResourceDiscoveryPage({ recentDocuments, searchDocuments, entityTypes, isLoadingRecent, isSearching, searchQuery, onSearchQueryChange, selectedEntityType, onSelectedEntityTypeChange, theme, showLineNumbers, activePanel, onNavigateToResource, onNavigateToCompose, translations: t, ToolbarPanels, }: ResourceDiscoveryPageProps): React__default.JSX.Element;
+
+/**
+ * ResourceCard Component
+ *
+ * Pure component for displaying a single resource in the discovery grid.
+ * Handles keyboard navigation and accessibility.
+ */
+
+interface ResourceCardProps {
+    resource: ResourceDescriptor;
+    onOpen: (resource: ResourceDescriptor) => void;
+    tabIndex?: number;
+    archivedLabel: string;
+    createdLabel: string;
+}
+declare const ResourceCard: React__default.MemoExoticComponent<({ resource, onOpen, tabIndex, archivedLabel, createdLabel }: ResourceCardProps) => React__default.JSX.Element>;
+
+/**
+ * ResourceViewerPage - Self-contained resource viewer component
+ *
+ * Handles all data loading, event subscriptions, and side effects internally.
+ * Only requires minimal props from the framework layer (routing, modals).
+ */
+
+type SemiontResource = ResourceDescriptor;
+interface ResourceViewerPageProps {
+    /**
+     * The resource to display
+     */
+    resource: SemiontResource;
+    /**
+     * Resource URI
+     */
+    rUri: ResourceId;
+    /**
+     * Current locale
+     */
+    locale: string;
+    /**
+     * Link component for routing
+     */
+    Link: React__default.ComponentType<any>;
+    /**
+     * Routes configuration
+     */
+    routes: any;
+    /**
+     * Component dependencies - passed from framework layer
+     */
+    ToolbarPanels: React__default.ComponentType<any>;
+    /**
+     * Callback to refetch document from parent
+     */
+    refetchDocument: () => Promise<unknown>;
+    /**
+     * Bus connection state for the active workspace. Six-valued state
+     * machine from `actor.state$`; CollaborationPanel maps it to the
+     * "Live" / "Disconnected" visual.
+     */
+    streamStatus: ConnectionState;
+    /**
+     * Name of the active knowledge base (for display in panels)
+     */
+    knowledgeBaseName?: string | undefined;
+}
+/**
+ * ResourceViewerPage - Main component
+ *
+ * Uses hooks directly (NO containers, NO render props, NO ResourceViewerPageContent wrapper)
+ *
+ * @emits nav:push - Navigate to a resource or filtered view
+ * @emits beckon:sparkle - Trigger sparkle animation on an annotation
+ * @emits bind:update-body - Update annotation body content
+ * @subscribes mark:archive - Archive the current resource
+ * @subscribes mark:unarchive - Unarchive the current resource
+ * @subscribes yield:clone - Clone the current resource
+ * @subscribes beckon:sparkle - Trigger sparkle animation
+ * @subscribes mark:added - Annotation was created
+ * @subscribes mark:removed - Annotation was deleted
+ * @subscribes mark:create-failed - Annotation creation failed
+ * @subscribes mark:delete-failed - Annotation deletion failed
+ * @subscribes mark:body-updated - Annotation body was updated
+ * @subscribes annotate:body-update-failed - Annotation body update failed
+ * @subscribes settings:theme-changed - UI theme changed
+ * @subscribes settings:line-numbers-toggled - Line numbers display toggled
+ * @subscribes detection:complete - Detection completed
+ * @subscribes detection:failed - Detection failed
+ * @subscribes generation:complete - Generation completed
+ * @subscribes generation:failed - Generation failed
+ * @subscribes browse:reference-navigate - Navigate to a referenced document
+ * @subscribes browse:entity-type-clicked - Navigate filtered by entity type
+ */
+declare function ResourceViewerPage({ resource, rUri, locale, Link, routes, ToolbarPanels, refetchDocument, streamStatus, knowledgeBaseName, }: ResourceViewerPageProps): React__default.JSX.Element;
+
+interface HoverEmitterProps {
+    onMouseEnter: () => void;
+    onMouseLeave: () => void;
+}
+declare function useHoverEmitter(annotationId: AnnotationId, hoverDelayMs?: number): HoverEmitterProps;
+
+interface SessionStateUnit extends StateUnit {
+    isLoggingOut$: Observable<boolean>;
+    logout(): Promise<void>;
+}
+declare function createSessionStateUnit(client: SemiontClient): SessionStateUnit;
+
+interface AnnotationGroups {
+    highlights: Annotation[];
+    comments: Annotation[];
+    assessments: Annotation[];
+    references: Annotation[];
+    tags: Annotation[];
+}
+type StoredEventResponse = components['schemas']['StoredEventResponse'];
+interface WizardState {
+    open: boolean;
+    annotationId: string | null;
+    resourceId: string | null;
+    defaultTitle: string;
+    entityTypes: string[];
+}
+interface ResourceViewerPageStateUnit extends StateUnit {
+    beckon: BeckonStateUnit;
+    browse: ShellStateUnit;
+    mark: MarkStateUnit;
+    gather: GatherStateUnit;
+    yield: YieldStateUnit;
+    annotations$: Observable<Annotation[]>;
+    annotationGroups$: Observable<AnnotationGroups>;
+    entityTypes$: Observable<string[]>;
+    events$: Observable<StoredEventResponse[]>;
+    referencedBy$: Observable<ReferencedByEntry[]>;
+    content$: Observable<string>;
+    contentLoading$: Observable<boolean>;
+    mediaToken$: Observable<string | null>;
+    wizard$: Observable<WizardState>;
+    closeWizard(): void;
+}
+declare function createResourceViewerPageStateUnit(client: SemiontClient, resourceId: ResourceId, locale: string, browse: ShellStateUnit, options?: {
+    mediaType?: string;
+}): ResourceViewerPageStateUnit;
+
+interface ResourceLoaderStateUnit extends StateUnit {
+    resource$: Observable<ResourceDescriptor | undefined>;
+    isLoading$: Observable<boolean>;
+    invalidate(): void;
+}
+declare function createResourceLoaderStateUnit(client: SemiontClient, resourceId: ResourceId): ResourceLoaderStateUnit;
+
+interface AdminUsersStateUnit extends StateUnit {
+    browse: ShellStateUnit;
+    users$: Observable<unknown[]>;
+    stats$: Observable<unknown | null>;
+    usersLoading$: Observable<boolean>;
+    statsLoading$: Observable<boolean>;
+    updateUser(id: string, data: {
+        isAdmin?: boolean;
+        isActive?: boolean;
+    }): Promise<void>;
+}
+declare function createAdminUsersStateUnit(client: SemiontClient, browse: ShellStateUnit): AdminUsersStateUnit;
+
+interface AdminSecurityStateUnit extends StateUnit {
+    browse: ShellStateUnit;
+    providers$: Observable<unknown[]>;
+    allowedDomains$: Observable<string[]>;
+    isLoading$: Observable<boolean>;
+}
+declare function createAdminSecurityStateUnit(client: SemiontClient, browse: ShellStateUnit): AdminSecurityStateUnit;
+
+interface WelcomeStateUnit extends StateUnit {
+    userData$: Observable<{
+        termsAcceptedAt?: string;
+    } | null>;
+    isProcessing$: Observable<boolean>;
+    acceptTerms(): Promise<void>;
+}
+declare function createWelcomeStateUnit(client: SemiontClient): WelcomeStateUnit;
+
+interface DiscoverSearchPipeline {
+    query$: Observable<string>;
+    state$: Observable<{
+        results: ResourceDescriptor[];
+        isSearching: boolean;
+    }>;
+    setQuery(value: string): void;
+}
+interface DiscoverStateUnit extends StateUnit {
+    browse: ShellStateUnit;
+    search: DiscoverSearchPipeline;
+    recentResources$: Observable<ResourceDescriptor[]>;
+    entityTypes$: Observable<string[]>;
+    isLoadingRecent$: Observable<boolean>;
+    selectedEntityType$: Observable<string>;
+    setSelectedEntityType(value: string): void;
+}
+declare function createDiscoverStateUnit(client: SemiontClient, browse: ShellStateUnit): DiscoverStateUnit;
+
+interface EntityTagsStateUnit extends StateUnit {
+    browse: ShellStateUnit;
+    entityTypes$: Observable<string[]>;
+    isLoading$: Observable<boolean>;
+    newTag$: Observable<string>;
+    error$: Observable<string>;
+    isAdding$: Observable<boolean>;
+    setNewTag(value: string): void;
+    addTag(): Promise<void>;
+}
+declare function createEntityTagsStateUnit(client: SemiontClient, browse: ShellStateUnit): EntityTagsStateUnit;
+
+/**
+ * `ShellStateUnit` is app-scoped — it owns toolbar panel state and lives on
+ * the `SemiontBrowser`'s own bus. Unlike session-scoped VMs, this hook
+ * does not need to wait for an active KB session; `useSemiont()`
+ * always returns the module-scoped `SemiontBrowser` singleton.
+ */
+declare function useShellStateUnit(): ShellStateUnit;
+
+/**
+ * Subscribe to an RxJS Observable and return its current value as React state.
+ *
+ * - For a `BehaviorSubject` (or anything with a `getValue()` method), returns
+ *   its current value synchronously at the first render. This matters for
+ *   callers that build derived objects in a `useState(factory)` initializer
+ *   at first render — they need the subject's value present immediately, not
+ *   after a second render triggered by the useEffect subscribe.
+ *
+ *   We duck-type on `.getValue` rather than using `instanceof BehaviorSubject`
+ *   because rxjs can be loaded through multiple module realms in tests (e.g.
+ *   a bundled CJS copy inside `@semiont/react-ui/dist` vs a fresh ESM import
+ *   in the test file), which makes `instanceof` unreliable.
+ * - For non-BehaviorSubject Observables, starts at `undefined` and emits
+ *   asynchronously after the subscribe.
+ * - Accepts `undefined`/`null` for cases where the observable's source isn't
+ *   ready yet (e.g. `semiont?.browse.events(rUri)` when the active session is
+ *   still loading). In that case the hook is a no-op and returns undefined.
+ * - Unsubscribes automatically on unmount or when `obs$` changes.
+ */
+declare function useObservable<T>(obs$: Observable<T> | null | undefined): T | undefined;
+
+export { ANNOTATORS, AVAILABLE_LOCALES, AdminDevOpsPage, AdminExchangePage, AdminSecurityPage, AdminUsersPage, AnnotateReferencesProgressWidget, AnnotateToolbar, AnnotateView, AnnotationHistory, AnnotationOverlay, AnnotationProvider, AssessmentEntry, AssessmentPanel, AssistSection, AsyncErrorBoundary, AuthErrorDisplay, BrowseView, Button, ButtonGroup, COMMON_PANELS, CodeMirrorRenderer, CollaborationPanel, CollapsibleResourceNavigation, CommentEntry, CommentsPanel, ComposeLoadingState, EntityTagsPage, EntityTypeBadges, ErrorBoundary, ExportCard, Footer, HighlightEntry, HighlightPanel, HistoryEvent, ImageURLSchema, ImageViewer, ImportCard, ImportProgress, JsonLdPanel, JsonLdView, KeyboardShortcutsHelpModal, LeftSidebar, LinkedDataPage, LiveRegionProvider, NavigationMenu, OAuthUserSchema, ObservableLink, PageLayout, PanelHeader, PermissionDeniedModal, PopupContainer, PopupHeader, ProtectedErrorBoundary, RESOURCE_PANELS, RecentDocumentsPage, ReferenceEntry, ReferenceResolutionWidget, ReferenceWizardModal, ReferencesPanel, ResizeHandle, ResourceAnnotationsProvider, ResourceCard, ResourceComposePage, ResourceDiscoveryPage, ResourceErrorState, ResourceInfoPanel, ResourceLoadingState, ResourceSearchModal, ResourceTagsInline, ResourceViewer, ResourceViewerPage, SearchModal, SelectedTextDisplay, SemiontBranding, SemiontFavicon, SemiontProvider, SessionExpiredModal, SessionExpiryBanner, SessionTimer, SettingsPanel, SignInForm, SignUpForm, SimpleNavigation, SkipLinks, SortableResourceTab, StatisticsPanel, StatusDisplay, SvgDrawingCanvas, TagEntry, TagSchemasPage, TaggingPanel, ThemeProvider, ToastContainer, ToastProvider, Toolbar, TranslationProvider, UnifiedAnnotationsPanel, UnifiedHeader, UploadProgressBar, UserMenuSkeleton, WebBrowserStorage, WelcomePage, applyHighlights, buildSourceToRenderedMap, buildTextNodeIndex, buttonStyles, clearHighlights, createAdminSecurityStateUnit, createAdminUsersStateUnit, createComposePageStateUnit, createDiscoverStateUnit, createEntityTagsStateUnit, createExchangeStateUnit, createResourceLoaderStateUnit, createResourceViewerPageStateUnit, createSessionStateUnit, createShellStateUnit, createWelcomeStateUnit, cssVariables, faviconPaths, formatTime, generateCSSVariables, getResourceIcon, getSelectedShapeForSelectorType, getSelectorType, getShortcutDisplay, getSupportedShapes, hideWidgetPreview, isShapeSupported, jsonLightHighlightStyle, jsonLightTheme, resolveAnnotationRanges, sanitizeImageURL, saveSelectedShapeForSelectorType, showWidgetPreview, supportsDetection, toOverlayAnnotations, tokens, useAnnotationManager, useDebounce, useDebouncedCallback, useDocumentAnnouncements, useDoubleKeyPress, useDropdown, useEventSubscription, useEventSubscriptions, useFormAnnouncements, useHoverDelay, useHoverEmitter, useIsTyping, useKeyboardShortcuts, useLanguageChangeAnnouncements, useLineNumbers, useLiveRegion, useLoadingState, useLocalStorage, useObservable, useObservableExternalNavigation, useObservableRouter, usePanelWidth, usePreloadTranslations, useResourceAnnotations, useResourceContent, useResourceLoadingAnnouncements, useRovingTabIndex, useSearchAnnouncements, useSemiont, useSessionExpiry, useShellStateUnit, useStateUnit, useTheme, useToast, useTranslations };
+export type { AdminDevOpsPageProps, AdminExchangePageProps, AdminExchangePageTranslations, AdminSecurityPageProps, AdminSecurityStateUnit, AdminUser, AdminUserStats, AdminUsersPageProps, AdminUsersStateUnit, AnnotationConfig, AnnotationCreationHandler, AnnotationGroups, AnnotationHandlers, AnnotationManager, AnnotationProviderProps, AnnotationUIState, AnnotationsCollection, Annotator, AuthErrorDisplayProps, AvailableLocale, BorderRadiusToken, ButtonGroupProps, ButtonProps, ClickAction, CloneData, CollapsibleResourceNavigationProps, ColorToken, ComposeLoadingStateProps, ComposeMode, ComposePageStateUnit, ComposeParams, CreateAnnotationParams, CreateConfig, DeleteAnnotationParams, DetectionConfig, DevOpsFeature, DiscoverStateUnit, DrawingMode, EntityTagsPageProps, EntityTagsStateUnit, ExchangeStateUnit, ExportCardProps, ExportCardTranslations, HoverEmitterProps, ImportCardProps, ImportCardTranslations, ImportPreview, ImportProgressProps, ImportProgressTranslations, KeyboardShortcut, LinkComponentProps, LinkedDataPageProps, LinkedDataPageTranslations, Motivation$8 as Motivation, NavigationItem, NavigationMenuHelper, NavigationProps, OAuthProvider, OAuthUser, ObservableLinkProps, OverlayAnnotation, RecentDocumentsPageProps, ReferenceData, ReferenceWizardModalProps, ResolvedTheme, ResourceCardProps, ResourceComposePageProps, ResourceDiscoveryPageProps, ResourceErrorStateProps, ResourceLoaderStateUnit, ResourceSearchModalProps, ResourceViewerPageProps, ResourceViewerPageStateUnit, RouteBuilder, SaveResourceParams$1 as SaveResourceParams, SearchModalProps, SelectionMotivation, SelectorType, SemiontProviderProps, SemiontResource$2 as SemiontResource, SessionStateUnit, ShadowToken, ShapeType, ShellStateUnit, ShellStateUnitOptions, SignInFormProps, SignUpFormProps, SimpleNavigationItem, SimpleNavigationProps, SortableResourceTabProps, SpacingToken, TagSchemasPageProps, TextSegment, TextSelection, Theme, ToastMessage, ToastType, ToolbarPanelType, TransitionToken, TranslationManager, TranslationProviderProps, TypographyToken, UICreateAnnotationParams, UploadProgressBarProps, UseResourceContentResult, WelcomePageProps, WelcomeStateUnit, WizardState };