import type { Batch2DEffect } from './core';
import type { Node, SceneTreeEvents, SceneTreeProperties } from './scene';
import { WebGLRenderer } from './core';
import { SceneTree } from './scene';
export type EngineData = Record<string, any> | Node | (Node | Record<string, any>)[];
export interface EngineProperties extends WebGLContextAttributes, SceneTreeProperties {
    view?: HTMLCanvasElement | WebGLRenderingContext | WebGL2RenderingContext;
    width?: number;
    height?: number;
    pixelRatio?: number;
    autoResize: boolean;
    autoStart: boolean;
    data?: EngineData;
}
interface EngineEvents extends SceneTreeEvents {
}
export interface Engine {
    on: <K extends keyof EngineEvents>(event: K, listener: (...args: EngineEvents[K]) => void) => this;
    once: <K extends keyof EngineEvents>(event: K, listener: (...args: EngineEvents[K]) => void) => this;
    off: <K extends keyof EngineEvents>(event: K, listener: (...args: EngineEvents[K]) => void) => this;
    emit: <K extends keyof EngineEvents>(event: K, ...args: EngineEvents[K]) => this;
}
export declare const defaultOptions: {
    readonly alpha: true;
    readonly stencil: true;
    readonly antialias: false;
    readonly premultipliedAlpha: true;
    readonly preserveDrawingBuffer: false;
    readonly powerPreference: "default";
};
export declare class Engine extends SceneTree {
    autoResize: boolean;
    autoStart: boolean;
    readonly renderer: WebGLRenderer;
    get view(): HTMLCanvasElement | undefined;
    get gl(): WebGLRenderingContext | WebGL2RenderingContext;
    get screen(): {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    get width(): number;
    get height(): number;
    get pixelRatio(): number;
    set pixelRatio(val: number);
    protected _flowEffect?: Batch2DEffect;
    get flowEffect(): Batch2DEffect | undefined;
    /**
     * 切换描边/连线的「流动」预设：引擎只内置 flowStreak，其余样式（箭头/生长线/虚线等）
     * 由宿主传自定义 Batch2DEffect。占用同一 flow 槽（按名替换 + 重编译），传 undefined 恢复默认。
     * 颜色/周期仍走 flowColor / flowPeriod（effectUniforms）。
     */
    set flowEffect(effect: Batch2DEffect | undefined);
    protected _resizeObserver: ResizeObserver | undefined;
    constructor(properties?: Partial<EngineProperties>);
    protected _updateProperty(key: string, value: any, oldValue: any): void;
    protected _setupInput(): this;
    resize(width: number, height: number, updateCss?: boolean): this;
    nextTick(): Promise<void>;
    waitUntilLoad(): Promise<void>;
    waitAndRender(delta?: number): Promise<void>;
    /**
     * Like {@link waitAndRender} but without the final `_render`. Used by the
     * export pipeline, where rendering at the full (possibly oversized) logical
     * size would allocate a render target beyond the GPU limit; {@link toPixels}
     * performs the actual (tiled) rendering instead.
     */
    waitUntilProcessed(delta?: number): Promise<void>;
    /**
     * Resize for an export pass. The requested size is remembered as the export
     * output size, but the root viewport + canvas are capped at the GPU limit:
     * the root's RenderTarget texture is reactive and re-uploads (texImage2D) on
     * every size change, so setting it beyond MAX_TEXTURE_SIZE — even just to hold
     * a "logical" size — throws `width or height out of range`. {@link toPixels}
     * tiles within the cap and stitches the full image. Does not render.
     */
    resizeForExport(width: number, height: number): this;
    render(node?: Node, delta?: number): void;
    start(): Promise<void>;
    /**
     * Largest dimension (in device pixels) a single offscreen render pass can
     * allocate. Capped by the GPU's MAX_TEXTURE_SIZE / MAX_RENDERBUFFER_SIZE /
     * MAX_VIEWPORT_DIMS *and* — crucially — the actual WebGL drawing-buffer size,
     * which the browser/GPU often clamps far below MAX_TEXTURE_SIZE (tied to
     * screen size / VRAM, e.g. ~5760 on a laptop while MAX_TEXTURE_SIZE is 16384).
     * The export reads pixels back from the drawing buffer, so anything beyond it
     * is lost/garbled. Oversized exports are tiled within this budget instead.
     */
    protected _maxExportPassSize(): number;
    protected _maxDrawingBufferCache: number;
    /**
     * Probe the real drawing-buffer cap on the *renderer's own* GL context (its
     * attributes — preserveDrawingBuffer / stencil / antialias — lower the cap vs
     * a bare context, so a throwaway probe overestimates). Temporarily sizes the
     * canvas (default framebuffer only, not the FBO textures) to `cap` and reads
     * `drawingBufferWidth/Height`, then restores. Cached per engine.
     */
    protected _maxDrawingBufferSize(cap: number): number;
    /** Tile budget in logical units (the GPU limit is in device pixels). */
    protected _exportTileLimit(): number;
    /** Resize the renderer + root viewport without triggering a render. */
    protected _resizeSilently(width: number, height: number): void;
    /** Full export size (set by {@link resizeForExport}); falls back to the root size. */
    protected _exportWidth: number;
    protected _exportHeight: number;
    get exportWidth(): number;
    get exportHeight(): number;
    needsChunkReadPixels(): boolean;
    toPixels(): Uint8ClampedArray<ArrayBuffer>;
    toImageData(): ImageData;
    toCanvas2D(imageData?: ImageData): HTMLCanvasElement;
    protected _destroy(): void;
}
export {};