react-iiif-vault 2.0.19 → 4.0.0

package/dist/ranges-Cc2ppjFD.d.ts

@@ -0,0 +1,689 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { BoxStyle, AtlasProps } from '@atlas-viewer/atlas';
+import * as React$1 from 'react';
+import React__default, { ReactNode, Context } from 'react';
+import { S as SVGTheme, l as RenderContextProps, s as AudioComponentProps, V as VideoComponentProps, q as useSvgEditor, c as AtlasStore, A as AnnotationRequest, d as AnnotationResponse, b as AnnotationRequestOptions } from './index-ClFUurPI.js';
+import { b as CanvasWorldObjectProps, I as ImageStrategyProps } from './ImageStrategy-BHLIi5gd.js';
+import { I as ImageOptions } from './Image-CXsx26cA.js';
+import * as polygon_editor from 'polygon-editor';
+import { InputShape, PolygonEvents } from 'polygon-editor';
+import { InternationalString, MetadataItem, ImageService as ImageService$1, ImageSize, SearchServiceQueryParams, SearchServiceSearchResponse, SearchService as SearchService$1, SearchServiceAutocomplete, SvgSelector as SvgSelector$1, FragmentSelector } from '@iiif/parser/presentation-3/types';
+import { RegionParameter, RotationParameter, SizeParameter } from '@iiif/parser/image-3';
+import { a as SingleImageStrategy, E as EmptyStrategy } from './useRenderingStrategy-Vubk-vUU.js';
+import { S as StrategyContext } from './ViewerPresetContext-D7N6KH9p.js';
+import * as mitt from 'mitt';
+import * as zustand from 'zustand';
+import { S as SimpleViewerContext } from './SimpleViewerContext.types-CWf5OFM7.js';
+import * as _iiif_helpers from '@iiif/helpers';
+import { ComplexChoice, SupportedSelector, SvgSelector, BoxSelector } from '@iiif/helpers';
+import { Q as ResourceContextType, aQ as AuthContextState, aR as AuthContextCurrentActions, aS as AuthContextActions } from './SimpleViewerContext.hooks-DYJSrd-U.js';
+import * as _iiif_helpers_vault_4 from '@iiif/helpers/vault-4';
+import { Vault4 } from '@iiif/helpers/vault-4';
+import { Vault } from '@iiif/helpers/vault';
+import { ManifestNormalized, RangeNormalized } from '@iiif/parser/presentation-3-normalized/types';
+import { ManifestNormalized as ManifestNormalized$1, RangeNormalized as RangeNormalized$1 } from '@iiif/parser/presentation-4-normalized/types';
+
+type RegionHighlightType = {
+    id: any;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+declare function RegionHighlight({ id, interactive, region, onClick, onHover, onSave, aspectRatio, maintainAspectRatio, disableCardinalControls, isEditing, style, }: {
+    id?: string;
+    region: RegionHighlightType;
+    isEditing: boolean;
+    onSave?: (annotation: RegionHighlightType) => void;
+    onClick?: (annotation: RegionHighlightType) => void;
+    onHover?: (annotation: RegionHighlightType) => void;
+    aspectRatio?: number;
+    maintainAspectRatio?: boolean;
+    disableCardinalControls?: boolean;
+    interactive?: boolean;
+    style?: BoxStyle;
+}): react_jsx_runtime.JSX.Element;
+
+type ResizeWorldItemProps = JSX.IntrinsicElements['worldObject'] & {
+    handleSize?: number;
+    resizable?: boolean;
+    aspectRatio?: number;
+    onSave: (pos: Partial<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>) => void;
+    children?: ReactNode;
+    maintainAspectRatio?: boolean;
+    disableCardinalControls?: boolean;
+};
+declare function ResizeWorldItem({ handleSize: _handleSize, resizable, onSave, children, maintainAspectRatio, disableCardinalControls, aspectRatio, ...props }: ResizeWorldItemProps): react_jsx_runtime.JSX.Element;
+
+declare function RenderAnnotationEditing({ theme, renderContextMenu, children, }: {
+    theme?: Partial<SVGTheme>;
+    renderContextMenu?: (options: RenderContextProps) => React.ReactNode;
+    children?: React.ReactNode;
+}): react_jsx_runtime.JSX.Element | null;
+declare function DefaultEditingTools(): react_jsx_runtime.JSX.Element | null;
+
+declare function CanvasWorldObject({ renderContextMenu, children, ...props }: CanvasWorldObjectProps & {
+    renderContextMenu?: (options: RenderContextProps) => ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function ThumbnailFallbackImage({ x, y }: {
+    x?: number;
+    y?: number;
+}): react_jsx_runtime.JSX.Element | null;
+
+declare function Render3DModelStrategy(): react_jsx_runtime.JSX.Element | null;
+
+declare function RenderAccompanyingCanvas(): react_jsx_runtime.JSX.Element;
+
+interface AnnotationStrategyProps {
+    children?: ReactNode;
+}
+declare function RenderAnnotationStrategy({ children }: AnnotationStrategyProps): react_jsx_runtime.JSX.Element | null;
+
+interface RenderAudioStrategyProps {
+    as?: React.ComponentType<AudioComponentProps>;
+}
+declare function RenderAudioStrategy({ as: CustomAudio }: RenderAudioStrategyProps): react_jsx_runtime.JSX.Element | null;
+
+declare function RenderComplexTimelineStrategy({ imageOptions }?: {
+    imageOptions?: ImageOptions;
+}): react_jsx_runtime.JSX.Element | null;
+
+interface RenderEmptyStrategyProps {
+    backgroundStyle?: BoxStyle;
+    alwaysShowBackground?: boolean;
+}
+declare function RenderEmptyStrategy({ backgroundStyle, alwaysShowBackground }: RenderEmptyStrategyProps): react_jsx_runtime.JSX.Element | null;
+
+declare function RenderImageStrategy(props: ImageStrategyProps): react_jsx_runtime.JSX.Element;
+
+interface TextualContextStrategyProps {
+    onClickPaintingAnnotation?: (id: string, e: any) => void;
+    children?: ReactNode;
+}
+declare function RenderTextualContentStrategy({ onClickPaintingAnnotation, children }: TextualContextStrategyProps): react_jsx_runtime.JSX.Element | null;
+
+interface RenderVideoStrategyProps {
+    as?: React__default.ComponentType<VideoComponentProps>;
+}
+declare function RenderVideoStrategy({ as: CustomVideo, }: RenderVideoStrategyProps): react_jsx_runtime.JSX.Element | null;
+
+declare function RenderYouTubeStrategy(): react_jsx_runtime.JSX.Element | null;
+
+declare const svgThemes: ({
+    name: string;
+    outer: {
+        borderWidth: number;
+        borderColor: string;
+    };
+    inner: {
+        borderWidth: number;
+        borderColor: string;
+    };
+} | {
+    name: string;
+    outer: {
+        borderWidth: string;
+        borderColor: string;
+    };
+    inner: {
+        borderWidth: string;
+        borderColor: string;
+    };
+} | {
+    name: string;
+    outer: {
+        borderWidth: string;
+        borderColor: string;
+    };
+    inner: {
+        borderWidth?: undefined;
+        borderColor?: undefined;
+    };
+})[];
+type HelperType = ReturnType<typeof useSvgEditor>['helper'];
+type StateType = ReturnType<typeof useSvgEditor>['state'];
+type SvgTheme = {
+    name?: string;
+    outer: BoxStyle;
+    inner: BoxStyle;
+};
+interface CreateCustomShapeProps {
+    image: {
+        width: number;
+        height: number;
+    };
+    shape?: any;
+    updateShape: any;
+    theme?: {
+        name?: string;
+        outer: BoxStyle;
+        inner: BoxStyle;
+    };
+    controlsHtmlId?: string;
+    renderControls?: (helper: HelperType, state: StateType, showShapes: boolean) => any;
+}
+declare function CreateCustomShape(props: CreateCustomShapeProps): null;
+
+interface PolygonSelectorProps {
+    id: string;
+    polygon: InputShape;
+    annotationBucket?: string;
+    isHighlighted?: boolean;
+    updatePolygon?: (shape: InputShape) => void;
+    readOnly?: boolean;
+    theme?: SvgTheme;
+    controlsHtmlId?: string;
+    renderControls?: CreateCustomShapeProps['renderControls'];
+}
+declare function PolygonSelector(props: PolygonSelectorProps): react_jsx_runtime.JSX.Element | null;
+
+declare const CanvasAnnotations: React$1.ForwardRefExoticComponent<{
+    canvasId?: string | undefined;
+} & React$1.RefAttributes<{
+    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;
+    customLabelRender?: (item: MetadataItem['label'], fallback: React.ReactNode) => React.ReactNode;
+    customValueRender?: (item: MetadataItem, fallback: React.ReactNode) => React.ReactNode;
+    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, customLabelRender, customValueRender, }: 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$1;
+    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;
+
+interface ImageServiceProps {
+    src: string;
+    atlas?: AtlasProps;
+    errorFallback?: React__default.FC;
+    interactive?: boolean;
+    skipSizes?: boolean;
+    renderViewerControls?: (strategy: SingleImageStrategy | EmptyStrategy) => ReactNode;
+    viewControlsDeps?: any[];
+    fluid?: boolean;
+    x?: number;
+    y?: number;
+    children?: React__default.ReactNode;
+}
+declare function ImageService({ src, errorFallback, interactive, skipSizes, children, renderViewerControls, viewControlsDeps, fluid, x, y, ...atlasProps }: ImageServiceProps & Omit<AtlasProps, 'children'>): react_jsx_runtime.JSX.Element | null;
+
+type ManifestMetadataProps = Omit<MetadataProps, 'metadata'>;
+declare function ManifestMetadata(props: ManifestMetadataProps): react_jsx_runtime.JSX.Element;
+
+interface SequenceThumbnailsProps {
+    flat?: boolean;
+    size?: {
+        width: number;
+        height?: number;
+    };
+    dereference?: boolean;
+    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;
+    scrollBehaviour?: ScrollBehavior;
+}
+declare function SequenceThumbnails({ scrollBehaviour, dereference, 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;
+
+interface RenderSvgEditorControlsProps {
+    showShapes?: boolean;
+    classNames?: Partial<{
+        button: string;
+    }>;
+    enabled?: {
+        draw?: boolean;
+        pen?: boolean;
+        line?: boolean;
+        lineBox?: boolean;
+        box?: boolean;
+        triangle?: boolean;
+        hexagon?: boolean;
+        circle?: boolean;
+        delete?: boolean;
+    };
+    icons?: Partial<{
+        DrawIcon: ReactNode;
+        PenIcon: ReactNode;
+        LineIcon: ReactNode;
+        LineBoxIcon: ReactNode;
+        ShapesIcon: ReactNode;
+        BoxIcon: ReactNode;
+        TriangleIcon: ReactNode;
+        HexagonIcon: ReactNode;
+        CircleIcon: ReactNode;
+        DeleteForeverIcon: ReactNode;
+        PointerIcon: ReactNode;
+        HandIcon: ReactNode;
+    }>;
+}
+declare function RenderSvgEditorControls({ showShapes, enabled, classNames, icons, }: RenderSvgEditorControlsProps): 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 useCustomContextBridge(): Record<string, {
+    value: any;
+    Provider: React__default.Provider<any>;
+}>;
+declare function CustomContextBridge(props: Record<string, {
+    value: any;
+    Provider: React__default.Provider<any>;
+}> & {
+    children: React__default.ReactNode;
+}): React__default.ReactNode;
+declare function CustomContextBridgeProvider(props: {
+    providers: Record<string, Context<any>>;
+    children: React__default.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useContextBridge(): {
+    VaultContext: {
+        vault: _iiif_helpers.Vault<_iiif_helpers.Vault3TypeMap> | _iiif_helpers_vault_4.Vault4 | null;
+        setVaultInstance: (vault: _iiif_helpers.Vault<_iiif_helpers.Vault3TypeMap> | _iiif_helpers_vault_4.Vault4) => void;
+    };
+    ResourceContext: ResourceContextType;
+    SimpleViewerReactContext: SimpleViewerContext;
+    VisibleCanvasReactContext: string[];
+    AuthRContext: zustand.StoreApi<AuthContextState & AuthContextCurrentActions & AuthContextActions> | null;
+    SearchReactContext: zustand.StoreApi<Search1Store> | null;
+    ReactEventContext: {
+        emitter: mitt.Emitter<Record<mitt.EventType, unknown>>;
+    };
+    ReactEmitterContext: mitt.Emitter<any>;
+    ContextBridgeReactContext: Record<string, React__default.Context<any>>;
+    StrategyReactContext: StrategyContext | null;
+    AtlasStoreReactContext: zustand.StoreApi<AtlasStore> | null;
+    ViewerIdentifierContext: string;
+};
+declare function ContextBridge(props: {
+    bridge: ReturnType<typeof useContextBridge>;
+    custom?: ReturnType<typeof useCustomContextBridge>;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function useCanvasChoices({ canvasId }?: {
+    canvasId?: string;
+}): {
+    choices: Array<{
+        canvasId: string;
+        choice: ComplexChoice;
+    }>;
+    actions: {
+        makeChoice: (id: string, options?: {
+            deselectOthers?: boolean;
+            deselect?: boolean;
+        }) => void;
+    };
+};
+
+declare function useCurrentAnnotationActions(): {
+    saveAnnotation: () => void;
+    cancelRequest: (requestId?: string | undefined) => void;
+};
+
+declare function useCurrentAnnotationMetadata({ requestId: customRequestId }?: {
+    requestId?: string;
+}): readonly [Record<string, any>, (data: Record<string, any>) => void];
+
+declare function useCurrentAnnotationRequest(): AnnotationRequest | null;
+
+declare function useCurrentAnnotationTransition(options: {
+    requestId?: string | null;
+    onStart?: (type: string) => void;
+    onEnd?: (type: string, response: PolygonEvents['polygons.end-transition']['response']) => void;
+    onTransition?: (type: string) => void;
+}): void;
+
+declare function usePolygonHelper(render: (t: any, s: any, dt: number) => void): {
+    currentShape: polygon_editor.InputShape | null;
+    state: polygon_editor.SlowState;
+    helper: {
+        state: polygon_editor.RenderState;
+        setState: (newState: Partial<polygon_editor.SlowState>) => void;
+        emitter: mitt.Emitter<polygon_editor.PolygonEvents>;
+        modifiers: {
+            reset(): void;
+            getForType(type: string | null): Record<string, string>;
+            set(modifier: string): void;
+            unset(modifier: string): void;
+        };
+        stamps: {
+            set(selectedStamp: polygon_editor.InputShape | null): void;
+            clear(): void;
+            square(): void;
+            triangle(): void;
+            pentagon(): void;
+            hexagon(): void;
+            circle(): void;
+        };
+        history: {
+            undo: () => void;
+            redo: () => void;
+            readonly canUndo: boolean;
+            readonly canRedo: boolean;
+        };
+        key: {
+            down(inputKey: string): boolean | undefined;
+            up(inputKey: string): void;
+        };
+        setScale: (scale: number) => void;
+        clock: {
+            set: (renderFunc: polygon_editor.RenderFunc) => void;
+            start: (renderFunc?: polygon_editor.RenderFunc | undefined, setStateFunc?: polygon_editor.SetState | undefined) => void;
+            stop: () => void;
+            step: (deltaTime?: number | undefined) => void;
+        };
+        pointer: (pointers: ([number, number] | [number, number, number, number, number, number])[]) => void;
+        blur: () => void;
+        pointerDown: () => void;
+        pointerUp: () => void;
+        setShape: (shape: polygon_editor.InputShape | null) => void;
+        label: (type: string | null) => string;
+        tools: {
+            setTool: (tool: polygon_editor.ValidTools) => void;
+            unsetTool: (tool: polygon_editor.ValidTools) => void;
+            toggleTool: (tool: polygon_editor.ValidTools) => void;
+            updateVisibility: (tool: polygon_editor.ValidTools) => void;
+            setCanDelete(canDelete: boolean): void;
+            setCanDeselect(canDeselect: boolean): void;
+            lockToolSwitching(): void;
+            unlockToolSwitching(): void;
+            toggleToolSwitching(): void;
+            shortcuts: {
+                [k: string]: string;
+            };
+            getValidIntents(tool?: polygon_editor.ValidTools | undefined): {
+                actions: polygon_editor.ActionIntent[];
+                transitions: polygon_editor.TransitionIntent[];
+                keys: polygon_editor.ActionIntent[];
+                all: Record<string, string>;
+                current: Record<string, string>;
+            };
+            getToolInfo(): {
+                name: polygon_editor.ValidTools;
+                cursor: string;
+                selectionCount: number;
+                pointCount: number;
+                isOpen: boolean;
+            };
+            smartSelect(): void;
+            clearSelection(): void;
+            autoSelect(): void;
+        };
+        snap: {
+            enabled: () => boolean;
+            enable: () => void;
+            disable: () => void;
+            toggle: () => void;
+            pointsEnabled: () => boolean;
+            enablePoints: () => void;
+            disablePoints: () => void;
+            togglePoints: () => void;
+            linesEnabled: () => boolean;
+            enableLines: () => void;
+            disableLines: () => void;
+            toggleLines: () => void;
+            intersectionsEnabled: () => boolean;
+            enableIntersections: () => void;
+            disableIntersections: () => void;
+            toggleIntersections: () => void;
+            gridEnabled: () => boolean;
+            enableGrid: () => void;
+            disableGrid: () => void;
+            toggleGrid: () => void;
+            parallelEnabled: () => boolean;
+            enableParallel: () => void;
+            disableParallel: () => void;
+            toggleParallel: () => void;
+            getThreshold: () => number;
+            setThreshold: (threshold: number) => void;
+            isActive: () => boolean;
+            getSnapPoint: () => ([number, number] | [number, number, number, number, number, number]) | null;
+            getActiveGuides: () => polygon_editor.SnapGuide[];
+            getTargets: () => polygon_editor.SnapTarget[];
+        };
+        selectAllPoints: () => void;
+        setBounds: (bounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        } | null) => void;
+        lockAspectRatio: () => void;
+        unlockAspectRatio: () => void;
+    };
+};
+
+declare function useRequestAnnotation(opts?: {
+    onSuccess?: (r: AnnotationResponse) => void;
+}): {
+    id: number;
+    busy: boolean;
+    isPending: boolean;
+    isActive: boolean;
+    requestId: string | null;
+    requestAnnotation: (request: AnnotationRequest, options?: Omit<AnnotationRequestOptions, 'requestId'>) => Promise<AnnotationResponse | null>;
+    cancelRequest: () => void;
+    completeRequest: () => void;
+    reset: () => void;
+    data: AnnotationResponse | null;
+};
+
+declare function useSvgEditorControls(): {
+    completeRequest: (requestId?: string | undefined) => void;
+    currentTool: polygon_editor.ValidTools;
+    selectedStamp: polygon_editor.InputShape | null;
+    switchTool: {
+        draw(): void;
+        pen(): void;
+        line(): void;
+        lineBox(): void;
+        box(): void;
+        triangle(): void;
+        hexagon(): void;
+        circle(): void;
+        remove(): void;
+        hand(): void;
+        pointer(): void;
+    };
+};
+
+type AnnotatedResource = {
+    annotations: readonly {
+        id: string;
+    }[];
+};
+declare function flattenAnnotationPageIds({ canvas, manifest, all, canvases, }: {
+    manifest?: AnnotatedResource;
+    canvas?: AnnotatedResource;
+    canvases?: readonly AnnotatedResource[];
+    all?: boolean;
+}): string[];
+
+declare function TranslationProvider(props: {
+    translations: Record<string, string>;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function LanguageProvider(props: {
+    language: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function TransliterationProvider(props: {
+    convert: null | ((input: string, targetLang: string) => string);
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useTransliteration(): ((input: string, targetLang: string) => string) | null;
+declare function useIIIFLanguage(): string;
+declare function useTranslations(): Record<string, 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, translations?: Record<string, string>): readonly [string, string | undefined];
+declare function useCreateLocaleString(): (inputText: InternationalString | string | null | undefined, defaultText?: string, separator?: string, translations?: Record<string, 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 function targetIntersects(a: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, b: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): boolean;
+
+declare function annotationResponseToSelector(response: {
+    polygon: AnnotationResponse['polygon'];
+    boundingBox?: AnnotationResponse['boundingBox'];
+    target?: AnnotationResponse['target'];
+}, on?: {
+    width: number;
+    height: number;
+} | null): SupportedSelector;
+
+declare function isRectangle(points: InputShape['points']): boolean;
+
+declare function isSvgSelector(t: SupportedSelector): t is SvgSelector;
+declare function isBoxSelector(t: SupportedSelector): t is BoxSelector;
+declare function serialiseSupportedSelector(selector: SupportedSelector, on?: {
+    width: number;
+    height: number;
+} | null): null | SvgSelector$1 | FragmentSelector;
+/** @deprecated Use serialiseSupportedSelector (corrected spelling). */
+declare const seraliseSupportedSelector: typeof serialiseSupportedSelector;
+
+declare function findManifestSelectedRange(vault: Vault, manifest: ManifestNormalized, canvasId: string): RangeNormalized | null;
+declare function findManifestSelectedRange(vault: Vault4, manifest: ManifestNormalized$1, canvasId: string): RangeNormalized$1 | null;
+declare function findSelectedRange(vault: Vault, range: RangeNormalized, canvasId: string): RangeNormalized | null;
+declare function findSelectedRange(vault: Vault4, range: RangeNormalized$1, canvasId: string): RangeNormalized$1 | null;
+
+export { TransliterationProvider as $, type AnnotationStrategyProps as A, SingleCanvasThumbnail as B, CanvasWorldObject as C, DefaultEditingTools as D, RenderSvgEditorControls as E, useCustomContextBridge as F, CustomContextBridge as G, CustomContextBridgeProvider as H, ImageService as I, useContextBridge as J, ContextBridge as K, useCanvasChoices as L, ManifestMetadata as M, useCurrentAnnotationActions as N, useCurrentAnnotationMetadata as O, type PolygonSelectorProps as P, useCurrentAnnotationRequest as Q, RegionHighlight as R, type SvgTheme as S, ThumbnailFallbackImage as T, useCurrentAnnotationTransition as U, usePolygonHelper as V, useRequestAnnotation as W, useSvgEditorControls as X, flattenAnnotationPageIds as Y, TranslationProvider as Z, LanguageProvider as _, isBoxSelector as a, useTransliteration as a0, useIIIFLanguage as a1, useTranslations as a2, LanguageString as a3, useClosestLanguage as a4, useLocaleString as a5, useCreateLocaleString as a6, LocaleString as a7, targetIntersects as a8, annotationResponseToSelector as a9, serialiseSupportedSelector as aa, seraliseSupportedSelector as ab, findManifestSelectedRange as ac, findSelectedRange as ad, isSvgSelector as b, ResizeWorldItem as c, RenderAnnotationEditing as d, Render3DModelStrategy as e, RenderAccompanyingCanvas as f, RenderAnnotationStrategy as g, RenderAudioStrategy as h, isRectangle as i, RenderComplexTimelineStrategy as j, RenderEmptyStrategy as k, RenderImageStrategy as l, RenderTextualContentStrategy as m, RenderVideoStrategy as n, RenderYouTubeStrategy as o, type CreateCustomShapeProps as p, CreateCustomShape as q, PolygonSelector as r, svgThemes as s, CanvasAnnotations as t, CombinedMetadata as u, type ImageProps as v, Image as w, type MetadataProps as x, Metadata as y, SequenceThumbnails as z };