import { BaseEvent, CanvasTexture, Color, Event, EventDispatcher, Object3D, Scene, Vector3, Vector3Tuple } from 'three';
import { Class, ValOrArr } from 'ts-browser-helpers';
import { TViewerScreenShader } from '../postprocessing';
import { AddObjectOptions, IAnimationLoopEvent, ICamera, IGeometry, IMaterial, IObject3D, ITexture, RootScene, TCameraControlsMode } from '../core';
import { ViewerRenderManager } from './ViewerRenderManager';
import { EasingFunctionType, GLStatsJS, IDialogWrapper, SerializationMetaType, SerializationResourcesType } from '../utils';
import { AssetManager, AssetManagerOptions, BlobExt, ExportFileOptions, IAsset, ImportAddOptions, ImportAssetOptions, ImportResult, RootSceneImportResult } from '../assetmanager';
import { IViewerPlugin, IViewerPluginSync } from './IViewerPlugin';
import { UiObjectConfig } from 'uiconfig.js';
import { IRenderTarget } from '../rendering';
import { DropzonePluginOptions } from '../plugins/interaction/DropzonePlugin';
import { Object3DManager } from '../assetmanager/Object3DManager';
import { ViewerTimeline } from '../utils/ViewerTimeline';
import { AViewerPlugin } from './AViewerPlugin';
export interface IViewerEvent extends BaseEvent, Partial<IAnimationLoopEvent> {
    type: '*' | 'update' | 'preRender' | 'postRender' | 'preFrame' | 'postFrame' | 'dispose' | 'addPlugin' | 'removePlugin' | 'renderEnabled' | 'renderDisabled' | 'renderError';
    eType?: '*' | 'update' | 'preRender' | 'postRender' | 'preFrame' | 'postFrame' | 'dispose' | 'addPlugin' | 'removePlugin' | 'renderEnabled' | 'renderDisabled' | 'renderError';
    [p: string]: any;
}
export type IViewerEventTypes = IViewerEvent['type'];
export interface ISerializedConfig {
    assetType: 'config';
    type: string;
    metadata?: {
        generator: string;
        version: number;
        [key: string]: any;
    };
    [key: string]: any;
}
export interface ISerializedViewerConfig extends ISerializedConfig {
    type: 'ThreeViewer' | 'ViewerApp';
    version: string;
    plugins: ISerializedConfig[];
    resources?: Partial<SerializationResourcesType> | SerializationMetaType;
    renderManager?: any;
    scene?: any;
    [key: string]: any;
}
export interface ViewerEventMap {
    preFrame: {
        time: number;
        deltaTime: number;
        timeline: {
            time: number;
            delta: number;
        };
        resized: boolean;
    };
}
export interface ViewerEventListener<T extends keyof ViewerEventMap> {
    callback: (event: ViewerEventMap[T] & {
        type: T;
        target: ThreeViewer;
    }) => void;
    order?: number;
}
export type IConsoleWrapper = Partial<Console> & Pick<Console, 'log' | 'warn' | 'error'>;
/**
 * Options for the ThreeViewer creation.
 * @category Viewer
 */
export interface ThreeViewerOptions {
    /**
     * The canvas element to use for rendering. Only one of container and canvas must be specified.
     */
    canvas?: HTMLCanvasElement;
    /**
     * The container for the canvas. A new canvas will be created in this container. Only one of container and canvas must be specified.
     */
    container?: HTMLElement;
    /**
     * The fragment shader snippet to render on screen.
     */
    screenShader?: TViewerScreenShader;
    /**
     * Use MSAA.
     * Renders objects in a multi-sampled buffer.
     * @default false
     */
    msaa?: boolean;
    /**
     * Use Uint8 RGBM HDR Render Pipeline.
     * Provides better performance with post-processing.
     * RenderManager Uses Half-float if set to false.
     * @default true
     */
    rgbm?: boolean;
    /**
     * Use rendered gbuffer as depth-prepass / z-prepass. (Requires DepthBufferPlugin/GBufferPlugin).
     * Set it to true if you only have opaque objects in the scene to get better performance.
     *
     * @default false
     *
     * todo fix: It should be disabled when there are any transparent/transmissive objects with render to depth buffer enabled, see forceZPrepass
     */
    zPrepass?: boolean;
    /**
     * Render scale, 1 = full resolution, 0.5 = half resolution, 2 = double resolution.
     * Same as pixelRatio in three.js
     * Can be set to `window.devicePixelRatio` to render at device resolution in browsers.
     * An optimal value is `Math.min(2, window.devicePixelRatio)` to prevent issues on mobile. This is set when 'auto' is passed.
     * @default 1
     */
    renderScale?: number | 'auto';
    /**
     * Max render scale when set to 'auto'
     * @default 2
     */
    maxRenderScale?: number;
    /**
     * Default Background color of the scene.
     * To set the background texture/map, use {@link ThreeViewerOptions.load.background} or {@link setBackgroundMap}
     * @default '#ffffff' (white)
     */
    backgroundColor?: string | Color | number | null;
    /**
     * Model Root Scale
     * @default 1
     */
    modelRootScale?: number;
    /**
     * Enable stencil in renderer and stencilBuffer in composer render targets.
     * @default false
     */
    stencil?: boolean;
    debug?: boolean;
    /**
     * Add initial plugins.
     */
    plugins?: (IViewerPluginSync | Class<IViewerPluginSync>)[];
    load?: {
        /**
         * Load one or more source files
         */
        src?: ValOrArr<string | IAsset | null>;
        /**
         * Load environment map
         */
        environment?: string | IAsset | ITexture | undefined | null;
        /**
         * Load background map
         */
        background?: string | IAsset | ITexture | undefined | null;
    };
    onLoad?: (results: any) => void;
    /**
     * TonemapPlugin is added to the viewer if this is true.
     * @default true
     */
    tonemap?: boolean;
    camera?: {
        type?: 'perspective' | 'orthographic';
        controlsMode?: TCameraControlsMode;
        position?: Vector3 | Vector3Tuple;
        target?: Vector3 | Vector3Tuple;
    } | ICamera;
    rootScene?: RootScene;
    /**
     * Max HDR intensity for rendering and post-processing.
     * Values above this might be clamped during post-processing.
     * @default 72 (when rgbm is false), 16 (when rgbm is true)
     */
    maxHDRIntensity?: number;
    /**
     * Power preference for the WebGL context.
     * @default 'high-performance'
     */
    powerPreference?: WebGLPowerPreference;
    /**
     * Options for the asset manager.
     */
    assetManager?: AssetManagerOptions;
    /**
     * Add the dropzone plugin to the viewer, allowing to drag and drop files into the viewer over the canvas/container.
     * Set to true/false to enable/disable the plugin, or pass options to configure the plugin. Assuming true if options are passed.
     * @default - false
     */
    dropzone?: boolean | DropzonePluginOptions;
    /**
     * If true, will stop event propagation on all pointer events on the viewer container (when camera interactions are enabled).
     *
     * Set this to true when the viewer is inside a carousel or similar component that might interfere with pointer events.
     * @default false
     */
    stopPointerEventPropagation?: boolean;
    /**
     * By default, all imported assets are cached in memory, so that calling import/load would return the same instance of an asset if the same source and options is passed again.
     * Set this to `false` to disable this caching.
     * @default true
     */
    cacheImportedAssets?: boolean;
    /**
     * @deprecated use {@link msaa} instead
     */
    isAntialiased?: boolean;
    /**
     * @deprecated use {@link rgbm} instead
     */
    useRgbm?: boolean;
    /**
     * @deprecated use {@link zPrepass} instead
     */
    useGBufferDepth?: boolean;
}
/**
 * Three Viewer
 *
 * The ThreeViewer is the main class in the framework to manage a scene, render and add plugins to it.
 * @category Viewer
 */
export declare class ThreeViewer extends EventDispatcher<Record<IViewerEventTypes, IViewerEvent>> {
    static readonly VERSION = "0.5.0";
    static readonly ConfigTypeSlug = "vjson";
    uiConfig: UiObjectConfig;
    static Console: IConsoleWrapper;
    static Dialog: IDialogWrapper;
    readonly type = "ThreeViewer";
    /**
     * If the viewer is enabled. Set this `false` to disable RAF loop.
     */
    enabled: boolean;
    /**
     * Enable or disable all rendering.
     * When disabled, the animation loop is still running, but nothing is rendered.
     * This can be used to pause rendering when not needed, for example when the viewer is not visible.
     * Note: this does not pause plugins or the timeline, use {@link enabled} for that.
     */
    renderEnabled: boolean;
    readonly assetManager: AssetManager;
    readonly object3dManager: Object3DManager;
    readonly renderManager: ViewerRenderManager;
    /**
     * The Scene attached to the viewer, this cannot be changed.
     * @type {RootScene}
     */
    private readonly _scene;
    /**
     * Main timeline for the viewer.
     *
     * It's a WIP, API might change.
     */
    readonly timeline: ViewerTimeline;
    get materialManager(): import('../assetmanager').MaterialManager<object>;
    readonly plugins: Record<string, IViewerPlugin>;
    /**
     * Scene with object hierarchy used for rendering
     */
    get scene(): RootScene & Scene;
    /**
     * Specifies how many frames to render in a single request animation frame. Keep to 1 for realtime rendering.
     * Note: should be max (screen refresh rate / animation frame rate) like 60Hz / 30fps
     */
    maxFramePerLoop: number;
    readonly debug: boolean;
    /**
     * Number of times to run composer render. If set to more than 1, preRender and postRender events will also be called multiple times.
     */
    rendersPerFrame: number;
    /**
     * Get the HTML Element containing the canvas
     * @returns {HTMLElement}
     */
    get container(): HTMLElement;
    /**
     * Get the HTML Canvas Element where the viewer is rendering
     * @returns {HTMLCanvasElement}
     */
    get canvas(): HTMLCanvasElement;
    get console(): IConsoleWrapper;
    get dialog(): IDialogWrapper;
    /**
     * Helper to track and visualize rendering performance while in debug mode.
     */
    renderStats?: GLStatsJS;
    /**
     * The ResizeObserver observing the canvas element. Add more elements to this observer to resize viewer on their size change.
     * @type {ResizeObserver | undefined}
     */
    readonly resizeObserver: ResizeObserver | undefined;
    private readonly _canvas;
    private readonly _container;
    private _needsResize;
    private _isRenderingFrame;
    private _needsReset;
    private _lastCameraPosition;
    private _lastCameraQuat;
    private _lastCameraTarget;
    private _tempVec;
    private _tempQuat;
    private _lastMainCamera;
    /**
     * If any of the viewers are in debug mode, this will be true.
     * This is required for debugging/logging in some cases.
     */
    static ViewerDebugging: boolean;
    /**
     * plugins that are not serialized/deserialized with the viewer from config. useful when loading files exported from the editor, etc
     * (runtime only, not serialized itself)
     */
    serializePluginsIgnored: string[];
    /**
     * Create a viewer instance for using the webgi viewer SDK.
     * @param options - {@link ThreeViewerOptions}
     */
    constructor({ debug, ...options }: ThreeViewerOptions);
    /**
     * Add an object/model/material/viewer-config/plugin-preset/... to the viewer scene from url or an {@link IAsset} object.
     * Same as {@link AssetManager.addAssetSingle}
     * @param obj
     * @param options
     */
    load<T extends ImportResult = ImportResult>(obj: string | IAsset | File | null, options?: ImportAddOptions): Promise<T | undefined>;
    /**
     * Imports an object/model/material/texture/viewer-config/plugin-preset/... to the viewer scene from url or an {@link IAsset} object.
     * Same as {@link AssetImporter.importSingle}
     * @param obj
     * @param options
     */
    import<T extends ImportResult = ImportResult>(obj: string | IAsset | File | null, options?: ImportAssetOptions): Promise<T | undefined>;
    /**
     * Set the environment map of the scene from url or an {@link IAsset} object.
     * @param map
     * @param setBackground - Set the background image of the scene from the same map.
     * @param options - Options for importing the asset. See {@link ImportAssetOptions}
     */
    setEnvironmentMap(map: string | IAsset | null | ITexture | File | undefined, { setBackground, ...options }?: ImportAssetOptions & {
        setBackground?: boolean;
    }): Promise<ITexture | null>;
    /**
     * Set the background image of the scene from url or an {@link IAsset} object.
     * @param map
     * @param setEnvironment - Set the environment map of the scene from the same map.
     * @param options - Options for importing the asset. See {@link ImportAssetOptions}
     */
    setBackgroundMap(map: string | IAsset | null | ITexture | File | undefined, { setEnvironment, ...options }?: ImportAssetOptions & {
        setBackground?: boolean;
    }): Promise<ITexture | null>;
    /**
     * Exports an object/mesh/material/texture/render-target/plugin-preset/viewer to a blob.
     * If no object is given, a glb is exported with the current viewer state.
     * @param obj
     * @param options
     */
    export(obj?: IObject3D | IMaterial | ITexture | IRenderTarget | IViewerPlugin | (typeof this), options?: ExportFileOptions): Promise<BlobExt | undefined>;
    /**
     * Export the scene to a file (default: glb with viewer config) and return a blob
     * @param options
     * @param useExporterPlugin - uses the {@link AssetExporterPlugin} if available. This is useful to use the options configured by the user in the plugin.
     */
    exportScene(options?: ExportFileOptions, useExporterPlugin?: boolean): Promise<BlobExt | undefined>;
    /**
     * Returns a blob with the screenshot of the canvas.
     * If {@link CanvasSnapshotPlugin} is added, it will be used, otherwise canvas.toBlob will be used directly.
     * @param mimeType default image/jpeg
     * @param quality between 0 and 100
     */
    getScreenshotBlob({ mimeType, quality }?: {
        mimeType?: string | undefined;
        quality?: number | undefined;
    }): Promise<Blob | null | undefined>;
    getScreenshotDataUrl({ mimeType, quality }?: {
        mimeType?: string | undefined;
        quality?: number | undefined;
    }): Promise<string | null | undefined>;
    /**
     * Disposes the viewer and frees up all resource and events. Do not use the viewer after calling dispose.
     * NOTE - If you want to reuse the viewer, set viewer.enabled to false instead, then set it to true again when required.
     * To dispose all the objects, materials in the scene, but not the viewer itself, use `viewer.scene.disposeSceneModels()`
     */
    dispose(clear?: boolean): void;
    /**
     * Mark that the canvas is resized. If the size is changed, the renderer and all render targets are resized. This happens before the render of the next frame.
     */
    resize: () => void;
    /**
     * Set the viewer to dirty and trigger render of the next frame.
     *
     * This also triggers the 'update' event on the viewer. Note - update event might be triggered multiple times in a single frame, use preFrame or preRender events to get notified only once per frame.
     * @param source - The source of the dirty event. like plugin or 3d object
     * @param event - The event that triggered the dirty event.
     */
    setDirty(source?: any, event?: Event): void;
    protected _animationLoop(event: IAnimationLoopEvent): void;
    /**
     * Get the Plugin by a constructor type or by the string type.
     * Use string type if the plugin is not a dependency, and you don't want to bundle the plugin.
     * @param type - The class of the plugin to get, or the string type of the plugin to get which is in the static PluginType property of the plugin
     * @returns {T extends IViewerPlugin | undefined} - The plugin of the specified type.
     */
    getPlugin<T extends IViewerPlugin>(type: Class<T> | string): T | undefined;
    getPlugins<T extends IViewerPlugin>(type: Class<T> | string): T[];
    /**
     * Get the Plugin by a constructor type or add a new plugin of the specified type if it doesn't exist.
     * @param type
     * @param args - arguments for the constructor of the plugin, used when a new plugin is created.
     */
    getOrAddPlugin<T extends IViewerPlugin>(type: Class<T>, ...args: ConstructorParameters<Class<T>>): Promise<T>;
    /**
     * Get the Plugin by a constructor type or add a new plugin to the viewer of the specified type if it doesn't exist(sync).
     * @param type
     * @param args - arguments for the constructor of the plugin, used when a new plugin is created.
     */
    getOrAddPluginSync<T extends IViewerPluginSync>(type: Class<T>, ...args: ConstructorParameters<Class<T>>): T;
    /**
     * Add a plugin to the viewer.
     * @param plugin - The instance of the plugin to add or the class of the plugin to add.
     * @param args - Arguments for the constructor of the plugin, in case a class is passed.
     * @returns {Promise<T>} - The plugin added.
     */
    addPlugin<T extends IViewerPlugin>(plugin: T | Class<T>, ...args: ConstructorParameters<Class<T>>): Promise<T>;
    /**
     * Add a plugin to the viewer(sync).
     * @param plugin
     * @param args
     */
    addPluginSync<T extends IViewerPluginSync>(plugin: T | Class<T>, ...args: ConstructorParameters<Class<T>>): T;
    /**
     * Add multiple plugins to the viewer.
     * @param plugins - List of plugin instances or classes
     */
    addPlugins(plugins: (IViewerPlugin | Class<IViewerPlugin>)[]): Promise<void>;
    /**
     * Add multiple plugins to the viewer(sync).
     * @param plugins - List of plugin instances or classes
     */
    addPluginsSync(plugins: (IViewerPluginSync | Class<IViewerPluginSync>)[]): void;
    /**
     * Remove a plugin instance or a plugin class. Works similar to {@link ThreeViewer.addPlugin}
     * @param p
     * @param dispose
     * @returns {Promise<void>}
     */
    removePlugin(p: IViewerPlugin<ThreeViewer, boolean>, dispose?: boolean): Promise<void>;
    /**
     * Remove a plugin instance or a plugin class(sync). Works similar to {@link ThreeViewer.addPluginSync}
     * @param p
     * @param dispose
     */
    removePluginSync(p: IViewerPluginSync, dispose?: boolean): void;
    /**
     * Set size of the canvas and update the renderer.
     * If no size or width/height is passed, canvas is set to 100% of the container.
     *
     * See also {@link ThreeViewer.setRenderSize} to set the size of the render target by automatically calculating the renderScale and fitting in container.
     *
     * Note: Apps using this should ideally set `max-width: 100%` for the canvas in css.
     * @param size
     */
    setSize(size?: {
        width?: number;
        height?: number;
    }): void;
    /**
     * Set the render size of the viewer to fit in the container according to the specified mode, maintaining aspect ratio.
     * Changes the renderScale accordingly.
     * Note: the canvas needs to be centered in the container to work properly, this can be done with the following css on the container:
     * ```css
     * display: flex;
     * justify-content: center;
     * align-items: center;
     * ```
     * or in js:
     * ```js
     * viewer.container.style.display = 'flex';
     * viewer.container.style.justifyContent = 'center';
     * viewer.container.style.alignItems = 'center';
     * ```
     * Modes:
     * 'contain': The canvas is scaled to fit within the container while maintaining its aspect ratio. The canvas will be fully visible, but there may be empty space around it.
     * 'cover': The canvas is scaled to fill the entire container while maintaining its aspect ratio. Part of the canvas may be clipped to fit the container.
     * 'fill': The canvas is stretched to completely fill the container, ignoring its aspect ratio.
     * 'scale-down': The canvas is scaled down to fit within the container while maintaining its aspect ratio, but it won't be scaled up if it's smaller than the container.
     * 'none': container size is ignored, but devicePixelRatio is used
     *
     * Check the example for more details - https://threepipe.org/examples/#viewer-render-size/
     * @param size - The size to set the render to. The canvas will render to this size.
     * @param mode - 'contain', 'cover', 'fill', 'scale-down' or 'none'. Default is 'contain'.
     * @param devicePixelRatio - typically set to `window.devicePixelRatio`, or `Math.min(1.5, window.devicePixelRatio)` for performance. Use this only when size is derived from dom elements.
     * @param containerSize - (optional) The size of the container, if not passed, the bounding client rect of the container is used.
     */
    setRenderSize(size: {
        width: number;
        height: number;
    }, mode?: 'contain' | 'cover' | 'fill' | 'scale-down' | 'none', devicePixelRatio?: number, containerSize?: {
        width: number;
        height: number;
    }): void;
    /**
     * Traverse all objects in scene model root.
     * @param callback
     */
    traverseSceneObjects<T extends IObject3D = IObject3D>(callback: (o: T) => void): void;
    deleteImportedViewerConfigOnLoad: boolean;
    deleteImportedViewerConfigOnLoadWait: number;
    /**
     * Add an object to the scene model root.
     * If an imported scene model root is passed, it will be loaded with viewer configuration, unless importConfig is false
     * @param imported
     * @param options
     */
    addSceneObject<T extends IObject3D | Object3D | RootSceneImportResult = RootSceneImportResult>(imported: T, options?: AddObjectOptions): Promise<T>;
    /**
     * Serialize all the plugins and their settings to save or create presets. Used in {@link toJSON}.
     * @param meta -  The meta object.
     * @param filter - List of PluginType for to include. If empty, no plugins will be serialized. If undefined, all plugins will be serialized.
     * @returns {any[]}
     */
    serializePlugins(meta: SerializationMetaType, filter?: string[]): ISerializedConfig[];
    serializePlugin(plugin: IViewerPlugin, meta: SerializationMetaType): ISerializedConfig | undefined;
    /**
     * Deserialize all the plugins and their settings from a preset. Used in {@link fromJSON}.
     * @param plugins - The output of {@link serializePlugins}.
     * @param meta - The meta object.
     * @returns {this}
     */
    deserializePlugins(plugins: any[], meta?: SerializationMetaType): this;
    /**
     * Serialize a single plugin settings.
     */
    exportPluginConfig(plugin?: string | Class<IViewerPlugin> | IViewerPlugin): ISerializedConfig | Record<string, never>;
    /**
     * Deserialize and import a single plugin settings.
     * Can also use {@link ThreeViewer.importConfig} to import only plugin config.
     * @param json
     * @param plugin
     */
    importPluginConfig(json: ISerializedConfig, plugin?: IViewerPlugin): Promise<IViewerPlugin<ThreeViewer, boolean> | undefined>;
    /**
     * Serialize multiple plugin settings.
     * @param filter - List of PluginType to include. If empty, no plugins will be serialized. If undefined, all plugins will be serialized.
     */
    exportPluginsConfig(filter?: string[]): ISerializedViewerConfig;
    /**
     * Serialize all the viewer and plugin settings.
     * @param binary - Indicate that the output will be converted and saved as binary data. (default: false)
     * @param pluginFilter - List of PluginType to include. If empty, no plugins will be serialized. If undefined, all plugins will be serialized.
     */
    exportConfig(binary?: boolean, pluginFilter?: string[]): ISerializedViewerConfig;
    /**
     * Deserialize and import all the viewer and plugin settings, exported with {@link exportConfig}.
     *
     * @param json - The serialized JSON object returned from {@link exportConfig} or {@link toJSON}.
     * @returns {Promise<this>} - The viewer instance with the imported config.
     */
    importConfig(json: ISerializedConfig | ISerializedViewerConfig, meta?: SerializationMetaType): Promise<this | IViewerPlugin | undefined>;
    /**
     * Serialize all the viewer and plugin settings and versions.
     * @param binary - Indicate that the output will be converted and saved as binary data. (default: true)
     * @param pluginFilter - List of PluginType to include. If empty, no plugins will be serialized. If undefined/not-passed, all plugins will be serialized.
     * @returns {any} - Serializable JSON object.
     */
    toJSON(binary?: boolean, pluginFilter?: string[], meta?: SerializationMetaType): ISerializedViewerConfig;
    /**
     * Deserialize all the viewer and plugin settings.
     * NOTE - use async {@link ThreeViewer.importConfig} to import a json/config exported with {@link ThreeViewer.exportConfig} or {@link ThreeViewer.toJSON}.
     * @param data - The serialized JSON object returned from {@link toJSON}.
     * @param meta - The meta object, see {@link SerializationMetaType}
     * @returns {this}
     */
    fromJSON(data: ISerializedViewerConfig, meta?: SerializationMetaType): this | null;
    loadConfigResources: (json: Partial<SerializationMetaType>, extraResources?: Partial<SerializationResourcesType>) => Promise<SerializationMetaType>;
    doOnce<TRet>(event: IViewerEventTypes, func?: (...args: any[]) => TRet): Promise<TRet | undefined>;
    dispatchEvent(event: IViewerEvent): void;
    /**
     * Uses the {@link FileTransferPlugin} to export a Blob/File. If the plugin is not available, it will download the blob.
     * {@link FileTransferPlugin} can be configured by other plugins to export the blob to a specific location like local file system, cloud storage, etc.
     * @param blob - The blob or file to export/download
     * @param name - name of the file, if not provided, the name of the file is used if it's a file.
     */
    exportBlob(blob: Blob | File, name?: string): Promise<void>;
    private _setActiveCameraView;
    private _resolvePluginOrClass;
    private _renderEnabledChanged;
    private readonly _defaultConfig;
    private _lastSize;
    private _onContextRestore;
    private _onContextLost;
    /**
     * Fits the camera to frame the selected objects (or the entire scene if none).
     * When `duration` is 0, the view is set instantly without animation.
     * @param selected - objects to fit (Object3D, materials, textures, or geometries). Falls back to entire scene.
     * @param distanceMultiplier - padding multiplier (default 1.5)
     * @param duration - animation duration in ms. Pass 0 for instant. Defaults to CameraViewPlugin.animDuration (1000ms).
     * @param ease - easing function or name
     */
    fitToView(selected?: Object3D | Object3D[] | IMaterial | IMaterial[] | ITexture | ITexture[] | IGeometry | IGeometry[], distanceMultiplier?: number, duration?: number, ease?: ((v: number) => number) | EasingFunctionType): Promise<void>;
    private _canvasTexture?;
    /**
     * Create and get a three.js CanvasTexture from the viewer's canvas.
     */
    get canvasTexture(): CanvasTexture;
    private _stopPropagation;
    private _onListeners;
    on<T extends keyof ViewerEventMap>(type: T, listener: ViewerEventListener<T>): (() => void) | undefined;
    off<T extends keyof ViewerEventMap>(type: T, listener: ViewerEventListener<T>): void;
    dispatch<T extends keyof ViewerEventMap>(type: T, event: ViewerEventMap[T]): void;
    private _onPluginAdd;
    private _onPluginRemove;
    private _pluginListeners;
    addPluginListener(type: 'add' | 'remove', listener: (event: IViewerEvent) => void, ...plugins: (string | undefined)[]): void;
    removePluginListener(type: 'add' | 'remove', listener: (event: IViewerEvent) => void): void;
    /**
     * Can be used to "subscribe" to plugins.
     * @param plugin
     * @param mount
     * @param unmount
     */
    forPlugin<T extends IViewerPlugin>(plugin: string | Class<T>, mount: (p: T) => void, unmount?: (p: T) => void, thisPlugin?: AViewerPlugin): void;
    /**
     * The renderer for the viewer that's attached to the canvas. This is wrapper around WebGLRenderer and EffectComposer and manages post-processing passes and rendering logic
     * @deprecated - use {@link renderManager} instead
     */
    get renderer(): ViewerRenderManager;
    /**
     * @deprecated use {@link assetManager} instead.
     * Gets the Asset manager, contains useful functions for managing, loading and inserting assets.
     */
    getManager(): AssetManager | undefined;
    /**
     * Get the Plugin by the string type.
     * @deprecated - Use {@link getPlugin} instead.
     * @param type
     * @returns {T | undefined}
     */
    getPluginByType<T extends IViewerPlugin>(type: string): T | undefined;
}
//# sourceMappingURL=../src/viewer/ThreeViewer.d.ts.map