react-iiif-vault 1.5.9 → 2.0.0

package/dist/index.d.ts

@@ -1,32 +1,39 @@
-import { A as AudioComponentProps, V as VideoComponentProps, S as SimpleViewerContext, a as SimpleViewerProps } from './index-CrfymD6m.js';
-export { C as CanvasPanel, c as SimpleViewerActions, d as SimpleViewerActionsType, b as SimpleViewerReducerState } from './index-CrfymD6m.js';
+export * from '@iiif/helpers/annotation-targets';
+import { S as SVGTheme, R as RenderContextProps, A as AudioComponentProps, V as VideoComponentProps, u as useSvgEditor, a as SimpleViewerContext, b as AtlasStore, c as AnnotationRequest, d as AnnotationResponse, e as AnnotationRequestOptions, f as SimpleViewerProps } from './index-yy_738ck.js';
+export { h as AtlasStoreEvents, n as AtlasStoreProvider, k as AtlasStoreReactContext, g as CanvasPanel, C as CanvasPanelProps, i as CreateAtlasStoreProps, o as RenderAnnotation, q as RenderAnnotationPage, x as SimpleViewerActions, y as SimpleViewerActionsType, w as SimpleViewerReducerState, j as createAtlasStore, v as defaultSvgTheme, m as getAtlasStoreByName, p as polygonToTarget, r as requestToAnnotationResponse, t as useAtlasContextMenu, l as useAtlasStore, s as useContextMenuStore } from './index-yy_738ck.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React$1 from 'react';
 import React__default, { ReactNode, FunctionComponent, RefObject, Context } from 'react';
-import { R as RenderingStrategy, b as StrategyActions, M as MediaStrategy, c as SingleImageStrategy, E as EmptyStrategy, C as ComplexTimelineStrategy, I as ImageWithOptionalService, T as TimelineKeyframe, U as UnknownStrategy, d as ImageServiceLoaderType } from './useRenderingStrategy-BiuSDiXu.js';
-export { f as AnnotationPageDescription, A as AudioSequence, n as ChoiceEvents, k as Single3DModelStrategy, S as SingleAudio, a as SingleVideo, e as SingleYouTubeVideo, i as TextContent, h as TextualContentStrategy, m as UseRenderingStrategy, o as UseRenderingStrategyOptions, V as VideoSequence, l as get3dStrategy, g as getImageStrategy, j as getTextualContentStrategy, u as useLoadImageService, p as useRenderingStrategy } from './useRenderingStrategy-BiuSDiXu.js';
+import { R as RenderingStrategy, b as StrategyActions, M as MediaStrategy, c as SingleImageStrategy, E as EmptyStrategy, C as ComplexTimelineStrategy, I as ImageWithOptionalService, T as TimelineKeyframe, d as ImageServiceLoaderType, U as UnknownStrategy } from './useRenderingStrategy-PvoNjiMV.js';
+export { i as AnnotationPageDescription, A as AudioSequence, n as ChoiceEvents, e as Single3DModelStrategy, S as SingleAudio, a as SingleVideo, h as SingleYouTubeVideo, k as TextContent, j as TextualContentStrategy, m as UseRenderingStrategy, o as UseRenderingStrategyOptions, V as VideoSequence, g as get3dStrategy, f as getImageStrategy, l as getTextualContentStrategy, u as useLoadImageService, p as useRenderingStrategy } from './useRenderingStrategy-PvoNjiMV.js';
 import * as _iiif_helpers from '@iiif/helpers';
-import { ChoiceDescription, Paintables, ComplexChoice } from '@iiif/helpers';
+import { ChoiceDescription, Paintables, ComplexChoice, SupportedSelector, SvgSelector, BoxSelector } from '@iiif/helpers';
 import { BoxStyle, AtlasProps, Preset } from '@atlas-viewer/atlas';
-import { InternationalString, ImageService as ImageService$1, ImageSize, AuthProbeService2, Auth2LocationResource, Auth2SubstituteResource, AuthAccessService2, AuthAccessTokenService2, AuthAccessToken2, SearchServiceQueryParams, SearchServiceSearchResponse, SearchService as SearchService$1, SearchServiceAutocomplete, Reference, Annotation } from '@iiif/presentation-3';
-import { RegionParameter, RotationParameter, SizeParameter } from '@iiif/parser/image-3';
 import * as polygon_editor from 'polygon-editor';
-import { RenderState, InputShape, SlowState } from 'polygon-editor';
+import { InputShape, PolygonEvents } from 'polygon-editor';
+import { InternationalString, ImageService as ImageService$1, ImageSize, AuthProbeService2, Auth2LocationResource, Auth2SubstituteResource, AuthAccessService2, AuthAccessTokenService2, AuthAccessToken2, SearchServiceQueryParams, SearchServiceSearchResponse, SearchService as SearchService$1, SearchServiceAutocomplete, Reference, Annotation, SvgSelector as SvgSelector$1, FragmentSelector } from '@iiif/presentation-3';
+import { RegionParameter, RotationParameter, SizeParameter } from '@iiif/parser/image-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 * as mitt from 'mitt';
 import { Emitter, EventType, Handler } from 'mitt';
+import { ImageServiceLoader, ImageCandidateRequest, ImageCandidate } from '@iiif/helpers/image-service';
 import { Vault, VaultOptions, NormalizedEntity, IIIFStore } from '@iiif/helpers/vault';
 import { CanvasNormalized, AnnotationNormalized, AnnotationPageNormalized, CollectionNormalized, ManifestNormalized, RangeNormalized } from '@iiif/presentation-3-normalized';
-import { ImageServiceLoader, ImageCandidateRequest, ImageCandidate } from '@iiif/helpers/image-service';
-import { C as CompatVault } from './utils-C-h4SU3S.js';
-export { e as emptyActions, b as emptyStrategy, g as getParsedTargetSelector, c as getRenderingStrategy, p as parseSpecificResource, u as unknownResponse, a as unsupportedStrategy } from './utils-C-h4SU3S.js';
+import { C as CompatVault } from './utils-DyrEcegR.js';
+export { e as emptyActions, c as emptyStrategy, a as getParsedTargetSelector, g as getRenderingStrategy, p as parseSpecificResource, u as unknownResponse, b as unsupportedStrategy } from './utils-DyrEcegR.js';
 import { VaultZustandStore } from '@iiif/helpers/vault/store';
 import * as _iiif_helpers_painting_annotations from '@iiif/helpers/painting-annotations';
 import * as _iiif_helpers_styles from '@iiif/helpers/styles';
-export * from '@iiif/helpers/annotation-targets';
+
+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;
@@ -52,27 +59,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;
@@ -82,19 +98,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>;
@@ -103,6 +111,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<{
@@ -169,6 +245,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;
 
@@ -222,89 +313,17 @@ interface SingleCanvasThumbnailProps {
 }
 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;
-    };
-    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 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;
@@ -312,101 +331,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;
@@ -418,6 +356,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;
@@ -595,82 +564,24 @@ interface ComplexTimelineStore extends MediaPlayerActions {
     removeElement: (id: string) => void;
     applyKeyframes(newIdx: number, keyframes: TimelineKeyframe[]): void;
     nextKeyframeIndex: number;
-    setProgressElement(div: HTMLDivElement): void;
-    setCurrentTimeElement(div: HTMLDivElement): void;
-    clearProgressElement(): void;
-    clearCurrentTimeElement(): void;
-}
-
-declare function ComplexTimelineProvider({ children, store, }: {
-    children: React.ReactNode;
-    store: StoreApi$1<ComplexTimelineStore>;
-}): react_jsx_runtime.JSX.Element;
-declare function useComplexTimeline<T>(selector: (store: ComplexTimelineStore) => T): T;
-
-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 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;
+    setProgressElement(div: HTMLDivElement): void;
+    setCurrentTimeElement(div: HTMLDivElement): void;
+    clearProgressElement(): void;
+    clearCurrentTimeElement(): void;
+}
 
-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;
+declare function ComplexTimelineProvider({ children, store, }: {
+    children: React.ReactNode;
+    store: StoreApi$1<ComplexTimelineStore>;
 }): react_jsx_runtime.JSX.Element;
+declare function useComplexTimeline<T>(selector: (store: ComplexTimelineStore) => T): T;
+
+interface StrategyContext {
+    strategy: RenderingStrategy;
+    choices: ChoiceDescription | null;
+}
+declare const StrategyReactContext: React$1.Context<StrategyContext | null>;
+declare function useStrategy(): StrategyContext;
 
 type SearchService = SearchService$1 & {
     service: SearchServiceAutocomplete | SearchServiceAutocomplete[];
@@ -693,6 +604,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>;
@@ -702,7 +628,7 @@ 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;
@@ -720,6 +646,9 @@ declare function useContextBridge(): {
     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>;
@@ -727,15 +656,58 @@ declare function ContextBridge(props: {
     children: ReactNode;
 }): react_jsx_runtime.JSX.Element;
 
-declare const VisibleCanvasReactContext: React__default.Context<string[]>;
-declare function useVisibleCanvases(): CanvasNormalized[];
+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;
+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 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 SelectorHelperEventTypes = 'click' | 'hover' | 'selector-updated' | 'highlight' | 'clear-highlight' | 'zoom-to' | 'event-listener' | 'remove-event-listener' | 'image-preview-request';
 declare function SelectorControllerProvider({ children }: {
     children: ReactNode;
@@ -805,59 +777,28 @@ 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;
 
-declare function getVideoStrategy(canvas: CanvasNormalized, paintables: Paintables, vault: CompatVault): UnknownStrategy | MediaStrategy;
+declare const VisibleCanvasReactContext: React__default.Context<string[]>;
+declare function useVisibleCanvases(): CanvasNormalized[];
 
 declare function getComplexTimelineStrategy(canvas: CanvasNormalized, paintables: Paintables, loadImageService: ImageServiceLoaderType, vault: CompatVault): ComplexTimelineStrategy;
 
+declare function getVideoStrategy(canvas: CanvasNormalized, paintables: Paintables, vault: CompatVault): UnknownStrategy | MediaStrategy;
+
 declare function useAnnotation(options?: {
     id: string;
 }): AnnotationNormalized | undefined;
@@ -914,13 +855,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;
@@ -929,11 +870,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 = {
@@ -1034,6 +1001,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;
@@ -1042,6 +1129,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[];
@@ -1053,6 +1155,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;
@@ -1084,57 +1205,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;
@@ -1180,6 +1250,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;
+declare function isBoxSelector(t: SupportedSelector): t is BoxSelector;
+declare function seraliseSupportedSelector(selector: SupportedSelector, on?: {
+    width: number;
+    height: number;
+} | null): null | SvgSelector$1 | 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;
@@ -1205,6 +1305,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
  *
@@ -1242,9 +1347,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 AnnotationStrategyProps, AnnotationStyleProvider, type AnnotationStyles, type AnnotationThemeDefinition, Auth, type AuthAccessState, type AuthContextActions, type AuthContextCurrentActions, type AuthContextState, AuthProvider, AuthRContext, AuthReactContext, AuthReactContextActions, type AuthState, CanvasAnnotations, CanvasContext, CanvasStrategyProvider, CanvasWorldObject, CollectionContext, CombinedMetadata, ComplexTimelineProvider, ComplexTimelineStrategy, ContextBridge, type ControlsContext, ControlsReactContext, CreateCustomShape, type CreateCustomShapeProps, CustomContextBridge, CustomContextBridgeProvider, EmptyStrategy, EventsProvider, Image, type ImageProps, ImageService, ImageServiceLoaderContext, ImageServiceLoaderType, type ImageServiceRequestOptions, type ImageStrategyProps, ImageWithOptionalService, InnerViewerProvider, LanguageProvider, LanguageString, LocaleString, ManifestContext, ManifestMetadata, type MediaPlayerActions, MediaPlayerProvider, type MediaPlayerState, MediaStrategy, Metadata, type MetadataProps, PolygonSelector, type PolygonSelectorProps, type ProbeStore, RangeContext, ReactEventContext, ReactVaultContext, Render3DModelStrategy, RenderAccompanyingCanvas, RenderAnnotationStrategy, RenderAudioStrategy, RenderComplexTimelineStrategy, RenderEmptyStrategy, RenderImageStrategy, RenderSvgEditorControls, RenderTextualContentStrategy, RenderVideoStrategy, RenderYouTubeStrategy, RenderingStrategy, type ResourceContextType, ResourceProvider, ResourceReactContext, type ResourceRequestOptions, SelectorControllerProvider, type SelectorHelperEventTypes, SequenceThumbnails, SimpleViewerContext, SimpleViewerProps, SimpleViewerProvider, SimpleViewerReactContext, SingleCanvasThumbnail, SingleImageStrategy, StrategyActions, type StrategyContext, StrategyReactContext, type SvgTheme, ThumbnailFallbackImage, TimelineKeyframe, TranslationProvider, TransliterationProvider, UnknownStrategy, type VaultActivatedAnnotation, VaultProvider, ViewerPresetContext, VirtualAnnotationProvider, VisibleCanvasReactContext, authDetailsForResource, createAuthStateStore, createProbe, defaultEmitter, findAllCanvasesInRange, findFirstCanvasFromRange, findManifestSelectedRange, findSelectedRange, flattenAnnotationPageIds, formatTime, getComplexTimelineStrategy, getDefaultAnnotationStyles, getManifestSequence, getVideoStrategy, getVisibleCanvasesFromCanvasId, hasAuth, makeAccessServiceRequest, makeAccessTokenRequest, svgThemes, 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, useLocaleString, useManifest, useMediaActions, useMediaElements, useMediaState, usePaintables, usePaintingAnnotations, usePolygonHelper, useRange, useRenderControls, 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, AnnotationRequest, AnnotationRequestOptions, AnnotationResponse, type AnnotationStrategyProps, AnnotationStyleProvider, type AnnotationStyles, type AnnotationThemeDefinition, AtlasStore, Auth, type AuthAccessState, type AuthContextActions, type AuthContextCurrentActions, type AuthContextState, AuthProvider, AuthRContext, AuthReactContext, AuthReactContextActions, type AuthState, CanvasAnnotations, CanvasContext, CanvasStrategyProvider, CanvasWorldObject, CollectionContext, CombinedMetadata, ComplexTimelineProvider, ComplexTimelineStrategy, ContextBridge, type ControlsContext, ControlsReactContext, CreateCustomShape, type CreateCustomShapeProps, CustomContextBridge, CustomContextBridgeProvider, DefaultEditingTools, EmptyStrategy, EventEmitterProvider, EventsProvider, Image, type ImageProps, ImageService, ImageServiceLoaderContext, ImageServiceLoaderType, type ImageServiceRequestOptions, type ImageStrategyProps, ImageWithOptionalService, InnerViewerProvider, LanguageProvider, LanguageString, LocaleString, ManifestContext, ManifestMetadata, type MediaPlayerActions, MediaPlayerProvider, type MediaPlayerState, MediaStrategy, Metadata, type MetadataProps, PolygonSelector, type PolygonSelectorProps, type ProbeStore, RangeContext, ReactEmitterContext, ReactEventContext, ReactVaultContext, Render3DModelStrategy, RenderAccompanyingCanvas, RenderAnnotationEditing, RenderAnnotationStrategy, RenderAudioStrategy, RenderComplexTimelineStrategy, RenderContextProps, RenderEmptyStrategy, RenderImageStrategy, RenderSvgEditorControls, RenderTextualContentStrategy, RenderVideoStrategy, RenderYouTubeStrategy, RenderingStrategy, type ResourceContextType, ResourceProvider, ResourceReactContext, type ResourceRequestOptions, SVGTheme, SelectorControllerProvider, type SelectorHelperEventTypes, SequenceThumbnails, SimpleViewerContext, SimpleViewerProps, SimpleViewerProvider, SimpleViewerReactContext, SingleCanvasThumbnail, SingleImageStrategy, StrategyActions, type StrategyContext, StrategyReactContext, type SvgTheme, ThumbnailFallbackImage, TimelineKeyframe, TranslationProvider, TransliterationProvider, UnknownStrategy, type VaultActivatedAnnotation, VaultProvider, ViewerPresetContext, VirtualAnnotationProvider, VisibleCanvasReactContext, annotationResponseToSelector, authDetailsForResource, createAuthStateStore, createProbe, defaultEmitter, findAllCanvasesInRange, findFirstCanvasFromRange, findManifestSelectedRange, findSelectedRange, flattenAnnotationPageIds, formatTime, getComplexTimelineStrategy, getDefaultAnnotationStyles, getManifestSequence, getVideoStrategy, getVisibleCanvasesFromCanvasId, hasAuth, isBoxSelector, isRectangle, isSvgSelector, makeAccessServiceRequest, makeAccessTokenRequest, seraliseSupportedSelector, svgThemes, targetIntersects, useAnnotation, useAnnotationPage, useAnnotationPageManager, useAnnotationStyles, useAnnotationsAtTime, useAuthActions, useAuthService, useAuthStore, useAuthToken, useAuthTokens, useCanvas, useCanvasChoices, useCanvasClock, useCanvasSequence, useCanvasStartTime, useCanvasSubset, useClosestLanguage, useCollection, useComplexTimeline, useContextBridge, useCreateLocaleString, useCurrentAnnotationActions, useCurrentAnnotationMetadata, useCurrentAnnotationRequest, useCurrentAnnotationTransition, useCurrentAuth, useCustomContextBridge, useDispatch, useEmitter, useEvent, useEventEmitter, useEventListener, useExistingVault, useExternalCollection, useExternalManifest, useExternalResource, useIIIFLanguage, useImage, useImageService, useImageServiceLoader, useImageTile, useIsAuthEnabled, useLocaleString, useManifest, useMediaActions, useMediaElements, useMediaState, usePaintables, usePaintingAnnotations, usePolygonHelper, useRange, useRenderControls, 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 };