import * as zarr from 'zarrita';

/**
 * Model for an element of `Multiscale.axes`.
 *
 * See https://ngff.openmicroscopy.org/0.4/#axes-md.
 */
export declare interface Axis {
    name: string;
    type?: string | null;
    unit?: unknown;
    [k: string]: unknown;
}

declare type Blending = "additive" | "translucent";

declare const BLUE_ORANGE_ICB: number[][];

declare const BRGBCMYW: number[][];

/**
 * A single omero channel.
 */
export declare interface Channel {
    color: string;
    window: Window_2;
    lut?: Color[];
    colorMap?: Map<number, Color>;
    active?: boolean;
    inverted?: boolean;
    [k: string]: unknown;
}

declare const CIVIDIS: number[][];

declare type Color = [number, number, number] | [number, number, number, number];

declare const COOL: number[][];

declare interface CoordinateSystem {
    name: string;
    axes: Axis[];
}

export declare function createRgbDataUrl(rbgData: Uint8ClampedArray, width: number): Promise<string>;

declare const CYAN_HOT: number[][];

/**
 * An element of Multiscale.datasets.
 */
export declare interface Dataset {
    path: string;
    coordinateTransformations: Array<Scale | Translation>;
    [k: string]: unknown;
}

declare const EDGES: number[][];

export declare const FILL_VALUE_KEY: number;

declare const FIRE: number[][];

declare const FIVE_RAMPS: number[][];

declare const GEM: number[][];

export declare function getArray(src: zarr.Group<zarr.Readable> | zarr.Readable | string, path?: string, zarr_version?: 2 | 3, options?: {
    signal?: AbortSignal;
}): Promise<zarr.Array<zarr.DataType>>;

export declare function getLutRgb(name: string): number[][];

export declare function getLuts(): {
    name: string;
    png: string;
}[];

export declare function getMinMaxValues(chunk2d: any): [number, number];

export declare function getMultiscale(group: zarr.Group<zarr.Readable> | zarr.Readable | string, options?: {
    signal?: AbortSignal;
}): Promise<{
    multiscale: Multiscale;
    omero: Omero | null | undefined;
    zarr_version: 2 | 3;
}>;

export declare function getMultiscaleWithArray(group: zarr.Group<zarr.Readable> | zarr.Readable | string, datasetIndex?: number, options?: {
    signal?: AbortSignal;
}): Promise<{
    arr: zarr.Array<any>;
    shapes: number[][] | undefined;
    multiscale: Multiscale;
    omero: Omero | null | undefined;
    scales: number[][];
    zarr_version: 2 | 3;
}>;

export declare function getPixelValueRange(dtype: string): {
    min: number;
    max: number;
};

export declare function getSlices(activeChannelIndices: number[], shape: number[], axesNames: string[], indices: {
    [k: string]: number | [number, number] | undefined;
}): (number | Slice | undefined)[][];

declare const GLASBEY: number[][];

declare const GLASBEY_INVERTED: number[][];

declare const GLOW: number[][];

declare const GRAYS: number[][];

declare const GREEN_FIRE_BLUE: number[][];

declare const HILO: number[][];

declare const ICA: number[][];

declare const ICA2: number[][];

declare const ICA3: number[][];

declare const ICE: number[][];

/**
 * Model for the metadata of OME-Zarr data.
 *
 * See https://ngff.openmicroscopy.org/0.4/#image-layout.
 */
export declare interface ImageAttrs {
    /**
     * The multiscale datasets for this image
     *
     * @minItems 1
     */
    multiscales: [Multiscale, ...Multiscale[]];
    omero?: Omero;
    version: string;
    [k: string]: unknown;
}

declare interface ImageAttrsV5 {
    ome: ImageAttrs;
}

declare const INFERNO: number[][];

export declare class LabelsImage extends NgffImage {
    constructor(attrs: OmeAttrs, store: zarr.Group<zarr.Readable> | zarr.Readable);
    static load(store: zarr.Group<zarr.Readable> | zarr.Readable | string, options?: {
        datasetIndex?: number;
        attrs?: OmeAttrs;
        signal?: AbortSignal;
    }): Promise<NgffImage>;
}

export declare const LUTS: {
    path: string;
    name: string;
    rgb: number[][];
}[];

export declare namespace luts {
    export {
        getLuts,
        getLutRgb,
        lutToPng,
        SIXTEEN_COLORS,
        THREE_THREE_TWO_RGB,
        FIVE_RAMPS,
        SIX_SHADES,
        BLUE_ORANGE_ICB,
        BRGBCMYW,
        CIVIDIS,
        COOL,
        CYAN_HOT,
        EDGES,
        FIRE,
        GEM,
        GLASBEY,
        GLASBEY_INVERTED,
        GLOW,
        GRAYS,
        GREEN_FIRE_BLUE,
        HILO,
        ICA,
        ICA2,
        ICA3,
        ICE,
        INFERNO,
        MAGENTA_HOT,
        MAGMA,
        MAKO,
        ORANGE_HOT,
        PHASE,
        PHYSICS,
        PLASMA,
        PUP_BR,
        PUP_NR,
        RAINBOW_RGB,
        RED_GREEN,
        RED_HOT,
        ROCKET,
        ROYAL,
        SEPIA,
        SMART,
        SPECTRUM,
        THAL,
        THALLIUM,
        THERMAL,
        TURBO,
        UNIONJACK,
        VIRIDIS,
        YELLOW_HOT,
        LUTS
    }
}

declare function lutToPng(lutRgb: Rgb): string;

declare const MAGENTA_HOT: number[][];

declare const MAGMA: number[][];

declare const MAKO: number[][];

/**
 * An element of multiscales metadata.
 */
export declare interface Multiscale {
    axes: Axis[];
    /**
     * @minItems 1
     */
    datasets: [Dataset, ...Dataset[]];
    version?: string;
    coordinateTransformations?: [unknown] | [unknown, unknown] | null;
    coordinateSystems?: CoordinateSystem[] | null;
    metadata?: {
        [k: string]: unknown;
    };
    name?: unknown;
    type?: {
        [k: string]: unknown;
    };
    [k: string]: unknown;
}

export declare class NgffImage {
    /**
     * This is the main Image class for the API. It handles both v0.4 and v0.5 formats,
     * and provides a consistent interface for accessing the multiscale datasets,
     * omero metadata, and zarr version.
     *
     * @minItems 1
     */
    attrs: OmeAttrs;
    imgAttrs: ImageAttrs;
    store: zarr.Group<zarr.Readable> | zarr.Readable;
    multiscales: [Multiscale, ...Multiscale[]];
    paths: string[];
    scales: number[][];
    shapes?: number[][];
    arrays: {
        [key: string]: zarr.Array<any>;
    };
    omero?: Omero;
    axes: Axis[];
    zarr_version: 2 | 3;
    omezarr_version: string;
    [k: string]: unknown;
    constructor(attrs: OmeAttrs, store: zarr.Group<zarr.Readable> | zarr.Readable);
    static load(store: zarr.Group<zarr.Readable> | zarr.Readable | string, options?: {
        datasetIndex?: number;
        attrs?: OmeAttrs;
        signal?: AbortSignal;
    }): Promise<NgffImage>;
    checkChannelIndex(channelIndex: number): Omero;
    setChannelActive(channelIndex: number, active: boolean): void;
    setChannelColor(channelIndex: number, color: string): void;
    setChannelStart(channelIndex: number, start: number): void;
    setChannelEnd(channelIndex: number, end: number): void;
    setChannelInverted(channelIndex: number, inverted: boolean): void;
    setChannelLut(channelIndex: number, lut: Color[] | undefined): void;
    setChannelColorMap(channelIndex: number, colorMap: Map<number, Color>): void;
    setZIndex(zIndex: number): void;
    setTIndex(tIndex: number): void;
    getShape(datasetIndex?: number): Promise<number[]>;
    getAxesNames(): string[];
    getVersion(): string;
    getZarrVersion(): 2 | 3;
    getLabelsPaths(): Promise<string[]>;
    getNeuroglancerUrl(): Promise<string>;
    openArray(pathOrIndex: string | number, options?: {
        signal?: AbortSignal;
    }): Promise<zarr.Array<any>>;
    calcShapes(datasetIndex?: number): Promise<number[][]>;
    getScales(): number[][];
    getPathForTargetSize(targetSize: number, datasetIndex?: number): Promise<string>;
    renderArray(options?: {
        arr?: zarr.Array<any> | string;
        targetSize?: number;
        arrayPathOrIndex?: string | number;
        slices?: {
            [k: string]: number | [number, number] | undefined;
        };
        autoBoost?: boolean;
        channels?: Channel[];
        maxSize?: number;
        signal?: AbortSignal;
        calcMinMaxForRange?: boolean;
    }): Promise<{
        data: Uint8ClampedArray;
        width: number;
        height: number;
    }>;
    render(options?: {
        arr?: zarr.Array<any> | string;
        targetSize?: number;
        arrayPathOrIndex?: string | number;
        slices?: {
            [k: string]: number | [number, number] | undefined;
        };
        autoBoost?: boolean;
        channels?: Channel[];
        maxSize?: number;
        signal?: AbortSignal;
        calcMinMaxForRange?: boolean;
    }): Promise<string>;
}

declare type OmeAttrs = ImageAttrs | ImageAttrsV5;

/**
 * omero model.
 */
export declare interface Omero {
    channels: Channel[];
    rdefs: {
        defaultT: number;
        defaultZ: number;
        model: "greyscale" | "color";
    };
    [k: string]: unknown;
}

export declare function openArray(src: zarr.Group<zarr.Readable> | zarr.Readable | string, path?: string, zarr_version?: 2 | 3, options?: {
    signal?: AbortSignal;
}): Promise<zarr.Array<zarr.DataType>>;

export declare function openGroup(src: zarr.Group<zarr.Readable> | zarr.Readable | string, path?: string, zarr_version?: 2 | 3, options?: {
    signal?: AbortSignal;
}): Promise<zarr.Group<zarr.Readable>>;

declare const ORANGE_HOT: number[][];

declare const PHASE: number[][];

declare const PHYSICS: number[][];

declare const PLASMA: number[][];

declare const PUP_BR: number[][];

declare const PUP_NR: number[][];

declare const RAINBOW_RGB: number[][];

declare const RED_GREEN: number[][];

declare const RED_HOT: number[][];

export declare function render(store: zarr.Group<zarr.Readable> | zarr.Readable | string, targetSize?: number, options?: {
    autoBoost?: boolean;
    maxSize?: number;
    attrs?: OmeAttrs;
    signal?: AbortSignal;
    datasetIndex?: number;
}): Promise<string>;

export declare function renderChunk(chunk: zarr.Chunk<zarr.NumberDataType | zarr.BigintDataType>, transferFunc: (value: number) => Color, options?: {
    dst?: Uint8ClampedArray;
    blending?: Blending;
}): Uint8ClampedArray;

export declare function renderChunks(ndChunks: any, ranges: Array<[number, number] | undefined>, colors: Array<[number, number, number]>, lutsOrColorMaps: Array<Color[] | Map<number, Color> | undefined> | undefined, inverteds: Array<boolean> | undefined, autoBoost?: boolean): Uint8ClampedArray;

export declare function renderChunkWithColormap(chunk: zarr.Chunk<zarr.NumberDataType | zarr.BigintDataType>, colormap: Map<number, Color>, options?: {
    dst?: Uint8ClampedArray;
    blending?: Blending;
    fillValue?: Color;
}): Uint8ClampedArray;

export declare function renderChunkWithLUT(chunk: zarr.Chunk<zarr.NumberDataType | zarr.BigintDataType>, lut: Color[], options?: {
    dst?: Uint8ClampedArray;
    blending?: Blending;
    range?: [number, number];
}): Uint8ClampedArray;

export declare function renderImage(arr: zarr.Array<any>, axes: Axis[], channels: Channel[] | null | undefined, sliceIndices?: {
    [k: string]: number | [number, number] | undefined;
}, autoBoost?: boolean): Promise<string>;

export declare function renderThumbnail(store: zarr.FetchStore | string, targetSize?: number | undefined, autoBoost?: boolean, maxSize?: number, options?: {
    signal?: AbortSignal;
}): Promise<string>;

declare type Rgb = Array<[number, number, number]>;

declare const ROCKET: number[][];

declare const ROYAL: number[][];

/**
 * Coordinate transformations....
 */
declare interface Scale {
    type: "scale";
    scale: number[];
}

declare const SEPIA: number[][];

declare const SIX_SHADES: number[][];

declare const SIXTEEN_COLORS: number[][];

declare interface Slice {
    start: number | null;
    stop: number | null;
    step: number | null;
}

declare const SMART: number[][];

declare const SPECTRUM: number[][];

declare const THAL: number[][];

declare const THALLIUM: number[][];

declare const THERMAL: number[][];

declare const THREE_THREE_TWO_RGB: number[][];

declare interface Translation {
    type: "translation";
    translation: number[];
}

declare const TURBO: number[][];

declare const UNIONJACK: number[][];

declare const VIRIDIS: number[][];

/**
 * A single window.
 */
declare interface Window_2 {
    max: number;
    min: number;
    start?: number;
    end?: number;
    [k: string]: unknown;
}
export { Window_2 as Window }

declare const YELLOW_HOT: number[][];

export { }