interface OmFileReaderBackend {
    /**
     * Get bytes from the backend at the specified offset and size
     * @param offset The offset in bytes from the start of the file
     * @param size The number of bytes to read
     */
    getBytes(offset: number, size: number): Promise<Uint8Array>;
    /**
     * Get the total size of the file in bytes
     */
    count(): Promise<number>;
    /**
     * Close the backend and release any resources
     */
    close(): Promise<void>;
}

interface Range {
    start: number;
    end: number;
}
interface OffsetSize {
    offset: number;
    size: number;
}
declare enum CompressionType {
    PforDelta2dInt16 = 0,
    FpxXor2d = 1,
    PforDelta2d = 2,
    PforDelta2dInt16Logarithmic = 3,
    None = 4
}
declare enum OmDataType {
    None = 0,
    Int8 = 1,
    Uint8 = 2,
    Int16 = 3,
    Uint16 = 4,
    Int32 = 5,
    Uint32 = 6,
    Int64 = 7,
    Uint64 = 8,
    Float = 9,
    Double = 10,
    String = 11,
    Int8Array = 12,
    Uint8Array = 13,
    Int16Array = 14,
    Uint16Array = 15,
    Int32Array = 16,
    Uint32Array = 17,
    Int64Array = 18,
    Uint64Array = 19,
    FloatArray = 20,
    DoubleArray = 21,
    StringArray = 22
}
type TypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;

interface WasmModule {
    _malloc(size: number): number;
    _free(ptr: number): void;
    setValue(ptr: number, value: any, type: string): void;
    getValue(ptr: number, type: string): any;
    HEAPU8: Uint8Array;
    om_header_size(): number;
    om_header_type(ptr: number): number;
    om_trailer_size(): number;
    om_trailer_read(trailerPtr: number, offsetPtr: number, sizePtr: number): boolean;
    om_variable_init(dataPtr: number): number;
    om_variable_get_type(variable: number): number;
    om_variable_get_compression(variable: number): number;
    om_variable_get_scale_factor(variable: number): number;
    om_variable_get_add_offset(variable: number): number;
    om_variable_get_dimension_count(variable: number): number;
    om_variable_get_dimension_value(variable: number, index: bigint): number;
    om_variable_get_chunk_count(variable: number): number;
    om_variable_get_chunk_value(variable: number, index: bigint): number;
    om_variable_get_name_count(variable: number): number;
    om_variable_get_name_ptr(variable: number): number;
    om_variable_get_children_count(variable: number): number;
    om_variable_get_children(variable: number, index: number, count: number, offsetPtr: number, sizePtr: number): boolean;
    om_variable_get_scalar(variable: number, ptrPtr: number, sizePtr: number): number;
    om_decoder_init(decoderPtr: number, variable: number, nDims: BigInt, readOffsetPtr: number, readCountPtr: number, intoCubeOffsetPtr: number, intoCubeDimensionPtr: number, ioSizeMerge: bigint, ioSizeMax: bigint): number;
    om_decoder_init_index_read(decoder: number, indexReadPtr: number): void;
    om_decoder_init_data_read(dataReadPtr: number, indexReadPtr: number): void;
    om_decoder_read_buffer_size(decoderPtr: number): number;
    om_decoder_next_index_read(decoder: number, indexRead: number): boolean;
    om_decoder_next_data_read(decoder: number, dataRead: number, indexData: number, indexCount: bigint, error: number): boolean;
    om_decoder_decode_chunks(decoder: number, chunkIndex: number, data: number, count: bigint, output: number, chunkBuffer: number, error: number): boolean;
    OM_HEADER_INVALID: number;
    OM_HEADER_LEGACY: number;
    OM_HEADER_READ_TRAILER: number;
    ERROR_OK: number;
    DATA_TYPE_INT8_ARRAY: number;
    DATA_TYPE_UINT8_ARRAY: number;
    DATA_TYPE_INT16_ARRAY: number;
    DATA_TYPE_UINT16_ARRAY: number;
    DATA_TYPE_INT32_ARRAY: number;
    DATA_TYPE_UINT32_ARRAY: number;
    DATA_TYPE_INT64_ARRAY: number;
    DATA_TYPE_UINT64_ARRAY: number;
    DATA_TYPE_FLOAT_ARRAY: number;
    DATA_TYPE_DOUBLE_ARRAY: number;
    sizeof_decoder: number;
}
declare function initWasm(): Promise<WasmModule>;
declare function getWasmModule(): WasmModule;

declare class OmFileReader {
    private backend;
    private wasm;
    private variable;
    private variableDataPtr;
    private verbose;
    constructor(backend: OmFileReaderBackend, wasm?: WasmModule);
    /**
     * Static factory method to create and initialize an OmFileReader
     */
    static create(backend: OmFileReaderBackend): Promise<OmFileReader>;
    initialize(): Promise<OmFileReader>;
    private _getString;
    dataType(): number;
    compression(): number;
    scaleFactor(): number;
    addOffset(): number;
    getDimensions(): number[];
    getChunkDimensions(): number[];
    getName(): string | null;
    numberOfChildren(): number;
    getChild(index: number): Promise<OmFileReader | null>;
    initChildFromOffsetSize(offsetSize: OffsetSize): Promise<OmFileReader>;
    readScalar<T>(dataType: OmDataType): T | null;
    private newIndexRead;
    private newDataRead;
    read(dataType: OmDataType, dimRanges: Range[], ioSizeMax?: bigint, ioSizeMerge?: bigint): Promise<TypedArray>;
    /**
     * Read data into an existing TypedArray with specified dimension ranges
     * @param dataType The data type to read
     * @param output The TypedArray to read data into
     * @param dimRanges Ranges for each dimension to read
     * @param ioSizeMax Maximum I/O size (default: 65536)
     * @param ioSizeMerge Merge threshold for I/O operations (default: 512)
     */
    readInto(dataType: OmDataType, output: TypedArray, dimRanges: Range[], ioSizeMax?: bigint, ioSizeMerge?: bigint): Promise<void>;
    private decode;
    private readDataBlock;
    /**
     * Helper method to copy data from WASM memory to a TypedArray with the correct type
     */
    private copyToTypedArray;
    dispose(): void;
}

declare class FileBackendNode implements OmFileReaderBackend {
    private filePath;
    private memory;
    private fileSize;
    private fileHandle;
    constructor(source: string | Uint8Array | ArrayBuffer);
    count(): Promise<number>;
    getBytes(offset: number, size: number): Promise<Uint8Array>;
    close(): Promise<void>;
}

declare class MemoryHttpBackend implements OmFileReaderBackend {
    private url;
    private fileSize;
    private fileData;
    private loadPromise;
    private countPromise;
    private maxFileSize;
    private onProgress?;
    private debug;
    /**
     * Create a new MemoryHttpBackend
     * @param options Configuration options
     */
    constructor(options: {
        url: string;
        maxFileSize?: number;
        onProgress?: (loaded: number, total: number) => void;
        debug?: boolean;
    });
    /**
     * Get the total size of the file
     */
    count(): Promise<number>;
    /**
     * Load the entire file into memory
     */
    loadFile(): Promise<void>;
    /**
     * Get bytes from the file
     * @param offset The starting position in the file
     * @param size The number of bytes to read
     */
    getBytes(offset: number, size: number): Promise<Uint8Array>;
    /**
     * Check if the file is fully loaded
     */
    isLoaded(): boolean;
    /**
     * Get the current loaded data or null if not loaded
     */
    getFileData(): Uint8Array | null;
    /**
     * Force a reload of the file
     */
    reload(): Promise<void>;
    /**
     * Close the backend and release any resources
     */
    close(): Promise<void>;
}

export { CompressionType, FileBackendNode, MemoryHttpBackend, OmDataType, OmFileReader, getWasmModule, initWasm };
export type { OffsetSize, OmFileReaderBackend, Range, TypedArray };