react-iiif-vault 2.0.19 → 4.0.0

package/dist/SimpleViewerContext.hooks-CTgfe0Gg.d.cts

@@ -0,0 +1,617 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { ReactNode, FunctionComponent, RefObject, DependencyList } from 'react';
+import { BoxStyle } from '@atlas-viewer/atlas';
+import * as zustand_vanilla from 'zustand/vanilla';
+import { StoreApi } from 'zustand/vanilla';
+import { AuthProbeService2, Auth2LocationResource, Auth2SubstituteResource, InternationalString, AuthAccessService2, AuthAccessTokenService2, AuthAccessToken2, Reference, ImageService, ImageSize, Annotation, SearchService } from '@iiif/parser/presentation-3/types';
+import { M as MediaStrategy, a as SingleImageStrategy, E as EmptyStrategy, C as ComplexTimelineStrategy, r as CompatibleCanvas, k as ImageServiceLoaderType, U as UnknownStrategy, R as RenderingStrategy, q as ViewableContainerReference } from './useRenderingStrategy-Vubk-vUU.cjs';
+import * as mitt from 'mitt';
+import { Emitter, EventType, Handler } from 'mitt';
+import { ImageServiceLoader, ImageCandidateRequest, ImageCandidate } from '@iiif/helpers/image-service';
+import { M as MediaPlayerState, e as MediaPlayerActions } from './ViewerPresetContext-DwFTIkDx.cjs';
+import { Vault, VaultOptions, IIIFStore, NormalizedEntity } from '@iiif/helpers/vault';
+import { Vault4 } from '@iiif/helpers/vault-4';
+import { CanvasNormalized, AnnotationPageNormalized, AnnotationNormalized } from '@iiif/parser/presentation-3-normalized/types';
+import { Paintables } from '@iiif/helpers';
+import { C as CompatVault } from './utils-De5WTLDh.cjs';
+import { VaultZustandStore } from '@iiif/helpers/vault/store';
+import { RegionParameter, RotationParameter } from '@iiif/parser/image-3';
+import * as _iiif_helpers_painting_annotations from '@iiif/helpers/painting-annotations';
+import * as zustand from 'zustand';
+import * as _iiif_helpers_styles from '@iiif/helpers/styles';
+import { S as SimpleViewerContext, a as SimpleViewerProps } from './SimpleViewerContext.types-Df-cpBss.cjs';
+
+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;
+
+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;
+    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 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;
+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;
+
+type ResourceContextType = {
+    collection?: string;
+    manifest?: string;
+    range?: string;
+    canvas?: string;
+    annotation?: string;
+    annotationPage?: string;
+    scene?: string;
+    timeline?: 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;
+
+interface ControlsContext {
+    renderMediaControls?: (strategy: MediaStrategy) => ReactNode;
+    viewControlsDeps: any[];
+    renderViewerControls?: (strategy: SingleImageStrategy | EmptyStrategy) => ReactNode;
+    mediaControlsDeps: any[];
+    renderComplexTimelineControls?: (strategy: ComplexTimelineStrategy) => ReactNode;
+    complexTimelineControlsDeps: any[];
+}
+declare const ControlsReactContext: React$1.Context<ControlsContext | null>;
+declare function useRenderControls(): ControlsContext;
+
+interface EventContext {
+    emitter: Emitter<any>;
+}
+declare const defaultEmitter: Emitter<Record<EventType, unknown>>;
+declare const ReactEventContext: React__default.Context<{
+    emitter: Emitter<Record<EventType, unknown>>;
+}>;
+declare function useEventEmitter<Events extends Record<EventType, unknown>>(): Emitter<Events>;
+declare function EventsProvider({ emitter, children }: EventContext & {
+    children: React__default.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare const ImageServiceLoaderContext: React__default.Context<ImageServiceLoader>;
+declare function useImageServiceLoader(): ImageServiceLoader;
+
+declare function ManifestContext({ manifest, children }: {
+    manifest: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function useMediaState(): MediaPlayerState;
+declare function useMediaActions(): MediaPlayerActions;
+declare function useMediaElements(): {
+    element: RefObject<HTMLAudioElement | HTMLVideoElement>;
+    currentTime: RefObject<HTMLDivElement>;
+    progress: RefObject<HTMLDivElement>;
+};
+declare function 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;
+}): react_jsx_runtime.JSX.Element;
+declare function useSelectorEmitter(): mitt.Emitter<Record<mitt.EventType, unknown>>;
+declare function useSelectorEvents(id: string): {
+    controller: {
+        withSelector(selectorId: string): {
+            on<T extends {
+                selectorId: string;
+            } = any>(type: SelectorHelperEventTypes, handler: Handler<T>): () => void;
+            emit<T_1 = any>(type: SelectorHelperEventTypes, event: T_1): void;
+        };
+        on<T_2 extends {
+            selectorId: string;
+        } = any>(type: SelectorHelperEventTypes, handler: Handler<T_2>): () => void;
+        emit<T_3 extends {
+            selectorId: string;
+        } = any>(type: SelectorHelperEventTypes, event: T_3): void;
+    };
+    onClick: (e?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }) => void;
+    onHover: (e?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }) => void;
+    isHighlighted: boolean;
+};
+declare function useSelectorController(): {
+    withSelector(selectorId: string): {
+        on<T extends {
+            selectorId: string;
+        } = any>(type: SelectorHelperEventTypes, handler: Handler<T>): () => void;
+        emit<T_1 = any>(type: SelectorHelperEventTypes, event: T_1): void;
+    };
+    on<T_2 extends {
+        selectorId: string;
+    } = any>(type: SelectorHelperEventTypes, handler: Handler<T_2>): () => void;
+    emit<T_3 extends {
+        selectorId: string;
+    } = any>(type: SelectorHelperEventTypes, event: T_3): void;
+};
+declare function useSelectorHelper(): {
+    withSelector(selectorId: string): {
+        highlight(): void;
+        clearHighlight(): void;
+        zoomTo(): void;
+        addEventListener(name: string, callback: () => void): () => void;
+        getImagePreview(): Promise<any>;
+        on<T extends {
+            selectorId: string;
+        } = any>(type: SelectorHelperEventTypes, handler: Handler<T>): () => void;
+    };
+    highlight(selectorId: string): void;
+    clearHighlight(selectorId: string): void;
+    zoomTo(selectorId: string): void;
+    addEventListener(selectorId: string, name: string, callback: () => void): () => void;
+    getImagePreview(selectorId: string): Promise<any>;
+    on<T_1 extends {
+        selectorId: string;
+    } = any>(type: SelectorHelperEventTypes, handler: Handler<T_1>): () => void;
+};
+
+declare const ReactVaultContext: React__default.Context<{
+    vault: Vault | Vault4 | null;
+    setVaultInstance: (vault: Vault | Vault4) => void;
+}>;
+declare function VaultProvider({ vault, vaultOptions, useGlobal, resources, version, children, }: {
+    vault?: Vault | Vault4;
+    version?: 3 | 4;
+    useGlobal?: boolean;
+    vaultOptions?: VaultOptions;
+    resources?: ResourceContextType;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare const VisibleCanvasReactContext: React__default.Context<string[]>;
+declare function useVisibleCanvases(): CanvasNormalized[];
+declare function useVisibleCanvasContainers(): CompatibleCanvas[];
+
+declare function getComplexTimelineStrategy(canvas: CompatibleCanvas, paintables: Paintables, loadImageService: ImageServiceLoaderType, vault: CompatVault): ComplexTimelineStrategy;
+
+declare function getVideoStrategy(canvas: CompatibleCanvas, paintables: Paintables, vault: CompatVault, enforceSpatial?: boolean): UnknownStrategy | MediaStrategy;
+
+type ActiveVault = Vault | Vault4;
+declare function useActiveVault(): ActiveVault;
+declare function useVault(): Vault;
+
+type VaultHooks<TVault extends ActiveVault> = {
+    useVault(): TVault;
+    useExistingVault(vault?: TVault): TVault;
+    useVaultEffect(callback: (vault: TVault) => void, deps?: DependencyList): void;
+    useVaultSelector<T>(selector: (state: IIIFStore, vault: TVault) => T, deps?: DependencyList): T;
+};
+/** Creates Vault hooks bound to one Presentation version and rejects a mismatched provider at runtime. */
+declare function createVaultHooks(): VaultHooks<Vault>;
+declare function createVaultHooks(version: 3): VaultHooks<Vault>;
+declare function createVaultHooks(version: 4): VaultHooks<Vault4>;
+
+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 useCanvasClock(canvasId?: string, autoplay?: boolean): void;
+
+declare function useCanvasStartTime(): {
+    startTime: number;
+    endTime?: number | undefined;
+} | null;
+
+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;
+
+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: Error | undefined;
+    cached: boolean;
+    resource?: T;
+};
+
+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 painting image service on the current Canvas. */
+declare function useImageService({ cacheKey }?: ImageServiceRequestOptions): {
+    data: ImageService | undefined;
+    isFetching: boolean;
+    status: 'error' | 'success' | 'loading' | 'idle';
+    error?: Error;
+};
+
+declare function useImageTile(): {
+    isLoading: boolean;
+    tile: {
+        id: string | undefined;
+        width: number | null | undefined;
+        height: number | null | undefined;
+        imageService: ImageService;
+        thumbnail: undefined;
+    } | null;
+};
+
+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 useStaticRenderingStrategy({ supports }?: {
+    supports?: Array<RenderingStrategy['type']>;
+}): RenderingStrategy;
+
+interface StylesheetStore {
+    stylesheets: Record<string, string>;
+    loading: string[];
+    errors: Array<{
+        url: string;
+        error: Error;
+    }>;
+    loadStylesheet(url: string): Promise<string>;
+    setStylesheet(value: string, url?: string): string;
+    parseStylesheet(stylesheet: Annotation['stylesheet'] | null): Promise<null | {
+        id: string;
+        type: 'CssStylesheet';
+        value: string;
+    }>;
+}
+declare const useStylesheetStore: zustand.UseBoundStore<zustand.StoreApi<StylesheetStore>>;
+declare function useRemoteStylesheet(stylesheet?: Annotation['stylesheet'] | null): readonly [Record<string, string>, {
+    readonly id: string;
+    readonly stylesheets: Record<string, string>;
+    readonly loading: string[];
+    readonly errors: {
+        url: string;
+        error: Error;
+    }[];
+}];
+
+declare function useResourceEvents<T extends NormalizedEntity>(resource?: Reference, scope?: string[]): any;
+
+declare function useResources<Type>(ids: string[], type: string): Type[];
+
+declare function useSearchService(): SearchService | 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 getCroppedThumbnail(thumbnail: any, request: ImageCandidateRequest): ImageCandidate | undefined;
+declare function useThumbnail(request: ImageCandidateRequest, dereference?: boolean, { canvasId, manifestId }?: {
+    canvasId?: string;
+    manifestId?: string;
+}): ImageCandidate | undefined;
+
+type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+type Transition = {
+    from: Rect;
+    to: Rect;
+};
+declare const DEFAULT_BEZIER: [number, number, number, number];
+declare const DEFAULT_POLL_INTERVAL = 16;
+type EasingPreset = 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'ease-in-cubic' | 'ease-out-cubic';
+declare const EASING_PRESETS: Record<EasingPreset, [number, number, number, number]>;
+declare function interpolateRect(a: Rect, b: Rect, t: number): Rect;
+declare function buildTransitions(initial: Rect, regions: Rect[]): Transition[];
+/**
+ * Create a cubic-bezier easing function given control points [x1,y1,x2,y2].
+ * Uses a numeric solve to invert x(t) -> t for a given x input.
+ */
+declare function cubicBezierEasing([x1, y1, x2, y2]: [number, number, number, number]): (x: number) => number;
+/**
+ * Map a progress value to a step index and local t in [0,1].
+ * If progress < 0 returns index -1 and t 0. If progress >= transitions.length returns index = transitions.length and t 0.
+ */
+declare function getStepFromProgress(progress: number, transitions: Transition[]): {
+    index: number;
+    t: number;
+};
+
+type EasingInput = ((t: number) => number) | EasingPreset | [number, number, number, number];
+type UseViewportTourOptions = {
+    initial: Rect;
+    regions: Rect[];
+    /** Provide either a numeric progress or a function that returns progress */
+    progress?: number;
+    getProgress?: () => number;
+    enabled?: boolean;
+    easing?: EasingInput;
+    /** if true, report progress every tick; otherwise only when step index changes */
+    reportEveryFrame?: boolean;
+    pollInterval?: number;
+    loop?: boolean;
+    onEnter?: (index: number) => void;
+    onExit?: (index: number) => void;
+    onProgress?: (index: number, t: number) => void;
+    /** optional callback to receive jump-to function for programmatic navigation */
+    jumpTo?: (fn: (index: number) => void) => void;
+};
+declare function useViewportTour(options: UseViewportTourOptions): {
+    transitions: Transition[];
+    currentIndex: number;
+    currentTransition: Transition | undefined;
+    t: number;
+    rect: Rect | undefined;
+    jumpTo: (indexToJump: number) => void;
+};
+
+type UseViewportScrollOptions = {
+    axis?: 'y' | 'x';
+    offset?: number;
+    steps?: number;
+    enabled?: boolean;
+};
+/**
+ * Returns a progress value derived from scroll position of provided element.
+ * The returned value is in range [0, steps].
+ * Uses passive scroll listener + requestAnimationFrame for efficient updates.
+ */
+declare function useViewportScroll(ref: {
+    current: HTMLElement | null;
+} | null, options?: UseViewportScrollOptions): number;
+
+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 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 useContainerSequence({ startCanvas, disablePaging }: {
+    startCanvas?: string;
+    disablePaging?: boolean;
+}): {
+    visibleItems: string[];
+    cursor: number;
+    items: ViewableContainerReference[];
+    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;
+};
+/** @deprecated Use useContainerSequence for Canvas and Timeline navigation. Root imports retain Presentation 3 item types. */
+declare function useCanvasSequence(options: Parameters<typeof useContainerSequence>[0]): Omit<ReturnType<typeof useContainerSequence>, 'items'> & {
+    items: Reference<'Canvas'>[];
+};
+
+export { getComplexTimelineStrategy as $, AnnotationContext as A, ControlsReactContext as B, CanvasContext as C, useRenderControls as D, defaultEmitter as E, ReactEventContext as F, useEventEmitter as G, EventsProvider as H, ImageServiceLoaderContext as I, useImageServiceLoader as J, useMediaState as K, useMediaActions as L, ManifestContext as M, useMediaElements as N, MediaPlayerProvider as O, RangeContext as P, type ResourceContextType as Q, ResourceProvider as R, ResourceReactContext as S, useResourceContext as T, type SelectorHelperEventTypes as U, type VaultActivatedAnnotation as V, SelectorControllerProvider as W, useSelectorEmitter as X, useSelectorEvents as Y, useSelectorController as Z, useSelectorHelper as _, ReactVaultContext as a, useVisibleCanvasContainers as a$, getVideoStrategy as a0, type VaultHooks as a1, createVaultHooks as a2, useAnnotationPageManager as a3, useCanvasClock as a4, useCanvasStartTime as a5, useDispatch as a6, useEventListener as a7, ReactEmitterContext as a8, EventEmitterProvider as a9, DEFAULT_BEZIER as aA, DEFAULT_POLL_INTERVAL as aB, type EasingPreset as aC, EASING_PRESETS as aD, interpolateRect as aE, buildTransitions as aF, cubicBezierEasing as aG, getStepFromProgress as aH, SimpleViewerReactContext as aI, InnerViewerProvider as aJ, SimpleViewerProvider as aK, useSimpleViewer as aL, useContainerSequence as aM, useCanvasSequence as aN, hasAuth as aO, type ProbeStore as aP, type AuthContextState as aQ, type AuthContextCurrentActions as aR, type AuthContextActions as aS, type AuthAccessState as aT, createAuthStateStore as aU, createProbe as aV, authDetailsForResource as aW, makeAccessTokenRequest as aX, makeAccessServiceRequest as aY, VaultProvider as aZ, useVisibleCanvases as a_, useEmitter as aa, useEvent as ab, type ResourceRequestOptions as ac, useExternalResource as ad, useImage as ae, type ImageServiceRequestOptions as af, useImageService as ag, useImageTile as ah, usePaintables as ai, useStaticRenderingStrategy as aj, useStylesheetStore as ak, useRemoteStylesheet as al, useResourceEvents as am, useResources as an, useSearchService as ao, useStyleHelper as ap, useStyles as aq, getCroppedThumbnail as ar, useThumbnail as as, type EasingInput as at, type UseViewportTourOptions as au, useViewportTour as av, type UseViewportScrollOptions as aw, useViewportScroll as ax, type Rect as ay, type Transition as az, VisibleCanvasReactContext as b, type ActiveVault as b0, useActiveVault as b1, useVault as b2, useVirtualAnnotationPageContext as c, VirtualAnnotationProvider as d, AnnotationPageContext as e, type AnnotationStyles as f, type AnnotationThemeDefinition as g, getDefaultAnnotationStyles as h, useAnnotationStyles as i, AnnotationStyleProvider as j, type AuthState as k, AuthRContext as l, AuthReactContext as m, AuthReactContextActions as n, AuthProvider as o, useIsAuthEnabled as p, useAuthStore as q, useAuthActions as r, useCurrentAuth as s, useAuthService as t, useVirtualAnnotationPage as u, useAuthTokens as v, useAuthToken as w, Auth as x, CollectionContext as y, type ControlsContext as z };