react-iiif-vault 0.9.10 → 0.9.13

package/.build/types/canvas-panel/Viewer.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { AtlasProps } from '@atlas-viewer/atlas/dist/types/modules/react-reconciler/Atlas';
+export declare function Viewer({ children, errorFallback, outerContainerProps, ...props }: AtlasProps & {
+    height?: number | string;
+    width?: number | string;
+    resizeHash?: number;
+    containerProps?: any;
+    outerContainerProps?: any;
+    aspectRatio?: number;
+    errorFallback?: any;
+} & {
+    children: ReactNode;
+}): JSX.Element;

package/.build/types/canvas-panel/index.d.ts

@@ -0,0 +1,18 @@
+import { Viewer } from './Viewer';
+import { RenderCanvas } from './render/Canvas';
+import { RenderImage } from './render/Image';
+export declare const CanvasPanel: {
+    RenderImage: typeof RenderImage;
+    RenderCanvas: typeof RenderCanvas;
+    RenderAnnotationPage: import("react").FC<{
+        page: import("@iiif/presentation-3").AnnotationPageNormalized | import("@iiif/presentation-3").AnnotationPage;
+        className?: string | undefined;
+    }>;
+    RenderAnnotation: import("react").FC<{
+        id: string;
+        className?: string | undefined;
+        style?: import("@atlas-viewer/atlas/*").BoxStyle | undefined;
+        interactive?: boolean | undefined;
+    }>;
+    Viewer: typeof Viewer;
+};

package/.build/types/canvas-panel/render/Annotation.d.ts

@@ -0,0 +1,8 @@
+import { BoxStyle } from '@atlas-viewer/atlas';
+import { FC } from 'react';
+export declare const RenderAnnotation: FC<{
+    id: string;
+    className?: string;
+    style?: BoxStyle;
+    interactive?: boolean;
+}>;

package/.build/types/canvas-panel/render/AnnotationPage.d.ts

@@ -0,0 +1,6 @@
+import { AnnotationPage, AnnotationPageNormalized } from '@iiif/presentation-3';
+import { FC } from 'react';
+export declare const RenderAnnotationPage: FC<{
+    page: AnnotationPage | AnnotationPageNormalized;
+    className?: string;
+}>;

package/.build/types/canvas-panel/render/Audio.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import { SingleAudio } from '../../features/rendering-strategy/resource-types';
+export declare function Audio({ media, children }: {
+    media: SingleAudio;
+    children: ReactNode;
+}): JSX.Element;

package/.build/types/canvas-panel/render/Canvas.d.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from 'react';
+import { ChoiceDescription } from '../../features/rendering-strategy/choice-types';
+import { StrategyActions } from '../../hooks/useRenderingStrategy';
+import { MediaStrategy, RenderingStrategy } from '../../features/rendering-strategy/strategies';
+import { SingleImageStrategy } from '../../features/rendering-strategy/image-strategy';
+declare type CanvasProps = {
+    x?: number;
+    y?: number;
+    onCreated?: any;
+    onChoiceChange?: (choice?: ChoiceDescription) => void;
+    registerActions?: (actions: StrategyActions) => void;
+    defaultChoices?: Array<{
+        id: string;
+        opacity?: number;
+    }>;
+    isStatic?: boolean;
+    children?: ReactNode;
+    renderViewerControls?: (strategy: SingleImageStrategy) => ReactNode;
+    renderMediaControls?: (strategy: MediaStrategy) => ReactNode;
+    strategies?: Array<RenderingStrategy['type']>;
+};
+export declare function RenderCanvas({ x, y, onChoiceChange, registerActions, defaultChoices, isStatic, renderViewerControls, renderMediaControls, strategies, children, }: CanvasProps): JSX.Element | null;
+export {};

package/.build/types/canvas-panel/render/DefaultCanvasFallback.d.ts

@@ -0,0 +1,5 @@
+export declare function DefaultCanvasFallback({ width, style, height }: {
+    width?: number;
+    height?: number;
+    style?: any;
+}): JSX.Element;

package/.build/types/canvas-panel/render/Image.d.ts

@@ -0,0 +1,13 @@
+import { ImageCandidate } from '@atlas-viewer/iiif-image-api';
+import { ReactNode } from 'react';
+import { ImageWithOptionalService } from '../../features/rendering-strategy/resource-types';
+export declare function RenderImage({ id, image, thumbnail, isStatic, x, y, annotations, children, }: {
+    id: string;
+    image: ImageWithOptionalService;
+    thumbnail?: ImageCandidate;
+    isStatic?: boolean;
+    x?: number;
+    y?: number;
+    annotations?: ReactNode;
+    children?: ReactNode;
+}): JSX.Element;

package/.build/types/canvas-panel/render/Model.d.ts

@@ -0,0 +1,3 @@
+export declare function Model({ model }: {
+    model: any;
+}): JSX.Element;

package/.build/types/canvas-panel/render/Video.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import { SingleVideo } from '../../features/rendering-strategy/resource-types';
+export declare function Video({ media, children }: {
+    media: SingleVideo;
+    children: ReactNode;
+}): JSX.Element;

package/.build/types/context/AnnotationContext.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export declare function AnnotationContext({ annotation, children }: {
+    annotation: string;
+    children: ReactNode;
+}): JSX.Element;

package/.build/types/context/CanvasContext.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export declare function CanvasContext({ canvas, children }: {
+    canvas: string;
+    children: ReactNode;
+}): JSX.Element;

package/.build/types/context/CollectionContext.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export declare function CollectionContext({ collection, children }: {
+    collection: string;
+    children: ReactNode;
+}): JSX.Element;

package/.build/types/context/ContextBridge.d.ts

@@ -0,0 +1,22 @@
+import { ReactNode } from 'react';
+export declare function useContextBridge(): {
+    VaultContext: {
+        vault: import("@iiif/vault/*").Vault | null;
+        setVaultInstance: (vault: import("@iiif/vault/*").Vault) => void;
+    };
+    ResourceContext: import("./ResourceContext").ResourceContextType;
+    SimpleViewerReactContext: {
+        setCurrentCanvasId: (newId: string | ((prev: string) => string)) => void;
+        setCurrentCanvasIndex: (newId: number | ((prev: number) => number)) => void;
+        currentCanvasIndex: number;
+        pagingView: boolean;
+        totalCanvases: number;
+        nextCanvas: () => void;
+        previousCanvas: () => void;
+    };
+    VisibleCanvasReactContext: string[];
+};
+export declare function ContextBridge(props: {
+    bridge: ReturnType<typeof useContextBridge>;
+    children: ReactNode;
+}): JSX.Element;

package/.build/types/context/ImageServiceLoaderContext.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { ImageServiceLoader } from '@atlas-viewer/iiif-image-api';
+export declare const ImageServiceLoaderContext: React.Context<ImageServiceLoader>;
+export declare function useImageServiceLoader(): ImageServiceLoader;

package/.build/types/context/ManifestContext.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export declare function ManifestContext({ manifest, children }: {
+    manifest: string;
+    children: ReactNode;
+}): JSX.Element;

package/.build/types/context/MediaContext.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode, RefObject } from 'react';
+import { MediaPlayerActions, MediaPlayerState } from '../hooks/useSimpleMediaPlayer';
+export declare function useMediaState(): MediaPlayerState;
+export declare function useMediaActions(): MediaPlayerActions;
+export declare function useMediaElements(): {
+    element: RefObject<HTMLAudioElement | HTMLVideoElement>;
+    currentTime: RefObject<HTMLDivElement>;
+    progress: RefObject<HTMLDivElement>;
+};
+export 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>;
+}): JSX.Element;

package/.build/types/context/PortalContext.d.ts

@@ -0,0 +1,7 @@
+import React, { ReactNode } from 'react';
+export declare const PortalContext: React.Context<HTMLDivElement | null>;
+export declare const OverlayPortalContext: React.Context<HTMLDivElement | null>;
+export declare function CanvasPortal({ children, overlay }: {
+    children: ReactNode;
+    overlay?: boolean;
+}): null;

package/.build/types/context/RangeContext.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export declare function RangeContext({ range, children }: {
+    range: string;
+    children: ReactNode;
+}): JSX.Element;

package/.build/types/context/ResourceContext.d.ts

@@ -0,0 +1,14 @@
+import React, { ReactNode } from 'react';
+export declare type ResourceContextType = {
+    collection?: string;
+    manifest?: string;
+    range?: string;
+    canvas?: string;
+    annotation?: string;
+};
+export declare const ResourceReactContext: React.Context<ResourceContextType>;
+export declare const useResourceContext: () => ResourceContextType;
+export declare function ResourceProvider({ value, children }: {
+    value: ResourceContextType;
+    children: ReactNode;
+}): JSX.Element;

package/.build/types/context/VaultContext.d.ts

@@ -0,0 +1,14 @@
+import React, { ReactNode } from 'react';
+import { Vault, VaultOptions } from '@iiif/vault';
+import { ResourceContextType } from './ResourceContext';
+export declare const ReactVaultContext: React.Context<{
+    vault: Vault | null;
+    setVaultInstance: (vault: Vault) => void;
+}>;
+export declare function VaultProvider({ vault, vaultOptions, useGlobal, resources, children, }: {
+    vault?: Vault;
+    useGlobal?: boolean;
+    vaultOptions?: VaultOptions;
+    resources?: ResourceContextType;
+    children: ReactNode;
+}): JSX.Element;

package/.build/types/context/ViewerPresetContext.d.ts

@@ -0,0 +1,3 @@
+import { Preset } from '@atlas-viewer/atlas';
+export declare const ViewerPresetContext: import("react").Context<Preset | null | undefined>;
+export declare function useViewerPreset(): Preset | null | undefined;

package/.build/types/context/VisibleCanvasContext.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { CanvasNormalized } from '@iiif/presentation-3';
+export declare const VisibleCanvasReactContext: React.Context<string[]>;
+export declare function useVisibleCanvases(): CanvasNormalized[];

package/.build/types/demo/demo.d.ts

@@ -0,0 +1 @@
+export {};

package/.build/types/demo/media-controls.d.ts

@@ -0,0 +1 @@
+export declare function MediaControls(): JSX.Element;

package/.build/types/demo/viewer-controls.d.ts

@@ -0,0 +1 @@
+export declare function ViewerControls(): JSX.Element;

package/.build/types/features/rendering-strategy/3d-strategy.d.ts

@@ -0,0 +1,13 @@
+import { CanvasNormalized } from '@iiif/presentation-3';
+import { Paintables } from './rendering-utils';
+import { AnnotationPageDescription } from './resource-types';
+import { ChoiceDescription } from './choice-types';
+import { ExternalWebResource } from '@iiif/presentation-3/resources/annotation';
+import { RenderingStrategy } from './strategies';
+export declare type Single3DModelStrategy = {
+    type: '3d-model';
+    model: ExternalWebResource;
+    choice?: ChoiceDescription;
+    annotations?: AnnotationPageDescription;
+};
+export declare function get3dStrategy(canvas: CanvasNormalized, paintables: Paintables): RenderingStrategy;

package/.build/types/features/rendering-strategy/audio-strategy.d.ts

@@ -0,0 +1,3 @@
+import { CanvasNormalized } from '@iiif/presentation-3';
+import { Paintables } from './rendering-utils';
+export declare function getAudioStrategy(canvas: CanvasNormalized, paintables: Paintables): import("./strategies").RenderingStrategy;

package/.build/types/features/rendering-strategy/choice-types.d.ts

@@ -0,0 +1,15 @@
+import { InternationalString } from '@iiif/presentation-3';
+export interface SingleChoice {
+    type: 'single-choice';
+    label?: InternationalString;
+    items: Array<{
+        id: string;
+        label?: InternationalString;
+        selected?: true;
+    }>;
+}
+export interface ComplexChoice {
+    type: 'complex-choice';
+    items: SingleChoice[];
+}
+export declare type ChoiceDescription = SingleChoice | ComplexChoice;

package/.build/types/features/rendering-strategy/image-strategy.d.ts

@@ -0,0 +1,13 @@
+import { CanvasNormalized } from '@iiif/presentation-3';
+import { ImageServiceLoaderType } from '../../hooks/useLoadImageService';
+import { AnnotationPageDescription, ImageWithOptionalService } from './resource-types';
+import { Paintables } from './rendering-utils';
+import { ChoiceDescription } from './choice-types';
+export declare type SingleImageStrategy = {
+    type: 'images';
+    image: ImageWithOptionalService;
+    images: Array<ImageWithOptionalService>;
+    choice?: ChoiceDescription;
+    annotations?: AnnotationPageDescription;
+};
+export declare function getImageStrategy(canvas: CanvasNormalized, paintables: Paintables, loadImageService: ImageServiceLoaderType): import("./strategies").RenderingStrategy;

package/.build/types/features/rendering-strategy/rendering-utils.d.ts

@@ -0,0 +1,21 @@
+import { AnnotationNormalized, ContentResource, IIIFExternalWebResource, SpecificResource } from '@iiif/presentation-3';
+import { Vault } from '@iiif/vault';
+import { ChoiceDescription } from './choice-types';
+import { UseRenderingStrategy } from '../../hooks/useRenderingStrategy';
+export declare function parseSpecificResource(resource: ContentResource): any[];
+export interface Paintables {
+    choice: ChoiceDescription | null;
+    types: string[];
+    items: Array<{
+        type: string;
+        resource: IIIFExternalWebResource | SpecificResource;
+        target: any;
+        selector: any;
+    }>;
+}
+export declare function getPaintables(vault: Vault, paintingAnnotations: AnnotationNormalized[], enabledChoices: string[]): Paintables;
+export declare const emptyActions: {
+    makeChoice: () => void;
+};
+export declare const unknownResponse: UseRenderingStrategy[0];
+export declare const unsupportedStrategy: (reason: string) => UseRenderingStrategy[0];

package/.build/types/features/rendering-strategy/resource-types.d.ts

@@ -0,0 +1,42 @@
+import { AnnotationPageNormalized, ImageService } from '@iiif/presentation-3';
+import { BoxSelector, TemporalBoxSelector, TemporalSelector } from '@iiif/vault-helpers/annotation-targets';
+export declare type ImageWithOptionalService = {
+    id: string;
+    type: 'Image';
+    service?: ImageService;
+    width?: number;
+    height?: number;
+    sizes?: Array<{
+        width: number;
+        height: number;
+    }>;
+    target: BoxSelector | TemporalBoxSelector;
+    selector: BoxSelector;
+};
+export declare type SingleAudio = {
+    type: 'Sound';
+    url: string;
+    format: string;
+    duration: number;
+    target: TemporalSelector;
+    selector: TemporalSelector;
+};
+export declare type SingleVideo = {
+    type: 'Video';
+    url: string;
+    format: string;
+    duration: number;
+    target: TemporalSelector | TemporalBoxSelector;
+    selector: TemporalSelector | TemporalBoxSelector;
+};
+export declare type AudioSequence = {
+    type: 'SoundSequence';
+    items: SingleAudio[];
+};
+export declare type VideoSequence = {
+    type: 'VideoSequence';
+    items: SingleVideo[];
+};
+export declare type AnnotationPageDescription = {
+    pages: AnnotationPageNormalized[];
+};

package/.build/types/features/rendering-strategy/strategies.d.ts

@@ -0,0 +1,22 @@
+import { AnnotationPageDescription, AudioSequence, ImageWithOptionalService, SingleAudio, SingleVideo, VideoSequence } from './resource-types';
+import { ChoiceDescription } from './choice-types';
+import { SingleImageStrategy } from './image-strategy';
+import { Single3DModelStrategy } from './3d-strategy';
+export declare type MediaStrategy = {
+    type: 'media';
+    media: SingleAudio | SingleVideo | AudioSequence | VideoSequence;
+    choice?: ChoiceDescription;
+    annotations?: AnnotationPageDescription;
+};
+export declare type ComplexTimelineStrategy = {
+    type: 'complex-timeline';
+    items: Array<ImageWithOptionalService | SingleAudio | SingleVideo>;
+    choice?: ChoiceDescription;
+    annotations?: AnnotationPageDescription;
+};
+export declare type UnknownStrategy = {
+    type: 'unknown';
+    reason?: string;
+    annotations?: AnnotationPageDescription;
+};
+export declare type RenderingStrategy = SingleImageStrategy | MediaStrategy | ComplexTimelineStrategy | Single3DModelStrategy | UnknownStrategy;

package/.build/types/features/rendering-strategy/video-strategy.d.ts

@@ -0,0 +1,3 @@
+import { CanvasNormalized } from '@iiif/presentation-3';
+import { Paintables } from './rendering-utils';
+export declare function getVideoStrategy(canvas: CanvasNormalized, paintables: Paintables): import("./strategies").RenderingStrategy;

package/.build/types/hooks/useAnnotation.d.ts

@@ -0,0 +1,8 @@
+import { AnnotationNormalized } from '@iiif/presentation-3';
+export declare function useAnnotation(options?: {
+    id: string;
+}): AnnotationNormalized | undefined;
+export declare function useAnnotation<T>(options?: {
+    id: string;
+    selector: (annotation: AnnotationNormalized) => T;
+}, deps?: any[]): T | undefined;

package/.build/types/hooks/useAnnotationPageManager.d.ts

@@ -0,0 +1,10 @@
+export declare function useAnnotationPageManager(resourceId?: string, options?: {
+    all?: boolean;
+}): {
+    availablePageIds: string[];
+    enabledPageIds: string[];
+    setPageEnabled: (id: string, opt?: {
+        deselectOthers?: boolean;
+    }) => void;
+    setPageDisabled: (deselectId: string) => void;
+};

package/.build/types/hooks/useAnnotationsAtTime.d.ts

@@ -0,0 +1,4 @@
+import { AnnotationNormalized } from '@iiif/presentation-3';
+export declare function useAnnotationsAtTime(time: number, options?: {
+    canvasId?: string;
+}): AnnotationNormalized[];

package/.build/types/hooks/useCanvas.d.ts

@@ -0,0 +1,8 @@
+import { CanvasNormalized } from '@iiif/presentation-3';
+export declare function useCanvas(options?: {
+    id: string;
+}): CanvasNormalized | undefined;
+export declare function useCanvas<T>(options?: {
+    id: string;
+    selector: (canvas: CanvasNormalized) => T;
+}, deps?: any[]): T | undefined;

package/.build/types/hooks/useCanvasClock.d.ts

@@ -0,0 +1 @@
+export declare function useCanvasClock(canvasId?: string, autoplay?: boolean): void;

package/.build/types/hooks/useCollection.d.ts

@@ -0,0 +1,8 @@
+import { CollectionNormalized } from '@iiif/presentation-3';
+export declare function useCollection(options: {
+    id: string;
+}): CollectionNormalized | undefined;
+export declare function useCollection<T>(options: {
+    id: string;
+    selector: (collection: CollectionNormalized) => T;
+}, deps?: any[]): T | undefined;

package/.build/types/hooks/useDispatch.d.ts

@@ -0,0 +1,2 @@
+import { ReduxStore } from '@iiif/vault';
+export declare function useDispatch(): ReduxStore['dispatch'];

package/.build/types/hooks/useEnabledAnnotationPageIds.d.ts

@@ -0,0 +1 @@
+export declare function useEnabledAnnotationPageIds(resourceId?: string, availablePageIds?: string[]): string[];

package/.build/types/hooks/useEventListener.d.ts

@@ -0,0 +1,4 @@
+import { Reference } from '@iiif/presentation-3';
+declare type SupportedEvents = 'onClick';
+export declare function useEventListener<T>(resource: Reference, name: SupportedEvents, listener: (e: any, resource: T) => void, scope?: string[], deps?: any[]): void;
+export {};

package/.build/types/hooks/useExistingVault.d.ts

@@ -0,0 +1 @@
+export declare function useExistingVault(): any;

package/.build/types/hooks/useExternalCollection.d.ts

@@ -0,0 +1,13 @@
+import { CollectionNormalized } from '@iiif/presentation-3';
+import { ResourceRequestOptions } from './useExternalResource';
+export declare function useExternalCollection(idOrRef: string | {
+    id: string;
+    type: string;
+}, options?: ResourceRequestOptions): {
+    id: string;
+    requestId: string;
+    isLoaded: boolean;
+    cached?: boolean;
+    error: any;
+    manifest?: CollectionNormalized;
+};

package/.build/types/hooks/useExternalManifest.d.ts

@@ -0,0 +1,13 @@
+import { ManifestNormalized } from '@iiif/presentation-3';
+import { ResourceRequestOptions } from './useExternalResource';
+export declare function useExternalManifest(idOrRef: string | {
+    id: string;
+    type: string;
+}, options?: ResourceRequestOptions): {
+    id: string;
+    requestId: string;
+    isLoaded: boolean;
+    cached?: boolean;
+    error: any;
+    manifest?: ManifestNormalized;
+};

package/.build/types/hooks/useExternalResource.d.ts

@@ -0,0 +1,16 @@
+export declare type ResourceRequestOptions = {
+    noCache?: boolean;
+};
+export 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;
+};

package/.build/types/hooks/useImageService.d.ts

@@ -0,0 +1,9 @@
+import { ImageService } from '@iiif/presentation-3';
+export interface ImageServiceRequestOptions {
+    cacheKey?: string;
+}
+export declare function useImageService({ cacheKey }?: ImageServiceRequestOptions): {
+    data: ImageService | undefined;
+    isFetching: boolean;
+    status: 'error' | 'success' | 'loading' | 'idle';
+};

package/.build/types/hooks/useImageTile.d.ts

@@ -0,0 +1,11 @@
+import { ImageService } from '@iiif/presentation-3';
+export declare function useImageTile(): {
+    isLoading: boolean;
+    tile: {
+        id: string | undefined;
+        width: number | null | undefined;
+        height: number | null | undefined;
+        imageService: ImageService;
+        thumbnail: undefined;
+    } | null;
+};

package/.build/types/hooks/useLoadImageService.d.ts

@@ -0,0 +1,6 @@
+import { ImageService } from '@iiif/presentation-3';
+export declare type ImageServiceLoaderType = (imageService: any | undefined, { height, width }: {
+    height: number;
+    width: number;
+}) => ImageService | undefined;
+export declare function useLoadImageService(): readonly [ImageServiceLoaderType, Record<string, string>];

package/.build/types/hooks/useManifest.d.ts

@@ -0,0 +1,8 @@
+import { ManifestNormalized } from '@iiif/presentation-3';
+export declare function useManifest(options?: {
+    id: string;
+}): ManifestNormalized | undefined;
+export declare function useManifest<T>(options?: {
+    id: string;
+    selector: (manifest: ManifestNormalized) => T;
+}, deps?: any[]): T | undefined;

package/.build/types/hooks/usePaintables.d.ts

@@ -0,0 +1,8 @@
+export declare function usePaintables(options?: {
+    defaultChoices?: string[];
+}, deps?: any[]): readonly [import("../features/rendering-strategy/rendering-utils").Paintables, {
+    makeChoice: (id: string, { deselectOthers, deselect }?: {
+        deselectOthers?: boolean | undefined;
+        deselect?: boolean | undefined;
+    }) => void;
+}];

package/.build/types/hooks/usePaintingAnnotations.d.ts

@@ -0,0 +1,4 @@
+import { AnnotationNormalized } from '@iiif/presentation-3';
+export declare function usePaintingAnnotations(options?: {
+    canvasId?: string;
+}): AnnotationNormalized[];

package/.build/types/hooks/useRange.d.ts

@@ -0,0 +1,8 @@
+import { RangeNormalized } from '@iiif/presentation-3';
+export declare function useRange(options?: {
+    id: string;
+}): RangeNormalized | undefined;
+export declare function useRange<T>(options?: {
+    id: string;
+    selector: (range: RangeNormalized) => T;
+}, deps?: any[]): T | undefined;

package/.build/types/hooks/useRenderingStrategy.d.ts

@@ -0,0 +1,14 @@
+import { RenderingStrategy } from '../features/rendering-strategy/strategies';
+export declare type StrategyActions = {
+    makeChoice: (id: string, options?: {
+        deselectOthers?: boolean;
+        deselect?: boolean;
+    }) => void;
+};
+export declare type UseRenderingStrategy = [RenderingStrategy, StrategyActions];
+export declare type UseRenderingStrategyOptions = {
+    strategies?: Array<RenderingStrategy['type']>;
+    annotationPageManagerId?: string;
+    defaultChoices?: string[];
+};
+export declare function useRenderingStrategy(options?: UseRenderingStrategyOptions): UseRenderingStrategy;

package/.build/types/hooks/useResourceEvents.d.ts

@@ -0,0 +1,3 @@
+import { NormalizedEntity } from '@iiif/vault';
+import { Reference } from '@iiif/presentation-3';
+export declare function useResourceEvents<T extends NormalizedEntity>(resource?: Reference, scope?: string[]): any;

package/.build/types/hooks/useResources.d.ts

@@ -0,0 +1 @@
+export declare function useResources<Type>(ids: string[], type: string): Type[];

package/.build/types/hooks/useSearchService.d.ts

@@ -0,0 +1,2 @@
+import { SearchService } from '@iiif/presentation-3';
+export declare function useSearchService(): SearchService | undefined;