import { CalculateGroup } from '../plugin/cal/CalculateGroup';
import type { Region } from '../plugin/interact/ClickHandler';
import type { VFXItem } from './VFXItem';
import { PredyPlayerRenderFrame } from '../render/PredyPlayerRenderFrame';
import { CompVFXItem } from './CompVFXItem';
import './createVFXItem';
import type { EventSystem } from '../plugin/interact/EventSystem';
import type { mat4, Renderer, Texture } from '@predy-js/render-interface';
import type { CameraParams } from '../math/Camera';
import { Camera } from '../math/Camera';
import type { PluginSystem } from './PluginSystem';
import type { MeshRendererOptions } from '../plugin/particle/ParticleSystem';
import type { Ray } from '../math/raycast';
import type { vec3, vec2 } from '@predy-js/specification';
import type { Transform } from '../math/Transform';
import type { PredyPlayer } from './type';
export interface CompositionHitTestOptions {
    maxCount?: number;
    stop?: (region: Region) => boolean;
    skip?: (item: VFXItem<any>) => boolean;
}
interface MsgItem {
    name: string;
    phrase: number;
    id: number;
    compositionId: number;
}
export declare const defCameraName = "default";
export declare class Composition {
    renderFrame: PredyPlayerRenderFrame;
    speed: number;
    readonly renderOrder: number;
    readonly calculateGroup: CalculateGroup;
    readonly id: number;
    readonly event: EventSystem;
    readonly renderer: Renderer;
    readonly loaderData: {
        [key: string]: any;
    };
    readonly _content: CompVFXItem;
    readonly pluginSystem: PluginSystem;
    readonly _cameraMap: Record<string, Camera>;
    readonly rootTransform: Transform;
    readonly willReverseTime: boolean;
    readonly keepColorBuffer: boolean;
    readonly textures: Texture[];
    readonly player: PredyPlayer;
    readonly keepCompiled: boolean;
    readonly keepResource: boolean;
    readonly env: string;
    readonly autoRefTex: boolean;
    readonly renderLevel: string;
    readonly name: string;
    readonly loadTime: number;
    private readonly _postLoaders;
    private readonly _texInfo;
    private _aspectReady;
    private _forwarding;
    _textureOffloaded: boolean;
    private _rendererOptions;
    private readonly onEnd;
    onMessageItem: (item: MsgItem) => void;
    private lastVideoUpdateTime;
    readonly isDestroyed = false;
    private _transferredRenderFrame?;
    constructor(props: any, player: PredyPlayer);
    getCamera(cid?: string): Camera;
    setCamera(cid: string, params: CameraParams): void;
    setCameraAspect(aspect: number): void;
    setCameraParams(camera: CameraParams, cid?: string): void;
    get forwarding(): boolean;
    get duration(): number;
    get items(): VFXItem[] | null;
    get time(): number;
    get startTime(): number;
    setEditorTransform(scale: number, dx: number, dy: number): number[];
    private _reset;
    forwardTime(currentTime: number, step?: number): void;
    restart(): void;
    start(): void;
    private _startContent;
    private _prepareRender;
    get shouldRestart(): boolean;
    get shouldDestroy(): boolean;
    private _checkAspect;
    tick(time: any): void;
    getParticleOptions(cid?: string): MeshRendererOptions;
    getItemByName(name: string, type?: string): VFXItem<any>;
    getItemById<T extends VFXItem<any>>(id: string): T;
    hitTest(x: number, y: number, force?: boolean, opt?: CompositionHitTestOptions): Region[];
    _hitTest(x: number, y: number, force?: boolean, opt?: CompositionHitTestOptions): {
        regions: Region[];
        ray?: Ray;
    };
    addInteractiveItem(item: any, cfg: any): any;
    removeInteractiveItem(item: any, type: any): void;
    pause(): void;
    resume(): void;
    destroyTextures(textures: (Texture | null | undefined)[]): void;
    updatePlugins(dt: number): void;
    itemLifetimeEvent(item: VFXItem<any>, start: boolean): void;
    destroyItem(item: VFXItem<any>): void;
    offloadTexture(): void;
    reloadTextureAsync(): Promise<void>;
    destroy(): void;
    static __compositionV3DToCanvasV2DTemp: {
        ndcMat: mat4;
        modelToNdcMat: mat4;
        ret: vec3;
    };
    /**
       * 世界坐标转换到canvas坐标 矩阵
       * @param out
       */
    worldToCanvasMatrix(out?: mat4): mat4;
    /**
       * 3D坐标转换到2D坐标
       * @param v3d 世界3D坐标， composition 的坐标系
       */
    world3DToCanvas2D(v3d: vec3): vec2;
}
export {};