import type { IBaseStreamingImageVolume, IImage, IGeometry, IImageLoadObject, IVolumeLoadObject, IGeometryLoadObject, ICachedImage, IImageVolume } from '../types';
import { ImageQualityStatus } from '../enums';
declare class Cache {
    private readonly _imageCache;
    private readonly _volumeCache;
    private readonly _imageIdsToVolumeIdCache;
    private readonly _referencedImageIdToImageIdCache;
    private readonly _geometryCache;
    private _imageCacheSize;
    private _maxCacheSize;
    private _geometryCacheSize;
    generateVolumeId(imageIds: string[]): string;
    getImageIdsForVolumeId(volumeId: string): string[];
    setMaxCacheSize: (newMaxCacheSize: number) => void;
    isCacheable: (byteLength: any) => boolean;
    getMaxCacheSize: () => number;
    getCacheSize: () => number;
    getBytesAvailable(): number;
    private _decacheImage;
    private _decacheVolume;
    purgeCache: () => void;
    purgeVolumeCache: () => void;
    decacheIfNecessaryUntilBytesAvailable(numBytes: number, volumeImageIds?: string[]): number | undefined;
    private _putImageCommon;
    putImageLoadObject(imageId: string, imageLoadObject: IImageLoadObject): Promise<void>;
    putImageSync(imageId: string, image: IImage): void;
    getImageLoadObject(imageId: string): IImageLoadObject | undefined;
    isLoaded(imageId: string): boolean;
    getVolumeContainingImageId(imageId: string): {
        volume: IImageVolume;
        imageIdIndex: number;
    } | undefined;
    getCachedImageBasedOnImageURI(imageId: string): ICachedImage | undefined;
    private _putVolumeCommon;
    putVolumeSync(volumeId: string, volume: IImageVolume): void;
    putVolumeLoadObject(volumeId: string, volumeLoadObject: IVolumeLoadObject): Promise<void>;
    getVolumeLoadObject: (volumeId: string) => IVolumeLoadObject | undefined;
    private _putGeometryCommon;
    putGeometrySync(geometryId: string, geometry: IGeometry): void;
    putGeometryLoadObject: (geometryId: string, geometryLoadObject: IGeometryLoadObject) => Promise<void>;
    getGeometry: (geometryId: string) => IGeometry | undefined;
    removeGeometryLoadObject: (geometryId: string) => void;
    private _decacheGeometry;
    incrementGeometryCacheSize: (increment: number) => void;
    decrementGeometryCacheSize: (decrement: number) => void;
    getImageByReferencedImageId: (referencedImageId: string) => IImage | undefined;
    getImage: (imageId: string, minQuality?: ImageQualityStatus) => IImage | undefined;
    setPartialImage(imageId: string, partialImage?: IImage): void;
    getImageQuality(imageId: string): ImageQualityStatus;
    getVolume: (volumeId: string, allowPartialMatch?: boolean) => IImageVolume | IBaseStreamingImageVolume | undefined;
    getVolumes: () => IImageVolume[];
    filterVolumesByReferenceId: (volumeId: string) => IImageVolume[];
    removeImageLoadObject: (imageId: string, { force }?: {
        force?: boolean;
    }) => void;
    removeVolumeLoadObject: (volumeId: string) => void;
    incrementImageCacheSize: (increment: number) => void;
    decrementImageCacheSize: (decrement: number) => void;
    getGeometryLoadObject: (geometryId: string) => IGeometryLoadObject | undefined;
}
declare const cache: Cache;
export default cache;
export { Cache, cache };