@tissuumaps/core 0.1.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,4533 @@
+import { default as default_2 } from 'openseadragon';
+import { JsonSchema } from '@jsonforms/core';
+import { mat3 } from 'gl-matrix';
+import { Mutate } from 'zustand';
+import { StoreApi } from 'zustand';
+import { UISchemaElement } from '@jsonforms/core';
+
+/**
+ * Base interface for data providers opening {@link AnnotatedDataSource}s
+ *
+ * In addition to a {@link DataProvider}, an annotated data provider receives
+ * the data of the table referenced by the data source, if any, when loading
+ * (see {@link AnnotatedDataProviderLoadOptions}).
+ *
+ * @typeParam TAnnotatedDataSource - The data source type this data provider
+ * opens
+ * @typeParam TData - The {@link Data} type produced by this data provider
+ * @typeParam TNormalizedAnnotatedDataSource - The data source type produced by
+ * {@link DataProvider.normalize} and accepted by
+ * {@link AnnotatedDataProvider.load}
+ */
+export declare interface AnnotatedDataProvider<TAnnotatedDataSource extends AnnotatedDataSource, TData extends Data, TNormalizedAnnotatedDataSource extends TAnnotatedDataSource = TAnnotatedDataSource> extends DataProvider<TAnnotatedDataSource, TData, TNormalizedAnnotatedDataSource> {
+    /**
+     * Opens a data source and returns the loaded data accessor
+     *
+     * The data source has to have been normalized by
+     * {@link DataProvider.normalize} beforehand.
+     *
+     * @param normalizedDataSource - The normalized data source to open
+     * @param options - See {@link AnnotatedDataProviderLoadOptions}
+     * @returns A promise that resolves to the loaded data accessor
+     */
+    load(normalizedDataSource: TNormalizedAnnotatedDataSource, options?: AnnotatedDataProviderLoadOptions): Promise<TData>;
+}
+
+/**
+ * Options accepted by {@link AnnotatedDataProvider.load}
+ */
+export declare type AnnotatedDataProviderLoadOptions = DataProviderLoadOptions & {
+    /** The data of the table referenced by the data source, if any */
+    tableDataPromise: Promise<TableData> | undefined;
+};
+
+/**
+ * A {@link RawAnnotatedDataSource} with {@link annotatedDataSourceDefaults} applied
+ */
+export declare type AnnotatedDataSource<TType extends string = string> = DataSource<TType> & Required<Pick<RawAnnotatedDataSource<TType>, keyof typeof annotatedDataSourceDefaults>> & Omit<RawAnnotatedDataSource<TType>, keyof typeof annotatedDataSourceDefaults>;
+
+/**
+ * Default values for {@link RawAnnotatedDataSource}
+ */
+export declare const annotatedDataSourceDefaults: {};
+
+/**
+ * The app store, i.e. its state and actions
+ */
+export declare type AppStore = AppStoreState & AppStoreActions;
+
+/**
+ * The actions of the app store
+ *
+ * Registering a data provider for a data source type that is already taken
+ * replaces the previously registered provider, which invalidates the data
+ * loaded through it.
+ */
+export declare type AppStoreActions = {
+    /**
+     * Opens a workspace, against which local data source paths are resolved
+     *
+     * @param workspace - The directory handle of the workspace, or `null` to
+     * close the open workspace
+     */
+    setWorkspace: (workspace: FileSystemDirectoryHandle | null) => void;
+    /**
+     * Sets how mouse events in the viewer are interpreted
+     *
+     * @param interactionMode - The interaction mode to switch to
+     */
+    setInteractionMode: (interactionMode: InteractionMode) => void;
+    /**
+     * Previews a single image channel on its own, or ends the preview
+     *
+     * @param imageChannelPreview - The image and channel to preview, or `null` to
+     * end the preview
+     */
+    setImageChannelPreview: (imageChannelPreview: ImageChannelPreview | null) => void;
+    /**
+     * Marks a project as open, or as closed
+     *
+     * @param projectOpen - Whether a project is open
+     */
+    setProjectOpen: (projectOpen: boolean) => void;
+    /**
+     * Highlights a group of an object in the viewer
+     *
+     * @param highlightedItemGroup - The group to highlight, or `null` to highlight
+     * none
+     */
+    setHighlightedItemGroup: (highlightedItemGroup: HighlightedItemGroup | null) => void;
+    /**
+     * Registers an image data provider
+     *
+     * @param type - The data source type the provider handles
+     * @param dataProvider - The data provider to register
+     */
+    registerImageDataProvider: (type: string, dataProvider: ImageDataProvider<ImageDataSource, ImageData_2>) => void;
+    /**
+     * Registers a labels data provider
+     *
+     * @param type - The data source type the provider handles
+     * @param dataProvider - The data provider to register
+     */
+    registerLabelsDataProvider: (type: string, dataProvider: LabelsDataProvider<LabelsDataSource, LabelsData>) => void;
+    /**
+     * Registers a points data provider
+     *
+     * @param type - The data source type the provider handles
+     * @param dataProvider - The data provider to register
+     */
+    registerPointsDataProvider: (type: string, dataProvider: PointsDataProvider<PointsDataSource, PointsData>) => void;
+    /**
+     * Registers a shapes data provider
+     *
+     * @param type - The data source type the provider handles
+     * @param dataProvider - The data provider to register
+     */
+    registerShapesDataProvider: (type: string, dataProvider: ShapesDataProvider<ShapesDataSource, ShapesData>) => void;
+    /**
+     * Registers a table data provider
+     *
+     * @param type - The data source type the provider handles
+     * @param dataProvider - The data provider to register
+     */
+    registerTableDataProvider: (type: string, dataProvider: TableDataProvider<TableDataSource, TableData>) => void;
+};
+
+/**
+ * The API through which the app store is read, written and subscribed to
+ */
+export declare type AppStoreApi = Mutate<StoreApi<AppStore>, [
+["zustand/immer", never]
+]>;
+
+/**
+ * The state of the app store, holding what is not part of the project
+ */
+export declare type AppStoreState = {
+    /** The directory handle of the open workspace, if any */
+    workspace: FileSystemDirectoryHandle | null;
+    /**
+     * Whether a project is open, possibly an empty one; the Project tab shows
+     * its welcome view otherwise
+     */
+    projectOpen: boolean;
+    /** How mouse events in the viewer are currently interpreted */
+    interactionMode: InteractionMode;
+    /** The channel previewed on its own while it is hovered, if any */
+    imageChannelPreview: ImageChannelPreview | null;
+    /**
+     * The group shown alone in the viewer, hiding every other item of its
+     * object, or `null` for none
+     */
+    highlightedItemGroup: HighlightedItemGroup | null;
+    /** The registered image data providers, by data source type */
+    imageDataProviders: Map<string, ImageDataProvider<ImageDataSource, ImageData_2>>;
+    /** The registered labels data providers, by data source type */
+    labelsDataProviders: Map<string, LabelsDataProvider<LabelsDataSource, LabelsData>>;
+    /** The registered points data providers, by data source type */
+    pointsDataProviders: Map<string, PointsDataProvider<PointsDataSource, PointsData>>;
+    /** The registered shapes data providers, by data source type */
+    shapesDataProviders: Map<string, ShapesDataProvider<ShapesDataSource, ShapesData>>;
+    /** The registered table data providers, by data source type */
+    tableDataProviders: Map<string, TableDataProvider<TableDataSource, TableData>>;
+    /**
+     * The registered plugins, by plugin ID, each as its human-readable name
+     * together with the element its user interface is mounted into, if it has one
+     *
+     * Written by the plugin registry, which owns the plugin lifecycle and keeps
+     * the plugin objects themselves to itself, so that nothing a plugin owns ends
+     * up frozen in the store.
+     */
+    plugins: Map<string, {
+        name: string;
+        container?: HTMLElement;
+    }>;
+};
+
+/**
+ * Utility methods for converting arrays to the types the storage API holds
+ */
+export declare class ArrayUtils {
+    /**
+     * Converts item IDs to an `IDArray`
+     *
+     * Integer typed arrays, string arrays and 64-bit float arrays holding safe
+     * integers are returned as they are. Any other array has to hold either
+     * strings only, which are copied into a string array, or safe integers only,
+     * which are copied into 64-bit floats. Numeric strings are not parsed:
+     * whether `"12"` is an ID or a number is up to the data provider. An empty
+     * array yields an empty unsigned 32-bit integer array.
+     *
+     * @param values - The IDs to convert
+     * @returns The IDs as an integer typed array, a 64-bit float array or a
+     * string array
+     * @throws Error if a value is neither a string nor a safe integer, or if
+     * strings and integers are mixed
+     */
+    static toIDArray(values: ArrayLike<unknown>): IDArray;
+    /**
+     * Tells whether an array is an integer typed array of at most 32 bits
+     */
+    private static _isIntOrUintArray;
+    /**
+     * Converts 64-bit integers to 64-bit floats
+     *
+     * @param values - The integers, as read from a file (e.g. a `BigInt64Array`)
+     * @returns The integers as floats
+     * @throws Error if an integer is outside the safe integer range
+     */
+    static parseSafeInts(values: ArrayLike<bigint>): Float64Array;
+}
+
+/**
+ * Utility methods for running large CPU workloads on the main thread without
+ * blocking the UI, by cooperatively yielding to the event loop
+ */
+export declare class AsyncUtils {
+    private static _messageChannel;
+    private static _pendingResolvers;
+    /**
+     * Yields control back to the event loop, allowing the browser to paint and
+     * process input before resuming.
+     *
+     * Uses the native `scheduler.yield()` when available, otherwise falls back to
+     * a shared `MessageChannel` (a macrotask without `setTimeout`'s clamping).
+     *
+     * @returns A promise that resolves once the event loop has been yielded to
+     */
+    static yield(): Promise<void>;
+    /**
+     * Creates a time-sliced yielder for loops whose iterations are too coarse or
+     * heterogeneous for {@link AsyncUtils.forEach} (e.g. nested loops).
+     *
+     * Call the returned function at safe points inside a loop: it checks the
+     * abort signal on every call for fail-fast cancellation, and additionally
+     * yields to the event loop once the time budget since the last yield is
+     * exceeded. When within budget and not aborted, it is a cheap no-op.
+     *
+     * @param options - Optional time (ms) to run before yielding
+     * @returns The yielder, which takes an optional abort signal
+     */
+    static createYielder(options?: {
+        yieldMs?: number;
+    }): (opts?: {
+        signal?: AbortSignal;
+    }) => Promise<void>;
+    /**
+     * Invokes `callback(item, index)` for every element of `items`, yielding to
+     * the event loop whenever the time budget is exceeded so the UI stays
+     * responsive.
+     *
+     * The abort signal is checked up front and after every yield, preserving
+     * fail-fast cancellation: an abort rejects with the signal's reason and no
+     * further iterations run.
+     *
+     * @param items - The array-like collection to iterate over
+     * @param callback - Synchronous work to perform for each `item` and its `index`
+     * @param options - Optional abort signal, time (ms) to run before yielding
+     *   (`yieldMs`), and the number of iterations between budget checks
+     *   (`checkEvery`)
+     * @returns A promise that resolves once every item has been visited, or
+     *   rejects with the signal's reason
+     */
+    static forEach<T>(items: ArrayLike<T>, callback: (item: T, index: number) => void, options?: {
+        signal?: AbortSignal;
+        yieldMs?: number;
+        checkEvery?: number;
+    }): Promise<void>;
+    /**
+     * Returns a promise that resolves or rejects with the given `promise`, but
+     * rejects early if the given `signal` is aborted.
+     *
+     * @param promise - The promise to race against the abort signal
+     * @param options - Optional abort signal to race against the promise
+     * @returns A promise that resolves or rejects based on the race condition
+     */
+    static raceSignal<T>(promise: Promise<T>, options?: {
+        signal?: AbortSignal;
+    }): Promise<T>;
+    /**
+     * Creates a promise together with the functions that resolve and reject it,
+     * like `Promise.withResolvers()`, which is not yet widely available.
+     *
+     * @returns The promise and the functions that resolve and reject it
+     */
+    static withResolvers<T>(): {
+        promise: Promise<T>;
+        resolve: (value: T | PromiseLike<T>) => void;
+        reject: (reason?: unknown) => void;
+    };
+}
+
+/** Utility methods for bitwise operations that yield unsigned 32-bit results */
+export declare class BitUtils {
+    /**
+     * Performs a bitwise AND, returning an unsigned 32-bit result
+     *
+     * @param a - First operand
+     * @param b - Second operand
+     * @returns The result, as an unsigned 32-bit integer
+     */
+    static safeAnd(a: number, b: number): number;
+    /**
+     * Performs a bitwise OR, returning an unsigned 32-bit result
+     *
+     * @param a - First operand
+     * @param b - Second operand
+     * @returns The result, as an unsigned 32-bit integer
+     */
+    static safeOr(a: number, b: number): number;
+    /**
+     * Performs a bitwise XOR, returning an unsigned 32-bit result
+     *
+     * @param a - First operand
+     * @param b - Second operand
+     * @returns The result, as an unsigned 32-bit integer
+     */
+    static safeXor(a: number, b: number): number;
+    /**
+     * Performs a bitwise NOT, returning an unsigned 32-bit result
+     *
+     * @param a - The operand
+     * @returns The result, as an unsigned 32-bit integer
+     */
+    static safeNot(a: number): number;
+    /**
+     * Performs a left shift, returning an unsigned 32-bit result
+     *
+     * @param value - The value to shift
+     * @param shift - Number of bit positions to shift
+     * @returns The result, as an unsigned 32-bit integer
+     */
+    static safeLeftShift(value: number, shift: number): number;
+    /**
+     * Performs an unsigned right shift
+     *
+     * @param value - The value to shift
+     * @param shift - Number of bit positions to shift
+     * @returns The result, as an unsigned 32-bit integer
+     */
+    static safeRightShift(value: number, shift: number): number;
+}
+
+/** Color palettes suitable for categorical data */
+export declare const categoricalColorPalettes: ColorPalette[];
+
+/** A color in RGB format */
+export declare type Color = {
+    /** Red component, between 0 and 255 */
+    r: number;
+    /** Green component, between 0 and 255 */
+    g: number;
+    /** Blue component, between 0 and 255 */
+    b: number;
+};
+
+/**
+ * Color configuration
+ *
+ * When sourced from a numerical table column, values are clipped to the
+ * configured range - or min-max-scaled, if none is given - and then mapped to
+ * the configured color palette.
+ */
+export declare type ColorConfig = ConstantConfig<Color> | FromConfig<{
+    /**
+     * Value range that is linearly mapped to the color palette
+     *
+     * Values are clipped to this range before mapping them to colors.
+     *
+     * If not specified, min-max-scaling is used.
+     */
+    range?: [number, number];
+    /** ID of the color palette to which clipped and rescaled numerical values are mapped */
+    palette: string;
+}> | GroupByConfig<false, {
+    /**
+     * ID of the color palette for mapping hashed group names to colors
+     *
+     * Only used when no project-global colormap is specified
+     */
+    palette?: string;
+}> | RandomConfig<{
+    /** ID of the color palette from which colors are randomly drawn */
+    palette: string;
+}>;
+
+/** A named, identifiable list of colors */
+export declare type ColorPalette = {
+    /** Color palette ID */
+    id: string;
+    /** Human-readable color palette name */
+    name: string;
+    /** The colors making up the palette, in order */
+    colors: Color[];
+};
+
+/** All available color palettes, continuous and categorical */
+export declare const colorPalettes: ColorPalette[];
+
+/** Utility methods for color parsing, packing, and conversion */
+export declare class ColorUtils {
+    /**
+     * Parses a text-based color palette into an array of colors
+     *
+     * Each non-empty line is expected to contain three numeric components
+     * separated by `sep`, scaled from `[0, maxValue]` to `[0, 255]`.
+     *
+     * @param str - Multi-line palette string
+     * @param options - Component separator (default `" "`) and maximum input
+     * value per component (default `1`)
+     * @returns The parsed colors, in the order of the palette's lines
+     * @throws Error if a non-empty line does not hold exactly three components
+     */
+    static parsePalette(str: string, options?: {
+        sep?: string;
+        maxValue?: number;
+    }): Color[];
+    /**
+     * Samples a continuous color scheme into an array of colors
+     *
+     * The scheme is evaluated at `n` evenly spaced positions covering the whole
+     * `[0, 1]` range, both ends included.
+     *
+     * @param colorScheme - Maps a position within `[0, 1]` to a CSS color string
+     * @param n - Number of colors to sample, an integer of at least two
+     * @returns The sampled colors, in the order of the scheme
+     * @throws Error if `n` is not an integer of at least two, or if the scheme
+     * yields a color string that cannot be parsed
+     */
+    static sampleColorScheme(colorScheme: (t: number) => string, n: number): Color[];
+    /**
+     * Packs an RGB color into a single 24-bit integer, `0xBBGGRR`
+     *
+     * The red component occupies the lowest byte, so that the integer, when
+     * stored in host byte order on a little-endian host, matches the R, G, B byte
+     * order of a canvas `ImageData` buffer.
+     *
+     * @param color - The color to pack
+     * @returns The packed color, `0xBBGGRR`
+     */
+    static packColor(color: Color): number;
+    /**
+     * Packs a visibility into the form that {@link withAlpha} folds into a color
+     *
+     * @param visibility - The visibility
+     * @returns `1` if visible, `0` if not
+     */
+    static packVisibility(visibility: boolean): number;
+    /**
+     * Packs an opacity into the form that {@link withAlpha} folds into a color
+     *
+     * @param opacity - The opacity, in the range [0, 1]; values outside are clamped
+     * @returns The opacity as an integer in the range [0, 255]
+     */
+    static packOpacity(opacity: number): number;
+    /**
+     * Folds a visibility and an opacity into the alpha channel of a packed color
+     *
+     * Combines the lower 24 bits of `color` (see {@link packColor}) with
+     * `opacity` as alpha if `visibility` is non-zero, and with zero alpha
+     * otherwise, into a packed 32-bit RGBA color, `0xAABBGGRR`.
+     *
+     * @param packedColor - The packed color, `0xBBGGRR`; any higher bits are discarded
+     * @param packedVisibility - The visibility, larger than `0` for visible
+     * @param packedOpacity - The opacity, in the range [0, 255]
+     * @returns The packed RGBA color, `0xAABBGGRR`, as an unsigned 32-bit integer
+     */
+    static withAlpha(packedColor: number, packedVisibility: number, packedOpacity: number): number;
+    /**
+     * Parses a hex color string into a {@link Color}
+     *
+     * @param hex - A `#RRGGBB` hex string
+     * @returns The parsed color
+     * @throws Error if the string is not a valid 6-digit hex color
+     */
+    static fromHex(hex: string): Color;
+    /**
+     * Formats a {@link Color} as a `#RRGGBB` hex string
+     *
+     * @param color - The color to format
+     * @returns The formatted hex string
+     */
+    static toHex(color: Color): string;
+    /**
+     * Checks whether two colors have identical RGB components
+     *
+     * Components are compared exactly, without rounding or tolerance.
+     *
+     * @param a - The first color
+     * @param b - The second color
+     * @returns `true` if all three components are equal, `false` otherwise
+     */
+    static equals(a: Color, b: Color): boolean;
+    /**
+     * Converts an HSB (HSV) color to RGB, following Java's `Color.HSBtoRGB`
+     *
+     * @param hue - The hue, in the range [0, 1) (values outside wrap around)
+     * @param saturation - The saturation, in the range [0, 1]
+     * @param brightness - The brightness, in the range [0, 1]
+     * @returns The RGB color, with integer components in the range [0, 255]
+     */
+    static fromHSB(hue: number, saturation: number, brightness: number): Color;
+}
+
+/**
+ * Base type for property configurations that can be sourced from different providers
+ *
+ * Concrete configuration types (e.g. {@link ColorConfig}, {@link SizeConfig}) are unions
+ * of this base with one or more source-specific types such as {@link ConstantConfig},
+ * {@link FromConfig}, {@link GroupByConfig}, and {@link RandomConfig}.
+ */
+export declare type Config<TSource extends string> = {
+    /**
+     * Explicitly prioritized configuration source
+     *
+     * When set, this overrides the automatic source detection in {@link getActiveConfigSource}.
+     */
+    source?: TSource;
+};
+
+/** Utility methods for property configurations */
+export declare class ConfigUtils {
+    /**
+     * Returns the group-to-value map that a configuration resolves its values
+     * from, if any
+     *
+     * Only an active `groupBy` source (see {@link getActiveConfigSource}) with a
+     * map ID resolves from a map. The map is returned as found in `maps`, rather
+     * than copied: maps are never mutated, as an edit replaces the map, so
+     * callers can detect an edit by comparing the returned maps by identity.
+     *
+     * @param config - The configuration
+     * @param maps - The project-global maps to look the referenced map up in
+     * @returns The map, or `undefined` if the configuration does not resolve
+     * from a map, or if the map it references does not exist
+     */
+    static findGroupByMap<TValue>(config: Config<string>, maps: GroupValueMap<TValue>[]): GroupValueMap<TValue> | undefined;
+    /**
+     * Returns the IDs of the maps that configurations refer to
+     *
+     * A configuration refers to its map whatever its active source, as switching
+     * back to `groupBy` uses the map again.
+     *
+     * @param configs - The configurations
+     * @returns The IDs of the referenced maps
+     */
+    static getGroupByMapIds(configs: Config<string>[]): Set<string>;
+    /**
+     * Creates the function that returns the value a group-by configuration
+     * assigns to a group
+     *
+     * With a map, a group takes its value in the map, else the map's default,
+     * else `defaultValue`; a map that does not exist gives every group
+     * `defaultValue`. Without a map, a group takes the palette value its name
+     * hashes to, or `defaultValue` if there is no palette.
+     *
+     * @param config - The group-by configuration
+     * @param map - The map the configuration refers to (see
+     * {@link findGroupByMap}), or `undefined` if it refers to none or the map
+     * does not exist
+     * @param defaultValue - The value of a group that nothing assigns one to
+     * @param palette - The values to pick from by hash if there is no map
+     * @returns The value of a group, by group name (the cell value as a string)
+     */
+    static createGroupValueGetter<TValue>(config: GroupByConfig<false>, map: GroupValueMap<TValue> | undefined, defaultValue: TValue, palette?: readonly TValue[]): (group: string) => TValue;
+    /**
+     * Returns the table column a configuration groups by
+     *
+     * @param config - The configuration
+     * @returns The column, or `undefined` if `groupBy` is not the active source
+     */
+    static getGroupByColumn(config: Config<string>): TableColumnRef | undefined;
+    /**
+     * Points a configuration at a map, grouping by a column
+     *
+     * The configuration keeps its other sources and the extra fields of its
+     * `groupBy` specification (e.g. a palette), so that switching back to them
+     * restores them. The unit of the active source, which only sizes have, is
+     * carried over, so that the values keep their scale. A configuration that
+     * already groups by the column with the map is returned as is, so that
+     * updating an object with it changes nothing.
+     *
+     * @param config - The configuration
+     * @param groupBy - The categorical table column to group by
+     * @param mapId - ID of the project-global map to take the group values from
+     * @returns The configuration, with `groupBy` as its active source
+     */
+    static withGroupByMap(config: Config<string>, groupBy: TableColumnRef, mapId: string): GroupByConfig<true>;
+    /**
+     * Returns the unit of the active source of a configuration
+     *
+     * @param config - The configuration, of which only sizes have a unit
+     * @returns The unit, or `undefined` if the active source has none
+     */
+    static getUnit(config: Config<string>): CoordinateSpace | undefined;
+    /**
+     * Determines whether two table column references point to the same column
+     *
+     * References without a table point to the column of `defaultTable`.
+     *
+     * @param tableColumnRef - The table column reference
+     * @param otherTableColumnRef - The table column reference to compare with
+     * @param defaultTable - ID of the table of references without a table
+     * @returns Whether both references point to the same column
+     */
+    static isSameTableColumn(tableColumnRef: TableColumnRef, otherTableColumnRef: TableColumnRef, defaultTable?: string): boolean;
+}
+
+/** Configuration to use a constant value */
+export declare type ConstantConfig<TValue, TConstantExtra = unknown> = Config<"constant"> & {
+    /** Specification of a constant value */
+    constant: {
+        value: NonNullable<TValue>;
+    } & TConstantExtra;
+};
+
+/** Color palettes suitable for continuous data */
+export declare const continuousColorPalettes: ColorPalette[];
+
+/** Coordinate space */
+export declare type CoordinateSpace = 
+/** Data (e.g. pixel) space */
+"data"
+/** Layer (e.g. physical) space */
+| "layer"
+/** World (i.e. global) space */
+| "world";
+
+/**
+ * Creates an {@link AnnotatedDataSource} from a {@link RawAnnotatedDataSource} by applying {@link annotatedDataSourceDefaults}
+ *
+ * @param rawAnnotatedDataSource - The raw annotated data source
+ * @returns The complete annotated data source with default values applied
+ */
+export declare function createAnnotatedDataSource<TType extends string>(rawAnnotatedDataSource: RawAnnotatedDataSource<TType>): AnnotatedDataSource<TType>;
+
+/**
+ * Creates a {@link DataObject} from a {@link RawDataObject} by applying {@link dataObjectDefaults}
+ *
+ * @param rawDataObject - The raw data object
+ * @returns The complete data object with default values applied
+ */
+export declare function createDataObject<TType extends string, TRawDataSource extends RawDataSource<TType>>(rawDataObject: RawDataObject<TRawDataSource>): DataObject<DataSource<TType>>;
+
+/**
+ * Creates a {@link DataSource} from a {@link RawDataSource} by applying {@link dataSourceDefaults}
+ *
+ * @param rawDataSource - The raw data source
+ * @returns The complete data source with default values applied
+ */
+export declare function createDataSource<TType extends string>(rawDataSource: RawDataSource<TType>): DataSource<TType>;
+
+/**
+ * Creates an {@link Image} from a {@link RawImage} by applying {@link imageDefaults}
+ *
+ * @param rawImage - The raw image
+ * @returns The complete image with default values applied
+ */
+export declare function createImage(rawImage: RawImage): Image_2;
+
+/**
+ * Creates an {@link ImageDataSource} from a {@link RawImageDataSource} by applying {@link imageDataSourceDefaults}
+ *
+ * @param rawImageDataSource - The raw image data source
+ * @returns The complete image data source with default values applied
+ */
+export declare function createImageDataSource<TType extends string>(rawImageDataSource: RawImageDataSource<TType>): ImageDataSource<TType>;
+
+/**
+ * Creates a {@link Labels} from a {@link RawLabels} by applying {@link labelsDefaults}
+ *
+ * @param rawLabels - The raw labels
+ * @returns The complete labels with default values applied
+ */
+export declare function createLabels(rawLabels: RawLabels): Labels;
+
+/**
+ * Creates a {@link LabelsDataSource} from a {@link RawLabelsDataSource} by applying {@link labelsDataSourceDefaults}
+ *
+ * @param rawLabelsDataSource - The raw labels data source
+ * @returns The complete labels data source with default values applied
+ */
+export declare function createLabelsDataSource<TType extends string>(rawLabelsDataSource: RawLabelsDataSource<TType>): LabelsDataSource<TType>;
+
+/**
+ * Creates a {@link Layer} from a {@link RawLayer} by applying {@link layerDefaults}
+ *
+ * @param rawLayer - The raw layer
+ * @returns The complete layer with default values applied
+ */
+export declare function createLayer(rawLayer: RawLayer): Layer;
+
+/**
+ * Creates a {@link Model} from a {@link RawModel} by applying {@link modelDefaults}
+ *
+ * @param rawModel - The raw model
+ * @returns The complete model with default values applied
+ */
+export declare function createModel(rawModel: RawModel): Model;
+
+/**
+ * Creates a {@link Points} from a {@link RawPoints} by applying {@link pointsDefaults}
+ *
+ * @param rawPoints - The raw points
+ * @returns The complete points with default values applied
+ */
+export declare function createPoints(rawPoints: RawPoints): Points;
+
+/**
+ * Creates a {@link PointsDataSource} from a {@link RawPointsDataSource} by applying {@link pointsDataSourceDefaults}
+ *
+ * @param rawPointsDataSource - The raw points data source
+ * @returns The complete points data source with default values applied
+ */
+export declare function createPointsDataSource<TType extends string>(rawPointsDataSource: RawPointsDataSource<TType>): PointsDataSource<TType>;
+
+/**
+ * Creates a {@link Project} from a {@link RawProject} by applying {@link projectDefaults}
+ *
+ * @param rawProject - The raw project
+ * @returns The complete project with default values applied
+ */
+export declare function createProject(rawProject: RawProject): Project;
+
+/**
+ * Creates a {@link RenderedDataObject} from a {@link RawRenderedDataObject} by applying {@link renderedDataObjectDefaults}
+ *
+ * @param rawRenderedDataObject - The raw rendered data object
+ * @returns The complete rendered data object with default values applied
+ */
+export declare function createRenderedDataObject<TType extends string, TRawDataSource extends RawDataSource<TType>>(rawRenderedDataObject: RawRenderedDataObject<TRawDataSource>): RenderedDataObject<DataSource<TType>>;
+
+/**
+ * Creates a {@link RenderedItemsDataObject} from a {@link RawRenderedItemsDataObject} by applying {@link renderedItemsDataObjectDefaults}
+ *
+ * @param rawRenderedItemsDataObject - The raw rendered items data object
+ * @returns The complete rendered items data object with default values applied
+ */
+export declare function createRenderedItemsDataObject<TType extends string, TRawDataSource extends RawDataSource<TType>>(rawRenderedItemsDataObject: RawRenderedItemsDataObject<TRawDataSource>): RenderedItemsDataObject<DataSource<TType>>;
+
+/**
+ * Creates a {@link RenderedRasterDataObject} from a {@link RawRenderedRasterDataObject} by applying {@link renderedRasterDataObjectDefaults}
+ *
+ * @param rawRenderedRasterDataObject - The raw rendered raster data object
+ * @returns The complete rendered raster data object with default values applied
+ */
+export declare function createRenderedRasterDataObject<TType extends string, TRawDataSource extends RawDataSource<TType>>(rawRenderedRasterDataObject: RawRenderedRasterDataObject<TRawDataSource>): RenderedRasterDataObject<DataSource<TType>>;
+
+/**
+ * Creates a {@link Shapes} from a {@link RawShapes} by applying {@link shapesDefaults}
+ *
+ * @param rawShapes - The raw shapes
+ * @returns The complete shapes with default values applied
+ */
+export declare function createShapes(rawShapes: RawShapes): Shapes;
+
+/**
+ * Creates a {@link ShapesDataSource} from a {@link RawShapesDataSource} by applying {@link shapesDataSourceDefaults}
+ *
+ * @param rawShapesDataSource - The raw shapes data source
+ * @returns The complete shapes data source with default values applied
+ */
+export declare function createShapesDataSource<TType extends string>(rawShapesDataSource: RawShapesDataSource<TType>): ShapesDataSource<TType>;
+
+/**
+ * Creates a {@link Table} from a {@link RawTable} by applying {@link tableDefaults}
+ *
+ * @param rawTable - The raw table
+ * @returns The complete table with default values applied
+ */
+export declare function createTable(rawTable: RawTable): Table;
+
+/**
+ * Creates a {@link TableDataSource} from a {@link RawTableDataSource} by applying {@link tableDataSourceDefaults}
+ *
+ * @param rawTableDataSource - The raw table data source
+ * @returns The complete table data source with default values applied
+ */
+export declare function createTableDataSource<TType extends string>(rawTableDataSource: RawTableDataSource<TType>): TableDataSource<TType>;
+
+/** A custom tile source that resolves tile URLs programmatically */
+export declare interface CustomTileSource {
+    /**
+     * Returns the URL for a specific tile
+     *
+     * @param level - Pyramid level
+     * @param x - Tile column index
+     * @param y - Tile row index
+     * @returns The tile URL, or a function that returns the URL
+     */
+    getTileUrl(level: number, x: number, y: number): string | (() => string);
+}
+
+/**
+ * Base interface for loaded data objects
+ */
+export declare interface Data {
+    /** Releases all resources held by this data object */
+    close(): void;
+}
+
+/**
+ * A {@link RawDataObject} with {@link dataObjectDefaults} applied
+ */
+export declare type DataObject<TDataSource extends DataSource<string>> = Model & Required<Pick<RawDataObject<TDataSource>, keyof typeof dataObjectDefaults>> & Omit<RawDataObject<TDataSource>, keyof typeof dataObjectDefaults>;
+
+/**
+ * Default values for {@link RawDataObject}
+ */
+export declare const dataObjectDefaults: {};
+
+/**
+ * Base interface for data providers
+ *
+ * @typeParam TDataSource - The data source type this data provider opens
+ * @typeParam TData - The {@link Data} type produced by this data provider
+ * @typeParam TNormalizedDataSource - The data source type produced by
+ * {@link DataProvider.normalize} and accepted by {@link DataProvider.load}
+ */
+export declare interface DataProvider<TDataSource extends DataSource, TData extends Data, TNormalizedDataSource extends TDataSource = TDataSource> {
+    /** The name of the data provider */
+    readonly name: string;
+    /** The JSON schema for the data source */
+    readonly schema: JsonSchema;
+    /** The JSON Forms UI schema for the data source */
+    readonly uischema: UISchemaElement;
+    /**
+     * Returns the data source with all of this data provider's defaults applied
+     * and its source normalized
+     *
+     * Data sources that normalize to the same value are considered equal, and
+     * their data is loaded only once and shared between all referencing objects.
+     * Normalization has to be idempotent: normalizing an already normalized data
+     * source must return the same value again.
+     *
+     * The source is normalized with `SourceUtils.normalizeSource`, which resolves
+     * it against the project source and the open workspace, so the result has to
+     * be recomputed when either changes.
+     *
+     * Normalizing may throw, e.g. for a source that cannot be resolved against
+     * the given workspace and project source. The data cache catches it, so only
+     * the objects referencing that data source fail to load; the data of all
+     * other objects is unaffected.
+     *
+     * @param dataSource - The data source to normalize
+     * @param workspace - The directory handle of the open workspace, if any
+     * @param projectSource - Where the project was loaded from: its absolute URL,
+     * the workspace-relative path of the project file, or `null` for projects
+     * that were loaded from neither
+     * @returns The normalized data source
+     */
+    normalize(dataSource: TDataSource, workspace: FileSystemDirectoryHandle | null, projectSource: string | null): TNormalizedDataSource;
+    /**
+     * Opens a data source and returns the loaded data accessor
+     *
+     * The data source has to have been normalized by
+     * {@link DataProvider.normalize} beforehand.
+     *
+     * @param normalizedDataSource - The normalized data source to open
+     * @param options - See {@link DataProviderLoadOptions}
+     * @returns A promise that resolves to the loaded data accessor
+     */
+    load(normalizedDataSource: TNormalizedDataSource, options?: DataProviderLoadOptions): Promise<TData>;
+}
+
+/**
+ * Options accepted by {@link DataProvider.load}
+ */
+export declare type DataProviderLoadOptions = {
+    /** Signal for aborting the load operation */
+    signal?: AbortSignal;
+    /** Directory handle of the open workspace, if any */
+    workspace?: FileSystemDirectoryHandle | null;
+    /** Callback for reporting the progress of the load operation */
+    onProgress?: ProgressCallback;
+};
+
+/**
+ * A reference to an object's data, in one of three states
+ *
+ * While `status` is `"loading"`, `progress` and `total` carry the most recent
+ * progress report, if there was any; `"loaded"` carries the data, and
+ * `"error"` the reason why loading it failed. A reference is replaced, rather
+ * than mutated, whenever its state changes.
+ */
+export declare type DataRef<TData extends Data> = {
+    /** Resolves with the loaded data, or rejects with the loading error */
+    promise: Promise<TData>;
+} & ({
+    status: "loading";
+    progress?: number;
+    total?: number;
+} | {
+    status: "loaded";
+    data: TData;
+} | {
+    status: "error";
+    error: unknown;
+});
+
+/**
+ * A {@link RawDataSource} with {@link dataSourceDefaults} applied
+ */
+export declare type DataSource<TType extends string = string> = Model & Required<Pick<RawDataSource<TType>, keyof typeof dataSourceDefaults>> & Omit<RawDataSource<TType>, keyof typeof dataSourceDefaults>;
+
+/**
+ * Default values for {@link RawDataSource}
+ */
+export declare const dataSourceDefaults: {};
+
+/**
+ * The data store, i.e. its state and actions
+ */
+export declare type DataStore = DataStoreState & DataStoreActions;
+
+/**
+ * The actions of the data store
+ *
+ * The data store has none: it is written to by the application, which keeps it
+ * in sync with the project and with the data it has loaded.
+ */
+export declare type DataStoreActions = {};
+
+/**
+ * The API through which the data store is read and subscribed to
+ */
+export declare type DataStoreApi = Mutate<StoreApi<DataStore>, [
+["zustand/immer", never]
+]>;
+
+/**
+ * The state of the data store, holding the data of the current project
+ *
+ * Each map is keyed by object ID; objects whose data is neither loaded nor
+ * being loaded are absent.
+ */
+export declare type DataStoreState = {
+    /** The data references of the project's images */
+    imageDataRefs: Map<string, DataRef<ImageData_2>>;
+    /** The data references of the project's labels */
+    labelsDataRefs: Map<string, DataRef<LabelsData>>;
+    /** The data references of the project's points */
+    pointsDataRefs: Map<string, DataRef<PointsData>>;
+    /** The data references of the project's shapes */
+    shapesDataRefs: Map<string, DataRef<ShapesData>>;
+    /** The data references of the project's tables */
+    tableDataRefs: Map<string, DataRef<TableData>>;
+};
+
+/** Default label color */
+export declare const defaultLabelColor: {
+    readonly r: 255;
+    readonly g: 255;
+    readonly b: 255;
+};
+
+/** ID of the default color palette for random label colors */
+export declare const defaultLabelColorPalette = "distinct";
+
+/** Default label opacity */
+export declare const defaultLabelOpacity = 1;
+
+/** Default label visibility */
+export declare const defaultLabelVisibility = true;
+
+/** Default point color */
+export declare const defaultPointColor: {
+    readonly r: 255;
+    readonly g: 255;
+    readonly b: 255;
+};
+
+/** Default point marker */
+export declare const defaultPointMarker: 6;
+
+/** Default point opacity */
+export declare const defaultPointOpacity = 1;
+
+/** Default point size */
+export declare const defaultPointSize = 1;
+
+/** Default coordinate space in which point sizes are specified */
+export declare const defaultPointSizeUnit: CoordinateSpace;
+
+/** Default point visibility */
+export declare const defaultPointVisibility = true;
+
+/**
+ * Default seed of random configurations (see `RandomConfig`), used when a
+ * configuration does not specify one
+ */
+export declare const defaultRandomSeed = 0;
+
+/** Default shape fill color */
+export declare const defaultShapeFillColor: {
+    readonly r: 255;
+    readonly g: 255;
+    readonly b: 255;
+};
+
+/** Default shape fill opacity */
+export declare const defaultShapeFillOpacity = 1;
+
+/** Default shape fill visibility */
+export declare const defaultShapeFillVisibility = true;
+
+/** Default shape opacity */
+export declare const defaultShapeOpacity = 1;
+
+/** Default shape stroke color */
+export declare const defaultShapeStrokeColor: {
+    readonly r: 0;
+    readonly g: 0;
+    readonly b: 0;
+};
+
+/** Default shape stroke opacity */
+export declare const defaultShapeStrokeOpacity = 1;
+
+/** Default shape stroke visibility */
+export declare const defaultShapeStrokeVisibility = true;
+
+/** Default shape visibility */
+export declare const defaultShapeVisibility = true;
+
+/** Dimensions of a two-dimensional object */
+export declare type Dims = {
+    /** The width of the object */
+    width: number;
+    /** The height of the object */
+    height: number;
+};
+
+/**
+ * Looks up a color palette by ID
+ *
+ * @param colorPaletteId - The ID of the color palette
+ * @returns The color palette, or `undefined` if no palette has the ID
+ */
+export declare function findColorPalette(colorPaletteId: string | undefined): ColorPalette | undefined;
+
+declare type Float16Array = typeof globalThis extends {
+    Float16Array: {
+        prototype: infer TFloat16ArrayPrototype;
+    };
+} ? TFloat16ArrayPrototype : never;
+
+/** Union of all natively supported floating-point typed arrays */
+export declare type FloatArray = Float16Array | Float32Array | Float64Array;
+
+/**
+ * Constants for the three-round xorshift-multiply finalizer {@link HashUtils.fmix32}
+ *
+ * The finalizer computes `h ^= h >>> s1; h *= m1; h ^= h >>> s2; h *= m2;
+ * h ^= h >>> s3` in 32-bit arithmetic. Shifts must lie in `[1, 31]` and
+ * multipliers must be odd for the finalizer to remain a bijection.
+ */
+export declare type Fmix32Config = {
+    /** Right shift of the first xorshift round, in bits */
+    s1: number;
+    /** Odd 32-bit multiplier applied after the first xorshift */
+    m1: number;
+    /** Right shift of the second xorshift round, in bits */
+    s2: number;
+    /** Odd 32-bit multiplier applied after the second xorshift */
+    m2: number;
+    /** Right shift of the final xorshift round, in bits */
+    s3: number;
+};
+
+/** Configuration to load values from a table column */
+export declare type FromConfig<TFromExtra = unknown> = Config<"from"> & {
+    /** Specification of what table column to load */
+    from: TableColumnRef & TFromExtra;
+};
+
+/** Utility methods for rectangle and dimension geometry */
+export declare class GeometryUtils {
+    /**
+     * Computes the union of multiple rectangles and returns the smallest rectangle that contains all of them
+     *
+     * @param rects - The rectangles to compute the union of
+     * @returns The smallest rectangle that contains all the input rectangles, or `null` if no rectangles are provided
+     */
+    static union(...rects: Rect[]): Rect | null;
+    /**
+     * Computes the intersection of two rectangles
+     *
+     * @param a - The first rectangle
+     * @param b - The second rectangle
+     * @returns The rectangle covered by both, or `null` if they do not overlap
+     * (touching edges do not count as overlapping)
+     */
+    static intersection(a: Rect, b: Rect): Rect | null;
+    /**
+     * Grows a rectangle by the same amount on every side
+     *
+     * @param rect - The rectangle to grow
+     * @param amount - The amount to move every side outwards by; negative
+     * amounts shrink the rectangle
+     * @returns The grown rectangle
+     */
+    static dilate(rect: Rect, amount: number): Rect;
+    /**
+     * Checks if two dimensions are equal by comparing their width and height properties
+     *
+     * @param a - The first dimensions to compare
+     * @param b - The second dimensions to compare
+     * @returns `true` if the dimensions are equal, `false` otherwise
+     */
+    static dimsEquals(a: Dims, b: Dims): boolean;
+    /**
+     * Checks if two rectangles are equal by comparing their x, y, width, and height properties
+     *
+     * @param a - The first rectangle to compare
+     * @param b - The second rectangle to compare
+     * @returns `true` if the rectangles are equal, `false` otherwise
+     */
+    static rectEquals(a: Rect, b: Rect): boolean;
+}
+
+/**
+ * Determines the active source of the given {@link Config}
+ *
+ * If a source is explicitly prioritized using {@link Config.source}, that source is returned.
+ *
+ * Otherwise, the active source is determined by checking for the presence of configuration-specific fields in the following order:
+ * - {@link ConstantConfig}
+ * - {@link FromConfig}
+ * - {@link GroupByConfig}
+ * - {@link RandomConfig}
+ *
+ * @param config - The configuration
+ * @returns The active configuration source, or `undefined` if none is active
+ */
+export declare function getActiveConfigSource<TSource extends string>(config: Config<TSource>): TSource | undefined;
+
+/** Configuration to map a categorical table column to values */
+export declare type GroupByConfig<TMapRequired extends boolean, TGroupByExtra = unknown> = Config<"groupBy"> & {
+    /** Specification of what categorical table column to load and how to map groups to values */
+    groupBy: TableColumnRef & {
+        /** Project-global group-to-value map ID */
+        map: TMapRequired extends true ? string : string | undefined;
+    } & TGroupByExtra;
+};
+
+/** A named mapping from string keys (groups) to typed values with an optional default value */
+export declare type GroupValueMap<TValue> = {
+    /** Map ID, referenced from data object configurations */
+    id: string;
+    /** Human-readable map name */
+    name: string;
+    /**
+     * Mapping from group names to values
+     *
+     * Group names are the table cell values as strings, e.g. `"3"` for a numeric
+     * cell.
+     */
+    values: {
+        [key: string]: TValue;
+    };
+    /** Default value for groups not present in {@link values} */
+    default?: TValue;
+};
+
+/**
+ * Utility methods for non-cryptographic hashing
+ *
+ * Hashing a string is split into two steps: {@link hashRaw} reduces the
+ * string to a 32-bit integer, and {@link mix} scrambles that integer together
+ * with a seed. Callers that hash the same key repeatedly with different seeds
+ * can cache the raw hash and only re-run the cheap mixing step. {@link hash}
+ * does both in one call.
+ *
+ * The underlying primitives, {@link fnv1a} and {@link fmix32}, are exposed
+ * for callers that need the plain algorithms without the seeding convention
+ * of the methods above.
+ */
+export declare class HashUtils {
+    private static readonly _murmur3Config;
+    /**
+     * Computes the raw hash of a string
+     *
+     * Currently {@link fnv1a}. The raw hash is fast and deterministic, but only
+     * weakly mixed: similar keys yield correlated hashes, and the hash of an
+     * empty string is non-zero. Pass the result through {@link mix} before
+     * using it to select from a small range.
+     *
+     * @param key - The string to hash; hashed by UTF-16 code unit
+     * @returns The raw hash, as a non-negative 32-bit integer
+     */
+    static hashRaw(key: string): number;
+    /**
+     * Scrambles a 32-bit integer with a seed
+     *
+     * The seed is XOR-ed into the value, which is then passed through
+     * {@link fmix32}. Consecutive inputs map to unrelated outputs, so the result
+     * is suitable for scattering sequential IDs or raw string hashes over a
+     * small range, e.g. `mix(id, seed) % palette.length`. Different seeds yield
+     * different outputs for the same input.
+     *
+     * @param h - The integer to mix; only its lower 32 bits are used
+     * @param seed - The seed; only its lower 32 bits are used
+     * @returns The mixed value, as a non-negative 32-bit integer
+     */
+    static mix(h: number, seed?: number): number;
+    /**
+     * Computes a seeded 32-bit hash of a string
+     *
+     * Equivalent to `mix(hashRaw(key), seed)`.
+     *
+     * @param key - The string to hash; hashed by UTF-16 code unit
+     * @param seed - The seed; only its lower 32 bits are used
+     * @returns The hash, as a non-negative 32-bit integer
+     */
+    static hash(key: string, seed?: number): number;
+    /**
+     * Computes the 32-bit FNV-1a hash of a string
+     *
+     * Iterates over the UTF-16 code units of the string, XOR-ing each into the
+     * running hash and multiplying by the FNV prime. The hash of an empty string
+     * is the FNV offset basis (`0x811c9dc5`). Code units above `0xff` are XOR-ed
+     * in whole rather than byte-wise, so results for non-Latin-1 text differ
+     * from byte-oriented FNV-1a implementations.
+     *
+     * @see http://www.isthe.com/chongo/tech/comp/fnv/
+     * @param str - The string to hash
+     * @returns The hash, as a non-negative 32-bit integer
+     */
+    static fnv1a(str: string): number;
+    /**
+     * Applies a three-round xorshift-multiply finalizer; defaults to MurmurHash3's constants
+     *
+     * The finalizer is a bijective avalanche step: every input bit affects
+     * every output bit, and distinct 32-bit inputs map to distinct outputs.
+     * Note that `fmix32(0)` is `0`.
+     *
+     * @see https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp
+     * @param h - The integer to finalize; only its lower 32 bits are used
+     * @param c - The constants to use; defaults are the MurmurHash3 finalizer constants
+     * @returns The finalized value, as a non-negative 32-bit integer
+     */
+    static fmix32(h: number, c?: Fmix32Config): number;
+}
+
+/** The items of one group of a labels, points or shapes object, highlighted in the viewer */
+export declare type HighlightedItemGroup = {
+    /**
+     * The object whose items are grouped, by the ID of its labels, points or
+     * shapes; IDs are only unique within each of these lists
+     */
+    annotatedObject: {
+        labelsId: string;
+    } | {
+        pointsId: string;
+    } | {
+        shapesId: string;
+    };
+    /** The categorical table column */
+    groupBy: TableColumnRef;
+    /** The group, i.e. the cell value as a string */
+    group: string;
+};
+
+/**
+ * The array types that can hold ID values
+ *
+ * Integer IDs are held by an integer typed array or by 64-bit floats (safe
+ * integers only), string IDs by a plain array.
+ */
+export declare type IDArray = IntOrUintArray | Float64Array | string[];
+
+/** Identity similarity transform */
+export declare const identityTransform: {
+    readonly flip: false;
+    readonly scale: 1;
+    readonly rotation: 0;
+    readonly translation: {
+        readonly x: 0;
+        readonly y: 0;
+    };
+};
+
+/**
+ * A {@link RawImage} with {@link imageDefaults} applied
+ */
+declare type Image_2 = RenderedRasterDataObject<ImageDataSource<string>> & Required<Pick<RawImage, keyof typeof imageDefaults>> & Omit<RawImage, keyof typeof imageDefaults>;
+export { Image_2 as Image }
+
+/**
+ * A channel of a two-dimensional raster image
+ *
+ * Channels are only applied to multi-channel image data, as reported by the
+ * image's data provider.
+ */
+export declare type ImageChannel = {
+    /**
+     * Channel name
+     *
+     * Overrides the channel name provided by the image data provider, if any.
+     *
+     * @defaultValue The name reported by the image data provider, or `undefined`
+     */
+    name?: string;
+    /**
+     * Channel visibility
+     *
+     * Overrides the channel visibility provided by the image data provider, if any.
+     *
+     * @defaultValue The visibility reported by the image data provider, or `true`
+     */
+    visibility?: boolean;
+    /**
+     * Channel opacity, in the range [0, 1]
+     *
+     * Overrides the channel opacity provided by the image data provider, if any.
+     *
+     * @defaultValue The opacity reported by the image data provider, or `1`
+     */
+    opacity?: number;
+    /**
+     * Channel color
+     *
+     * Overrides the channel color provided by the image data provider, if any.
+     *
+     * @defaultValue The color reported by the image data provider, or white for
+     * single-channel image data, or a default color for the channel index
+     * otherwise (see {@link ImageUtils.getDefaultChannelColor})
+     */
+    color?: Color;
+    /**
+     * Channel contrast limits, in the channel's image data value range
+     *
+     * Overrides the channel contrast limits provided by the image data provider, if any.
+     *
+     * @defaultValue The contrast limits reported by the image data provider, or
+     * limits derived from the channel histogram reported by the image data
+     * provider (see {@link ImageUtils.getDefaultContrastLimits}), or the value
+     * range of the channel's data type
+     */
+    contrastLimits?: [number, number];
+};
+
+/** The value histogram of a channel, in raw pixel values */
+export declare type ImageChannelHistogram = {
+    /**
+     * The number of samples per bin, bin `i` of `n` counting the values around
+     * `vmin + i / (n - 1) * (vmax - vmin)` (see
+     * {@link MathUtils.computeHistogram})
+     */
+    hist: number[];
+    /** The values the first and the last bin are centered on, as `[vmin, vmax]` */
+    range: [number, number];
+};
+
+/** A single image channel shown on its own, without touching the project */
+export declare type ImageChannelPreview = {
+    /** The ID of the previewed image */
+    imageId: string;
+    /** The index of the previewed channel (0-based) */
+    channelIndex: number;
+};
+
+/**
+ * How the channels of multi-channel image data are displayed
+ *
+ * - `composite`: all visible channels, blended in their colors
+ * - `grayscale`: the active channel alone, in gray
+ * - `color`: the active channel alone, in its color
+ */
+export declare const ImageChannelViewMode: {
+    readonly composite: "composite";
+    readonly grayscale: "grayscale";
+    readonly color: "color";
+};
+
+/** One of the channel view modes of the {@link ImageChannelViewMode} object */
+export declare type ImageChannelViewMode = (typeof ImageChannelViewMode)[keyof typeof ImageChannelViewMode];
+
+/**
+ * Loaded image data providing one or more OpenSeadragon-compatible tile sources
+ *
+ * Image data is either multi-channel, in which case it provides one tile source
+ * per channel, addressed by channel index; or it is not, in which case it
+ * provides a single tile source that is not addressed by channel.
+ * {@link ImageData.getSizeC} returns `undefined` for image data that is not multi-channel.
+ *
+ * Multi-channel image data that implements {@link RasterData.getTileData}
+ * provides a single sample ("grayscale value") per pixel and channel, which the
+ * renderer contrast-stretches and colorizes (see
+ * {@link ImageData.getChannelContrastLimits} and
+ * {@link ImageData.getChannelColor}). Multi-channel image data that does not
+ * implement it is free to provide grayscale or RGB tile sources per channel,
+ * which are drawn as they are.
+ */
+declare interface ImageData_2 extends RasterData {
+    /** Returns the number of channels in the image, or undefined if not multi-channel */
+    getSizeC(): number | undefined;
+    /**
+     * Returns the tile source of a channel, or the only tile source of image data that is not multi-channel
+     *
+     * @param c - The channel index (0-based), required for multi-channel image
+     * data and to be omitted otherwise
+     * @returns The tile source, which can be a URL string, a TileSourceConfig
+     * object, or a CustomTileSource object
+     * @throws Error if `c` is omitted for multi-channel image data, if `c` is
+     * passed for image data that is not multi-channel, or if `c` is out of bounds
+     */
+    getTileSource(c?: number): string | TileSourceConfig | CustomTileSource;
+    /** Returns the name of a specific channel, or undefined if not available */
+    getChannelName?: (c: number) => string | undefined;
+    /** Returns the visibility of a specific channel, or undefined if not available */
+    getChannelVisibility?: (c: number) => boolean | undefined;
+    /** Returns the opacity of a specific channel, or undefined if not available */
+    getChannelOpacity?: (c: number) => number | undefined;
+    /**
+     * Returns the color of a specific channel, or undefined if not available
+     *
+     * Channels without a color (neither configured on the image nor returned
+     * here) are colorized with a default color derived from the channel index
+     * (see {@link ImageUtils.getDefaultChannelColor}), so that multi-channel image data
+     * without any color information renders as distinguishable channels rather
+     * than as a single white blob; the only channel of single-channel image data
+     * is colorized white instead. Data providers should only return colors that
+     * their image metadata actually specifies, and `undefined` for all other
+     * channels, leaving the choice of default colors to the renderer.
+     *
+     * @param c - The channel index (0-based)
+     * @returns The channel's color, or `undefined` if not available
+     */
+    getChannelColor?: (c: number) => Color | undefined;
+    /**
+     * Returns the value histogram of a specific channel, or undefined if not available
+     *
+     * `hist[i]` counts the channel values that fall into bin `i`, with bins
+     * spread evenly over `range`: the first bin corresponds to the range's lower
+     * bound, the last bin to its upper bound. The histogram may be computed from
+     * a downsampled resolution level. The renderer derives default contrast
+     * limits from the histogram for channels without contrast limits (neither
+     * configured on the image nor returned by
+     * {@link ImageData.getChannelContrastLimits}, see
+     * {@link ImageUtils.getDefaultContrastLimits}). As the renderer calls this on every
+     * synchronization, implementations should return a precomputed histogram
+     * rather than compute one on each call.
+     *
+     * @param c - The channel index (0-based)
+     * @returns The channel's histogram, as bin counts and the value range the
+     * bins span, or `undefined` if not available
+     */
+    getChannelHistogram?: (c: number) => ImageChannelHistogram | undefined;
+    /**
+     * Returns the range the data type of a specific channel can hold, or undefined if not available
+     *
+     * The full range of integer channel data of at most 32 bits, e.g.
+     * `[0, 65535]` for unsigned 16-bit samples. Other channel data has no such
+     * range and returns `undefined`.
+     *
+     * @param c - The channel index (0-based)
+     * @returns The data type range, as `[min, max]`, or `undefined` if not
+     * available
+     */
+    getChannelDataTypeRange?: (c: number) => [number, number] | undefined;
+    /**
+     * Returns the contrast limits of a specific channel, or undefined if not available
+     *
+     * The renderer scales each channel value linearly between the contrast
+     * limits, clamps the result to `[0, 1]` and multiplies it with the channel's
+     * color. Channels without contrast limits (neither configured on the image
+     * nor returned here) are stretched between quantile-based limits derived
+     * from the channel's histogram, if {@link ImageData.getChannelHistogram}
+     * provides one (see {@link ImageUtils.getDefaultContrastLimits}), then over
+     * the data type range declared by {@link ImageData.getChannelDataTypeRange},
+     * and otherwise over the value range that the data type of their channel data
+     * can hold, as returned by {@link ImageUtils.getDataTypeRange} (the full
+     * integer range for integer typed arrays, `[0, 1]` for floating-point typed
+     * arrays).
+     *
+     * @param c - The channel index (0-based)
+     * @returns The channel's contrast limits, in the channel's value range, or
+     * `undefined` if not available
+     */
+    getChannelContrastLimits?: (c: number) => [number, number] | undefined;
+}
+export { ImageData_2 as ImageData }
+
+/**
+ * Data provider for raster images
+ *
+ * @typeParam TImageDataSource - The data source type this data provider opens
+ * @typeParam TImageData - The {@link ImageData} type produced by this data
+ * provider
+ * @typeParam TNormalizedImageDataSource - The normalized data source type
+ * produced by `normalize` and accepted by `load`
+ */
+export declare interface ImageDataProvider<TImageDataSource extends ImageDataSource, TImageData extends ImageData_2, TNormalizedImageDataSource extends TImageDataSource = TImageDataSource> extends DataProvider<TImageDataSource, TImageData, TNormalizedImageDataSource> {
+}
+
+/**
+ * A {@link RawImageDataSource} with {@link imageDataSourceDefaults} applied
+ */
+export declare type ImageDataSource<TType extends string = string> = DataSource<TType> & Required<Pick<RawImageDataSource<TType>, keyof typeof imageDataSourceDefaults>> & Omit<RawImageDataSource<TType>, keyof typeof imageDataSourceDefaults>;
+
+/**
+ * Default values for {@link RawImageDataSource}
+ */
+export declare const imageDataSourceDefaults: {};
+
+/**
+ * Default values for {@link RawImage}
+ */
+export declare const imageDefaults: {
+    readonly channelViewMode: "composite";
+    readonly activeChannel: 0;
+};
+
+/** Utility methods for resolving and defaulting image channel settings */
+export declare class ImageUtils {
+    /**
+     * Returns the color of a channel
+     *
+     * The color configured on the image wins, then the one its data states, and
+     * the only channel of single-channel image data is white, as a grayscale
+     * image rather than in the red the index-based default would give it (see
+     * {@link ImageUtils.getDefaultChannelColor}).
+     *
+     * @param image - The image
+     * @param data - The image data providing the channel
+     * @param c - The channel index (0-based)
+     * @returns The channel's color
+     */
+    static getChannelColor(image: Image_2, data: ImageData_2, c: number): Color;
+    /**
+     * Returns the contrast limits of a channel
+     *
+     * The limits configured on the image win over those its data states.
+     * Channels with neither are stretched between quantile-based limits derived
+     * from their histogram (see {@link ImageUtils.getDefaultContrastLimits}), if
+     * the data provides one, and otherwise over the range the data declares for
+     * their data type.
+     *
+     * @param image - The image
+     * @param data - The image data providing the channel
+     * @param c - The channel index (0-based)
+     * @returns The channel's contrast limits, or `undefined` if the data
+     * provides neither limits, a histogram nor a data type range
+     */
+    static getChannelContrastLimits(image: Image_2, data: ImageData_2, c: number): [number, number] | undefined;
+    /**
+     * Returns the visibility of a channel
+     *
+     * The visibility configured on the image wins over the one its data states,
+     * and channels with neither are visible.
+     *
+     * @param image - The image
+     * @param data - The image data providing the channel
+     * @param c - The channel index (0-based)
+     * @returns Whether the channel is visible
+     */
+    static getChannelVisibility(image: Image_2, data: ImageData_2, c: number): boolean;
+    /**
+     * Returns the opacity of a channel
+     *
+     * The opacity configured on the image wins over the one its data states,
+     * and channels with neither are fully opaque.
+     *
+     * @param image - The image
+     * @param data - The image data providing the channel
+     * @param c - The channel index (0-based)
+     * @returns The channel's opacity, in `[0, 1]`
+     */
+    static getChannelOpacity(image: Image_2, data: ImageData_2, c: number): number;
+    /**
+     * Returns the channel an image shows in the single-channel view modes
+     *
+     * The image's active channel is bounded to the channels the data has, so
+     * that an image kept from data with more channels still shows one.
+     *
+     * @param image - The image
+     * @param sizeC - The number of channels the image data has
+     * @returns The channel index (0-based)
+     */
+    static getActiveChannel(image: Image_2, sizeC: number): number;
+    /**
+     * Returns a default color for a channel, for use when no channel colors are
+     * known
+     *
+     * The first six channels map to red, green, blue, yellow, cyan, and magenta.
+     * Further channels are assigned hues 128 degrees apart, with saturation and
+     * brightness decreasing by 0.05 every ten channels. Channel indices wrap
+     * around after 100, so that saturation and brightness stay above 0.5.
+     * Colors are not guaranteed to be unique.
+     *
+     * Resembles `ImageChannel.getDefaultChannelColor` in QuPath v0.7.0, except
+     * that yellow, cyan, and magenta have been replaced by pure versions (255
+     * for the two highest components, 0 for the lowest), and that QuPath wraps
+     * after 360 channels instead, yielding dim colors and eventually black.
+     *
+     * @param c - The channel index, a non-negative integer
+     * @returns The default color for the channel
+     */
+    static getDefaultChannelColor(c: number): Color;
+    /**
+     * Returns quantile-based contrast limits derived from a channel histogram,
+     * for use as default contrast limits when no contrast limits are known
+     *
+     * The histogram's `hist[i]` counts the values that fall into bin `i`, with
+     * bins spread evenly over `range`: bin `0` maps to the range's lower bound,
+     * the last bin to its upper bound, and each bin in between to
+     * `vmin + i / (n - 1) * (vmax - vmin)` (see
+     * {@link MathUtils.computeHistogram}). The lower limit is the value of the
+     * first bin at which the cumulative count from the bottom reaches the
+     * fraction `qlow` of the total count, the upper limit is the value of the
+     * first bin at which the cumulative count from the top reaches the fraction
+     * `1 - qhigh`; i.e., the fraction `qlow` of the values is clipped at the
+     * bottom and the fraction `1 - qhigh` at the top. Only non-empty bins are
+     * considered, so quantiles of `0` and `1` yield the first and last non-empty
+     * bin, respectively. Values that fall into the same bin cannot be told
+     * apart, so the limits are only as precise as the bins.
+     *
+     * Histograms with fewer than two bins, histograms whose counts sum to zero
+     * and degenerate ranges return `range` as is. So do histograms whose clipped
+     * limits would not be ascending (upper bin at or below lower bin), which
+     * happens if more than `qhigh - qlow` of the values fall into a single bin,
+     * e.g. for sparse channels that are mostly background, or if `qhigh` is
+     * below `qlow`, and a `qlow` above `1`, which no bin can reach.
+     *
+     * @param histogram - The channel histogram, as bin counts and value range
+     * @param qlow - The quantile of the lower limit, in `[0, 1]`
+     * @param qhigh - The quantile of the upper limit, in `[0, 1]`, above `qlow`
+     * @returns The contrast limits, as `[low, high]` in the histogram's value
+     * range, with `low < high` unless the range is degenerate
+     */
+    static getDefaultContrastLimits(histogram: ImageChannelHistogram, qlow?: number, qhigh?: number): [number, number];
+    /**
+     * Returns the value range that an integer type can hold
+     *
+     * @param bits - The number of bits per value, at most 32
+     * @param signed - Whether the type is signed
+     * @returns The value range, as `[min, max]`
+     */
+    static getIntegerTypeRange(bits: number, signed: boolean): [number, number];
+    /**
+     * Returns the value range that the type of the given array can hold, for use
+     * as default contrast limits of image channel data
+     *
+     * Integer typed arrays span their full integer range, floating-point typed
+     * arrays are taken to hold normalized values in `[0, 1]`.
+     *
+     * @param values - The array whose value range to return
+     * @returns The value range, as `[min, max]`
+     */
+    static getDataTypeRange(values: TypedArray): [number, number];
+}
+
+/** Union of all natively supported signed integer typed arrays */
+export declare type IntArray = Int8Array | Int16Array | Int32Array;
+
+/**
+ * Interaction mode, determining how mouse events are interpreted
+ */
+export declare type InteractionMode = "pan" | "drawRectangle" | "drawPolygon" | "drawFreehand";
+
+/** Union of all natively supported integer typed arrays */
+export declare type IntOrUintArray = IntArray | UintArray;
+
+/**
+ * Determines whether the given object is a {@link ConstantConfig}
+ *
+ * @param obj - The object to check
+ * @returns Whether the object is a {@link ConstantConfig}
+ */
+export declare function isConstantConfig<TValue, TConstantExtra = unknown>(obj: unknown): obj is ConstantConfig<TValue, TConstantExtra>;
+
+/**
+ * Determines whether the given object is a {@link FromConfig}
+ *
+ * @param obj - The object to check
+ * @returns Whether the object is a {@link FromConfig}
+ */
+export declare function isFromConfig<TFromExtra = unknown>(obj: unknown): obj is FromConfig<TFromExtra>;
+
+/**
+ * Determines whether the given object is a {@link GroupByConfig}
+ *
+ * @param obj - The object to check
+ * @returns Whether the object is a {@link GroupByConfig}
+ */
+export declare function isGroupByConfig<TMapRequired extends boolean, TGroupByExtra = unknown>(obj: unknown): obj is GroupByConfig<TMapRequired, TGroupByExtra>;
+
+/**
+ * Determines whether the given object is a {@link RandomConfig}
+ *
+ * @param obj - The object to check
+ * @returns Whether the object is a {@link RandomConfig}
+ */
+export declare function isRandomConfig<TRandomExtra = unknown>(obj: unknown): obj is RandomConfig<TRandomExtra>;
+
+/**
+ * A {@link Data} object that contains an indexed collection of items
+ *
+ * Extended by data types whose storage is addressable by item IDs
+ * (e.g. points, shapes, tables).
+ *
+ * Implementations have to be immutable: the values returned by their accessors
+ * must not change over the lifetime of the object, and the arrays they return
+ * have to keep their identity across calls (i.e. be memoized rather than built
+ * anew on every call). Consumers rely on that identity to detect change - a
+ * renderer that compares the previous `getIds()` result against the current one
+ * re-uploads its GPU buffers whenever the two differ - so an implementation
+ * returning a fresh array each time is correct but defeats every such cache.
+ */
+export declare interface ItemsData extends Data {
+    /**
+     * Returns an array of item IDs
+     *
+     * IDs are either integers, held by an integer typed array or by 64-bit
+     * floats (safe integers only), or strings, held by a plain array (see
+     * `IDArray`). The returned array is owned by this data object: callers must
+     * not modify it, and every call returns the very same array (see
+     * {@link ItemsData}). IDs are expected to be unique, which is not checked.
+     *
+     * @returns The item IDs
+     */
+    getIds(): IDArray;
+    /**
+     * Returns the total number of items
+     *
+     * @returns The item count
+     */
+    getSize(): number;
+    /**
+     * Returns the item names if available, otherwise undefined
+     *
+     * Optional: data types that never carry item names need not implement it.
+     *
+     * The returned array is owned by this data object: callers must not modify it,
+     * and every call returns the very same array (see {@link ItemsData}).
+     *
+     * @returns The item names, or `undefined` if not available
+     */
+    getNames?: () => string[] | undefined;
+}
+
+/**
+ * Utility methods for JSON serialization with support for non-finite numbers
+ *
+ * `NaN`, `Infinity` and `-Infinity` are encoded as the sentinel strings
+ * `"__NaN__"`, `"__PositiveInfinity__"` and `"__NegativeInfinity__"`, which
+ * {@link JSONUtils.parse} decodes back into numbers. Strings that happen to
+ * equal a sentinel are therefore not round-trip safe.
+ */
+export declare class JSONUtils {
+    /**
+     * Serializes a value to JSON, encoding non-finite numbers as sentinel strings
+     *
+     * Behaves like `JSON.stringify` without indentation: `toJSON` methods are
+     * honored, and object properties that cannot be represented (`undefined`,
+     * functions, symbols) are omitted.
+     *
+     * It differs from `JSON.stringify` where the latter is lossy: such a value
+     * throws instead of yielding `undefined` when it is the top-level value, and
+     * throws instead of being written as `null` when it is an array element. It
+     * also does not detect circular references, which overflow the stack rather
+     * than throwing a `TypeError`.
+     *
+     * @param value - The value to serialize
+     * @param options - Optional `stable` flag, sorting object keys alphabetically
+     *   so that the output is independent of property insertion order
+     *   (default `false`)
+     * @throws If the value itself, or any array element it contains, cannot be
+     *   represented in JSON
+     */
+    static stringify(value: unknown, options?: {
+        stable?: boolean;
+    }): string;
+    /**
+     * Parses JSON, decoding the sentinel strings written by
+     * {@link JSONUtils.stringify} back into `NaN`, `Infinity` and `-Infinity`
+     *
+     * @param text - The JSON text to parse
+     * @throws If the text is not valid JSON
+     */
+    static parse(text: string): unknown;
+    /** Whether a value can be represented in JSON */
+    private static _isStringifiable;
+    /**
+     * Serializes a single primitive value (or object key) using
+     * `JSON.stringify`, replacing non-finite numbers with sentinel strings
+     *
+     * The replacer reads the raw value from the holder object, because
+     * `JSON.stringify` would otherwise pass the already-converted value (`null`
+     * for non-finite numbers) to the replacer.
+     */
+    private static _stringifyPrimitive;
+}
+
+/**
+ * A {@link RawLabels} with {@link labelsDefaults} applied
+ */
+export declare type Labels = RenderedRasterDataObject<LabelsDataSource<string>> & Required<Pick<RawLabels, keyof typeof labelsDefaults>> & Omit<RawLabels, keyof typeof labelsDefaults>;
+
+/**
+ * Loaded label image data providing a tiled, multi-resolution integer raster
+ *
+ * Each pixel value represents a label (segment) ID. Unlike points and shapes, a
+ * label image does not enumerate its labels: their IDs are only known per
+ * tile, as the tiles are read, so that arbitrarily large label images can be
+ * opened without scanning them.
+ */
+export declare interface LabelsData extends RasterData {
+    /**
+     * Extracts the label IDs of an invalidated tile
+     *
+     * Label images always carry values rather than colors, so unlike for
+     * {@link RasterData.getTileData} this is not optional, and the values are
+     * integers (signed or unsigned, of up to 32 bits).
+     *
+     * @param event - The tile invalidation event
+     * @returns The label IDs of the invalidated tile, one per raster pixel in
+     * row-major order, along with the width and height of the raster in pixels
+     * @throws Error if the event does not contain label image data
+     */
+    getTileData(event: default_2.TileInvalidatedEvent): Promise<{
+        values: IntOrUintArray;
+        width: number;
+        height: number;
+    }>;
+}
+
+/**
+ * Data provider for label images
+ *
+ * @typeParam TLabelsDataSource - The data source type this data provider opens
+ * @typeParam TLabelsData - The {@link LabelsData} type produced by this data
+ * provider
+ * @typeParam TNormalizedLabelsDataSource - The normalized data source type
+ * produced by `normalize` and accepted by `load`
+ */
+export declare interface LabelsDataProvider<TLabelsDataSource extends LabelsDataSource, TLabelsData extends LabelsData, TNormalizedLabelsDataSource extends TLabelsDataSource = TLabelsDataSource> extends AnnotatedDataProvider<TLabelsDataSource, TLabelsData, TNormalizedLabelsDataSource> {
+}
+
+/**
+ * A {@link RawLabelsDataSource} with {@link labelsDataSourceDefaults} applied
+ */
+export declare type LabelsDataSource<TType extends string = string> = AnnotatedDataSource<TType> & Required<Pick<RawLabelsDataSource<TType>, keyof typeof labelsDataSourceDefaults>> & Omit<RawLabelsDataSource<TType>, keyof typeof labelsDataSourceDefaults>;
+
+/**
+ * Default values for {@link RawLabelsDataSource}
+ */
+export declare const labelsDataSourceDefaults: {};
+
+/**
+ * Default values for {@link RawLabels}
+ */
+export declare const labelsDefaults: {
+    readonly labelColor: {
+        readonly random: {
+            readonly palette: "distinct";
+        };
+    };
+    readonly labelVisibility: {
+        readonly constant: {
+            readonly value: true;
+        };
+    };
+    readonly labelOpacity: {
+        readonly constant: {
+            readonly value: 1;
+        };
+    };
+};
+
+/**
+ * A {@link RawLayer} with {@link layerDefaults} applied
+ */
+export declare type Layer = Model & Required<Pick<RawLayer, keyof typeof layerDefaults>> & Omit<RawLayer, keyof typeof layerDefaults>;
+
+/**
+ * Default values for {@link RawLayer}
+ */
+export declare const layerDefaults: {
+    readonly transform: {
+        readonly flip: false;
+        readonly scale: 1;
+        readonly rotation: 0;
+        readonly translation: {
+            readonly x: 0;
+            readonly y: 0;
+        };
+    };
+    readonly visibility: true;
+    readonly opacity: 1;
+    readonly pointSizeFactor: 1;
+};
+
+/** The marker shapes that points can be rendered as */
+export declare const Marker: {
+    readonly Cross: 0;
+    readonly Diamond: 1;
+    readonly Square: 2;
+    readonly TriangleUp: 3;
+    readonly Star: 4;
+    readonly Clobber: 5;
+    readonly Disc: 6;
+    readonly HBar: 7;
+    readonly VBar: 8;
+    readonly TailedArrow: 9;
+    readonly TriangleDown: 10;
+    readonly Ring: 11;
+    readonly X: 12;
+    readonly Arrow: 13;
+    readonly Gaussian: 14;
+};
+
+/** One of the marker shapes of the {@link Marker} object, as its index */
+export declare type Marker = (typeof Marker)[keyof typeof Marker];
+
+/**
+ * Marker configuration
+ *
+ * When sourced from a table column, numerical values are interpreted as
+ * {@link Marker} indices (e.g. `0` = Cross, `6` = Disc).
+ */
+export declare type MarkerConfig = ConstantConfig<Marker> | FromConfig | GroupByConfig<false>;
+
+/** Ordered palette of marker shapes, for distinguishing categorical groups */
+export declare const markerPalette: (0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14)[];
+
+/**
+ * Utility methods for numeric clamping, remapping, alignment, rounding,
+ * medians, histograms and counts
+ */
+export declare class MathUtils {
+    /**
+     * Clamps a value to the range `[min, max]`
+     *
+     * @param value - The value to clamp
+     * @param min - Lower bound
+     * @param max - Upper bound
+     * @returns The clamped value
+     */
+    static clamp(value: number, min: number, max: number): number;
+    /**
+     * Linearly maps a value from one range to another
+     *
+     * Values outside `from` are extrapolated, not clamped; clamp at the call
+     * site where the domain is known. Swapping `from` and `to` yields the
+     * inverse mapping.
+     *
+     * @param value - The value to map
+     * @param from - The source range, as `[min, max]`, with `min !== max`
+     * @param to - The target range, as `[min, max]`
+     * @returns The mapped value
+     * @throws Error if `from` is degenerate
+     */
+    static remap(value: number, from: [number, number], to: [number, number]): number;
+    /**
+     * Aligns a positive number `n` to the next multiple of `m`
+     *
+     * If `n` is already a multiple of `m`, returns `n`.
+     * Otherwise, returns the smallest multiple of `m` that is greater than `n`.
+     *
+     * @param n - The non-negative number to align
+     * @param m - The strictly positive multiple to align to
+     * @returns The aligned number
+     * @throws Error if `n` is negative, or if `m` is not strictly positive
+     */
+    static align(n: number, m: number): number;
+    /**
+     * Rounds a value to the decimal places that a step needs
+     *
+     * Steps of `1` or more round to whole numbers, `0.1` to one decimal place,
+     * `0.05` to two. Stepping through a range adds floating-point noise that this
+     * rounds away, e.g. `0.30000000000000004` becomes `0.3` for a step of `0.1`.
+     *
+     * @param value - The value to round
+     * @param step - The strictly positive step
+     * @returns The rounded value
+     * @throws Error if `step` is not strictly positive
+     */
+    static roundToStepDecimals(value: number, step: number): number;
+    /**
+     * Computes the weighted median of numeric values
+     *
+     * Returns the smallest value whose cumulative weight, in ascending order of
+     * the values, reaches half the total weight. If the total weight is zero,
+     * all values are weighted equally instead.
+     *
+     * @param values - The non-empty values to compute the weighted median of
+     * @param weights - The non-negative weight of each value
+     * @returns The weighted median
+     * @throws Error if `values` is empty, or if `weights` has a different length
+     */
+    static computeWeightedMedian(values: TypedArray, weights: TypedArray): number;
+    /**
+     * Computes the range of numeric values, as their minimum and maximum
+     *
+     * Non-finite values (`NaN`, infinities) are ignored. If no finite value is
+     * found (e.g. for empty arrays), the empty range `[Infinity, -Infinity]` is
+     * returned; callers can detect it by checking that the lower bound exceeds
+     * the upper bound.
+     *
+     * The values are traversed on the main thread, yielding to the event loop
+     * periodically so the UI stays responsive for large arrays (see
+     * {@link AsyncUtils.forEach}). Aborting the signal rejects with its reason.
+     *
+     * @param values - The values to compute the range of
+     * @param options - Optional abort signal
+     * @returns A promise that resolves to the range, as `[min, max]`
+     */
+    static computeRange(values: TypedArray, options?: {
+        signal?: AbortSignal;
+    }): Promise<[number, number]>;
+    /**
+     * Computes the histogram of numeric values over a given value range
+     *
+     * `hist[i]` counts the values that are closest to bin `i`, with bins spread
+     * evenly over `range`: bin `0` maps to the range's lower bound, the last bin
+     * to its upper bound, and each bin in between to `vmin + i / (bins - 1) *
+     * (vmax - vmin)`. Values outside the range are counted in the nearest edge
+     * bin, non-finite values (`NaN`, infinities) are ignored. If the range is
+     * degenerate (upper bound not above lower bound), or if `bins` is `1`, all
+     * values fall into bin `0`.
+     *
+     * If `sample` is positive and smaller than the number of values, the
+     * histogram is estimated from `sample` values drawn uniformly with
+     * replacement, using the seeded generator of
+     * {@link RandomUtils.createUint32RNG}; the counts then sum to `sample`
+     * (minus ignored non-finite values) rather than to the number of values.
+     * Sampling is deterministic for a given `seed`. Otherwise, every value is
+     * counted exactly once.
+     *
+     * The values are traversed on the main thread, yielding to the event loop
+     * periodically so the UI stays responsive for large arrays (see
+     * {@link AsyncUtils.forEach}). Aborting the signal rejects with its reason.
+     *
+     * @param values - The values to compute the histogram of
+     * @param range - The value range the bins span, as `[min, max]`
+     * @param options - Optional abort signal (`signal`), number of bins
+     *   (`bins`, a positive integer, defaults to `1024`), number of values to
+     *   sample (`sample`; omitting it, `0`, or at least the number of values
+     *   disables sampling), and seed for sampling (`seed`, defaults to `0`)
+     * @returns A promise that resolves to the histogram, as bin counts (`hist`)
+     * and the given value range (`range`)
+     */
+    static computeHistogram(values: TypedArray, range: [number, number], options?: {
+        signal?: AbortSignal;
+        bins?: number;
+        sample?: number;
+        seed?: number;
+    }): Promise<{
+        hist: number[];
+        range: [number, number];
+    }>;
+    /**
+     * Redistributes the counts of a histogram over equal bins of another range
+     *
+     * The new bins split `range` into `bins` equal intervals, the upper bound
+     * counting in the last one. Each bin of `histogram` is counted in the new bin
+     * that its value falls into (see {@link computeHistogram}), or dropped if
+     * its value is outside `range`. If `range` is degenerate (upper bound not
+     * above lower bound), all counts fall into bin `0`.
+     *
+     * @param histogram - The histogram to redistribute, as bin counts (`hist`)
+     * and the value range they span (`range`)
+     * @param range - The value range the new bins span, as `[min, max]`
+     * @param bins - The number of new bins, a positive integer
+     * @returns The redistributed histogram, as the counts of the new bins
+     * (`hist`) and the given value range (`range`)
+     */
+    static rebinHistogram(histogram: {
+        hist: number[];
+        range: [number, number];
+    }, range: [number, number], bins: number): {
+        hist: number[];
+        range: [number, number];
+    };
+    /**
+     * Counts the number of occurrences of every distinct value
+     *
+     * The counts are keyed by value, in the order the values first occur.
+     * Distinctness follows `Map` key equality, i.e. `NaN` counts as one value
+     * and `0` and `-0` as the same one.
+     *
+     * The values are traversed on the main thread, yielding to the event loop
+     * periodically so the UI stays responsive for large arrays (see
+     * {@link AsyncUtils.forEach}). Aborting the signal rejects with its reason.
+     *
+     * @typeParam T - Element type of the values
+     * @param values - The values to count
+     * @param options - Optional abort signal
+     * @returns A promise that resolves to the count of every distinct value, in
+     * the order the values first appear
+     */
+    static computeUniqueValueCounts<T>(values: TypedArrayOrArray<T>, options?: {
+        signal?: AbortSignal;
+    }): Promise<Map<T, number>>;
+}
+
+/**
+ * A {@link RawModel} with {@link modelDefaults} applied
+ */
+export declare type Model = object & Required<Pick<RawModel, keyof typeof modelDefaults>> & Omit<RawModel, keyof typeof modelDefaults>;
+
+/**
+ * Default values for {@link RawModel}
+ */
+export declare const modelDefaults: {};
+
+/** A geometry consisting of one or more {@link Polygon}s */
+export declare type MultiPolygon = {
+    /** The individual polygons that make up this multi-polygon */
+    polygons: Polygon[];
+};
+
+/**
+ * Utility methods for coercing untrusted values to numbers
+ *
+ * Numbers, bigints and non-blank strings are accepted; everything else, and
+ * everything that does not coerce to a finite number, is rejected. The
+ * `tryParse*` methods report rejection by returning `undefined`, the `parse*`
+ * methods by throwing.
+ */
+export declare class NumberUtils {
+    private static readonly _minSafeBigInt;
+    private static readonly _maxSafeBigInt;
+    /**
+     * Parses a value as a finite number
+     *
+     * @param value - The value to parse
+     * @returns The parsed number
+     * @throws Error if the value is not a finite number
+     */
+    static parseFinite(value: unknown): number;
+    /**
+     * Parses a value as a safe integer
+     *
+     * @param value - The value to parse
+     * @returns The parsed integer
+     * @throws Error if the value is not a safe integer
+     */
+    static parseSafeInt(value: unknown): number;
+    /**
+     * Parses a value as a finite number, without throwing
+     *
+     * A bigint outside of the safe integer range loses precision when converted:
+     * by default this is only warned about, `requireSafeBigInt` rejects it.
+     *
+     * @param value - The value to parse
+     * @param options - Set `requireSafeBigInt` to reject bigints that are outside
+     * of the safe integer range, rather than converting them with a warning
+     * @returns The parsed number, or `undefined` if the value is not a finite
+     * number
+     */
+    static tryParseFinite(value: unknown, options?: {
+        requireSafeBigInt?: boolean;
+    }): number | undefined;
+    /**
+     * Parses a value as a safe integer, without throwing
+     *
+     * @param value - The value to parse
+     * @returns The parsed integer, or `undefined` if the value is not a safe
+     * integer
+     */
+    static tryParseSafeInt(value: unknown): number | undefined;
+}
+
+/**
+ * Opacity configuration
+ *
+ * Numerical table values are interpreted as opacities between `0` (fully transparent) and `1` (fully opaque).
+ */
+export declare type OpacityConfig = ConstantConfig<number> | FromConfig | GroupByConfig<true>;
+
+/**
+ * OpenSeadragon options, as consumed by the `OpenSeadragonContext` of
+ * `@tissuumaps/render`
+ *
+ * @see https://openseadragon.github.io/docs/OpenSeadragon.html#.Options
+ */
+export declare type OpenSeadragonOptions = {
+    /** Options applied to the viewer and its tiled images */
+    viewerOptions: OpenSeadragonViewerOptions;
+    /** Options applied while the viewer is animating */
+    viewerAnimationStartOptions: OpenSeadragonViewerOptions;
+    /**
+     * Options applied once the viewer stopped animating, on top of the restored
+     * pre-animation values
+     */
+    viewerAnimationFinishOptions: OpenSeadragonViewerOptions;
+};
+
+/**
+ * OpenSeadragon viewer options, without options requiring a DOM element reference
+ *
+ * Viewer options may originate from a serialized project, which cannot carry DOM
+ * element references. Options taking an element are therefore either narrowed to
+ * an element ID or disallowed. In addition, `element` is omitted, as the viewer
+ * sets it to its own container element (which takes precedence over
+ * OpenSeadragon's `id` option), and `compositeOperation` is omitted, as viewer
+ * options are applied to every tiled image in the world, which would overwrite
+ * the composite operations that the renderers set per tiled image.
+ */
+export declare type OpenSeadragonViewerOptions = Omit<default_2.Options, "element" | "compositeOperation"> & {
+    /** Unsupported, use `navigatorId` instead */
+    navigatorElement?: never;
+    /** Element ID of the toolbar container */
+    toolbar?: string;
+    /** Element ID of the zoom-in button */
+    zoomInButton?: string;
+    /** Element ID of the zoom-out button */
+    zoomOutButton?: string;
+    /** Element ID of the home (reset zoom) button */
+    homeButton?: string;
+    /** Element ID of the full-page toggle button */
+    fullPageButton?: string;
+    /** Element ID of the rotate-left button */
+    rotateLeftButton?: string;
+    /** Element ID of the rotate-right button */
+    rotateRightButton?: string;
+    /** Element ID of the previous-page button */
+    previousButton?: string;
+    /** Element ID of the next-page button */
+    nextButton?: string;
+    /** Unsupported */
+    referenceStripElement?: never;
+};
+
+/** An ordered sequence of vertices forming an open or closed path */
+export declare type Path = Vertex[];
+
+/**
+ * A plugin that can be registered with the application
+ *
+ * A plugin's lifecycle is `setup`, `mount`, `unmount`, `teardown`: registering
+ * the plugin calls {@link setup} and then {@link mount}, and unregistering it
+ * calls the callback returned by `mount` and then the callback returned by
+ * `setup`. All four steps are optional.
+ */
+declare type Plugin_2 = {
+    /** The unique ID of the plugin */
+    id: string;
+    /** The human-readable name of the plugin */
+    name: string;
+    /**
+     * Sets up the plugin and registers any necessary event listeners or other resources
+     *
+     * Called first when the plugin is registered. A plugin whose `setup` throws is
+     * not registered, and the teardown callback is not called: releasing whatever
+     * `setup` had already acquired before it throws is `setup`'s own
+     * responsibility.
+     *
+     * A plugin that only contributes a user interface does not need a `setup`:
+     * its {@link mount} receives the same stores.
+     *
+     * @param stores - The stores provided by the application for the plugin to interact with
+     * @returns A teardown callback that unregisters the event listeners and
+     * releases the other resources again, if any. It is called last when the
+     * plugin is unregistered, after the user interface has been unmounted, and
+     * only for a plugin that was registered successfully.
+     */
+    setup?: (stores: PluginStores) => (() => void) | void;
+    /**
+     * Mounts the plugin's user interface, if any
+     *
+     * A plugin with a `mount` is shown as a panel titled with the plugin's
+     * {@link name}, for exactly as long as the plugin is registered. Closing the
+     * panel unregisters the plugin; a plugin without a `mount` can only be
+     * unregistered through the registry.
+     *
+     * Called once {@link setup} has returned successfully, with an empty element
+     * owned by the application. The element is not part of the document yet: the
+     * application attaches it to the panel once that is shown, and keeps the user
+     * interface mounted while the panel is hidden behind other tabs or moved.
+     * A plugin whose `mount` throws is not registered, and the teardown callback
+     * returned by `setup` is called.
+     *
+     * The container is discarded together with the plugin, so the returned
+     * callback only has to release what is not plain DOM, such as store
+     * subscriptions, listeners on `window`, or a React root.
+     *
+     * @param container - The element to mount the user interface into
+     * @param stores - The stores provided by the application for the plugin to interact with
+     * @returns An unmount callback that unmounts the user interface again, if
+     * any. It is called first when the plugin is unregistered, before the
+     * teardown callback returned by {@link setup}.
+     */
+    mount?: (container: HTMLElement, stores: PluginStores) => (() => void) | void;
+};
+export { Plugin_2 as Plugin }
+
+/**
+ * The registry through which the application registers and unregisters plugins
+ */
+export declare type PluginRegistry = {
+    /**
+     * Registers a plugin, calling its `setup` and then its `mount`, if it has them
+     *
+     * Registering a plugin whose ID is already in use unregisters the previously
+     * registered plugin first.
+     *
+     * @param plugin - The plugin to register
+     */
+    registerPlugin: (plugin: Plugin_2) => void;
+    /**
+     * Unregisters a registered plugin, calling the unmount callback returned by
+     * its `mount` and then the teardown callback returned by its `setup`
+     *
+     * @param pluginId - The ID of the plugin to unregister
+     */
+    unregisterPlugin: (pluginId: string) => void;
+};
+
+/**
+ * The stores provided by the application for a plugin to interact with
+ */
+export declare type PluginStores = {
+    appStore: AppStoreApi;
+    dataStore: DataStoreApi;
+    projectStore: ProjectStoreApi;
+    settingsStore: SettingsStoreApi;
+};
+
+/**
+ * A {@link RawPoints} object with {@link pointsDefaults} applied
+ */
+export declare type Points = RenderedItemsDataObject<PointsDataSource<string>> & Required<Pick<RawPoints, keyof typeof pointsDefaults>> & Omit<RawPoints, keyof typeof pointsDefaults>;
+
+/**
+ * Loaded point cloud data providing coordinate access
+ */
+export declare interface PointsData extends ItemsData {
+    /**
+     * Loads the geometry for all points
+     *
+     * @param options - Optional abort signal and progress callback
+     * @returns A promise that resolves to the loaded points geometry
+     */
+    loadGeometry(options?: {
+        signal?: AbortSignal;
+        onProgress?: ProgressCallback;
+    }): Promise<PointsGeometry>;
+}
+
+/**
+ * Data provider for point clouds
+ *
+ * @typeParam TPointsDataSource - The data source type this data provider opens
+ * @typeParam TPointsData - The {@link PointsData} type produced by this data
+ * provider
+ * @typeParam TNormalizedPointsDataSource - The normalized data source type
+ * produced by `normalize` and accepted by `load`
+ */
+export declare interface PointsDataProvider<TPointsDataSource extends PointsDataSource, TPointsData extends PointsData, TNormalizedPointsDataSource extends TPointsDataSource = TPointsDataSource> extends AnnotatedDataProvider<TPointsDataSource, TPointsData, TNormalizedPointsDataSource> {
+}
+
+/**
+ * A {@link RawPointsDataSource} with {@link pointsDataSourceDefaults} applied
+ */
+export declare type PointsDataSource<TType extends string = string> = AnnotatedDataSource<TType> & Required<Pick<RawPointsDataSource<TType>, keyof typeof pointsDataSourceDefaults>> & Omit<RawPointsDataSource<TType>, keyof typeof pointsDataSourceDefaults>;
+
+/**
+ * Default values for {@link RawPointsDataSource}
+ */
+export declare const pointsDataSourceDefaults: {};
+
+/**
+ * Default values for {@link RawPoints}
+ */
+export declare const pointsDefaults: {
+    readonly pointMarker: {
+        readonly constant: {
+            readonly value: 6;
+        };
+    };
+    readonly pointSize: {
+        readonly constant: {
+            readonly value: 1;
+        };
+    };
+    readonly pointColor: {
+        readonly constant: {
+            readonly value: {
+                readonly r: 255;
+                readonly g: 255;
+                readonly b: 255;
+            };
+        };
+    };
+    readonly pointVisibility: {
+        readonly constant: {
+            readonly value: true;
+        };
+    };
+    readonly pointOpacity: {
+        readonly constant: {
+            readonly value: 1;
+        };
+    };
+    readonly pointSizeFactor: 1;
+};
+
+/** Point cloud geometry consisting of separate arrays for x and y coordinates */
+export declare type PointsGeometry = {
+    /** X coordinates of the points */
+    xs: Float32Array;
+    /** Y coordinates of the points */
+    ys: Float32Array;
+};
+
+/** A polygon defined by an outer shell and zero or more interior holes */
+export declare type Polygon = {
+    /** The outer boundary of the polygon */
+    shell: Path;
+    /** Interior rings that are subtracted from the polygon area */
+    holes: Path[];
+};
+
+/**
+ * A callback function that receives progress updates
+ *
+ * @param progress - The current progress value in the range [0, total]
+ * @param total - The total amount of work to be done
+ */
+export declare type ProgressCallback = (progress: number, total: number) => void;
+
+/**
+ * A {@link RawProject} with {@link projectDefaults} applied
+ */
+export declare type Project = Model & Required<Pick<RawProject, keyof typeof projectDefaults>> & Omit<RawProject, keyof typeof projectDefaults | ("layers" | "images" | "labels" | "points" | "shapes" | "tables")> & {
+    layers: Layer[];
+    images: Image_2[];
+    labels: Labels[];
+    points: Points[];
+    shapes: Shapes[];
+    tables: Table[];
+};
+
+/**
+ * Default values for {@link RawProject}
+ */
+export declare const projectDefaults: {
+    readonly markerMaps: [];
+    readonly sizeMaps: [];
+    readonly colorMaps: [];
+    readonly visibilityMaps: [];
+    readonly opacityMaps: [];
+    readonly osOptions: {
+        readonly viewerOptions: {
+            readonly minZoomImageRatio: 0;
+            readonly maxZoomPixelRatio: number;
+            readonly preserveImageSizeOnResize: true;
+            readonly visibilityRatio: 0;
+            readonly animationTime: 0;
+            readonly gestureSettingsMouse: {
+                readonly flickEnabled: false;
+            };
+            readonly gestureSettingsTouch: {
+                readonly flickEnabled: false;
+            };
+            readonly gestureSettingsPen: {
+                readonly flickEnabled: false;
+            };
+            readonly gestureSettingsUnknown: {
+                readonly flickEnabled: false;
+            };
+            readonly zoomPerClick: 1;
+            readonly showNavigator: true;
+            readonly navigatorPosition: "BOTTOM_LEFT";
+            readonly maxImageCacheCount: 2000;
+            readonly showNavigationControl: false;
+            readonly imageSmoothingEnabled: false;
+        };
+        readonly viewerAnimationStartOptions: {
+            readonly immediateRender: false;
+            readonly imageLoaderLimit: 1;
+        };
+        readonly viewerAnimationFinishOptions: {
+            readonly immediateRender: true;
+        };
+    };
+    readonly glOptions: {
+        readonly pointsRenderOptions: {
+            readonly globalPointSizeFactor: 1;
+        };
+        readonly shapesRenderOptions: {
+            readonly strokeWidth: 1;
+            readonly edgesPerScanline: 8;
+            readonly binWidthFactor: 1;
+            readonly shapePadding: 0.2;
+        };
+    };
+    readonly viewerBackgroundColor: {
+        readonly r: 0;
+        readonly g: 0;
+        readonly b: 0;
+    };
+};
+
+/**
+ * The project store, i.e. its state and actions
+ */
+export declare type ProjectStore = ProjectStoreState & ProjectStoreActions;
+
+/**
+ * The actions of the project store
+ *
+ * Every collection of the project - its layers, images, labels, points, shapes
+ * and tables - is manipulated through the same five families of actions:
+ * `add*` inserts an object, `update*` overwrites some of its properties,
+ * `move*` reorders it, `delete*` removes it, and `clear*` empties the whole
+ * collection. Objects are addressed by their ID, and their order within a
+ * collection is meaningful: it is the order in which they are listed and
+ * rendered.
+ *
+ * Adding an object whose ID is already taken, referring to one that is not
+ * part of the project, or passing an index outside of a collection's bounds is
+ * an error.
+ *
+ * The lists of maps are not reordered, so they have no `move*` actions.
+ */
+export declare type ProjectStoreActions = {
+    /**
+     * Renames the project
+     *
+     * @param name - The new project name
+     */
+    setName: (name: string) => void;
+    /**
+     * Adds a layer to the project
+     *
+     * @param layer - The layer to add
+     * @param index - The index to insert at, defaulting to the end of the
+     * collection
+     */
+    addLayer: (layer: Layer, index?: number) => void;
+    /**
+     * Adds an image to the project
+     *
+     * @param image - The image to add
+     * @param index - The index to insert at, defaulting to the end of the
+     * collection
+     */
+    addImage: (image: Image_2, index?: number) => void;
+    /**
+     * Adds labels to the project
+     *
+     * @param labels - The labels to add
+     * @param index - The index to insert at, defaulting to the end of the
+     * collection
+     */
+    addLabels: (labels: Labels, index?: number) => void;
+    /**
+     * Adds points to the project
+     *
+     * @param points - The points to add
+     * @param index - The index to insert at, defaulting to the end of the
+     * collection
+     */
+    addPoints: (points: Points, index?: number) => void;
+    /**
+     * Adds shapes to the project
+     *
+     * @param shapes - The shapes to add
+     * @param index - The index to insert at, defaulting to the end of the
+     * collection
+     */
+    addShapes: (shapes: Shapes, index?: number) => void;
+    /**
+     * Adds a table to the project
+     *
+     * @param table - The table to add
+     * @param index - The index to insert at, defaulting to the end of the
+     * collection
+     */
+    addTable: (table: Table, index?: number) => void;
+    /**
+     * Adds a marker map to the project
+     *
+     * @param map - The map to add
+     */
+    addMarkerMap: (map: GroupValueMap<Marker>) => void;
+    /**
+     * Adds a size map to the project
+     *
+     * @param map - The map to add
+     */
+    addSizeMap: (map: GroupValueMap<number>) => void;
+    /**
+     * Adds a color map to the project
+     *
+     * @param map - The map to add
+     */
+    addColorMap: (map: GroupValueMap<Color>) => void;
+    /**
+     * Adds a visibility map to the project
+     *
+     * @param map - The map to add
+     */
+    addVisibilityMap: (map: GroupValueMap<boolean>) => void;
+    /**
+     * Adds an opacity map to the project
+     *
+     * @param map - The map to add
+     */
+    addOpacityMap: (map: GroupValueMap<number>) => void;
+    /**
+     * Applies updates to a layer of the project
+     *
+     * @param layerId - The ID of the layer to update
+     * @param updates - The properties to overwrite on the layer
+     */
+    updateLayer: (layerId: string, updates: Partial<Omit<Layer, "id">>) => void;
+    /**
+     * Applies updates to an image of the project
+     *
+     * @param imageId - The ID of the image to update
+     * @param updates - The properties to overwrite on the image
+     */
+    updateImage: (imageId: string, updates: Partial<Omit<Image_2, "id">>) => void;
+    /**
+     * Applies updates to labels of the project
+     *
+     * @param labelsId - The ID of the labels to update
+     * @param updates - The properties to overwrite on the labels
+     */
+    updateLabels: (labelsId: string, updates: Partial<Omit<Labels, "id">>) => void;
+    /**
+     * Applies updates to points of the project
+     *
+     * @param pointsId - The ID of the points to update
+     * @param updates - The properties to overwrite on the points
+     */
+    updatePoints: (pointsId: string, updates: Partial<Omit<Points, "id">>) => void;
+    /**
+     * Applies updates to shapes of the project
+     *
+     * @param shapesId - The ID of the shapes to update
+     * @param updates - The properties to overwrite on the shapes
+     */
+    updateShapes: (shapesId: string, updates: Partial<Omit<Shapes, "id">>) => void;
+    /**
+     * Applies updates to a table of the project
+     *
+     * @param tableId - The ID of the table to update
+     * @param updates - The properties to overwrite on the table
+     */
+    updateTable: (tableId: string, updates: Partial<Omit<Table, "id">>) => void;
+    /**
+     * Applies updates to a marker map of the project
+     *
+     * @param mapId - The ID of the map to update
+     * @param updates - The properties to overwrite on the map
+     */
+    updateMarkerMap: (mapId: string, updates: Partial<Omit<GroupValueMap<Marker>, "id">>) => void;
+    /**
+     * Applies updates to a size map of the project
+     *
+     * @param mapId - The ID of the map to update
+     * @param updates - The properties to overwrite on the map
+     */
+    updateSizeMap: (mapId: string, updates: Partial<Omit<GroupValueMap<number>, "id">>) => void;
+    /**
+     * Applies updates to a color map of the project
+     *
+     * @param mapId - The ID of the map to update
+     * @param updates - The properties to overwrite on the map
+     */
+    updateColorMap: (mapId: string, updates: Partial<Omit<GroupValueMap<Color>, "id">>) => void;
+    /**
+     * Applies updates to a visibility map of the project
+     *
+     * @param mapId - The ID of the map to update
+     * @param updates - The properties to overwrite on the map
+     */
+    updateVisibilityMap: (mapId: string, updates: Partial<Omit<GroupValueMap<boolean>, "id">>) => void;
+    /**
+     * Applies updates to an opacity map of the project
+     *
+     * @param mapId - The ID of the map to update
+     * @param updates - The properties to overwrite on the map
+     */
+    updateOpacityMap: (mapId: string, updates: Partial<Omit<GroupValueMap<number>, "id">>) => void;
+    /**
+     * Moves a layer of the project to another index
+     *
+     * @param layerId - The ID of the layer to move
+     * @param newIndex - The index to move the layer to
+     */
+    moveLayer: (layerId: string, newIndex: number) => void;
+    /**
+     * Moves an image of the project to another index
+     *
+     * @param imageId - The ID of the image to move
+     * @param newIndex - The index to move the image to
+     */
+    moveImage: (imageId: string, newIndex: number) => void;
+    /**
+     * Moves labels of the project to another index
+     *
+     * @param labelsId - The ID of the labels to move
+     * @param newIndex - The index to move the labels to
+     */
+    moveLabels: (labelsId: string, newIndex: number) => void;
+    /**
+     * Moves points of the project to another index
+     *
+     * @param pointsId - The ID of the points to move
+     * @param newIndex - The index to move the points to
+     */
+    movePoints: (pointsId: string, newIndex: number) => void;
+    /**
+     * Moves shapes of the project to another index
+     *
+     * @param shapesId - The ID of the shapes to move
+     * @param newIndex - The index to move the shapes to
+     */
+    moveShapes: (shapesId: string, newIndex: number) => void;
+    /**
+     * Removes a layer from the project
+     *
+     * @param layerId - The ID of the layer to remove
+     */
+    deleteLayer: (layerId: string) => void;
+    /**
+     * Removes an image from the project
+     *
+     * @param imageId - The ID of the image to remove
+     */
+    deleteImage: (imageId: string) => void;
+    /**
+     * Removes labels from the project
+     *
+     * @param labelsId - The ID of the labels to remove
+     */
+    deleteLabels: (labelsId: string) => void;
+    /**
+     * Removes points from the project
+     *
+     * @param pointsId - The ID of the points to remove
+     */
+    deletePoints: (pointsId: string) => void;
+    /**
+     * Removes shapes from the project
+     *
+     * @param shapesId - The ID of the shapes to remove
+     */
+    deleteShapes: (shapesId: string) => void;
+    /**
+     * Removes a table from the project
+     *
+     * @param tableId - The ID of the table to remove
+     */
+    deleteTable: (tableId: string) => void;
+    /**
+     * Removes a marker map from the project
+     *
+     * @param mapId - The ID of the map to remove
+     */
+    deleteMarkerMap: (mapId: string) => void;
+    /**
+     * Removes a size map from the project
+     *
+     * @param mapId - The ID of the map to remove
+     */
+    deleteSizeMap: (mapId: string) => void;
+    /**
+     * Removes a color map from the project
+     *
+     * @param mapId - The ID of the map to remove
+     */
+    deleteColorMap: (mapId: string) => void;
+    /**
+     * Removes a visibility map from the project
+     *
+     * @param mapId - The ID of the map to remove
+     */
+    deleteVisibilityMap: (mapId: string) => void;
+    /**
+     * Removes an opacity map from the project
+     *
+     * @param mapId - The ID of the map to remove
+     */
+    deleteOpacityMap: (mapId: string) => void;
+    /**
+     * Removes all layers from the project
+     */
+    clearLayers: () => void;
+    /**
+     * Removes all images from the project
+     */
+    clearImages: () => void;
+    /**
+     * Removes all labels from the project
+     */
+    clearLabels: () => void;
+    /**
+     * Removes all points from the project
+     */
+    clearPoints: () => void;
+    /**
+     * Removes all shapes from the project
+     */
+    clearShapes: () => void;
+    /**
+     * Removes all tables from the project
+     */
+    clearTables: () => void;
+    /**
+     * Removes all marker maps from the project
+     */
+    clearMarkerMaps: () => void;
+    /**
+     * Removes all size maps from the project
+     */
+    clearSizeMaps: () => void;
+    /**
+     * Removes all color maps from the project
+     */
+    clearColorMaps: () => void;
+    /**
+     * Removes all visibility maps from the project
+     */
+    clearVisibilityMaps: () => void;
+    /**
+     * Removes all opacity maps from the project
+     */
+    clearOpacityMaps: () => void;
+    /**
+     * Sets the project's OpenSeadragon viewer options
+     *
+     * @param osOptions - The OpenSeadragon options to apply
+     */
+    setOSOptions: (osOptions: Project["osOptions"]) => void;
+    /**
+     * Sets the project's WebGL render options
+     *
+     * @param glOptions - The WebGL options to apply
+     */
+    setGLOptions: (glOptions: Project["glOptions"]) => void;
+    /**
+     * Sets the project's viewer background color
+     *
+     * @param viewerBackgroundColor - The viewer background color to apply
+     */
+    setViewerBackgroundColor: (viewerBackgroundColor: Project["viewerBackgroundColor"]) => void;
+    /**
+     * Replaces the project with a new, empty one
+     */
+    clear: () => void;
+};
+
+/**
+ * The API through which the project store is read, written and subscribed to
+ */
+export declare type ProjectStoreApi = Mutate<StoreApi<ProjectStore>, [
+["zustand/immer", never]
+]>;
+
+/**
+ * The state of the project store, i.e. the currently open {@link Project}
+ *
+ * In addition to the project itself, the store keeps track of where the
+ * project was loaded from, which is what project-relative paths in its data
+ * sources are resolved against, and of an ID identifying the open project as
+ * such. Both
+ * describe how the project was opened rather than what it contains, so they are
+ * not part of {@link Project} and are not to be saved, serialized or exported
+ * with it.
+ */
+export declare type ProjectStoreState = Project & {
+    /**
+     * Where the open project was loaded from: its absolute URL, the
+     * workspace-relative path of the project file, or `null` if it was loaded
+     * from neither
+     */
+    source: string | null;
+    /**
+     * Identifies the open project regardless of its content: a fresh ID is
+     * generated whenever a project is loaded or the store is cleared, so that a
+     * new project can be told apart from edits to the open one
+     */
+    instanceId: string;
+};
+
+/** Utility methods for projects */
+export declare class ProjectUtils {
+    /**
+     * Returns whether a project has any data objects
+     *
+     * @param project - The project, or only its data objects
+     * @returns `true` if the project has images, labels, points, shapes or tables
+     */
+    static hasData(project: Pick<Project, "images" | "labels" | "points" | "shapes" | "tables">): boolean;
+    /**
+     * Returns the marker configurations of a project's points
+     *
+     * @param project - The project, or only its labels, points and shapes
+     * @returns The marker configurations
+     */
+    static getMarkerConfigs(project: Pick<Project, "labels" | "points" | "shapes">): MarkerConfig[];
+    /**
+     * Returns the size configurations of a project's points
+     *
+     * @param project - The project, or only its labels, points and shapes
+     * @returns The size configurations
+     */
+    static getSizeConfigs(project: Pick<Project, "labels" | "points" | "shapes">): SizeConfig[];
+    /**
+     * Returns the color configurations of a project's labels, points and shapes
+     *
+     * @param project - The project, or only its labels, points and shapes
+     * @returns The color configurations, including the fill and stroke colors of
+     * shapes
+     */
+    static getColorConfigs(project: Pick<Project, "labels" | "points" | "shapes">): ColorConfig[];
+    /**
+     * Returns the visibility configurations of a project's labels, points and
+     * shapes
+     *
+     * @param project - The project, or only its labels, points and shapes
+     * @returns The visibility configurations, including the shape, fill and
+     * stroke visibilities of shapes
+     */
+    static getVisibilityConfigs(project: Pick<Project, "labels" | "points" | "shapes">): VisibilityConfig[];
+    /**
+     * Returns the opacity configurations of a project's labels, points and shapes
+     *
+     * @param project - The project, or only its labels, points and shapes
+     * @returns The opacity configurations, including the shape, fill and stroke
+     * opacities of shapes
+     */
+    static getOpacityConfigs(project: Pick<Project, "labels" | "points" | "shapes">): OpacityConfig[];
+}
+
+/** Configuration to use random values */
+export declare type RandomConfig<TRandomExtra = unknown> = Config<"random"> & {
+    /** Specification of random value generation */
+    random: {
+        /**
+         * The seed for the random number generator
+         *
+         * Values are drawn deterministically from the item ID and the seed, so
+         * different seeds yield different assignments for the same items.
+         *
+         * @defaultValue {@link defaultRandomSeed}
+         */
+        seed?: number;
+    } & TRandomExtra;
+};
+
+/**
+ * Utility methods for seeded, non-cryptographic pseudo-random numbers
+ *
+ * All methods except {@link seed} are deterministic: the same seed always
+ * yields the same sequence, so callers can store a seed instead of the values
+ * it produced (e.g. for reproducible random colors). None of the generators
+ * are suitable for security-sensitive purposes.
+ *
+ * {@link createUint32RNG} returns a generator that draws one 32-bit integer
+ * per call; {@link toUnitFloat32} maps such a draw to `[0, 1)`. The scalar
+ * `rand*` methods take the first draw of a fresh generator, and the
+ * `rand*Array` methods write consecutive draws of a fresh generator into a
+ * typed array. Because they all consume the same stream,
+ * `randUint32Array(n, seed)` starts with `randUint32(seed)`, and a longer
+ * array has the shorter one as a prefix.
+ *
+ * Every `rand*` method takes either a seed or a generator as `seedOrRng`. A
+ * seed creates a fresh generator; passing a generator draws from it instead,
+ * which allows continuing one stream across several calls.
+ *
+ * The underlying generator, {@link splitmix32}, is exposed for callers that
+ * need the plain algorithm regardless of the current default.
+ */
+export declare class RandomUtils {
+    private static readonly _splitmix32Config;
+    /**
+     * Draws a random seed from `Math.random()`
+     *
+     * This is the one non-deterministic method of this class; use it to obtain
+     * a seed for the other methods when reproducibility is not required, e.g.
+     * for a "shuffle" action. The result is stored rather than the values it
+     * produces, so the draw can be reproduced later.
+     *
+     * @returns A uniformly distributed non-negative 32-bit integer
+     */
+    static seed(): number;
+    /**
+     * Creates a seeded generator of 32-bit integers
+     *
+     * Currently {@link splitmix32}. Each call to the returned function yields
+     * the next value of the stream.
+     *
+     * @param seed - The seed; only its lower 32 bits are used
+     * @returns A function that returns the next non-negative 32-bit integer
+     */
+    static createUint32RNG(seed?: number): () => number;
+    /**
+     * Draws a 32-bit integer
+     *
+     * Given a seed, returns the first value of a fresh generator for it, i.e.
+     * `createUint32RNG(seed)()`. Note that this is a pure function of the seed:
+     * calling it repeatedly with the same seed returns the same value. Given a
+     * generator, returns its next value instead.
+     *
+     * @param seedOrRng - The seed (only its lower 32 bits are used), or the
+     * generator to draw from
+     * @returns A non-negative 32-bit integer
+     */
+    static randUint32(seedOrRng?: number | (() => number)): number;
+    /**
+     * Draws consecutive 32-bit integers into an array
+     *
+     * Given a seed, values come from a fresh generator for it, so the first
+     * element equals `randUint32(seed)`. Given a generator, its next `n` values
+     * are drawn instead, e.g. to continue one stream across several arrays. By
+     * default, a new array of length `n` is allocated; pass `array` to fill the
+     * first `n` elements of an existing array in place instead, leaving any
+     * further elements untouched.
+     *
+     * @param n - The number of values to draw, a non-negative integer
+     * @param seedOrRng - The seed (only its lower 32 bits are used), or the
+     * generator to draw from
+     * @param array - The array to fill; defaults to `new Uint32Array(n)`
+     * @returns The filled array, i.e. `array` if given
+     * @throws RangeError if `array` is given and holds fewer than `n` elements
+     */
+    static randUint32Array(n: number, seedOrRng?: number | (() => number), array?: Uint32Array): Uint32Array;
+    /**
+     * Maps a 32-bit integer to a float in `[0, 1)` that is exact in `float32`
+     *
+     * Uses the upper 24 bits of the integer, so the result is a multiple of
+     * `2^-24` and survives storage in a `Float32Array` without rounding. The
+     * largest possible result is `1 - 2^-24`; the lower 8 bits of the input are
+     * discarded.
+     *
+     * @param uint32 - The integer to map; only its lower 32 bits are used
+     * @returns A float in `[0, 1)`
+     */
+    static toUnitFloat32(uint32: number): number;
+    /**
+     * Draws a float in `[0, 1)` that is exact in `float32`
+     *
+     * Equivalent to `toUnitFloat32(randUint32(seedOrRng))`. Given a seed, this
+     * is a pure function of it: calling it repeatedly with the same seed returns
+     * the same value. Given a generator, its next value is drawn instead.
+     *
+     * @param seedOrRng - The seed (only its lower 32 bits are used), or the
+     * generator to draw from
+     * @returns A float in `[0, 1)`, exact in `float32`
+     */
+    static randUnitFloat32(seedOrRng?: number | (() => number)): number;
+    /**
+     * Draws consecutive floats in `[0, 1)` into an array
+     *
+     * Each element is `toUnitFloat32` of the corresponding element that
+     * {@link randUint32Array} would produce for the same arguments, and is
+     * stored in the `Float32Array` without rounding. Given a seed, values come
+     * from a fresh generator for it, so the first element equals
+     * `randUnitFloat32(seed)`. Given a generator, its next `n` values are drawn
+     * instead, e.g. to continue one stream across several arrays. By default, a
+     * new array of length `n` is allocated; pass `array` to fill the first `n`
+     * elements of an existing array in place instead, leaving any further
+     * elements untouched.
+     *
+     * @param n - The number of values to draw, a non-negative integer
+     * @param seedOrRng - The seed (only its lower 32 bits are used), or the
+     * generator to draw from
+     * @param array - The array to fill; defaults to `new Float32Array(n)`
+     * @returns The filled array, i.e. `array` if given
+     * @throws RangeError if `array` is given and holds fewer than `n` elements
+     */
+    static randUnitFloat32Array(n: number, seedOrRng?: number | (() => number), array?: Float32Array): Float32Array;
+    /**
+     * Creates a SplitMix32 generator
+     *
+     * The state is a 32-bit counter advanced by the golden-ratio constant
+     * `0x9e3779b9` (a Weyl sequence); each output is the state passed through
+     * {@link HashUtils.fmix32} with the SplitMix32 constants. Since the
+     * finalizer is a bijection, the stream has a period of `2^32` and visits
+     * every 32-bit value exactly once per period. All seeds walk the same
+     * cycle; seeds that differ in their lower 32 bits start at different points.
+     *
+     * @see https://github.com/bryc/code/blob/master/jshash/PRNGs.md#splitmix32
+     * @param seed - The seed; only its lower 32 bits are used
+     * @returns A function that returns the next non-negative 32-bit integer
+     */
+    static splitmix32(seed?: number): () => number;
+    /**
+     * Resolves a seed or generator to a generator
+     *
+     * @param seedOrRng - A seed, or an existing generator
+     * @returns A fresh generator for the seed, or the given generator
+     */
+    private static _toRNG;
+}
+
+/**
+ * A {@link Data} object that provides a tiled, multi-resolution raster
+ *
+ * Extended by data types that are drawn as OpenSeadragon tiled images (e.g.
+ * images, labels).
+ */
+export declare interface RasterData extends Data {
+    /**
+     * Returns the tile source of this raster
+     *
+     * Data types providing more than one tile source (see `ImageData`) extend
+     * this to address them.
+     *
+     * @returns The tile source, which can be a URL string, a TileSourceConfig
+     * object, or a CustomTileSource object
+     */
+    getTileSource(): string | TileSourceConfig | CustomTileSource;
+    /**
+     * Extracts the raw values of an invalidated tile
+     *
+     * Provided by raster data whose tiles carry values rather than colors (e.g.
+     * label IDs, or one sample per pixel of an image channel), which the renderer
+     * recolors through a data transfer; raster data whose tiles are drawn as they
+     * are does not provide it. The tile in `event` already belongs to one of this
+     * raster's tile sources, which identifies the channel for multi-channel data.
+     *
+     * The raster does not need to be cropped to the tile's source bounds: it may
+     * cover the full tile size, as the renderer crops it when drawing.
+     *
+     * @param event - The tile invalidation event
+     * @returns The values of the invalidated tile, one per raster pixel in
+     * row-major order, along with the width and height of the raster in pixels
+     * @throws Error if the event does not contain raster data
+     */
+    getTileData?: (event: default_2.TileInvalidatedEvent) => Promise<{
+        values: TypedArray;
+        width: number;
+        height: number;
+    }>;
+}
+
+/**
+ * A data source for rendered data objects whose items can be annotated by a
+ * referenced table (e.g. labels, points, shapes)
+ */
+export declare interface RawAnnotatedDataSource<TType extends string = string> extends RawDataSource<TType> {
+    /** ID of the table holding the per-item annotations of this data source, if any */
+    table?: string;
+}
+
+/**
+ * A named, identifiable data object backed by a data source
+ */
+export declare interface RawDataObject<TRawDataSource extends RawDataSource<string>> extends RawModel {
+    /** Data object ID */
+    id: string;
+    /** Human-readable data object name */
+    name: string;
+    /** Data source */
+    dataSource: TRawDataSource;
+}
+
+/**
+ * A data source for data objects
+ */
+export declare interface RawDataSource<TType extends string = string> extends RawModel {
+    /**
+     * Data source type
+     */
+    type: TType;
+    /**
+     * Where the data is loaded from: a URL, an app-relative path (`//` prefix),
+     * a workspace-relative path (`/` prefix), or a project-relative path (no
+     * prefix); see `SourceUtils` for the syntax and how paths are resolved
+     */
+    source?: string;
+}
+
+/**
+ * A two-dimensional raster image
+ */
+export declare interface RawImage extends RawRenderedRasterDataObject<RawImageDataSource<string>> {
+    /**
+     * The channels of the image, indexed by channel
+     *
+     * Channels beyond the end of the array, and channels of images whose data is
+     * not multi-channel, use the default values of {@link ImageChannel}.
+     */
+    channels?: ImageChannel[];
+    /**
+     * How the channels are displayed
+     *
+     * In the single-channel modes, only {@link RawImage.activeChannel} is shown,
+     * whatever the visibility of the channels; the channel colors are kept, and
+     * ignored in grayscale.
+     *
+     * @defaultValue {@link imageDefaults.channelViewMode}
+     */
+    channelViewMode?: ImageChannelViewMode;
+    /**
+     * The channel shown in the single-channel view modes (0-based)
+     *
+     * @defaultValue {@link imageDefaults.activeChannel}
+     */
+    activeChannel?: number;
+}
+
+/**
+ * A data source for two-dimensional raster images
+ */
+export declare interface RawImageDataSource<TType extends string = string> extends RawDataSource<TType> {
+}
+
+/**
+ * A two-dimensional label mask
+ */
+export declare interface RawLabels extends RawRenderedRasterDataObject<RawLabelsDataSource<string>> {
+    /**
+     * Label color
+     *
+     * @defaultValue {@link labelsDefaults.labelColor}
+     */
+    labelColor?: ColorConfig;
+    /**
+     * Label visibility
+     *
+     * @defaultValue {@link labelsDefaults.labelVisibility}
+     */
+    labelVisibility?: VisibilityConfig;
+    /**
+     * Label opacity
+     *
+     * @defaultValue {@link labelsDefaults.labelOpacity}
+     */
+    labelOpacity?: OpacityConfig;
+}
+
+/**
+ * A data source for two-dimensional label masks
+ */
+export declare interface RawLabelsDataSource<TType extends string = string> extends RawAnnotatedDataSource<TType> {
+}
+
+/**
+ * A named collection of rendered data objects sharing the same (e.g. physical) coordinate system
+ */
+export declare interface RawLayer extends RawModel {
+    /**
+     * Layer ID
+     */
+    id: string;
+    /**
+     * Human-readable layer name
+     */
+    name: string;
+    /**
+     * Transformation from layer space to world space
+     *
+     * @defaultValue {@link layerDefaults.transform}
+     */
+    transform?: SimilarityTransform;
+    /**
+     * Layer visibility
+     *
+     * @defaultValue {@link layerDefaults.visibility}
+     */
+    visibility?: boolean;
+    /**
+     * Layer opacity, in the range [0, 1]
+     *
+     * @defaultValue {@link layerDefaults.opacity}
+     */
+    opacity?: number;
+    /**
+     * Layer-level point size scaling factor
+     *
+     * A unitless scaling factor by which the size of every point rendered on this
+     * layer is multiplied, for adjusting point sizes per layer.
+     *
+     * Point sizes are also affected by the project-global
+     * {@link WebGLPointsRenderOptions.globalPointSizeFactor} and by the
+     * {@link RawPoints}-specific size settings.
+     *
+     * @defaultValue {@link layerDefaults.pointSizeFactor}
+     */
+    pointSizeFactor?: number;
+}
+
+/**
+ * Base interface for all model types in a TissUUmaps project
+ */
+export declare interface RawModel {
+}
+
+/**
+ * A two-dimensional point cloud
+ */
+export declare interface RawPoints extends RawRenderedItemsDataObject<RawPointsDataSource<string>> {
+    /**
+     * Point marker
+     *
+     * @defaultValue {@link pointsDefaults.pointMarker}
+     */
+    pointMarker?: MarkerConfig;
+    /**
+     * Point size
+     *
+     * @defaultValue {@link pointsDefaults.pointSize}
+     */
+    pointSize?: SizeConfig;
+    /**
+     * Point color
+     *
+     * @defaultValue {@link pointsDefaults.pointColor}
+     */
+    pointColor?: ColorConfig;
+    /**
+     * Point visibility
+     *
+     * @defaultValue {@link pointsDefaults.pointVisibility}
+     */
+    pointVisibility?: VisibilityConfig;
+    /**
+     * Point opacity
+     *
+     * @defaultValue {@link pointsDefaults.pointOpacity}
+     */
+    pointOpacity?: OpacityConfig;
+    /**
+     * Object-level point size scaling factor
+     *
+     * A unitless scaling factor by which the size of every point of this object is
+     * multiplied, for adjusting point sizes without touching the individual point
+     * sizes or their unit.
+     *
+     * Point sizes are also affected by {@link RawLayer.pointSizeFactor} and by the
+     * project-global {@link WebGLPointsRenderOptions.globalPointSizeFactor}.
+     *
+     * @defaultValue {@link pointsDefaults.pointSizeFactor}
+     */
+    pointSizeFactor?: number;
+}
+
+/**
+ * A data source for two-dimensional point clouds
+ */
+export declare interface RawPointsDataSource<TType extends string = string> extends RawAnnotatedDataSource<TType> {
+}
+
+/**
+ * A TissUUmaps project
+ *
+ * Top-level container that assembles layers, data objects (images, labels,
+ * points, shapes), tables, group-to-value maps, and viewer/render options
+ * into a single serializable configuration.
+ */
+export declare interface RawProject extends RawModel {
+    /**
+     * Project name
+     */
+    name: string;
+    /**
+     * Layers
+     */
+    layers?: RawLayer[];
+    /**
+     * Images
+     */
+    images?: RawImage[];
+    /**
+     * Labels
+     */
+    labels?: RawLabels[];
+    /**
+     * Points
+     */
+    points?: RawPoints[];
+    /**
+     * Shapes
+     */
+    shapes?: RawShapes[];
+    /**
+     * Tables
+     */
+    tables?: RawTable[];
+    /**
+     * Project-global marker maps, referenced by {@link GroupByConfig} marker configurations
+     *
+     * Map IDs are unique within this list; the other lists of maps may reuse them.
+     *
+     * @defaultValue {@link projectDefaults.markerMaps}
+     */
+    markerMaps?: GroupValueMap<Marker>[];
+    /**
+     * Project-global size maps, referenced by {@link GroupByConfig} size configurations
+     *
+     * Map IDs are unique within this list; the other lists of maps may reuse them.
+     *
+     * @defaultValue {@link projectDefaults.sizeMaps}
+     */
+    sizeMaps?: GroupValueMap<number>[];
+    /**
+     * Project-global color maps, referenced by {@link GroupByConfig} color configurations
+     *
+     * Map IDs are unique within this list; the other lists of maps may reuse them.
+     *
+     * @defaultValue {@link projectDefaults.colorMaps}
+     */
+    colorMaps?: GroupValueMap<Color>[];
+    /**
+     * Project-global visibility maps, referenced by {@link GroupByConfig} visibility configurations
+     *
+     * Map IDs are unique within this list; the other lists of maps may reuse them.
+     *
+     * @defaultValue {@link projectDefaults.visibilityMaps}
+     */
+    visibilityMaps?: GroupValueMap<boolean>[];
+    /**
+     * Project-global opacity maps, referenced by {@link GroupByConfig} opacity configurations
+     *
+     * Map IDs are unique within this list; the other lists of maps may reuse them.
+     *
+     * @defaultValue {@link projectDefaults.opacityMaps}
+     */
+    opacityMaps?: GroupValueMap<number>[];
+    /**
+     * OpenSeadragon viewer options for images/labels
+     *
+     * @defaultValue {@link projectDefaults.osOptions}
+     * @see https://openseadragon.github.io/docs/OpenSeadragon.html#.Options
+     */
+    osOptions?: OpenSeadragonOptions;
+    /**
+     * WebGL render options for points/shapes
+     *
+     * @defaultValue {@link projectDefaults.glOptions}
+     */
+    glOptions?: WebGLOptions;
+    /**
+     * Color of the viewer background, behind all rendered content
+     *
+     * @defaultValue {@link projectDefaults.viewerBackgroundColor}
+     */
+    viewerBackgroundColor?: Color;
+}
+
+/**
+ * A data object that is rendered
+ *
+ * Which layer(s) a rendered data object is drawn on depends on its kind of
+ * data (see {@link RawRenderedRasterDataObject} and
+ * {@link RawRenderedItemsDataObject}).
+ */
+export declare interface RawRenderedDataObject<TRawDataSource extends RawDataSource<string>> extends RawDataObject<TRawDataSource> {
+    /**
+     * Data object visibility
+     *
+     * @defaultValue {@link renderedDataObjectDefaults.visibility}
+     */
+    visibility?: boolean;
+    /**
+     * Data object opacity, in the range [0, 1]
+     *
+     * @defaultValue {@link renderedDataObjectDefaults.opacity}
+     */
+    opacity?: number;
+    /**
+     * Transformation from data object space to layer space
+     *
+     * @defaultValue {@link renderedDataObjectDefaults.transform}
+     */
+    transform?: SimilarityTransform;
+}
+
+/**
+ * A rendered data object whose data consists of items (e.g. points, shapes)
+ *
+ * Items can be distributed across layers, so the layer may be given per item.
+ * Tables consist of items as well, but are not rendered, and hence are plain
+ * {@link RawDataObject}s.
+ */
+export declare interface RawRenderedItemsDataObject<TRawDataSource extends RawDataSource<string>> extends RawRenderedDataObject<TRawDataSource> {
+    /**
+     * Layer ID
+     *
+     * Can be specified as:
+     * - An ID of an existing Layer
+     * - A table column holding the layer ID values for each item, of the
+     *   object's own table unless it names another
+     */
+    layer: string | TableColumnRef;
+}
+
+/**
+ * A rendered data object whose data is a raster (e.g. images, labels)
+ *
+ * A raster cannot be split between layers, so it is drawn on a single layer.
+ */
+export declare interface RawRenderedRasterDataObject<TRawDataSource extends RawDataSource<string>> extends RawRenderedDataObject<TRawDataSource> {
+    /** Layer ID */
+    layer: string;
+}
+
+/**
+ * A two-dimensional shape cloud
+ */
+export declare interface RawShapes extends RawRenderedItemsDataObject<RawShapesDataSource<string>> {
+    /**
+     * Shape visibility
+     *
+     * Applies to both the fill and the stroke of a shape, on top of
+     * {@link shapeFillVisibility} and {@link shapeStrokeVisibility}.
+     *
+     * @defaultValue {@link shapesDefaults.shapeVisibility}
+     */
+    shapeVisibility?: VisibilityConfig;
+    /**
+     * Shape opacity
+     *
+     * Multiplies {@link shapeFillOpacity} and {@link shapeStrokeOpacity}.
+     *
+     * @defaultValue {@link shapesDefaults.shapeOpacity}
+     */
+    shapeOpacity?: OpacityConfig;
+    /**
+     * Shape fill color
+     *
+     * @defaultValue {@link shapesDefaults.shapeFillColor}
+     */
+    shapeFillColor?: ColorConfig;
+    /**
+     * Shape fill visibility
+     *
+     * @defaultValue {@link shapesDefaults.shapeFillVisibility}
+     */
+    shapeFillVisibility?: VisibilityConfig;
+    /**
+     * Shape fill opacity
+     *
+     * @defaultValue {@link shapesDefaults.shapeFillOpacity}
+     */
+    shapeFillOpacity?: OpacityConfig;
+    /**
+     * Shape stroke color
+     *
+     * @defaultValue {@link shapesDefaults.shapeStrokeColor}
+     */
+    shapeStrokeColor?: ColorConfig;
+    /**
+     * Shape stroke visibility
+     *
+     * @defaultValue {@link shapesDefaults.shapeStrokeVisibility}
+     */
+    shapeStrokeVisibility?: VisibilityConfig;
+    /**
+     * Shape stroke opacity
+     *
+     * @defaultValue {@link shapesDefaults.shapeStrokeOpacity}
+     */
+    shapeStrokeOpacity?: OpacityConfig;
+}
+
+/**
+ * A data source for two-dimensional shape clouds
+ */
+export declare interface RawShapesDataSource<TType extends string = string> extends RawAnnotatedDataSource<TType> {
+}
+
+/**
+ * Tabular data
+ */
+export declare interface RawTable extends RawDataObject<RawTableDataSource<string>> {
+}
+
+/**
+ * A data source for tabular data
+ */
+export declare interface RawTableDataSource<TType extends string = string> extends RawDataSource<TType> {
+}
+
+/** An axis-aligned rectangle defined by its top-left corner and dimensions */
+export declare type Rect = {
+    /** X coordinate of the top-left corner */
+    x: number;
+    /** Y coordinate of the top-left corner */
+    y: number;
+    /** Width of the rectangle */
+    width: number;
+    /** Height of the rectangle */
+    height: number;
+};
+
+/**
+ * A {@link RawRenderedDataObject} with {@link renderedDataObjectDefaults} applied
+ */
+export declare type RenderedDataObject<TDataSource extends DataSource<string>> = DataObject<TDataSource> & Required<Pick<RawRenderedDataObject<TDataSource>, keyof typeof renderedDataObjectDefaults>> & Omit<RawRenderedDataObject<TDataSource>, keyof typeof renderedDataObjectDefaults>;
+
+/**
+ * Default values for {@link RawRenderedDataObject}
+ */
+export declare const renderedDataObjectDefaults: {
+    readonly visibility: true;
+    readonly opacity: 1;
+    readonly transform: {
+        readonly flip: false;
+        readonly scale: 1;
+        readonly rotation: 0;
+        readonly translation: {
+            readonly x: 0;
+            readonly y: 0;
+        };
+    };
+};
+
+/**
+ * A {@link RawRenderedItemsDataObject} with {@link renderedItemsDataObjectDefaults} applied
+ */
+export declare type RenderedItemsDataObject<TDataSource extends DataSource<string>> = RenderedDataObject<TDataSource> & Required<Pick<RawRenderedItemsDataObject<TDataSource>, keyof typeof renderedItemsDataObjectDefaults>> & Omit<RawRenderedItemsDataObject<TDataSource>, keyof typeof renderedItemsDataObjectDefaults>;
+
+/**
+ * Default values for {@link RawRenderedItemsDataObject}
+ */
+export declare const renderedItemsDataObjectDefaults: {};
+
+/**
+ * A {@link RawRenderedRasterDataObject} with {@link renderedRasterDataObjectDefaults} applied
+ */
+export declare type RenderedRasterDataObject<TDataSource extends DataSource<string>> = RenderedDataObject<TDataSource> & Required<Pick<RawRenderedRasterDataObject<TDataSource>, keyof typeof renderedRasterDataObjectDefaults>> & Omit<RawRenderedRasterDataObject<TDataSource>, keyof typeof renderedRasterDataObjectDefaults>;
+
+/**
+ * Default values for {@link RawRenderedRasterDataObject}
+ */
+export declare const renderedRasterDataObjectDefaults: {};
+
+/**
+ * The settings store, i.e. its state and actions
+ */
+export declare type SettingsStore = SettingsStoreState & SettingsStoreActions;
+
+/**
+ * The actions of the settings store
+ */
+export declare type SettingsStoreActions = {
+    /**
+     * Switches the user interface between light and dark mode
+     *
+     * @param dark - Whether to show the user interface in dark mode
+     */
+    setDark: (dark: boolean) => void;
+};
+
+/**
+ * The API through which the settings store is read, written and subscribed to
+ */
+export declare type SettingsStoreApi = Mutate<StoreApi<SettingsStore>, [
+["zustand/immer", never]
+]>;
+
+/**
+ * The state of the settings store, holding the user's application settings
+ */
+export declare type SettingsStoreState = {
+    /** Whether the user interface is shown in dark mode */
+    dark: boolean;
+};
+
+/**
+ * A {@link RawShapes} object with {@link shapesDefaults} applied
+ */
+export declare type Shapes = RenderedItemsDataObject<ShapesDataSource<string>> & Required<Pick<RawShapes, keyof typeof shapesDefaults>> & Omit<RawShapes, keyof typeof shapesDefaults>;
+
+/**
+ * Loaded shape collection data providing geometry access
+ */
+export declare interface ShapesData extends ItemsData {
+    /**
+     * Loads the geometry for all shapes
+     *
+     * @param options - Optional abort signal and progress callback
+     * @returns A promise that resolves to the loaded shapes geometry
+     */
+    loadGeometry(options?: {
+        signal?: AbortSignal;
+        onProgress?: ProgressCallback;
+    }): Promise<ShapesGeometry>;
+}
+
+/**
+ * Data provider for shape (polygon) collections
+ *
+ * @typeParam TShapesDataSource - The data source type this data provider opens
+ * @typeParam TShapesData - The {@link ShapesData} type produced by this data
+ * provider
+ * @typeParam TNormalizedShapesDataSource - The normalized data source type
+ * produced by `normalize` and accepted by `load`
+ */
+export declare interface ShapesDataProvider<TShapesDataSource extends ShapesDataSource, TShapesData extends ShapesData, TNormalizedShapesDataSource extends TShapesDataSource = TShapesDataSource> extends AnnotatedDataProvider<TShapesDataSource, TShapesData, TNormalizedShapesDataSource> {
+}
+
+/**
+ * A {@link RawShapesDataSource} with {@link shapesDataSourceDefaults} applied
+ */
+export declare type ShapesDataSource<TType extends string = string> = AnnotatedDataSource<TType> & Required<Pick<RawShapesDataSource<TType>, keyof typeof shapesDataSourceDefaults>> & Omit<RawShapesDataSource<TType>, keyof typeof shapesDataSourceDefaults>;
+
+/**
+ * Default values for {@link RawShapesDataSource}
+ */
+export declare const shapesDataSourceDefaults: {};
+
+/**
+ * Default values for {@link RawShapes}
+ */
+export declare const shapesDefaults: {
+    readonly shapeVisibility: {
+        readonly constant: {
+            readonly value: true;
+        };
+    };
+    readonly shapeOpacity: {
+        readonly constant: {
+            readonly value: 1;
+        };
+    };
+    readonly shapeFillColor: {
+        readonly constant: {
+            readonly value: {
+                readonly r: 255;
+                readonly g: 255;
+                readonly b: 255;
+            };
+        };
+    };
+    readonly shapeFillVisibility: {
+        readonly constant: {
+            readonly value: true;
+        };
+    };
+    readonly shapeFillOpacity: {
+        readonly constant: {
+            readonly value: 1;
+        };
+    };
+    readonly shapeStrokeColor: {
+        readonly constant: {
+            readonly value: {
+                readonly r: 0;
+                readonly g: 0;
+                readonly b: 0;
+            };
+        };
+    };
+    readonly shapeStrokeVisibility: {
+        readonly constant: {
+            readonly value: true;
+        };
+    };
+    readonly shapeStrokeOpacity: {
+        readonly constant: {
+            readonly value: 1;
+        };
+    };
+};
+
+/**
+ * Geometry for shapes (multi-polygons) stored in CSR-style format
+ *
+ * Shapes are organized in a shapes -> polygons -> rings -> vertices structure,
+ * using CSR-style offset arrays to define the relationships between these elements.
+ * Typed arrays are used for efficient storage and transfer across worker boundaries.
+ *
+ * - Shape `s` owns polygons `[shapePolygonOffsets[s], shapePolygonOffsets[s+1])`
+ * - Polygon `p` owns rings `[polygonRingOffsets[p], polygonRingOffsets[p+1])`
+ * - Ring `r` owns vertices `[ringVertexOffsets[r], ringVertexOffsets[r+1])`
+ * - Vertex `v` has coordinates at `coords[2*v]` (x) and `coords[2*v + 1]` (y)
+ */
+export declare type ShapesGeometry = {
+    /**
+     * Shape --> polygon offsets
+     *
+     * Length: number of shapes + 1 (last entry is total polygon count)
+     *
+     * One entry per shape (multi-polygon), giving the starting polygon index for each shape.
+     */
+    shapePolygonOffsets: Uint32Array;
+    /**
+     * Polygon --> ring offsets
+     *
+     * Length: number of polygons + 1 (last entry is total ring count)
+     *
+     * One entry per polygon, giving the starting ring index for each polygon; the first ring is the shell, and any subsequent rings are holes.
+     */
+    polygonRingOffsets: Uint32Array;
+    /**
+     * Ring --> vertex offsets
+     *
+     * Length: number of rings + 1 (last entry is total vertex count)
+     *
+     * One entry per ring, giving the starting vertex index for each ring; the last vertex of a ring is implicitly connected to the first vertex.
+     */
+    ringVertexOffsets: Uint32Array;
+    /**
+     * Vertex coordinates
+     *
+     * Length: 2 * number of vertices
+     *
+     * Two entries per vertex, giving the x and y coordinates of each vertex; the coordinates of vertex i are at indices 2*i and 2*i + 1 (interleaved).
+     */
+    coords: Float32Array;
+};
+
+/** Similarity transform (uniform scale, rotation, translation, and flip) */
+export declare type SimilarityTransform = {
+    /** Horizontal reflection, applied before scaling, rotation, and translation */
+    flip: boolean;
+    /** Uniform scale factor (1 = no scaling) */
+    scale: number;
+    /** Rotation around origin, in degrees */
+    rotation: number;
+    /** Translation in X and Y, applied after scaling and rotation */
+    translation: {
+        x: number;
+        y: number;
+    };
+};
+
+/**
+ * Size configuration
+ *
+ * When sourced from a table column, numerical values are interpreted as sizes
+ * in the specified {@link CoordinateSpace} unit.
+ */
+export declare type SizeConfig = ConstantConfig<number, {
+    /** Coordinate space in which the size values are specified */
+    unit?: CoordinateSpace;
+}> | FromConfig<{
+    /** Coordinate space in which the size values are specified */
+    unit?: CoordinateSpace;
+}> | GroupByConfig<true, {
+    /** Coordinate space in which the size values are specified */
+    unit?: CoordinateSpace;
+}>;
+
+/**
+ * Utility methods for resolving the `source` of data sources to URLs or file
+ * system handles
+ *
+ * A source is one of the following, tried in this order:
+ *
+ * 1. A URL with a scheme (e.g. `https://…`, `blob:…`, `data:…`), which is
+ *    normalized and returned as is.
+ * 2. An app-relative path, prefixed with `//`, resolved against the base URL
+ *    of the application (e.g. `//data/points.csv`).
+ * 3. A workspace-relative path, prefixed with `/`, resolved to a file or
+ *    directory within the open workspace (e.g. `/data/points.csv`). Without an
+ *    open workspace it falls back to being app-relative.
+ * 4. A project-relative path, without prefix, resolved against where the
+ *    project was loaded from: a URL, or a workspace-relative path (e.g.
+ *    `points.csv`, `./points.csv`, `../shared/points.csv`). Without a project
+ *    source it falls back to being workspace-relative. Whenever it resolves to
+ *    a workspace-relative path - against a workspace-relative project source,
+ *    or through that fallback - it falls back further to being app-relative if
+ *    no workspace is open.
+ *
+ * Resolution happens in two steps:
+ *
+ * 1. {@link SourceUtils.normalizeSource} classifies the source, applies the
+ *    fallbacks and normalizes it, synchronously and without touching the file
+ *    system. The result is either an absolute URL or a workspace-relative
+ *    path. Sources referring to the same data normalize to the same string,
+ *    and normalizing a normalized source yields it unchanged.
+ * 2. {@link SourceUtils.resolveSource} opens the file or directory that a
+ *    normalized workspace-relative path refers to;
+ *    {@link SourceUtils.resolveSourceFile} and
+ *    {@link SourceUtils.resolveSourceDirectory} accept only one of the two,
+ *    and {@link SourceUtils.openSourceFile} also opens the file.
+ *    URLs need no such step and are returned as is.
+ *
+ * Paths use `/` as separator and may contain `.` and `..` segments. Resolving
+ * against a URL follows URL semantics: `..` segments beyond the root of the
+ * URL's path are dropped silently. Resolving within the workspace collapses the
+ * segments and fails if the path leaves the workspace.
+ *
+ * A relative path whose first segment contains a colon (e.g.
+ * `sample1:ch2.tif`) is taken for a URL; write it as `./sample1:ch2.tif`
+ * instead.
+ */
+export declare class SourceUtils {
+    private static readonly _pathSep;
+    private static readonly _appPathPrefix;
+    private static readonly _workspacePathPrefix;
+    private static readonly _urlSchemePattern;
+    /**
+     * Returns whether a normalized source refers to a file or directory within
+     * the workspace
+     *
+     * @param normalizedSource - The normalized source (see
+     *   {@link SourceUtils.normalizeSource})
+     * @returns `true` for workspace-relative paths, `false` for URLs and
+     *   app-relative paths
+     */
+    static isWorkspacePath(normalizedSource: string): boolean;
+    /**
+     * Builds a workspace-relative path from the segments of a path within the
+     * workspace, as returned by `FileSystemDirectoryHandle.resolve`
+     *
+     * @param segments - The path segments, from the workspace root down to the
+     *   file or directory
+     * @returns The workspace-relative path (with `/` prefix)
+     */
+    static makeWorkspacePath(segments: string[]): string;
+    /**
+     * Returns the directory that contains a normalized source
+     *
+     * @param normalizedSource - The normalized source (see
+     *   {@link SourceUtils.normalizeSource})
+     * @returns The normalized parent source and the name of the source within
+     *   it, decoded for URLs; `null` if the source is the root of its URL's path
+     *   or lies directly in the workspace, as the workspace root is no source
+     */
+    static getParentSource(normalizedSource: string): {
+        parentSource: string;
+        name: string;
+    } | null;
+    /**
+     * Normalizes a source, applying the fallbacks for missing project sources
+     * and workspaces
+     *
+     * @param source - The source to normalize
+     * @param workspace - The directory handle of the open workspace, if any
+     * @param projectSource - Where the project was loaded from: its absolute URL,
+     *   the workspace-relative path of the project file (with `/` prefix), or
+     *   `null` for projects that were loaded from neither (e.g. uploaded ones)
+     * @param options - Optional base URL that app-relative paths are resolved
+     *   against (default `document.baseURI`); the application relies on the
+     *   default, and the option is what keeps normalization a pure function of
+     *   its arguments, testable without a `document`
+     * @returns The absolute URL for URLs, app-relative paths, and paths that fall
+     *   back to being app-relative or resolve against a project URL; or the
+     *   normalized workspace-relative path (with `/` prefix) for paths within the
+     *   open workspace
+     * @throws Error if the source is empty or not a valid URL, or if it cannot be
+     *   normalized as a project-relative, workspace-relative or app-relative path
+     *   (see {@link SourceUtils._normalizeProjectPath},
+     *   {@link SourceUtils._normalizeWorkspacePath} and
+     *   {@link SourceUtils._normalizeAppPath})
+     */
+    static normalizeSource(source: string, workspace: FileSystemDirectoryHandle | null, projectSource: string | null, options?: {
+        baseUrl?: string;
+    }): string;
+    /**
+     * Resolves a normalized source to an absolute URL, a file handle or a
+     * directory handle
+     *
+     * URLs are returned as is. A workspace-relative path is opened within the
+     * workspace one directory at a time, and its last segment as a file, or as a
+     * directory if it names one. No fallbacks apply here: the source has to be
+     * normalized with {@link SourceUtils.normalizeSource} first, using the same
+     * workspace. Nothing is thrown synchronously: the returned promise rejects
+     * instead.
+     *
+     * @param normalizedSource - The normalized source to resolve: an absolute URL
+     *   or a workspace-relative path (with `/` prefix), as returned by
+     *   {@link SourceUtils.normalizeSource}
+     * @param workspace - The directory handle of the open workspace, if any
+     * @param options - Optional abort signal, checked upfront and between file
+     *   system calls
+     * @returns A promise that resolves to the absolute URL, or to the file or
+     *   directory handle for sources within the workspace
+     * @throws Error if a workspace-relative path is given without an open
+     *   workspace, or if the path leaves the workspace or names its root
+     * @throws DOMException if a segment names nothing within the workspace
+     *   (`NotFoundError`), if a segment other than the last names a file
+     *   (`TypeMismatchError`), or if the operation is aborted (`AbortError`)
+     */
+    static resolveSource(normalizedSource: string, workspace: FileSystemDirectoryHandle | null, options?: {
+        signal?: AbortSignal;
+    }): Promise<string | FileSystemFileHandle | FileSystemDirectoryHandle>;
+    /**
+     * Resolves a normalized source to an absolute URL or a file handle
+     *
+     * Like {@link SourceUtils.resolveSource}, for sources that have to refer to
+     * a file.
+     *
+     * @param normalizedSource - See {@link SourceUtils.resolveSource}
+     * @param workspace - See {@link SourceUtils.resolveSource}
+     * @param options - See {@link SourceUtils.resolveSource}
+     * @returns A promise that resolves to the absolute URL, or to the file handle
+     *   for sources within the workspace
+     * @throws See {@link SourceUtils.resolveSource}
+     * @throws DOMException if the source refers to a directory within the
+     *   workspace (`TypeMismatchError`)
+     */
+    static resolveSourceFile(normalizedSource: string, workspace: FileSystemDirectoryHandle | null, options?: {
+        signal?: AbortSignal;
+    }): Promise<string | FileSystemFileHandle>;
+    /**
+     * Resolves a normalized source to an absolute URL or an opened file
+     *
+     * Like {@link SourceUtils.resolveSourceFile}, for readers that take either
+     * a URL or a `File`: a file in the workspace is opened right away.
+     *
+     * @param normalizedSource - See {@link SourceUtils.resolveSource}
+     * @param workspace - See {@link SourceUtils.resolveSource}
+     * @param options - See {@link SourceUtils.resolveSource}; the signal is
+     *   also checked once the file is open, as opening it does not throw on
+     *   abort
+     * @returns A promise that resolves to the absolute URL, or to the opened
+     *   file for sources within the workspace
+     * @throws See {@link SourceUtils.resolveSourceFile}
+     * @throws DOMException if the file cannot be opened, e.g. because it was
+     *   removed (`NotFoundError`) or its read permission was revoked
+     *   (`NotAllowedError`)
+     * @throws The abort reason of the signal, if it is aborted once the file
+     *   is open
+     */
+    static openSourceFile(normalizedSource: string, workspace: FileSystemDirectoryHandle | null, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        url: string;
+        file?: undefined;
+    } | {
+        url?: undefined;
+        file: File;
+    }>;
+    /**
+     * Resolves a normalized source to an absolute URL or a directory handle
+     *
+     * Like {@link SourceUtils.resolveSource}, for sources that have to refer to
+     * a directory.
+     *
+     * @param normalizedSource - See {@link SourceUtils.resolveSource}
+     * @param workspace - See {@link SourceUtils.resolveSource}
+     * @param options - See {@link SourceUtils.resolveSource}
+     * @returns A promise that resolves to the absolute URL, or to the directory
+     *   handle for sources within the workspace
+     * @throws See {@link SourceUtils.resolveSource}
+     * @throws DOMException if the source refers to a file within the workspace
+     *   (`TypeMismatchError`)
+     */
+    static resolveSourceDirectory(normalizedSource: string, workspace: FileSystemDirectoryHandle | null, options?: {
+        signal?: AbortSignal;
+    }): Promise<string | FileSystemDirectoryHandle>;
+    /**
+     * Normalizes a project-relative path
+     *
+     * Against a project URL, the path is resolved to an absolute URL. Against a
+     * workspace-relative project path, the path is resolved within the project
+     * file's directory to a workspace-relative path. Without a project source,
+     * the path is normalized as a workspace-relative path as is. Both of the
+     * latter go through {@link SourceUtils._normalizeWorkspacePath}, including
+     * its fallback for when no workspace is open.
+     *
+     * @param projectPath - The project-relative path (without prefix)
+     * @param workspace - The directory handle of the open workspace, if any
+     * @param projectSource - See {@link SourceUtils.normalizeSource}
+     * @param options - Optional base URL for the app-relative fallback (see
+     *   {@link SourceUtils._normalizeAppPath})
+     * @returns The absolute URL, or the normalized workspace-relative path
+     * @throws Error if the path does not form a valid URL with the project URL,
+     *   if it leaves the workspace, or if it cannot be normalized as a
+     *   workspace-relative path (see {@link SourceUtils._normalizeWorkspacePath})
+     */
+    private static _normalizeProjectPath;
+    /**
+     * Normalizes a workspace-relative path
+     *
+     * With an open workspace, the path's segments are collapsed and the `/`
+     * prefix is kept. Without one, the path is normalized as an app-relative
+     * path instead (see {@link SourceUtils._normalizeAppPath}), dropping its `/`
+     * prefix: `/data/points.csv` then resolves like `//data/points.csv`.
+     *
+     * @param workspacePath - The workspace-relative path (with `/` prefix)
+     * @param workspace - The directory handle of the open workspace, if any
+     * @param options - Optional base URL for the app-relative fallback (see
+     *   {@link SourceUtils._normalizeAppPath})
+     * @returns The normalized workspace-relative path, or the absolute URL if no
+     *   workspace is open
+     * @throws Error if the path lacks the `/` prefix, or if it leaves the
+     *   workspace or names its root (with an open workspace) or cannot be
+     *   normalized as an app-relative path (without one, see
+     *   {@link SourceUtils._normalizeAppPath})
+     */
+    private static _normalizeWorkspacePath;
+    /**
+     * Normalizes an app-relative path to an absolute URL
+     *
+     * The path is resolved against the base URL like a relative URL, so `..`
+     * segments can lead above the application and a `/` right after the prefix
+     * makes the path absolute within the origin.
+     *
+     * @param appPath - The app-relative path (with `//` prefix)
+     * @param options - Optional base URL to resolve against (default
+     *   `document.baseURI`)
+     * @returns The absolute URL
+     * @throws Error if the path lacks the `//` prefix
+     * @throws TypeError if the path does not form a valid URL with the base URL
+     */
+    private static _normalizeAppPath;
+    /**
+     * Splits a path into segments, dropping empty and `.` segments and
+     * collapsing `..` segments against the segments preceding them
+     *
+     * @param path - The path to split, using `/` as separator
+     * @param baseSegments - The segments of the directory the path is relative
+     *   to, which `..` segments collapse against first (default: the root)
+     * @returns The collapsed segments, empty if the path names the root itself
+     * @throws Error if the path leads above the root
+     */
+    private static _collapseSegments;
+}
+
+/**
+ * A {@link RawTable} with {@link tableDefaults} applied
+ */
+export declare type Table = DataObject<TableDataSource<string>> & Required<Pick<RawTable, keyof typeof tableDefaults>> & Omit<RawTable, keyof typeof tableDefaults>;
+
+/** A column query suggested by `TableData.suggestColumnQueries` */
+export declare type TableColumnQuerySuggestion = {
+    /** The suggested query, in the provider's own format */
+    query: string;
+    /**
+     * Whether the query continues into a group of columns
+     *
+     * A group suggestion does not resolve to a column; it continues the query,
+     * e.g. into the columns of a group or a matrix. Other suggestions are
+     * expected to resolve to an exact column name.
+     *
+     * @defaultValue false
+     */
+    group?: boolean;
+};
+
+/** Reference to a table column */
+export declare type TableColumnRef = {
+    /**
+     * ID of the table holding the column
+     *
+     * If not specified, the table of the data source is used.
+     */
+    table?: string;
+    /** Name of the table column */
+    column: string;
+};
+
+/**
+ * Loaded tabular data providing column-wise access
+ *
+ * The items of a table are its rows, each of which annotates one item of
+ * another data object (see `AnnotatedDataSource`); the item IDs and names are
+ * those of the annotated items, in row order.
+ */
+export declare interface TableData extends ItemsData {
+    /**
+     * Returns column query suggestions for the current query
+     *
+     * The query format is up to the provider. Suggestions matching the current
+     * query come first, best matches first, followed by the other suggestions.
+     * The list is not capped.
+     *
+     * @param currentQuery - The partial column query to autocomplete
+     * @param options - Optional abort signal
+     * @returns A list of suggested column queries
+     */
+    suggestColumnQueries(currentQuery: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<TableColumnQuerySuggestion[]>;
+    /**
+     * Resolves a query to an exact column name
+     *
+     * @param query - The column query
+     * @param options - Optional abort signal
+     * @returns The resolved column name, or `null` if no match is found
+     */
+    resolveColumnQuery(query: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<string | null>;
+    /**
+     * Loads a column's values
+     *
+     * Numeric columns are loaded as numeric typed arrays, all other columns as
+     * plain arrays (see `TypedArrayOrArray`).
+     *
+     * @typeParam T - Element type of the returned array
+     * @param column - The column name
+     * @param options - Optional abort signal and progress callback
+     * @returns The column values
+     */
+    loadValues<T>(column: string, options?: {
+        signal?: AbortSignal;
+        onProgress?: ProgressCallback;
+    }): Promise<TypedArrayOrArray<T>>;
+    /**
+     * Loads the number of rows per unique value of a column
+     *
+     * @typeParam T - Element type of the column
+     * @param column - The column name
+     * @param options - Optional abort signal and progress callback
+     * @returns The row count of every unique column value, keyed by value, in the
+     * order the values first appear
+     */
+    loadUniqueValueCounts<T>(column: string, options?: {
+        signal?: AbortSignal;
+        onProgress?: ProgressCallback;
+    }): Promise<Map<T, number>>;
+    /**
+     * Loads a column's minimum and maximum values
+     *
+     * @param column - The column name
+     * @param options - Optional abort signal and progress callback
+     * @returns The numeric [min, max] value range of the column, or `undefined` if not numeric
+     */
+    loadValueRange(column: string, options?: {
+        signal?: AbortSignal;
+        onProgress?: ProgressCallback;
+    }): Promise<[number, number] | undefined>;
+}
+
+/**
+ * Data provider for tabular data
+ *
+ * @typeParam TTableDataSource - The data source type this data provider opens
+ * @typeParam TTableData - The {@link TableData} type produced by this data
+ * provider
+ * @typeParam TNormalizedTableDataSource - The normalized data source type
+ * produced by `normalize` and accepted by `load`
+ */
+export declare interface TableDataProvider<TTableDataSource extends TableDataSource, TTableData extends TableData, TNormalizedTableDataSource extends TTableDataSource = TTableDataSource> extends DataProvider<TTableDataSource, TTableData, TNormalizedTableDataSource> {
+}
+
+/**
+ * A {@link RawTableDataSource} with {@link tableDataSourceDefaults} applied
+ */
+export declare type TableDataSource<TType extends string = string> = DataSource<TType> & Required<Pick<RawTableDataSource<TType>, keyof typeof tableDataSourceDefaults>> & Omit<RawTableDataSource<TType>, keyof typeof tableDataSourceDefaults>;
+
+/**
+ * Default values for {@link RawTableDataSource}
+ */
+export declare const tableDataSourceDefaults: {};
+
+/**
+ * Default values for {@link RawTable}
+ */
+export declare const tableDefaults: {};
+
+/**
+ * Lookups into tabular data (`TableData`) by item ID
+ *
+ * A table annotates the items of another data object: each of its rows holds
+ * the item ID it belongs to, and consumers address rows by that ID rather than
+ * by position (see `ItemsData`). Looking rows up by ID needs a map from ID to
+ * row index, which is linear in the size of the table to build and costly to
+ * hold; {@link forEachRow} therefore builds it at most once per table, and not
+ * at all in the common case that the IDs to look up are the table's own, in
+ * row order. Once built, the map is retained for as long as the table's data
+ * is: it is keyed by the identity of the table's ID array, so it is freed
+ * together with the data, and a table that is looked up by other IDs - shapes
+ * annotated by a separate table, or the items of one layer of an object -
+ * keeps one entry per row alive until then. That is the price of sharing the
+ * map between every consumer of the table.
+ *
+ * Item IDs are expected to be unique within a table (see `ItemsData`). For a
+ * duplicated ID, the row-order fast path addresses each row by its own
+ * position, whereas the lookup maps the ID to its last row; a table with
+ * duplicated IDs is reported once, when its map is built.
+ *
+ * On top of the row lookup, {@link fillFromTableValues} and
+ * {@link fillFromTableGroups} fill a typed array with one packed value per
+ * item from a table column, one by parsing the cell values and one by mapping
+ * their distinct values as groups. IDs that the table does not contain fall
+ * back to a default value, with a warning.
+ */
+export declare class TableUtils {
+    /**
+     * Row indices by item ID, by the table's ID array
+     *
+     * Keyed by the array that `getIds()` returns, which stays the very same array
+     * for as long as the data is unchanged (see `ItemsData`), so an entry lives
+     * exactly as long as the data it was built from. Holds the pending build,
+     * so that concurrent lookups share it.
+     */
+    private static readonly _rowIndicesCache;
+    /**
+     * Fills `packedValues` by loading values from the given table column
+     *
+     * For each ID in `ids`, the corresponding row is looked up in the table by ID
+     * (see {@link forEachRow}). The raw cell value is parsed by
+     * `parseTableValue`; if that fails, or if the table does not contain the ID,
+     * `defaultValue` is used instead.
+     *
+     * @param packedValues - Output typed array to fill, in the order of `ids`
+     * @param tableData - The table to look up values in
+     * @param ids - Ordered list of item IDs
+     * @param column - Name of the table column to load values from
+     * @param defaultValue - Value used when the ID is missing or parsing fails
+     * @param parseTableValue - Converts a raw cell value to `TValue`, or to
+     * `undefined` on failure
+     * @param packValue - Converts `TValue` to the numeric representation stored
+     * in `packedValues`
+     * @param options - Optional abort signal
+     */
+    static fillFromTableValues<TValue>(packedValues: TypedArray, tableData: TableData, ids: IDArray, column: string, defaultValue: TValue, parseTableValue: (value: unknown) => TValue | undefined, packValue: (value: TValue) => number, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Fills `packedValues` by grouping IDs by the given table column and mapping the groups to values
+     *
+     * For each ID in `ids`, the corresponding row is looked up in the table by ID
+     * (see {@link forEachRow}). The raw cell value is converted to a string to
+     * form the group key, which `mapGroupToValue` maps to a value; if the table
+     * does not contain the ID, `defaultValue` is used instead. Groups are
+     * resolved once per distinct cell value, i.e. `mapGroupToValue` is not
+     * called per item.
+     *
+     * @param packedValues - Output typed array to fill, in the order of `ids`
+     * @param tableData - The table to look up group keys in
+     * @param ids - Ordered list of item IDs
+     * @param column - Name of the table column to load group keys from
+     * @param defaultValue - Value used when the ID is missing
+     * @param mapGroupToValue - Maps a group key (the cell value as a string) to
+     * `TValue`
+     * @param packValue - Converts `TValue` to the numeric representation stored
+     * in `packedValues`
+     * @param options - Optional abort signal
+     */
+    static fillFromTableGroups<TValue>(packedValues: TypedArray, tableData: TableData, ids: IDArray, column: string, defaultValue: TValue, mapGroupToValue: (group: string) => TValue, packValue: (value: TValue) => number, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Calls `callback` for every ID with the index of the table row holding that ID
+     *
+     * If `ids` is the table's own ID array, the ID at position `i` is held by
+     * row `i` and no lookup is needed. Otherwise the rows are looked up in the
+     * table's row indices (see {@link getRowIndices}); IDs the table does not
+     * contain are reported with an undefined row index.
+     *
+     * @param ids - Ordered list of item IDs
+     * @param tableData - The table to look the IDs up in
+     * @param callback - Called with the row index of each ID, or `undefined` if
+     * the table does not contain it, and the position of the ID in `ids`
+     * @param options - Optional abort signal
+     */
+    static forEachRow(ids: IDArray, tableData: TableData, callback: (rowIndex: number | undefined, i: number) => void, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Returns the row indices of a table by item ID
+     *
+     * Built at most once per table, cooperatively yielding, and shared by all
+     * callers, which is why a caller's abort signal only detaches that caller:
+     * the build itself keeps going for the others, and for the next lookup.
+     *
+     * @param tableData - The table to return the row indices of
+     * @param options - Optional abort signal
+     * @returns The row index of every item ID of the table; for an ID occurring
+     * more than once, which is reported with a warning, the index of its last row
+     */
+    static getRowIndices(tableData: TableData, options?: {
+        signal?: AbortSignal;
+    }): Promise<ReadonlyMap<number | string, number>>;
+    /**
+     * Builds the row indices by item ID for the given table IDs
+     */
+    private static _buildRowIndices;
+}
+
+/** Configuration object accepted by OpenSeadragon as a tile source */
+export declare type TileSourceConfig = object;
+
+/**
+ * Utility methods for converting between {@link SimilarityTransform}
+ * objects and `gl-matrix` {@link mat3} matrices
+ */
+export declare class TransformUtils {
+    /**
+     * Decomposes a 3×3 similarity matrix into a {@link SimilarityTransform}
+     *
+     * Extracts flip, uniform scale, rotation (in degrees), and translation
+     * from a column-major `gl-matrix` {@link mat3}. A negative 2D determinant
+     * indicates a horizontal reflection.
+     *
+     * If `pivot` is given, flip and rotation are expressed about `pivot`
+     * (in the input coordinates of `m`) instead of the origin, while scale
+     * stays about the origin. Flip, scale, and rotation are unaffected; only
+     * the translation changes to `m(pivot) - scale * pivot`, i.e. the position
+     * of the scaled content before it is flipped and rotated about its (scaled)
+     * pivot. This matches viewers that place an image by its top-left corner
+     * and then flip/rotate it about its center.
+     *
+     * @param m - The source matrix
+     * @param pivot - Optional point about which flip and rotation are expressed
+     * @returns The decomposed transform
+     */
+    static decompose(m: mat3, pivot?: {
+        x: number;
+        y: number;
+    }): SimilarityTransform;
+    /**
+     * Builds a 3×3 similarity matrix from a (partial) {@link SimilarityTransform}
+     *
+     * Applies, in order: flip/scale, rotation, and translation.
+     *
+     * If `pivot` is given, flip and rotation are applied about `pivot` (in the
+     * source coordinates of the transform) instead of the origin, while scale
+     * stays about the origin. The translation is then the position of the
+     * scaled content before it is flipped and rotated about its (scaled)
+     * pivot. This is the inverse of {@link decompose} called with
+     * the same pivot.
+     *
+     * @param tf - The transform components (all optional)
+     * @param pivot - Optional point about which flip and rotation are applied
+     * @returns The composed matrix
+     */
+    static compose(tf: Partial<SimilarityTransform>, pivot?: {
+        x: number;
+        y: number;
+    }): mat3;
+    /**
+     * Transforms an axis-aligned rectangle and returns the axis-aligned bounding box of the transformed corners
+     *
+     * @param rect - The rectangle to transform
+     * @param m - The transformation matrix to apply to the rectangle corners
+     * @returns The axis-aligned bounding box of the transformed rectangle
+     */
+    static transformBoundingBox(rect: Rect, m: mat3): Rect;
+}
+
+/** Union of all natively supported numeric typed arrays */
+export declare type TypedArray = IntOrUintArray | FloatArray;
+
+/**
+ * The array types that can hold values of type `T`
+ *
+ * Numbers are held by numeric typed arrays only, anything else by a plain
+ * array. For an unconstrained `T`, both are possible.
+ */
+export declare type TypedArrayOrArray<T> = [T] extends [number] ? TypedArray : unknown extends T ? TypedArray | T[] : T[];
+
+/** Union of all natively supported unsigned integer typed arrays */
+export declare type UintArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;
+
+/** A 2-D point */
+export declare type Vertex = {
+    /** X coordinate of the vertex */
+    x: number;
+    /** Y coordinate of the vertex */
+    y: number;
+};
+
+/**
+ * Visibility configuration
+ *
+ * Numerical table values are interpreted as booleans, where `0` is `false` and any other value is `true`.
+ */
+export declare type VisibilityConfig = ConstantConfig<boolean> | FromConfig | GroupByConfig<true>;
+
+/**
+ * Options for the WebGL renderers
+ */
+export declare type WebGLOptions = {
+    /** Options for rendering the project's points */
+    pointsRenderOptions: WebGLPointsRenderOptions;
+    /** Options for rendering the project's shapes */
+    shapesRenderOptions: WebGLShapesRenderOptions;
+};
+
+/**
+ * Options for rendering points
+ */
+export declare type WebGLPointsRenderOptions = {
+    /**
+     * Unitless factor by which the size of every point is multiplied
+     *
+     * Applies on top of the layer- and object-level point size settings.
+     */
+    globalPointSizeFactor: number;
+};
+
+/**
+ * Options for rendering shapes
+ */
+export declare type WebGLShapesRenderOptions = {
+    /** Width of the shape outlines, in world coordinates */
+    strokeWidth: number;
+    /**
+     * Number of polygon edges of a typical shape that a scanline holds, when
+     * rasterizing a shapes object
+     *
+     * The rasterizer divides a shapes object's bounding box into horizontal
+     * scanlines, and each scanline into x-bins, and lists for each of them the
+     * shapes and polygon edges reaching into it (including their padding, see
+     * {@link shapePadding}), so that the fragment shader only has to consider
+     * those. As edges are only assigned to scanlines, the scanline height bounds
+     * the number of edges a fragment tests per shape. Fewer edges per scanline
+     * mean fewer edges to test per fragment, at the cost of a larger scanline
+     * texture, as shapes and edges spanning several scanlines are listed in each
+     * of them.
+     */
+    edgesPerScanline: number;
+    /**
+     * Width of the x-bins of the scanlines a shapes object is rasterized into
+     * (see {@link edgesPerScanline}), relative to the median width of its shapes
+     *
+     * The bin width bounds the number of shapes a fragment considers. Narrower
+     * bins mean fewer shapes to consider per fragment, at the cost of a larger
+     * scanline texture, as shapes spanning several bins are listed in each of
+     * them.
+     */
+    binWidthFactor: number;
+    /**
+     * Fraction of the median height and width of the shapes that shapes and
+     * polygon edges are padded by on either side when rasterizing a shapes
+     * object (see {@link edgesPerScanline})
+     *
+     * Strokes and anti-aliased edges reaching beyond a shape are only drawn
+     * within the padding, i.e. half the stroke width is limited to this fraction
+     * of the median shape height vertically and of the median shape width
+     * horizontally, whatever the numbers of scanlines and bins. Zoomed out far
+     * enough that the padding is only about a pixel, even the thinnest strokes
+     * and anti-aliased edges are cut off. Larger paddings let strokes reach
+     * further, at the cost of more shapes and edges to test per fragment and a
+     * larger scanline texture.
+     */
+    shapePadding: number;
+};
+
+export { }