import { Vector2, Box3, Vector3 } from 'three';
import { ChunkId, ChunkKey } from '../utils/common_types.js';
import { BlockDataAdapter, IdenticalBoolAdapter } from './BlockDataAdapter.js';
declare enum ChunkAxisOrder {
    ZXY = 0,
    ZYX = 1
}
export type ChunkMetadata = {
    chunkKey?: string;
    bounds: Box3;
    margin?: number;
};
export type EmptyChunkStub = {
    metadata: ChunkMetadata;
};
export type ChunkStub<T extends ChunkMetadata> = {
    metadata: T;
    rawdata: Uint16Array;
};
export type DataChunkStub = ChunkStub<ChunkMetadata>;
export type ChunkHeightBuffer<DataType> = {
    pos: Vector2;
    content: DataType[];
};
export type ChunkHeightRawBuffer = {
    pos: Vector2;
    content: Uint16Array;
};
type ChunkEmptyIteration<PosFormat> = {
    pos: PosFormat;
    localPos: PosFormat;
    index: number;
};
type ChunkRawDataIteration<PosFormat> = ChunkEmptyIteration<PosFormat> & {
    rawData: number;
};
type ChunkDataIteration<PosFormat, DataType> = ChunkEmptyIteration<PosFormat> & {
    data: DataType;
};
type ChunkHeightRawBufferIteration = ChunkEmptyIteration<Vector2> & ChunkHeightRawBuffer;
type ChunkHeightBufferIteration<DataType> = ChunkEmptyIteration<Vector2> & ChunkHeightBuffer<DataType>;
/**
 * Base chunk container with no data
 */
export declare class ChunkContainer {
    bounds: Box3;
    extendedBounds: Box3;
    dimensions: Vector3;
    extendedDims: Vector3;
    margin: number;
    chunkKey: string;
    chunkId: ChunkId | undefined;
    axisOrder: ChunkAxisOrder;
    constructor(bounds?: Box3, margin?: number, axisOrder?: ChunkAxisOrder);
    get id(): ChunkId | undefined;
    set id(chunkId: ChunkId | undefined);
    get localBox(): Box3;
    get localExtendedBox(): Box3;
    adjustBounds(bounds: Box3): void;
    /**
     *
     * @param localPos queried buffer location as Vector2 or Vector3
     * @returns buffer or block index for Vector2 or Vector3 input respectively.
     */
    getIndex(localPos: Vector2 | Vector3): number;
    toLocalPos(pos: Vector3): Vector3;
    toWorldPos(pos: Vector3): Vector3;
    inLocalRange(localPos: Vector3): boolean;
    inWorldRange(globalPos: Vector3): boolean;
    isOverlapping(bounds: Box3): boolean;
    containsPoint(pos: Vector3): boolean;
    adjustInputBounds(input: Box3 | Vector3, local?: boolean): Box3;
    /**
     * iterate raw data
     * @param rangeBox iteration range as global coords
     * @param skipMargin
     */
    iterateContent(iteratedBounds?: Box3 | Vector3, skipMargin?: boolean): Generator<ChunkEmptyIteration<Vector3>, void, unknown>;
    /**
     * iterate raw data
     * @param rangeBox iteration range as global coords
     * @param skipMargin
     */
    iterHeightBuffers(iteratedBounds?: Box3 | Vector3): Generator<ChunkEmptyIteration<Vector2>, void, unknown>;
    fromStub(chunkStub: EmptyChunkStub): this;
    toStub(): EmptyChunkStub;
    fromKey(chunkKey: ChunkKey, chunkDim: Vector3): this;
    static iterOverlap(sourceChunk: ChunkContainer, targetChunk: ChunkContainer): Generator<{
        sourceIndex: number;
        targetIndex: number;
    }, void, unknown>;
}
/**
 * Read only container sharing its data with another to avoid costly data copy operations
 */
export declare abstract class ChunkSharedContainer<BlockData> extends ChunkContainer {
    static defaultDataAdapter: BlockDataAdapter<any>;
    protected abstract readonly rawData: Uint16Array<ArrayBufferLike>;
    isEmpty?: boolean;
    abstract dataAdapter: BlockDataAdapter<BlockData>;
    constructor(bounds?: Box3, margin?: number, axisOrder?: ChunkAxisOrder);
    isEmptySafe(): boolean;
    readRawSector(sectorIndex: number): number;
    readBlockData(sectorIndex: number): BlockData;
    readRawBuffer(localPos: Vector2): Uint16Array<ArrayBuffer>;
    readBlocksBuffer(localPos: Vector2): BlockData[];
    iterateRawContent(iteratedBounds?: Box3 | Vector3, skipMargin?: boolean): Generator<ChunkRawDataIteration<Vector3>, void, unknown>;
    iterateContent(iteratedBounds?: Box3 | Vector3, skipMargin?: boolean): Generator<ChunkDataIteration<Vector3, BlockData>, void, unknown>;
    iterHeightBuffers(iteratedBounds?: Box3 | Vector3): Generator<ChunkHeightRawBufferIteration, void, unknown>;
    iterBlocksHeightBuffers(iteratedBounds?: Box3 | Vector3): Generator<ChunkHeightBufferIteration<BlockData>, void, unknown>;
    copyContentToTarget(targetChunk: ChunkDataContainer<BlockData>, skipEmpty?: boolean): void;
    toStub(): DataChunkStub;
}
/**
 * Writeable container owning its data
 */
export declare abstract class ChunkDataContainer<BlockData> extends ChunkSharedContainer<BlockData> {
    rawData: Uint16Array<ArrayBufferLike>;
    get dataSize(): number;
    writeRawSector(localPos: Vector3, rawVal: number): void;
    writeBlockData(localPos: Vector3, blockData: BlockData): number;
    writeRawBuffer(localPos: Vector2, buffer: Uint16Array): void;
    writeBlocksBuffer(localPos: Vector2, buffer: BlockData[]): void;
    fromKey(chunkKey: ChunkKey, chunkDim: Vector3): this;
    fromStub({ metadata, rawdata }: DataChunkStub): this;
    toStub(): DataChunkStub;
    fromStubConcat(concatData: Uint8Array): this | null;
    toStubConcat(): Uint8Array<ArrayBuffer>;
    fromCompressedBlob(compressedBlob: Blob): Promise<this>;
    toCompressedBlob(): Promise<Blob>;
    /**
     * merge spared chunks into unique container
     */
    fromMergedChunks(sourceChunks: ChunkSharedContainer<BlockData>[]): this;
}
export declare class ChunkMask extends ChunkDataContainer<boolean> {
    dataAdapter: IdenticalBoolAdapter;
    applyMaskOnTargetChunk(targetChunk: ChunkDataContainer<any>): void;
}
export {};