@semiont/react-ui 0.2.28-build.40

package/dist/index.d.mts

@@ -0,0 +1,3003 @@
+import * as _semiont_api_client from '@semiont/api-client';
+import { components, ResourceUri, Selector, GenerationContext, SemiontApiClient, AnnotationUri, ResourceAnnotationUri, ValidationResult, DetectionProgress as DetectionProgress$1, GenerationProgress as GenerationProgress$1, ResourceEvent as ResourceEvent$1, StoredEvent, paths } from '@semiont/api-client';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { A as ApiClientManager, O as OpenResourcesManager, S as SessionManager, T as TranslationManager } from './TranslationManager-Co_5fSxl.mjs';
+export { a as OpenResource, b as SessionState } from './TranslationManager-Co_5fSxl.mjs';
+import * as React$1 from 'react';
+import React__default, { MutableRefObject, KeyboardEvent as KeyboardEvent$1, ReactNode, Component, ErrorInfo } from 'react';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions } from '@tanstack/react-query';
+import * as _codemirror_state from '@codemirror/state';
+import { HighlightStyle } from '@codemirror/language';
+import { WidgetType } from '@codemirror/view';
+import { Root } from 'hast';
+import { Root as Root$1 } from 'mdast';
+import { VFile } from 'vfile';
+import { TagSchema } from '@semiont/ontology';
+export { TAG_SCHEMAS, TagCategory, TagSchema, getAllTagSchemas, getSchemaCategory as getTagCategory, getTagSchema, getTagSchemasByDomain, isValidCategory } from '@semiont/ontology';
+
+type Annotation$o = components['schemas']['Annotation'];
+/**
+ * Collection of all annotation types for a resource.
+ * Replaces separate highlights, references, assessments, comments, tags props.
+ */
+interface AnnotationsCollection {
+    highlights: Annotation$o[];
+    references: Annotation$o[];
+    assessments: Annotation$o[];
+    comments: Annotation$o[];
+    tags: Annotation$o[];
+}
+/**
+ * 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$o, 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: SelectionMotivation;
+    /** Selector information - either text or SVG */
+    selector: {
+        /** Selector type */
+        type: 'TextQuoteSelector' | 'SvgSelector';
+        /** 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;
+    };
+    /** 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$o | 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: SelectionMotivation | null;
+    /** Currently selected click mode (detail, follow, delete, jsonld) */
+    selectedClick: ClickAction;
+    /** Currently selected shape for image annotations */
+    selectedShape: ShapeType;
+    /** ID of currently hovered annotation (optional - only set when hovering) */
+    hoveredAnnotationId?: string | null;
+    /** ID of currently hovered comment for panel highlighting (optional - only set when hovering) */
+    hoveredCommentId?: 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;
+}
+
+type Annotation$n = components['schemas']['Annotation'];
+/**
+ * Parameters for creating an annotation
+ */
+interface CreateAnnotationParams {
+    rUri: ResourceUri;
+    motivation: 'highlighting' | 'linking' | 'assessing' | 'commenting' | 'tagging';
+    selector: Selector | Selector[];
+    body?: any[];
+}
+/**
+ * Parameters for deleting an annotation
+ */
+interface DeleteAnnotationParams {
+    annotationId: string;
+    rUri: ResourceUri;
+}
+/**
+ * Annotation Manager Interface
+ *
+ * Framework-agnostic interface for annotation mutations.
+ * Apps provide implementations via AnnotationProvider.
+ *
+ * Example implementation (React Query):
+ * ```typescript
+ * function useAnnotationManager(): AnnotationManager {
+ *   const createMutation = useAnnotations().create.useMutation();
+ *   const deleteMutation = useAnnotations().delete.useMutation();
+ *
+ *   return {
+ *     createAnnotation: async (params) => {
+ *       const result = await createMutation.mutateAsync({...});
+ *       return result.annotation;
+ *     },
+ *     deleteAnnotation: async (params) => {
+ *       await deleteMutation.mutateAsync({...});
+ *     }
+ *   };
+ * }
+ * ```
+ */
+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
+     */
+    createAnnotation: (params: CreateAnnotationParams) => Promise<Annotation$n | undefined>;
+    /**
+     * Delete an annotation
+     * @param params - Deletion parameters (annotationId, rUri)
+     * @returns Promise resolving when deletion completes
+     */
+    deleteAnnotation: (params: DeleteAnnotationParams) => Promise<void>;
+}
+
+/**
+ * Cache Manager Interface
+ *
+ * Framework-agnostic interface for cache invalidation.
+ * Apps provide implementations via CacheProvider.
+ *
+ * This abstraction allows react-ui to trigger cache invalidation
+ * without depending on a specific data fetching library (React Query, SWR, Apollo, etc.)
+ *
+ * Example implementation (React Query):
+ * ```typescript
+ * function useCacheManager(): CacheManager {
+ *   const queryClient = useQueryClient();
+ *
+ *   return {
+ *     invalidateAnnotations: (rUri) => {
+ *       queryClient.invalidateQueries({ queryKey: ['annotations', rUri] });
+ *     },
+ *     invalidateEvents: (rUri) => {
+ *       queryClient.invalidateQueries({ queryKey: ['documents', 'events', rUri] });
+ *     }
+ *   };
+ * }
+ * ```
+ *
+ * Example implementation (SWR):
+ * ```typescript
+ * function useCacheManager(): CacheManager {
+ *   const { mutate } = useSWRConfig();
+ *
+ *   return {
+ *     invalidateAnnotations: (rUri) => {
+ *       mutate((key) => Array.isArray(key) && key[0] === 'annotations' && key[1] === rUri);
+ *     },
+ *     invalidateEvents: (rUri) => {
+ *       mutate((key) => Array.isArray(key) && key[0] === 'events' && key[1] === rUri);
+ *     }
+ *   };
+ * }
+ * ```
+ */
+interface CacheManager {
+    /**
+     * Invalidate annotation cache for a resource
+     * @param rUri - Resource URI
+     * @returns Promise or void (synchronous invalidation is acceptable)
+     */
+    invalidateAnnotations: (rUri: ResourceUri) => void | Promise<void>;
+    /**
+     * Invalidate events cache for a resource
+     * @param rUri - Resource URI
+     * @returns Promise or void (synchronous invalidation is acceptable)
+     */
+    invalidateEvents: (rUri: ResourceUri) => void | Promise<void>;
+}
+
+/**
+ * Type definitions for resource viewer feature
+ */
+
+type SemiontResource$2 = components['schemas']['ResourceDescriptor'];
+type Annotation$m = components['schemas']['Annotation'];
+type Motivation$2 = components['schemas']['Motivation'];
+/**
+ * Selection for creating annotations
+ */
+interface TextSelection {
+    exact: string;
+    start: number;
+    end: number;
+    prefix?: string;
+    suffix?: string;
+    svgSelector?: string;
+}
+/**
+ * Generation options
+ */
+interface GenerationOptions {
+    title: string;
+    prompt?: string;
+    language?: string;
+    temperature?: number;
+    maxTokens?: number;
+    context?: GenerationContext;
+}
+
+/**
+ * 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 Annotation$l = components['schemas']['Annotation'];
+type Motivation$1 = components['schemas']['Motivation'];
+/**
+ * Detection configuration for SSE-based annotation detection
+ */
+interface DetectionConfig {
+    sseMethod: 'detectAnnotations' | 'detectHighlights' | 'detectAssessments' | 'detectComments' | 'detectTags';
+    countField: 'foundCount' | 'createdCount' | 'tagsCreated';
+    displayNamePlural: string;
+    displayNameSingular: string;
+    formatRequestParams?: (args: any[]) => Array<{
+        label: string;
+        value: string;
+    }>;
+}
+/**
+ * Annotator: Encapsulates all motivation-specific behavior
+ * Handles clicks, hovers, detection, and other operations for one annotation type
+ *
+ * Metadata is static (defined in registry), handlers are injected at runtime (from page.tsx)
+ */
+interface Annotator {
+    motivation: Motivation$1;
+    internalType: string;
+    displayName: string;
+    description: string;
+    className: string;
+    iconEmoji?: string;
+    isClickable: boolean;
+    hasHoverInteraction: boolean;
+    hasSidePanel: boolean;
+    matchesAnnotation: (annotation: Annotation$l) => boolean;
+    announceOnCreate: string;
+    detection?: DetectionConfig;
+    handlers?: {
+        onClick?: (annotation: Annotation$l) => void;
+        onHover?: (annotationId: string | null) => void;
+        onDetect?: (...args: any[]) => void | Promise<void>;
+        onUpdate?: (annotationId: string, ...args: any[]) => void | Promise<void>;
+        onCreate?: (...args: any[]) => void | Promise<void>;
+    };
+}
+/**
+ * Registry of all annotators (motivation handlers)
+ * Metadata is defined here, handlers are injected at runtime
+ */
+declare const ANNOTATORS: Record<string, Annotator>;
+/**
+ * Get annotator for an annotation by checking all registered types
+ * Returns null if annotation doesn't match any registered type
+ */
+declare function getAnnotator(annotation: Annotation$l): Annotator | null;
+/**
+ * Get CSS className for an annotation
+ * Falls back to highlight style if no match found
+ */
+declare function getAnnotationClassName(annotation: Annotation$l): string;
+/**
+ * Get internal type string for an annotation (e.g., 'highlight', 'comment')
+ * Falls back to 'highlight' if no match found
+ */
+declare function getAnnotationInternalType(annotation: Annotation$l): string;
+/**
+ * Group annotations by their internal type
+ * Returns a record with keys like 'highlight', 'comment', 'assessment', 'reference'
+ * Each value is an array of annotations of that type
+ */
+declare function groupAnnotationsByType(annotations: Annotation$l[]): Record<string, Annotation$l[]>;
+/**
+ * Create a copy of annotators with handlers injected
+ * Use this in page.tsx to inject runtime handlers into the registry
+ */
+declare function withHandlers(handlers: Record<string, Annotator['handlers']>): Record<string, Annotator>;
+/**
+ * Generic detection handler factory
+ * Creates a detection handler for any annotator with detection config
+ *
+ * This eliminates the need for motivation-specific detection handlers
+ * (handleDetectHighlights, handleDetectAssessments, etc.)
+ */
+declare function createDetectionHandler(annotator: Annotator, context: {
+    client: any;
+    rUri: any;
+    setDetectingMotivation: (motivation: Motivation$1 | null) => void;
+    setMotivationDetectionProgress: (progress: any) => void;
+    detectionStreamRef: MutableRefObject<any>;
+    cacheManager: CacheManager;
+    showSuccess: (message: string) => void;
+    showError: (message: string) => void;
+}): (...args: any[]) => Promise<void>;
+/**
+ * Generic detection cancellation handler
+ * Cancels any active detection stream
+ */
+declare function createCancelDetectionHandler(context: {
+    detectionStreamRef: MutableRefObject<any>;
+    setDetectingMotivation: (motivation: Motivation$1 | null) => void;
+    setMotivationDetectionProgress: (progress: any) => void;
+}): () => void;
+
+/**
+ * Resource operations
+ */
+declare function useResources(): {
+    list: {
+        useQuery: (options?: {
+            limit?: number;
+            archived?: boolean;
+            query?: string;
+        }) => _tanstack_react_query.UseQueryResult<{
+            resources: _semiont_api_client.components["schemas"]["ResourceDescriptor"][];
+            total: number;
+            offset: number;
+            limit: number;
+        }, Error>;
+    };
+    get: {
+        useQuery: (rUri: ResourceUri, options?: Omit<UseQueryOptions, "queryKey" | "queryFn">) => _tanstack_react_query.UseQueryResult<unknown, Error>;
+    };
+    events: {
+        useQuery: (rUri: ResourceUri) => _tanstack_react_query.UseQueryResult<{
+            events: any[];
+        }, Error>;
+    };
+    annotations: {
+        useQuery: (rUri: ResourceUri) => _tanstack_react_query.UseQueryResult<{
+            resource: _semiont_api_client.components["schemas"]["ResourceDescriptor"];
+            annotations: _semiont_api_client.components["schemas"]["Annotation"][];
+        }, Error>;
+    };
+    referencedBy: {
+        useQuery: (rUri: ResourceUri) => _tanstack_react_query.UseQueryResult<{
+            referencedBy: any[];
+        }, Error>;
+    };
+    search: {
+        useQuery: (query: string, limit: number) => _tanstack_react_query.UseQueryResult<{
+            resources: _semiont_api_client.components["schemas"]["ResourceDescriptor"][];
+            total: number;
+            offset: number;
+            limit: number;
+        }, Error>;
+    };
+    create: {
+        useMutation: () => _tanstack_react_query.UseMutationResult<{
+            resource: _semiont_api_client.components["schemas"]["ResourceDescriptor"];
+            annotations: _semiont_api_client.components["schemas"]["Annotation"][];
+        }, Error, {
+            name: string;
+            file: File | Buffer;
+            format: string;
+            entityTypes?: string[];
+            language?: string;
+            creationMethod?: string;
+            sourceAnnotationId?: string;
+            sourceResourceId?: string;
+        }, unknown>;
+    };
+    update: {
+        useMutation: () => _tanstack_react_query.UseMutationResult<{
+            resource: _semiont_api_client.components["schemas"]["ResourceDescriptor"];
+            annotations: _semiont_api_client.components["schemas"]["Annotation"][];
+            entityReferences: _semiont_api_client.components["schemas"]["Annotation"][];
+        }, Error, {
+            rUri: ResourceUri;
+            data: Parameters<SemiontApiClient["updateResource"]>[1];
+        }, unknown>;
+    };
+    generateCloneToken: {
+        useMutation: () => _tanstack_react_query.UseMutationResult<{
+            token: string;
+            expiresAt: string;
+            resource: _semiont_api_client.components["schemas"]["ResourceDescriptor"];
+        }, Error, ResourceUri, unknown>;
+    };
+    getByToken: {
+        useQuery: (token: string) => _tanstack_react_query.UseQueryResult<{
+            sourceResource: _semiont_api_client.components["schemas"]["ResourceDescriptor"];
+            expiresAt: string;
+        }, Error>;
+    };
+    createFromToken: {
+        useMutation: () => _tanstack_react_query.UseMutationResult<{
+            resource: _semiont_api_client.components["schemas"]["ResourceDescriptor"];
+            annotations: _semiont_api_client.components["schemas"]["Annotation"][];
+        }, Error, {
+            token: string;
+            name: string;
+            content: string;
+            archiveOriginal?: boolean;
+        }, unknown>;
+    };
+};
+/**
+ * Annotation operations
+ */
+declare function useAnnotations(): {
+    get: {
+        useQuery: (annotationUri: AnnotationUri) => _tanstack_react_query.UseQueryResult<never, Error>;
+    };
+    getResourceAnnotation: {
+        useQuery: (annotationUri: ResourceAnnotationUri) => _tanstack_react_query.UseQueryResult<{
+            annotation: _semiont_api_client.components["schemas"]["Annotation"];
+            resource: _semiont_api_client.components["schemas"]["ResourceDescriptor"] | null;
+            resolvedResource: _semiont_api_client.components["schemas"]["ResourceDescriptor"] | null;
+        }, Error>;
+    };
+    history: {
+        useQuery: (annotationUri: ResourceAnnotationUri) => _tanstack_react_query.UseQueryResult<{
+            events: {
+                id: string;
+                type: string;
+                timestamp: string;
+                userId: string;
+                resourceId: string;
+                payload: {
+                    name: string;
+                    format: _semiont_api_client.components["schemas"]["ContentFormat"];
+                    contentChecksum: string;
+                    creationMethod: "api" | "upload" | "ui" | "reference" | "clone" | "generated";
+                    entityTypes?: string[];
+                    metadata?: {
+                        [key: string]: unknown;
+                    };
+                } | {
+                    name: string;
+                    format: _semiont_api_client.components["schemas"]["ContentFormat"];
+                    contentChecksum: string;
+                    parentResourceId: string;
+                    creationMethod: "api" | "upload" | "ui" | "reference" | "clone" | "generated";
+                    entityTypes?: string[];
+                    metadata?: {
+                        [key: string]: unknown;
+                    };
+                } | {
+                    reason?: string;
+                } | Record<string, never> | {
+                    annotation: _semiont_api_client.components["schemas"]["Annotation"];
+                } | {
+                    annotationId: string;
+                } | {
+                    annotationId: string;
+                    targetResourceId: string;
+                } | {
+                    entityType: string;
+                } | {
+                    entityType: string;
+                };
+                metadata: {
+                    sequenceNumber: number;
+                    prevEventHash?: string;
+                    checksum?: string;
+                };
+            }[];
+            total: number;
+            annotationId: string;
+            resourceId: string;
+        }, Error>;
+    };
+    create: {
+        useMutation: () => _tanstack_react_query.UseMutationResult<{
+            annotation: _semiont_api_client.components["schemas"]["Annotation"];
+        }, Error, {
+            rUri: ResourceUri;
+            data: Parameters<SemiontApiClient["createAnnotation"]>[1];
+        }, unknown>;
+    };
+    delete: {
+        useMutation: () => _tanstack_react_query.UseMutationResult<void, Error, ResourceAnnotationUri, unknown>;
+    };
+    updateBody: {
+        useMutation: () => _tanstack_react_query.UseMutationResult<{
+            annotation: _semiont_api_client.components["schemas"]["Annotation"];
+        }, Error, {
+            annotationUri: ResourceAnnotationUri;
+            data: Parameters<SemiontApiClient["updateAnnotationBody"]>[1];
+        }, unknown>;
+    };
+    llmContext: {
+        useQuery: (resourceUri: ResourceUri, annotationId: string, options?: {
+            contextWindow?: number;
+        }) => _tanstack_react_query.UseQueryResult<{
+            annotation: _semiont_api_client.components["schemas"]["Annotation"];
+            sourceResource: _semiont_api_client.components["schemas"]["ResourceDescriptor"];
+            targetResource?: _semiont_api_client.components["schemas"]["ResourceDescriptor"] | null;
+            context?: _semiont_api_client.components["schemas"]["GenerationContext"];
+            sourceContext?: {
+                before: string;
+                selected: string;
+                after: string;
+            };
+            targetContext?: {
+                content: string;
+                summary?: string;
+            };
+            suggestedResolution?: {
+                resourceId: string;
+                resourceName: string;
+                confidence: number;
+                reasoning: string;
+            };
+        }, Error>;
+    };
+};
+/**
+ * Entity type operations
+ */
+declare function useEntityTypes(): {
+    list: {
+        useQuery: (options?: Omit<UseQueryOptions<{
+            entityTypes: string[];
+        }>, "queryKey" | "queryFn">) => _tanstack_react_query.UseQueryResult<{
+            entityTypes: string[];
+        }, Error>;
+    };
+    add: {
+        useMutation: () => _tanstack_react_query.UseMutationResult<{
+            success: boolean;
+            entityTypes: string[];
+        }, Error, string, unknown>;
+    };
+    addBulk: {
+        useMutation: () => _tanstack_react_query.UseMutationResult<{
+            success: boolean;
+            entityTypes: string[];
+        }, Error, string[], unknown>;
+    };
+};
+/**
+ * Admin operations
+ */
+declare function useAdmin(): {
+    users: {
+        list: {
+            useQuery: () => _tanstack_react_query.UseQueryResult<{
+                success: boolean;
+                users: {
+                    id: string;
+                    email: string;
+                    name: string | null;
+                    image: string | null;
+                    domain: string;
+                    provider: string;
+                    isAdmin: boolean;
+                    isActive: boolean;
+                    lastLogin: string | null;
+                    created: string;
+                    updatedAt: string;
+                }[];
+            }, Error>;
+        };
+        stats: {
+            useQuery: () => _tanstack_react_query.UseQueryResult<{
+                success: boolean;
+                stats: {
+                    totalUsers: number;
+                    activeUsers: number;
+                    adminUsers: number;
+                    regularUsers: number;
+                    domainBreakdown: {
+                        domain: string;
+                        count: number;
+                    }[];
+                    recentSignups: {
+                        id: string;
+                        email: string;
+                        name: string | null;
+                        created: string;
+                    }[];
+                };
+            }, Error>;
+        };
+        update: {
+            useMutation: () => _tanstack_react_query.UseMutationResult<{
+                success: boolean;
+                user: {
+                    id: string;
+                    email: string;
+                    name: string | null;
+                    image: string | null;
+                    domain: string;
+                    provider: string;
+                    isAdmin: boolean;
+                    isActive: boolean;
+                    lastLogin: string | null;
+                    created: string;
+                    updatedAt: string;
+                };
+            }, Error, {
+                id: string;
+                data: Parameters<SemiontApiClient["updateUser"]>[1];
+            }, unknown>;
+        };
+    };
+    oauth: {
+        config: {
+            useQuery: () => _tanstack_react_query.UseQueryResult<{
+                providers: {
+                    name: string;
+                    isConfigured: boolean;
+                    clientId: string;
+                }[];
+                allowedDomains: string[];
+            }, Error>;
+        };
+    };
+};
+/**
+ * Authentication and user operations via API
+ */
+declare function useAuthApi(): {
+    me: {
+        useQuery: () => _tanstack_react_query.UseQueryResult<{
+            id: string;
+            email: string;
+            name: string | null;
+            image: string | null;
+            domain: string;
+            provider: string;
+            isAdmin: boolean;
+            isActive: boolean;
+            termsAcceptedAt: string | null;
+            lastLogin: string | null;
+            created: string;
+        }, Error>;
+    };
+    acceptTerms: {
+        useMutation: () => _tanstack_react_query.UseMutationResult<{
+            success: boolean;
+            message: string;
+        }, Error, void, unknown>;
+    };
+    generateMCPToken: {
+        useMutation: () => _tanstack_react_query.UseMutationResult<{
+            refresh_token: string;
+        }, Error, void, unknown>;
+    };
+    logout: {
+        useMutation: () => _tanstack_react_query.UseMutationResult<{
+            success: boolean;
+            message: string;
+        }, Error, void, unknown>;
+    };
+};
+/**
+ * Health check and system status
+ */
+declare function useHealth(): {
+    check: {
+        useQuery: () => _tanstack_react_query.UseQueryResult<{
+            status: string;
+            message: string;
+            version: string;
+            timestamp: string;
+            database: "connected" | "disconnected" | "unknown";
+            environment: string;
+        }, Error>;
+    };
+    status: {
+        useQuery: (refetchInterval?: number) => _tanstack_react_query.UseQueryResult<{
+            status: string;
+            version: string;
+            features: {
+                semanticContent: string;
+                collaboration: string;
+                rbac: string;
+            };
+            message: string;
+            authenticatedAs?: string;
+        }, Error>;
+    };
+};
+
+/**
+ * Global authentication event system for coordinating auth state across components
+ */
+declare const AUTH_EVENTS: {
+    readonly UNAUTHORIZED: "auth:unauthorized";
+    readonly FORBIDDEN: "auth:forbidden";
+    readonly SESSION_EXPIRED: "auth:session-expired";
+};
+type AuthEventType = typeof AUTH_EVENTS[keyof typeof AUTH_EVENTS];
+interface AuthEventDetail {
+    message?: string;
+    statusCode?: number;
+    timestamp: number;
+}
+/**
+ * Dispatch an authentication event
+ */
+declare function dispatchAuthEvent(type: AuthEventType, detail?: Partial<AuthEventDetail>): void;
+/**
+ * Listen for authentication events
+ */
+declare function onAuthEvent(type: AuthEventType, handler: (event: CustomEvent<AuthEventDetail>) => void): () => void;
+/**
+ * Dispatch a 401 Unauthorized event
+ */
+declare function dispatch401Error(message?: string): void;
+/**
+ * Dispatch a 403 Forbidden event
+ */
+declare function dispatch403Error(message?: string): void;
+
+/**
+ * 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: "px-6 py-2 bg-gradient-to-r from-cyan-500/20 to-blue-500/20 hover:from-cyan-600 hover:to-blue-600 dark:from-cyan-600/20 dark:to-blue-600/20 dark:hover:from-cyan-500 dark:hover:to-blue-500 text-cyan-700 hover:text-white dark:text-cyan-400 dark:hover:text-white border border-cyan-400/30 hover:border-cyan-600 dark:border-cyan-500/30 dark:hover:border-cyan-400 rounded-lg transition-all duration-300 backdrop-blur-sm disabled:opacity-50 disabled:cursor-not-allowed";
+        readonly large: "w-full py-3 bg-gradient-to-r from-cyan-500/20 to-blue-500/20 hover:from-cyan-600 hover:to-blue-600 dark:from-cyan-600/20 dark:to-blue-600/20 dark:hover:from-cyan-500 dark:hover:to-blue-500 text-cyan-700 hover:text-white dark:text-cyan-400 dark:hover:text-white border border-cyan-400/30 hover:border-cyan-600 dark:border-cyan-500/30 dark:hover:border-cyan-400 rounded-lg transition-all duration-300 transform hover:scale-[1.02] font-medium flex items-center justify-center gap-2 backdrop-blur-sm disabled:opacity-50 disabled:cursor-not-allowed";
+    };
+    readonly secondary: {
+        readonly base: "px-6 py-2 bg-black/10 hover:bg-black/20 dark:bg-white/10 dark:hover:bg-white/20 border border-black/20 dark:border-white/20 text-gray-900 dark:text-white rounded-lg disabled:opacity-50 disabled:cursor-not-allowed transition-all duration-300";
+        readonly withScale: "px-6 py-2 bg-black/10 hover:bg-black/20 dark:bg-white/10 dark:hover:bg-white/20 border border-black/20 dark:border-white/20 text-gray-900 dark:text-white rounded-lg disabled:opacity-50 disabled:cursor-not-allowed transition-all duration-300 transform hover:scale-105";
+    };
+    readonly tertiary: {
+        readonly base: "px-4 py-2 text-gray-700 dark:text-gray-300 hover:bg-gray-100 dark:hover:bg-gray-700 rounded-lg transition-colors";
+    };
+    readonly danger: {
+        readonly base: "px-6 py-2 text-red-600 dark:text-red-400 hover:bg-red-50 dark:hover:bg-red-900/20 border border-red-200 dark:border-red-800 rounded-lg transition-all duration-300";
+    };
+    readonly warning: {
+        readonly base: "px-6 py-2 bg-yellow-400/20 hover:bg-yellow-400/30 dark:bg-yellow-500/20 dark:hover:bg-yellow-500/30 text-yellow-800 hover:text-yellow-900 dark:text-yellow-300 dark:hover:text-yellow-200 border border-yellow-400/30 hover:border-yellow-500 dark:border-yellow-500/30 dark:hover:border-yellow-400 rounded-lg transition-all duration-300 backdrop-blur-sm";
+    };
+    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:
+ * - Wiki link pills (clickable, styled)
+ * - Reference previews (hover for context)
+ * - Entity type badges
+ */
+
+type Annotation$k = components['schemas']['Annotation'];
+/**
+ * Reference Resolution Widget
+ * Shows a small indicator next to references with hover preview
+ */
+declare class ReferenceResolutionWidget extends WidgetType {
+    readonly annotation: Annotation$k;
+    readonly targetDocumentName?: string | undefined;
+    readonly onNavigate?: ((documentId: string) => void) | undefined;
+    readonly onUnresolvedClick?: ((annotation: Annotation$k) => void) | undefined;
+    readonly isGenerating?: boolean | undefined;
+    constructor(annotation: Annotation$k, targetDocumentName?: string | undefined, onNavigate?: ((documentId: string) => void) | undefined, onUnresolvedClick?: ((annotation: Annotation$k) => void) | undefined, isGenerating?: boolean | undefined);
+    eq(other: ReferenceResolutionWidget): boolean;
+    toDOM(): HTMLSpanElement;
+    private showPreview;
+    private hidePreview;
+    ignoreEvent(event: Event): boolean;
+}
+
+/**
+ * Centralized query keys for React Query
+ * Following TanStack Query best practices for type-safe cache invalidation
+ * @see https://tanstack.com/query/latest/docs/framework/react/guides/query-keys
+ *
+ * Keys use semantic names (not URL paths) and are properly typed with 'as const'
+ */
+
+declare const QUERY_KEYS: {
+    users: {
+        me: () => readonly ["users", "me"];
+    };
+    health: () => readonly ["health"];
+    status: () => readonly ["status"];
+    resources: {
+        all: (limit?: number, archived?: boolean) => readonly ["resources", {
+            readonly limit: number | undefined;
+            readonly archived: boolean | undefined;
+        }];
+        detail: (rUri: ResourceUri) => readonly ["resources", ResourceUri];
+        byToken: (token: string) => readonly ["resources", "by-token", string];
+        search: (query: string, limit: number) => readonly ["resources", "search", {
+            readonly query: string;
+            readonly limit: number;
+        }];
+        events: (rUri: ResourceUri) => readonly ["resources", ResourceUri, "events"];
+        annotations: (rUri: ResourceUri) => readonly ["resources", ResourceUri, "annotations"];
+        referencedBy: (rUri: ResourceUri) => readonly ["resources", ResourceUri, "referenced-by"];
+    };
+    annotations: {
+        detail: (aUri: AnnotationUri) => readonly ["annotations", AnnotationUri];
+        history: (aUri: ResourceAnnotationUri) => readonly ["annotations", ResourceAnnotationUri, "history"];
+        llmContext: (resourceUri: ResourceUri, annotationId: string) => readonly ["annotations", "llm-context", ResourceUri, string];
+    };
+    entityTypes: {
+        all: () => readonly ["entity-types"];
+    };
+    admin: {
+        users: {
+            all: () => readonly ["admin", "users"];
+            stats: () => readonly ["admin", "users", "stats"];
+        };
+        oauth: {
+            config: () => readonly ["admin", "oauth", "config"];
+        };
+    };
+    documents: {
+        all: (limit?: number, archived?: boolean) => readonly ["resources", {
+            readonly limit: number | undefined;
+            readonly archived: boolean | undefined;
+        }];
+        detail: (rUri: ResourceUri) => readonly ["resources", ResourceUri];
+        byToken: (token: string) => readonly ["resources", "by-token", string];
+        search: (query: string, limit: number) => readonly ["resources", "search", {
+            readonly query: string;
+            readonly limit: number;
+        }];
+        events: (rUri: ResourceUri) => readonly ["resources", ResourceUri, "events"];
+        annotations: (rUri: ResourceUri) => readonly ["resources", ResourceUri, "annotations"];
+        referencedBy: (rUri: ResourceUri) => readonly ["resources", ResourceUri, "referenced-by"];
+    };
+};
+
+declare function rehypeRenderAnnotations(): (tree: Root, file: any) => void;
+
+/**
+ * Simplified annotation format for remark plugin.
+ * This is NOT the W3C Annotation - it's a pre-processed format with offset/length
+ * for efficient markdown text processing.
+ */
+interface PreparedAnnotation {
+    id: string;
+    exact: string;
+    offset: number;
+    length: number;
+    type: string;
+    source: string | null;
+}
+interface RemarkAnnotationsOptions {
+    annotations: PreparedAnnotation[];
+}
+declare function remarkAnnotations(options: RemarkAnnotationsOptions): (tree: Root$1, file: VFile) => void;
+
+/**
+ * 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;
+
+type Annotation$j = components['schemas']['Annotation'];
+/**
+ * Shared logic for annotation panel components
+ *
+ * Handles:
+ * - Sorting annotations by position in the resource
+ * - Hover effects: scroll to annotation and pulse highlight
+ * - Ref management for annotation elements
+ *
+ * Used by: HighlightPanel, AssessmentPanel, CommentsPanel, ReferencesPanel
+ */
+declare function useAnnotationPanel<T extends Annotation$j>(annotations: T[], hoveredId: string | null | undefined): {
+    sortedAnnotations: T[];
+    containerRef: React$1.RefObject<HTMLDivElement>;
+    handleAnnotationRef: (id: string, el: HTMLElement | null) => void;
+};
+
+/**
+ * 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;
+
+interface DetectionProgress extends DetectionProgress$1 {
+    completedEntityTypes?: Array<{
+        entityType: string;
+        foundCount: number;
+    }>;
+}
+interface UseDetectionProgressOptions {
+    rUri: ResourceUri;
+    onComplete?: (progress: DetectionProgress) => void;
+    onError?: (error: string) => void;
+    onProgress?: (progress: DetectionProgress) => void;
+}
+declare function useDetectionProgress({ rUri, onComplete, onError, onProgress }: UseDetectionProgressOptions): {
+    isDetecting: boolean;
+    progress: DetectionProgress | null;
+    startDetection: (entityTypes: string[]) => Promise<void>;
+    cancelDetection: () => void;
+};
+
+declare function useFormattedTime(milliseconds: number | null): string | null;
+
+interface UseFormValidationOptions {
+    announceErrors?: boolean;
+}
+declare function useFormValidation(options?: UseFormValidationOptions): {
+    errors: Record<string, string>;
+    setFieldError: (field: string, message: string) => void;
+    clearFieldError: (field: string) => void;
+    clearAllErrors: () => void;
+    validateField: (field: string, value: any, rules: Record<string, (value: any) => string | null>) => boolean;
+    announceSuccess: (message: string) => void;
+    getFieldError: (field: string) => string | null;
+    hasErrors: () => boolean;
+};
+declare const validationRules: {
+    required: (message?: string) => (value: any) => string | null;
+    minLength: (min: number, message?: string) => (value: string) => string | null;
+    maxLength: (max: number, message?: string) => (value: string) => string | null;
+    email: (message?: string) => (value: string) => string | null;
+    url: (message?: string) => (value: string) => string | null;
+    pattern: (regex: RegExp, message: string) => (value: string) => string | null;
+};
+
+type GenerationProgress = GenerationProgress$1;
+interface UseGenerationProgressOptions {
+    onComplete?: (progress: GenerationProgress) => void;
+    onError?: (error: string) => void;
+    onProgress?: (progress: GenerationProgress) => void;
+}
+declare function useGenerationProgress({ onComplete, onError, onProgress }: UseGenerationProgressOptions): {
+    isGenerating: boolean;
+    progress: GenerationProgress$1 | null;
+    startGeneration: (referenceId: AnnotationUri, resourceId: ResourceUri, options: {
+        title?: string;
+        prompt?: string;
+        language?: string;
+        context: GenerationContext;
+        temperature?: number;
+        maxTokens?: number;
+    }) => Promise<void>;
+    cancelGeneration: () => void;
+    clearProgress: () => void;
+};
+
+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;
+};
+
+/**
+ * Resource event structure from the event store
+ * (Re-exported from api-client for consistency)
+ */
+type ResourceEvent = ResourceEvent$1;
+/**
+ * Stream connection status
+ */
+type StreamStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+interface UseResourceEventsOptions {
+    rUri: ResourceUri;
+    onEvent?: (event: ResourceEvent) => void;
+    onAnnotationAdded?: (event: ResourceEvent) => void;
+    onAnnotationRemoved?: (event: ResourceEvent) => void;
+    onAnnotationBodyUpdated?: (event: ResourceEvent) => void;
+    onEntityTagAdded?: (event: ResourceEvent) => void;
+    onEntityTagRemoved?: (event: ResourceEvent) => void;
+    onDocumentArchived?: (event: ResourceEvent) => void;
+    onDocumentUnarchived?: (event: ResourceEvent) => void;
+    onError?: (error: string) => void;
+    autoConnect?: boolean;
+}
+/**
+ * React hook for subscribing to real-time document events via SSE
+ *
+ * Opens a long-lived SSE connection to receive events as they happen.
+ * Automatically reconnects on disconnect (with exponential backoff).
+ *
+ * @example
+ * ```tsx
+ * const { status, connect, disconnect } = useResourceEvents({
+ *   rUri: resourceUri('http://localhost:4000/resources/doc-123'),
+ *   onAnnotationAdded: (event) => {
+ *     console.log('New annotation:', event.payload);
+ *     // Update UI to show new annotation (highlight, reference, or assessment)
+ *   },
+ *   onAnnotationBodyUpdated: (event) => {
+ *     console.log('Annotation body updated:', event.payload);
+ *     // Update annotation display to reflect body changes
+ *   }
+ * });
+ * ```
+ */
+declare function useResourceEvents({ rUri, onEvent, onAnnotationAdded, onAnnotationRemoved, onAnnotationBodyUpdated, onEntityTagAdded, onEntityTagRemoved, onDocumentArchived, onDocumentUnarchived, onError, autoConnect, }: UseResourceEventsOptions): {
+    status: StreamStatus;
+    lastEvent: ResourceEvent$1 | null;
+    eventCount: number;
+    connect: () => Promise<void>;
+    disconnect: () => void;
+    isConnected: boolean;
+};
+
+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>;
+    handleKeyDown: (event: KeyboardEvent$1) => void;
+    focusItem: (index: number) => void;
+};
+
+declare function useSessionExpiry(): {
+    timeRemaining: number | null;
+    isExpiringSoon: boolean;
+};
+
+type Theme = 'light' | 'dark' | 'system';
+declare function useTheme(): {
+    theme: Theme;
+    setTheme: (newTheme: Theme) => void;
+};
+
+type ToolbarPanelType = 'document' | 'history' | 'info' | 'annotations' | 'settings' | 'collaboration' | 'user' | 'jsonld';
+interface UseToolbarOptions {
+    /** Initial panel to show (default: null) */
+    initialPanel?: ToolbarPanelType | null;
+    /** Whether to persist active panel to localStorage (default: false) */
+    persistToStorage?: boolean;
+    /** Storage key for persistence (default: 'activeToolbarPanel') */
+    storageKey?: string;
+}
+declare function useToolbar(options?: UseToolbarOptions): {
+    activePanel: ToolbarPanelType | null;
+    togglePanel: (panel: ToolbarPanelType) => void;
+    setActivePanel: React$1.Dispatch<React$1.SetStateAction<ToolbarPanelType | null>>;
+};
+
+/**
+ * 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>;
+};
+/**
+ * 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 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
+ * // In app (apps/frontend/src/hooks/useAnnotationManager.ts)
+ * function useAnnotationManager(): AnnotationManager {
+ *   const annotations = useAnnotations();
+ *   const createMutation = annotations.create.useMutation();
+ *   const deleteMutation = annotations.delete.useMutation();
+ *
+ *   return {
+ *     createAnnotation: async (params) => {
+ *       const result = await createMutation.mutateAsync({
+ *         rUri: params.rUri,
+ *         data: { motivation: params.motivation, target: { source: params.rUri, selector: params.selector }, body: params.body }
+ *       });
+ *       return result.annotation;
+ *     },
+ *     deleteAnnotation: async (params) => {
+ *       const annotationIdSegment = params.annotationId.split('/').pop() || params.annotationId;
+ *       await deleteMutation.mutateAsync(resourceAnnotationUri(`${params.rUri}/annotations/${annotationIdSegment}`));
+ *     }
+ *   };
+ * }
+ *
+ * // In app layout
+ * const annotationManager = useAnnotationManager();
+ * <AnnotationProvider annotationManager={annotationManager}>
+ *   <YourComponents />
+ * </AnnotationProvider>
+ * ```
+ */
+declare function AnnotationProvider({ annotationManager, children }: AnnotationProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access the AnnotationManager
+ *
+ * @throws Error if used outside AnnotationProvider
+ * @returns AnnotationManager instance
+ */
+declare function useAnnotationManager(): AnnotationManager;
+
+interface AnnotationUIContextType {
+    newAnnotationIds: Set<string>;
+    clearNewAnnotationId: (id: AnnotationUri) => void;
+    triggerSparkleAnimation: (annotationId: string) => void;
+}
+interface AnnotationUIProviderProps {
+    children: React__default.ReactNode;
+}
+/**
+ * Annotation UI Provider
+ *
+ * Manages UI-only state for annotation interactions (sparkle animations).
+ * This is NOT part of the Provider Pattern - it's internal react-ui state management.
+ *
+ * Usage:
+ * ```typescript
+ * <AnnotationUIProvider>
+ *   <ResourceViewer ... />
+ * </AnnotationUIProvider>
+ * ```
+ */
+declare function AnnotationUIProvider({ children }: AnnotationUIProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access annotation UI state
+ *
+ * @throws Error if used outside AnnotationUIProvider
+ * @returns AnnotationUI context
+ */
+declare function useAnnotationUI(): AnnotationUIContextType;
+
+interface ApiClientProviderProps {
+    apiClientManager: ApiClientManager;
+    children: ReactNode;
+}
+/**
+ * Provider for API client management
+ * Apps must provide an ApiClientManager implementation
+ */
+declare function ApiClientProvider({ apiClientManager, children, }: ApiClientProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access the API client
+ * Must be used within an ApiClientProvider
+ * @returns API client instance (null if not authenticated)
+ */
+declare function useApiClient(): _semiont_api_client.SemiontApiClient | null;
+
+interface CacheProviderProps {
+    cacheManager: CacheManager;
+    children: React__default.ReactNode;
+}
+/**
+ * Cache Provider
+ *
+ * Provides cache invalidation capabilities via the Provider Pattern.
+ * Apps inject their own CacheManager implementation.
+ *
+ * Example usage:
+ * ```typescript
+ * // In app (apps/frontend/src/hooks/useCacheManager.ts)
+ * function useCacheManager(): CacheManager {
+ *   const queryClient = useQueryClient();
+ *
+ *   return {
+ *     invalidateAnnotations: (rUri) => {
+ *       queryClient.invalidateQueries({ queryKey: ['annotations', rUri] });
+ *     },
+ *     invalidateEvents: (rUri) => {
+ *       queryClient.invalidateQueries({ queryKey: ['documents', 'events', rUri] });
+ *     }
+ *   };
+ * }
+ *
+ * // In app layout
+ * const cacheManager = useCacheManager();
+ * <CacheProvider cacheManager={cacheManager}>
+ *   <YourComponents />
+ * </CacheProvider>
+ * ```
+ */
+declare function CacheProvider({ cacheManager, children }: CacheProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access the CacheManager
+ *
+ * @throws Error if used outside CacheProvider
+ * @returns CacheManager instance
+ */
+declare function useCacheManager(): CacheManager;
+
+/**
+ * Provider Pattern: Accepts OpenResourcesManager implementation as prop
+ * and makes it available to child components via Context.
+ *
+ * Apps provide their own implementation (localStorage, sessionStorage, database, etc.)
+ * and pass it to this provider at the root level.
+ *
+ * @example
+ * ```tsx
+ * // In app root
+ * const openResourcesManager = useOpenResourcesManager(); // App's implementation
+ *
+ * <OpenResourcesProvider openResourcesManager={openResourcesManager}>
+ *   <App />
+ * </OpenResourcesProvider>
+ * ```
+ */
+declare function OpenResourcesProvider({ openResourcesManager, children }: {
+    openResourcesManager: OpenResourcesManager;
+    children: React__default.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access OpenResourcesManager from Context
+ * Components use this hook to access open resources functionality
+ */
+declare function useOpenResources(): OpenResourcesManager;
+
+type Annotation$i = components['schemas']['Annotation'];
+interface SelectionData {
+    exact: string;
+    start: number;
+    end: number;
+}
+interface ResourceAnnotationsContextType {
+    newAnnotationIds: Set<string>;
+    createAnnotation: (rUri: ResourceUri, motivation: 'highlighting' | 'linking' | 'assessing' | 'commenting' | 'tagging', selector: Selector | Selector[], body?: any[]) => Promise<Annotation$i | undefined>;
+    deleteAnnotation: (annotationId: string, rUri: ResourceUri) => Promise<void>;
+    clearNewAnnotationId: (id: AnnotationUri) => void;
+    triggerSparkleAnimation: (annotationId: string) => void;
+}
+declare function ResourceAnnotationsProvider({ children }: {
+    children: React__default.ReactNode;
+}): react_jsx_runtime.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;
+}
+
+/**
+ * Provider Pattern: Accepts SessionManager implementation as prop
+ * and makes it available to child components via Context.
+ *
+ * Apps provide their own implementation (next-auth, custom auth, etc.)
+ * and pass it to this provider at the root level.
+ *
+ * @example
+ * ```tsx
+ * // In app root
+ * const sessionManager = useSessionManager(); // App's implementation
+ *
+ * <SessionProvider sessionManager={sessionManager}>
+ *   <App />
+ * </SessionProvider>
+ * ```
+ */
+declare function SessionProvider({ sessionManager, children }: {
+    sessionManager: SessionManager;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access SessionManager from Context
+ * Components use this hook to access session state and expiry information
+ */
+declare function useSessionContext(): SessionManager;
+
+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_jsx_runtime.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;
+};
+
+type Annotation$h = components['schemas']['Annotation'];
+interface TextSegment {
+    exact: string;
+    annotation?: Annotation$h;
+    start: number;
+    end: number;
+}
+interface Props$b {
+    content: string;
+    segments: TextSegment[];
+    onAnnotationClick?: (annotation: Annotation$h) => void;
+    onAnnotationHover?: (annotationId: string | null) => void;
+    onTextSelect?: (exact: string, position: {
+        start: number;
+        end: number;
+    }) => void;
+    onChange?: (content: string) => void;
+    editable?: boolean;
+    newAnnotationIds?: Set<string>;
+    hoveredAnnotationId?: string | null;
+    hoveredCommentId?: string | null;
+    scrollToAnnotationId?: string | null;
+    sourceView?: boolean;
+    showLineNumbers?: boolean;
+    enableWidgets?: boolean;
+    onEntityTypeClick?: (entityType: string) => void;
+    onReferenceNavigate?: (documentId: string) => void;
+    onUnresolvedReferenceClick?: (annotation: Annotation$h) => void;
+    getTargetDocumentName?: (documentId: string) => string | undefined;
+    generatingReferenceId?: string | null;
+    onDeleteAnnotation?: (annotation: Annotation$h) => void;
+}
+declare function CodeMirrorRenderer({ content, segments, onAnnotationClick, onAnnotationHover, onTextSelect, onChange, editable, newAnnotationIds, hoveredAnnotationId, hoveredCommentId, scrollToAnnotationId, sourceView, showLineNumbers, enableWidgets, onEntityTypeClick, onReferenceNavigate, onUnresolvedReferenceClick, getTargetDocumentName, generatingReferenceId, onDeleteAnnotation }: Props$b): react_jsx_runtime.JSX.Element;
+
+interface DetectionProgressWidgetProps {
+    progress: DetectionProgress | null;
+    onCancel?: () => void;
+}
+declare function DetectionProgressWidget({ progress, onCancel }: DetectionProgressWidgetProps): react_jsx_runtime.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;
+    errorInfo: ErrorInfo | 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 | boolean | Iterable<React__default.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;
+}
+/**
+ * Specialized error boundary for async components
+ */
+declare function AsyncErrorBoundary({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+type Annotation$g = components['schemas']['Annotation'];
+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_jsx_runtime.JSX.Element;
+declare function useSearchAnnouncements(): {
+    announceSearchResults: (count: number, query: string) => void;
+    announceSearching: () => void;
+};
+declare function useDocumentAnnouncements(): {
+    announceDocumentSaved: () => void;
+    announceDocumentDeleted: () => void;
+    announceAnnotationCreated: (annotation: Annotation$g) => void;
+    announceAnnotationDeleted: () => void;
+    announceError: (message: string) => void;
+};
+
+interface ResourceTagsInlineProps {
+    documentId: string;
+    tags: string[];
+    isEditing: boolean;
+    onUpdate: (tags: string[]) => Promise<void>;
+    disabled?: boolean;
+}
+declare function ResourceTagsInline({ documentId, tags, isEditing, onUpdate, disabled }: ResourceTagsInlineProps): react_jsx_runtime.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_jsx_runtime.JSX.Element;
+declare function useToast(): ToastContextType;
+
+type ToolbarContext = 'document' | 'simple';
+interface Props$9<T extends string = string> {
+    context: ToolbarContext;
+    activePanel: T | null;
+    onPanelToggle: (panel: T) => void;
+    isArchived?: boolean;
+}
+declare function Toolbar<T extends string = string>({ context, activePanel, onPanelToggle, isArchived }: Props$9<T>): react_jsx_runtime.JSX.Element;
+
+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;
+    onSelectionChange: (motivation: SelectionMotivation | null) => void;
+    onClickChange: (motivation: ClickAction) => void;
+    showSelectionGroup?: boolean;
+    showDeleteButton?: boolean;
+    showShapeGroup?: boolean;
+    selectedShape?: ShapeType;
+    onShapeChange?: (shape: ShapeType) => void;
+    annotateMode: boolean;
+    onAnnotateModeToggle: () => void;
+}
+declare function AnnotateToolbar({ selectedMotivation, selectedClick, onSelectionChange, onClickChange, showSelectionGroup, showDeleteButton, showShapeGroup, selectedShape, onShapeChange, annotateMode, onAnnotateModeToggle }: AnnotateToolbarProps): react_jsx_runtime.JSX.Element;
+
+type Annotation$f = components['schemas']['Annotation'];
+interface JsonLdViewProps {
+    annotation: Annotation$f;
+    onBack: () => void;
+}
+declare function JsonLdView({ annotation, onBack }: JsonLdViewProps): react_jsx_runtime.JSX.Element;
+
+interface SelectedTextDisplayProps {
+    exact: string;
+}
+declare function SelectedTextDisplay({ exact }: SelectedTextDisplayProps): react_jsx_runtime.JSX.Element;
+interface EntityTypeBadgesProps {
+    entityTypes: string;
+}
+declare function EntityTypeBadges({ entityTypes }: EntityTypeBadgesProps): react_jsx_runtime.JSX.Element | null;
+interface PopupHeaderProps {
+    title: string;
+    selectedText?: string;
+    onClose: () => void;
+}
+declare function PopupHeader({ title, selectedText, onClose }: PopupHeaderProps): react_jsx_runtime.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_jsx_runtime.JSX.Element;
+
+type Annotation$e = components['schemas']['Annotation'];
+interface AnnotationOverlayProps {
+    annotations: Annotation$e[];
+    imageWidth: number;
+    imageHeight: number;
+    displayWidth: number;
+    displayHeight: number;
+    onAnnotationClick?: (annotation: Annotation$e) => void;
+    onAnnotationHover?: (annotationId: string | null) => void;
+    hoveredAnnotationId?: string | null;
+    selectedAnnotationId?: string | null;
+}
+/**
+ * Render annotation overlay - displays existing annotations as SVG shapes
+ */
+declare function AnnotationOverlay({ annotations, imageWidth, imageHeight, displayWidth, displayHeight, onAnnotationClick, onAnnotationHover, hoveredAnnotationId, selectedAnnotationId }: AnnotationOverlayProps): react_jsx_runtime.JSX.Element;
+
+type Annotation$d = components['schemas']['Annotation'];
+type DrawingMode = 'rectangle' | 'polygon' | 'circle' | 'freeform' | null;
+interface SvgDrawingCanvasProps {
+    resourceUri: ResourceUri;
+    existingAnnotations?: Annotation$d[];
+    drawingMode: DrawingMode;
+    selectedMotivation?: SelectionMotivation | null;
+    onAnnotationCreate?: (svg: string, position?: {
+        x: number;
+        y: number;
+    }) => void;
+    onAnnotationClick?: (annotation: Annotation$d) => void;
+    onAnnotationHover?: (annotationId: string | null) => void;
+    hoveredAnnotationId?: string | null;
+    selectedAnnotationId?: string | null;
+}
+declare function SvgDrawingCanvas({ resourceUri, existingAnnotations, drawingMode, selectedMotivation, onAnnotationCreate, onAnnotationClick, onAnnotationHover, hoveredAnnotationId, selectedAnnotationId }: SvgDrawingCanvasProps): react_jsx_runtime.JSX.Element;
+
+interface KeyboardShortcutsHelpModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+}
+declare function KeyboardShortcutsHelpModal({ isOpen, onClose }: KeyboardShortcutsHelpModalProps): react_jsx_runtime.JSX.Element;
+
+interface ProposeEntitiesModalProps {
+    isOpen: boolean;
+    onConfirm: (selectedTypes: string[]) => void;
+    onCancel: () => void;
+}
+declare function ProposeEntitiesModal({ isOpen, onConfirm, onCancel }: ProposeEntitiesModalProps): react_jsx_runtime.JSX.Element;
+
+type Annotation$c = components['schemas']['Annotation'];
+
+interface Props$8 {
+    content: string;
+    mimeType?: string;
+    resourceUri?: string;
+    annotations: AnnotationsCollection;
+    handlers?: AnnotationHandlers;
+    creationHandler?: AnnotationCreationHandler;
+    uiState: AnnotationUIState;
+    onUIStateChange?: (state: Partial<AnnotationUIState>) => void;
+    editable?: boolean;
+    enableWidgets?: boolean;
+    onEntityTypeClick?: (entityType: string) => void;
+    onReferenceNavigate?: (documentId: string) => void;
+    onUnresolvedReferenceClick?: (annotation: Annotation$c) => void;
+    getTargetDocumentName?: (documentId: string) => string | undefined;
+    generatingReferenceId?: string | null;
+    onDeleteAnnotation?: (annotation: Annotation$c) => void;
+    showLineNumbers?: boolean;
+    annotateMode: boolean;
+    onAnnotateModeToggle: () => void;
+}
+declare function AnnotateView({ content, mimeType, resourceUri, annotations, handlers, creationHandler, uiState, onUIStateChange, editable, enableWidgets, onEntityTypeClick, onReferenceNavigate, onUnresolvedReferenceClick, getTargetDocumentName, generatingReferenceId, onDeleteAnnotation, showLineNumbers, annotateMode, onAnnotateModeToggle }: Props$8): react_jsx_runtime.JSX.Element;
+
+interface Props$7 {
+    rUri: ResourceUri;
+    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_jsx_runtime.JSX.Element | null;
+
+interface Props$6 {
+    content: string;
+    mimeType: string;
+    resourceUri: string;
+    annotations: AnnotationsCollection;
+    handlers?: AnnotationHandlers;
+    hoveredAnnotationId?: string | null;
+    hoveredCommentId?: string | null;
+    selectedClick?: ClickAction;
+    onClickChange?: (motivation: ClickAction) => void;
+    annotateMode: boolean;
+    onAnnotateModeToggle: () => void;
+}
+declare function BrowseView({ content, mimeType, resourceUri, annotations, handlers, hoveredAnnotationId, hoveredCommentId, selectedClick, onClickChange, annotateMode, onAnnotateModeToggle }: Props$6): react_jsx_runtime.JSX.Element;
+
+type TranslateFn$4 = (key: string, params?: Record<string, string | number>) => string;
+interface Props$5 {
+    event: StoredEvent;
+    annotations: any[];
+    allEvents: StoredEvent[];
+    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_jsx_runtime.JSX.Element;
+
+type SemiontResource$1 = components['schemas']['ResourceDescriptor'];
+interface Props$4 {
+    resource: SemiontResource$1 & {
+        content: string;
+    };
+    annotations: AnnotationsCollection;
+    onRefetchAnnotations?: () => void;
+    annotateMode: boolean;
+    onAnnotateModeToggle: () => void;
+    generatingReferenceId?: string | null;
+    onAnnotationHover?: (annotationId: string | null) => void;
+    onCommentHover?: (commentId: string | null) => void;
+    hoveredAnnotationId?: string | null;
+    hoveredCommentId?: string | null;
+    scrollToAnnotationId?: string | null;
+    showLineNumbers?: boolean;
+    onCommentCreationRequested?: (selection: {
+        exact: string;
+        start: number;
+        end: number;
+    }) => void;
+    onTagCreationRequested?: (selection: {
+        exact: string;
+        start: number;
+        end: number;
+    }) => void;
+    onReferenceCreationRequested?: (selection: {
+        exact: string;
+        start: number;
+        end: number;
+        prefix?: string;
+        suffix?: string;
+        svgSelector?: string;
+    }) => void;
+    onCommentClick?: (commentId: string) => void;
+    onReferenceClick?: (referenceId: string) => void;
+    onHighlightClick?: (highlightId: string) => void;
+    onAssessmentClick?: (assessmentId: string) => void;
+    onTagClick?: (tagId: string) => void;
+}
+declare function ResourceViewer({ resource, annotations, onRefetchAnnotations, annotateMode, onAnnotateModeToggle, generatingReferenceId, onAnnotationHover, onCommentHover, hoveredAnnotationId, hoveredCommentId, scrollToAnnotationId, showLineNumbers, onCommentCreationRequested, onTagCreationRequested, onReferenceCreationRequested, onCommentClick, onReferenceClick, onHighlightClick, onAssessmentClick, onTagClick }: Props$4): react_jsx_runtime.JSX.Element;
+
+type Annotation$b = components['schemas']['Annotation'];
+interface AssessmentEntryProps {
+    assessment: Annotation$b;
+    isFocused: boolean;
+    onClick: () => void;
+    onAssessmentRef: (assessmentId: string, el: HTMLElement | null) => void;
+    onAssessmentHover?: (assessmentId: string | null) => void;
+}
+declare function AssessmentEntry({ assessment, isFocused, onClick, onAssessmentRef, onAssessmentHover, }: AssessmentEntryProps): react_jsx_runtime.JSX.Element;
+
+type Annotation$a = components['schemas']['Annotation'];
+interface AssessmentPanelProps {
+    annotations: Annotation$a[];
+    onAnnotationClick: (annotation: Annotation$a) => void;
+    focusedAnnotationId: string | null;
+    hoveredAnnotationId?: string | null;
+    onAnnotationHover?: (annotationId: string | null) => void;
+    onDetect?: (instructions?: string) => void | Promise<void>;
+    isDetecting?: boolean;
+    detectionProgress?: {
+        status: string;
+        percentage?: number;
+        message?: string;
+    } | null;
+    annotateMode?: boolean;
+}
+declare function AssessmentPanel({ annotations, onAnnotationClick, focusedAnnotationId, hoveredAnnotationId, onAnnotationHover, onDetect, isDetecting, detectionProgress, annotateMode, }: AssessmentPanelProps): react_jsx_runtime.JSX.Element;
+
+interface Props$3 {
+    isConnected: boolean;
+    eventCount: number;
+    lastEventTimestamp?: string;
+}
+declare function CollaborationPanel({ isConnected, eventCount, lastEventTimestamp }: Props$3): react_jsx_runtime.JSX.Element;
+
+type Annotation$9 = components['schemas']['Annotation'];
+interface CommentEntryProps {
+    comment: Annotation$9;
+    isFocused: boolean;
+    onClick: () => void;
+    onUpdate: (newText: string) => void;
+    onCommentRef: (commentId: string, el: HTMLElement | null) => void;
+    onCommentHover?: (commentId: string | null) => void;
+    annotateMode?: boolean;
+}
+declare function CommentEntry({ comment, isFocused, onClick, onUpdate, onCommentRef, onCommentHover, annotateMode, }: CommentEntryProps): react_jsx_runtime.JSX.Element;
+
+type Annotation$8 = components['schemas']['Annotation'];
+interface CommentsPanelProps {
+    annotations: Annotation$8[];
+    onAnnotationClick: (annotation: Annotation$8) => void;
+    onUpdate: (annotationId: string, newText: string) => void;
+    onCreate?: (commentText: string) => void;
+    focusedAnnotationId: string | null;
+    hoveredAnnotationId?: string | null;
+    onAnnotationHover?: (annotationId: string | null) => void;
+    pendingSelection?: {
+        exact: string;
+        start: number;
+        end: number;
+    } | null;
+    annotateMode?: boolean;
+    onDetect?: (instructions?: string, tone?: string) => void | Promise<void>;
+    isDetecting?: boolean;
+    detectionProgress?: {
+        status: string;
+        percentage?: number;
+        message?: string;
+    } | null;
+}
+declare function CommentsPanel({ annotations, onAnnotationClick, onUpdate, onCreate, focusedAnnotationId, hoveredAnnotationId, onAnnotationHover, pendingSelection, annotateMode, onDetect, isDetecting, detectionProgress, }: CommentsPanelProps): react_jsx_runtime.JSX.Element;
+
+interface DetectSectionProps {
+    annotationType: 'highlight' | 'assessment' | 'comment';
+    isDetecting: boolean;
+    detectionProgress?: {
+        status: string;
+        percentage?: number;
+        message?: string;
+        requestParams?: Array<{
+            label: string;
+            value: string;
+        }>;
+    } | null | undefined;
+    onDetect: (instructions?: string, tone?: string, density?: number) => void | Promise<void>;
+}
+/**
+ * Shared detect section for Highlight, Assessment, and Comment panels
+ *
+ * Provides:
+ * - Optional instructions textarea
+ * - Optional tone selector (for comments)
+ * - Detect button with sparkle animation
+ * - Progress display during detection
+ */
+declare function DetectSection({ annotationType, isDetecting, detectionProgress, onDetect }: DetectSectionProps): react_jsx_runtime.JSX.Element;
+
+type Annotation$7 = components['schemas']['Annotation'];
+interface HighlightEntryProps {
+    highlight: Annotation$7;
+    isFocused: boolean;
+    onClick: () => void;
+    onHighlightRef: (highlightId: string, el: HTMLElement | null) => void;
+    onHighlightHover?: (highlightId: string | null) => void;
+}
+declare function HighlightEntry({ highlight, isFocused, onClick, onHighlightRef, onHighlightHover, }: HighlightEntryProps): react_jsx_runtime.JSX.Element;
+
+type Annotation$6 = components['schemas']['Annotation'];
+interface HighlightPanelProps {
+    annotations: Annotation$6[];
+    onAnnotationClick: (annotation: Annotation$6) => void;
+    focusedAnnotationId: string | null;
+    hoveredAnnotationId?: string | null;
+    onAnnotationHover?: (annotationId: string | null) => void;
+    onDetect?: (instructions?: string) => void | Promise<void>;
+    isDetecting?: boolean;
+    detectionProgress?: {
+        status: string;
+        percentage?: number;
+        message?: string;
+    } | null;
+    annotateMode?: boolean;
+}
+declare function HighlightPanel({ annotations, onAnnotationClick, focusedAnnotationId, hoveredAnnotationId, onAnnotationHover, onDetect, isDetecting, detectionProgress, annotateMode, }: HighlightPanelProps): react_jsx_runtime.JSX.Element;
+
+type SemiontResource = components['schemas']['ResourceDescriptor'];
+interface Props$2 {
+    resource: SemiontResource;
+}
+declare function JsonLdPanel({ resource: semiontResource }: Props$2): react_jsx_runtime.JSX.Element;
+
+interface PanelHeaderProps {
+    annotationType: keyof typeof ANNOTATORS;
+    count: number;
+    title: string;
+}
+/**
+ * Shared header for annotation panels
+ *
+ * Displays the annotation icon, translated title, and count in a consistent format
+ */
+declare function PanelHeader({ annotationType, count, title }: PanelHeaderProps): react_jsx_runtime.JSX.Element;
+
+type Annotation$5 = components['schemas']['Annotation'];
+interface ReferenceEntryProps {
+    reference: Annotation$5;
+    isFocused: boolean;
+    onClick: () => void;
+    routes: RouteBuilder;
+    onReferenceRef: (referenceId: string, el: HTMLElement | null) => void;
+    onReferenceHover?: (referenceId: string | null) => void;
+    onGenerateDocument?: (referenceId: string, options: {
+        title: string;
+        prompt?: string;
+    }) => void;
+    onSearchDocuments?: (referenceId: string, searchTerm: string) => void;
+    onUpdateReference?: (referenceId: string, updates: Partial<Annotation$5>) => void;
+    annotateMode?: boolean;
+}
+declare function ReferenceEntry({ reference, isFocused, onClick, routes, onReferenceRef, onReferenceHover, onGenerateDocument, onSearchDocuments, onUpdateReference, annotateMode, }: ReferenceEntryProps): react_jsx_runtime.JSX.Element;
+
+type Annotation$4 = components['schemas']['Annotation'];
+type ResponseContent<T> = T extends {
+    responses: {
+        200: {
+            content: {
+                'application/json': infer R;
+            };
+        };
+    };
+} ? R : never;
+type ReferencedBy = ResponseContent<paths['/resources/{id}/referenced-by']['get']>['referencedBy'][number];
+interface Props$1 {
+    annotations?: Annotation$4[];
+    onAnnotationClick?: (annotation: Annotation$4) => void;
+    focusedAnnotationId?: string | null;
+    hoveredAnnotationId?: string | null;
+    onAnnotationHover?: (annotationId: string | null) => void;
+    onDetect: (selectedTypes: string[], includeDescriptiveReferences?: boolean) => void;
+    onCreate?: (entityType?: string) => void;
+    isDetecting: boolean;
+    detectionProgress: any;
+    annotateMode?: boolean;
+    Link: React__default.ComponentType<LinkComponentProps>;
+    routes: RouteBuilder;
+    allEntityTypes: string[];
+    onCancelDetection: () => void;
+    onSearchDocuments?: (referenceId: string, searchTerm: string) => void;
+    onUpdate?: (referenceId: string, updates: Partial<Annotation$4>) => void;
+    onGenerateDocument?: (referenceId: string, options: {
+        title: string;
+        prompt?: string;
+    }) => void;
+    mediaType?: string | undefined;
+    referencedBy?: ReferencedBy[];
+    referencedByLoading?: boolean;
+    pendingSelection?: {
+        exact: string;
+        start: number;
+        end: number;
+        prefix?: string;
+        suffix?: string;
+        svgSelector?: string;
+    } | null;
+}
+declare function ReferencesPanel({ annotations, onAnnotationClick, focusedAnnotationId, hoveredAnnotationId, onAnnotationHover, onDetect, onCreate, isDetecting, detectionProgress, annotateMode, Link, routes, allEntityTypes, onCancelDetection, onSearchDocuments, onUpdate, onGenerateDocument, mediaType, referencedBy, referencedByLoading, pendingSelection, }: Props$1): react_jsx_runtime.JSX.Element;
+
+interface Props {
+    documentEntityTypes: string[];
+    documentLocale?: string | undefined;
+    primaryMediaType?: string | undefined;
+    primaryByteSize?: number | undefined;
+    isArchived?: boolean;
+    onArchive?: () => void;
+    onUnarchive?: () => void;
+    onClone?: () => void;
+}
+declare function ResourceInfoPanel({ documentEntityTypes, documentLocale, primaryMediaType, primaryByteSize, isArchived, onArchive, onUnarchive, onClone }: Props): react_jsx_runtime.JSX.Element;
+
+type Annotation$3 = components['schemas']['Annotation'];
+interface StatisticsPanelProps {
+    highlights: Annotation$3[];
+    comments: Annotation$3[];
+    assessments: Annotation$3[];
+    references: Annotation$3[];
+    tags: Annotation$3[];
+}
+declare function StatisticsPanel({ highlights, comments, assessments, references, tags }: StatisticsPanelProps): react_jsx_runtime.JSX.Element;
+
+type Annotation$2 = components['schemas']['Annotation'];
+interface TagEntryProps {
+    tag: Annotation$2;
+    isFocused: boolean;
+    onClick: () => void;
+    onTagRef: (tagId: string, el: HTMLElement | null) => void;
+    onTagHover?: (tagId: string | null) => void;
+}
+declare function TagEntry({ tag, isFocused, onClick, onTagRef, onTagHover, }: TagEntryProps): react_jsx_runtime.JSX.Element;
+
+type Annotation$1 = components['schemas']['Annotation'];
+interface TaggingPanelProps {
+    annotations: Annotation$1[];
+    onAnnotationClick: (annotation: Annotation$1) => void;
+    focusedAnnotationId: string | null;
+    hoveredAnnotationId?: string | null;
+    onAnnotationHover?: (annotationId: string | null) => void;
+    annotateMode?: boolean;
+    onDetect?: (schemaId: string, categories: string[]) => void | Promise<void>;
+    onCreate?: (selection: {
+        exact: string;
+        start: number;
+        end: number;
+    }, schemaId: string, category: string) => void | Promise<void>;
+    isDetecting?: boolean;
+    detectionProgress?: {
+        status: string;
+        percentage?: number;
+        currentCategory?: string;
+        processedCategories?: number;
+        totalCategories?: number;
+        message?: string;
+        requestParams?: Array<{
+            label: string;
+            value: string;
+        }>;
+    } | null;
+    pendingSelection?: {
+        exact: string;
+        start: number;
+        end: number;
+    } | null;
+}
+declare function TaggingPanel({ annotations, onAnnotationClick, focusedAnnotationId, hoveredAnnotationId, onAnnotationHover, annotateMode, onDetect, onCreate, isDetecting, detectionProgress, pendingSelection }: TaggingPanelProps): react_jsx_runtime.JSX.Element;
+
+type Annotation = components['schemas']['Annotation'];
+type Motivation = components['schemas']['Motivation'];
+type AnnotatorKey = keyof typeof ANNOTATORS;
+type TabKey = 'statistics' | AnnotatorKey;
+/**
+ * Simplified UnifiedAnnotationsPanel using Annotator abstraction
+ *
+ * Key simplifications:
+ * - Single annotations array (grouped internally by motivation)
+ * - Single focusedAnnotationId (motivation-agnostic)
+ * - Single hoveredAnnotationId (motivation-agnostic)
+ * - Annotators contain handlers (no explosion of onXClick, onXHover props)
+ */
+interface UnifiedAnnotationsPanelProps {
+    annotations: Annotation[];
+    annotators: Record<string, Annotator>;
+    focusedAnnotationId: string | null;
+    hoveredAnnotationId?: string | null;
+    annotateMode?: boolean;
+    detectingMotivation?: Motivation | null;
+    detectionProgress?: {
+        status: string;
+        percentage?: number;
+        message?: string;
+        currentCategory?: string;
+        processedCategories?: number;
+        totalCategories?: number;
+    } | null;
+    pendingCommentSelection?: {
+        exact: string;
+        start: number;
+        end: number;
+    } | null;
+    pendingTagSelection?: {
+        exact: string;
+        start: number;
+        end: number;
+    } | null;
+    pendingReferenceSelection?: {
+        exact: string;
+        start: number;
+        end: number;
+        prefix?: string;
+        suffix?: string;
+        svgSelector?: string;
+    } | null;
+    allEntityTypes?: string[];
+    generatingReferenceId?: string | null;
+    onGenerateDocument?: (referenceId: string, options: {
+        title: string;
+        prompt?: string;
+    }) => void;
+    onSearchDocuments?: (referenceId: string, searchTerm: string) => void;
+    onUpdateReference?: (referenceId: string, updates: Partial<Annotation>) => void;
+    onCancelDetection?: () => void;
+    mediaType?: string;
+    referencedBy?: any[];
+    referencedByLoading?: boolean;
+    resourceId?: string;
+    initialTab?: TabKey;
+    Link: React__default.ComponentType<LinkComponentProps>;
+    routes: RouteBuilder;
+}
+declare function UnifiedAnnotationsPanel(props: UnifiedAnnotationsPanelProps): react_jsx_runtime.JSX.Element;
+
+interface ImageViewerProps {
+    resourceUri: ResourceUri;
+    mimeType: string;
+    alt?: string;
+}
+declare function ImageViewer({ resourceUri, mimeType, alt }: ImageViewerProps): react_jsx_runtime.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;
+    apiDocsUrl?: string;
+    sourceCodeUrl?: string;
+}
+declare function Footer({ Link, routes, t, CookiePreferences, onOpenKeyboardHelp, apiDocsUrl, sourceCodeUrl }: FooterProps): react_jsx_runtime.JSX.Element;
+
+type TranslateFn$2 = (key: string, params?: Record<string, any>) => string;
+interface NavigationMenuProps {
+    Link: React__default.ComponentType<LinkComponentProps>;
+    routes: RouteBuilder;
+    t: TranslateFn$2;
+    isAdmin?: boolean;
+    isModerator?: boolean;
+    brandingLink?: string;
+    onItemClick?: () => void;
+    className?: string;
+}
+declare function NavigationMenu({ Link, routes, t, isAdmin, isModerator, brandingLink, onItemClick, className }: NavigationMenuProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * 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_jsx_runtime.JSX.Element;
+
+interface StatusDisplayProps {
+    isFullyAuthenticated?: boolean;
+    isAuthenticated?: boolean;
+    hasValidBackendToken?: boolean;
+}
+declare function StatusDisplay({ isFullyAuthenticated, isAuthenticated, hasValidBackendToken }: StatusDisplayProps): react_jsx_runtime.JSX.Element;
+
+declare function SessionTimer(): react_jsx_runtime.JSX.Element | null;
+
+declare function SessionExpiryBanner(): react_jsx_runtime.JSX.Element | null;
+
+declare function UserMenuSkeleton(): react_jsx_runtime.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_jsx_runtime.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;
+}
+declare function UnifiedHeader({ Link, routes, t, tHome, showBranding, showAuthLinks, brandingLink, variant, isAuthenticated, isAdmin, isModerator }: UnifiedHeaderProps): react_jsx_runtime.JSX.Element;
+
+interface LeftSidebarProps {
+    Link: React__default.ComponentType<LinkComponentProps>;
+    routes: RouteBuilder;
+    t: TranslateFn;
+    tHome: TranslateFn;
+    children: React__default.ReactNode | ((isCollapsed: boolean, toggleCollapsed: () => void) => React__default.ReactNode);
+    brandingLink?: string;
+    collapsible?: boolean;
+    storageKey?: string;
+    isAuthenticated?: boolean;
+    isAdmin?: boolean;
+    isModerator?: boolean;
+}
+declare function LeftSidebar({ Link, routes, t, tHome, children, brandingLink, collapsible, storageKey, isAuthenticated, isAdmin, isModerator }: LeftSidebarProps): react_jsx_runtime.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_jsx_runtime.JSX.Element;
+
+/**
+ * ComposeLoadingState Component
+ *
+ * Simple loading state display for the compose page.
+ */
+interface ComposeLoadingStateProps {
+    message: string;
+}
+declare function ComposeLoadingState({ message }: ComposeLoadingStateProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * ResourceLoadingState - Loading state component for resource viewer
+ *
+ * Pure React component - no Next.js dependencies.
+ */
+declare function ResourceLoadingState(): react_jsx_runtime.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_jsx_runtime.JSX.Element;
+
+interface DevOpsFeature {
+    title: string;
+    description: string;
+    icon: React__default.ComponentType<any>;
+    available: string;
+}
+interface AdminDevOpsPageProps {
+    suggestedFeatures: DevOpsFeature[];
+    theme: 'light' | 'dark' | 'system';
+    onThemeChange: (theme: 'light' | 'dark' | 'system') => void;
+    showLineNumbers: boolean;
+    onLineNumbersToggle: () => void;
+    activePanel: string | null;
+    onPanelToggle: (panel: string | null) => void;
+    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, onThemeChange, showLineNumbers, onLineNumbersToggle, activePanel, onPanelToggle, translations: t, StatusDisplay, ToolbarPanels, Toolbar, }: AdminDevOpsPageProps): react_jsx_runtime.JSX.Element;
+
+interface OAuthProvider {
+    name: string;
+    clientId?: string;
+}
+interface AdminSecurityPageProps {
+    providers: OAuthProvider[];
+    allowedDomains: string[];
+    isLoading: boolean;
+    theme: 'light' | 'dark' | 'system';
+    onThemeChange: (theme: 'light' | 'dark' | 'system') => void;
+    showLineNumbers: boolean;
+    onLineNumbersToggle: () => void;
+    activePanel: string | null;
+    onPanelToggle: (panel: string | null) => void;
+    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, onThemeChange, showLineNumbers, onLineNumbersToggle, activePanel, onPanelToggle, translations: t, ToolbarPanels, Toolbar, }: AdminSecurityPageProps): react_jsx_runtime.JSX.Element;
+
+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';
+    onThemeChange: (theme: 'light' | 'dark' | 'system') => void;
+    showLineNumbers: boolean;
+    onLineNumbersToggle: () => void;
+    activePanel: string | null;
+    onPanelToggle: (panel: string | null) => void;
+    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, onThemeChange, showLineNumbers, onLineNumbersToggle, activePanel, onPanelToggle, translations: t, ToolbarPanels, Toolbar, buttonStyles, }: AdminUsersPageProps): react_jsx_runtime.JSX.Element;
+
+interface SignInFormProps {
+    /**
+     * Callback when user clicks Google sign-in
+     */
+    onGoogleSignIn: () => Promise<void>;
+    /**
+     * Callback when user submits email/password credentials
+     */
+    onCredentialsSignIn?: ((email: string, password: string) => Promise<void>) | undefined;
+    /**
+     * Error message to display (if any)
+     */
+    error?: string | null;
+    /**
+     * Whether to show email/password auth form
+     */
+    showCredentialsAuth?: boolean;
+    /**
+     * Link component for routing - passed from parent
+     */
+    Link: React__default.ComponentType<any>;
+    /**
+     * Translation strings
+     */
+    translations: {
+        pageTitle: string;
+        welcomeBack: string;
+        signInPrompt: string;
+        continueWithGoogle: string;
+        emailLabel: string;
+        emailPlaceholder: string;
+        passwordLabel: string;
+        passwordPlaceholder: string;
+        signInWithCredentials: string;
+        or: string;
+        credentialsAuthEnabled: string;
+        approvedDomainsOnly: string;
+        backToHome: string;
+        learnMore: string;
+        signUpInstead: string;
+        errorEmailRequired: string;
+        errorPasswordRequired: string;
+        tagline: string;
+    };
+}
+/**
+ * SignInForm - Main sign-in component
+ */
+declare function SignInForm({ onGoogleSignIn, onCredentialsSignIn, error, showCredentialsAuth, Link, translations: t, }: SignInFormProps): react_jsx_runtime.JSX.Element;
+
+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;
+    };
+}
+/**
+ * SignUpForm component
+ *
+ * Renders the sign-up form with Google OAuth button.
+ * Manages loading state internally.
+ */
+declare function SignUpForm({ onSignUp, Link, translations: t }: SignUpFormProps): react_jsx_runtime.JSX.Element;
+
+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_jsx_runtime.JSX.Element;
+
+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_jsx_runtime.JSX.Element;
+
+interface EntityTagsPageProps {
+    entityTypes: string[];
+    isLoading: boolean;
+    error: string;
+    newTag: string;
+    onNewTagChange: (value: string) => void;
+    onAddTag: () => void;
+    isAddingTag: boolean;
+    theme: 'light' | 'dark' | 'system';
+    onThemeChange: (theme: 'light' | 'dark' | 'system') => void;
+    showLineNumbers: boolean;
+    onLineNumbersToggle: () => void;
+    activePanel: string | null;
+    onPanelToggle: (panel: string | null) => void;
+    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, isLoading, error, newTag, onNewTagChange, onAddTag, isAddingTag, theme, onThemeChange, showLineNumbers, onLineNumbersToggle, activePanel, onPanelToggle, translations: t, ToolbarPanels, Toolbar, }: EntityTagsPageProps): react_jsx_runtime.JSX.Element;
+
+interface RecentDocumentsPageProps {
+    hasDocuments: boolean;
+    isLoading: boolean;
+    theme: 'light' | 'dark' | 'system';
+    onThemeChange: (theme: 'light' | 'dark' | 'system') => void;
+    showLineNumbers: boolean;
+    onLineNumbersToggle: () => void;
+    activePanel: string | null;
+    onPanelToggle: (panel: string | null) => void;
+    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({ hasDocuments, isLoading, theme, onThemeChange, showLineNumbers, onLineNumbersToggle, activePanel, onPanelToggle, translations: t, ToolbarPanels, Toolbar, }: RecentDocumentsPageProps): react_jsx_runtime.JSX.Element;
+
+interface TagSchemasPageProps {
+    schemas: TagSchema[];
+    isLoading: boolean;
+    theme: 'light' | 'dark' | 'system';
+    onThemeChange: (theme: 'light' | 'dark' | 'system') => void;
+    showLineNumbers: boolean;
+    onLineNumbersToggle: () => void;
+    activePanel: string | null;
+    onPanelToggle: (panel: string | null) => void;
+    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, onThemeChange, showLineNumbers, onLineNumbersToggle, activePanel, onPanelToggle, translations: t, ToolbarPanels, Toolbar, }: TagSchemasPageProps): react_jsx_runtime.JSX.Element;
+
+type ResourceDescriptor$2 = components['schemas']['ResourceDescriptor'];
+interface ResourceComposePageProps {
+    mode: 'new' | 'clone' | 'reference';
+    cloneData?: {
+        sourceResource: ResourceDescriptor$2;
+        sourceContent: string;
+    };
+    referenceData?: {
+        referenceId: string;
+        sourceDocumentId: string;
+        name: string;
+        entityTypes: string[];
+    };
+    availableEntityTypes: string[];
+    initialLocale: string;
+    theme: 'light' | 'dark';
+    onThemeChange: (theme: 'light' | 'dark') => void;
+    showLineNumbers: boolean;
+    onLineNumbersToggle: () => void;
+    activePanel: string | null;
+    onPanelToggle: (panel: string) => void;
+    onSaveResource: (params: SaveResourceParams) => Promise<void>;
+    onCancel: () => void;
+    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;
+    content?: string;
+    file?: File;
+    format?: string;
+    charset?: string;
+    entityTypes?: string[];
+    language: string;
+    archiveOriginal?: boolean;
+    referenceId?: string;
+    sourceDocumentId?: string;
+}
+declare function ResourceComposePage({ mode, cloneData, referenceData, availableEntityTypes, initialLocale, theme, onThemeChange, showLineNumbers, onLineNumbersToggle, activePanel, onPanelToggle, onSaveResource, onCancel, translations: t, ToolbarPanels, Toolbar, }: ResourceComposePageProps): react_jsx_runtime.JSX.Element;
+
+type ResourceDescriptor$1 = components['schemas']['ResourceDescriptor'];
+interface ResourceDiscoveryPageProps {
+    recentDocuments: ResourceDescriptor$1[];
+    searchDocuments: ResourceDescriptor$1[];
+    entityTypes: string[];
+    isLoadingRecent: boolean;
+    isSearching: boolean;
+    theme: 'light' | 'dark';
+    onThemeChange: (theme: 'light' | 'dark') => void;
+    showLineNumbers: boolean;
+    onLineNumbersToggle: () => void;
+    activePanel: string | null;
+    onPanelToggle: (panel: string) => void;
+    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, theme, onThemeChange, showLineNumbers, onLineNumbersToggle, activePanel, onPanelToggle, onNavigateToResource, onNavigateToCompose, translations: t, ToolbarPanels, }: ResourceDiscoveryPageProps): react_jsx_runtime.JSX.Element;
+
+type ResourceDescriptor = components['schemas']['ResourceDescriptor'];
+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_jsx_runtime.JSX.Element>;
+
+interface ResourceViewerPageProps {
+    /**
+     * The resource to display
+     */
+    resource: SemiontResource$2;
+    /**
+     * Resource URI
+     */
+    rUri: ResourceUri;
+    /**
+     * Document content (already loaded)
+     */
+    content: string;
+    /**
+     * Whether content is still loading
+     */
+    contentLoading: boolean;
+    /**
+     * All annotations for this resource
+     */
+    annotations: Annotation$m[];
+    /**
+     * Resources that reference this resource
+     */
+    referencedBy: any[];
+    /**
+     * Whether referencedBy is loading
+     */
+    referencedByLoading: boolean;
+    /**
+     * All available entity types
+     */
+    allEntityTypes: string[];
+    /**
+     * Current locale
+     */
+    locale: string;
+    /**
+     * Theme state
+     */
+    theme: any;
+    onThemeChange: (theme: any) => void;
+    /**
+     * Line numbers state
+     */
+    showLineNumbers: boolean;
+    onLineNumbersToggle: () => void;
+    /**
+     * Active toolbar panel
+     */
+    activePanel: any;
+    onPanelToggle: (panel: any) => void;
+    setActivePanel: (panel: any) => void;
+    /**
+     * Callbacks for resource actions
+     */
+    onUpdateDocumentTags: (tags: string[]) => Promise<void>;
+    onArchive: () => Promise<void>;
+    onUnarchive: () => Promise<void>;
+    onClone: () => Promise<void>;
+    onUpdateAnnotationBody: (annotationUri: string, data: any) => Promise<void>;
+    onRefetchAnnotations: () => Promise<void>;
+    /**
+     * Annotation CRUD callbacks
+     */
+    onCreateAnnotation: (rUri: ResourceUri, motivation: Motivation$2, selector: any, body: any[]) => Promise<void>;
+    onDeleteAnnotation: (annotationId: string) => Promise<void>;
+    onTriggerSparkleAnimation: (annotationId: string) => void;
+    onClearNewAnnotationId: (annotationId: string) => void;
+    /**
+     * Toast notifications
+     */
+    showSuccess: (message: string) => void;
+    showError: (message: string) => void;
+    /**
+     * Real-time event handlers
+     */
+    onAnnotationAdded: (event: any) => void;
+    onAnnotationRemoved: (event: any) => void;
+    onAnnotationBodyUpdated: (event: any) => void;
+    onDocumentArchived: (event: any) => void;
+    onDocumentUnarchived: (event: any) => void;
+    onEntityTagAdded: (event: any) => void;
+    onEntityTagRemoved: (event: any) => void;
+    onEventError: (error: any) => void;
+    /**
+     * Cache manager for detection
+     */
+    cacheManager: any;
+    /**
+     * API client
+     */
+    client: any;
+    /**
+     * Link component for routing
+     */
+    Link: React__default.ComponentType<any>;
+    /**
+     * Routes configuration
+     */
+    routes: any;
+    /**
+     * Component dependencies - passed from frontend
+     */
+    ToolbarPanels: React__default.ComponentType<any>;
+    SearchResourcesModal: React__default.ComponentType<any>;
+    GenerationConfigModal: React__default.ComponentType<any>;
+}
+declare function ResourceViewerPage({ resource, rUri, content, contentLoading, annotations, referencedBy, referencedByLoading, allEntityTypes, locale, theme, onThemeChange, showLineNumbers, onLineNumbersToggle, activePanel, onPanelToggle, setActivePanel, onUpdateDocumentTags, onArchive, onUnarchive, onClone, onUpdateAnnotationBody, onRefetchAnnotations, onCreateAnnotation, onDeleteAnnotation, onTriggerSparkleAnimation, onClearNewAnnotationId, showSuccess, showError, onAnnotationAdded, onAnnotationRemoved, onAnnotationBodyUpdated, onDocumentArchived, onDocumentUnarchived, onEntityTagAdded, onEntityTagRemoved, onEventError, cacheManager, client, Link, routes, ToolbarPanels, SearchResourcesModal, GenerationConfigModal, }: ResourceViewerPageProps): react_jsx_runtime.JSX.Element;
+
+export { ANNOTATORS, AUTH_EVENTS, AVAILABLE_LOCALES, AdminDevOpsPage, type AdminDevOpsPageProps, AdminSecurityPage, type AdminSecurityPageProps, type AdminUser, type AdminUserStats, AdminUsersPage, type AdminUsersPageProps, AnnotateToolbar, AnnotateView, type Annotation$m as Annotation, type AnnotationConfig, type AnnotationCreationHandler, type AnnotationHandlers, AnnotationHistory, type AnnotationManager, AnnotationOverlay, AnnotationProvider, type AnnotationProviderProps, AnnotationUIProvider, type AnnotationUIProviderProps, type AnnotationUIState, type AnnotationsCollection, type Annotator, ApiClientManager, ApiClientProvider, type ApiClientProviderProps, AssessmentEntry, AssessmentPanel, AsyncErrorBoundary, AuthErrorDisplay, type AuthErrorDisplayProps, type AuthEventDetail, type AuthEventType, type AvailableLocale, BrowseView, type CacheManager, CacheProvider, type CacheProviderProps, type ClickAction, CodeMirrorRenderer, CollaborationPanel, CommentEntry, CommentsPanel, ComposeLoadingState, type ComposeLoadingStateProps, type CreateAnnotationParams, type DeleteAnnotationParams, DetectSection, type DetectionConfig, type DetectionProgress, DetectionProgressWidget, type DevOpsFeature, type DrawingMode, EntityTagsPage, type EntityTagsPageProps, EntityTypeBadges, ErrorBoundary, Footer, type GenerationOptions, type GenerationProgress, HighlightEntry, HighlightPanel, HistoryEvent, ImageURLSchema, ImageViewer, JsonLdPanel, JsonLdView, type KeyboardShortcut, KeyboardShortcutsHelpModal, LeftSidebar, type LinkComponentProps, LiveRegionProvider, type Motivation$2 as Motivation, NavigationMenu, type OAuthProvider, type OAuthUser, OAuthUserSchema, OpenResourcesManager, OpenResourcesProvider, PageLayout, PanelHeader, PopupContainer, PopupHeader, type PreparedAnnotation, ProposeEntitiesModal, QUERY_KEYS, RecentDocumentsPage, type RecentDocumentsPageProps, ReferenceEntry, ReferenceResolutionWidget, ReferencesPanel, ResourceAnnotationsProvider, ResourceCard, type ResourceCardProps, ResourceComposePage, type ResourceComposePageProps, ResourceDiscoveryPage, type ResourceDiscoveryPageProps, ResourceErrorState, type ResourceErrorStateProps, type ResourceEvent, ResourceInfoPanel, ResourceLoadingState, ResourceTagsInline, ResourceViewer, ResourceViewerPage, type ResourceViewerPageProps, type RouteBuilder, type SaveResourceParams, SelectedTextDisplay, type SelectionData, type SelectionMotivation, SemiontBranding, type SemiontResource$2 as SemiontResource, SessionExpiryBanner, SessionManager, SessionProvider, SessionTimer, type ShapeType, SignInForm, type SignInFormProps, SignUpForm, type SignUpFormProps, SkipLinks, StatisticsPanel, StatusDisplay, type StreamStatus, SvgDrawingCanvas, TagEntry, TagSchemasPage, type TagSchemasPageProps, TaggingPanel, type TextSegment, type TextSelection, ToastContainer, type ToastMessage, ToastProvider, type ToastType, Toolbar, type ToolbarPanelType, TranslationManager, TranslationProvider, type TranslationProviderProps, type UICreateAnnotationParams, UnifiedAnnotationsPanel, UnifiedHeader, UserMenuSkeleton, WelcomePage, type WelcomePageProps, buttonStyles, createCancelDetectionHandler, createDetectionHandler, dispatch401Error, dispatch403Error, dispatchAuthEvent, getAnnotationClassName, getAnnotationInternalType, getAnnotator, getResourceIcon, getShortcutDisplay, groupAnnotationsByType, jsonLightHighlightStyle, jsonLightTheme, onAuthEvent, rehypeRenderAnnotations, remarkAnnotations, sanitizeImageURL, supportsDetection, useAdmin, useAnnotationManager, useAnnotationPanel, useAnnotationUI, useAnnotations, useApiClient, useAuthApi, useCacheManager, useDebounce, useDebouncedCallback, useDetectionProgress, useDocumentAnnouncements, useDoubleKeyPress, useDropdown, useEntityTypes, useFormValidation, useFormattedTime, useGenerationProgress, useHealth, useIsTyping, useKeyboardShortcuts, useLineNumbers, useLiveRegion, useLoadingState, useLocalStorage, useOpenResources, usePreloadTranslations, useResourceAnnotations, useResourceEvents, useResources, useRovingTabIndex, useSearchAnnouncements, useSessionContext, useSessionExpiry, useTheme, useToast, useToolbar, useTranslations, validationRules, withHandlers };