@idetik/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1865 @@
+import * as gl_matrix from 'gl-matrix';
+import { vec3, mat4, quat, vec4, vec2 } from 'gl-matrix';
+import { Location } from '@zarrita/core';
+import { Readable } from '@zarrita/storage';
+import * as zarr from 'zarrita';
+import { z } from 'zod';
+
+type Point = {
+    type: "point";
+    value: number;
+};
+type Interval = {
+    type: "interval";
+    start: number;
+    stop: number;
+};
+type Full = {
+    type: "full";
+};
+type Index = Point | Interval | Full;
+type DimensionalIndex = {
+    dimension: string;
+    index: Index;
+};
+type Region = Array<DimensionalIndex>;
+
+declare abstract class Node {
+    readonly uuid: string;
+    abstract get type(): string;
+}
+
+type TextureFilter = "nearest" | "linear";
+type TextureWrapMode = "repeat" | "clamp_to_edge";
+type TextureDataFormat = "scalar" | "rgb" | "rgba";
+type TextureDataType = "byte" | "short" | "int" | "unsigned_byte" | "unsigned_short" | "unsigned_int" | "float";
+type TextureUnpackRowAlignment = 1 | 2 | 4 | 8;
+type DataTextureTypedArray = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Float32Array;
+declare abstract class Texture extends Node {
+    dataFormat: TextureDataFormat;
+    dataType: TextureDataType;
+    maxFilter: TextureFilter;
+    minFilter: TextureFilter;
+    mipmapLevels: number;
+    unpackAlignment: TextureUnpackRowAlignment;
+    wrapR: TextureWrapMode;
+    wrapS: TextureWrapMode;
+    wrapT: TextureWrapMode;
+    needsUpdate: boolean;
+    abstract get width(): number;
+    abstract get height(): number;
+    abstract get data(): TexImageSource | ArrayBufferView | null;
+    abstract set data(data: DataTextureTypedArray);
+    get type(): string;
+}
+
+declare class PromiseScheduler {
+    private readonly maxConcurrent_;
+    private readonly pending_;
+    private readonly abortController_;
+    private numRunning_;
+    constructor(maxConcurrent: number);
+    submit<T>(task: () => Promise<T>): Promise<T>;
+    private maybeRunNext;
+    get abortSignal(): AbortSignal;
+    shutdown(): void;
+    get numRunning(): number;
+    get numPending(): number;
+}
+
+declare const chunkDataTypes: readonly [Int8ArrayConstructor, Int16ArrayConstructor, Int32ArrayConstructor, Uint8ArrayConstructor, Uint16ArrayConstructor, Uint32ArrayConstructor, Float32ArrayConstructor];
+type ChunkDataConstructor = (typeof chunkDataTypes)[number];
+type ChunkData = InstanceType<ChunkDataConstructor>;
+type Chunk = {
+    data?: ChunkData;
+    state: "unloaded" | "queued" | "loading" | "loaded";
+    lod: number;
+    visible: boolean;
+    prefetch: boolean;
+    priority: number | null;
+    orderKey: number | null;
+    shape: {
+        x: number;
+        y: number;
+        z: number;
+        c: number;
+    };
+    rowAlignmentBytes: TextureUnpackRowAlignment;
+    chunkIndex: {
+        x: number;
+        y: number;
+        z: number;
+        c: number;
+        t: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    offset: {
+        x: number;
+        y: number;
+        z: number;
+    };
+};
+type SourceDimensionMap = {
+    x: SourceDimension;
+    y: SourceDimension;
+    z?: SourceDimension;
+    c?: SourceDimension;
+    t?: SourceDimension;
+    numLods: number;
+};
+type SourceDimension = {
+    name: string;
+    index: number;
+    unit?: string;
+    lods: SourceDimensionLod[];
+};
+type SourceDimensionLod = {
+    size: number;
+    chunkSize: number;
+    scale: number;
+    translation: number;
+};
+type SliceCoordinates = {
+    z?: number;
+    c?: number;
+    t?: number;
+};
+type ChunkSource = {
+    open(): Promise<ChunkLoader>;
+};
+type LoaderAttributes = {
+    dimensionNames: string[];
+    dimensionUnits: (string | undefined)[];
+    chunks: readonly number[];
+    shape: readonly number[];
+    scale: readonly number[];
+    translation: readonly number[];
+};
+type ChunkLoader = {
+    loadRegion(input: Region, lod: number, scheduler?: PromiseScheduler): Promise<Chunk>;
+    getSourceDimensionMap(): SourceDimensionMap;
+    loadChunkData(chunk: Chunk, signal: AbortSignal): Promise<void>;
+    getAttributes(): ReadonlyArray<LoaderAttributes>;
+};
+
+declare class Box3 {
+    min: vec3;
+    max: vec3;
+    /**
+     * Initializes as an empty box if no values are provided using the
+     * "empty-by-sentinel" pattern: min = +Infinity, max = -Infinity.
+     * This allows expansion functions to work without special-casing
+     * the first element, and avoids biasing toward (0,0,0).
+     */
+    constructor(min?: vec3, max?: vec3);
+    clone(): Box3;
+    isEmpty(): boolean;
+    static intersects(a: Box3, b: Box3): boolean;
+    expandWithPoint(p: vec3): void;
+    applyTransform(matrix: mat4): void;
+}
+
+type Primitive = "triangles" | "points" | "lines";
+type GeometryAttributeType = "position" | "normal" | "uv" | "next_position" | "previous_position" | "direction" | "path_proportion" | "color" | "size" | "marker";
+type GeometryAttribute = {
+    type: GeometryAttributeType;
+    itemSize: number;
+    offset: number;
+};
+declare class Geometry extends Node {
+    private boundingBox_;
+    protected primitive_: Primitive;
+    protected attributes_: GeometryAttribute[];
+    protected vertexData_: Float32Array;
+    protected indexData_: Uint32Array;
+    constructor(vertexData?: number[], indexData?: number[], primitive?: Primitive);
+    addAttribute(attr: GeometryAttribute): void;
+    get vertexCount(): number;
+    get stride(): number;
+    get strideBytes(): number;
+    get primitive(): Primitive;
+    get vertexData(): Float32Array<ArrayBufferLike>;
+    get indexData(): Uint32Array<ArrayBufferLike>;
+    get attributes(): GeometryAttribute[];
+    get boundingBox(): Box3;
+    get type(): string;
+    private getAttribute;
+}
+
+declare class WireframeGeometry extends Geometry {
+    constructor(geometry: Geometry);
+}
+
+declare class TrsTransform {
+    private dirty_;
+    private matrix_;
+    private rotation_;
+    private translation_;
+    private scale_;
+    addRotation(q: quat): void;
+    setRotation(q: quat): void;
+    get rotation(): gl_matrix.vec4;
+    addTranslation(vec: vec3): void;
+    setTranslation(vec: vec3): void;
+    get translation(): vec3;
+    addScale(vec: vec3): void;
+    setScale(vec: vec3): void;
+    targetTo(target: vec3): void;
+    get scale(): vec3;
+    get matrix(): mat4;
+    get inverse(): mat4;
+    private computeMatrix;
+}
+
+type Shader = "floatScalarImage" | "floatScalarImageArray" | "floatVolume" | "intScalarImage" | "intScalarImageArray" | "intVolume" | "labelImage" | "points" | "projectedLine" | "uintScalarImage" | "uintScalarImageArray" | "uintVolume" | "wireframe";
+
+type ColorLike = Color | vec3 | vec4;
+declare class Color {
+    static readonly RED: Color;
+    static readonly GREEN: Color;
+    static readonly BLUE: Color;
+    static readonly YELLOW: Color;
+    static readonly MAGENTA: Color;
+    static readonly CYAN: Color;
+    static readonly BLACK: Color;
+    static readonly WHITE: Color;
+    static readonly TRANSPARENT: Color;
+    private readonly rgba_;
+    constructor(r: number, g: number, b: number, a?: number);
+    get rgb(): [number, number, number];
+    get rgba(): readonly [number, number, number, number];
+    get r(): number;
+    get g(): number;
+    get b(): number;
+    get a(): number;
+    get rgbHex(): string;
+    get packed(): number;
+    static from(colorLike: ColorLike): Color;
+    static fromRgbHex(hex: string): Color;
+    private toHexComponent;
+}
+
+declare abstract class RenderableObject extends Node {
+    wireframeEnabled: boolean;
+    wireframeColor: Color;
+    private readonly textures_;
+    private staleTextures_;
+    private readonly transform_;
+    private geometry_;
+    private wireframeGeometry_;
+    private programName_;
+    setTexture(index: number, texture: Texture): void;
+    popStaleTextures(): Texture[];
+    get geometry(): Geometry;
+    get wireframeGeometry(): WireframeGeometry;
+    get textures(): Texture[];
+    get transform(): TrsTransform;
+    set geometry(geometry: Geometry);
+    get programName(): Shader;
+    get boundingBox(): Box3;
+    protected set programName(programName: Shader);
+    /**
+     * Get uniforms for shader program. Override in derived classes that need custom uniforms.
+     * @returns Object containing uniform name-value pairs
+     */
+    getUniforms(): Record<string, unknown>;
+}
+
+declare class Frustum {
+    private readonly planes_;
+    constructor(m: mat4);
+    setWithViewProjection(m: mat4): void;
+    intersectsWithBox3(box: Box3): boolean;
+}
+
+type CameraType = "OrthographicCamera" | "PerspectiveCamera";
+declare abstract class Camera extends RenderableObject {
+    protected projectionMatrix_: mat4;
+    protected near_: number;
+    protected far_: number;
+    protected abstract updateProjectionMatrix(): void;
+    abstract get type(): CameraType;
+    update(): void;
+    get projectionMatrix(): mat4;
+    get viewMatrix(): mat4;
+    get right(): vec3;
+    get up(): vec3;
+    get frustum(): Frustum;
+    abstract setAspectRatio(aspectRatio: number): void;
+    abstract zoom(factor: number): void;
+    pan(vec: vec3): void;
+    get position(): vec3;
+    clipToWorld(position: vec3): vec3;
+}
+
+declare class Box2 {
+    min: vec2;
+    max: vec2;
+    /**
+     * Initializes as an empty box if no values are provided using the
+     * "empty-by-sentinel" pattern: min = +Infinity, max = -Infinity.
+     * This allows expansion functions to work without special-casing
+     * the first element, and avoids biasing toward (0,0).
+     */
+    constructor(min?: vec2, max?: vec2);
+    clone(): Box2;
+    isEmpty(): boolean;
+    static intersects(a: Box2, b: Box2): boolean;
+    static equals(a: Box2, b: Box2): boolean;
+    floor(): Box2;
+    toRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+
+declare class OrthographicCamera extends Camera {
+    private width_;
+    private height_;
+    private viewportAspectRatio_;
+    private viewportSize_;
+    constructor(left: number, right: number, top: number, bottom: number, near?: number, far?: number);
+    get viewportSize(): [number, number];
+    setAspectRatio(aspectRatio: number): void;
+    setFrame(left: number, right: number, bottom: number, top: number): void;
+    get type(): CameraType;
+    zoom(factor: number): void;
+    getWorldViewRect(): Box2;
+    protected updateProjectionMatrix(): void;
+}
+
+declare const ALL_CATEGORIES: readonly ["fallbackVisible", "prefetchTime", "visibleCurrent", "fallbackBackground", "prefetchSpace"];
+type PriorityCategory = (typeof ALL_CATEGORIES)[number];
+type ImageSourcePolicyConfig = {
+    profile?: string;
+    prefetch: {
+        x: number;
+        y: number;
+        z?: number;
+        t?: number;
+    };
+    priorityOrder: PriorityCategory[];
+    lod?: {
+        min?: number;
+        max?: number;
+        bias?: number;
+    };
+};
+type ImageSourcePolicy = Readonly<{
+    profile: string;
+    prefetch: {
+        x: number;
+        y: number;
+        z: number;
+        t: number;
+    };
+    priorityOrder: readonly PriorityCategory[];
+    priorityMap: Readonly<Record<PriorityCategory, number>>;
+    lod: {
+        min: number;
+        max: number;
+        bias: number;
+    };
+}>;
+declare function createImageSourcePolicy(config: ImageSourcePolicyConfig): ImageSourcePolicy;
+declare function createExplorationPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
+declare function createPlaybackPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
+declare function createNoPrefetchPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
+
+declare class ChunkManagerSource {
+    private readonly chunks_;
+    private readonly loader_;
+    private readonly lowestResLOD_;
+    private readonly sliceCoords_;
+    private readonly dimensions_;
+    private readonly tIndicesWithQueuedChunks_;
+    private readonly sourceMaxSquareDistance2D_;
+    private policy_;
+    private policyChanged_;
+    private currentLOD_;
+    private lastViewBounds2D_;
+    private lastZBounds_?;
+    private lastTCoord_?;
+    constructor(loader: ChunkLoader, sliceCoords: SliceCoordinates, policy: ImageSourcePolicy);
+    getChunks(): Chunk[];
+    getChunksAtCurrentTime(): Chunk[];
+    private getCurrentTimeIndex;
+    allVisibleLowestLODLoaded(): boolean;
+    updateAndCollectChunkChanges(lodFactor: number, viewBounds2D: Box2): Chunk[];
+    get lodCount(): number;
+    get dimensions(): SourceDimensionMap;
+    get currentLOD(): number;
+    setImageSourcePolicy(newPolicy: ImageSourcePolicy, key: symbol): void;
+    loadChunkData(chunk: Chunk, signal: AbortSignal): Promise<void>;
+    private setLOD;
+    private updateAndCollectChunkChangesForCurrentLod;
+    private disposeStaleTimeChunks;
+    private updateChunksAtTimeIndex;
+    private markTimeChunksForPrefetch;
+    private isChunkChannelInSlice;
+    private shouldDispose;
+    private disposeChunk;
+    private computePriority;
+    private validateXYScaleRatios;
+    private getAndValidateTimeDimension;
+    private getAndValidateChannelDimension;
+    private isChunkWithinBounds;
+    private getZBounds;
+    private viewBounds2DChanged;
+    private zBoundsChanged;
+    private getPaddedBounds;
+    private squareDistance2D;
+}
+
+declare class ChunkManager {
+    private readonly sources_;
+    private readonly pendingSources_;
+    private readonly queue_;
+    addSource(source: ChunkSource, sliceCoords: SliceCoordinates, policy: ImageSourcePolicy): Promise<ChunkManagerSource>;
+    update(camera: OrthographicCamera, bufferWidth: number): void;
+}
+
+declare const eventTypes: readonly ["pointerdown", "pointermove", "pointerup", "pointercancel", "wheel"];
+type EventType = (typeof eventTypes)[number];
+declare class EventContext {
+    private propagationStopped_;
+    readonly type: EventType;
+    readonly event?: Event;
+    worldPos?: vec3;
+    clipPos?: vec3;
+    constructor(type: EventType, event?: Event);
+    get propagationStopped(): boolean;
+    stopPropagation(): void;
+}
+type Listener = (event: EventContext) => void;
+declare class EventDispatcher {
+    private readonly listeners_;
+    private readonly element_;
+    private isConnected_;
+    constructor(element: HTMLElement);
+    addEventListener(listener: Listener): void;
+    connect(): void;
+    disconnect(): void;
+    private readonly handleEvent;
+}
+
+type LayerState = "initialized" | "loading" | "ready";
+type blendMode = "normal" | "additive" | "subtractive" | "multiply";
+type StateChangeCallback = (newState: LayerState, prevState?: LayerState) => void;
+interface LayerOptions {
+    transparent?: boolean;
+    opacity?: number;
+    blendMode?: blendMode;
+}
+declare abstract class Layer {
+    abstract readonly type: string;
+    private objects_;
+    private state_;
+    private readonly callbacks_;
+    transparent: boolean;
+    private opacity_;
+    blendMode: blendMode;
+    constructor({ transparent, opacity, blendMode, }?: LayerOptions);
+    get opacity(): number;
+    set opacity(value: number);
+    abstract update(): void;
+    onEvent(_: EventContext): void;
+    onAttached(_context: IdetikContext): Promise<void>;
+    onDetached(): void;
+    get objects(): RenderableObject[];
+    get state(): LayerState;
+    addStateChangeCallback(callback: StateChangeCallback): void;
+    removeStateChangeCallback(callback: StateChangeCallback): void;
+    protected setState(newState: LayerState): void;
+    protected addObject(object: RenderableObject): void;
+    protected removeObject(object: RenderableObject): void;
+    protected clearObjects(): void;
+}
+
+declare class LayerManager {
+    private layers_;
+    private callbacks_;
+    private readonly context_;
+    constructor(context: IdetikContext);
+    partitionLayers(): {
+        opaque: Layer[];
+        transparent: Layer[];
+    };
+    add(layer: Layer): void;
+    remove(layer: Layer): void;
+    removeByIndex(index: number): void;
+    removeAll(): void;
+    get layers(): readonly Layer[];
+    private notifyLayersChanged;
+    addLayersChangeCallback(callback: () => void): () => void;
+    removeLayersChangeCallback(callback: () => void): void;
+}
+
+interface CameraControls {
+    onEvent(event: EventContext): void;
+}
+declare class PanZoomControls implements CameraControls {
+    private readonly camera_;
+    private dragActive_;
+    private dragStart_;
+    constructor(camera: OrthographicCamera);
+    onEvent(event: EventContext): void;
+    private onWheel;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerEnd;
+}
+
+interface ViewportConfig {
+    id?: string;
+    element?: HTMLElement;
+    camera: Camera;
+    layers?: Layer[];
+    cameraControls?: CameraControls;
+}
+interface ViewportProps extends ViewportConfig {
+    id: string;
+    element: HTMLElement;
+    layerManager: LayerManager;
+}
+declare class Viewport {
+    readonly id: string;
+    readonly element: HTMLElement;
+    readonly camera: Camera;
+    readonly layerManager: LayerManager;
+    readonly events: EventDispatcher;
+    cameraControls?: CameraControls;
+    constructor(props: ViewportProps);
+    updateSize(): void;
+    getBoxRelativeTo(canvas: HTMLCanvasElement): Box2;
+    clientToClip(position: vec2, depth?: number): vec3;
+    clientToWorld(position: vec2, depth?: number): vec3;
+    private getBox;
+    private updateAspectRatio;
+}
+declare function parseViewportConfigs(viewportConfigs: ViewportConfig[], canvas: HTMLCanvasElement, context: IdetikContext): Viewport[];
+
+type Overlay = {
+    update(idetik: Idetik, timestamp?: DOMHighResTimeStamp): void;
+};
+type IdetikParams = {
+    canvas: HTMLCanvasElement;
+    viewports: [ViewportConfig, ...ViewportConfig[]];
+    overlays?: Overlay[];
+    showStats?: boolean;
+};
+type IdetikContext = {
+    chunkManager: ChunkManager;
+};
+declare class Idetik {
+    private lastAnimationId_?;
+    private readonly chunkManager_;
+    private readonly context_;
+    private readonly renderer_;
+    private readonly viewports_;
+    readonly canvas: HTMLCanvasElement;
+    readonly overlays: Overlay[];
+    private readonly stats_?;
+    private readonly sizeObserver_;
+    /**
+     * Creates a new Idetik visualization runtime instance.
+     *
+     * @param params - Configuration parameters for the Idetik instance
+     * @param params.canvas - HTMLCanvasElement to render to
+     * @param params.viewports - Array of viewport configurations. (At least one required.)
+     *   Each viewport renders with its own camera, layers, and controls.
+     *   The `element` property is optional and defaults to the canvas if not provided.
+     *   Elements must be unique across viewports.
+     *   The `id` property is optional but useful for referencing specific viewports later.
+     * @param params.overlays - Optional array of overlay objects that update each frame (e.g., for HUD elements)
+     * @param params.showStats - Optional flag to display performance statistics
+     *
+     * @example
+     * // Single viewport (element defaults to canvas)
+     * const camera = new OrthographicCamera(0, 1024, 0, 1024);
+     * const idetik = new Idetik({
+     *   canvas: document.querySelector('canvas')!,
+     *   viewports: [{
+     *     camera: camera,
+     *     layers: [imageLayer],
+     *     cameraControls: new PanZoomControls(camera)
+     *   }]
+     * });
+     *
+     * @example
+     * // Multiple viewports - one defaults to canvas, others use separate elements
+     * const idetik = new Idetik({
+     *   canvas: document.querySelector('canvas')!,
+     *   viewports: [
+     *     {
+     *       id: 'main',
+     *       // element omitted - defaults to canvas
+     *       camera: camera1,
+     *       layers: [layer1]
+     *     },
+     *     {
+     *       id: 'minimap',
+     *       element: document.querySelector('#minimap')!,
+     *       camera: camera2,
+     *       layers: [layer2]
+     *     }
+     *   ]
+     * });
+     *
+     * @throws {Error} If viewports array is empty or not provided
+     * @throws {Error} If viewports have duplicate IDs or shared elements
+     */
+    constructor(params: IdetikParams);
+    get renderedObjects(): number;
+    get width(): number;
+    get height(): number;
+    get textureInfo(): {
+        textures: number;
+        totalBytes: number;
+    };
+    get viewports(): readonly Viewport[];
+    getViewport(id: string): Viewport | undefined;
+    start(): this;
+    private animate;
+    stop(): void;
+    private updateSize;
+}
+
+declare abstract class Renderer {
+    private readonly canvas_;
+    private width_;
+    private height_;
+    private backgroundColor_;
+    protected renderedObjects_: number;
+    protected abstract resize(width: number, height: number): void;
+    protected abstract renderObject(layer: Layer, objectIndex: number, camera: Camera): void;
+    protected abstract clear(): void;
+    constructor(canvas: HTMLCanvasElement);
+    abstract render(viewport: Viewport): void;
+    updateSize(): void;
+    private updateRendererSize;
+    protected get canvas(): HTMLCanvasElement;
+    get width(): number;
+    get height(): number;
+    get backgroundColor(): Color;
+    get renderedObjects(): number;
+    set backgroundColor(color: ColorLike);
+}
+
+declare class WebGLRenderer extends Renderer {
+    private readonly gl_;
+    private readonly programs_;
+    private readonly bindings_;
+    private readonly textures_;
+    private readonly state_;
+    private renderedObjectsPerFrame_;
+    constructor(canvas: HTMLCanvasElement);
+    render(viewport: Viewport): void;
+    get textureInfo(): {
+        textures: number;
+        totalBytes: number;
+    };
+    private renderLayer;
+    protected renderObject(layer: Layer, objectIndex: number, camera: Camera): void;
+    private drawGeometry;
+    private glGetPrimitive;
+    protected resize(width: number, height: number): void;
+    protected clear(): void;
+    private get gl();
+}
+
+type PerspectiveCameraOptions = {
+    fov?: number;
+    aspectRatio?: number;
+    near?: number;
+    far?: number;
+    position?: vec3;
+};
+declare class PerspectiveCamera extends Camera {
+    private fov_;
+    private aspectRatio_;
+    constructor(options?: PerspectiveCameraOptions);
+    setAspectRatio(aspectRatio: number): void;
+    get type(): CameraType;
+    get fov(): number;
+    zoom(factor: number): void;
+    protected updateProjectionMatrix(): void;
+}
+
+declare class AxesLayer extends Layer {
+    readonly type = "AxesLayer";
+    constructor(params: {
+        length: number;
+        width: number;
+    });
+    update(): void;
+}
+
+type LineParameters = {
+    path: vec3[];
+    color: vec3;
+    width: number;
+};
+declare class ProjectedLineLayer extends Layer {
+    readonly type = "ProjectedLineLayer";
+    private paths_;
+    constructor(lines?: LineParameters[]);
+    private addLine;
+    update(): void;
+    get extent(): BoundingBox3D$1;
+}
+type BoundingBox3D$1 = {
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+    zMin: number;
+    zMax: number;
+};
+
+type TrackParameters = {
+    path: vec3[];
+    interpolation?: {
+        pointsPerSegment: number;
+        tangentFactor?: number;
+    };
+    time?: number[];
+    color: vec3;
+    width: number;
+};
+declare class TracksLayer extends Layer {
+    readonly type = "TracksLayer";
+    private tracks_;
+    constructor(tracks?: TrackParameters[]);
+    private addLine;
+    setTimeIndex(index: number): void;
+    update(): void;
+    get extent(): BoundingBox3D;
+}
+type BoundingBox3D = {
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+    zMin: number;
+    zMax: number;
+};
+
+type ChannelProps = {
+    visible?: boolean;
+    color?: ColorLike;
+    contrastLimits?: [number, number];
+};
+/** Layer that exposes channel controls. */
+interface ChannelsEnabled {
+    channelProps: ChannelProps[] | undefined;
+    setChannelProps(channelProps: ChannelProps[]): void;
+    resetChannelProps(): void;
+    addChannelChangeCallback(callback: () => void): void;
+    removeChannelChangeCallback(callback: () => void): void;
+}
+
+interface PointPickingResult {
+    world: vec3;
+    value: number;
+}
+
+type ChunkedImageLayerProps = LayerOptions & {
+    source: ChunkSource;
+    sliceCoords: SliceCoordinates;
+    policy: ImageSourcePolicy;
+    channelProps?: ChannelProps[];
+    onPickValue?: (info: PointPickingResult) => void;
+};
+declare class ChunkedImageLayer extends Layer implements ChannelsEnabled {
+    readonly type = "ChunkedImageLayer";
+    private readonly source_;
+    private readonly sliceCoords_;
+    private readonly onPickValue_?;
+    private readonly visibleChunks_;
+    private readonly pool_;
+    private readonly initialChannelProps_?;
+    private readonly channelChangeCallbacks_;
+    private policy_;
+    private channelProps_?;
+    private chunkManagerSource_?;
+    private pointerDownPos_;
+    private zPrevPointWorld_?;
+    private debugMode_;
+    private static readonly STALE_PRESENTATION_MS_;
+    private lastPresentationTimeStamp_?;
+    private lastPresentationTimeCoord_?;
+    private readonly wireframeColors_;
+    constructor({ source, sliceCoords, policy, channelProps, onPickValue, ...layerOptions }: ChunkedImageLayerProps);
+    onAttached(context: IdetikContext): Promise<void>;
+    onDetached(): void;
+    update(): void;
+    private updateChunks;
+    get lastPresentationTimeCoord(): number | undefined;
+    private isPresentationStale;
+    private resliceIfZChanged;
+    onEvent(event: EventContext): void;
+    get chunkManagerSource(): ChunkManagerSource | undefined;
+    get source(): ChunkSource;
+    get imageSourcePolicy(): Readonly<ImageSourcePolicy>;
+    set imageSourcePolicy(newPolicy: ImageSourcePolicy);
+    private slicePlane;
+    private getImageForChunk;
+    private createImage;
+    private getDataForImage;
+    private updateImageChunk;
+    getValueAtWorld(world: vec3): number | null;
+    private getValueFromChunk;
+    get debugMode(): boolean;
+    set debugMode(debug: boolean);
+    get channelProps(): ChannelProps[] | undefined;
+    setChannelProps(channelProps: ChannelProps[]): void;
+    resetChannelProps(): void;
+    addChannelChangeCallback(callback: () => void): void;
+    removeChannelChangeCallback(callback: () => void): void;
+    private releaseAndRemoveChunks;
+}
+
+declare class VolumeLayer extends Layer {
+    readonly type = "VolumeLayer";
+    constructor();
+    update(): void;
+}
+
+type ImageLayerProps = LayerOptions & {
+    source: ChunkSource;
+    region: Region;
+    channelProps?: ChannelProps[];
+    onPickValue?: (info: PointPickingResult) => void;
+    lod?: number;
+};
+declare class ImageLayer extends Layer implements ChannelsEnabled {
+    readonly type = "ImageLayer";
+    private readonly source_;
+    private readonly region_;
+    private readonly lod_?;
+    private readonly onPickValue_?;
+    private readonly initialChannelProps_?;
+    private readonly channelChangeCallbacks_;
+    private channelProps_?;
+    private image_?;
+    private chunk_?;
+    private extent_?;
+    private pointerDownPos_;
+    constructor({ source, region, channelProps, onPickValue, lod, ...layerOptions }: ImageLayerProps);
+    update(): void;
+    onEvent(event: EventContext): void;
+    get channelProps(): ChannelProps[] | undefined;
+    setChannelProps(channelProps: ChannelProps[]): void;
+    resetChannelProps(): void;
+    addChannelChangeCallback(callback: () => void): void;
+    removeChannelChangeCallback(callback: () => void): void;
+    private load;
+    get extent(): {
+        x: number;
+        y: number;
+    } | undefined;
+    private createImage;
+    getValueAtWorld(world: vec3): number | null;
+}
+
+type LabelColorMapProps = {
+    lookupTable?: ReadonlyMap<number, ColorLike>;
+    cycle?: ColorLike[];
+};
+declare class LabelColorMap {
+    readonly lookupTable: ReadonlyMap<number, Color>;
+    readonly cycle: ReadonlyArray<Color>;
+    constructor(props?: LabelColorMapProps);
+}
+
+type LabelImageLayerProps = LayerOptions & {
+    source: ChunkSource;
+    region: Region;
+    colorMap?: LabelColorMapProps;
+    onPickValue?: (info: PointPickingResult) => void;
+    lod?: number;
+    outlineSelected?: boolean;
+};
+declare class LabelImageLayer extends Layer {
+    readonly type = "LabelImageLayer";
+    private readonly source_;
+    private readonly region_;
+    private readonly lod_?;
+    private colorMap_;
+    private readonly onPickValue_?;
+    private readonly outlineSelected_;
+    private image_?;
+    private imageChunk_?;
+    private pointerDownPos_;
+    private selectedValue_;
+    constructor({ source, region, colorMap, onPickValue, lod, outlineSelected, ...layerOptions }: LabelImageLayerProps);
+    update(): void;
+    get colorMap(): LabelColorMap;
+    setColorMap(colorMap: LabelColorMapProps): void;
+    setSelectedValue(value: number | null): void;
+    onEvent(event: EventContext): void;
+    private load;
+    private createImage;
+    getValueAtWorld(world: vec3): number | null;
+}
+
+type SetIndexResult = {
+    success: boolean;
+    reason?: "duplicate" | "canceled";
+    chunk?: Chunk;
+};
+
+type ImageSeriesLayerProps = LayerOptions & {
+    source: ChunkSource;
+    region: Region;
+    seriesDimensionName: string;
+    channelProps?: ChannelProps[];
+    lod?: number;
+};
+declare class ImageSeriesLayer extends Layer implements ChannelsEnabled {
+    readonly type = "ImageSeriesLayer";
+    private readonly seriesLoader_;
+    private readonly initialChannelProps_?;
+    private readonly channelChangeCallbacks_;
+    private channelProps_?;
+    private texture_;
+    private image_?;
+    private extent_?;
+    constructor({ source, region, seriesDimensionName, channelProps, lod, ...layerOptions }: ImageSeriesLayerProps);
+    update(): void;
+    get channelProps(): ChannelProps[] | undefined;
+    setChannelProps(channelProps: ChannelProps[]): void;
+    resetChannelProps(): void;
+    addChannelChangeCallback(callback: () => void): void;
+    removeChannelChangeCallback(callback: () => void): void;
+    setPosition(position: number): Promise<SetIndexResult>;
+    setIndex(index: number): Promise<SetIndexResult>;
+    close(): void;
+    preloadSeries(): Promise<undefined>;
+    get extent(): {
+        x: number;
+        y: number;
+    } | undefined;
+    private processIndexResult;
+    private setData;
+    private createImage;
+}
+
+/**The zarr.json attributes key*/
+declare const Image$1: z.ZodObject<{
+    /**The versioned OME-Zarr Metadata namespace*/
+    ome: z.ZodObject<{
+        /**The multiscale datasets for this image*/
+        multiscales: z.ZodArray<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            datasets: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                coordinateTransformations: z.ZodArray<z.ZodEffects<z.ZodAny, any, any>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                coordinateTransformations: any[];
+            }, {
+                path: string;
+                coordinateTransformations: any[];
+            }>, "many">;
+            axes: z.ZodArray<z.ZodEffects<z.ZodAny, any, any>, "many">;
+            coordinateTransformations: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodAny, any, any>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            datasets: {
+                path: string;
+                coordinateTransformations: any[];
+            }[];
+            axes: any[];
+            name?: string | undefined;
+            coordinateTransformations?: any[] | undefined;
+        }, {
+            datasets: {
+                path: string;
+                coordinateTransformations: any[];
+            }[];
+            axes: any[];
+            name?: string | undefined;
+            coordinateTransformations?: any[] | undefined;
+        }>, "many">;
+        omero: z.ZodOptional<z.ZodObject<{
+            channels: z.ZodArray<z.ZodObject<{
+                window: z.ZodOptional<z.ZodObject<{
+                    end: z.ZodNumber;
+                    max: z.ZodNumber;
+                    min: z.ZodNumber;
+                    start: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    min: number;
+                    max: number;
+                    end: number;
+                    start: number;
+                }, {
+                    min: number;
+                    max: number;
+                    end: number;
+                    start: number;
+                }>>;
+                label: z.ZodOptional<z.ZodString>;
+                family: z.ZodOptional<z.ZodString>;
+                color: z.ZodOptional<z.ZodString>;
+                active: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                color?: string | undefined;
+                window?: {
+                    min: number;
+                    max: number;
+                    end: number;
+                    start: number;
+                } | undefined;
+                label?: string | undefined;
+                family?: string | undefined;
+                active?: boolean | undefined;
+            }, {
+                color?: string | undefined;
+                window?: {
+                    min: number;
+                    max: number;
+                    end: number;
+                    start: number;
+                } | undefined;
+                label?: string | undefined;
+                family?: string | undefined;
+                active?: boolean | undefined;
+            }>, "many">;
+            rdefs: z.ZodOptional<z.ZodObject<{
+                defaultT: z.ZodOptional<z.ZodNumber>;
+                defaultZ: z.ZodOptional<z.ZodNumber>;
+                color: z.ZodOptional<z.ZodEnum<["color", "greyscale"]>>;
+                projection: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                color?: "color" | "greyscale" | undefined;
+                defaultT?: number | undefined;
+                defaultZ?: number | undefined;
+                projection?: string | undefined;
+            }, {
+                color?: "color" | "greyscale" | undefined;
+                defaultT?: number | undefined;
+                defaultZ?: number | undefined;
+                projection?: string | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            channels: {
+                color?: string | undefined;
+                window?: {
+                    min: number;
+                    max: number;
+                    end: number;
+                    start: number;
+                } | undefined;
+                label?: string | undefined;
+                family?: string | undefined;
+                active?: boolean | undefined;
+            }[];
+            rdefs?: {
+                color?: "color" | "greyscale" | undefined;
+                defaultT?: number | undefined;
+                defaultZ?: number | undefined;
+                projection?: string | undefined;
+            } | undefined;
+        }, {
+            channels: {
+                color?: string | undefined;
+                window?: {
+                    min: number;
+                    max: number;
+                    end: number;
+                    start: number;
+                } | undefined;
+                label?: string | undefined;
+                family?: string | undefined;
+                active?: boolean | undefined;
+            }[];
+            rdefs?: {
+                color?: "color" | "greyscale" | undefined;
+                defaultT?: number | undefined;
+                defaultZ?: number | undefined;
+                projection?: string | undefined;
+            } | undefined;
+        }>>;
+        /**The version of the OME-Zarr Metadata*/
+        version: z.ZodLiteral<"0.5">;
+    }, "strip", z.ZodTypeAny, {
+        multiscales: {
+            datasets: {
+                path: string;
+                coordinateTransformations: any[];
+            }[];
+            axes: any[];
+            name?: string | undefined;
+            coordinateTransformations?: any[] | undefined;
+        }[];
+        version: "0.5";
+        omero?: {
+            channels: {
+                color?: string | undefined;
+                window?: {
+                    min: number;
+                    max: number;
+                    end: number;
+                    start: number;
+                } | undefined;
+                label?: string | undefined;
+                family?: string | undefined;
+                active?: boolean | undefined;
+            }[];
+            rdefs?: {
+                color?: "color" | "greyscale" | undefined;
+                defaultT?: number | undefined;
+                defaultZ?: number | undefined;
+                projection?: string | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        multiscales: {
+            datasets: {
+                path: string;
+                coordinateTransformations: any[];
+            }[];
+            axes: any[];
+            name?: string | undefined;
+            coordinateTransformations?: any[] | undefined;
+        }[];
+        version: "0.5";
+        omero?: {
+            channels: {
+                color?: string | undefined;
+                window?: {
+                    min: number;
+                    max: number;
+                    end: number;
+                    start: number;
+                } | undefined;
+                label?: string | undefined;
+                family?: string | undefined;
+                active?: boolean | undefined;
+            }[];
+            rdefs?: {
+                color?: "color" | "greyscale" | undefined;
+                defaultT?: number | undefined;
+                defaultZ?: number | undefined;
+                projection?: string | undefined;
+            } | undefined;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    ome: {
+        multiscales: {
+            datasets: {
+                path: string;
+                coordinateTransformations: any[];
+            }[];
+            axes: any[];
+            name?: string | undefined;
+            coordinateTransformations?: any[] | undefined;
+        }[];
+        version: "0.5";
+        omero?: {
+            channels: {
+                color?: string | undefined;
+                window?: {
+                    min: number;
+                    max: number;
+                    end: number;
+                    start: number;
+                } | undefined;
+                label?: string | undefined;
+                family?: string | undefined;
+                active?: boolean | undefined;
+            }[];
+            rdefs?: {
+                color?: "color" | "greyscale" | undefined;
+                defaultT?: number | undefined;
+                defaultZ?: number | undefined;
+                projection?: string | undefined;
+            } | undefined;
+        } | undefined;
+    };
+}, {
+    ome: {
+        multiscales: {
+            datasets: {
+                path: string;
+                coordinateTransformations: any[];
+            }[];
+            axes: any[];
+            name?: string | undefined;
+            coordinateTransformations?: any[] | undefined;
+        }[];
+        version: "0.5";
+        omero?: {
+            channels: {
+                color?: string | undefined;
+                window?: {
+                    min: number;
+                    max: number;
+                    end: number;
+                    start: number;
+                } | undefined;
+                label?: string | undefined;
+                family?: string | undefined;
+                active?: boolean | undefined;
+            }[];
+            rdefs?: {
+                color?: "color" | "greyscale" | undefined;
+                defaultT?: number | undefined;
+                defaultZ?: number | undefined;
+                projection?: string | undefined;
+            } | undefined;
+        } | undefined;
+    };
+}>;
+type Image$1 = z.infer<typeof Image$1>;
+
+type Version$1 = "v2" | "v3";
+type ZarrArrayParams = {
+    arrayPath: string;
+    zarrVersion: Version$1 | undefined;
+} & ({
+    type: "fetch";
+    url: string;
+    fetchOptions?: {
+        overrides?: RequestInit;
+        useSuffixRequest?: boolean;
+    };
+} | {
+    type: "filesystem";
+    directoryHandle: FileSystemDirectoryHandle;
+    path: string;
+});
+
+type OmeZarrImageLoaderProps = {
+    metadata: Image$1["ome"]["multiscales"][number];
+    arrays: zarr.Array<zarr.DataType, Readable>[];
+    arrayParams: ZarrArrayParams[];
+};
+declare class OmeZarrImageLoader {
+    private readonly metadata_;
+    private readonly arrays_;
+    private readonly arrayParams_;
+    private readonly loaderAttributes_;
+    private readonly dimensions_;
+    constructor(props: OmeZarrImageLoaderProps);
+    getSourceDimensionMap(): SourceDimensionMap;
+    loadChunkData(chunk: Chunk, signal: AbortSignal): Promise<void>;
+    private trimChunkPadding;
+    loadRegion(region: Region, lod: number, scheduler?: PromiseScheduler): Promise<Chunk>;
+    getAttributes(): ReadonlyArray<LoaderAttributes>;
+    private regionToIndices;
+}
+
+/**The zarr.json attributes key*/
+declare const Plate: z.ZodObject<{
+    /**The versioned OME-Zarr Metadata namespace*/
+    ome: z.ZodObject<{
+        plate: z.ZodObject<{
+            /**The acquisitions for this plate*/
+            acquisitions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                /**A unique identifier within the context of the plate*/
+                id: z.ZodNumber;
+                /**The maximum number of fields of view for the acquisition*/
+                maximumfieldcount: z.ZodOptional<z.ZodNumber>;
+                /**The name of the acquisition*/
+                name: z.ZodOptional<z.ZodString>;
+                /**The description of the acquisition*/
+                description: z.ZodOptional<z.ZodString>;
+                /**The start timestamp of the acquisition, expressed as epoch time i.e. the number seconds since the Epoch*/
+                starttime: z.ZodOptional<z.ZodNumber>;
+                /**The end timestamp of the acquisition, expressed as epoch time i.e. the number seconds since the Epoch*/
+                endtime: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }, {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }>, "many">>;
+            /**The maximum number of fields per view across all wells*/
+            field_count: z.ZodOptional<z.ZodNumber>;
+            /**The name of the plate*/
+            name: z.ZodOptional<z.ZodString>;
+            /**The columns of the plate*/
+            columns: z.ZodArray<z.ZodObject<{
+                /**The column name*/
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>, "many">;
+            /**The rows of the plate*/
+            rows: z.ZodArray<z.ZodObject<{
+                /**The row name*/
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>, "many">;
+            /**The wells of the plate*/
+            wells: z.ZodArray<z.ZodObject<{
+                /**The path to the well subgroup*/
+                path: z.ZodString;
+                /**The index of the well in the rows list*/
+                rowIndex: z.ZodNumber;
+                /**The index of the well in the columns list*/
+                columnIndex: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }, {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            columns: {
+                name: string;
+            }[];
+            rows: {
+                name: string;
+            }[];
+            wells: {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }[];
+            name?: string | undefined;
+            acquisitions?: {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }[] | undefined;
+            field_count?: number | undefined;
+        }, {
+            columns: {
+                name: string;
+            }[];
+            rows: {
+                name: string;
+            }[];
+            wells: {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }[];
+            name?: string | undefined;
+            acquisitions?: {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }[] | undefined;
+            field_count?: number | undefined;
+        }>;
+        /**The version of the OME-Zarr Metadata*/
+        version: z.ZodLiteral<"0.5">;
+    }, "strip", z.ZodTypeAny, {
+        version: "0.5";
+        plate: {
+            columns: {
+                name: string;
+            }[];
+            rows: {
+                name: string;
+            }[];
+            wells: {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }[];
+            name?: string | undefined;
+            acquisitions?: {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }[] | undefined;
+            field_count?: number | undefined;
+        };
+    }, {
+        version: "0.5";
+        plate: {
+            columns: {
+                name: string;
+            }[];
+            rows: {
+                name: string;
+            }[];
+            wells: {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }[];
+            name?: string | undefined;
+            acquisitions?: {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }[] | undefined;
+            field_count?: number | undefined;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    ome: {
+        version: "0.5";
+        plate: {
+            columns: {
+                name: string;
+            }[];
+            rows: {
+                name: string;
+            }[];
+            wells: {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }[];
+            name?: string | undefined;
+            acquisitions?: {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }[] | undefined;
+            field_count?: number | undefined;
+        };
+    };
+}, {
+    ome: {
+        version: "0.5";
+        plate: {
+            columns: {
+                name: string;
+            }[];
+            rows: {
+                name: string;
+            }[];
+            wells: {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }[];
+            name?: string | undefined;
+            acquisitions?: {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }[] | undefined;
+            field_count?: number | undefined;
+        };
+    };
+}>;
+type Plate = z.infer<typeof Plate>;
+
+/**JSON from OME-Zarr zarr.json*/
+declare const Well: z.ZodObject<{
+    /**The versioned OME-Zarr Metadata namespace*/
+    ome: z.ZodObject<{
+        well: z.ZodObject<{
+            /**The fields of view for this well*/
+            images: z.ZodArray<z.ZodObject<{
+                /**A unique identifier within the context of the plate*/
+                acquisition: z.ZodOptional<z.ZodNumber>;
+                /**The path for this field of view subgroup*/
+                path: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                acquisition?: number | undefined;
+            }, {
+                path: string;
+                acquisition?: number | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            images: {
+                path: string;
+                acquisition?: number | undefined;
+            }[];
+        }, {
+            images: {
+                path: string;
+                acquisition?: number | undefined;
+            }[];
+        }>;
+        /**The version of the OME-Zarr Metadata*/
+        version: z.ZodLiteral<"0.5">;
+    }, "strip", z.ZodTypeAny, {
+        version: "0.5";
+        well: {
+            images: {
+                path: string;
+                acquisition?: number | undefined;
+            }[];
+        };
+    }, {
+        version: "0.5";
+        well: {
+            images: {
+                path: string;
+                acquisition?: number | undefined;
+            }[];
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    ome: {
+        version: "0.5";
+        well: {
+            images: {
+                path: string;
+                acquisition?: number | undefined;
+            }[];
+        };
+    };
+}, {
+    ome: {
+        version: "0.5";
+        well: {
+            images: {
+                path: string;
+                acquisition?: number | undefined;
+            }[];
+        };
+    };
+}>;
+type Well = z.infer<typeof Well>;
+
+declare const versions: readonly ["0.4", "0.5"];
+type Version = (typeof versions)[number];
+type AdaptedOme<T> = T & {
+    originalVersion: Version;
+};
+declare function loadOmeZarrPlate(url: string, version?: Version): Promise<AdaptedOme<Plate["ome"]>>;
+declare function loadOmeZarrWell(url: string, path: string, version?: Version): Promise<AdaptedOme<Well["ome"]>>;
+type OmeroMetadata = NonNullable<Image$1["ome"]["omero"]>;
+type OmeroChannel = OmeroMetadata["channels"][number];
+declare function loadOmeroChannels(source: OmeZarrImageSource): Promise<OmeroChannel[]>;
+declare function loadOmeroDefaults(source: OmeZarrImageSource): Promise<OmeroMetadata["rdefs"]>;
+
+/** Options for customizing fetch requests, such as adding authentication headers for private S3 data */
+type FetchOptions = {
+    /** RequestInit overrides to customize fetch behavior (e.g., custom headers for S3 authentication) */
+    overrides?: RequestInit;
+    /** Whether to use suffix requests for range queries */
+    useSuffixRequest?: boolean;
+};
+/** Opens an OME-Zarr multiscale image Zarr group from either a URL or local directory. */
+declare class OmeZarrImageSource {
+    readonly location: Location<Readable>;
+    readonly version?: Version;
+    readonly fetchOptions?: FetchOptions;
+    /**
+     * @param url URL of Zarr root
+     * @param version OME-Zarr version
+     * @param fetchOptions Optional fetch configuration (e.g., authentication headers for private S3 data)
+     */
+    constructor(url: string, version?: Version, fetchOptions?: FetchOptions);
+    /**
+     * @param directory return value of `window.showDirectoryPicker()` which gives the browser
+     *    permission to access a directory (only works in Chrome/Edge)
+     * @param version OME-Zarr version
+     * @param path path to image, beginning with "/". This argument allows the application to only
+     *    ask the user once for permission to the root directory
+     */
+    constructor(directory: FileSystemDirectoryHandle, version?: Version, path?: `/${string}`);
+    open(): Promise<OmeZarrImageLoader>;
+}
+
+declare class Plane {
+    normal: vec3;
+    signedDistance: number;
+    constructor(normal?: vec3, distance?: number);
+    set(normal: vec3, distance: number): void;
+    signedDistanceToPoint(point: vec3): number;
+    normalize(): void;
+}
+
+declare class Spherical {
+    radius: number;
+    phi: number;
+    theta: number;
+    constructor(radius: number, phi: number, theta: number);
+    toVec3(): vec3;
+}
+
+/**JSON from OME-NGFF .zattrs*/
+declare const Image: z.ZodObject<{
+    /**The multiscale datasets for this image*/
+    multiscales: z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        datasets: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            coordinateTransformations: z.ZodArray<z.ZodEffects<z.ZodAny, any, any>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            coordinateTransformations: any[];
+        }, {
+            path: string;
+            coordinateTransformations: any[];
+        }>, "many">;
+        version: z.ZodOptional<z.ZodLiteral<"0.4">>;
+        axes: z.ZodArray<z.ZodEffects<z.ZodAny, any, any>, "many">;
+        coordinateTransformations: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodAny, any, any>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        datasets: {
+            path: string;
+            coordinateTransformations: any[];
+        }[];
+        axes: any[];
+        name?: string | undefined;
+        coordinateTransformations?: any[] | undefined;
+        version?: "0.4" | undefined;
+    }, {
+        datasets: {
+            path: string;
+            coordinateTransformations: any[];
+        }[];
+        axes: any[];
+        name?: string | undefined;
+        coordinateTransformations?: any[] | undefined;
+        version?: "0.4" | undefined;
+    }>, "many">;
+    omero: z.ZodOptional<z.ZodObject<{
+        channels: z.ZodArray<z.ZodObject<{
+            window: z.ZodObject<{
+                end: z.ZodNumber;
+                max: z.ZodNumber;
+                min: z.ZodNumber;
+                start: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                min: number;
+                max: number;
+                end: number;
+                start: number;
+            }, {
+                min: number;
+                max: number;
+                end: number;
+                start: number;
+            }>;
+            label: z.ZodOptional<z.ZodString>;
+            family: z.ZodOptional<z.ZodString>;
+            color: z.ZodString;
+            active: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            color: string;
+            window: {
+                min: number;
+                max: number;
+                end: number;
+                start: number;
+            };
+            label?: string | undefined;
+            family?: string | undefined;
+            active?: boolean | undefined;
+        }, {
+            color: string;
+            window: {
+                min: number;
+                max: number;
+                end: number;
+                start: number;
+            };
+            label?: string | undefined;
+            family?: string | undefined;
+            active?: boolean | undefined;
+        }>, "many">;
+        rdefs: z.ZodOptional<z.ZodObject<{
+            defaultT: z.ZodOptional<z.ZodNumber>;
+            defaultZ: z.ZodOptional<z.ZodNumber>;
+            color: z.ZodOptional<z.ZodEnum<["color", "greyscale"]>>;
+            projection: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            color?: "color" | "greyscale" | undefined;
+            defaultT?: number | undefined;
+            defaultZ?: number | undefined;
+            projection?: string | undefined;
+        }, {
+            color?: "color" | "greyscale" | undefined;
+            defaultT?: number | undefined;
+            defaultZ?: number | undefined;
+            projection?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        channels: {
+            color: string;
+            window: {
+                min: number;
+                max: number;
+                end: number;
+                start: number;
+            };
+            label?: string | undefined;
+            family?: string | undefined;
+            active?: boolean | undefined;
+        }[];
+        rdefs?: {
+            color?: "color" | "greyscale" | undefined;
+            defaultT?: number | undefined;
+            defaultZ?: number | undefined;
+            projection?: string | undefined;
+        } | undefined;
+    }, {
+        channels: {
+            color: string;
+            window: {
+                min: number;
+                max: number;
+                end: number;
+                start: number;
+            };
+            label?: string | undefined;
+            family?: string | undefined;
+            active?: boolean | undefined;
+        }[];
+        rdefs?: {
+            color?: "color" | "greyscale" | undefined;
+            defaultT?: number | undefined;
+            defaultZ?: number | undefined;
+            projection?: string | undefined;
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    multiscales: {
+        datasets: {
+            path: string;
+            coordinateTransformations: any[];
+        }[];
+        axes: any[];
+        name?: string | undefined;
+        coordinateTransformations?: any[] | undefined;
+        version?: "0.4" | undefined;
+    }[];
+    omero?: {
+        channels: {
+            color: string;
+            window: {
+                min: number;
+                max: number;
+                end: number;
+                start: number;
+            };
+            label?: string | undefined;
+            family?: string | undefined;
+            active?: boolean | undefined;
+        }[];
+        rdefs?: {
+            color?: "color" | "greyscale" | undefined;
+            defaultT?: number | undefined;
+            defaultZ?: number | undefined;
+            projection?: string | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    multiscales: {
+        datasets: {
+            path: string;
+            coordinateTransformations: any[];
+        }[];
+        axes: any[];
+        name?: string | undefined;
+        coordinateTransformations?: any[] | undefined;
+        version?: "0.4" | undefined;
+    }[];
+    omero?: {
+        channels: {
+            color: string;
+            window: {
+                min: number;
+                max: number;
+                end: number;
+                start: number;
+            };
+            label?: string | undefined;
+            family?: string | undefined;
+            active?: boolean | undefined;
+        }[];
+        rdefs?: {
+            color?: "color" | "greyscale" | undefined;
+            defaultT?: number | undefined;
+            defaultZ?: number | undefined;
+            projection?: string | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+type Image = z.infer<typeof Image>;
+
+declare class Texture2DArray extends Texture {
+    private data_;
+    private readonly width_;
+    private readonly height_;
+    private readonly depth_;
+    constructor(data: DataTextureTypedArray, width: number, height: number);
+    get type(): string;
+    set data(data: DataTextureTypedArray);
+    get data(): DataTextureTypedArray;
+    get width(): number;
+    get height(): number;
+    get depth(): number;
+    updateWithChunk(chunk: Chunk, data?: ChunkData): void;
+    static createWithChunk(chunk: Chunk, data?: ChunkData): Texture2DArray;
+}
+
+type PointProperties = {
+    position: vec3;
+    color: Color;
+    size: number;
+    markerIndex: number;
+};
+declare class Points extends RenderableObject {
+    private atlas_;
+    constructor(points: PointProperties[], markerAtlas: Texture2DArray);
+    get type(): string;
+}
+
+declare class Texture3D extends Texture {
+    private data_;
+    private readonly width_;
+    private readonly height_;
+    private readonly depth_;
+    constructor(data: DataTextureTypedArray, width: number, height: number, depth: number);
+    set data(data: DataTextureTypedArray);
+    get type(): string;
+    get data(): DataTextureTypedArray;
+    get width(): number;
+    get height(): number;
+    get depth(): number;
+    updateWithChunk(chunk: Chunk): void;
+    static createWithChunk(chunk: Chunk): Texture3D;
+}
+
+export { AxesLayer, Box2, Box3, type CameraControls, type ChannelProps, type ChannelsEnabled, type Chunk, type ChunkLoader, ChunkedImageLayer, Color, type ColorLike, EventContext, type FetchOptions, Frustum, Idetik, ImageLayer, ImageSeriesLayer, type ImageSourcePolicy, type ImageSourcePolicyConfig, LabelImageLayer, Layer, LayerManager, type LayerState, Image as OmeZarrImage, OmeZarrImageSource, type OmeroChannel, type OmeroMetadata, OrthographicCamera, PanZoomControls, PerspectiveCamera, Plane, type PointPickingResult, Points, type PriorityCategory, ProjectedLineLayer, type Region, type SliceCoordinates, Spherical, Texture2DArray, Texture3D, TracksLayer, Viewport, type ViewportConfig, VolumeLayer, WebGLRenderer, createExplorationPolicy, createImageSourcePolicy, createNoPrefetchPolicy, createPlaybackPolicy, loadOmeZarrPlate, loadOmeZarrWell, loadOmeroChannels, loadOmeroDefaults, parseViewportConfigs };