@nulib/clover 0.0.0-stage → 4.0.0-beta.0

package/dist/index.d.mts

@@ -0,0 +1,2204 @@
+// Generated by dts-bundle-generator v8.0.1
+
+import { Canvas, Collection, Manifest, Scene, Timeline } from '@iiif/parser/presentation-4/types';
+import { Annotation, IIIFExternalWebResource, InternationalString, MetadataItem } from '@iiif/presentation-3';
+import React from 'react';
+import { CSSProperties, ReactNode } from 'react';
+
+/**
+ * Where an annotation points, read from any form of Presentation 4 target:
+ *
+ * - a URI, `canvas#xywh=x,y,w,h` or `canvas#t=start,end`;
+ * - a reference, `{ id, type }`, whose id carries the same fragments (what the upgrader
+ *   makes of a Presentation 3 string target);
+ * - a `SpecificResource`, `{ source, selector }`, with a `FragmentSelector`,
+ *   `PointSelector` or `SvgSelector` (or an array of them, of which the first that
+ *   applies wins);
+ * - several of these, as Presentation 4 groups them (`Independents`, `List`,
+ *   `Composite`, which the upgrader makes of a Presentation 3 array), of which this reads
+ *   the first; `annotationTargets` (`components/Canvas/track.ts`, with the hotspots that
+ *   follow a recording) reads them all.
+ *
+ * A fragment may give a region and a time at once (`xywh=…&t=…`, both dimensions of a
+ * Media Fragment): the region through that stretch of a recording.
+ */
+export interface ParsedAnnotationTarget {
+	/** The Canvas (or other resource) targeted, without its fragment. */
+	id: string;
+	point?: {
+		x: number;
+		y: number;
+	};
+	rect?: {
+		x: number;
+		y: number;
+		w: number;
+		h: number;
+	};
+	svg?: string;
+	/** A media fragment's time, as written: `start` or `start,end`. */
+	t?: string;
+}
+/**
+ * IIIF language maps as text: the closest language to the reader's, and that language's
+ * tag, so the text can carry a `lang` attribute.
+ */
+export type LanguageMapLike = string | Record<string, string[] | string | undefined> | null | undefined;
+export interface LocalizedValue {
+	text: string;
+	/** The tag the text is in; undefined for `none` (no language) or plain strings. */
+	lang?: string;
+}
+export declare function localize(value: LanguageMapLike, language?: string, separator?: string): LocalizedValue;
+/**
+ * What an annotation says: its text bodies (plain, HTML or Markdown, as their `format`
+ * says) and its images (Cookbook 0377). Caption files belong to the media transcript, so
+ * are left out. Light, for the Canvas's caption as well as the lists.
+ */
+export interface AnnotationBodyEntry {
+	/** `TextualBody` text, as published: plain, or IIIF's limited HTML. */
+	value?: string;
+	format?: string;
+	language?: string;
+	/** An image body (Cookbook 0377): its URL. */
+	image?: string;
+	/** An image body's label, else its annotation's: the image's text alternative. */
+	label?: LanguageMapLike;
+}
+/**
+ * A IIIF resource Clover can show directly, a Manifest's item: a Canvas (`Canvas`), a
+ * Timeline (`Timeline`, sound) or a Scene (`Scene`, 3D).
+ */
+export type Container = Canvas | Timeline | Scene;
+/**
+ * `resource` as Presentation 4: a Manifest, Collection, Canvas, Timeline or Scene from any
+ * supported version. Presentation 4 input is returned as it is.
+ */
+export declare function toPresentation4<T = Manifest | Collection | Container>(resource: unknown): Promise<T>;
+/**
+ * Annotations to read and to point at: everything a Manifest's Canvases carry in their
+ * `annotations` (comments, tags, transcriptions, descriptions), and pages a host adds.
+ * Painting annotations are the picture, not commentary, and caption files belong to the
+ * media transcript, so neither is listed here.
+ *
+ * A set is one AnnotationPage. Sets are memoized on the Manifest and the added pages, so
+ * the same arrays come back while nothing changes.
+ */
+export interface AnnotationEntry {
+	id: string;
+	/** The set it came from. */
+	setId: string;
+	/** The Canvas it targets. */
+	canvasId: string;
+	target: ParsedAnnotationTarget;
+	motivation: string[];
+	bodies: AnnotationBodyEntry[];
+	/** The annotation as published, for a host's own rendering. */
+	annotation: Record<string, any>;
+}
+export interface AnnotationSet {
+	id: string;
+	label?: LanguageMapLike;
+	/** Where it came from: the Manifest's Canvases, the host, or a Content Search. */
+	source: "manifest" | "added" | "search";
+	entries: AnnotationEntry[];
+}
+/**
+ * How Clover asks for things: one setting for every request it makes — the IIIF resource,
+ * referenced annotation pages, `info.json`, tiles, captions and HLS segments.
+ *
+ * A `<video>` or `<img>` element cannot send headers, so where Clover must use one (media
+ * without HLS, an image served without CORS) only `credentials` applies.
+ */
+export interface CloverRequest {
+	/** Cookies and HTTP authentication: `"include"` sends them cross-origin. */
+	credentials?: RequestCredentials;
+	/** Extra headers, such as `Authorization`. They force a CORS preflight. */
+	headers?: Record<string, string>;
+	/** Your own `fetch`, to sign, log or proxy requests. */
+	fetch?: typeof fetch;
+}
+/**
+ * Annotations a host adds to what the Manifest carries: an AnnotationPage, an
+ * AnnotationCollection (its pages followed from `first` through `next`), or a list of
+ * either, as URLs or objects. Each page becomes one set.
+ */
+export type AnnotationsInput = string | Record<string, unknown> | unknown[];
+/**
+ * IIIF Content State: a link that opens a resource at a place — a Canvas, a region of it,
+ * a moment in it. Clover reads the forms the spec gives (an annotation with the
+ * `contentState` motivation, or its bare target) as JSON or base64url-encoded, and turns
+ * them into what to load and where to go once it has (`content-state-reader.ts`, loaded
+ * only for one), and writes where the reader is as one (here).
+ *
+ * @see https://iiif.io/api/content-state/
+ */
+/** Where to go once a resource has loaded. Consumed once it has been applied. */
+export interface Target {
+	canvasId: string;
+	/** In the Canvas's own coordinates. */
+	region?: {
+		x: number;
+		y: number;
+		w: number;
+		h: number;
+	};
+	/** Seconds into a time-based Canvas. */
+	time?: number;
+	/** Start playback on arrival (auto-advance from the previous Canvas). */
+	autoplay?: boolean;
+}
+/** A content state as a link carries it: base64url of the URI-encoded JSON, unpadded. */
+export declare function encodeContentState(json: unknown): string;
+export interface ContentStateOutput {
+	/** The content state annotation. */
+	json: Record<string, unknown>;
+	/** The same, encoded for a URL. */
+	encoded: string;
+}
+/**
+ * Where the reader is, as a content state: the Canvas within its Manifest, and the
+ * visible region (`xywh=`) or the media time (`t=`) when there is one. Regions are
+ * rounded to whole pixels.
+ */
+export declare function buildContentState({ manifestId, canvasId, region, time, }: {
+	manifestId: string;
+	canvasId: string;
+	region?: {
+		x: number;
+		y: number;
+		w: number;
+		h: number;
+	} | null;
+	time?: number | null;
+}): ContentStateOutput;
+/**
+ * Turning whatever a `Root` is handed into a Manifest to show.
+ *
+ * `iiifContent` may be a URL, a IIIF resource object (Presentation 2, 3 or 4), or a content
+ * state (JSON or base64url). The resource may be a Manifest, a Collection (its first
+ * Manifest is shown), a lone Canvas (its `partOf` Manifest, or a Manifest made around
+ * it), or annotations, an AnnotationPage or AnnotationCollection (the Manifest their first
+ * annotation's Canvas is `partOf`, at that Canvas). Everything is fetched once, with the
+ * request settings, and upgraded to Presentation 4.
+ */
+export type IIIFContent = string | Record<string, unknown>;
+/**
+ * IIIF Content Search, versions 1 and 2: finding the Manifest's service, asking it, and
+ * reading the answer into hits to list and an annotation set to draw.
+ *
+ * - **Version 2** answers with an AnnotationPage of `highlighting` annotations on the
+ *   Canvases, and (optionally) `contextualizing` annotations whose TextQuoteSelectors give
+ *   the words around each match. Further pages hang from `next`.
+ * - **Version 1** answers with a Presentation 2 AnnotationList: `resources` (annotations
+ *   `on` a Canvas region, their text in `resource.chars`) and `hits` grouping them with
+ *   `before`, `match` and `after`. Further pages hang from `next` (or `within.next`).
+ *
+ * Neither is upgraded through `@iiif/parser`: the two shapes are small, and read
+ * directly. Finding the service is here; asking it and reading the answer are in
+ * `core/search.ts`. Both load statically: measured through esbuild, a lazy split cost
+ * more than it saved (shared modules are hoisted into an extra chunk).
+ */
+export interface SearchService {
+	id: string;
+	version: 1 | 2;
+}
+export interface SearchHit {
+	id: string;
+	/** The Canvas the hit is on. */
+	canvasId: string;
+	/** The annotations (regions) it highlights; the first is the one to go to. */
+	entryIds: string[];
+	before?: string;
+	match: string;
+	after?: string;
+}
+export interface SearchResults {
+	query: string;
+	hits: SearchHit[];
+	/** The hits as an annotation set, so the Canvas draws them where they are. */
+	set: AnnotationSet;
+}
+/** The set's id, so hosts and parts can tell search hotspots from annotations. */
+export declare const SEARCH_SET_ID = "content-search";
+/** The Manifest's Content Search service (2 preferred over 1), or null. */
+export declare function searchServiceOf(manifest: Manifest | null): SearchService | null;
+/**
+ * The smallest store Clover needs: state, a way to change it, and subscribers. React reads
+ * it through `useSyncExternalStore`, so a part re-renders only when what it selected
+ * changed.
+ */
+export interface Store<State> {
+	get(): State;
+	/** Merge a patch. Subscribers hear of it only if some value actually changed. */
+	set(patch: Partial<State> | ((state: State) => Partial<State>)): void;
+	subscribe(listener: () => void): () => void;
+}
+/**
+ * A stream of values that change too often for the store: the viewport on every frame,
+ * the media element and its time. Emitting never touches the store, so panning or playback
+ * re-renders nothing that has not subscribed.
+ */
+export interface Channel<Value> {
+	get(): Value;
+	emit(value: Value): void;
+	subscribe(listener: (value: Value) => void): () => void;
+}
+/**
+ * One Clover: what a `Root` owns. Framework-free, so it can be tested — and driven —
+ * without React.
+ *
+ * The store holds only what parts render from. Everything that changes per frame (the
+ * viewport) or per tick (media time) goes through channels, so panning or playback
+ * re-renders nothing that has not asked to hear about it.
+ */
+export type CloverStatus = "idle" | "loading" | "ready" | "error";
+export interface CloverState {
+	status: CloverStatus;
+	error: Error | null;
+	/** The Manifest shown, in Presentation 4. */
+	manifest: Manifest | null;
+	/** The Collection it was reached through, if any. */
+	collection: Collection | null;
+	/** The Canvas the reader is on: the first of the view that shows it. */
+	canvasId: string | null;
+	/** Where to go once the view is drawn: a region, a time. Consumed once applied. */
+	target: Target | null;
+	/** The annotation picked, from a list or its hotspot; the Canvas frames it. */
+	annotationId: string | null;
+	/** Annotation sets switched off: their hotspots are not drawn. */
+	hiddenSets: string[];
+	/**
+	 * Sets that start hidden (a still Canvas's OCR, `startsHidden`) switched on. What is
+	 * drawn is `selectHiddenSets`'s.
+	 */
+	shownSets: string[];
+	/** Sets the host added through `annotations`, beside the Manifest's own. */
+	addedSets: AnnotationSet[];
+	/** A Content Search of the Manifest: its query, progress and hits. */
+	search: SearchState;
+}
+export interface SearchState {
+	query: string;
+	status: "idle" | "loading" | "ready" | "error";
+	hits: SearchHit[];
+	/** The hits as a set the Canvas draws; null until there are any. */
+	set: AnnotationSet | null;
+}
+export interface ViewportState {
+	/** The visible region, in the coordinates of the Canvas holding most of the view. */
+	canvasId: string;
+	region: {
+		x: number;
+		y: number;
+		w: number;
+		h: number;
+	};
+}
+export interface CloverOptions {
+	request?: CloverRequest;
+	/**
+	 * Called with the Canvas the reader moves to. When `isControlled()` is true the store
+	 * is not changed: the host decides, and hands the id back through `syncCanvas`.
+	 */
+	onCanvasChange?: (canvasId: string) => void;
+	isControlled?: () => boolean;
+	/**
+	 * Called with the Manifest the reader moves to within a Collection. When
+	 * `isManifestControlled()` is true nothing moves: the host decides, and hands the id
+	 * back through `syncManifest`.
+	 */
+	onManifestChange?: (manifestId: string) => void;
+	isManifestControlled?: () => boolean;
+}
+export interface Clover {
+	store: Store<CloverState>;
+	viewport: Channel<ViewportState | null>;
+	media: Channel<HTMLVideoElement | null>;
+	/**
+	 * The caption file the reader chose in a Canvas's own Captions menu, by its `id` (the
+	 * WebVTT's address): `null` until they choose, or for Off. A transcript follows it.
+	 */
+	captions: Channel<string | null>;
+	/** The annotation hovered or focused, in a list or on the Canvas. */
+	highlight: Channel<string | null>;
+	/** The chapter (its Range's id) under the pointer on a seek bar, or in `Contents`. */
+	chapter: Channel<string | null>;
+	readonly request: CloverRequest | undefined;
+	setRequest(request: CloverRequest | undefined): void;
+	/** Load content. `canvasId` wins over everything; `defaultCanvasId` over `start`. */
+	load(content: IIIFContent, initial?: Initial): Promise<void>;
+	goTo(canvasId: string, target?: Omit<Target, "canvasId">): void;
+	/**
+	 * Show another member of the Collection: a Manifest (fetched if only referenced), or a
+	 * nested Collection, which is entered as `load` would.
+	 */
+	goToManifest(id: string, canvasId?: string): Promise<void>;
+	/** A controlled host's Manifest, shown without asking it again. */
+	syncManifest(id: string | null): Promise<void>;
+	/**
+	 * Show a Collection the Manifest is part of (its `partOf`) beside it: the Collection's
+	 * members become a choice, while the Manifest and the reader's place stay as they are.
+	 * Nothing changes if it will not load, or the reader has moved on meanwhile. The
+	 * information panel calls it when its Collection section first opens.
+	 */
+	openCollection(id: string): Promise<void>;
+	next(options?: {
+		autoplay?: boolean;
+		wrap?: boolean;
+	}): void;
+	previous(): void;
+	first(): void;
+	last(): void;
+	/** Mark the pending target applied, so it is not applied again. */
+	consumeTarget(): void;
+	/** A controlled host's Canvas, applied without asking it again. */
+	syncCanvas(canvasId: string | null): void;
+	/**
+	 * Pick an annotation (null to clear). On another Canvas, go there first; in a hidden
+	 * set, show the set.
+	 */
+	selectAnnotation(id: string | null): void;
+	/**
+	 * Search the Manifest through its Content Search service (1 or 2). The hits are listed
+	 * in `state.search` and drawn on the Canvas; an empty query clears them.
+	 */
+	search(query: string): Promise<void>;
+	/** Show or hide a set's hotspots. */
+	setSetVisible(setId: string, visible: boolean): void;
+	/** Add annotations beside the Manifest's: pages, collections, or a list of either. */
+	loadAnnotations(input: AnnotationsInput | null): Promise<void>;
+	/** Where the reader is, as a content state: the Canvas and its region or time. */
+	getContentState(): ContentStateOutput | null;
+	/**
+	 * Whose referenced annotation pages to fetch: the view's (default, as the reader moves)
+	 * or every Canvas's (a page listing all of them).
+	 */
+	setAnnotationPages(scope: "view" | "all"): void;
+	/**
+	 * Fetch every Canvas's referenced annotation pages while held, whatever
+	 * `setAnnotationPages` says: for a listing of all of them (`Annotations`'
+	 * `scope="all"`). Returns the release.
+	 */
+	holdAllAnnotationPages(): () => void;
+	/** Abandon any load in flight. The instance stays usable. */
+	dispose(): void;
+}
+export interface Navigation {
+	/** Zero-based index of the current view. */
+	position: number;
+	total: number;
+	hasPrevious: boolean;
+	hasNext: boolean;
+	previous(): void;
+	next(): void;
+	first(): void;
+	last(): void;
+	goTo(canvasId: string): void;
+}
+/** Where to open: the host's Canvas, its default, and in a Collection its Manifest. */
+export interface Initial {
+	canvasId?: string | null;
+	defaultCanvasId?: string | null;
+	manifestId?: string | null;
+}
+/**
+ * Renderers of your own for some views, drawn by `Body` in place of `Canvas`: a 3D
+ * model, a PDF, a map, anything a Canvas paints that Clover does not draw, or draws
+ * differently than you want. The successor to 3.x's `customDisplays`.
+ */
+export interface BodyRendererProps {
+	/** The view's Canvases, in Presentation 4: one, or two for a spread. */
+	canvases: Container[];
+	/**
+	 * The bodies the view's Canvases paint, unwrapped: a `Choice` as its first item, a
+	 * `SpecificResource` as its `source`, Presentation 4's groups as their items.
+	 */
+	bodies: Array<Record<string, any>>;
+	/** `Body`'s children (its controls), to place if the renderer wants them. */
+	children?: React.ReactNode;
+}
+export interface BodyRenderer {
+	/** Draws a view showing one of these Canvases… */
+	canvasId?: string[];
+	/** …or painting a body of one of these formats (`model/gltf-binary`, `application/pdf`)… */
+	format?: string[];
+	/** …or any view this says yes to. */
+	match?: (view: Omit<BodyRendererProps, "children">) => boolean;
+	/**
+	 * What draws it. It renders inside the Root, so Clover's hooks work in it
+	 * (`useActiveCanvas`, `useNavigation`, `useClover`…), as 3.x's `hooks` prop gave.
+	 */
+	component: React.ComponentType<BodyRendererProps>;
+}
+export interface RootProps extends Omit<React.HTMLAttributes<HTMLElement>, "children"> {
+	/**
+	 * What to show: a URL, a IIIF resource (Presentation 2, 3 or 4: a Manifest, Collection
+	 * or Canvas), or a content state (JSON or base64url).
+	 */
+	iiifContent: IIIFContent;
+	/** The Canvas to show, controlled: moving asks `onCanvasChange` to change it. */
+	canvasId?: string;
+	/** The Canvas to start on, uncontrolled. A content state or `start` still wins. */
+	defaultCanvasId?: string;
+	/** The reader moved to a Canvas (the first of the view that shows it). */
+	onCanvasChange?: (canvasId: string) => void;
+	/**
+	 * In a Collection, the member Manifest to show, controlled: choosing another asks
+	 * `onManifestChange` to change it.
+	 */
+	manifestId?: string;
+	/** In a Collection, the member Manifest to open first, uncontrolled. */
+	defaultManifestId?: string;
+	/** In a Collection, the reader moved (or, controlled, asks to move) to a Manifest. */
+	onManifestChange?: (manifestId: string) => void;
+	onStatusChange?: (status: CloverStatus, error: Error | null) => void;
+	/**
+	 * A Content Search query to run once the Manifest is shown, and again whenever it
+	 * changes (3.x's `iiifContentSearchQuery`). The reader can search on from `Search`.
+	 */
+	searchQuery?: string;
+	/** Credentials, headers and `fetch` for every request any part makes. */
+	request?: CloverRequest;
+	/** The language to read IIIF text in. The reader's, by default. */
+	language?: string;
+	/**
+	 * Renderers of your own for some views — by Canvas id, painting format, or a test —
+	 * drawn by every `Body` inside in place of `Canvas` (3.x's `customDisplays`).
+	 */
+	renderers?: BodyRenderer[];
+	/**
+	 * Annotations to show beside the Manifest's own: an AnnotationPage or
+	 * AnnotationCollection (or a list of them), as URLs or objects.
+	 */
+	annotations?: AnnotationsInput;
+	/**
+	 * Whose referenced annotation pages to fetch: the view's as the reader moves (default),
+	 * or every Canvas's at once, for a layout that shows them all.
+	 */
+	annotationPages?: "view" | "all";
+	/**
+	 * Where the reader is, as a IIIF content state, whenever it settles: after a move, a
+	 * pan or zoom, or a pause or seek in media. Debounced, and only when it changed.
+	 */
+	onContentStateChange?: (state: ContentStateOutput) => void;
+	/** The element to render. Default `div`. */
+	as?: React.ElementType;
+	children?: React.ReactNode;
+}
+/**
+ * The root of any Clover composition. It loads `iiifContent`, holds where the reader is,
+ * and gives every part inside it the same state. Render parts — `Clover.Body`,
+ * `Clover.Label`, `Clover.Items` — anywhere within it, in any layout.
+ */
+export declare const Root: React.ForwardRefExoticComponent<RootProps & React.RefAttributes<HTMLElement>>;
+export interface Point {
+	x: number;
+	y: number;
+}
+/** An axis-aligned rectangle in whatever space the caller is working in. */
+export interface Rect {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+}
+export type BackendKind = "webgl2" | "canvas2d" | "none";
+/**
+ * Where the camera looks, in world units.
+ *
+ * - `x`, `y`: the world point at the center of the viewport.
+ * - `zoom`: CSS pixels per world unit.
+ * - `rotation`: radians, clockwise on screen.
+ *
+ * World units are the pixels of the first image in the scene, so for a single image
+ * "world" and "image" coordinates are the same thing — which is what a content-state
+ * `xywh=` fragment wants.
+ */
+export interface CameraState {
+	x: number;
+	y: number;
+	zoom: number;
+	rotation: number;
+}
+export interface GestureOptions {
+	/**
+	 * A mouse click zooms in; with Shift, out. With this or `dblClickToZoom`, a double tap
+	 * (a finger, or a pen that does not hover) zooms in.
+	 */
+	clickToZoom: boolean;
+	/** A double click zooms in. Only consulted when `clickToZoom` is off. */
+	dblClickToZoom: boolean;
+	pinchToZoom: boolean;
+	/**
+	 * Plain wheel zooms. Off by default, matching Clover's OpenSeadragon setting, so an
+	 * embedded viewer never swallows page scroll. A trackpad pinch (a wheel event with
+	 * `ctrlKey`) always zooms the image, since it is never a page scroll.
+	 */
+	scrollToZoom: boolean;
+	/**
+	 * The reader may move the camera at all: drag, pinch, wheel, double-click and keys.
+	 * Off, the view stays where the host puts it and only taps are reported (a lone video
+	 * or sound, always fitted to the Body).
+	 */
+	navigable: boolean;
+}
+export type BackendPreference = "auto" | BackendKind;
+export type CanvasRendererEvent = 
+/** The first set of images is laid out and fitted. Fires once. */
+"open"
+/** The camera moved. Fires at most once per frame. */
+ | "viewport"
+/** A new set of images replaced the previous one. */
+ | "change" | "error"
+/** The backend changed (fallback, or a context released and reacquired). */
+ | "backend"
+/** A click that is not a zoom, with click-to-zoom turned off. */
+ | "tap";
+/**
+ * Manifest-level layout: which Canvases of a sequence are shown together.
+ *
+ * This is the host's decision — a Viewer stepping through a Manifest — not `Canvas`'s.
+ * `Canvas` draws whatever Canvases it is handed; a host uses this to decide what to hand
+ * it from the Manifest's `behavior`, and steps through the result itself.
+ *
+ * @see https://iiif.io/api/presentation/3.0/#behavior
+ */
+/** The order to lay several Canvases out in, along their reading axis. */
+export type ViewingDirection = "left-to-right" | "right-to-left" | "top-to-bottom" | "bottom-to-top";
+/** The spec's default is `left-to-right`. */
+export declare function resolveDirection(declared: unknown): ViewingDirection;
+/** The behaviors that arrange a sequence. Other behaviors do not affect layout. */
+export type SequenceBehavior = "individuals" | "paged" | "continuous" | "unordered";
+/** The Canvases shown together, as indexes into the sequence. */
+export type View = number[];
+/**
+ * The layout behavior to use: the first recognized layout value, so a `behavior` array
+ * may carry values from other sets (`auto-advance`, `hidden`) alongside it. The spec's
+ * default is `individuals`.
+ */
+export declare function resolveBehavior(declared: unknown): SequenceBehavior;
+/**
+ * Group a sequence into views.
+ *
+ * - `individuals` and `unordered`: one Canvas per view.
+ * - `continuous`: every Canvas in one view, a single joined object.
+ * - `paged`: spreads. The first Canvas stands alone (a cover), as does any Canvas whose
+ *   own behavior is `facing-pages` (it is already a spread) or `non-paged` (never
+ *   paired); the rest pair up. These are `@iiif/helpers`' `getManifestSequence` rules,
+ *   which the Viewer uses, so the two never disagree about what a spread is.
+ */
+export declare function groupViews(canvases: Array<{
+	behavior?: unknown;
+}>, behavior: SequenceBehavior): View[];
+/** A region of the image as shares of it: 0 to 1 across and down. */
+export interface RegionShare {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+}
+/**
+ * A small picture of a IIIF resource, for a list or a strip of them.
+ *
+ * - The resource's own `thumbnail` comes first; then, for a Canvas, the first image it
+ *   paints; then its placeholder or accompanying Canvas's (video and sound).
+ * - An image service is asked for nothing until its own `info.json` has been read (the
+ *   renderer's cached fetch, so a Canvas shown later does not ask again), and then only
+ *   as strictly as it says it can answer (`sizedImageUrl`): never more than the image has,
+ *   nor than its limits, at level 0 only a size it lists (Mat, 2026-10-24: "be
+ *   responsible when making IIIF image server requests"). What a manifest says of a
+ *   service is not trusted to say what its server does.
+ * - Without a service, the image itself is used.
+ */
+export interface ThumbnailSource {
+	/** Ready to use: an image with no service. */
+	src?: string;
+	/** An image service: its `info.json` is read before a URL is made (`resolveThumbnail`). */
+	service?: string;
+	/**
+	 * Only part of the image: shares of it (a target's region), or a region in Image API
+	 * syntax in the service's own pixels (a painting's selector), read against its `info.json`.
+	 */
+	region?: RegionShare | string;
+	/** Used if the service cannot answer. */
+	fallback?: string;
+}
+/**
+ * Where a resource's thumbnail comes from, to be sized by `resolveThumbnail`. Null if it
+ * has nothing to show.
+ */
+export declare function thumbnailSource(resource: unknown): ThumbnailSource | null;
+/**
+ * A picture to stand in for a Canvas as large as it is drawn, to be sized by
+ * `resolveThumbnail`: the first image it paints first, then its placeholder's or
+ * accompanying Canvas's, and only then its own `thumbnail`, which is often small. Null if
+ * it has nothing to show.
+ */
+export declare function stillSource(resource: unknown): ThumbnailSource | null;
+/**
+ * A source's URL at about `size` pixels on its longer side: a service's, made from its own
+ * `info.json` (`sizedImageUrl`), else the fallback, as where the service cannot answer.
+ */
+export declare function resolveThumbnail(source: ThumbnailSource, size?: number, request?: CloverRequest): Promise<string | undefined>;
+/**
+ * What `Canvas` draws: the IIIF Canvases it is handed, each with the images, video and
+ * sound it paints.
+ *
+ * Pure and React-free. It reads Presentation 4 Canvases and Timelines (Clover's one data
+ * shape; see `core/presentation.ts`), with their annotation pages embedded, and turns them
+ * into scene images placed in the world. Which Canvases to hand over — one, or a spread —
+ * is the host's decision; see `core/sequence.ts`.
+ */
+/** The parts of a Presentation 4 Canvas (or Timeline) this module reads. */
+export interface IIIFCanvas {
+	id: string;
+	type?: string;
+	width?: number;
+	height?: number;
+	behavior?: string[] | string;
+	label?: unknown;
+	/** Descriptive text and label/value pairs, shown from the Canvas's information control. */
+	summary?: unknown;
+	metadata?: Array<{
+		label?: unknown;
+		value?: unknown;
+	}>;
+	/** Seconds, on a time-based Canvas. */
+	duration?: number;
+	items?: Array<{
+		items?: Array<IIIFAnnotation>;
+	}>;
+	/** Non-painting annotations, embedded: captions are `supplementing` WebVTT here. */
+	annotations?: Array<{
+		items?: Array<IIIFAnnotation>;
+	}>;
+	/** Other forms of it: a transcript as plain text, among them. */
+	rendering?: unknown;
+	/** Shown before the Canvas is opened, and before playback begins. */
+	placeholderContainer?: IIIFCanvas;
+	/** Shown while sound plays, which has no picture of its own. */
+	accompanyingContainer?: IIIFCanvas;
+}
+export interface IIIFAnnotation {
+	id?: string;
+	motivation?: string | string[];
+	body?: unknown;
+	target?: unknown;
+}
+/**
+ * Where a `linking` annotation leads (Cookbook 0022): its first body that is not text. A
+ * Canvas, with the Manifest its `partOf` names; a Manifest or Collection; or a web page.
+ */
+export interface AnnotationLink {
+	/** Its address: the Canvas's or Manifest's id, or the page's. */
+	id: string;
+	canvasId?: string;
+	manifestId?: string;
+}
+export interface CanvasAnnotation {
+	annotation: Annotation;
+	/** Which image in the scene the annotation targets (its index in `body`/`src`). */
+	targetIndex: number;
+	/** Its AnnotationPage's `label`, which the menu and a recording's cues show it under. */
+	pageLabel?: LanguageMapLike;
+	/** Its AnnotationPage's `id`, by which the menu hides its page (`hiddenPages`). */
+	pageId?: string;
+}
+/**
+ * Everything a control needs in order to work, ready to spread onto a button: the id, the
+ * accessible name, the click handler and the icon. Spreading `buttonProps` keeps the wiring
+ * while the element, its shape and its styling stay the consumer's.
+ */
+export type ControlButtonProps = {
+	buttonProps: {
+		id: string;
+		type: "button";
+		"aria-label": string;
+		/**
+		 * The language of the name, when it is not the page's: a Choice's own label, or one
+		 * of Clover's strings in another language. Spread it with the rest (WCAG 3.1.2).
+		 */
+		lang?: string;
+		/** The key the Canvas answers to for this control, when it has one. */
+		"aria-keyshortcuts"?: string;
+		onClick?: React.MouseEventHandler<HTMLButtonElement>;
+		/** On a control that opens a menu (the Choice control): its state and target. */
+		"aria-expanded"?: boolean;
+		"aria-controls"?: string;
+	};
+	icon: React.ReactNode;
+	label: string;
+	/**
+	 * The popover Clover's own controls show on hover and focus: the name, and the key when
+	 * there is one. Render it inside your button, last, to keep it.
+	 */
+	tip: React.ReactNode;
+};
+/**
+ * Replacements for the controls over a Canvas. Each key is optional, so a consumer can
+ * override one control and leave the rest as they are. A replacement owns the whole
+ * button, not just the glyph, so it can change shape as well as appearance.
+ */
+export type ControlButtons = {
+	zoomIn?: React.ComponentType<ControlButtonProps>;
+	zoomOut?: React.ComponentType<ControlButtonProps>;
+	fullPage?: React.ComponentType<ControlButtonProps>;
+	rotateRight?: React.ComponentType<ControlButtonProps>;
+	rotateLeft?: React.ComponentType<ControlButtonProps>;
+	/** A Scene's: its models turned up, or down, about the horizontal axis. */
+	rotateUp?: React.ComponentType<ControlButtonProps>;
+	rotateDown?: React.ComponentType<ControlButtonProps>;
+	reset?: React.ComponentType<ControlButtonProps>;
+	choice?: React.ComponentType<ControlButtonProps>;
+};
+/** A painting body as `body` takes it: a web resource that may carry a `label`. */
+export interface LabeledIIIFExternalWebResource extends IIIFExternalWebResource {
+	label?: InternationalString;
+	region?: string;
+}
+/** Which controls to show. All are on by default, as in `Image`. */
+export interface CanvasControlsConfig {
+	zoom?: boolean;
+	fullPage?: boolean;
+	rotation?: boolean;
+	reset?: boolean;
+	/**
+	 * A control listing the `annotations` by their text; picking one zooms to it. Shown
+	 * only when some annotation can be drawn.
+	 */
+	annotations?: boolean;
+	/**
+	 * An `i` control that slides out the Canvases' `summary` and `metadata` as a caption.
+	 * Shown only when a Canvas has either.
+	 */
+	information?: boolean;
+}
+export interface CloverCanvasOptions {
+	/** Which painter to use. `auto` (default) tries WebGL2, then Canvas2D. */
+	backend?: BackendPreference;
+	/** Pointer, wheel and keyboard behavior. Wheel zoom is off by default. */
+	gestures?: Partial<GestureOptions>;
+	/** Largest zoom, in CSS pixels per image pixel. Default 1.1. */
+	maxZoomPixelRatio?: number;
+	/** Smallest zoom, as a fraction of the home zoom. Default 0.9. */
+	minZoomImageRatio?: number;
+	/** Seconds for an animation to close most of its distance. 0 disables easing. */
+	animationTime?: number;
+	/**
+	 * Milliseconds the controls and navigator stay after a mouse (or a pen that hovers)
+	 * stops moving, as the Player's `hideDelay`. Default 2000; `Infinity` keeps them once
+	 * shown. A finger, or a pen that does not hover, has no timer: a tap on the picture
+	 * shows them, and another hides them. Focus that no press brought holds them too.
+	 */
+	hideDelay?: number;
+	/** A time-based Canvas's video or sound. */
+	/**
+	 * An animation Canvas (painting annotations at `#t=` times, one per frame): play on
+	 * arrival, and loop at the end (the reader can turn looping off and on). Inside a `Root`,
+	 * `auto-advance` and `repeat` behaviors set them, and a Manifest's `auto-advance` moves
+	 * on when a non-looping animation ends (`onEnded`, as for video). Neither by default; a
+	 * reader asking for reduced motion is never autoplayed.
+	 */
+	animation?: {
+		autoplay?: boolean;
+		loop?: boolean;
+	};
+	/**
+	 * Credentials, headers and a custom `fetch` for every request the Canvas makes:
+	 * `info.json`, tiles, captions and HLS. A `<video>` or an image without CORS can only
+	 * send credentials. Inside a `Root`, the Root's `request` is used.
+	 */
+	request?: CloverRequest;
+}
+/**
+ * Imperative control over a mounted `Canvas`, handed to `onReady`. Coordinates are world
+ * units — the pixels of the first image — so `getBounds()` is directly an `xywh=` region.
+ */
+export interface CanvasHandle {
+	readonly backendKind: BackendKind;
+	/**
+	 * Whether the view is at home, fitted whole: false once the reader zooms, pans or turns
+	 * it, true again on `home()`. A resize keeps it, refitting home. Read it on `viewport`.
+	 */
+	readonly atHome: boolean;
+	fitBounds(bounds: Rect, immediate?: boolean): void;
+	/** Zoom to a rectangle in image `index`'s own coordinates, padded as `Image` pads. */
+	fitItemRect(index: number, rect: Rect, immediate?: boolean): void;
+	/** A rectangle in image `index`'s own coordinates, in world units. */
+	itemRectToWorld(index: number, rect: Rect): Rect | null;
+	getBounds(): Rect;
+	getHomeBounds(): Rect | null;
+	getCamera(): CameraState;
+	home(immediate?: boolean): void;
+	zoomBy(factor: number, at?: Point, animate?: boolean): void;
+	panBy(dx: number, dy: number, animate?: boolean): void;
+	/** Degrees, clockwise. */
+	setRotation(degrees: number, immediate?: boolean): void;
+	getRotation(): number;
+	rotateBy(degrees: number): void;
+	worldToScreenPoint(point: Point): Point;
+	screenToWorldPoint(point: Point): Point;
+	on(event: CanvasRendererEvent, listener: (detail?: unknown) => void): () => void;
+	/**
+	 * Zoom to an annotation's hotspot, as picking it does, and focus it. False while there
+	 * is no hotspot for that id (not among `annotations`, or not yet placed).
+	 */
+	zoomToAnnotation(id: string): boolean;
+	/**
+	 * Frame a rectangle in one shown Canvas's own coordinates (an `xywh=` region of it).
+	 * False while that Canvas is not laid out yet.
+	 */
+	fitCanvasRect(canvasId: string, rect: Rect, immediate?: boolean): boolean;
+	/**
+	 * The visible part of whichever shown Canvas fills most of the view, in its own
+	 * coordinates: what a content state or a share link records. Null before layout.
+	 */
+	getCanvasRegion(): {
+		canvasId: string;
+		rect: Rect;
+	} | null;
+}
+export interface CloverCanvasProps {
+	/**
+	 * Presentation 4 Canvases (or Timelines) to draw: one, or several shown together (a
+	 * spread). Each one's painting annotations are composed at their targets. Upgrade
+	 * Presentation 2 or 3 with `toPresentation4()` first. Inside a `Root`, leave this (and
+	 * `body` and `src`) out and the Canvas shows the Root's current view.
+	 */
+	canvases?: IIIFCanvas[];
+	/**
+	 * A Canvas to load and draw, on its own, outside any `Root`: a URL or an object, in any
+	 * Presentation version (upgraded as it loads), fetched with `options.request`. A
+	 * Manifest gives its first Canvas. Nothing is drawn until it arrives, or if it will
+	 * not load. Takes precedence over the Root's view, as `canvases` does.
+	 */
+	iiifContent?: string | Record<string, unknown>;
+	/** How to lay out several Canvases: in reading order along this direction. */
+	viewingDirection?: ViewingDirection;
+	/** IIIF painting bodies (Image resources). Takes precedence over `src`. */
+	body?: LabeledIIIFExternalWebResource | LabeledIIIFExternalWebResource[];
+	/** Plain image URLs — or, with `isTiledImage`, image service URIs. */
+	src?: string | string[];
+	/** Treat each `src` as a IIIF Image API service (its base URI or `info.json`). */
+	isTiledImage?: boolean;
+	/** Accessible name for the viewport. */
+	label?: InternationalString | string;
+	/**
+	 * What the view is part of, named under its title where a lone recording plays as a
+	 * player: the Manifest's label, by default, inside a `Root` or given `iiifContent`.
+	 */
+	partOf?: InternationalString | string;
+	/**
+	 * The language to read IIIF text in: labels, Choices, annotations. The reader's, by
+	 * default; inside a `Root`, the Root's.
+	 */
+	language?: string;
+	/** Stable id for this instance. A new id remounts the renderer. */
+	instanceId?: string;
+	className?: string;
+	options?: CloverCanvasOptions;
+	/**
+	 * Show an overview of the whole image with the visible region outlined; press or drag
+	 * in it to move there. Off by default; never shown for a Canvas of video or sound.
+	 */
+	navigator?: boolean;
+	/**
+	 * Show the control cluster (`true`, the default), none (`false`), or some. Without the
+	 * zoom and reset controls, one pointer can still zoom back out: at the largest zoom, a
+	 * click or a double tap goes home. With the click zooms off as well (`gestures`), a
+	 * pinch is the only zoom left on touch, so give the reader one of your own, through
+	 * the handle `onReady` passes (`home()`, `zoomBy(0.5)`) (WCAG 2.5.1).
+	 */
+	controls?: boolean | CanvasControlsConfig;
+	/** Replace any control with your own component — the `Viewer`'s `controlButtons`. */
+	controlButtons?: ControlButtons;
+	/**
+	 * Annotations to draw as hotspots, as `Image` takes them. Only rectangular (`xywh`)
+	 * targets are drawn; coordinates are the target image's own.
+	 */
+	annotations?: CanvasAnnotation[];
+	/**
+	 * The AnnotationPages (each annotation's `pageId`) whose annotations are hidden: none
+	 * of them is drawn, but the annotations menu still lists them under their page, with
+	 * its hide toggle, to show them again. Leave it out for the Canvas to keep its own.
+	 */
+	hiddenPages?: string[];
+	/**
+	 * AnnotationPages drawn (while not hidden) but never offered in the annotations menu,
+	 * as the Annotations list leaves them out: a search's hits, which Search lists, and a
+	 * still Canvas's OCR, which a search finds in. Leave it out for the Canvas to keep its
+	 * own OCR out.
+	 */
+	unlistedPages?: string[];
+	/** The reader hid AnnotationPages from the picture (`visible` false), or showed them. */
+	onPageVisibilityChange?: (pageIds: string[], visible: boolean) => void;
+	/** The hovered or focused annotation's id, or null when none is. */
+	onAnnotationActive?: (id: string | null) => void;
+	/**
+	 * The picked annotation, controlled. A new id is framed once its hotspot is placed;
+	 * `null` clears the pick. Leave it out for the Canvas to keep its own.
+	 */
+	selectedAnnotation?: string | null;
+	/**
+	 * Glide to a picked annotation, as the camera eases to anywhere else, rather than
+	 * framing it at once. Default `false`: an annotation picked on the Canvas, in a list
+	 * beside it or by a link is framed in one cut, once its view is drawn. A reader who
+	 * asks for reduced motion gets the cut either way.
+	 */
+	animateAnnotations?: boolean;
+	/** An annotation to highlight, as hovering it in a list beside the Canvas does. */
+	highlightedAnnotation?: string | null;
+	/**
+	 * A hotspot (or the annotations menu) picked an annotation; `null` when the reader let
+	 * it go, by a click or tap off it on the Canvas, or Escape.
+	 */
+	onAnnotationSelect?: (id: string | null) => void;
+	/**
+	 * A linking annotation's hotspot pressed (Cookbook 0022), leading to a Canvas or a
+	 * Manifest: show it. Inside a `Root`, or loading its own (`iiifContent`), the Canvas
+	 * shows it itself unless you take this; otherwise, without it, the hotspot is picked as
+	 * any other. A link to a web page is a link, and opens the page in a new tab.
+	 */
+	onAnnotationLink?: (link: AnnotationLink) => void;
+	/** Called once, when the first images are laid out and fitted. */
+	onReady?: (handle: CanvasHandle) => void;
+	/**
+	 * The id of the Manifest these Canvases are from. When it changes (another of a
+	 * Collection's members, say) the Canvas is cleared at once, so the last Manifest's
+	 * images never show beside the next one's while those load. Within one Manifest,
+	 * moving from Canvas to Canvas keeps the last one drawn until the next is ready, so a
+	 * page turn never flashes empty.
+	 */
+	manifestId?: string;
+	/** The visible world rectangle, at most once per frame while the camera moves. */
+	onViewportChange?: (bounds: Rect) => void;
+	/**
+	 * A time-based Canvas's media element once it exists, and `null` when it goes: for a
+	 * host's own transcript, chapters or `#t=` seeks. Sound plays through a `<video>` too.
+	 */
+	onMediaElement?: (element: HTMLVideoElement | null) => void;
+	/**
+	 * The reader chose a caption track in the Canvas's own Captions menu: the Manifest's
+	 * caption file (its `id`, the WebVTT's address, and the `language` of its cues), or
+	 * `null` for Off or a track the media carries itself. For a host's own transcript to
+	 * follow, as Clover's `Transcript` does.
+	 */
+	onCaptionChange?: (caption: {
+		id: string;
+		language?: string;
+	} | null) => void;
+	/**
+	 * Which of the Manifest's caption files to show while captions are on, by its `id`:
+	 * for a host's own transcript to lead the captions' language as well as follow it
+	 * (`onCaptionChange`). It changes the track shown, never whether one shows: Off stays
+	 * off. Inside a `Root` the Canvas takes it from the Root, which Clover's `Transcript`
+	 * sets.
+	 */
+	caption?: string | null;
+	/** Playback reached the end — a host's cue to move to the next Canvas. */
+	onEnded?: () => void;
+	/**
+	 * Chapters of the Canvas's video or sound: marked on the seek bar, listed in a menu, and
+	 * named beside the time. Inside a `Root`, they come from the Manifest's Ranges. `lang`
+	 * is the language a label is written in, set on it where it shows.
+	 */
+	chapters?: Array<{
+		/** Its own id (a Range's), by which `highlightedChapter` names it. */
+		id?: string;
+		label: string;
+		lang?: string;
+		start: number;
+		end?: number;
+	}>;
+	/** A chapter (by its `id`) to mark on the seek bar, as hovering it in a list does. */
+	highlightedChapter?: string | null;
+	/** The chapter under the pointer on the seek bar (its `id`), or null as it leaves. */
+	onChapterHighlight?: (id: string | null) => void;
+	/**
+	 * Show a Canvas's `placeholderContainer` first (the default). `false` opens the Canvas
+	 * straight away, as a host does when a link or content state points into it.
+	 */
+	placeholder?: boolean;
+	/** Rendered after the controls in the cluster: a host's own controls. */
+	children?: ReactNode;
+}
+export type BodyProps = Omit<CloverCanvasProps, "canvases" | "body" | "src" | "isTiledImage" | "viewingDirection"> & {
+	/** Props for the wrapping element, which gives the Body its size. */
+	style?: React.CSSProperties;
+	/** Renderers for this Body only; the Root's (`renderers` on `Root`) otherwise. */
+	renderers?: BodyRenderer[];
+};
+/**
+ * The current view of the Root, drawn by the part for its container: `Canvas` (images,
+ * video), `Timeline` (sound) or `Scene` (3D), as Presentation 4 names them; or by a
+ * renderer of your own that claims the view (by Canvas id, painting format or a test,
+ * from `renderers` here or on the `Root`), which goes first. Children become controls in
+ * the cluster, or are handed to the renderer.
+ *
+ * The Body needs a height to draw into. It is set inline, so it holds without the
+ * stylesheet, through `--clover-body-height` (default `60vh`): set that property to
+ * size it, `100%` to fill a sized parent.
+ *
+ * While the Root loads (the first Manifest, or the next one chosen) the Body is busy and
+ * shows Clover's loading mark, a line along its top edge, over what it still shows; it
+ * keeps its size and its background, so nothing moves.
+ */
+export declare function Body({ className, style, renderers, children, ...canvas }: BodyProps): React.JSX.Element;
+export interface LabelProps extends Omit<React.HTMLAttributes<HTMLElement>, "lang"> {
+	/** Whose label: the Manifest's (the default), or the current Canvas's. */
+	of?: "manifest" | "canvas";
+	/** A label to show instead of the Root's. Outside a `Root`, the label to show. */
+	label?: LanguageMapLike;
+	/** The element to render, such as `h1`. Default `span`. */
+	as?: React.ElementType;
+}
+/**
+ * A label, in the Root's language and marked with the language it is in: the Manifest's,
+ * the Canvas's, or inside a `Provider` the provider's name. Renders nothing while there is
+ * none.
+ */
+export declare const Label: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLElement>>;
+/** What the pieces step through inside a Root: its views, or its Collection's members. */
+export type StepsOf = "views" | "members";
+export type ButtonProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "type" | "children">;
+export interface StepProps extends ButtonProps {
+	/** What it steps through: the Root's views (default), or its Collection's members. */
+	of?: StepsOf;
+}
+/** Go to the previous item. `aria-disabled` on the first. */
+export declare const Previous: React.ForwardRefExoticComponent<StepProps & React.RefAttributes<HTMLButtonElement>>;
+/** Go to the next item. `aria-disabled` on the last. */
+export declare const Next: React.ForwardRefExoticComponent<StepProps & React.RefAttributes<HTMLButtonElement>>;
+export interface PositionProps extends React.HTMLAttributes<HTMLElement> {
+	/** What it counts: the Root's views (default), or its Collection's members. */
+	of?: StepsOf;
+	as?: React.ElementType;
+}
+/**
+ * Where the reader is, counted in items: "2 / 5", the same in every language. Assistive
+ * technology reads the sentence instead, "Item 2 of 5" in the reader's language, which a
+ * bare slash would leave to guesswork.
+ */
+export declare const Position: React.ForwardRefExoticComponent<PositionProps & React.RefAttributes<HTMLElement>>;
+/**
+ * What `Items` shows: light models of a Manifest's views or a Collection's members, never
+ * the resources themselves, so a long sequence costs a few fields per item.
+ *
+ * Memoized on the resource object, as the selectors are.
+ */
+export interface ItemPart {
+	id: string;
+	type: string;
+	label?: LanguageMapLike;
+	/** The resource, for a thumbnail and for `renderItem`. */
+	resource: unknown;
+	/** Seconds, for video and sound. */
+	duration?: number;
+	/** What it mostly paints: `Image`, `Video`, `Audio` (`Sound` in Presentation 3) or `Model`. */
+	media?: string;
+}
+export interface ItemModel {
+	/** The first Canvas of a view, or a member's id. What selecting it goes to. */
+	id: string;
+	/** A Canvas view: one Canvas, or a spread. A member: itself. */
+	parts: ItemPart[];
+	label?: LanguageMapLike;
+	summary?: LanguageMapLike;
+	/** Where a link to a member goes: its `homepage`, else its id. */
+	href?: string;
+}
+/**
+ * A scrolling row of thumbnails (`slider`), a column, a wrapping grid, or one item at a
+ * time (`pager`: Previous, Position and Next).
+ */
+export type ItemsLayout = "slider" | "list" | "grid" | "pager";
+export interface ItemsProps extends Omit<React.HTMLAttributes<HTMLElement>, "onSelect" | "children"> {
+	/**
+	 * A scrolling row (the default), a column, a wrapping grid, or `pager`: Previous,
+	 * Position and Next, stepping one item at a time, with no thumbnails.
+	 */
+	layout?: ItemsLayout;
+	/**
+	 * Inside a `Root`: the Manifest's views (default), or the members of the Collection it
+	 * belongs to, choosing one to show.
+	 */
+	of?: "views" | "members";
+	/**
+	 * Standalone: a Collection (its members), a Manifest (its views) or a URL to one. Inside
+	 * a `Root`, leave it out to list the Root's views.
+	 */
+	iiifContent?: IIIFContent;
+	/** Standalone: a list of IIIF resources (Manifests, Collections, Canvases) as they are. */
+	items?: unknown[];
+	/**
+	 * `id` selects: a listbox whose options go to a view (in a `Root`). `homepage` leaves: a
+	 * list of links to each item's `homepage`. Defaults to `id` for views and `homepage`
+	 * for a Collection's members or a list.
+	 */
+	navigation?: "id" | "homepage";
+	/**
+	 * An item was chosen, with the click's or the key's own event. For a link, call
+	 * `event.preventDefault()` to stay on the page and handle it yourself.
+	 */
+	onSelect?: (item: ItemModel, event: React.SyntheticEvent) => void;
+	/** Standalone: show the resource's label, summary and homepage link. Default true. */
+	header?: boolean;
+	/**
+	 * Standalone: the level of the header's title, to fit the outline of the page around
+	 * it (a slider under an `h2` takes 3). Default 2.
+	 */
+	headingLevel?: number;
+	/** Pixels requested for each thumbnail's longer side. Default 200. */
+	thumbnailSize?: number;
+	/** Standalone: credentials, headers and `fetch`. In a `Root`, the Root's are used. */
+	request?: CloverRequest;
+	/** Standalone: the language to read IIIF text in. */
+	language?: string;
+	/** Replace an item's figure with your own. */
+	renderItem?: (item: ItemModel, state: {
+		selected: boolean;
+	}) => React.ReactNode;
+	as?: React.ElementType;
+}
+/**
+ * Thumbnails of a sequence: the views of a Manifest, or the members of a Collection.
+ * The successor to 3.x's `Slider` and the Viewer's thumbnail rail.
+ *
+ * - **Inside a `Root`**, a single-select listbox of the Root's views (a spread is one
+ *   item). One tab stop; arrows move, Enter or Space selects; the selection follows the
+ *   pager and stays in view.
+ * - **Standalone**, a list of links to each item's `homepage` — a Collection slider.
+ *
+ * The slider is the browser's own scrolling with CSS snap points: wheel, trackpad,
+ * touch and keyboard all work, and a mouse can drag it.
+ */
+export declare const Items: React.ForwardRefExoticComponent<ItemsProps & React.RefAttributes<HTMLElement>>;
+export interface StatusProps {
+	className?: string;
+	/**
+	 * Shown while loading. Default: Clover's loading mark (three pulsing dots), announced
+	 * as a translated "Loading…". `false` shows nothing and only announces it, for a
+	 * layout with a `Body`, which shows its own loading, so nothing moves.
+	 */
+	loading?: React.ReactNode;
+	/** Shown when loading failed. Default: a translated message and the error's own. */
+	error?: (error: Error) => React.ReactNode;
+}
+/**
+ * Loading and error states, announced: a `role="status"` region while loading and
+ * `role="alert"` on failure. The region stays for the Status's whole life, empty and out
+ * of sight once the content is ready, and only its words change: many screen readers
+ * announce words put into a region already there, but not a region inserted with them
+ * (WCAG 4.1.3).
+ */
+export declare function Status({ className, loading, error: renderError, }: StatusProps): React.JSX.Element;
+/** Whose property a part reads: the Root's Manifest, or the Canvas in view. */
+export type Of = "manifest" | "canvas";
+export type Json = Record<string, any>;
+/** The provider a part is drawn for, inside `Provider`; null outside one. */
+export declare const useProvider: () => Json | null;
+export interface PartProps<Value> extends Omit<React.HTMLAttributes<HTMLElement>, "lang"> {
+	/** Whose property: the Manifest's (default) or the current Canvas's. */
+	of?: Of;
+	/** The element to render. */
+	as?: React.ElementType;
+	/** Show this value instead of the Root's. */
+	value?: Value;
+}
+/**
+ * `summary`, as sanitized HTML, cut to five lines, with "Read more" under it when it runs
+ * longer (`ReadMore`). Every summary Clover shows is this part: About's, a Collection's, a
+ * Canvas's in its information box.
+ *
+ * The number of lines is a CSS custom property, `--clover-summary-lines` (default `5`),
+ * set on `.clover-summary` or on any element around it; `none` shows it whole.
+ *
+ * ```css
+ * .my-layout .clover-summary {
+ *   --clover-summary-lines: 3;
+ * }
+ * ```
+ */
+export declare function Summary({ of, as, value, className, ...rest }: PartProps<LanguageMapLike>): React.JSX.Element | null;
+/**
+ * Any IIIF language map — an annotation's text, a label you hold — in the reader's
+ * language, read strictly by `format` (`readAs`): `text/html` as sanitized HTML,
+ * `text/plain` as written, and none by IIIF's rule (HTML only from `<` to `>`).
+ * `format="text/markdown"` reads Markdown, its lists as lists and its headings as
+ * headings, the first at `headingLevel` (default 3).
+ */
+export declare function Value({ value, format, headingLevel, as, className, ...rest }: Omit<PartProps<LanguageMapLike>, "of"> & {
+	format?: string;
+	/** With Markdown, the level of its first heading; the rest follow under it. Default 3. */
+	headingLevel?: number;
+}): React.JSX.Element;
+/** `metadata`, as a description list of label and value pairs. */
+export declare function Metadata({ of, value, className, renderValue, ...rest }: Omit<PartProps<MetadataItem[]>, "as"> & {
+	/** Your own rendering of a value; Clover's when it returns undefined. */
+	renderValue?: (item: MetadataItem) => React.ReactNode;
+}): React.JSX.Element;
+/** `requiredStatement`: the attribution that must be shown, as a label and value. */
+export declare function RequiredStatement({ of, value, className, ...rest }: Omit<PartProps<MetadataItem>, "as">): React.JSX.Element;
+/** `rights`: a link to the license or rights statement. */
+export declare function Rights({ of, value, className, ...rest }: Omit<PartProps<string>, "as">): React.JSX.Element | null;
+/** The resource's `id`: a link to its IIIF JSON. */
+export declare function Id({ of, value, className, ...rest }: Omit<PartProps<string>, "as">): React.JSX.Element | null;
+export interface LinkedResource {
+	id?: string;
+	label?: LanguageMapLike;
+	format?: string;
+	type?: string;
+}
+export type LinksProps = Omit<PartProps<LinkedResource[]>, "as">;
+/** `homepage`: the resource's own web page. */
+export declare const Homepage: ({ className, ...props }: LinksProps) => React.JSX.Element;
+/** `rendering`: alternate formats, such as a PDF of the whole object. */
+export declare const Rendering: ({ className, ...props }: LinksProps) => React.JSX.Element;
+/** `seeAlso`: machine-readable descriptions elsewhere. */
+export declare const SeeAlso: ({ className, ...props }: LinksProps) => React.JSX.Element;
+/** `partOf`: the Collections the resource belongs to. */
+export declare const PartOf: ({ className, ...props }: LinksProps) => React.JSX.Element;
+/**
+ * The resource's `thumbnail` (or, for a Canvas, its first image), at `size` pixels on
+ * the longer side. Its `alt` is the resource's label.
+ */
+export declare function Thumbnail({ of, value, size, className, ...rest }: Omit<React.ImgHTMLAttributes<HTMLImageElement>, "src"> & {
+	of?: Of;
+	/** A resource to picture instead of the Root's: a Manifest, Canvas or Collection. */
+	value?: unknown;
+	size?: number;
+}): React.JSX.Element | null;
+export interface ProviderProps extends Omit<React.HTMLAttributes<HTMLUListElement>, "lang" | "children"> {
+	/** Whose providers: the Manifest's (default) or the current Canvas's. */
+	of?: Of;
+	/** Providers to show instead of the Root's: an Agent, or a list of them. */
+	value?: unknown;
+	/** Link each provider to its homepage, when it has one. Default `true`. */
+	link?: boolean;
+	/**
+	 * What to draw for each provider, inside its link: `Logo`, `Label` and the link parts,
+	 * which read that provider, and anything of your own (`useProvider`). Default: its logo
+	 * and its name.
+	 */
+	children?: React.ReactNode;
+}
+/**
+ * `provider`: who provided the resource, each as a list item, its logo and its name
+ * linked to its homepage. A compound part: what it holds is drawn once for each provider,
+ * so `<Provider><Logo /></Provider>` shows each one's logo alone, linked, named for
+ * assistive technology by the provider's name. Renders nothing without a provider.
+ */
+export declare function Provider({ of, value, link, children, className, ...rest }: ProviderProps): React.JSX.Element | null;
+export interface LogoProps extends Omit<React.ImgHTMLAttributes<HTMLImageElement>, "src"> {
+	/** Whose providers' logos: the Manifest's (default) or the current Canvas's. */
+	of?: Of;
+	/** Logos to show instead: an image (`{ id, width?, height? }`), an Agent, or a list. */
+	value?: unknown;
+}
+/**
+ * `logo`: a provider's logo, the first it gives, at `--clover-logo-height`. Inside a
+ * `Provider`, the logo of the provider it is drawn for; elsewhere, each of the resource's
+ * providers' in turn. Its `alt` is the provider's name (else its homepage's, else "Logo"),
+ * unless one is given; `alt=""` where its name is written beside it. Renders nothing
+ * without a logo, and nothing for a logo that fails to load, never the browser's broken
+ * picture.
+ */
+export declare function Logo({ of, value, alt, className, ...rest }: LogoProps): React.JSX.Element | null;
+/** How the sections are laid out. */
+export type SectionsLayout = "tabs" | "accordion";
+export interface TabProps {
+	/** Identifies the tab, for `value` / `defaultValue` on the panel. */
+	value: string;
+	/** What the tab says. */
+	label: React.ReactNode;
+	children?: React.ReactNode;
+}
+/**
+ * One tab of an `Panel`: its label and what it shows. Anything can go in a
+ * tab — `Clover.About`, your own component reading the Root through hooks — which is how
+ * 3.x's information panel plugins are written now.
+ *
+ * It renders nothing itself: `Panel` reads its props and renders the tab.
+ */
+export declare const Tab: React.FC<TabProps>;
+/** How an information panel lays out its sections. */
+export type PanelLayout = SectionsLayout;
+export interface PanelProps extends Omit<React.HTMLAttributes<HTMLElement>, "defaultValue"> {
+	/**
+	 * `tabs` (the default): a row of tabs, one section shown at a time. `accordion`: the
+	 * sections stacked as boxes, each opened by its heading, one always open.
+	 */
+	layout?: PanelLayout;
+	/** The tab shown, controlled (`tabs`). */
+	value?: string;
+	/**
+	 * The tab shown first (`tabs`), or the box open to start with (`accordion`). Default:
+	 * the first.
+	 */
+	defaultValue?: string;
+	/** Called with the tab chosen, or the box opened. */
+	onValueChange?: (value: string) => void;
+	/**
+	 * The panel can be closed: a close button appears in it. Closing from inside the panel
+	 * hands focus back to the control that opens it (whatever has `aria-controls` naming the
+	 * panel or an element around it), so focus is never left on something hidden.
+	 */
+	onClose?: () => void;
+	/**
+	 * The panel floats over the page: Escape inside it closes it too, and its close button
+	 * sits at its inner edge (the start, for a panel over the end of the page) rather than
+	 * the end of its first row. A panel docked beside the Body needs neither, and is
+	 * better without `onClose` at all: the toggle that opens it closes it.
+	 */
+	closeOnEscape?: boolean;
+	/**
+	 * The level of the sections' headings (`accordion`), one under the heading the panel
+	 * belongs to. The default sections' own headings are a level below them; tabs are not
+	 * headings, so there they start at this level. Default 3.
+	 */
+	headingLevel?: number;
+	/** The element to render. Default `aside`. */
+	as?: React.ElementType;
+	/** Whether the default About lists the downloads (`About`'s `download`). Default `true`. */
+	download?: boolean;
+	/**
+	 * `Clover.Tab`s. Without any, the panel has the tabs Clover has data for: About,
+	 * Contents when the Manifest has Ranges, Search when it has a Content Search service, a
+	 * Map when it (or a Canvas or annotation) has navPlace or a georeference,
+	 * a Transcript when the view's media has captions or a plain-text transcript, and
+	 * Annotations when there are any.
+	 */
+	children?: React.ReactNode;
+}
+/**
+ * Information about the Root's resource, in sections: tabs by default, or stacked boxes
+ * with `layout="accordion"`. Its default sections are the ones Clover has data for; give
+ * it `Clover.Tab` children to choose them, in order, including your own (a `Tab` is a
+ * section in either layout):
+ *
+ * ```jsx
+ * <Clover.Panel>
+ *   <Clover.Tab value="about" label="About"><Clover.About /></Clover.Tab>
+ *   <Clover.Tab value="notes" label="Notes"><MyNotes /></Clover.Tab>
+ * </Clover.Panel>
+ * ```
+ */
+export declare const Panel: React.ForwardRefExoticComponent<PanelProps & React.RefAttributes<HTMLElement>>;
+export interface AboutProps extends React.HTMLAttributes<HTMLElement> {
+	/** Also show the current Canvas's summary, for Manifests that describe each image. */
+	canvasSummary?: boolean;
+	/**
+	 * The heading level for each section's title. Default 3. Past 6 a title is not a
+	 * heading, and names its section instead (`ui/heading.ts`).
+	 */
+	headingLevel?: number;
+	/** List the downloads, Download's links, in a section of their own. Default `true`. */
+	download?: boolean;
+	/**
+	 * The Manifest's thumbnail first, small, at its own shape, floated at the end of the
+	 * label's lines, over the summary (Mat, 2026-10-26: "float it right to the side of the
+	 * label. and above summary"). Named by the label where there is none beside it, and
+	 * decorative where there is. Default `true`.
+	 */
+	thumbnail?: boolean;
+	/**
+	 * The resource's label again, as a heading at `headingLevel`, over what About says of
+	 * it (Mat, 2026-10-26: "repeat label as a heading"). Default `true`.
+	 */
+	label?: boolean;
+}
+/**
+ * Everything the Manifest says about itself, in the order 3.x's About tab shows it:
+ * what a Canvas shown on its own is part of, then summary, metadata, required statement,
+ * provider (its logo and name, linked to its homepage), rights, homepage, see also,
+ * downloads, and the Manifest's own address, its thumbnail over them all (`thumbnail`).
+ * Each part renders only if the Manifest has
+ * it. The downloads are Download's: the `rendering` of the page in view ("This page")
+ * and of the Manifest ("All pages").
+ */
+export declare function About({ canvasSummary, headingLevel, download, thumbnail, label, className, ...rest }: AboutProps): React.JSX.Element | null;
+export interface AnnotationsProps extends React.HTMLAttributes<HTMLElement> {
+	/**
+	 * Every annotation in the Manifest (default), as the Viewer's panel lists them: by
+	 * layer (AnnotationPages that share a label, or have none), then by Canvas, under each
+	 * Canvas's label, the ones in view marked current and kept in sight as the reader
+	 * moves. Or `"view"`: the view's alone, by set.
+	 */
+	scope?: "view" | "all";
+	/** Your own rendering of an annotation's content. */
+	renderEntry?: (entry: AnnotationEntry) => React.ReactNode;
+	/**
+	 * The heading level for each set's title. Headings in an annotation's Markdown sit a
+	 * level below it, or at it in a set with no title. Default 3.
+	 */
+	headingLevel?: number;
+	as?: React.ElementType;
+}
+/**
+ * The annotations of the Root's resource — comments, tags, transcriptions — grouped by
+ * set, as a list to read and to point with.
+ *
+ * - Each entry shows its content (IIIF's limited HTML, sanitized; an image body as an
+ *   image). Pressing it frames the annotation on the Canvas, going to its Canvas first if
+ *   need be. For the keyboard, a button inside it does the same, out of sight, its focus
+ *   drawn around the entry.
+ * - Hovering or focusing an entry highlights its hotspot, and hovering a hotspot
+ *   highlights its entry: one highlight, shared through the Root, with no timers.
+ * - Each set is headed by its AnnotationPage's own label, when it has one, and at the
+ *   header's end a toggle that hides its annotations from the Canvas (`HideToggle`: an
+ *   eye, "Hide" and the page's label, or "Hide annotations" for a page without one).
+ *   Pointed at or focused, it lights every entry it hides.
+ * - Where the same words come as separate annotations, one per language (a transcription
+ *   and its translation), the set's header offers their languages by code ("AR", "EN"),
+ *   and lists one at a time: the Root's `language` to start, else the reader's
+ *   (`LanguageChoice`). Annotations in no language show whichever is chosen.
+ */
+export declare const Annotations: React.ForwardRefExoticComponent<AnnotationsProps & React.RefAttributes<HTMLElement>>;
+export interface TranscriptProps extends React.HTMLAttributes<HTMLElement> {
+	as?: React.ElementType;
+	/** Keep the current cue in view as it plays. Default true. */
+	follow?: boolean;
+	/**
+	 * A field over the captions' cues to find words in, and steps through the cues that
+	 * have them, as Search steps through hits. Default true; captions only.
+	 */
+	find?: boolean;
+	/**
+	 * The find field held in view as the cues scroll under it: at the top of the box that
+	 * scrolls them, or, in a Panel's accordion, under the stuck headings, as Search's is.
+	 * Default `false`.
+	 */
+	sticky?: boolean;
+	/**
+	 * The find field's size, as Search's: `large` (the default), or `small`, a tad smaller,
+	 * for a narrow column, as the templates' Panels take it.
+	 */
+	size?: "large" | "small";
+}
+/**
+ * The words of the video or sound in view. From its WebVTT captions: one entry per cue,
+ * the current one marked as it plays, and a press on any entry seeking there. From a
+ * transcript as plain text (Cookbook 0017's `rendering`, 0253's `provides: transcript`):
+ * its paragraphs, untimed, in the file's language. The captions come first.
+ *
+ * Playback re-renders the transcript only when the current cue changes, and writes nothing
+ * to the Root's store. A caption file is the one the Canvas loads for its captions,
+ * fetched once.
+ *
+ * With several caption files (one per language), a row of their language codes ("EN",
+ * "IT") picks one: native radios, each named by its code and its file's label, in that
+ * label's language. In an information panel's accordion the row sits beside the
+ * Transcript's heading (`useSectionActions`), where it is not lost in the cues; elsewhere
+ * it is over them.
+ */
+export declare const Transcript: React.ForwardRefExoticComponent<TranscriptProps & React.RefAttributes<HTMLElement>>;
+export interface ContentsProps extends React.HTMLAttributes<HTMLElement> {
+	as?: React.ElementType;
+}
+/**
+ * The Manifest's table of contents, from its Ranges: chapters of a book, acts of an opera,
+ * nested as they nest. The entry the reader is in is marked, following playback through a
+ * time-based Canvas. Choosing an entry goes to its Canvas, and to its region or its moment.
+ * Hovering or focusing one marks its chapter on the Canvas's seek bar, and the chapter
+ * under the pointer there marks its entry here: one highlight, through the Root
+ * (`clover.chapter`), as the annotations share theirs.
+ */
+export declare const Contents: React.ForwardRefExoticComponent<ContentsProps & React.RefAttributes<HTMLElement>>;
+export interface DownloadProps extends Omit<React.HTMLAttributes<HTMLElement>, "children"> {
+	/**
+	 * The level of its groups' titles ("This page", "All pages"), a level under the
+	 * heading it sits beneath. Default 3.
+	 */
+	headingLevel?: number;
+}
+/**
+ * Downloads, as 3.x's Viewer offers them: the `rendering` of the Canvases in view ("This
+ * page") and of the Manifest ("All pages") — a PDF, a text, a high-resolution file —
+ * each a link, as Homepage lists a resource's pages (Mat, 2026-10-21: links, not a
+ * button that opens them). Renders nothing when there is nothing to download.
+ */
+export declare function Download({ className, headingLevel, ...rest }: DownloadProps): React.JSX.Element | null;
+/** A length: pixels as a number, or a CSS length in `px`, `rem` or `%` of the split. */
+export type SplitLength = number | string;
+export type SplitProps = React.HTMLAttributes<HTMLElement> & {
+	as?: React.ElementType;
+	/**
+	 * Remember the sizes the reader drags to, in `localStorage` under this key, so the
+	 * same layout opens at them next time.
+	 */
+	storageKey?: string;
+};
+/**
+ * Panes side by side, divided by handles the reader drags (or moves by keyboard) to share
+ * the width between them. One pane beside each handle is given a `size`; the other takes
+ * what is left. Not tied to any part: split the Body from the information panel, or
+ * anything from anything.
+ *
+ * ```jsx
+ * <Clover.Split>
+ *   <Clover.SplitPane min="16rem"><Clover.Body /></Clover.SplitPane>
+ *   <Clover.SplitHandle />
+ *   <Clover.SplitPane size="24rem" min="14rem"><Clover.Panel /></Clover.SplitPane>
+ * </Clover.Split>
+ * ```
+ *
+ * Without the stylesheet the panes still sit side by side (that much is inline); the
+ * sizes, the bar and its grip are the stylesheet's.
+ */
+export declare const Split: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLElement> & {
+	as?: React.ElementType;
+	/**
+	 * Remember the sizes the reader drags to, in `localStorage` under this key, so the
+	 * same layout opens at them next time.
+	 */
+	storageKey?: string;
+} & React.RefAttributes<HTMLElement>>;
+export type SplitPaneProps = React.HTMLAttributes<HTMLElement> & {
+	as?: React.ElementType;
+	/** Its width to start with. A pane without one takes the width that is left. */
+	size?: SplitLength;
+	/** The narrowest it may be, beside the others and under a handle. */
+	min?: SplitLength;
+	/** The widest a handle may make it. */
+	max?: SplitLength;
+	/**
+	 * The name its size is remembered under (with the Split's `storageKey`). Default: its
+	 * place among the Split's panes.
+	 */
+	name?: string;
+};
+/** One side of a `Split`. */
+export declare const SplitPane: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLElement> & {
+	as?: React.ElementType;
+	/** Its width to start with. A pane without one takes the width that is left. */
+	size?: SplitLength;
+	/** The narrowest it may be, beside the others and under a handle. */
+	min?: SplitLength;
+	/** The widest a handle may make it. */
+	max?: SplitLength;
+	/**
+	 * The name its size is remembered under (with the Split's `storageKey`). Default: its
+	 * place among the Split's panes.
+	 */
+	name?: string;
+} & React.RefAttributes<HTMLElement>>;
+export type SplitHandleProps = React.HTMLAttributes<HTMLDivElement>;
+/**
+ * The bar between two panes, with a grip at its middle. Drag it. Or click or tap it: each
+ * click steps the pane on to its next width, from its narrowest to its own size to its
+ * widest and around again, so one pointer resizes it without a drag (WCAG 2.5.7). A double
+ * click steps it once. Or focus it and use the arrow keys (Shift for bigger steps, Home
+ * and End for the limits). It is a focusable `separator` carrying the sized pane's share
+ * of the width, and names itself in a popover on hover and focus.
+ */
+export declare const SplitHandle: React.ForwardRefExoticComponent<SplitHandleProps & React.RefAttributes<HTMLDivElement>>;
+export interface SearchProps extends React.HTMLAttributes<HTMLElement> {
+	/** The heading level of each Canvas's group of hits. Default 3. */
+	headingLevel?: number;
+	/**
+	 * The field held in view as the hits scroll under it: at the top of the box that
+	 * scrolls them, or, in a Panel's accordion, under the stuck headings. Default `false`.
+	 */
+	sticky?: boolean;
+	/**
+	 * The field's size: `large` (the default), its submit a round control's; or `small`,
+	 * a tad smaller, for a narrow column. Default `"large"`.
+	 */
+	size?: "large" | "small";
+	/** The element to render. Default `div`. */
+	as?: React.ElementType;
+}
+export declare const Search: React.ForwardRefExoticComponent<SearchProps & React.RefAttributes<HTMLElement>>;
+/** Ask the service, following further pages, and read the hits. */
+export declare function search(service: SearchService, query: string, { request, signal }?: {
+	request?: CloverRequest;
+	signal?: AbortSignal;
+}): Promise<SearchResults>;
+/** Serve MapLibre's worker from `url` for every map Clover draws (a Viewer's Map tab included). */
+export declare function setMapWorkerUrl(url: string | undefined): void;
+export interface CollectionProps extends React.HTMLAttributes<HTMLElement> {
+	/**
+	 * The level of its headings: the Collection's label, Homepage and its address. Default
+	 * 3. Past 6 each is not a heading, and names what it heads instead (`ui/heading.ts`).
+	 */
+	headingLevel?: number;
+}
+/**
+ * The Collection the Manifest was reached through, or else the first it is `partOf`, as
+ * About describes a Manifest: its label and summary, its members as a list (each opening
+ * its Manifest in the Root, `Items of="members"`), then its homepage and its own address.
+ * The `Panel`'s Collection section is this part.
+ *
+ * A `partOf` Collection is fetched only when the part first shows (the panel mounts a
+ * section's content then), never ahead of the reader; until it arrives, what the
+ * Manifest's `partOf` says of it is shown. Renders nothing when there is no Collection.
+ */
+export declare const Collection: React.ForwardRefExoticComponent<CollectionProps & React.RefAttributes<HTMLDivElement>>;
+export interface CollectionSelectProps extends Omit<React.HTMLAttributes<HTMLElement>, "onChange"> {
+	/** Called with the member chosen, before Clover moves there. */
+	onChange?: (id: string) => void;
+}
+/**
+ * A native `<select>` of the Collection's members, labeled by the Collection: choosing a
+ * Manifest shows it, choosing a nested Collection enters it. Renders nothing outside a
+ * Collection, or for a Collection of one.
+ *
+ * Each choice loads a whole Manifest, so a keyboard only moves through the members, and
+ * Enter makes the choice (WCAG 3.2.2). Escape, or leaving the menu, takes the step back:
+ * loaded once focus had moved on, a Manifest could take away the control focus moved to
+ * (WCAG 2.4.3). A choice from the menu's own list (a pointer, a phone's picker, a list
+ * opened with Alt+↓ or on macOS) is made at once.
+ */
+export declare const CollectionSelect: React.ForwardRefExoticComponent<CollectionSelectProps & React.RefAttributes<HTMLElement>>;
+export interface PanelToggleProps {
+	/** Whether the panel is showing. */
+	open: boolean;
+	onOpenChange: (open: boolean) => void;
+	/** The panel's `id`, for `aria-controls`. */
+	controls?: string;
+}
+/**
+ * A button that shows and hides an `Panel`. It is styled as a Canvas control,
+ * so it sits in the cluster when given to `Clover.Body` as a child:
+ *
+ * ```jsx
+ * <Clover.Body>
+ *   <Clover.PanelToggle open={open} onOpenChange={setOpen} controls="panel" />
+ * </Clover.Body>
+ * <Clover.Panel id="panel" hidden={!open} />
+ * ```
+ */
+export declare function PanelToggle({ open, onOpenChange, controls, }: PanelToggleProps): React.JSX.Element;
+/**
+ * EXPERIMENTAL. Clover's own 2D renderer for images, video and sound, drawn with WebGL2
+ * and falling back to Canvas2D.
+ *
+ * - **Inside a `Root`**, given no `canvases`, `body` or `src`, it shows the Root's current
+ *   view and reports back to it: a deep link's region or time, the media element, the end
+ *   of playback for auto-advance.
+ * - **Standalone** (or given something to draw), it draws exactly what it is handed and
+ *   knows nothing of the Manifest around it; given `iiifContent`, it loads that Canvas
+ *   itself.
+ */
+export declare const Canvas: React.FC<CloverCanvasProps>;
+export type TimelineProps = Omit<CloverCanvasProps, "canvases" | "body" | "src" | "isTiledImage" | "viewingDirection" | "navigator" | "onViewportChange" | "onReady" | "animateAnnotations"> & {
+	/**
+	 * A Presentation 4 Timeline to play: its sound, with what it carries (captions, a
+	 * transcript, annotations on its time, an accompanying or placeholder Canvas).
+	 * Upgrade older resources with `toPresentation4()`; a Presentation 3 Canvas of sound
+	 * alone upgrades to one. Inside a `Root`, leave it out to play the Root's view.
+	 */
+	timeline?: IIIFCanvas;
+};
+/**
+ * A IIIF Presentation 4 Timeline, played: sound, which has a duration and
+ * no picture. It is drawn on Canvas's Body, with Canvas's transport, captions, chapters
+ * and annotations on its time, and shows the Timeline's accompanying Canvas (or its
+ * placeholder) while it plays, as the Viewer has shown sound. It draws on a surface of its
+ * own (`playerSurface`), not Canvas's image renderer, which it never loads.
+ *
+ * - **Inside a `Root`**, given nothing to play, it plays the Root's view when that is a
+ *   Timeline, and draws nothing otherwise. `Body` draws a Timeline view with it.
+ * - **Standalone**, it plays the `timeline` it is handed; given `iiifContent`, it loads a
+ *   Timeline itself (a Manifest gives its first).
+ */
+export declare function Timeline({ timeline, className, ...props }: TimelineProps): React.JSX.Element | null;
+/** The parts of a Presentation 4 Scene this module reads. */
+export interface IIIFScene {
+	id: string;
+	type?: string;
+	label?: unknown;
+	summary?: unknown;
+	metadata?: Array<{
+		label?: unknown;
+		value?: unknown;
+	}>;
+	backgroundColor?: string | null;
+	items?: Array<{
+		items?: Array<Record<string, any>>;
+	}>;
+}
+/** Which of the Scene's controls to show. All are on by default. */
+export interface SceneControlsConfig {
+	zoom?: boolean;
+	fullPage?: boolean;
+	rotation?: boolean;
+	reset?: boolean;
+	/** An `i` control that slides out the Scene's `summary` and `metadata`. */
+	information?: boolean;
+}
+export interface SceneProps {
+	/**
+	 * A Presentation 4 Scene to draw: the models it paints, where it places them. Upgrade
+	 * older resources with `toPresentation4()`. Inside a `Root`, leave it out to draw the
+	 * Root's view.
+	 */
+	scene?: IIIFScene;
+	/**
+	 * A Scene to load and draw, on its own, outside any `Root`: a URL or an object, in any
+	 * Presentation version, fetched with `options.request`. A Manifest gives its first
+	 * Scene.
+	 */
+	iiifContent?: string | Record<string, unknown>;
+	/** The view's accessible name: the Scene's own label by default. */
+	label?: unknown;
+	/** The language to read IIIF text in. The reader's, by default; inside a `Root`, the Root's. */
+	language?: string;
+	className?: string;
+	/** All of Clover's controls (`true`, the default), none (`false`), or all but those set `false`. */
+	controls?: boolean | SceneControlsConfig;
+	/** Replace any control with your own component, as `Canvas` takes them. */
+	controlButtons?: ControlButtons;
+	options?: {
+		/** Credentials and headers for the Scene and its models. Inside a `Root`, the Root's. */
+		request?: CloverRequest;
+		/** Milliseconds the controls stay after a mouse stops moving, as `Canvas`'s. */
+		hideDelay?: number;
+	};
+	/**
+	 * The Manifest the Scene is from: when it changes, the last one's models go at once. A
+	 * `Root` sets it.
+	 */
+	manifestId?: string;
+	/**
+	 * What draws the models: Clover's own WebGL2 renderer (`"clover"`, the default), or
+	 * three.js (`"three"`), once the page registers it (`registerThreeEngine`, from
+	 * `@nulib/clover/three`), for glTF's material extensions, skins and morph targets at
+	 * rest, and sparse accessors, which Clover's does not draw yet.
+	 */
+	engine?: "clover" | "three";
+	/** Rendered after the controls in the cluster: a host's own controls. */
+	children?: React.ReactNode;
+}
+/**
+ * A IIIF Presentation 4 Scene, drawn in 3D: the glTF models it paints, each
+ * where the Scene places it, lit as a neutral room lights them and framed by a default
+ * camera, which the reader turns and zooms by pointer, key or control. Its drawing, Clover's
+ * own WebGL2 glTF renderer (or three.js, `engine="three"`, once the page registers it from
+ * `@nulib/clover/three`), loads only when a Scene first comes near the window.
+ *
+ * - **Inside a `Root`**, given nothing to draw, it draws the Root's view when that is a
+ *   Scene, and nothing otherwise. `Body` draws a Scene view with it.
+ * - **Standalone**, it draws the `scene` it is handed; given `iiifContent`, it loads a
+ *   Scene itself (a Manifest gives its first).
+ */
+export declare function Scene(props: SceneProps): React.JSX.Element | null;
+export interface Sequence {
+	/** The Canvases, Timelines and Scenes Clover can show, in order. */
+	canvases: Container[];
+	views: View[];
+	direction: ViewingDirection;
+}
+/**
+ * Hooks for building parts of your own. Each reads one slice of the nearest `Root`'s
+ * state and re-renders only when that slice changes.
+ */
+/** Loading, ready or error, and the error. */
+export declare function useStatus(): {
+	status: CloverStatus;
+	error: Error | null;
+};
+/** The Manifest shown, in Presentation 4; null until loaded. */
+export declare function useManifest(): Manifest | null;
+/** The Canvases, Timelines and Scenes, their grouping into views, and the reading direction. */
+export declare function useSequence(): Sequence;
+/** The Canvases of the current view: one, or a spread. */
+export declare function useVisibleCanvases(): Container[];
+/** The Canvas the reader is on (the first of the current view). */
+export declare function useActiveCanvas(): Container | null;
+/** Moving between views. Steps by view, so a spread moves two pages at a time. */
+export declare function useNavigation(): Navigation;
+/** Every annotation set: the Manifest's own (fetched so far) and any the host added. */
+export declare function useAnnotationSets(): AnnotationSet[];
+/** A IIIF language map as text in the Root's language, with the tag it is in. */
+export declare function useLocalized(value: LanguageMapLike): LocalizedValue;
+/** Clover's interface strings in the current language: `t("commonClose")`. */
+export declare function useT(): (key: string, values?: Record<string, unknown>) => string;
+/**
+ * The language of one of Clover's strings where it is not the page's (a French reader on
+ * an English page, or a key that fell back to English), for the element that shows it, or
+ * is named by it, to carry as `lang` (WCAG 3.1.2). Undefined otherwise: the string takes
+ * the page's language. The page's is the nearest `lang` around the Root.
+ *
+ * ```jsx
+ * const t = Clover.useT();
+ * const langOf = Clover.useLangOf();
+ * <button aria-label={t("commonClose")} lang={langOf("commonClose")} />
+ * ```
+ */
+export declare function useLangOf(): (key: string) => string | undefined;
+/**
+ * Hidden from sight, present for assistive technology. Inline, not a class: it has to
+ * hold without the stylesheet, or the text it hides would show.
+ */
+export declare const visuallyHidden: CSSProperties;
+/**
+ * A key a control answers to: as `aria-keyshortcuts` names it (WAI-ARIA key names, `Plus`
+ * and `Space` spelled out, alternatives space-separated), and as its popover shows it.
+ */
+export interface Shortcut {
+	keys: string;
+	glyph: string;
+}
+/**
+ * The popover a control shows on hover and on keyboard focus: its name, the same string
+ * its `aria-label` gives assistive technology (WCAG 2.5.3, Label in Name), and its key
+ * when it has one. Put it inside the control, last; the control carries the name and
+ * `aria-keyshortcuts`, so the popover itself is hidden from assistive technology.
+ *
+ * WCAG 1.4.13 (Content on Hover or Focus): it shows on focus as well as hover; Escape
+ * hides it without moving the pointer or focus; the pointer can move onto it without it
+ * closing; and it stays until the pointer or focus leaves. Styles are `ui/Tip.css`.
+ */
+export declare function Tip({ label, lang, shortcut, scrolls, image, }: {
+	label: string;
+	/** The language of `label`, where it is not its control's. */
+	lang?: string;
+	shortcut?: Shortcut;
+	/**
+	 * It may run longer than the room it is kept in (a hotspot's note, kept inside the
+	 * Body): capped there, it scrolls (`scrollNote` in `Canvas/Annotations.tsx`). It never takes focus, which a scroller
+	 * might, hidden as it is from assistive technology: a press on it focuses its control.
+	 */
+	scrolls?: boolean;
+	/**
+	 * A picture above the words (a hotspot's image, Cookbook 0377): fetched only once it
+	 * shows, and named by them, as the control is.
+	 */
+	image?: string;
+}): React.JSX.Element;
+/**
+ * Clover's popups open one at a time: the Canvas's menus (annotations, Choice, an
+ * animation's frames) and its information, and the playback controls' menus. Opening
+ * one closes whichever other is open, anywhere on the page, as a menu bar
+ * does, and however it was opened: a key opens a popup without the press outside that
+ * closes a menu.
+ *
+ * Each still closes itself as it did (Escape, a press outside). Closed by another, a popup
+ * leaves focus where it is, since it has moved on to the one that opened. A popup of your
+ * own joins them with its open state and the way to close it:
+ *
+ * ```tsx
+ * const [open, setOpen] = useState(false);
+ * Clover.useOneOpen(open, () => setOpen(false));
+ * ```
+ */
+export declare function useOneOpen(open: boolean, close: () => void): void;
+/**
+ * An id unique on the page, across every render root, React's or Preact's: what Clover
+ * uses wherever it would call `useId`, and what a part of your own can use too.
+ */
+export declare function useUniqueId(): string;
+/**
+ * "Read more" for text cut short. Its one child is clamped by its own CSS (a
+ * `-webkit-line-clamp`, as `Summary` is: `components/Primitives/Primitives.css`); a
+ * button under it, shown only once the text runs past that, opens it in full ("Read
+ * more", `aria-expanded`) and cuts it short again ("Read less"). While open, the child
+ * carries `data-read-more="open"`, which its clamp leaves alone.
+ *
+ * For text of your own: wrap one element (or a component that forwards its ref), and
+ * clamp it in your CSS.
+ *
+ * ```tsx
+ * <Clover.ReadMore>
+ *   <p className="my-note">{text}</p>
+ * </Clover.ReadMore>
+ * ```
+ */
+export declare function ReadMore({ children }: {
+	children: React.ReactElement;
+}): React.JSX.Element;
+/** A title at a level, and what goes on it and on the group it heads. */
+export interface Titled {
+	/** The title's element: its heading, or past 6 the fallback, a `p`. */
+	as: React.ElementType;
+	/** For the title: past 6, the `id` its group is named by. */
+	title: {
+		id?: string;
+	};
+	/** For the element around what it heads: past 6, a group the title names. */
+	group: {
+		role?: "group";
+		"aria-labelledby"?: string;
+	};
+}
+/**
+ * A title at `level` with this `id`, and the group it heads, for a layout of your own.
+ * To h6 the title is a heading, and its group needs nothing. Past 6 it is a `p` (or
+ * `fallback`) that names the group: spread `title` on the title and `group` on the
+ * element around what it heads.
+ *
+ * ```tsx
+ * const title = Clover.titled(headingLevel, "viewer-title");
+ * <Clover.Root iiifContent={url} {...title.group}>
+ *   <Clover.Label as={title.as} {...title.title} />
+ * ```
+ */
+export declare function titled(level: number, id: string, fallback?: React.ElementType): Titled;
+/**
+ * The Clover a `Root` owns, and the language it reads IIIF text in. The context value is
+ * set once per Root (and when `language` changes), so parts never re-render through it:
+ * they subscribe to the store for exactly what they read.
+ */
+export interface CloverContextValue {
+	clover: Clover;
+	language?: string;
+	/** Renderers of the host's own, for `Body` to draw some views with. */
+	renderers?: BodyRenderer[];
+}
+/** The Clover of the nearest `Root`. Throws outside one, naming the part. */
+export declare function useClover(part?: string): CloverContextValue;
+/**
+ * A value derived from the store, re-rendering only when it changes. Selectors should
+ * return the same object for the same state (the core's are memoized), or pass `isEqual`.
+ */
+export declare function useCloverSelector<Value>(selector: (state: CloverState) => Value, isEqual?: (a: Value, b: Value) => boolean, part?: string): Value;
+/**
+ * Reading a content state: what a Root handed one (JSON or base64url, not a URL) loads
+ * and where it goes. Its own chunk, loaded only for a content state (`loadContent`): a
+ * page that opens a URL never carries it. Writing one stays in `content-state.ts`.
+ */
+export type Json = Record<string, any>;
+/** A content state string (JSON, or base64url-encoded JSON) as JSON; null if neither. */
+export declare function decodeContentState(value: string): Json | null;
+/**
+ * WebVTT, read by Clover: cues with their start, end and text. The Canvas's captions and
+ * the `Transcript` share one fetch per file through `loadVtt`.
+ *
+ * @see https://www.w3.org/TR/webvtt1/
+ */
+export interface Cue {
+	start: number;
+	end: number;
+	/** The cue text with voice and styling tags (`<v Speaker>`, `<i>`) removed. */
+	text: string;
+	/** The speaker, when a `<v>` tag names one. */
+	voice?: string;
+}
+export declare function parseVtt(text: string): Cue[];
+/**
+ * The cue playing at `time`: the latest to start at or before it that has not ended.
+ * Binary search, so a long transcript costs a few comparisons per tick. -1 if none.
+ */
+export declare function cueAt(cues: Cue[], time: number): number;
+/**
+ * Chapters of a time-based Canvas, from the Manifest's Ranges: a Range whose items name
+ * the Canvas with a time fragment (`#t=0,30`, or a `FragmentSelector` with `t=`) is a
+ * chapter. Ranges nest, and a reference cycle is walked once. Chapters come back by start
+ * time with the gaps closed, as a seek bar draws them contiguous.
+ */
+export interface Chapter {
+	/** Its Range's id, as `Contents` keys the Range. */
+	id?: string;
+	label?: LanguageMapLike;
+	start: number;
+	end?: number;
+}
+export declare function chaptersOf(manifest: Manifest | null, canvasId: string | null, duration?: number): Chapter[];
+/** One entry of a table of contents: a Range, where it starts, and the Ranges within. */
+export interface ContentsNode {
+	id: string;
+	label?: LanguageMapLike;
+	/** The first Canvas the Range (or its first descendant) names; none for an empty Range. */
+	canvasId?: string;
+	/** Every Canvas the Range covers, its own and its descendants'. */
+	canvasIds: string[];
+	/** The span on that Canvas, for time-based media. */
+	time?: {
+		start: number;
+		end?: number;
+	};
+	/** The region on that Canvas, when the Range names one. */
+	region?: {
+		x: number;
+		y: number;
+		w: number;
+		h: number;
+	};
+	children: ContentsNode[];
+}
+/**
+ * The Manifest's table of contents, from `structures`. A single top Range that only wraps
+ * others is unwrapped, as a reader expects its chapters, not one entry holding them.
+ * Ranges marked `no-nav` are left out (their children are kept), and a cycle is walked once.
+ */
+export declare function tableOfContents(manifest: Manifest | null): ContentsNode[];
+/**
+ * The entry the reader is in: the deepest covering `canvasId` whose span holds `time` (or
+ * that has no span). Null when none is.
+ */
+export declare function currentContents(nodes: ContentsNode[], canvasId: string | null, time?: number): string | null;
+export declare function toPlainText(html: string): string;
+/**
+ * How a text is read, strictly by its `format`'s media type: `text/html` as IIIF's HTML,
+ * sanitized to what the Presentation API allows; `text/markdown` as Markdown; `text/plain`
+ * (and any other type) as written, a `<` included. With no format, as IIIF's property
+ * values come, by IIIF's rule: HTML only from a first `<` to a last `>`, whitespace
+ * aside; anything else is plain text.
+ */
+export declare function readAs(format: string | undefined, value?: string): "markdown" | "html" | "plain";
+export type Json = Record<string, any>;
+/**
+ * A small picture of a region of a Canvas (an annotation's `xywh`, in the Canvas's own
+ * coordinates), to be cut by the image server (`resolveThumbnail`): the image painted
+ * there is found, and the region read as shares of it (scaled from where it is painted),
+ * so the service's own `info.json` decides how it is asked for, never more than the
+ * region has, and from a server that cannot cut a region, nothing (no fallback: all of
+ * the image is not the region). Null where no image with a service is painted there.
+ */
+export declare function regionSource(canvas: Json | undefined, rect: {
+	x: number;
+	y: number;
+	w: number;
+	h: number;
+}): ThumbnailSource | null;
+/**
+ * Clover's translations, without a translation library.
+ *
+ * Clover needs a key lookup with a fallback chain, `{{name}}` interpolation and language
+ * detection. i18next did that at about 20 kB gzipped across three packages;
+ * this does it in well under one. Languages are still defined the way i18next defines
+ * them, so existing `initCloverI18n` calls keep working:
+ *
+ *     initCloverI18n({
+ *       lng: "de",
+ *       fallbackLng: ["de", "en"],
+ *       resources: { de: { clover: { informationPanelTabsAbout: "Über" } } },
+ *     });
+ *
+ * English ships with Clover. Each other language it ships loads the first time Clover is
+ * to speak it, so until it arrives a string shows in English, marked as English by
+ * `langOf`, and the readers re-render when it does. `cloverI18n.ready()` waits for it.
+ */
+export declare const CLOVER_I18N_NAMESPACE = "clover";
+/** `resources[language][namespace][key]` — i18next's resource shape. */
+export type CloverI18nResources = Record<string, Record<string, Record<string, string>>>;
+export interface CloverI18nOptions {
+	/**
+	 * The language to use. When not given: the page's `<html lang>`, then the browser's
+	 * languages, so Clover speaks the language of the page around it.
+	 */
+	lng?: string;
+	/** Languages to try, in order, when a key is missing. English is always last. */
+	fallbackLng?: string | readonly string[] | false;
+	/** Strings to add or override, merged into what Clover ships. */
+	resources?: CloverI18nResources;
+}
+/** One of Clover's strings, and the language it is written in. */
+export interface CloverString {
+	text: string;
+	/** The language the string came from; undefined when no language has the key. */
+	lang?: string;
+}
+declare const cloverI18n: {
+	/** The language set, or else the first of the reader's that Clover has strings for. */
+	readonly language: string;
+	/**
+	 * The language Clover's strings are in: the first of the lookup chain that has any. A
+	 * language set with no strings of its own resolves to the next, English at the last.
+	 */
+	readonly resolvedLanguage: string;
+	changeLanguage(lng: string): void;
+	/** A string and the language it came from, which a missing key leaves in another. */
+	resolve(key: string, values?: Record<string, unknown>, namespace?: string): CloverString;
+	t(key: string, values?: Record<string, unknown>, namespace?: string): string;
+	/**
+	 * The language of a key's string where it is not the page's (`hostLanguage`), for the
+	 * element that shows it, or is named by it, to carry as `lang` (WCAG 3.1.2). Otherwise
+	 * undefined: the string takes the page's language. Without `hostLanguage`, only a
+	 * string that fell back to another language than the interface's is marked.
+	 */
+	langOf(key: string, hostLanguage?: string, namespace?: string): string | undefined;
+	/**
+	 * Settles once the language Clover speaks has loaded, or failed to: for a server render,
+	 * or a test, that needs the strings in place before it draws.
+	 *
+	 *     await initCloverI18n({ lng: "fr" }).ready();
+	 */
+	ready(): Promise<void>;
+	/** For `useSyncExternalStore`: re-render readers when the language or strings change. */
+	subscribe(listener: () => void): () => void;
+	getSnapshot(): number;
+};
+export type CloverI18n = typeof cloverI18n;
+/**
+ * Set Clover's language and add or override strings. Safe to call more than once: each
+ * call merges its `resources` and applies any `lng` or `fallbackLng` it is given.
+ */
+export declare function initCloverI18n(options?: CloverI18nOptions): CloverI18n;
+export type DefaultProps = Omit<RootProps, "children"> & {
+	/** The header over the Body: the resource's title and provider. Default `true`. */
+	header?: boolean;
+	/**
+	 * The title's heading level, to fit the outline of the page around the layout (under
+	 * an `h2`, 3). The panel's sections are a level below it, or at it with no header,
+	 * taking the title's place. Default 2.
+	 */
+	headingLevel?: number;
+	/** The information panel beside the Body, with its toggle. Default `true`. */
+	panel?: boolean;
+	/**
+	 * Whether the panel starts open beside the Body. Default `true`. Where it has no room
+	 * there and would slide over the Body, it starts closed.
+	 */
+	defaultPanelOpen?: boolean;
+	/**
+	 * How the information panel lays out its sections: `"accordion"` (the default),
+	 * stacked boxes each opened by its heading, or `"tabs"`.
+	 */
+	panelLayout?: PanelLayout;
+	/** The downloads in the panel's About, as links. Default `true`. */
+	download?: boolean;
+	/** The thumbnails under the Body: a layout, or `false` for none. Default `slider`. */
+	items?: Exclude<ItemsLayout, "pager"> | false;
+	/**
+	 * Where the panel's width is remembered once the reader drags its bar
+	 * (`localStorage`). Default `"clover-template-default"`; `false` forgets it.
+	 */
+	storageKey?: string | false;
+	/**
+	 * Fill the box it sits in: as tall as that box, the Body taking what the header and
+	 * the strip leave, so nothing runs below it. For a box of a set height, the window
+	 * under a page's own header say. Default `false`: the Body is
+	 * `--clover-body-height` tall, and the layout as tall as it needs.
+	 */
+	fill?: boolean;
+};
+declare function Default({ className, header, headingLevel, panel, defaultPanelOpen, panelLayout, download, items, storageKey, fill, ...root }: DefaultProps): React.JSX.Element;
+/**
+ * A layout the Viewer draws: one from `@nulib/clover/templates`, or a component of your
+ * own that takes the `Clover.Root` props.
+ */
+export type ViewerTemplate = React.ComponentType<any>;
+/**
+ * The Viewer's props are its template's: `Default`'s when there is none, and those of the
+ * one passed otherwise, so `template={Document}` brings `defaultSidebarOpen` with it.
+ */
+export type ViewerProps<T extends ViewerTemplate = typeof Default> = {
+	/** The layout. Default `Default`, Clover 3.x's Viewer, loaded when first needed. */
+	template?: T;
+} & React.ComponentProps<T>;
+/**
+ * Clover's Viewer: a Manifest (or Collection, or content state) in a layout. The default
+ * export of `@nulib/clover`.
+ *
+ * ```jsx
+ * import Viewer from "@nulib/clover";
+ * import { Document } from "@nulib/clover/templates";
+ *
+ * <Viewer iiifContent={url} />
+ * <Viewer iiifContent={url} template={Document} />
+ * ```
+ *
+ * The Viewer is a shell that holds no layout of its own, so a page ships only the
+ * template it passes. With none it loads `Default` on first render: one request more,
+ * and nothing drawn on the server. Pass `template={Default}` to have it up front.
+ */
+export declare function Viewer<T extends ViewerTemplate = typeof Default>({ template, ...props }: ViewerProps<T>): React.JSX.Element;
+
+export {
+	Viewer as default,
+};
+
+export {};