import * as THREE from 'three';
import * as React from 'react';
import { TinyEmitter } from 'tiny-emitter';
import { ReactThreeFiber } from './three-types';
import { RectReadOnly } from 'react-use-measure';
export declare type Camera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
export declare function isOrthographicCamera(def: THREE.Camera): def is THREE.OrthographicCamera;
export declare type DomEvent = React.MouseEvent<HTMLDivElement, MouseEvent> | React.WheelEvent<HTMLDivElement> | React.PointerEvent<HTMLDivElement>;
export interface Intersection extends THREE.Intersection {
    eventObject: THREE.Object3D;
}
export declare type PointerEvent = DomEvent & Intersection & {
    stopped: React.MutableRefObject<boolean>;
    unprojectedPoint: THREE.Vector3;
    ray: THREE.Ray;
    camera: THREE.Camera;
    stopPropagation: () => void;
    sourceEvent: DomEvent;
    delta: number;
};
export declare type RenderCallback = (state: CanvasContext, delta: number) => void;
export declare type SharedCanvasContext = {
    gl: THREE.WebGLRenderer;
    aspect: number;
    subscribe: (callback: React.MutableRefObject<RenderCallback>, priority?: number) => () => void;
    setDefaultCamera: (camera: Camera) => void;
    invalidate: () => void;
    intersect: (event?: DomEvent) => void;
    camera: Camera;
    raycaster: THREE.Raycaster;
    mouse: THREE.Vector2;
    clock: THREE.Clock;
    scene: THREE.Scene;
    size: RectReadOnly;
    viewport: {
        width: number;
        height: number;
        factor: number;
    };
    events: PointerEvents;
};
export declare type Subscription = {
    ref: React.MutableRefObject<RenderCallback>;
    priority: number;
};
export declare type CanvasContext = SharedCanvasContext & {
    captured: Intersection[] | undefined;
    noEvents: boolean;
    ready: boolean;
    active: boolean;
    manual: number;
    vr: boolean;
    concurrent: boolean;
    invalidateFrameloop: boolean;
    frames: number;
    subscribers: Subscription[];
    initialClick: [number, number];
    initialHits: THREE.Object3D[];
    pointer: TinyEmitter;
};
export declare type FilterFunction = (items: THREE.Intersection[], state: SharedCanvasContext) => THREE.Intersection[];
export declare type ResizeOptions = {
    debounce?: number | {
        scroll: number;
        resize: number;
    };
    scroll?: boolean;
};
export interface CanvasProps {
    children: React.ReactNode;
    vr?: boolean;
    gl2?: boolean;
    concurrent?: boolean;
    shadowMap?: boolean | Partial<THREE.WebGLShadowMap>;
    orthographic?: boolean;
    resize?: ResizeOptions;
    invalidateFrameloop?: boolean;
    updateDefaultCamera?: boolean;
    noEvents?: boolean;
    gl?: Partial<THREE.WebGLRendererParameters>;
    camera?: Partial<ReactThreeFiber.Object3DNode<THREE.Camera, typeof THREE.Camera> & ReactThreeFiber.Object3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera> & ReactThreeFiber.Object3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>>;
    raycaster?: Partial<THREE.Raycaster> & {
        filter?: FilterFunction;
    };
    pixelRatio?: number;
    onCreated?: (props: CanvasContext) => Promise<any> | void;
    onPointerMissed?: () => void;
}
export interface UseCanvasProps extends CanvasProps {
    gl: THREE.WebGLRenderer;
    size: RectReadOnly;
}
export declare type PointerEvents = {
    onClick(e: any): void;
    onWheel(e: any): void;
    onPointerDown(e: any): void;
    onPointerUp(e: any): void;
    onPointerLeave(e: any): void;
    onPointerMove(e: any): void;
    onGotPointerCapture(e: any): void;
    onLostPointerCapture(e: any): void;
};
export declare const stateContext: React.Context<SharedCanvasContext>;
export declare const useCanvas: (props: UseCanvasProps) => PointerEvents;