react-iiif-vault 1.0.11 → 1.1.1

package/dist/index.d.ts

@@ -0,0 +1,722 @@
+import { S as SimpleViewerContext, a as SimpleViewerProps } from './index-Cxs6aAuK.js';
+export { C as CanvasPanel, c as SimpleViewerActions, d as SimpleViewerActionsType, b as SimpleViewerReducerState } from './index-Cxs6aAuK.js';
+import * as React$1 from 'react';
+import React__default, { ReactNode, FunctionComponent, RefObject } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { InternationalString, ImageService, ImageSize, AuthProbeService2, Auth2LocationResource, Auth2SubstituteResource, AuthAccessService2, AuthAccessTokenService2, AuthAccessToken2, SearchServiceQueryParams, SearchServiceSearchResponse, SearchService as SearchService$1, SearchServiceAutocomplete, Reference, Annotation } from '@iiif/presentation-3';
+import { RegionParameter, RotationParameter, SizeParameter, ImageServiceLoader, ImageCandidateRequest, ImageCandidate } from '@atlas-viewer/iiif-image-api';
+import * as zustand_vanilla from 'zustand/vanilla';
+import { StoreApi } from 'zustand/vanilla';
+import { Vault, VaultOptions, NormalizedEntity, IIIFStore } from '@iiif/helpers/vault';
+import * as zustand from 'zustand';
+import * as _iiif_helpers from '@iiif/helpers';
+import { Paintables } from '@iiif/helpers';
+import { CanvasNormalized, AnnotationNormalized, AnnotationPageNormalized, CollectionNormalized, ManifestNormalized, RangeNormalized } from '@iiif/presentation-3-normalized';
+import { Preset } from '@atlas-viewer/atlas';
+import { R as RenderingStrategy } from './useRenderingStrategy-Xj9yQm4y.js';
+export { e as AnnotationPageDescription, A as AudioSequence, C as ComplexTimelineStrategy, E as EmptyStrategy, j as ImageServiceLoaderType, I as ImageWithOptionalService, M as MediaStrategy, h as Single3DModelStrategy, b as SingleAudio, a as SingleImageStrategy, c as SingleVideo, d as SingleYouTubeVideo, S as StrategyActions, T as TextualContentStrategy, U as UnknownStrategy, k as UseRenderingStrategy, l as UseRenderingStrategyOptions, V as VideoSequence, i as get3dStrategy, g as getImageStrategy, f as getTextualContentStrategy, u as useLoadImageService, m as useRenderingStrategy } from './useRenderingStrategy-Xj9yQm4y.js';
+export { emptyActions, emptyStrategy, getParsedTargetSelector, getRenderingStrategy, parseSpecificResource, unknownResponse, unsupportedStrategy } from './utils.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 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 useIsAuthEnabled(): boolean;
+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;
+
+declare function getVideoStrategy(canvas: CanvasNormalized, paintables: Paintables): 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, Auth, type AuthAccessState, type AuthContextActions, type AuthContextCurrentActions, type AuthContextState, AuthProvider, AuthProvider_Old, AuthRContext, AuthReactContext, AuthReactContextActions, type AuthState, CanvasAnnotations, CanvasContext, CollectionContext, CombinedMetadata, ContextBridge, Image, type ImageProps, ImageServiceLoaderContext, type ImageServiceRequestOptions, InnerViewerProvider, LanguageProvider, LanguageString, LocaleString, ManifestContext, ManifestMetadata, type MediaPlayerActions, MediaPlayerProvider, type MediaPlayerState, Metadata, type MetadataProps, type ProbeStore, RangeContext, ReactVaultContext, RenderingStrategy, type ResourceContextType, ResourceProvider, ResourceReactContext, type ResourceRequestOptions, SequenceThumbnails, SimpleViewerContext, SimpleViewerProps, SimpleViewerProvider, SimpleViewerReactContext, SingleCanvasThumbnail, type VaultActivatedAnnotation, VaultProvider, ViewerPresetContext, VirtualAnnotationProvider, VisibleCanvasReactContext, authDetailsForResource, createAuthStateStore, createProbe, findAllCanvasesInRange, findFirstCanvasFromRange, findManifestSelectedRange, findSelectedRange, flattenAnnotationPageIds, formatTime, getManifestSequence, getVideoStrategy, getVisibleCanvasesFromCanvasId, hasAuth, makeAccessServiceRequest, makeAccessTokenRequest, 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, useIsAuthEnabled, useLocaleString, useManifest, useMediaActions, useMediaElements, useMediaState, usePaintables, usePaintingAnnotations, useRange, useResourceContext, useResourceEvents, useResources, useSearchService, useSimpleMediaPlayer, useSimpleViewer, useStyleHelper, useStyles, useThumbnail, useVault, useVaultEffect, useVaultSelector, useViewerPreset, useVirtualAnnotationPage, useVirtualAnnotationPageContext, useVisibleCanvases };