react-iiif-vault 1.0.11 → 1.1.0

package/dist/bundle.d.ts

@@ -0,0 +1,1058 @@
+import * as React$1 from 'react';
+import React__default, { ReactNode, FC, RefObject, ForwardRefExoticComponent, RefAttributes, FunctionComponent } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { AtlasProps, BoxStyle, ViewerMode, Preset } from '@atlas-viewer/atlas';
+import { AnnotationPage, ImageService, 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, CanvasNormalized, AnnotationNormalized, CollectionNormalized, ManifestNormalized, RangeNormalized } from '@iiif/presentation-3-normalized';
+import * as _iiif_helpers from '@iiif/helpers';
+import { ChoiceDescription, Paintables, SupportedTarget, 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 { ImageCandidate, RegionParameter, RotationParameter, SizeParameter, ImageServiceLoader, ImageCandidateRequest } from '@atlas-viewer/iiif-image-api';
+import { Vault, VaultOptions, NormalizedEntity, IIIFStore } from '@iiif/helpers/vault';
+import * as zustand_vanilla from 'zustand/vanilla';
+import { StoreApi } from 'zustand/vanilla';
+import * as zustand from 'zustand';
+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;
+    worldScale?: number;
+} & {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare const RenderAnnotation: FC<{
+    id: string;
+    className?: string;
+    style?: BoxStyle;
+    interactive?: boolean;
+}>;
+
+declare const RenderAnnotationPage: FC<{
+    page: AnnotationPage | AnnotationPageNormalized;
+    className?: string;
+}>;
+
+type ImageWithOptionalService = {
+    id: string;
+    annotationId: string;
+    type: 'Image';
+    service?: ImageService;
+    width?: number;
+    height?: number;
+    sizes?: Array<{
+        width: number;
+        height: number;
+    }>;
+    target: BoxSelector | TemporalBoxSelector;
+    selector?: BoxSelector;
+};
+type SingleAudio = {
+    type: 'Sound';
+    annotationId: string;
+    url: string;
+    format: string;
+    duration: number;
+    target: TemporalSelector;
+    /**
+     * Which part of this audio should be used (cropping).
+     */
+    selector: TemporalSelector;
+};
+type SingleYouTubeVideo = {
+    type: 'VideoYouTube';
+    annotationId: string;
+    url: string;
+    youTubeId: string;
+    duration: number;
+    target: TemporalSelector | TemporalBoxSelector;
+    selector: TemporalSelector | TemporalBoxSelector;
+};
+type SingleVideo = {
+    type: 'Video';
+    annotationId: string;
+    url: string;
+    format: string;
+    duration: number;
+    /**
+     * Where on the canvas should this section of video be painted.
+     */
+    target: TemporalSelector | TemporalBoxSelector;
+    /**
+     * Which part of this video should be painted.
+     */
+    selector: TemporalSelector | TemporalBoxSelector;
+};
+type AudioSequence = {
+    type: 'SoundSequence';
+    items: SingleAudio[];
+};
+type VideoSequence = {
+    type: 'VideoSequence';
+    items: SingleVideo[];
+};
+type AnnotationPageDescription = {
+    pages: AnnotationPageNormalized[];
+};
+
+type ImageServiceLoaderType = (imageService: any | undefined, { height, width }: {
+    height: number;
+    width: number;
+}) => ImageService | undefined;
+declare function useLoadImageService(): readonly [ImageServiceLoaderType, Record<string, string>];
+
+type SingleImageStrategy = {
+    type: 'images';
+    image: ImageWithOptionalService;
+    images: Array<ImageWithOptionalService>;
+    choice?: ChoiceDescription;
+    annotations?: AnnotationPageDescription;
+};
+declare function getImageStrategy(canvas: CanvasNormalized, paintables: Paintables, loadImageService: ImageServiceLoaderType): RenderingStrategy;
+
+type Single3DModelStrategy = {
+    type: '3d-model';
+    model: ExternalWebResource;
+    choice?: ChoiceDescription;
+    annotations?: AnnotationPageDescription;
+};
+declare function get3dStrategy(canvas: CanvasNormalized, paintables: Paintables): RenderingStrategy;
+
+type TextualContentStrategy = {
+    type: 'textual-content';
+    items: {
+        annotationId: string;
+        text: InternationalString;
+        target: SupportedTarget | null;
+    }[];
+    choice?: ChoiceDescription;
+    annotations?: AnnotationPageDescription;
+};
+declare function getTextualContentStrategy(canvas: CanvasNormalized, paintables: Paintables): RenderingStrategy;
+
+type MediaStrategy = {
+    type: 'media';
+    media: SingleAudio | SingleVideo | AudioSequence | VideoSequence | SingleYouTubeVideo;
+    choice?: ChoiceDescription;
+    annotations?: AnnotationPageDescription;
+};
+type ComplexTimelineStrategy = {
+    type: 'complex-timeline';
+    items: Array<ImageWithOptionalService | SingleAudio | SingleVideo>;
+    choice?: ChoiceDescription;
+    annotations?: AnnotationPageDescription;
+};
+type EmptyStrategy = {
+    type: 'empty';
+    image: null;
+    images: [];
+    height: number;
+    width: number;
+    annotations?: AnnotationPageDescription;
+};
+type UnknownStrategy = {
+    type: 'unknown';
+    reason?: string;
+    annotations?: AnnotationPageDescription;
+};
+type RenderingStrategy = SingleImageStrategy | MediaStrategy | ComplexTimelineStrategy | Single3DModelStrategy | TextualContentStrategy | UnknownStrategy | EmptyStrategy;
+
+type StrategyActions = {
+    makeChoice: (id: string, options?: {
+        deselectOthers?: boolean;
+        deselect?: boolean;
+    }) => void;
+};
+type UseRenderingStrategy = [RenderingStrategy, StrategyActions];
+type UseRenderingStrategyOptions = {
+    strategies?: Array<RenderingStrategy['type']>;
+    annotationPageManagerId?: string;
+    enableSingleAnnotation?: boolean;
+    defaultChoices?: string[];
+};
+declare function useRenderingStrategy(options?: UseRenderingStrategyOptions): UseRenderingStrategy;
+
+type CanvasProps = {
+    x?: number;
+    y?: number;
+    onCreated?: any;
+    onChoiceChange?: (choice?: ChoiceDescription) => void;
+    registerActions?: (actions: StrategyActions) => void;
+    defaultChoices?: Array<{
+        id: string;
+        opacity?: number;
+    }>;
+    isStatic?: boolean;
+    keepCanvasScale?: boolean;
+    children?: ReactNode;
+    renderViewerControls?: (strategy: SingleImageStrategy | EmptyStrategy) => ReactNode;
+    viewControlsDeps?: any[];
+    renderMediaControls?: (strategy: MediaStrategy) => ReactNode;
+    mediaControlsDeps?: any[];
+    strategies?: Array<RenderingStrategy['type']>;
+    backgroundStyle?: BoxStyle;
+    alwaysShowBackground?: boolean;
+    enableSizes?: boolean;
+    enableYouTube?: boolean;
+    ignoreSize?: boolean;
+    throwOnUnknown?: boolean;
+    onClickPaintingAnnotation?: (id: string, image: ImageWithOptionalService, e: any) => void;
+};
+declare function RenderCanvas({ x, y, onChoiceChange, registerActions, defaultChoices, isStatic, renderViewerControls, renderMediaControls, viewControlsDeps, mediaControlsDeps, strategies, throwOnUnknown, backgroundStyle, alwaysShowBackground, keepCanvasScale, enableSizes, enableYouTube, onClickPaintingAnnotation, children, }: CanvasProps): react_jsx_runtime.JSX.Element | null;
+
+declare function RenderImage({ id, image, thumbnail, isStatic, x, y, children, selector, onClick, enableSizes, }: {
+    id: string;
+    image: ImageWithOptionalService;
+    thumbnail?: ImageCandidate;
+    isStatic?: boolean;
+    enableSizes?: boolean;
+    selector?: BoxSelector$1;
+    x?: number;
+    y?: number;
+    children?: ReactNode;
+    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 AudioHTML({ media, children }: {
+    media: SingleAudio;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function Audio({ media, mediaControlsDeps, children, }: {
+    media: SingleAudio;
+    mediaControlsDeps?: any[];
+    children: ReactNode;
+}): null;
+
+declare function VideoHTML({ element, media, playPause, }: {
+    element: RefObject<any>;
+    media: SingleVideo;
+    playPause: () => void;
+}): react_jsx_runtime.JSX.Element;
+declare function Video({ media, mediaControlsDeps, children, }: {
+    media: SingleVideo;
+    mediaControlsDeps?: any[];
+    children: ReactNode;
+}): null;
+
+declare function ModelHTML({ model }: {
+    model: any;
+}): react_jsx_runtime.JSX.Element;
+declare function Model({ model, name }: {
+    model: any;
+    name?: string;
+}): null;
+
+interface CanvasPanelProps {
+    manifest: string;
+    startCanvas?: string;
+    rangeId?: string;
+    pagingEnabled?: boolean;
+    header?: ReactNode;
+    children?: ReactNode;
+    mode?: ViewerMode;
+    reuseAtlas?: boolean;
+    height?: number;
+    spacing?: number;
+    components?: {
+        ViewerControls?: FC;
+        MediaControls?: FC;
+    };
+    canvasProps?: Omit<Partial<CanvasProps>, 'x'>;
+    annotations?: ReactNode;
+}
+type CanvasPanelType = ForwardRefExoticComponent<CanvasPanelProps & RefAttributes<SimpleViewerContext>> & {
+    RenderImage: typeof RenderImage;
+    RenderCanvas: typeof RenderCanvas;
+    RenderAnnotationPage: typeof RenderAnnotationPage;
+    RenderAnnotation: typeof RenderAnnotation;
+    Viewer: typeof Viewer;
+    CanvasBackground: typeof CanvasBackground;
+    Audio: typeof Audio;
+    Video: typeof Video;
+    Model: typeof Model;
+    AudioHTML: typeof AudioHTML;
+    VideoHTML: typeof VideoHTML;
+    ModelHTML: typeof ModelHTML;
+};
+declare const CanvasPanel: CanvasPanelType;
+
+declare const CanvasAnnotations: React$1.ForwardRefExoticComponent<{
+    canvasId?: string | undefined;
+} & React$1.RefAttributes<{
+    availablePageIds: string[];
+    enabledPageIds: string[];
+    setPageEnabled: (id: string, opt?: {
+        deselectOthers?: boolean | undefined;
+    }) => void;
+    setPageDisabled: (deselectId: string) => void;
+}>>;
+
+type FacetConfig = {
+    id: string;
+    label: InternationalString;
+    keys: string[];
+    values?: FacetConfigValue[];
+};
+type FacetConfigValue = {
+    id: string;
+    label: InternationalString;
+    values: string[];
+    key: string;
+};
+interface MetadataProps {
+    config?: FacetConfig[];
+    metadata?: Array<{
+        label: InternationalString;
+        value: InternationalString;
+    } | null>;
+    labelWidth?: number;
+    allowHtml?: boolean;
+    showEmptyMessage?: boolean;
+    separator?: string;
+    classes?: {
+        container?: string;
+        row?: string;
+        label?: string;
+        value?: string;
+        empty?: string;
+    };
+    emptyMessage?: string;
+    emptyValueFallback?: string;
+    emptyLabelFallback?: string;
+    tableHeader?: React.ReactNode;
+    tableFooter?: React.ReactNode;
+    emptyFallback?: React.ReactNode;
+}
+declare function Metadata({ metadata, config, labelWidth, showEmptyMessage, allowHtml, emptyFallback, classes, emptyMessage, emptyValueFallback, emptyLabelFallback, separator, tableFooter, tableHeader, }: MetadataProps): react_jsx_runtime.JSX.Element;
+
+type CombinedMetadataProps = Omit<MetadataProps, 'metadata'>;
+declare function CombinedMetadata(props: CombinedMetadataProps): react_jsx_runtime.JSX.Element;
+
+interface ImageProps {
+    src: string | ImageService;
+    alt?: string;
+    size?: Partial<ImageSize>;
+    region?: RegionParameter;
+    className?: string;
+    style?: React.CSSProperties;
+    fetchImageService?: boolean;
+    quality?: string;
+    rotation?: number | RotationParameter;
+    format?: string;
+}
+declare function Image(props: ImageProps): react_jsx_runtime.JSX.Element | null;
+
+type ManifestMetadataProps = Omit<MetadataProps, 'metadata'>;
+declare function ManifestMetadata(props: ManifestMetadataProps): react_jsx_runtime.JSX.Element;
+
+interface SequenceThumbnailsProps {
+    flat?: boolean;
+    size?: {
+        width: number;
+        height?: number;
+    };
+    classes?: {
+        container?: string;
+        row?: string;
+        item?: string;
+        figure?: string;
+        imageWrapper?: string;
+        img?: string;
+        label?: string;
+        selected?: {
+            row?: string;
+            item?: string;
+            figure?: string;
+            img?: string;
+            label?: string;
+            imageWrapper?: string;
+        };
+    };
+    figure?: boolean;
+    showLabel?: boolean;
+    fallback?: React.ReactNode;
+}
+declare function SequenceThumbnails({ flat, size, classes, showLabel, figure, fallback }: SequenceThumbnailsProps): react_jsx_runtime.JSX.Element;
+
+interface SingleCanvasThumbnailProps {
+    canvasId?: string;
+    size?: Partial<SizeParameter>;
+    visible?: boolean;
+    alt?: string;
+    dereference?: boolean;
+    figure?: boolean;
+    showLabel?: boolean;
+    classes?: {
+        figure?: string;
+        img?: string;
+        label?: string;
+        imageWrapper?: string;
+    };
+    placeholder?: React.ReactNode;
+    fallback?: React.ReactNode;
+}
+declare function SingleCanvasThumbnail(props: SingleCanvasThumbnailProps): react_jsx_runtime.JSX.Element;
+
+declare function AnnotationContext({ annotation, children }: {
+    annotation: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function AnnotationPageContext({ annotationPage, children }: {
+    annotationPage: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function hasAuth(resource: any): boolean;
+interface ProbeStore {
+    service?: AuthProbeService2;
+    status: 'unknown' | 'probing' | 'error' | 'success';
+    shouldRedirect: boolean;
+    redirectResource: Auth2LocationResource | null;
+    shouldSubstitute: boolean;
+    substituteResource: Auth2SubstituteResource | null;
+    error: string | null;
+    errorHeading: InternationalString | null;
+    errorNote: InternationalString | null;
+    shouldDisplayResource: boolean;
+    token: string | null;
+    probe: () => Promise<void>;
+    setToken: (token: string) => void;
+}
+interface AuthContextState {
+    currentAuth: number;
+    authItems: AuthAccessState[];
+}
+interface AuthContextCurrentActions {
+    login(): void;
+    logout(): void;
+    nextAuth(): void;
+    previousAuth(): void;
+    setAuth(index: number): void;
+}
+interface AuthContextActions {
+    addService(service: AuthAccessService2, probeId: string): void;
+    removeService(service: AuthAccessService2, probeId: string): void;
+}
+interface AuthAccessState {
+    id: string;
+    type: 'external' | 'kiosk' | 'active';
+    service: AuthAccessService2;
+    probeId: string;
+    isPending: boolean;
+    isLoggedIn: boolean;
+    canAuthenticate: boolean;
+    instances: number;
+    error?: string;
+    session: null | {
+        token: string;
+        expires: number;
+    };
+}
+declare const createAuthStateStore: () => zustand_vanilla.StoreApi<AuthContextCurrentActions & AuthContextState & AuthContextActions>;
+declare const createProbe: (service?: AuthProbeService2, token?: string) => zustand_vanilla.StoreApi<ProbeStore>;
+declare function authDetailsForResource(resource: any): {
+    hasAuth?: boolean | undefined;
+    services: {
+        probe?: AuthProbeService2;
+        access?: AuthAccessService2;
+    };
+};
+declare function makeAccessTokenRequest<T extends AuthAccessTokenService2>(service: T, { strict }?: {
+    strict?: boolean;
+}): Promise<AuthAccessToken2>;
+declare function makeAccessServiceRequest<T extends AuthAccessService2>(service: T): Promise<void>;
+
+interface AuthState {
+    id: string;
+    type: 'external' | 'kiosk' | 'active';
+    service: AuthAccessService2;
+    probeId: string;
+    isPending: boolean;
+    isLoggedIn: boolean;
+    canAuthenticate: boolean;
+    instances: number;
+    error?: string;
+    session: null | {
+        token: string;
+        expires: number;
+    };
+}
+declare const AuthRContext: React$1.Context<StoreApi<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 AuthProvider_Old({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useAuthStore(): StoreApi<AuthContextState & AuthContextCurrentActions & AuthContextActions>;
+declare function useAuthActions(): {
+    login: () => void;
+    logout: () => void;
+    nextAuth: () => void;
+    previousAuth: () => void;
+    setAuth: (index: number) => void;
+    addService: (service: AuthAccessService2, probeId: string) => void;
+    removeService: (service: AuthAccessService2, probeId: string) => void;
+};
+declare function useCurrentAuth(): AuthContextState & AuthContextCurrentActions & AuthContextActions;
+declare function useAuthService(id: string): AuthAccessState | undefined;
+declare function useAuthTokens(id?: string): string | undefined;
+declare function useAuthToken(id: string): string | null;
+declare function useCurrentAuth_old(): AuthContextState & AuthContextCurrentActions;
+declare function useAuthService_old(id: string): AuthState | null;
+declare function useAuthTokens_old(id?: string): string | null;
+declare function useAuthToken_old(id?: string): string | null;
+declare function useAuthActions_old(): AuthContextActions | null;
+interface AuthProps<T, Extra> {
+    resource: T;
+    extra?: Extra;
+    children: (service: T) => ReactNode;
+    fallbackComponent?: FunctionComponent<any> | null;
+    loadingComponent?: FunctionComponent<any> | null;
+    errorComponent?: FunctionComponent<{
+        resource: T;
+        error: string;
+        heading: InternationalString | null;
+        note: InternationalString | null;
+        extra: Extra | undefined;
+    }> | null;
+}
+declare function Auth<Element, Extra = any>(props: AuthProps<Element, Extra>): string | number | boolean | Iterable<ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;
+
+declare function CanvasContext({ canvas, children }: {
+    canvas: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function CollectionContext({ collection, children }: {
+    collection: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function ManifestContext({ manifest, children }: {
+    manifest: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+type MediaPlayerState = {
+    isPlaying: boolean;
+    isMuted: boolean;
+    playRequested: boolean;
+    volume: number;
+    isFinished: boolean;
+    duration: number;
+};
+type MediaPlayerActions = {
+    play(): void;
+    pause(): void;
+    playPause(): void;
+    mute(): void;
+    unmute(): void;
+    toggleMute(): void;
+    setVolume(volume: number): void;
+    setDurationPercent(percent: number): void;
+    setTime(time: number): void;
+};
+declare function formatTime(time: number): string;
+declare function useSimpleMediaPlayer(props: {
+    duration: number;
+}): readonly [
+    {
+        element: RefObject<HTMLAudioElement | HTMLVideoElement>;
+        currentTime: RefObject<HTMLDivElement>;
+        progress: RefObject<HTMLDivElement>;
+    },
+    MediaPlayerState,
+    MediaPlayerActions
+];
+
+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;
+
+type SearchService = SearchService$1 & {
+    service: SearchServiceAutocomplete | SearchServiceAutocomplete[];
+};
+interface Search1Store {
+    service: SearchService | undefined;
+    lastQuery: SearchServiceQueryParams;
+    resources: SearchServiceSearchResponse['resources'];
+    loading: boolean;
+    error: boolean;
+    hasAutocomplete: boolean;
+    hasSearch: boolean;
+    errorMessage: string;
+    highlight: SearchServiceSearchResponse['resources'][number] | null;
+    search: (query: SearchServiceQueryParams, options?: {
+        headers?: HeadersInit;
+    }) => void;
+    clearSearch: () => void;
+    highlightResult: (id: string) => void;
+    nextResult: () => void;
+}
+
+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;
+};
+declare function ContextBridge(props: {
+    bridge: ReturnType<typeof useContextBridge>;
+    children: ReactNode;
+}): 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;
+
+/**
+ * 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) => UseRenderingStrategy[0];
+declare const emptyStrategy: (width: number, height: number) => UseRenderingStrategy[0];
+
+declare function getVideoStrategy(canvas: CanvasNormalized, paintables: Paintables): RenderingStrategy;
+
+interface GetRenderStrategyOptions {
+    canvas: CanvasNormalized | null | undefined;
+    paintables: Paintables$1;
+    supports: string[];
+    loadImageService: ImageServiceLoaderType;
+}
+declare function getRenderingStrategy({ canvas, paintables, supports, loadImageService }: GetRenderStrategyOptions): RenderingStrategy;
+
+declare function useAnnotation(options?: {
+    id: string;
+}): AnnotationNormalized | undefined;
+declare function useAnnotation<T>(options?: {
+    id: string;
+    selector: (annotation: AnnotationNormalized) => T;
+}, deps?: any[]): T | undefined;
+
+declare function useAnnotationPage(options?: {
+    id: string;
+}): AnnotationPageNormalized | undefined;
+declare function useAnnotationPage<T>(options?: {
+    id: string;
+    selector: (annotation: AnnotationPageNormalized) => T;
+}, deps?: any[]): T | undefined;
+
+declare function useAnnotationPageManager(resourceId?: string, options?: {
+    all?: boolean;
+}): {
+    availablePageIds: string[];
+    enabledPageIds: string[];
+    setPageEnabled: (id: string, opt?: {
+        deselectOthers?: boolean;
+    }) => void;
+    setPageDisabled: (deselectId: string) => void;
+};
+
+declare function useAnnotationsAtTime(time: number, options?: {
+    canvasId?: string;
+}): AnnotationNormalized[];
+
+declare function useCanvas(options?: {
+    id: string;
+}): CanvasNormalized | undefined;
+declare function useCanvas<T>(options?: {
+    id: string;
+    selector: (canvas: CanvasNormalized) => T;
+}, deps?: any[]): T | undefined;
+
+declare function useCanvasClock(canvasId?: string, autoplay?: boolean): void;
+
+declare function useCanvasSubset(idsOrRefs?: Array<string | Reference>): Reference<'Canvas'>[];
+
+declare function useCollection(options: {
+    id: string;
+}): CollectionNormalized | undefined;
+declare function useCollection<T>(options: {
+    id: string;
+    selector: (collection: CollectionNormalized) => T;
+}, deps?: any[]): T | undefined;
+
+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 function useExistingVault(vault?: Vault): Vault;
+
+type ResourceRequestOptions = {
+    noCache?: boolean;
+};
+declare function useExternalResource<T extends {
+    id: string;
+}>(idOrRef: string | {
+    id: string;
+    type: string;
+}, { noCache }?: ResourceRequestOptions): {
+    id: string;
+    requestId: string;
+    isLoaded: boolean;
+    error: any;
+    cached: boolean;
+    resource?: T;
+};
+
+declare function useExternalCollection(idOrRef: string | {
+    id: string;
+    type: string;
+}, options?: ResourceRequestOptions): {
+    id: string;
+    requestId: string;
+    isLoaded: boolean;
+    cached?: boolean;
+    error: any;
+    manifest?: CollectionNormalized;
+};
+
+declare function useExternalManifest(idOrRef: string | {
+    id: string;
+    type: string;
+}, options?: ResourceRequestOptions): {
+    id: string;
+    requestId: string;
+    isLoaded: boolean;
+    cached?: boolean;
+    error: any;
+    manifest?: ManifestNormalized;
+};
+
+declare function useImage(service: ImageService | undefined, data?: {
+    size?: Partial<ImageSize>;
+    selector?: RegionParameter;
+    rotation?: number | RotationParameter;
+    format?: string;
+    region?: RegionParameter;
+    quality?: string;
+}, deps?: any[]): string | null;
+
+interface ImageServiceRequestOptions {
+    cacheKey?: string;
+}
+/**
+ * Returns the First image service on the current canvas.
+ *
+ * @note It is better to use the hook useRenderingStrategy for rendering.
+ */
+declare function useImageService({ cacheKey }?: ImageServiceRequestOptions): {
+    data: ImageService | undefined;
+    isFetching: boolean;
+    status: 'error' | 'success' | 'loading' | 'idle';
+};
+
+declare function useImageTile(): {
+    isLoading: boolean;
+    tile: {
+        id: string | undefined;
+        width: number | null | undefined;
+        height: number | null | undefined;
+        imageService: ImageService;
+        thumbnail: undefined;
+    } | null;
+};
+
+declare function useManifest(options?: {
+    id: string;
+}): ManifestNormalized | undefined;
+declare function useManifest<T>(options?: {
+    id: string;
+    selector: (manifest: ManifestNormalized) => T;
+}, deps?: any[]): T | undefined;
+
+declare function usePaintables(options?: {
+    defaultChoices?: string[];
+    enableSingleAnnotation?: boolean;
+}, deps?: any[]): readonly [_iiif_helpers_painting_annotations.Paintables, {
+    makeChoice: (id: string, { deselectOthers, deselect }?: {
+        deselectOthers?: boolean;
+        deselect?: boolean;
+    }) => void;
+}];
+
+declare function usePaintingAnnotations(options?: {
+    canvasId?: string;
+    enableSingleAnnotation?: boolean;
+}): AnnotationNormalized[];
+
+declare function useRange(options?: {
+    id: string;
+}): RangeNormalized | undefined;
+declare function useRange<T>(options?: {
+    id: string;
+    selector: (range: RangeNormalized) => T;
+}, deps?: any[]): T | undefined;
+
+declare function useResourceEvents<T extends NormalizedEntity>(resource?: Reference, scope?: string[]): any;
+
+declare function useResources<Type>(ids: string[], type: string): Type[];
+
+declare function useSearchService(): SearchService$1 | undefined;
+
+declare function useStyleHelper(): _iiif_helpers_styles.StyledHelper<_iiif_helpers_styles.StyleDefinition>;
+
+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 useThumbnail(request: ImageCandidateRequest, dereference?: boolean, { canvasId, manifestId }?: {
+    canvasId?: string;
+    manifestId?: string;
+}): ImageCandidate | undefined;
+
+declare const useVault: () => Vault;
+
+declare const useVaultEffect: (callback: (vault: Vault) => void, deps?: any[]) => void;
+
+declare function useVaultSelector<T>(selector: (state: IIIFStore, vault: Vault) => T, deps?: any[]): T;
+
+interface VaultActivatedAnnotation {
+    __vault?: Vault;
+    bindToVault(vault: Vault): void;
+    source: string | {
+        id: string;
+    };
+}
+declare function useVirtualAnnotationPage(): readonly [AnnotationPageNormalized | null, {
+    readonly addAnnotation: (id: string | Annotation | VaultActivatedAnnotation | AnnotationNormalized, atIndex?: number) => void;
+    readonly removeAnnotation: (id: string | Annotation | VaultActivatedAnnotation | AnnotationNormalized) => void;
+}];
+
+declare function useVirtualAnnotationPageContext(): [AnnotationPageNormalized | null, {
+    addAnnotation: (id: string | Annotation | VaultActivatedAnnotation | AnnotationNormalized, atIndex?: number | undefined) => void;
+    removeAnnotation: (id: string | Annotation | VaultActivatedAnnotation | AnnotationNormalized) => void;
+}];
+declare function VirtualAnnotationProvider({ children }: {
+    children: any;
+}): react_jsx_runtime.JSX.Element;
+
+declare function flattenAnnotationPageIds({ canvas, manifest, all, canvases, }: {
+    manifest?: ManifestNormalized;
+    canvas?: CanvasNormalized;
+    canvases?: CanvasNormalized[];
+    all?: boolean;
+}): string[];
+
+declare function LanguageProvider(props: {
+    language: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useIIIFLanguage(): string;
+type LanguageStringProps = {
+    [key: string]: any;
+} & {
+    as?: string | React__default.FC<any>;
+    language: string;
+    viewingDirection?: 'rtl' | 'rtl';
+};
+declare function LanguageString({ as: Component, language, children, viewingDirection, ...props }: LanguageStringProps): react_jsx_runtime.JSX.Element;
+declare const useClosestLanguage: (getLanguages: () => string[], deps?: any[]) => string | undefined;
+declare function useLocaleString(inputText: InternationalString | string | null | undefined, defaultText?: string, separator?: string): readonly [string, string | undefined];
+declare function useCreateLocaleString(): (inputText: InternationalString | string | null | undefined, defaultText?: string, separator?: string) => string;
+type LocaleStringProps = {
+    as?: string | React__default.FC<any>;
+    defaultText?: string;
+    to?: string;
+    separator?: string;
+    enableDangerouslySetInnerHTML?: boolean;
+    children: InternationalString | string | null | undefined;
+    style?: React__default.CSSProperties;
+    extraProps?: any;
+} & Record<string, any>;
+declare function LocaleString({ as: Component, defaultText, enableDangerouslySetInnerHTML, children, separator, ...props }: LocaleStringProps): react_jsx_runtime.JSX.Element;
+
+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;
+declare function useSimpleViewer(): SimpleViewerContext;
+
+declare function useCanvasSequence({ startCanvas, disablePaging }: {
+    startCanvas?: string;
+    disablePaging?: boolean;
+}): {
+    visibleItems: string[];
+    cursor: number;
+    items: {
+        type: "Canvas";
+        id: string;
+    }[];
+    sequence: number[][];
+    hasPrevious: boolean;
+    hasNext: boolean;
+    setSequenceIndex: React$1.Dispatch<React$1.SetStateAction<number>>;
+    setCanvasIndex: (index: number) => void;
+    setCanvasId: (id: string) => void;
+    next: () => void;
+    previous: () => void;
+};
+
+/**
+ * Get visible canvases from canvas ID
+ *
+ * This function returns a list of canvas references that should all be displayed
+ * when the passed canvasId is visible. This should work for individual items,
+ * 2-up paged view and continuous (scrolls).
+ *
+ * The options are listed below (from IIIF docs)
+ *
+ * - `unordered` - Valid on Collections, Manifests and Ranges. The Canvases included in resources that have this behavior
+ *    have no inherent order, and user interfaces should avoid implying an order to the user. Disjoint with individuals,
+ *    continuous, and paged.
+ *
+ * - `individuals` - Valid on Collections, Manifests, and Ranges. For Collections that have this behavior, each of the
+ *    included Manifests are distinct objects in the given order. For Manifests and Ranges, the included Canvases are
+ *    distinct views, and should not be presented in a page-turning interface. This is the default layout behavior if
+ *    not specified. Disjoint with unordered, continuous, and paged.
+ *
+ * - `continuous`  Valid on Collections, Manifests and Ranges, which include Canvases that have at least height and
+ *    width dimensions. Canvases included in resources that have this behavior are partial views and an appropriate
+ *    rendering might display all of the Canvases virtually stitched together, such as a long scroll split into
+ *    sections. This behavior has no implication for audio resources. The viewingDirection of the Manifest will
+ *    determine the appropriate arrangement of the Canvases. Disjoint with unordered, individuals and paged.
+ *
+ * - `paged`  Valid on Collections, Manifests and Ranges, which include Canvases that have at least height and width
+ *    dimensions. Canvases included in resources that have this behavior represent views that should be presented in
+ *    a page-turning interface if one is available. The first canvas is a single view (the first recto) and thus the
+ *    second canvas likely represents the back of the object in the first canvas. If this is not the case, see the
+ *    behavior value non-paged. Disjoint with unordered, individuals, continuous, facing-pages and non-paged.
+ *
+ */
+declare function getVisibleCanvasesFromCanvasId(vault: Vault, manifestOrRange: ManifestNormalized | RangeNormalized, canvasId: string | null, preventPaged?: boolean): Reference<'Canvas'>[];
+declare function getManifestSequence(vault: Vault, manifestOrRange: ManifestNormalized | RangeNormalized, { disablePaging, skipNonPaged }?: {
+    disablePaging?: boolean;
+    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 AudioSequence, Auth, type AuthAccessState, type AuthContextActions, type AuthContextCurrentActions, type AuthContextState, AuthProvider, AuthProvider_Old, AuthRContext, AuthReactContext, AuthReactContextActions, type AuthState, CanvasAnnotations, CanvasContext, CanvasPanel, CollectionContext, CombinedMetadata, type ComplexTimelineStrategy, ContextBridge, type EmptyStrategy, Image, type ImageProps, ImageServiceLoaderContext, type ImageServiceLoaderType, type ImageServiceRequestOptions, type ImageWithOptionalService, InnerViewerProvider, LanguageProvider, LanguageString, LocaleString, ManifestContext, ManifestMetadata, type MediaPlayerActions, MediaPlayerProvider, type MediaPlayerState, type MediaStrategy, Metadata, type MetadataProps, type ProbeStore, RangeContext, ReactVaultContext, type RenderingStrategy, type ResourceContextType, ResourceProvider, ResourceReactContext, type ResourceRequestOptions, 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 TextualContentStrategy, type UnknownStrategy, type UseRenderingStrategy, type UseRenderingStrategyOptions, type VaultActivatedAnnotation, VaultProvider, type VideoSequence, ViewerPresetContext, VirtualAnnotationProvider, VisibleCanvasReactContext, authDetailsForResource, createAuthStateStore, createProbe, emptyActions, emptyStrategy, findAllCanvasesInRange, findFirstCanvasFromRange, findManifestSelectedRange, findSelectedRange, flattenAnnotationPageIds, formatTime, get3dStrategy, getImageStrategy, getManifestSequence, getParsedTargetSelector, getRenderingStrategy, getTextualContentStrategy, getVideoStrategy, getVisibleCanvasesFromCanvasId, hasAuth, makeAccessServiceRequest, makeAccessTokenRequest, parseSpecificResource, unknownResponse, unsupportedStrategy, useAnnotation, useAnnotationPage, useAnnotationPageManager, useAnnotationsAtTime, useAuthActions, useAuthActions_old, useAuthService, useAuthService_old, useAuthStore, useAuthToken, useAuthToken_old, useAuthTokens, useAuthTokens_old, useCanvas, useCanvasClock, useCanvasSequence, useCanvasSubset, useClosestLanguage, useCollection, useContextBridge, useCreateLocaleString, useCurrentAuth, useCurrentAuth_old, useDispatch, useEventListener, useExistingVault, useExternalCollection, useExternalManifest, useExternalResource, useIIIFLanguage, useImage, useImageService, useImageServiceLoader, useImageTile, useLoadImageService, useLocaleString, useManifest, useMediaActions, useMediaElements, useMediaState, usePaintables, usePaintingAnnotations, useRange, useRenderingStrategy, useResourceContext, useResourceEvents, useResources, useSearchService, useSimpleMediaPlayer, useSimpleViewer, useStyleHelper, useStyles, useThumbnail, useVault, useVaultEffect, useVaultSelector, useViewerPreset, useVirtualAnnotationPage, useVirtualAnnotationPageContext, useVisibleCanvases };