import { TileCache } from '../tilecache/TileCache.js';
import { WarpedMapList } from '../maps/WarpedMapList.js';
import { FetchableTile } from '../tilecache/FetchableTile.js';
import { Size, Tile } from '@allmaps/types';
import { Viewport } from '../viewport/Viewport.js';
import { WarpedMap } from '../maps/WarpedMap.js';
import { CacheableTileFactory, BaseRenderOptions, GetWarpedMapOptions, AnimationOptions, SpecificBaseRenderOptions, Sprite, WarpedMapListOptions, WebGL2WarpedMapOptions } from '../shared/types.js';

/**
 * Abstract base class for renderers
 */
export declare abstract class BaseRenderer<W extends WarpedMap, D> extends EventTarget {
    #private;
    DEFAULT_SPECIFIC_BASE_RENDER_OPTIONS: SpecificBaseRenderOptions<W>;
    warpedMapList: WarpedMapList<W>;
    tileCache: TileCache<D>;
    spritesTileCache: TileCache<D>;
    mapsInList: Set<string>;
    mapsInPreviousViewport: Set<string>;
    mapsInViewport: Set<string>;
    mapsWithFetchableTilesForPreviousViewport: Set<string>;
    mapsWithFetchableTilesForViewport: Set<string>;
    mapsWithRequestedTilesForViewport: Set<string>;
    protected viewport: Viewport | undefined;
    options: BaseRenderOptions<W>;
    constructor(cacheableTileFactory: CacheableTileFactory<D>, options?: Partial<BaseRenderOptions<W>>);
    /**
     * Parses an annotation and adds its georeferenced map to this renderer's warped map list
     *
     * @param annotation - Annotation
     * @param mapOptions - Map options
     */
    addGeoreferenceAnnotation(annotation: unknown, mapOptions?: Partial<GetWarpedMapOptions<W>>): (string | Error)[];
    /**
     * Adds a georeferenced map to this renderer's warped map list
     *
     * @param georeferencedMap - Georeferenced Map
     * @param mapOptions - Map options
     */
    addGeoreferencedMap(georeferencedMap: unknown, mapOptions?: Partial<GetWarpedMapOptions<W>>): string;
    addSprites(sprites: Sprite[], imageUrl: string, imageSize: Size): Promise<unknown>;
    /**
     * Get the default options of the renderer and list
     */
    getDefaultOptions(): BaseRenderOptions<W> & GetWarpedMapOptions<W>;
    /**
     * Get the default options of a map
     *
     * These come from the default option settings for WebGL2WarpedMaps and the map's georeferenced map proporties
     *
     * @param mapId - Map ID for which the options apply
     */
    getMapDefaultOptions(mapId: string): GetWarpedMapOptions<W> | undefined;
    /**
     * Get the render and list options
     */
    getOptions(): Partial<BaseRenderOptions<W>>;
    /**
     * Get the map-specific options of a map
     *
     * @param mapId - Map ID for which the options apply
     */
    getMapMapOptions(mapId: string): Partial<GetWarpedMapOptions<W>> | undefined;
    /**
     * Get the options of a map
     *
     * These options are the result of merging the default, georeferenced map,
     * layer and map-specific options of that map.
     *
     * @param mapId - Map ID for which the options apply
     */
    getMapOptions(mapId: string): GetWarpedMapOptions<W> | undefined;
    /**
     * Set the options
     *
     * @param options - Options to set
     */
    setOptions(options?: Partial<BaseRenderOptions<W>>): void;
    /**
     * Set the list options
     *
     * @param listOptions - List options to set
     * @param animationOptions - Animation options
     */
    setListOptions(listOptions?: Partial<WarpedMapListOptions<W>>, animationOptions?: Partial<AnimationOptions>): void;
    /**
     * Set the map-specific options of the specified maps
     *
     * Useful when map-specific options are changed for multiple maps at once,
     * but only one animation should be fired.
     *
     * @param mapIds - Map IDs of the maps whose options to set
     * @param mapsOptions - Map-specific options to apply to each of those maps
     * @param animationOptions - Animation options
     */
    setMapsOptions(mapIds: string[], mapsOptions?: Partial<WebGL2WarpedMapOptions>, animationOptions?: Partial<AnimationOptions>): void;
    /**
     * Set the map-specific options of all maps using a per-map callback
     *
     * Useful when map-specific options are changed for multiple maps at once
     * (with possibly different options for different maps), but only one animation should be fired.
     *
     * The callback receives each map's ID and returns the options to apply,
     * or `undefined` to leave that map unchanged.
     *
     * @param mapsOptionsCallbackFn - Callback returning the options to apply for a given map
     * @param animationOptions - Animation options
     */
    setMapsOptions(mapsOptionsCallbackFn: (mapId: string) => Partial<WebGL2WarpedMapOptions> | undefined, animationOptions?: Partial<AnimationOptions>): void;
    setMapsOptions(firstArgument: string[] | ((mapId: string) => Partial<WebGL2WarpedMapOptions> | undefined), secondArgument?: Partial<WebGL2WarpedMapOptions> | Partial<AnimationOptions>, thirdArgument?: Partial<AnimationOptions>): void;
    /**
     * Set the map-specific options of the specified maps, and the list options
     *
     * Useful when map-specific options are changed for multiple maps at once,
     * together with the list options, but only one animation should be fired.
     *
     * @param mapIds - IDs of the maps whose options to set
     * @param mapsOptions - Map-specific options to apply to each of those maps
     * @param listOptions - List options to apply
     * @param animationOptions - Animation options
     */
    setMapsAndListOptions(mapIds: string[], mapsOptions?: Partial<WebGL2WarpedMapOptions>, listOptions?: Partial<WarpedMapListOptions<W>>, animationOptions?: Partial<AnimationOptions>): void;
    /**
     * Set the map-specific options of all maps using a per-map callback, and the list options
     *
     * Useful when map-specific options are changed for multiple maps at once (with possibly different options for different maps),
     * together with the list options, but only one animation should be fired.
     *
     * The callback receives each map's ID and returns the options to apply,
     * or `undefined` to leave that map unchanged.
     *
     * @param mapsOptionsCallbackFn - Callback returning the options to apply for a given map
     * @param listOptions - List options to apply
     * @param animationOptions - Animation options
     */
    setMapsAndListOptions(mapsOptionsCallbackFn: (mapId: string) => Partial<WebGL2WarpedMapOptions> | undefined, listOptions?: Partial<WarpedMapListOptions<W>>, animationOptions?: Partial<AnimationOptions>): void;
    setMapsAndListOptions(mapIds: string[], mapsOptions?: Partial<WebGL2WarpedMapOptions>, listOptions?: Partial<WarpedMapListOptions<W>>, animationOptions?: Partial<AnimationOptions>): void;
    setMapsAndListOptions(mapsOptionsCallbackFn: (mapId: string) => Partial<WebGL2WarpedMapOptions> | undefined, listOptions?: Partial<WarpedMapListOptions<W>>, animationOptions?: Partial<AnimationOptions>): void;
    setMapsAndListOptions(firstArgument: string[] | ((mapId: string) => Partial<WebGL2WarpedMapOptions> | undefined), secondArgument?: Partial<WebGL2WarpedMapOptions> | Partial<WarpedMapListOptions<W>>, thirdArgument?: Partial<WarpedMapListOptions<W>> | Partial<AnimationOptions>, fourthArgument?: Partial<AnimationOptions>): void;
    /**
     * Reset the list options
     *
     * Undefined option keys reset all options
     *
     * @param listOptionKeys - Keys of the list options to reset
     * @param animationOptions - Animation options
     */
    resetListOptions(listOptionKeys?: string[], animationOptions?: Partial<AnimationOptions>): void;
    /**
     * Reset the map-specific options of the specified maps
     *
     * Omitting `mapsOptionKeys` resets all options; passing an empty array resets none.
     *
     * @param mapIds - IDs of the maps whose options to reset
     * @param mapsOptionKeys - Keys of the options to reset
     * @param animationOptions - Animation options
     */
    resetMapsOptions(mapIds: string[], mapsOptionKeys?: Array<keyof WebGL2WarpedMapOptions>, animationOptions?: Partial<AnimationOptions>): void;
    /**
     * Reset the map-specific options of all maps using a per-map callback
     *
     * The callback receives each map's ID and returns the keys to reset for that map.
     * Returning `undefined` from the callback resets all options for that map, returning an empty array resets none.
     *
     * @param mapsOptionKeysCallbackFn - Callback returning the option keys to reset for a given map
     * @param animationOptions - Animation options
     */
    resetMapsOptions(mapsOptionKeysCallbackFn: (mapId: string) => Array<keyof WebGL2WarpedMapOptions> | undefined, animationOptions?: Partial<AnimationOptions>): void;
    resetMapsOptions(firstArgument?: string[] | ((mapId: string) => Array<keyof WebGL2WarpedMapOptions> | undefined), secondArgument?: Array<keyof WebGL2WarpedMapOptions> | Partial<AnimationOptions>, thirdArgument?: Partial<AnimationOptions>): void;
    /**
     * Reset the map-specific options of the specified maps, and the list options
     *
     * Omitting `mapsOptionKeys` or `listOptionKeys` resets all options for that scope;
     * passing an empty array resets none.
     *
     * @param mapIds - IDs of the maps whose options to reset
     * @param mapsOptionKeys - Keys of the map-specific options to reset
     * @param listOptionKeys - Keys of the list options to reset
     * @param animationOptions - Animation options
     */
    resetMapsAndListOptions(mapIds: string[], mapsOptionKeys?: Array<keyof WebGL2WarpedMapOptions>, listOptionKeys?: Array<keyof WebGL2WarpedMapOptions>, animationOptions?: Partial<AnimationOptions>): void;
    /**
     * Reset the map-specific options of all maps using a per-map callback, and the list options
     *
     * The callback receives each map's ID and returns the keys to reset for that map.
     * Returning `undefined` from the callback resets all options for that map, returning an empty array resets none.
     * Omitting `listOptionKeys` resets all list options.
     *
     * @param mapsOptionKeysCallbackFn - Callback returning the option keys to reset for a given map
     * @param listOptionKeys - Keys of the list options to reset
     * @param animationOptions - Animation options
     */
    resetMapsAndListOptions(mapsOptionKeysCallbackFn: (mapId: string) => Array<keyof WebGL2WarpedMapOptions> | undefined, listOptionKeys?: Array<keyof WebGL2WarpedMapOptions>, animationOptions?: Partial<AnimationOptions>): void;
    resetMapsAndListOptions(firstArgument?: string[] | ((mapId: string) => Array<keyof WebGL2WarpedMapOptions> | undefined), secondArgument?: Array<keyof WebGL2WarpedMapOptions>, thirdArgument?: Array<keyof WebGL2WarpedMapOptions> | Partial<AnimationOptions>, fourthArgument?: Partial<AnimationOptions>): void;
    protected loadMissingImagesInViewport(): Promise<void>[];
    protected someImagesInViewport(): boolean;
    protected shouldRequestFetchableTiles(): boolean;
    protected assureProjection(): void;
    protected requestFetchableTiles(): void;
    protected findMapsInViewport(viewportBufferRatio?: number): Set<string>;
    protected findMapsToAnticipate(): Set<string>;
    protected getMapFetchableTilesForViewport(mapId: string, mapsInViewportForRequest: Set<string>): FetchableTile[];
    protected getMapOverviewFetchableTilesForViewport(mapId: string, totalFetchableTilesForViewportResolution: number, mapsInViewportForOverviewRequest: Set<string>, spriteFetchabelTiles: FetchableTile[]): FetchableTile[];
    protected updateMapsForViewport(allFechableTilesForViewport: FetchableTile[]): {
        mapsWithFetchableTilesForViewportEntering: string[];
        mapsWithFetchableTilesForViewportLeaving: string[];
        mapsInViewportEntering: string[];
        mapsInViewportLeaving: string[];
    };
    protected mapsInViewportsToEnteringAndLeaving(mapsForPreviousViewport: string[], mapsForViewport: string[]): {
        mapsForViewportEntering: string[];
        mapsForViewportLeaving: string[];
    };
    protected pruneTileCache(mapsInViewportForOverviewPrune: Set<string>): void;
    protected filterOutTilesCloseToSpriteTiles(tiles: Tile[], warpedMap: WarpedMap): Tile[];
    destroy(): void;
    protected clearMap(mapId: string): void;
    protected mapTileLoaded(event: Event): void;
    protected mapTileDeleted(event: Event): void;
    protected imageLoaded(event: Event): void;
    protected warpedMapAdded(event: Event): void;
    protected warpedMapRemoved(event: Event): void;
    protected prepareChange(event: Event): void;
    protected immediateChange(event: Event): void;
    protected animatedChange(event: Event): void;
    protected addEventListeners(): void;
    protected removeEventListeners(): void;
}