declare class Vec2 {
    constructor(x: any, y: any);
    x: any;
    y: any;
    area(): number;
    flatIndex(width: any): any;
    add(other: any): Vec2;
    sub(other: any): Vec2;
    mul(scalar: any): Vec2;
    div(scalar: any): Vec2;
    equals(other: any): boolean;
    clone(): Vec2;
    toString(): string;
}
declare class IntegerBounds {
    static fromDimensions(width: any, height: any): IntegerBounds;
    static fromMinMax(minX: any, minY: any, maxX: any, maxY: any): IntegerBounds;
    constructor(position: any, size: any);
    position: any;
    size: any;
    end(): Vec2;
    area(): any;
    contains(pos: any): boolean;
    intersect(other: any): IntegerBounds;
    clone(): IntegerBounds;
    toString(): string;
}
declare const SampleType: Readonly<{
    F16: "f16";
    F32: "f32";
    U32: "u32";
}>;
declare const Compression: Readonly<{
    Uncompressed: 0;
    RLE: 1;
    ZIP1: 2;
    ZIP16: 3;
    PIZ: 4;
    PXR24: 5;
    B44: 6;
    B44A: 7;
}>;
declare const LineOrder: Readonly<{
    Increasing: 0;
    Decreasing: 1;
    Unspecified: 2;
}>;
declare class Blocks {
    static ScanLines: Blocks;
    static Tiles(size: any): Blocks;
    static MipMaps(size: any, roundingMode?: number): Blocks;
    static RipMaps(size: any, roundingMode?: number): Blocks;
    constructor(type: any, tileSize?: any, levelMode?: number, roundingMode?: number);
    type: any;
    tileSize: any;
    levelMode: number;
    roundingMode: number;
    isTiled(): boolean;
    hasMipMaps(): boolean;
    hasRipMaps(): boolean;
    hasLevels(): boolean;
}
declare const LevelMode: Readonly<{
    Singular: 0;
    MipMap: 1;
    RipMap: 2;
}>;
declare const RoundingMode: Readonly<{
    Down: 0;
    Up: 1;
}>;

declare class ImageAttributes {
    static withSize(size: any): ImageAttributes;
    constructor(displayWindow: any);
    displayWindow: any;
    pixelAspect: number;
    chromaticities: any;
    timeCode: any;
    custom: Map<any, any>;
}
declare class LayerAttributes {
    static named(name: any): LayerAttributes;
    layerName: any;
    layerPosition: Vec2;
    screenWindowCenter: Vec2;
    screenWindowWidth: number;
    custom: Map<any, any>;
}
declare class Encoding {
    static UNCOMPRESSED: Encoding;
    static FAST_LOSSLESS: Encoding;
    static SMALL_LOSSLESS: Encoding;
    static SMALL_FAST_LOSSLESS: Encoding;
    constructor(compression: any, blocks: any, lineOrder: any);
    compression: any;
    blocks: any;
    lineOrder: any;
}

declare class Image$1 {
    static fromLayer(layer: any): Image$1;
    static fromChannels(size: any, channels: any, encoding?: Encoding): Image$1;
    static empty(attributes: any): Image$1;
    constructor(attributes: any, layerData: any);
    attributes: any;
    layerData: any;
    get layers(): any[];
    withLayer(layer: any): Image$1;
    write(): WriteImageWithOptions;
}
declare class WriteImageWithOptions {
    constructor(image: any);
    _image: any;
    _parallel: boolean;
    _onProgress: any;
    parallel(): this;
    nonParallel(): this;
    onProgress(callback: any): this;
    toArrayBuffer(): ArrayBuffer;
    toUint8Array(): Uint8Array<ArrayBuffer>;
}

declare class Layer$1 {
    static create(size: any, channelData: any, encoding?: Encoding, attributes?: LayerAttributes): Layer$1;
    static named(name: any, size: any, channelData: any, encoding?: Encoding): Layer$1;
    constructor(size: any, attributes: any, encoding: any, channelData: any);
    size: any;
    attributes: any;
    encoding: any;
    channelData: any;
}

declare class BinaryReader {
    constructor(buffer: any);
    buffer: any;
    byteOffset: number;
    byteLength: any;
    view: DataView<any>;
    u8: Uint8Array<any>;
    position: number;
    checkBounds(count: any): void;
    readU8(): number;
    readI8(): number;
    readU16(): number;
    readI16(): number;
    readU32(): number;
    readI32(): number;
    readU64(): bigint;
    readI64(): bigint;
    readF32(): number;
    readF64(): number;
    readF16(): number;
    readBytes(count: any): Uint8Array<ArrayBuffer>;
    readBytesView(count: any): Uint8Array<any>;
    readNullTerminatedString(): string;
    readFixedString(length: any): string;
    readLengthPrefixedString(): string;
    peekU8(): number;
    peekU32(): number;
    getPosition(): number;
    setPosition(pos: any): void;
    skip(count: any): void;
    remaining(): number;
    hasRemaining(): boolean;
    isAtEnd(): boolean;
    subReader(length: any): BinaryReader;
}

declare class BinaryWriter {
    constructor(initialCapacity?: number);
    buffer: ArrayBuffer;
    view: DataView<ArrayBuffer>;
    u8: Uint8Array<ArrayBuffer>;
    position: number;
    ensureCapacity(additional: any): void;
    writeU8(value: any): void;
    writeI8(value: any): void;
    writeU16(value: any): void;
    writeI16(value: any): void;
    writeU32(value: any): void;
    writeI32(value: any): void;
    writeU64(value: any): void;
    writeI64(value: any): void;
    writeF32(value: any): void;
    writeF64(value: any): void;
    writeF16(value: any): void;
    writeBytes(bytes: any): void;
    writeNullTerminatedString(str: any): void;
    writeFixedString(str: any, length: any): void;
    writeLengthPrefixedString(str: any): void;
    getPosition(): number;
    setPosition(pos: any): void;
    patchAt(pos: any, writeFn: any): void;
    reserve(bytes: any): number;
    toArrayBuffer(): ArrayBuffer;
    toUint8Array(): Uint8Array<ArrayBuffer>;
    get byteLength(): number;
}

declare class ChannelDescription {
    static named(name: any, sampleType?: "f32"): ChannelDescription;
    constructor(name: any, sampleType?: "f32", quantizeLinearly?: any, sampling?: Vec2);
    name: any;
    sampleType: "f32";
    quantizeLinearly: any;
    sampling: Vec2;
    get pixelTypeId(): 0 | 2 | 1;
    get bytesPerSample(): 2 | 4;
}
declare class ChannelList {
    constructor(channels: any);
    list: any[];
    get bytesPerPixel(): any;
    get uniformSampleType(): any;
    write(writer: any): void;
}

declare class FlatSamples {
    static f16(data: any): FlatSamples;
    static f32(data: any): FlatSamples;
    static u32(data: any): FlatSamples;
    constructor(sampleType: any, data: any);
    sampleType: any;
    data: any;
    get length(): any;
    valueAt(index: any): any;
    getBytesAt(index: any): Uint8Array<ArrayBuffer>;
    writeBytesTo(startIndex: any, count: any, target: any, targetOffset: any): void;
    toFloat32Array(halfToFloatFn: any): Float32Array<any>;
}
declare class AnyChannel {
    constructor(name: any, samples: any, quantizeLinearly?: any, sampling?: Vec2);
    name: any;
    samples: any;
    quantizeLinearly: any;
    sampling: Vec2;
    toDescription(): ChannelDescription;
}
declare class AnyChannels {
    constructor(list: any);
    list: any[];
    _channelMap: Map<any, any>;
    getChannelList(): ChannelList;
    getSampleBytes(channelName: any, pixelIndex: any): any;
    writeScanlineBytes(channelName: any, startPixelIndex: any, pixelCount: any, target: any, targetOffset: any): void;
    getChannelAsFloat32(channelName: any, halfToFloatFn: any, _pixelCount: any): any;
}
declare class SpecificChannels {
    static rgb(pixels: any, sampleType?: "f32"): SpecificChannels;
    static rgba(pixels: any, sampleType?: "f32"): SpecificChannels;
    static build(): SpecificChannelsBuilder;
    constructor(channels: any, pixels: any);
    _originalChannels: any;
    _sortedChannels: any[];
    _channelIndices: Map<any, any>;
    pixels: any;
    getChannelList(): ChannelList;
    getSampleBytes(channelName: any, pixelIndex: any): Uint8Array<ArrayBuffer>;
    writeScanlineBytes(channelName: any, startPixelIndex: any, pixelCount: any, target: any, targetOffset: any): void;
    getChannelAsFloat32(channelName: any, _halfToFloatFn: any, pixelCount: any): Float32Array<any>;
}
declare class SpecificChannelsBuilder {
    _channels: any[];
    withChannel(name: any, sampleType?: "f32"): this;
    withPixels(pixels: any): SpecificChannels;
    withPixelFn(fn: any): SpecificChannels;
}

declare function readMeta(reader: any): ParsedMeta;
declare class ParsedHeader {
    channels: any;
    compression: 0;
    dataWindow: any;
    displayWindow: any;
    lineOrder: 0;
    pixelAspectRatio: number;
    screenWindowCenter: Vec2;
    screenWindowWidth: number;
    tiles: any;
    name: any;
    type: any;
    chunkCount: any;
    customAttributes: Map<any, any>;
    get width(): any;
    get height(): any;
    get isTiled(): boolean;
    get blocks(): Blocks;
    get scanLinesPerBlock(): 1 | 16 | 32;
    validate(): void;
}
declare class ParsedMeta {
    constructor(version: any, flags: any, headers: any);
    version: any;
    flags: any;
    headers: any;
    get isTiled(): boolean;
    get hasLongNames(): boolean;
    get isDeepData(): boolean;
    get isMultiPart(): boolean;
    get layerCount(): any;
}

declare function decodeRgba(buffer: any): {
    width: any;
    height: any;
    pixels: Float32Array<ArrayBuffer>;
    dataWindow: any;
    displayWindow: any;
    compression: any;
    attributes: any;
};
declare function decodeRgb(buffer: any): {
    width: any;
    height: any;
    pixels: Float32Array<ArrayBuffer>;
    dataWindow: any;
    displayWindow: any;
    compression: any;
    attributes: any;
};
declare class EXRReader {
    static fromArrayBuffer(buffer: any): EXRReader;
    constructor(buffer: any);
    _reader: BinaryReader;
    _meta: ParsedMeta;
    _offsetTables: any[][];
    _pixelCache: Map<any, any>;
    getLayerCount(): any;
    getLayerNames(): any;
    getHeader(layerIndex?: number): any;
    getChannelNames(layerIndex?: number): any;
    getWidth(layerIndex?: number): any;
    getHeight(layerIndex?: number): any;
    getDataWindow(layerIndex?: number): any;
    getDisplayWindow(layerIndex?: number): any;
    getCompression(layerIndex?: number): any;
    getAttributes(layerIndex?: number): any;
    isMultiPart(): boolean;
    isTiled(layerIndex?: number): any;
    readLayer(layerIndex?: number): any;
    readChannel(channelName: any, layerIndex?: number): any;
    readRgba(layerIndex?: number): Float32Array<ArrayBuffer>;
    readRgb(layerIndex?: number): Float32Array<ArrayBuffer>;
    clearCache(): void;
}

declare function encodeRgba(width: any, height: any, pixels: any, encoding?: Encoding): ArrayBuffer;
declare function encodeRgb(width: any, height: any, pixels: any, encoding?: Encoding): ArrayBuffer;

declare class EXRWriter {
    constructor(width: any, height: any);
    width: any;
    height: any;
    _layers: any[];
    addLayer(name: any, options?: {}): LayerBuilder;
    encode(): ArrayBuffer;
    _buildImage(): Image;
}

declare class LayerBuilder {
    constructor(writer: any, name: any, options: any);
    _writer: any;
    _name: any;
    _encoding: any;
    _channelDescriptions: any[];
    _pixelSource: any;
    _isRgba: boolean;
    _isRgb: boolean;
    _sampleType: "f32";
    rgba(data: any): this;
    rgb(data: any): this;
    channel(name: any, sampleType: any, data: any): this;
    compression(compression: any): this;
    tiled(tileWidth?: number, tileHeight?: number): this;
    scanlines(): this;
    sampleType(sampleType: any): this;
    end(): any;
    _build(size: any): Layer;
}

declare function floatToHalf(value: any): number;
declare function halfToFloat(half: any): number;
declare function float32ArrayToHalf(floats: any): Uint16Array<any>;
declare function halfToFloat32Array(halves: any): Float32Array<any>;

export { AnyChannel, AnyChannels, BinaryReader, BinaryWriter, Blocks, ChannelDescription, ChannelList, Compression, EXRReader, EXRWriter, Encoding, FlatSamples, Image$1 as Image, ImageAttributes, IntegerBounds, Layer$1 as Layer, LayerAttributes, LevelMode, LineOrder, ParsedHeader, ParsedMeta, RoundingMode, SampleType, SpecificChannels, Vec2, decodeRgb, decodeRgba, encodeRgb, encodeRgba, float32ArrayToHalf, floatToHalf, halfToFloat, halfToFloat32Array, readMeta };