import { MapChunkHitbox, MapStreamChunk, MapStreamManifest, MapStreamPacket, RpgProvider } from '@rpgjs/common';
import { MapData, LoadMapOptions } from './loadMap';
export interface ClientMapStreamingAdapter<TManifestData = unknown, TChunkData = unknown, TState = unknown> {
    /** CanvasEngine component that renders the provider-specific state. */
    component: unknown;
    /** Create empty client render state from public manifest data. */
    createState(manifest: MapStreamManifest<TManifestData>): TState;
    /** Apply one disclosed render chunk to the state. */
    applyChunk(state: TState, chunk: MapStreamChunk<TChunkData>): void;
    /** Remove one chunk that left the retention window. */
    removeChunk(state: TState, key: string): void;
    /** Return the serializable/component-ready map value exposed to CanvasEngine. */
    getData(state: TState): unknown;
    /** Optionally derive component parameters from the public manifest. */
    getParams?(manifest: MapStreamManifest<TManifestData>): Record<string, unknown>;
}
export interface ClientMapStreamingOptions<TManifestData = unknown, TChunkData = unknown, TState = unknown> {
    /** Format adapter paired with the server compiler. */
    adapter: ClientMapStreamingAdapter<TManifestData, TChunkData, TState>;
    /** Optional direct loader used only by standalone RPG mode. */
    directLoad?: LoadMapOptions;
    /** Maximum wait for the initial authoritative manifest. Defaults to 10 seconds. */
    timeoutMs?: number;
}
type StreamingPhysicsMap = {
    data: {
        (): MapData | null;
        set(value: MapData): void;
    };
    replaceStreamedStaticHitboxes(namespace: string, hitboxes: MapChunkHitbox[]): void;
    clearStreamedStaticHitboxes(namespace: string): void;
};
export declare class MapStreamClientController<TManifestData, TChunkData, TState> {
    private readonly adapter;
    private state;
    private manifest;
    private readonly chunks;
    private attachedMap?;
    constructor(adapter: ClientMapStreamingAdapter<TManifestData, TChunkData, TState>, manifest: MapStreamManifest<TManifestData>);
    get revision(): string;
    reset(manifest: MapStreamManifest<TManifestData>): void;
    receive(packet: MapStreamPacket<TManifestData, TChunkData>): void;
    toMapData(): MapData;
    attach(map: StreamingPhysicsMap): void;
    detach(): void;
    private publish;
    private updatePredictionBoundary;
}
/**
 * Provide a transport-neutral client map loader backed by authoritative chunks.
 * Standalone mode may keep a direct loader while MMORPG mode never fetches the
 * private source map.
 *
 * @param options - Client adapter, optional standalone loader, and timeout.
 * @returns Dependency-injection providers for the RPGJS map loader.
 *
 * @example
 * ```ts
 * provideClientMapStreaming({
 *   adapter: {
 *     component: MyMap,
 *     createState: (manifest) => ({ manifest, chunks: new Map() }),
 *     applyChunk: (state, chunk) => state.chunks.set(chunk.key, chunk.renderData),
 *     removeChunk: (state, key) => state.chunks.delete(key),
 *     getData: (state) => state,
 *   },
 * })
 * ```
 */
export declare function provideClientMapStreaming<TManifestData, TChunkData, TState>(options: ClientMapStreamingOptions<TManifestData, TChunkData, TState>): RpgProvider[];
export {};