react-iiif-vault 1.5.9 → 2.0.0

package/dist/bundle.d.ts

@@ -1,42 +1,478 @@
+import { BoxSelector, TemporalBoxSelector, TemporalSelector } from '@iiif/helpers/annotation-targets';
+export * from '@iiif/helpers/annotation-targets';
+import { ViewerMode, Runtime, BoxStyle, AtlasProps, Preset } from '@atlas-viewer/atlas';
 import * as React$1 from 'react';
 import React__default, { ReactNode, FC, ComponentType, RefObject, ForwardRefExoticComponent, RefAttributes, FunctionComponent, Context } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { AtlasProps, Preset, BoxStyle, ViewerMode } from '@atlas-viewer/atlas';
-import { AnnotationPage, ImageService as ImageService$1, ExternalWebResource, InternationalString, Reference, ImageSize, AuthProbeService2, Auth2LocationResource, Auth2SubstituteResource, AuthAccessService2, AuthAccessTokenService2, AuthAccessToken2, SearchServiceQueryParams, SearchServiceSearchResponse, SearchService as SearchService$1, SearchServiceAutocomplete, ContentResource, W3CAnnotationTarget, PointSelector, Annotation } from '@iiif/presentation-3';
-import { AnnotationPageNormalized, AnnotationNormalized, CanvasNormalized, CollectionNormalized, ManifestNormalized, RangeNormalized } from '@iiif/presentation-3-normalized';
-import * as _iiif_helpers from '@iiif/helpers';
-import { ChoiceDescription, Paintables, SupportedTarget, ComplexChoice, ImageCandidate, BoxSelector as BoxSelector$1, TemporalBoxSelector as TemporalBoxSelector$1 } from '@iiif/helpers';
-import { BoxSelector, TemporalBoxSelector, TemporalSelector } from '@iiif/helpers/annotation-targets';
-export * from '@iiif/helpers/annotation-targets';
+import * as zustand from 'zustand';
+import { StoreApi } from 'zustand';
 import * as mitt from 'mitt';
 import { Emitter, EventType, Handler } from 'mitt';
+import * as polygon_editor from 'polygon-editor';
+import { RenderState, SlowState, InputShape, ValidTools, createHelper, PolygonEvents } from 'polygon-editor';
 import * as _iiif_helpers_vault from '@iiif/helpers/vault';
 import { Vault, VaultOptions, NormalizedEntity, IIIFStore } from '@iiif/helpers/vault';
-import { RegionParameter, RotationParameter, SizeParameter } from '@iiif/parser/image-3';
-import * as polygon_editor from 'polygon-editor';
-import { RenderState, InputShape, SlowState } from 'polygon-editor';
+import { Reference, FragmentSelector, SvgSelector, AnnotationPage, ImageService as ImageService$1, ExternalWebResource, InternationalString, ImageSize, AuthProbeService2, Auth2LocationResource, Auth2SubstituteResource, AuthAccessService2, AuthAccessTokenService2, AuthAccessToken2, SearchServiceQueryParams, SearchServiceSearchResponse, SearchService as SearchService$1, SearchServiceAutocomplete, ContentResource, W3CAnnotationTarget, PointSelector, Annotation } from '@iiif/presentation-3';
 import * as zustand_vanilla from 'zustand/vanilla';
-import { StoreApi } from 'zustand/vanilla';
-import * as zustand from 'zustand';
-import { StoreApi as StoreApi$1 } from 'zustand';
+import { StoreApi as StoreApi$1 } from 'zustand/vanilla';
+import { AnnotationPageNormalized, AnnotationNormalized, CanvasNormalized, CollectionNormalized, ManifestNormalized, RangeNormalized } from '@iiif/presentation-3-normalized';
+import * as _iiif_helpers from '@iiif/helpers';
+import { ChoiceDescription, Paintables, SupportedTarget, ComplexChoice, ImageCandidate, BoxSelector as BoxSelector$1, TemporalBoxSelector as TemporalBoxSelector$1, SupportedSelector, SvgSelector as SvgSelector$1 } from '@iiif/helpers';
+import { RegionParameter, RotationParameter, SizeParameter } from '@iiif/parser/image-3';
 import { ImageServiceLoader, ImageCandidateRequest, ImageCandidate as ImageCandidate$1 } from '@iiif/helpers/image-service';
 import * as _iiif_helpers_painting_annotations from '@iiif/helpers/painting-annotations';
 import { Paintables as Paintables$1 } from '@iiif/helpers/painting-annotations';
 import { VaultZustandStore } from '@iiif/helpers/vault/store';
 import * as _iiif_helpers_styles from '@iiif/helpers/styles';
 
-declare function Viewer({ children, errorFallback, outerContainerProps, worldScale: _worldScale, ...props }: AtlasProps & {
-    height?: number | string;
-    width?: number | string;
-    resizeHash?: number;
-    containerProps?: any;
-    outerContainerProps?: any;
-    aspectRatio?: number;
-    errorFallback?: any;
-    renderPreset?: Preset;
-    worldScale?: number;
-} & {
+type RenderContextProps = {
+    canvasId?: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    close: () => void;
+};
+declare const useContextMenuStore: zustand.UseBoundStore<zustand.StoreApi<{
+    isMenuOpen: boolean;
+    menuPosition: {
+        x: number;
+        y: number;
+    };
+    open(position: {
+        x: number;
+        y: number;
+    }): void;
+    toggle(position: {
+        x: number;
+        y: number;
+    }): void;
+    setMenuPosition(position: {
+        x: number;
+        y: number;
+    }): void;
+    setIsMenuOpen(isMenuOpen: boolean | ((prev: boolean) => boolean)): void;
+    close(): void;
+}>>;
+declare function useAtlasContextMenu(id: string, canvasId?: string, renderContextMenu?: (props: RenderContextProps) => React.ReactNode): readonly [react_jsx_runtime.JSX.Element, {
+    onContextMenu: (e: any) => void;
+}, {
+    readonly open: (position: {
+        x: number;
+        y: number;
+    }) => void;
+    readonly close: () => void;
+    readonly toggle: (position: {
+        x: number;
+        y: number;
+    }) => void;
+    readonly isMenuOpen: boolean;
+    readonly setIsMenuOpen: (isMenuOpen: boolean | ((prev: boolean) => boolean)) => void;
+    readonly menuPosition: {
+        x: number;
+        y: number;
+    };
+    readonly setMenuPosition: (position: {
+        x: number;
+        y: number;
+    }) => void;
+}];
+
+interface SvgEditorOptions {
+    image: {
+        height: number;
+        width: number;
+    };
+    hideShapeLines?: boolean;
+    onChange?: (shape: InputShape) => void;
+    theme?: Partial<SVGTheme>;
+}
+declare const defaultSvgTheme: {
+    shapeFill: string;
+    shapeStroke: string;
+    lineStroke: string;
+    ghostLineStroke: string;
+    activeLineStroke: string;
+    boundingBoxDottedStroke: string;
+    boundingBoxStroke: string;
+    controlFill: string;
+};
+type SVGTheme = typeof defaultSvgTheme;
+declare function useSvgEditor(options: SvgEditorOptions): {
+    currentTool: polygon_editor.ValidTools;
+    setCurrentTool: (tool: polygon_editor.ValidTools) => void;
+    helper: {
+        state: RenderState;
+        setState: (newState: Partial<SlowState>) => void;
+        emitter: mitt.Emitter<polygon_editor.PolygonEvents>;
+        modifiers: {
+            reset(): void;
+            getForType(type: string | null): Record<string, string>;
+            set(modifier: string): void;
+            unset(modifier: string): void;
+        };
+        stamps: {
+            set(selectedStamp: InputShape | null): void;
+            clear(): void;
+            square(): void;
+            triangle(): void;
+            pentagon(): void;
+            hexagon(): void;
+            circle(): void;
+        };
+        history: {
+            undo: () => void;
+            redo: () => void;
+            readonly canUndo: boolean;
+            readonly canRedo: boolean;
+        };
+        key: {
+            down(inputKey: string): boolean | undefined;
+            up(inputKey: string): void;
+        };
+        setScale: (scale: number) => void;
+        clock: {
+            set: (renderFunc: polygon_editor.RenderFunc) => void;
+            start: (renderFunc?: polygon_editor.RenderFunc | undefined, setStateFunc?: polygon_editor.SetState | undefined) => void;
+            stop: () => void;
+            step: (deltaTime?: number | undefined) => void;
+        };
+        pointer: (pointers: ([number, number] | [number, number, number, number, number, number])[]) => void;
+        blur: () => void;
+        pointerDown: () => void;
+        pointerUp: () => void;
+        setShape: (shape: InputShape | null) => void;
+        label: (type: string | null) => string;
+        tools: {
+            setTool: (tool: polygon_editor.ValidTools) => void;
+            unsetTool: (tool: polygon_editor.ValidTools) => void;
+            toggleTool: (tool: polygon_editor.ValidTools) => void;
+            updateVisibility: (tool: polygon_editor.ValidTools) => void;
+            setCanDelete(canDelete: boolean): void;
+            setCanDeselect(canDeselect: boolean): void;
+            lockToolSwitching(): void;
+            unlockToolSwitching(): void;
+            toggleToolSwitching(): void;
+            shortcuts: {
+                [k: string]: string;
+            };
+            getValidIntents(tool?: polygon_editor.ValidTools | undefined): {
+                actions: polygon_editor.ActionIntent[];
+                transitions: polygon_editor.TransitionIntent[];
+                keys: polygon_editor.ActionIntent[];
+                all: Record<string, string>;
+                current: Record<string, string>;
+            };
+            getToolInfo(): {
+                name: polygon_editor.ValidTools;
+                cursor: string;
+                selectionCount: number;
+                pointCount: number;
+                isOpen: boolean;
+            };
+            smartSelect(): void;
+            clearSelection(): void;
+            autoSelect(): void;
+        };
+        snap: {
+            enabled: () => boolean;
+            enable: () => void;
+            disable: () => void;
+            toggle: () => void;
+            pointsEnabled: () => boolean;
+            enablePoints: () => void;
+            disablePoints: () => void;
+            togglePoints: () => void;
+            linesEnabled: () => boolean;
+            enableLines: () => void;
+            disableLines: () => void;
+            toggleLines: () => void;
+            intersectionsEnabled: () => boolean;
+            enableIntersections: () => void;
+            disableIntersections: () => void;
+            toggleIntersections: () => void;
+            gridEnabled: () => boolean;
+            enableGrid: () => void;
+            disableGrid: () => void;
+            toggleGrid: () => void;
+            parallelEnabled: () => boolean;
+            enableParallel: () => void;
+            disableParallel: () => void;
+            toggleParallel: () => void;
+            getThreshold: () => number;
+            setThreshold: (threshold: number) => void;
+            isActive: () => boolean;
+            getSnapPoint: () => ([number, number] | [number, number, number, number, number, number]) | null;
+            getActiveGuides: () => polygon_editor.SnapGuide[];
+            getTargets: () => polygon_editor.SnapTarget[];
+        };
+        selectAllPoints: () => void;
+        setBounds: (bounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        } | null) => void;
+        lockAspectRatio: () => void;
+        unlockAspectRatio: () => void;
+    };
+    currentShape: InputShape | null;
+    state: SlowState;
+    isAddingPoint: boolean;
+    isSplitting: boolean;
+    isStamping: boolean | null;
+    isHoveringPoint: boolean;
+    transitionDirection: string | null;
+    transitionRotate: boolean;
+    defs: react_jsx_runtime.JSX.Element;
+    editor: react_jsx_runtime.JSX.Element | null;
+};
+
+type SimpleViewerContext = {
+    items: Reference<'Canvas'>[];
+    sequence: number[][];
+    hasNext: boolean;
+    hasPrevious: boolean;
+    setSequenceIndex: (newId: number) => void;
+    setCurrentCanvasId: (newId: string) => void;
+    setCurrentCanvasIndex: (newId: number) => void;
+    currentSequenceIndex: number;
+    nextCanvas: () => void;
+    previousCanvas: () => void;
+};
+type SimpleViewerProps = {
+    vault?: Vault;
+    manifest: string;
+    pagingEnabled?: boolean;
     children: ReactNode;
+    startCanvas?: string;
+    rangeId?: string;
+};
+type SimpleViewerReducerState = {
+    sequence: number[][];
+    availableCanvases: Reference<'Canvas'>[];
+    visibleCanvases: Reference<'Canvas'>[];
+    currentCanvas: string | null;
+    isPaged: boolean;
+    rangeId: string | null;
+};
+interface SimpleViewerActions {
+    setCurrentCanvasId(newId: string): void;
+    setCurrentCanvasIndex(newId: number): void;
+    nextCanvas(): void;
+    previousCanvas(): void;
+    setCurrentRange(newId: string): void;
+    clearRange(): void;
+    setPagingEnabled(isEnabled: boolean): void;
+}
+type SimpleViewerActionsType = {
+    [T in keyof SimpleViewerActions]: {
+        type: T;
+        payload: Parameters<SimpleViewerActions[T]>[0];
+    };
+}[keyof SimpleViewerActions];
+
+type Polygons = ReturnType<typeof createHelper>;
+type Point = [number, number] | [number, number, number, number, number, number];
+type AnnotationRequest = {
+    annotationPopup?: React.ReactNode;
+    arguments?: Record<string, any>;
+    svgTheme?: Partial<SVGTheme>;
+    selectByDefault?: boolean;
+    bounds?: null | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+} & ({
+    type: 'polygon' | 'draw';
+    noBox?: boolean;
+    points?: Array<Point>;
+    open?: boolean;
+    selector?: undefined;
+} | {
+    type: 'target';
+    selector: null | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+} | {
+    type: 'box';
+    selector?: null | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+});
+type AnnotationRequestOptions = {
+    requestId: string;
+    canvasId?: string | null;
+    toolId?: keyof AtlasStore['switchTool'];
+};
+interface AtlasStore {
+    mode: ViewerMode;
+    tool: {
+        enabled: boolean;
+        requestId: string | null;
+        canvasId: string | null;
+    };
+    requestType: null | 'polygon' | 'target' | 'box' | 'draw';
+    metadata: Record<string, any>;
+    requests: Record<string, AnnotationRequest>;
+    switchTool: {
+        draw(): void;
+        pen(): void;
+        line(): void;
+        lineBox(): void;
+        box(): void;
+        triangle(): void;
+        hexagon(): void;
+        circle(): void;
+        remove(): void;
+        hand(): void;
+        pointer(): void;
+    };
+    history: {
+        canUndo: boolean;
+        canRedo: boolean;
+        undo(): void;
+        redo(): void;
+    };
+    stableViewport: null | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zoom: number;
+    };
+    canvasRelativePositions: Record<string, {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    canvasViewports: Record<string, {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zoom?: number;
+    }>;
+    validRequestIds: string[];
+    polygon: InputShape | null;
+    polygons: Polygons;
+    polygonState: SlowState;
+    setPolygonState: (state: SlowState | ((prev: SlowState) => SlowState)) => void;
+    setToolCanvasId: (canvasId: string) => void;
+    setMetadata(data: Record<string, any>, requestId?: string): void;
+    getRequestId(): {
+        requestId: string;
+        clear: () => void;
+    };
+    requestAnnotation(req: AnnotationRequest, options: AnnotationRequestOptions): Promise<AnnotationResponse | null>;
+    setAtlasRuntime(runtime: Runtime): void;
+    setCanvasRelativePosition(canvasId: string, position: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): void;
+    clearCanvasRelativePosition(canvasId: string): void;
+    clearAtlasRuntime(): void;
+    completeRequest(requestId?: string): void;
+    cancelRequest(requestId?: string): void;
+    reset(): void;
+    changeMode(mode: ViewerMode): void;
+    nudgeLeft(): void;
+    nudgeRight(): void;
+    nudgeUp(): void;
+    nudgeDown(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    goHome(): void;
+}
+declare function polygonToTarget(polygon: InputShape, on?: {
+    width: number;
+    height: number;
+} | null): FragmentSelector | SvgSelector | null;
+declare function requestToAnnotationResponse(request: AnnotationRequest): Omit<AnnotationResponse, 'id'>;
+type AnnotationResponse = {
+    id: string;
+    canvasId?: string | null;
+    polygon: InputShape | null;
+    cancelled?: boolean;
+    requestType: 'draw' | 'polygon' | 'target' | 'box';
+    target: FragmentSelector | SvgSelector | null;
+    boundingBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    metadata: Record<string, any>;
+    arguments: Record<string, any>;
+};
+type AtlasStoreEvents = {
+    'atlas.canvas-click': {
+        canvasId: string;
+        target: {
+            x: number;
+            y: number;
+        };
+        worldTarget: {
+            x: number;
+            y: number;
+        };
+    };
+    'atlas.viewport-change': {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zoom: number;
+    };
+    'atlas.ready': {
+        runtime: Runtime;
+    };
+    'atlas.annotation-completed': AnnotationResponse;
+    'atlas.annotation-request': {
+        id: string;
+    };
+    'atlas.request-cancelled': {
+        id: string;
+    };
+    'atlas.polygon-render': {
+        state: RenderState;
+        slowState: SlowState;
+        dt: number;
+    };
+    'atlas.polygon-update': {
+        id?: string;
+        points: Array<Point>;
+        open: boolean;
+    };
+};
+interface CreateAtlasStoreProps {
+    events: Emitter<AtlasStoreEvents>;
+    keyboardShortcutsEnabled?: boolean;
+    keyboardShortcutMapping?: Record<string, string>;
+    enabledTools?: Array<ValidTools>;
+    debug?: boolean;
+}
+declare function createAtlasStore({ events, enabledTools, keyboardShortcutMapping, keyboardShortcutsEnabled, debug, }: CreateAtlasStoreProps): zustand_vanilla.StoreApi<AtlasStore>;
+
+declare const AtlasStoreReactContext: React$1.Context<StoreApi<AtlasStore> | null>;
+declare function useAtlasStore(): StoreApi<AtlasStore>;
+declare function getAtlasStoreByName(name?: string): AtlasStore;
+declare function AtlasStoreProvider({ children, name, existing, atlasStoreConfig, }: {
+    name?: string;
+    children: React.ReactNode;
+    existing?: StoreApi<AtlasStore>;
+    atlasStoreConfig?: Partial<CreateAtlasStoreProps>;
 }): react_jsx_runtime.JSX.Element;
 
 declare const RenderAnnotation: FC<{
@@ -117,6 +553,19 @@ type AnnotationPageDescription = {
     pages: AnnotationPageNormalized[];
 };
 
+interface AudioComponentProps {
+    media: SingleAudio;
+    startTime?: number | null;
+    children: ReactNode;
+}
+declare function AudioHTML({ media, startTime, children }: AudioComponentProps): react_jsx_runtime.JSX.Element;
+declare function Audio({ media, mediaControlsDeps, audioCopmonent, children, }: {
+    media: SingleAudio;
+    mediaControlsDeps?: any[];
+    children: ReactNode;
+    audioCopmonent?: ComponentType<AudioComponentProps>;
+}): null;
+
 type ImageServiceLoaderType = (imageService: any | undefined, { height, width }: {
     height: number;
     width: number;
@@ -129,15 +578,6 @@ declare function useLoadImageService(): readonly [ImageServiceLoaderType, Record
     real?: boolean | undefined;
 }>];
 
-type SingleImageStrategy = {
-    type: 'images';
-    image: ImageWithOptionalService;
-    images: Array<ImageWithOptionalService>;
-    choice?: ChoiceDescription;
-    annotations?: AnnotationPageDescription;
-};
-declare function getImageStrategy(canvas: CanvasNormalized, paintables: Paintables, loadImageService: ImageServiceLoaderType): SingleImageStrategy | UnknownStrategy;
-
 type Single3DModelStrategy = {
     type: '3d-model';
     model: ExternalWebResource;
@@ -207,6 +647,15 @@ type UnknownStrategy = {
 };
 type RenderingStrategy = SingleImageStrategy | MediaStrategy | ComplexTimelineStrategy | Single3DModelStrategy | TextualContentStrategy | UnknownStrategy | EmptyStrategy;
 
+type SingleImageStrategy = {
+    type: 'images';
+    image: ImageWithOptionalService;
+    images: Array<ImageWithOptionalService>;
+    choice?: ChoiceDescription;
+    annotations?: AnnotationPageDescription;
+};
+declare function getImageStrategy(canvas: CanvasNormalized, paintables: Paintables, loadImageService: ImageServiceLoaderType): SingleImageStrategy | UnknownStrategy;
+
 type StrategyActions = {
     makeChoice: (id: string, options?: {
         deselectOthers?: boolean;
@@ -237,19 +686,6 @@ type UseRenderingStrategyOptions = {
 };
 declare function useRenderingStrategy(options?: UseRenderingStrategyOptions): UseRenderingStrategy;
 
-interface AudioComponentProps {
-    media: SingleAudio;
-    startTime?: number | null;
-    children: ReactNode;
-}
-declare function AudioHTML({ media, startTime, children }: AudioComponentProps): react_jsx_runtime.JSX.Element;
-declare function Audio({ media, mediaControlsDeps, audioCopmonent, children, }: {
-    media: SingleAudio;
-    mediaControlsDeps?: any[];
-    children: ReactNode;
-    audioCopmonent?: ComponentType<AudioComponentProps>;
-}): null;
-
 interface VideoComponentProps {
     element: RefObject<HTMLVideoElement>;
     media: SingleVideo;
@@ -295,13 +731,21 @@ type CanvasProps = {
     enableYouTube?: boolean;
     ignoreSize?: boolean;
     throwOnUnknown?: boolean;
+    renderContextMenu?: (options: RenderContextProps) => ReactNode;
     onClickPaintingAnnotation?: (id: string, image: ImageWithOptionalService, e: any) => void;
     components?: {
         Video?: React__default.ComponentType<VideoComponentProps>;
         Audio?: React__default.ComponentType<AudioComponentProps>;
     };
+    annotationPopup?: React__default.ReactNode;
+    svgTheme?: Partial<SVGTheme>;
+    renderAnnotationContextMenu?: (options: RenderContextProps) => React__default.ReactNode;
 };
-declare function RenderCanvas({ x, y, onChoiceChange, registerActions, defaultChoices, isStatic, renderViewerControls, renderMediaControls, renderComplexTimelineControls, complexTimelineControlsDeps, viewControlsDeps, mediaControlsDeps, strategies, throwOnUnknown, backgroundStyle, alwaysShowBackground, keepCanvasScale, enableSizes, enableYouTube, onClickPaintingAnnotation, components, children, }: CanvasProps): react_jsx_runtime.JSX.Element;
+declare function RenderCanvas({ x, y, onChoiceChange, registerActions, defaultChoices, isStatic, renderViewerControls, renderMediaControls, renderComplexTimelineControls, complexTimelineControlsDeps, viewControlsDeps, mediaControlsDeps, strategies, throwOnUnknown, backgroundStyle, alwaysShowBackground, keepCanvasScale, enableSizes, enableYouTube, onClickPaintingAnnotation, components, children, annotationPopup, svgTheme, renderContextMenu, renderAnnotationContextMenu, }: CanvasProps): react_jsx_runtime.JSX.Element;
+
+declare function CanvasBackground({ style }: {
+    style?: BoxStyle;
+}): react_jsx_runtime.JSX.Element | null;
 
 declare function RenderImage({ id, image, thumbnail, isStatic, x, y, children, selector, onClick, enableSizes, }: {
     id: string;
@@ -316,54 +760,6 @@ declare function RenderImage({ id, image, thumbnail, isStatic, x, y, children, s
     onClick?: (e: any) => void;
 }): react_jsx_runtime.JSX.Element;
 
-declare function CanvasBackground({ style }: {
-    style?: BoxStyle;
-}): react_jsx_runtime.JSX.Element | null;
-
-type SimpleViewerContext = {
-    items: Reference<'Canvas'>[];
-    sequence: number[][];
-    hasNext: boolean;
-    hasPrevious: boolean;
-    setSequenceIndex: (newId: number) => void;
-    setCurrentCanvasId: (newId: string) => void;
-    setCurrentCanvasIndex: (newId: number) => void;
-    currentSequenceIndex: number;
-    nextCanvas: () => void;
-    previousCanvas: () => void;
-};
-type SimpleViewerProps = {
-    vault?: Vault;
-    manifest: string;
-    pagingEnabled?: boolean;
-    children: ReactNode;
-    startCanvas?: string;
-    rangeId?: string;
-};
-type SimpleViewerReducerState = {
-    sequence: number[][];
-    availableCanvases: Reference<'Canvas'>[];
-    visibleCanvases: Reference<'Canvas'>[];
-    currentCanvas: string | null;
-    isPaged: boolean;
-    rangeId: string | null;
-};
-interface SimpleViewerActions {
-    setCurrentCanvasId(newId: string): void;
-    setCurrentCanvasIndex(newId: number): void;
-    nextCanvas(): void;
-    previousCanvas(): void;
-    setCurrentRange(newId: string): void;
-    clearRange(): void;
-    setPagingEnabled(isEnabled: boolean): void;
-}
-type SimpleViewerActionsType = {
-    [T in keyof SimpleViewerActions]: {
-        type: T;
-        payload: Parameters<SimpleViewerActions[T]>[0];
-    };
-}[keyof SimpleViewerActions];
-
 declare function ModelHTML({ model }: {
     model: any;
 }): react_jsx_runtime.JSX.Element;
@@ -377,6 +773,23 @@ interface PlaceholderCanvasProps {
 }
 declare function PlaceholderCanvas(props: PlaceholderCanvasProps): react_jsx_runtime.JSX.Element | null;
 
+type ViewerProps = AtlasProps & {
+    name?: string;
+    height?: number | string;
+    width?: number | string;
+    resizeHash?: number;
+    containerProps?: any;
+    outerContainerProps?: any;
+    aspectRatio?: number;
+    errorFallback?: any;
+    renderPreset?: Preset;
+    worldScale?: number;
+    updateViewportTimeout?: number;
+} & {
+    children: ReactNode;
+};
+declare function Viewer(props: ViewerProps): react_jsx_runtime.JSX.Element;
+
 interface CanvasPanelProps {
     manifest: string;
     startCanvas?: string;
@@ -388,6 +801,7 @@ interface CanvasPanelProps {
     reuseAtlas?: boolean;
     runtimeOptions?: any;
     renderPreset?: any;
+    name?: string;
     height?: number;
     spacing?: number;
     components?: {
@@ -397,6 +811,12 @@ interface CanvasPanelProps {
     };
     canvasProps?: Omit<Partial<CanvasProps>, 'x'>;
     annotations?: ReactNode;
+    annotationPopup?: ReactNode;
+    svgTheme?: SVGTheme;
+    updateViewportTimeout?: number;
+    renderContextMenu?: (options: RenderContextProps) => ReactNode;
+    keepCanvasScale?: boolean;
+    renderAnnotationContextMenu?: (options: RenderContextProps) => ReactNode;
 }
 type CanvasPanelType = ForwardRefExoticComponent<CanvasPanelProps & RefAttributes<SimpleViewerContext>> & {
     RenderImage: typeof RenderImage;
@@ -412,9 +832,17 @@ type CanvasPanelType = ForwardRefExoticComponent<CanvasPanelProps & RefAttribute
     VideoHTML: typeof VideoHTML;
     ModelHTML: typeof ModelHTML;
     PlaceholderCanvas: typeof PlaceholderCanvas;
+    getAtlasStoreByName: typeof getAtlasStoreByName;
 };
 declare const CanvasPanel: CanvasPanelType;
 
+declare function RenderAnnotationEditing({ theme, renderContextMenu, children, }: {
+    theme?: Partial<SVGTheme>;
+    renderContextMenu?: (options: RenderContextProps) => React.ReactNode;
+    children?: React.ReactNode;
+}): react_jsx_runtime.JSX.Element | null;
+declare function DefaultEditingTools(): react_jsx_runtime.JSX.Element | null;
+
 interface CanvasStrategyProviderProps {
     onChoiceChange?: (choice?: ChoiceDescription) => void;
     strategies?: Array<RenderingStrategy['type']>;
@@ -439,27 +867,36 @@ interface CanvasWorldObjectProps {
     y?: number;
     keepCanvasScale?: boolean;
     children?: ReactNode;
+    renderContextMenu?: (options: RenderContextProps) => ReactNode;
 }
-declare function CanvasWorldObject({ x, y, keepCanvasScale, children }: CanvasWorldObjectProps): react_jsx_runtime.JSX.Element | null;
+declare function CanvasWorldObject({ x, y, keepCanvasScale, renderContextMenu, children, }: CanvasWorldObjectProps): react_jsx_runtime.JSX.Element | null;
 
 declare function ThumbnailFallbackImage({ x, y }: {
     x?: number;
     y?: number;
 }): react_jsx_runtime.JSX.Element | null;
 
-interface RenderEmptyStrategyProps {
-    backgroundStyle?: BoxStyle;
-    alwaysShowBackground?: boolean;
+declare function Render3DModelStrategy(): react_jsx_runtime.JSX.Element | null;
+
+declare function RenderAccompanyingCanvas(): react_jsx_runtime.JSX.Element;
+
+interface AnnotationStrategyProps {
+    children?: ReactNode;
 }
-declare function RenderEmptyStrategy({ backgroundStyle, alwaysShowBackground }: RenderEmptyStrategyProps): react_jsx_runtime.JSX.Element | null;
+declare function RenderAnnotationStrategy({ children }: AnnotationStrategyProps): react_jsx_runtime.JSX.Element | null;
+
+interface RenderAudioStrategyProps {
+    as?: React.ComponentType<AudioComponentProps>;
+}
+declare function RenderAudioStrategy({ as: CustomAudio, }: RenderAudioStrategyProps): react_jsx_runtime.JSX.Element | null;
 
 declare function RenderComplexTimelineStrategy(): react_jsx_runtime.JSX.Element | null;
 
-interface TextualContextStrategyProps {
-    onClickPaintingAnnotation?: (id: string, e: any) => void;
-    children?: ReactNode;
+interface RenderEmptyStrategyProps {
+    backgroundStyle?: BoxStyle;
+    alwaysShowBackground?: boolean;
 }
-declare function RenderTextualContentStrategy({ onClickPaintingAnnotation, children }: TextualContextStrategyProps): react_jsx_runtime.JSX.Element | null;
+declare function RenderEmptyStrategy({ backgroundStyle, alwaysShowBackground }: RenderEmptyStrategyProps): react_jsx_runtime.JSX.Element | null;
 
 interface ImageStrategyProps {
     isStatic?: boolean;
@@ -469,19 +906,11 @@ interface ImageStrategyProps {
 }
 declare function RenderImageStrategy({ isStatic, enableSizes, onClickPaintingAnnotation, children, }: ImageStrategyProps): react_jsx_runtime.JSX.Element | null;
 
-declare function Render3DModelStrategy(): react_jsx_runtime.JSX.Element | null;
-
-interface AnnotationStrategyProps {
+interface TextualContextStrategyProps {
+    onClickPaintingAnnotation?: (id: string, e: any) => void;
     children?: ReactNode;
 }
-declare function RenderAnnotationStrategy({ children }: AnnotationStrategyProps): react_jsx_runtime.JSX.Element | null;
-
-interface RenderAudioStrategyProps {
-    as?: React.ComponentType<AudioComponentProps>;
-}
-declare function RenderAudioStrategy({ as: CustomAudio, }: RenderAudioStrategyProps): react_jsx_runtime.JSX.Element | null;
-
-declare function RenderAccompanyingCanvas(): react_jsx_runtime.JSX.Element;
+declare function RenderTextualContentStrategy({ onClickPaintingAnnotation, children }: TextualContextStrategyProps): react_jsx_runtime.JSX.Element | null;
 
 interface RenderVideoStrategyProps {
     as?: React__default.ComponentType<VideoComponentProps>;
@@ -490,6 +919,74 @@ declare function RenderVideoStrategy({ as: CustomVideo, }: RenderVideoStrategyPr
 
 declare function RenderYouTubeStrategy(): react_jsx_runtime.JSX.Element | null;
 
+declare const svgThemes: ({
+    name: string;
+    outer: {
+        borderWidth: number;
+        borderColor: string;
+    };
+    inner: {
+        borderWidth: number;
+        borderColor: string;
+    };
+} | {
+    name: string;
+    outer: {
+        borderWidth: string;
+        borderColor: string;
+    };
+    inner: {
+        borderWidth: string;
+        borderColor: string;
+    };
+} | {
+    name: string;
+    outer: {
+        borderWidth: string;
+        borderColor: string;
+    };
+    inner: {
+        borderWidth?: undefined;
+        borderColor?: undefined;
+    };
+})[];
+type HelperType = ReturnType<typeof useSvgEditor>['helper'];
+type StateType = ReturnType<typeof useSvgEditor>['state'];
+type SvgTheme = {
+    name?: string;
+    outer: BoxStyle;
+    inner: BoxStyle;
+};
+interface CreateCustomShapeProps {
+    image: {
+        width: number;
+        height: number;
+    };
+    shape?: any;
+    updateShape: any;
+    theme?: {
+        name?: string;
+        outer: BoxStyle;
+        inner: BoxStyle;
+    };
+    controlsHtmlId?: string;
+    renderControls?: (helper: HelperType, state: StateType, showShapes: boolean) => any;
+}
+declare function CreateCustomShape(props: CreateCustomShapeProps): null;
+
+interface PolygonSelectorProps {
+    id: string;
+    polygon: InputShape;
+    annotationBucket?: string;
+    isHighlighted?: boolean;
+    updatePolygon?: (shape: InputShape) => void;
+    readOnly?: boolean;
+    theme?: SvgTheme;
+    controlsHtmlId?: string;
+    renderControls?: CreateCustomShapeProps['renderControls'];
+}
+declare function PolygonSelector(props: PolygonSelectorProps): react_jsx_runtime.JSX.Element | null;
+
 declare const CanvasAnnotations: React$1.ForwardRefExoticComponent<{
     canvasId?: string | undefined;
 } & React$1.RefAttributes<{
@@ -556,6 +1053,21 @@ interface ImageProps {
 }
 declare function Image(props: ImageProps): react_jsx_runtime.JSX.Element | null;
 
+interface ImageServiceProps {
+    src: string;
+    atlas?: AtlasProps;
+    errorFallback?: React__default.FC;
+    interactive?: boolean;
+    skipSizes?: boolean;
+    renderViewerControls?: (strategy: SingleImageStrategy | EmptyStrategy) => ReactNode;
+    viewControlsDeps?: any[];
+    fluid?: boolean;
+    x?: number;
+    y?: number;
+    children?: React__default.ReactNode;
+}
+declare function ImageService({ src, errorFallback, interactive, skipSizes, children, renderViewerControls, viewControlsDeps, fluid, x, y, ...atlasProps }: ImageServiceProps & Omit<AtlasProps, 'children'>): react_jsx_runtime.JSX.Element | null;
+
 type ManifestMetadataProps = Omit<MetadataProps, 'metadata'>;
 declare function ManifestMetadata(props: ManifestMetadataProps): react_jsx_runtime.JSX.Element;
 
@@ -602,96 +1114,24 @@ interface SingleCanvasThumbnailProps {
         figure?: string;
         img?: string;
         label?: string;
-        imageWrapper?: string;
-    };
-    placeholder?: React.ReactNode;
-    fallback?: React.ReactNode;
-}
-declare function SingleCanvasThumbnail(props: SingleCanvasThumbnailProps): react_jsx_runtime.JSX.Element;
-
-interface SvgEditorOptions {
-    image: {
-        height: number;
-        width: number;
-    };
-    currentShape: InputShape | null;
-    onChange: (e: InputShape) => void;
-    hideShapeLines?: boolean;
-}
-declare function useSvgEditor(options: SvgEditorOptions, deps: any[]): {
-    helper: {
-        draw: {
-            enable(): void;
-            disable(): void;
-            toggle(): void;
-        };
-        state: RenderState;
-        modifiers: {
-            reset(): void;
-            getForType(type: string | null): Record<string, string>;
-            set(modifier: string): void;
-            unset(modifier: string): void;
-        };
-        stamps: {
-            set(selectedStamp: InputShape | null): void;
-            clear(): void;
-            square(): void;
-            triangle(): void;
-            pentagon(): void;
-            hexagon(): void;
-        };
-        key: {
-            down(key: string): true | undefined;
-            up(key: string): void;
-        };
-        setScale: (scale: number) => void;
-        clock: {
-            set: (renderFunc: polygon_editor.RenderFunc) => void;
-            start: (renderFunc?: polygon_editor.RenderFunc | undefined, setStateFunc?: polygon_editor.SetState | undefined) => void;
-            stop: () => void;
-            step: (deltaTime?: number | undefined) => void;
-        };
-        pointer: (pointers: ([number, number] | [number, number, number, number, number, number])[]) => void;
-        blur: () => void;
-        pointerDown: () => void;
-        pointerUp: () => void;
-        setShape: (shape: InputShape | null) => void;
-        modes: {
-            toggleLineBoxMode: () => void;
-            toggleLineMode: () => void;
-            enableLineMode(): void;
-            disableLineMode(): void;
-            enableLineBoxMode(): void;
-            disableLineBoxMode(): void;
-        };
-        label: (type: string | null) => string;
+        imageWrapper?: string;
     };
-    state: SlowState;
-    isAddingPoint: boolean;
-    isSplitting: boolean;
-    isStamping: boolean | null;
-    isHoveringPoint: boolean;
-    transitionDirection: string | null;
-    transitionRotate: boolean;
-    defs: react_jsx_runtime.JSX.Element;
-    editor: react_jsx_runtime.JSX.Element | null;
-};
+    placeholder?: React.ReactNode;
+    fallback?: React.ReactNode;
+}
+declare function SingleCanvasThumbnail(props: SingleCanvasThumbnailProps): react_jsx_runtime.JSX.Element;
 
-type HelperType$1 = ReturnType<typeof useSvgEditor>['helper'];
-type StateType$1 = ReturnType<typeof useSvgEditor>['state'];
 interface RenderSvgEditorControlsProps {
-    helper: HelperType$1;
-    state: StateType$1;
-    showShapes: boolean;
+    showShapes?: boolean;
     classNames?: Partial<{
         button: string;
     }>;
     enabled?: {
         draw?: boolean;
-        polygon?: boolean;
+        pen?: boolean;
         line?: boolean;
         lineBox?: boolean;
-        square?: boolean;
+        box?: boolean;
         triangle?: boolean;
         hexagon?: boolean;
         circle?: boolean;
@@ -699,101 +1139,20 @@ interface RenderSvgEditorControlsProps {
     };
     icons?: Partial<{
         DrawIcon: ReactNode;
-        PolygonIcon: ReactNode;
+        PenIcon: ReactNode;
         LineIcon: ReactNode;
         LineBoxIcon: ReactNode;
         ShapesIcon: ReactNode;
-        SquareIcon: ReactNode;
+        BoxIcon: ReactNode;
         TriangleIcon: ReactNode;
         HexagonIcon: ReactNode;
         CircleIcon: ReactNode;
         DeleteForeverIcon: ReactNode;
+        PointerIcon: ReactNode;
+        HandIcon: ReactNode;
     }>;
 }
-declare function RenderSvgEditorControls({ helper, showShapes, state, enabled, classNames, icons, }: RenderSvgEditorControlsProps): react_jsx_runtime.JSX.Element;
-
-declare const svgThemes: ({
-    name: string;
-    outer: {
-        borderWidth: number;
-        borderColor: string;
-    };
-    inner: {
-        borderWidth: number;
-        borderColor: string;
-    };
-} | {
-    name: string;
-    outer: {
-        borderWidth: string;
-        borderColor: string;
-    };
-    inner: {
-        borderWidth: string;
-        borderColor: string;
-    };
-} | {
-    name: string;
-    outer: {
-        borderWidth: string;
-        borderColor: string;
-    };
-    inner: {
-        borderWidth?: undefined;
-        borderColor?: undefined;
-    };
-})[];
-type HelperType = ReturnType<typeof useSvgEditor>['helper'];
-type StateType = ReturnType<typeof useSvgEditor>['state'];
-type SvgTheme = {
-    name?: string;
-    outer: BoxStyle;
-    inner: BoxStyle;
-};
-interface CreateCustomShapeProps {
-    image: {
-        width: number;
-        height: number;
-    };
-    shape?: any;
-    updateShape: any;
-    theme?: {
-        name?: string;
-        outer: BoxStyle;
-        inner: BoxStyle;
-    };
-    controlsHtmlId?: string;
-    renderControls?: (helper: HelperType, state: StateType, showShapes: boolean) => any;
-}
-declare function CreateCustomShape(props: CreateCustomShapeProps): react_jsx_runtime.JSX.Element;
-
-interface PolygonSelectorProps {
-    id: string;
-    polygon: InputShape;
-    annotationBucket?: string;
-    isHighlighted?: boolean;
-    updatePolygon?: (shape: InputShape) => void;
-    readOnly?: boolean;
-    theme?: SvgTheme;
-    controlsHtmlId?: string;
-    renderControls?: CreateCustomShapeProps['renderControls'];
-}
-declare function PolygonSelector(props: PolygonSelectorProps): react_jsx_runtime.JSX.Element | null;
-
-interface ImageServiceProps {
-    src: string;
-    atlas?: AtlasProps;
-    errorFallback?: React__default.FC;
-    interactive?: boolean;
-    skipSizes?: boolean;
-    renderViewerControls?: (strategy: SingleImageStrategy | EmptyStrategy) => ReactNode;
-    viewControlsDeps?: any[];
-    fluid?: boolean;
-    x?: number;
-    y?: number;
-    children?: React__default.ReactNode;
-}
-declare function ImageService({ src, errorFallback, interactive, skipSizes, children, renderViewerControls, viewControlsDeps, fluid, x, y, ...atlasProps }: ImageServiceProps & Omit<AtlasProps, 'children'>): react_jsx_runtime.JSX.Element | null;
+declare function RenderSvgEditorControls({ showShapes, enabled, classNames, icons, }: RenderSvgEditorControlsProps): react_jsx_runtime.JSX.Element;
 
 declare function AnnotationContext({ annotation, children }: {
     annotation: string;
@@ -805,6 +1164,37 @@ declare function AnnotationPageContext({ annotationPage, children }: {
     children: ReactNode;
 }): react_jsx_runtime.JSX.Element;
 
+interface AnnotationStyles {
+    id: number;
+    name: string;
+    creator?: {
+        id: number;
+        name: string;
+    };
+    createdAt: Date;
+    theme: {
+        default: AnnotationThemeDefinition;
+        hidden: AnnotationThemeDefinition;
+        highlighted: AnnotationThemeDefinition;
+    } & Record<string, AnnotationThemeDefinition>;
+}
+type AnnotationThemeDefinition = BoxStyle & {
+    hidden?: boolean;
+    interactive?: boolean;
+    hotspot?: boolean;
+    hotspotSize?: 'lg' | 'md' | 'sm';
+};
+declare function getDefaultAnnotationStyles(): AnnotationStyles['theme'];
+declare function useAnnotationStyles(): {
+    default: AnnotationThemeDefinition;
+    hidden: AnnotationThemeDefinition;
+    highlighted: AnnotationThemeDefinition;
+} & Record<string, AnnotationThemeDefinition>;
+declare function AnnotationStyleProvider({ theme, children, }: {
+    theme?: AnnotationStyles['theme'];
+    children: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
 declare function hasAuth(resource: any): boolean;
 interface ProbeStore {
     service?: AuthProbeService2;
@@ -880,14 +1270,14 @@ interface AuthState {
         expires: number;
     };
 }
-declare const AuthRContext: React$1.Context<StoreApi<AuthContextState & AuthContextCurrentActions & AuthContextActions> | null>;
+declare const AuthRContext: React$1.Context<StoreApi$1<AuthContextState & AuthContextCurrentActions & AuthContextActions> | null>;
 declare const AuthReactContext: React$1.Context<(AuthContextState & AuthContextCurrentActions) | null>;
 declare const AuthReactContextActions: React$1.Context<AuthContextActions | null>;
 declare function AuthProvider({ children }: {
     children: ReactNode;
 }): react_jsx_runtime.JSX.Element;
 declare function useIsAuthEnabled(): boolean;
-declare function useAuthStore(): StoreApi<AuthContextState & AuthContextCurrentActions & AuthContextActions>;
+declare function useAuthStore(): StoreApi$1<AuthContextState & AuthContextCurrentActions & AuthContextActions>;
 declare function useAuthActions(): {
     login: () => void;
     logout: () => void;
@@ -990,74 +1380,16 @@ interface ComplexTimelineStore extends MediaPlayerActions {
 
 declare function ComplexTimelineProvider({ children, store, }: {
     children: React.ReactNode;
-    store: StoreApi$1<ComplexTimelineStore>;
+    store: StoreApi<ComplexTimelineStore>;
 }): react_jsx_runtime.JSX.Element;
 declare function useComplexTimeline<T>(selector: (store: ComplexTimelineStore) => T): T;
 
-interface EventContext {
-    emitter: Emitter<any>;
+interface StrategyContext {
+    strategy: RenderingStrategy;
+    choices: ChoiceDescription | null;
 }
-declare const defaultEmitter: Emitter<Record<EventType, unknown>>;
-declare const ReactEventContext: React__default.Context<{
-    emitter: Emitter<Record<EventType, unknown>>;
-}>;
-declare function useEventEmitter<Events extends Record<EventType, unknown>>(): Emitter<Events>;
-declare function EventsProvider({ emitter, children }: EventContext & {
-    children: React__default.ReactNode;
-}): react_jsx_runtime.JSX.Element;
-
-declare function ManifestContext({ manifest, children }: {
-    manifest: string;
-    children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
-
-declare function useMediaState(): MediaPlayerState;
-declare function useMediaActions(): MediaPlayerActions;
-declare function useMediaElements(): {
-    element: RefObject<HTMLAudioElement | HTMLVideoElement>;
-    currentTime: RefObject<HTMLDivElement>;
-    progress: RefObject<HTMLDivElement>;
-};
-declare function MediaPlayerProvider({ actions, state, children, currentTime, progress, element, }: {
-    actions: MediaPlayerActions;
-    state: MediaPlayerState;
-    children: ReactNode;
-    currentTime: RefObject<HTMLDivElement>;
-    progress: RefObject<HTMLDivElement>;
-    element: RefObject<HTMLAudioElement | HTMLVideoElement>;
-}): react_jsx_runtime.JSX.Element;
-
-declare function RangeContext({ range, children }: {
-    range: string;
-    children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
-
-type ResourceContextType = {
-    collection?: string;
-    manifest?: string;
-    range?: string;
-    canvas?: string;
-    annotation?: string;
-    annotationPage?: string;
-};
-declare const ResourceReactContext: React__default.Context<ResourceContextType>;
-declare const useResourceContext: () => ResourceContextType;
-declare function ResourceProvider({ value, children }: {
-    value: ResourceContextType;
-    children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
-
-declare const ReactVaultContext: React__default.Context<{
-    vault: Vault | null;
-    setVaultInstance: (vault: Vault) => void;
-}>;
-declare function VaultProvider({ vault, vaultOptions, useGlobal, resources, children, }: {
-    vault?: Vault;
-    useGlobal?: boolean;
-    vaultOptions?: VaultOptions;
-    resources?: ResourceContextType;
-    children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
+declare const StrategyReactContext: React$1.Context<StrategyContext | null>;
+declare function useStrategy(): StrategyContext;
 
 type SearchService = SearchService$1 & {
     service: SearchServiceAutocomplete | SearchServiceAutocomplete[];
@@ -1080,6 +1412,21 @@ interface Search1Store {
     nextResult: () => void;
 }
 
+type ResourceContextType = {
+    collection?: string;
+    manifest?: string;
+    range?: string;
+    canvas?: string;
+    annotation?: string;
+    annotationPage?: string;
+};
+declare const ResourceReactContext: React__default.Context<ResourceContextType>;
+declare const useResourceContext: () => ResourceContextType;
+declare function ResourceProvider({ value, children }: {
+    value: ResourceContextType;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
 declare function useCustomContextBridge(): Record<string, {
     value: any;
     Provider: React__default.Provider<any>;
@@ -1089,39 +1436,85 @@ declare function CustomContextBridge(props: Record<string, {
     Provider: React__default.Provider<any>;
 }> & {
     children: React__default.ReactNode;
-}): ReactNode;
+}): React__default.ReactNode;
 declare function CustomContextBridgeProvider(props: {
     providers: Record<string, Context<any>>;
     children: React__default.ReactNode;
 }): react_jsx_runtime.JSX.Element;
-declare function useContextBridge(): {
-    VaultContext: {
-        vault: _iiif_helpers.Vault | null;
-        setVaultInstance: (vault: _iiif_helpers.Vault) => void;
-    };
-    ResourceContext: ResourceContextType;
-    SimpleViewerReactContext: SimpleViewerContext;
-    VisibleCanvasReactContext: string[];
-    AuthRContext: zustand.StoreApi<AuthContextState & AuthContextCurrentActions & AuthContextActions> | null;
-    SearchReactContext: zustand.StoreApi<Search1Store> | null;
-    ReactEventContext: {
-        emitter: mitt.Emitter<Record<mitt.EventType, unknown>>;
-    };
+declare function useContextBridge(): {
+    VaultContext: {
+        vault: _iiif_helpers.Vault | null;
+        setVaultInstance: (vault: _iiif_helpers.Vault) => void;
+    };
+    ResourceContext: ResourceContextType;
+    SimpleViewerReactContext: SimpleViewerContext;
+    VisibleCanvasReactContext: string[];
+    AuthRContext: zustand.StoreApi<AuthContextState & AuthContextCurrentActions & AuthContextActions> | null;
+    SearchReactContext: zustand.StoreApi<Search1Store> | null;
+    ReactEventContext: {
+        emitter: mitt.Emitter<Record<mitt.EventType, unknown>>;
+    };
+    ContextBridgeReactContext: Record<string, React__default.Context<any>>;
+    StrategyReactContext: StrategyContext | null;
+    AtlasStoreReactContext: zustand.StoreApi<AtlasStore> | null;
+};
+declare function ContextBridge(props: {
+    bridge: ReturnType<typeof useContextBridge>;
+    custom?: ReturnType<typeof useCustomContextBridge>;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+interface ControlsContext {
+    renderMediaControls?: (strategy: MediaStrategy) => ReactNode;
+    viewControlsDeps: any[];
+    renderViewerControls?: (strategy: SingleImageStrategy | EmptyStrategy) => ReactNode;
+    mediaControlsDeps: any[];
+    renderComplexTimelineControls?: (strategy: ComplexTimelineStrategy) => ReactNode;
+    complexTimelineControlsDeps: any[];
+}
+declare const ControlsReactContext: React$1.Context<ControlsContext | null>;
+declare function useRenderControls(): ControlsContext;
+
+interface EventContext {
+    emitter: Emitter<any>;
+}
+declare const defaultEmitter: Emitter<Record<EventType, unknown>>;
+declare const ReactEventContext: React__default.Context<{
+    emitter: Emitter<Record<EventType, unknown>>;
+}>;
+declare function useEventEmitter<Events extends Record<EventType, unknown>>(): Emitter<Events>;
+declare function EventsProvider({ emitter, children }: EventContext & {
+    children: React__default.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare const ImageServiceLoaderContext: React__default.Context<ImageServiceLoader>;
+declare function useImageServiceLoader(): ImageServiceLoader;
+
+declare function ManifestContext({ manifest, children }: {
+    manifest: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function useMediaState(): MediaPlayerState;
+declare function useMediaActions(): MediaPlayerActions;
+declare function useMediaElements(): {
+    element: RefObject<HTMLAudioElement | HTMLVideoElement>;
+    currentTime: RefObject<HTMLDivElement>;
+    progress: RefObject<HTMLDivElement>;
 };
-declare function ContextBridge(props: {
-    bridge: ReturnType<typeof useContextBridge>;
-    custom?: ReturnType<typeof useCustomContextBridge>;
+declare function MediaPlayerProvider({ actions, state, children, currentTime, progress, element, }: {
+    actions: MediaPlayerActions;
+    state: MediaPlayerState;
     children: ReactNode;
+    currentTime: RefObject<HTMLDivElement>;
+    progress: RefObject<HTMLDivElement>;
+    element: RefObject<HTMLAudioElement | HTMLVideoElement>;
 }): react_jsx_runtime.JSX.Element;
 
-declare const VisibleCanvasReactContext: React__default.Context<string[]>;
-declare function useVisibleCanvases(): CanvasNormalized[];
-
-declare const ViewerPresetContext: React$1.Context<Preset | null | undefined>;
-declare function useViewerPreset(): Preset | null | undefined;
-
-declare const ImageServiceLoaderContext: React__default.Context<ImageServiceLoader>;
-declare function useImageServiceLoader(): ImageServiceLoader;
+declare function RangeContext({ range, children }: {
+    range: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
 
 type SelectorHelperEventTypes = 'click' | 'hover' | 'selector-updated' | 'highlight' | 'clear-highlight' | 'zoom-to' | 'event-listener' | 'remove-event-listener' | 'image-preview-request';
 declare function SelectorControllerProvider({ children }: {
@@ -1192,70 +1585,23 @@ declare function useSelectorHelper(): {
     } = any>(type: SelectorHelperEventTypes, handler: Handler<T_1>): () => void;
 };
 
-interface AnnotationStyles {
-    id: number;
-    name: string;
-    creator?: {
-        id: number;
-        name: string;
-    };
-    createdAt: Date;
-    theme: {
-        default: AnnotationThemeDefinition;
-        hidden: AnnotationThemeDefinition;
-        highlighted: AnnotationThemeDefinition;
-    } & Record<string, AnnotationThemeDefinition>;
-}
-type AnnotationThemeDefinition = BoxStyle & {
-    hidden?: boolean;
-    interactive?: boolean;
-    hotspot?: boolean;
-    hotspotSize?: 'lg' | 'md' | 'sm';
-};
-declare function getDefaultAnnotationStyles(): AnnotationStyles['theme'];
-declare function useAnnotationStyles(): {
-    default: AnnotationThemeDefinition;
-    hidden: AnnotationThemeDefinition;
-    highlighted: AnnotationThemeDefinition;
-} & Record<string, AnnotationThemeDefinition>;
-declare function AnnotationStyleProvider({ theme, children, }: {
-    theme?: AnnotationStyles['theme'];
-    children: React.ReactNode;
+declare const ReactVaultContext: React__default.Context<{
+    vault: Vault | null;
+    setVaultInstance: (vault: Vault) => void;
+}>;
+declare function VaultProvider({ vault, vaultOptions, useGlobal, resources, children, }: {
+    vault?: Vault;
+    useGlobal?: boolean;
+    vaultOptions?: VaultOptions;
+    resources?: ResourceContextType;
+    children: ReactNode;
 }): react_jsx_runtime.JSX.Element;
 
-interface StrategyContext {
-    strategy: RenderingStrategy;
-    choices: ChoiceDescription | null;
-}
-declare const StrategyReactContext: React$1.Context<StrategyContext | null>;
-declare function useStrategy(): StrategyContext;
-
-interface ControlsContext {
-    renderMediaControls?: (strategy: MediaStrategy) => ReactNode;
-    viewControlsDeps: any[];
-    renderViewerControls?: (strategy: SingleImageStrategy | EmptyStrategy) => ReactNode;
-    mediaControlsDeps: any[];
-    renderComplexTimelineControls?: (strategy: ComplexTimelineStrategy) => ReactNode;
-    complexTimelineControlsDeps: any[];
-}
-declare const ControlsReactContext: React$1.Context<ControlsContext | null>;
-declare function useRenderControls(): ControlsContext;
+declare const ViewerPresetContext: React$1.Context<Preset | null | undefined>;
+declare function useViewerPreset(): Preset | null | undefined;
 
-/**
- * Parse specific resource.
- *
- * This could be expanded to support pulling out more from the specific resource.
- *
- * @param resource
- */
-declare function parseSpecificResource(resource: ContentResource): any[];
-declare function getParsedTargetSelector(canvas: CanvasNormalized, target: W3CAnnotationTarget | W3CAnnotationTarget[]): [TemporalBoxSelector$1 | BoxSelector$1 | PointSelector | null, SupportedTarget['source']];
-declare const emptyActions: {
-    makeChoice: () => void;
-};
-declare const unknownResponse: UseRenderingStrategy[0];
-declare const unsupportedStrategy: (reason: string) => UnknownStrategy;
-declare const emptyStrategy: (width: number, height: number) => UseRenderingStrategy[0];
+declare const VisibleCanvasReactContext: React__default.Context<string[]>;
+declare function useVisibleCanvases(): CanvasNormalized[];
 
 type CompatVault = {
     get: _iiif_helpers_vault.Vault['get'];
@@ -1265,7 +1611,7 @@ type CompatVault = {
     requestStatus: _iiif_helpers_vault.Vault['requestStatus'];
 };
 
-declare function getVideoStrategy(canvas: CanvasNormalized, paintables: Paintables, vault: CompatVault): UnknownStrategy | MediaStrategy;
+declare function getComplexTimelineStrategy(canvas: CanvasNormalized, paintables: Paintables, loadImageService: ImageServiceLoaderType, vault: CompatVault): ComplexTimelineStrategy;
 
 interface GetRenderStrategyOptions {
     canvas: CanvasNormalized | null | undefined;
@@ -1276,7 +1622,23 @@ interface GetRenderStrategyOptions {
 }
 declare function getRenderingStrategy({ canvas, paintables, supports, loadImageService, vault, }: GetRenderStrategyOptions): RenderingStrategy;
 
-declare function getComplexTimelineStrategy(canvas: CanvasNormalized, paintables: Paintables, loadImageService: ImageServiceLoaderType, vault: CompatVault): ComplexTimelineStrategy;
+/**
+ * Parse specific resource.
+ *
+ * This could be expanded to support pulling out more from the specific resource.
+ *
+ * @param resource
+ */
+declare function parseSpecificResource(resource: ContentResource): any[];
+declare function getParsedTargetSelector(canvas: CanvasNormalized, target: W3CAnnotationTarget | W3CAnnotationTarget[]): [TemporalBoxSelector$1 | BoxSelector$1 | PointSelector | null, SupportedTarget['source']];
+declare const emptyActions: {
+    makeChoice: () => void;
+};
+declare const unknownResponse: UseRenderingStrategy[0];
+declare const unsupportedStrategy: (reason: string) => UnknownStrategy;
+declare const emptyStrategy: (width: number, height: number) => UseRenderingStrategy[0];
+
+declare function getVideoStrategy(canvas: CanvasNormalized, paintables: Paintables, vault: CompatVault): UnknownStrategy | MediaStrategy;
 
 declare function useAnnotation(options?: {
     id: string;
@@ -1334,13 +1696,13 @@ declare function useCanvasChoices({ canvasId }?: {
 
 declare function useCanvasClock(canvasId?: string, autoplay?: boolean): void;
 
-declare function useCanvasSubset(idsOrRefs?: Array<string | Reference>): Reference<'Canvas'>[];
-
 declare function useCanvasStartTime(): {
     startTime: number;
     endTime?: number | undefined;
 } | null;
 
+declare function useCanvasSubset(idsOrRefs?: Array<string | Reference>): Reference<'Canvas'>[];
+
 declare function useCollection(options: {
     id: string;
 }): CollectionNormalized | undefined;
@@ -1349,11 +1711,37 @@ declare function useCollection<T>(options: {
     selector: (collection: CollectionNormalized) => T;
 }, deps?: any[]): T | undefined;
 
+declare function useCurrentAnnotationActions(): {
+    saveAnnotation: () => void;
+    cancelRequest: (requestId?: string | undefined) => void;
+};
+
+declare function useCurrentAnnotationMetadata({ requestId: customRequestId }?: {
+    requestId?: string;
+}): readonly [Record<string, any>, (data: Record<string, any>) => void];
+
+declare function useCurrentAnnotationRequest(): AnnotationRequest | null;
+
+declare function useCurrentAnnotationTransition(options: {
+    requestId?: string | null;
+    onStart?: (type: string) => void;
+    onEnd?: (type: string, response: PolygonEvents['polygons.end-transition']['response']) => void;
+    onTransition?: (type: string) => void;
+}): void;
+
 declare function useDispatch(): VaultZustandStore['dispatch'];
 
 type SupportedEvents = 'onClick';
 declare function useEventListener<T>(resource: Reference, name: SupportedEvents, listener: (e: any, resource: T) => void, scope?: string[], deps?: any[]): void;
 
+declare const ReactEmitterContext: React$1.Context<Emitter<any>>;
+declare function EventEmitterProvider({ children, emitter, }: {
+    children: React.ReactNode;
+    emitter: Emitter<any>;
+}): react_jsx_runtime.JSX.Element;
+declare function useEmitter<Event extends Record<string | symbol, unknown>>(): Emitter<Event>;
+declare function useEvent<Event extends Record<string | symbol, unknown>, Key extends keyof Event>(key: Key, listener: (data: Event[Key]) => void, deps?: any[]): void;
+
 declare function useExistingVault(vault?: Vault): Vault;
 
 type ResourceRequestOptions = {
@@ -1454,6 +1842,126 @@ declare function usePaintingAnnotations(options?: {
     enableSingleAnnotation?: boolean;
 }): AnnotationNormalized[];
 
+declare function usePolygonHelper(render: (t: any, s: any, dt: number) => void): {
+    currentShape: polygon_editor.InputShape | null;
+    state: polygon_editor.SlowState;
+    helper: {
+        state: polygon_editor.RenderState;
+        setState: (newState: Partial<polygon_editor.SlowState>) => void;
+        emitter: mitt.Emitter<polygon_editor.PolygonEvents>;
+        modifiers: {
+            reset(): void;
+            getForType(type: string | null): Record<string, string>;
+            set(modifier: string): void;
+            unset(modifier: string): void;
+        };
+        stamps: {
+            set(selectedStamp: polygon_editor.InputShape | null): void;
+            clear(): void;
+            square(): void;
+            triangle(): void;
+            pentagon(): void;
+            hexagon(): void;
+            circle(): void;
+        };
+        history: {
+            undo: () => void;
+            redo: () => void;
+            readonly canUndo: boolean;
+            readonly canRedo: boolean;
+        };
+        key: {
+            down(inputKey: string): boolean | undefined;
+            up(inputKey: string): void;
+        };
+        setScale: (scale: number) => void;
+        clock: {
+            set: (renderFunc: polygon_editor.RenderFunc) => void;
+            start: (renderFunc?: polygon_editor.RenderFunc | undefined, setStateFunc?: polygon_editor.SetState | undefined) => void;
+            stop: () => void;
+            step: (deltaTime?: number | undefined) => void;
+        };
+        pointer: (pointers: ([number, number] | [number, number, number, number, number, number])[]) => void;
+        blur: () => void;
+        pointerDown: () => void;
+        pointerUp: () => void;
+        setShape: (shape: polygon_editor.InputShape | null) => void;
+        label: (type: string | null) => string;
+        tools: {
+            setTool: (tool: polygon_editor.ValidTools) => void;
+            unsetTool: (tool: polygon_editor.ValidTools) => void;
+            toggleTool: (tool: polygon_editor.ValidTools) => void;
+            updateVisibility: (tool: polygon_editor.ValidTools) => void;
+            setCanDelete(canDelete: boolean): void;
+            setCanDeselect(canDeselect: boolean): void;
+            lockToolSwitching(): void;
+            unlockToolSwitching(): void;
+            toggleToolSwitching(): void;
+            shortcuts: {
+                [k: string]: string;
+            };
+            getValidIntents(tool?: polygon_editor.ValidTools | undefined): {
+                actions: polygon_editor.ActionIntent[];
+                transitions: polygon_editor.TransitionIntent[];
+                keys: polygon_editor.ActionIntent[];
+                all: Record<string, string>;
+                current: Record<string, string>;
+            };
+            getToolInfo(): {
+                name: polygon_editor.ValidTools;
+                cursor: string;
+                selectionCount: number;
+                pointCount: number;
+                isOpen: boolean;
+            };
+            smartSelect(): void;
+            clearSelection(): void;
+            autoSelect(): void;
+        };
+        snap: {
+            enabled: () => boolean;
+            enable: () => void;
+            disable: () => void;
+            toggle: () => void;
+            pointsEnabled: () => boolean;
+            enablePoints: () => void;
+            disablePoints: () => void;
+            togglePoints: () => void;
+            linesEnabled: () => boolean;
+            enableLines: () => void;
+            disableLines: () => void;
+            toggleLines: () => void;
+            intersectionsEnabled: () => boolean;
+            enableIntersections: () => void;
+            disableIntersections: () => void;
+            toggleIntersections: () => void;
+            gridEnabled: () => boolean;
+            enableGrid: () => void;
+            disableGrid: () => void;
+            toggleGrid: () => void;
+            parallelEnabled: () => boolean;
+            enableParallel: () => void;
+            disableParallel: () => void;
+            toggleParallel: () => void;
+            getThreshold: () => number;
+            setThreshold: (threshold: number) => void;
+            isActive: () => boolean;
+            getSnapPoint: () => ([number, number] | [number, number, number, number, number, number]) | null;
+            getActiveGuides: () => polygon_editor.SnapGuide[];
+            getTargets: () => polygon_editor.SnapTarget[];
+        };
+        selectAllPoints: () => void;
+        setBounds: (bounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        } | null) => void;
+        lockAspectRatio: () => void;
+        unlockAspectRatio: () => void;
+    };
+};
+
 declare function useRange(options?: {
     id: string;
 }): RangeNormalized | undefined;
@@ -1462,6 +1970,21 @@ declare function useRange<T>(options?: {
     selector: (range: RangeNormalized) => T;
 }, deps?: any[]): T | undefined;
 
+declare function useRequestAnnotation(opts?: {
+    onSuccess?: (r: AnnotationResponse) => void;
+}): {
+    id: number;
+    busy: boolean;
+    isPending: boolean;
+    isActive: boolean;
+    requestId: string | null;
+    requestAnnotation: (request: AnnotationRequest, options?: Omit<AnnotationRequestOptions, 'requestId'>) => Promise<AnnotationResponse | null>;
+    cancelRequest: () => void;
+    completeRequest: () => void;
+    reset: () => void;
+    data: AnnotationResponse | null;
+};
+
 declare function useResourceEvents<T extends NormalizedEntity>(resource?: Reference, scope?: string[]): any;
 
 declare function useResources<Type>(ids: string[], type: string): Type[];
@@ -1473,6 +1996,25 @@ declare function useStyleHelper(): _iiif_helpers_styles.StyledHelper<_iiif_helpe
 declare function useStyles<Style extends Record<string, Record<string, any>>>(resource: undefined | Reference<any>): Style;
 declare function useStyles<Style extends Record<string, any>>(resource: undefined | Reference<any>, scope: string): Style;
 
+declare function useSvgEditorControls(): {
+    completeRequest: (requestId?: string | undefined) => void;
+    currentTool: polygon_editor.ValidTools;
+    selectedStamp: polygon_editor.InputShape | null;
+    switchTool: {
+        draw(): void;
+        pen(): void;
+        line(): void;
+        lineBox(): void;
+        box(): void;
+        triangle(): void;
+        hexagon(): void;
+        circle(): void;
+        remove(): void;
+        hand(): void;
+        pointer(): void;
+    };
+};
+
 declare function useThumbnail(request: ImageCandidateRequest, dereference?: boolean, { canvasId, manifestId }?: {
     canvasId?: string;
     manifestId?: string;
@@ -1504,57 +2046,6 @@ declare function VirtualAnnotationProvider({ children }: {
     children: any;
 }): react_jsx_runtime.JSX.Element;
 
-declare function usePolygonHelper(data: any, render: (t: any, s: any) => void, commitShape: (shape: InputShape) => void): {
-    state: SlowState;
-    helper: {
-        draw: {
-            enable(): void;
-            disable(): void;
-            toggle(): void;
-        };
-        state: polygon_editor.RenderState;
-        modifiers: {
-            reset(): void;
-            getForType(type: string | null): Record<string, string>;
-            set(modifier: string): void;
-            unset(modifier: string): void;
-        };
-        stamps: {
-            set(selectedStamp: InputShape | null): void;
-            clear(): void;
-            square(): void;
-            triangle(): void;
-            pentagon(): void;
-            hexagon(): void;
-        };
-        key: {
-            down(key: string): true | undefined;
-            up(key: string): void;
-        };
-        setScale: (scale: number) => void;
-        clock: {
-            set: (renderFunc: polygon_editor.RenderFunc) => void;
-            start: (renderFunc?: polygon_editor.RenderFunc | undefined, setStateFunc?: polygon_editor.SetState | undefined) => void;
-            stop: () => void;
-            step: (deltaTime?: number | undefined) => void;
-        };
-        pointer: (pointers: ([number, number] | [number, number, number, number, number, number])[]) => void;
-        blur: () => void;
-        pointerDown: () => void;
-        pointerUp: () => void;
-        setShape: (shape: InputShape | null) => void;
-        modes: {
-            toggleLineBoxMode: () => void;
-            toggleLineMode: () => void;
-            enableLineMode(): void;
-            disableLineMode(): void;
-            enableLineBoxMode(): void;
-            disableLineBoxMode(): void;
-        };
-        label: (type: string | null) => string;
-    };
-};
-
 declare function flattenAnnotationPageIds({ canvas, manifest, all, canvases, }: {
     manifest?: ManifestNormalized;
     canvas?: CanvasNormalized;
@@ -1600,6 +2091,36 @@ type LocaleStringProps = {
 } & Record<string, any>;
 declare function LocaleString({ as: Component, defaultText, enableDangerouslySetInnerHTML, children, separator, ...props }: LocaleStringProps): react_jsx_runtime.JSX.Element;
 
+declare function targetIntersects(a: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, b: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): boolean;
+
+declare function annotationResponseToSelector(response: {
+    polygon: AnnotationResponse['polygon'];
+    boundingBox?: AnnotationResponse['boundingBox'];
+    target?: AnnotationResponse['target'];
+}, on?: {
+    width: number;
+    height: number;
+} | null): SupportedSelector;
+
+declare function isRectangle(points: InputShape['points']): boolean;
+
+declare function isSvgSelector(t: SupportedSelector): t is SvgSelector$1;
+declare function isBoxSelector(t: SupportedSelector): t is BoxSelector$1;
+declare function seraliseSupportedSelector(selector: SupportedSelector, on?: {
+    width: number;
+    height: number;
+} | null): null | SvgSelector | FragmentSelector;
+
 declare const SimpleViewerReactContext: React__default.Context<SimpleViewerContext>;
 declare function InnerViewerProvider(props: SimpleViewerProps): react_jsx_runtime.JSX.Element | null;
 declare function SimpleViewerProvider(props: SimpleViewerProps): react_jsx_runtime.JSX.Element;
@@ -1625,6 +2146,11 @@ declare function useCanvasSequence({ startCanvas, disablePaging }: {
     previous: () => void;
 };
 
+declare function findFirstCanvasFromRange(vault: Vault, range: RangeNormalized): null | Reference<'Canvas'>;
+declare function findAllCanvasesInRange(vault: Vault, range: RangeNormalized): Array<Reference<'Canvas'>>;
+declare function findManifestSelectedRange(vault: Vault, manifest: ManifestNormalized, canvasId: string): null | RangeNormalized;
+declare function findSelectedRange(vault: Vault, range: RangeNormalized, canvasId: string): null | RangeNormalized;
+
 /**
  * Get visible canvases from canvas ID
  *
@@ -1662,9 +2188,4 @@ declare function getManifestSequence(vault: Vault, manifestOrRange: ManifestNorm
     skipNonPaged?: boolean;
 }): [Reference<'Canvas'>[], number[][]];
 
-declare function findFirstCanvasFromRange(vault: Vault, range: RangeNormalized): null | Reference<'Canvas'>;
-declare function findAllCanvasesInRange(vault: Vault, range: RangeNormalized): Array<Reference<'Canvas'>>;
-declare function findManifestSelectedRange(vault: Vault, manifest: ManifestNormalized, canvasId: string): null | RangeNormalized;
-declare function findSelectedRange(vault: Vault, range: RangeNormalized, canvasId: string): null | RangeNormalized;
-
-export { AnnotationContext, AnnotationPageContext, type AnnotationPageDescription, type AnnotationStrategyProps, AnnotationStyleProvider, type AnnotationStyles, type AnnotationThemeDefinition, type AudioSequence, Auth, type AuthAccessState, type AuthContextActions, type AuthContextCurrentActions, type AuthContextState, AuthProvider, AuthRContext, AuthReactContext, AuthReactContextActions, type AuthState, CanvasAnnotations, CanvasContext, CanvasPanel, CanvasStrategyProvider, CanvasWorldObject, type ChoiceEvents, CollectionContext, CombinedMetadata, ComplexTimelineProvider, type ComplexTimelineStrategy, ContextBridge, type ControlsContext, ControlsReactContext, CreateCustomShape, type CreateCustomShapeProps, CustomContextBridge, CustomContextBridgeProvider, type EmptyStrategy, EventsProvider, Image, type ImageProps, ImageService, ImageServiceLoaderContext, type ImageServiceLoaderType, type ImageServiceRequestOptions, type ImageStrategyProps, type ImageWithOptionalService, InnerViewerProvider, LanguageProvider, LanguageString, LocaleString, ManifestContext, ManifestMetadata, type MediaPlayerActions, MediaPlayerProvider, type MediaPlayerState, type MediaStrategy, Metadata, type MetadataProps, PolygonSelector, type PolygonSelectorProps, type ProbeStore, RangeContext, ReactEventContext, ReactVaultContext, Render3DModelStrategy, RenderAccompanyingCanvas, RenderAnnotationStrategy, RenderAudioStrategy, RenderComplexTimelineStrategy, RenderEmptyStrategy, RenderImageStrategy, RenderSvgEditorControls, RenderTextualContentStrategy, RenderVideoStrategy, RenderYouTubeStrategy, type RenderingStrategy, type ResourceContextType, ResourceProvider, ResourceReactContext, type ResourceRequestOptions, SelectorControllerProvider, type SelectorHelperEventTypes, SequenceThumbnails, type SimpleViewerActions, type SimpleViewerActionsType, type SimpleViewerContext, type SimpleViewerProps, SimpleViewerProvider, SimpleViewerReactContext, type SimpleViewerReducerState, type Single3DModelStrategy, type SingleAudio, SingleCanvasThumbnail, type SingleImageStrategy, type SingleVideo, type SingleYouTubeVideo, type StrategyActions, type StrategyContext, StrategyReactContext, type SvgTheme, type TextContent, type TextualContentStrategy, ThumbnailFallbackImage, type TimelineKeyframe, TranslationProvider, TransliterationProvider, type UnknownStrategy, type UseRenderingStrategy, type UseRenderingStrategyOptions, type VaultActivatedAnnotation, VaultProvider, type VideoSequence, ViewerPresetContext, VirtualAnnotationProvider, VisibleCanvasReactContext, authDetailsForResource, createAuthStateStore, createProbe, defaultEmitter, emptyActions, emptyStrategy, findAllCanvasesInRange, findFirstCanvasFromRange, findManifestSelectedRange, findSelectedRange, flattenAnnotationPageIds, formatTime, get3dStrategy, getComplexTimelineStrategy, getDefaultAnnotationStyles, getImageStrategy, getManifestSequence, getParsedTargetSelector, getRenderingStrategy, getTextualContentStrategy, getVideoStrategy, getVisibleCanvasesFromCanvasId, hasAuth, makeAccessServiceRequest, makeAccessTokenRequest, parseSpecificResource, svgThemes, unknownResponse, unsupportedStrategy, useAnnotation, useAnnotationPage, useAnnotationPageManager, useAnnotationStyles, useAnnotationsAtTime, useAuthActions, useAuthService, useAuthStore, useAuthToken, useAuthTokens, useCanvas, useCanvasChoices, useCanvasClock, useCanvasSequence, useCanvasStartTime, useCanvasSubset, useClosestLanguage, useCollection, useComplexTimeline, useContextBridge, useCreateLocaleString, useCurrentAuth, useCustomContextBridge, useDispatch, useEventEmitter, useEventListener, useExistingVault, useExternalCollection, useExternalManifest, useExternalResource, useIIIFLanguage, useImage, useImageService, useImageServiceLoader, useImageTile, useIsAuthEnabled, useLoadImageService, useLocaleString, useManifest, useMediaActions, useMediaElements, useMediaState, usePaintables, usePaintingAnnotations, usePolygonHelper, useRange, useRenderControls, useRenderingStrategy, useResourceContext, useResourceEvents, useResources, useSearchService, useSelectorController, useSelectorEmitter, useSelectorEvents, useSelectorHelper, useSimpleMediaPlayer, useSimpleViewer, useStrategy, useStyleHelper, useStyles, useSvgEditor, useThumbnail, useTranslations, useTransliteration, useVault, useVaultEffect, useVaultSelector, useViewerPreset, useVirtualAnnotationPage, useVirtualAnnotationPageContext, useVisibleCanvases };
+export { AnnotationContext, AnnotationPageContext, type AnnotationPageDescription, type AnnotationRequest, type AnnotationRequestOptions, type AnnotationResponse, type AnnotationStrategyProps, AnnotationStyleProvider, type AnnotationStyles, type AnnotationThemeDefinition, type AtlasStore, type AtlasStoreEvents, AtlasStoreProvider, AtlasStoreReactContext, type AudioSequence, Auth, type AuthAccessState, type AuthContextActions, type AuthContextCurrentActions, type AuthContextState, AuthProvider, AuthRContext, AuthReactContext, AuthReactContextActions, type AuthState, CanvasAnnotations, CanvasContext, CanvasPanel, type CanvasPanelProps, CanvasStrategyProvider, CanvasWorldObject, type ChoiceEvents, CollectionContext, CombinedMetadata, ComplexTimelineProvider, type ComplexTimelineStrategy, ContextBridge, type ControlsContext, ControlsReactContext, type CreateAtlasStoreProps, CreateCustomShape, type CreateCustomShapeProps, CustomContextBridge, CustomContextBridgeProvider, DefaultEditingTools, type EmptyStrategy, EventEmitterProvider, EventsProvider, Image, type ImageProps, ImageService, ImageServiceLoaderContext, type ImageServiceLoaderType, type ImageServiceRequestOptions, type ImageStrategyProps, type ImageWithOptionalService, InnerViewerProvider, LanguageProvider, LanguageString, LocaleString, ManifestContext, ManifestMetadata, type MediaPlayerActions, MediaPlayerProvider, type MediaPlayerState, type MediaStrategy, Metadata, type MetadataProps, PolygonSelector, type PolygonSelectorProps, type ProbeStore, RangeContext, ReactEmitterContext, ReactEventContext, ReactVaultContext, Render3DModelStrategy, RenderAccompanyingCanvas, RenderAnnotation, RenderAnnotationEditing, RenderAnnotationPage, RenderAnnotationStrategy, RenderAudioStrategy, RenderComplexTimelineStrategy, type RenderContextProps, RenderEmptyStrategy, RenderImageStrategy, RenderSvgEditorControls, RenderTextualContentStrategy, RenderVideoStrategy, RenderYouTubeStrategy, type RenderingStrategy, type ResourceContextType, ResourceProvider, ResourceReactContext, type ResourceRequestOptions, type SVGTheme, SelectorControllerProvider, type SelectorHelperEventTypes, SequenceThumbnails, type SimpleViewerActions, type SimpleViewerActionsType, type SimpleViewerContext, type SimpleViewerProps, SimpleViewerProvider, SimpleViewerReactContext, type SimpleViewerReducerState, type Single3DModelStrategy, type SingleAudio, SingleCanvasThumbnail, type SingleImageStrategy, type SingleVideo, type SingleYouTubeVideo, type StrategyActions, type StrategyContext, StrategyReactContext, type SvgTheme, type TextContent, type TextualContentStrategy, ThumbnailFallbackImage, type TimelineKeyframe, TranslationProvider, TransliterationProvider, type UnknownStrategy, type UseRenderingStrategy, type UseRenderingStrategyOptions, type VaultActivatedAnnotation, VaultProvider, type VideoSequence, ViewerPresetContext, VirtualAnnotationProvider, VisibleCanvasReactContext, annotationResponseToSelector, authDetailsForResource, createAtlasStore, createAuthStateStore, createProbe, defaultEmitter, defaultSvgTheme, emptyActions, emptyStrategy, findAllCanvasesInRange, findFirstCanvasFromRange, findManifestSelectedRange, findSelectedRange, flattenAnnotationPageIds, formatTime, get3dStrategy, getAtlasStoreByName, getComplexTimelineStrategy, getDefaultAnnotationStyles, getImageStrategy, getManifestSequence, getParsedTargetSelector, getRenderingStrategy, getTextualContentStrategy, getVideoStrategy, getVisibleCanvasesFromCanvasId, hasAuth, isBoxSelector, isRectangle, isSvgSelector, makeAccessServiceRequest, makeAccessTokenRequest, parseSpecificResource, polygonToTarget, requestToAnnotationResponse, seraliseSupportedSelector, svgThemes, targetIntersects, unknownResponse, unsupportedStrategy, useAnnotation, useAnnotationPage, useAnnotationPageManager, useAnnotationStyles, useAnnotationsAtTime, useAtlasContextMenu, useAtlasStore, useAuthActions, useAuthService, useAuthStore, useAuthToken, useAuthTokens, useCanvas, useCanvasChoices, useCanvasClock, useCanvasSequence, useCanvasStartTime, useCanvasSubset, useClosestLanguage, useCollection, useComplexTimeline, useContextBridge, useContextMenuStore, useCreateLocaleString, useCurrentAnnotationActions, useCurrentAnnotationMetadata, useCurrentAnnotationRequest, useCurrentAnnotationTransition, useCurrentAuth, useCustomContextBridge, useDispatch, useEmitter, useEvent, useEventEmitter, useEventListener, useExistingVault, useExternalCollection, useExternalManifest, useExternalResource, useIIIFLanguage, useImage, useImageService, useImageServiceLoader, useImageTile, useIsAuthEnabled, useLoadImageService, useLocaleString, useManifest, useMediaActions, useMediaElements, useMediaState, usePaintables, usePaintingAnnotations, usePolygonHelper, useRange, useRenderControls, useRenderingStrategy, useRequestAnnotation, useResourceContext, useResourceEvents, useResources, useSearchService, useSelectorController, useSelectorEmitter, useSelectorEvents, useSelectorHelper, useSimpleMediaPlayer, useSimpleViewer, useStrategy, useStyleHelper, useStyles, useSvgEditor, useSvgEditorControls, useThumbnail, useTranslations, useTransliteration, useVault, useVaultEffect, useVaultSelector, useViewerPreset, useVirtualAnnotationPage, useVirtualAnnotationPageContext, useVisibleCanvases };