angular-three 0.0.0-replace

package/lib/canvas.d.ts

@@ -0,0 +1,1170 @@
+import { ElementRef, ViewContainerRef, type Type } from '@angular/core';
+import { type ResizeResult } from 'ngxtension/resize';
+import * as THREE from 'three';
+import type { NgtCamera, NgtEventManager } from './events';
+import { type NgtCanvasElement } from './roots';
+import { type NgtDpr, type NgtPerformance, type NgtRendererLike, type NgtSize, type NgtState } from './store';
+import type { NgtObject3DNode } from './three-types';
+import type { NgtAnyRecord, NgtProperties } from './types';
+import { type NgtSignalStore } from './utils/signal-store';
+import * as i0 from "@angular/core";
+export type NgtGLOptions = NgtRendererLike | ((canvas: NgtCanvasElement) => NgtRendererLike) | Partial<NgtProperties<THREE.WebGLRenderer> | THREE.WebGLRendererParameters> | undefined;
+export type NgtCanvasInputs = {
+    /** A threejs renderer instance or props that go into the default renderer */
+    gl?: NgtGLOptions;
+    /** Dimensions to fit the renderer to. Will measure canvas dimensions if omitted */
+    size?: NgtSize;
+    /**
+     * Enables shadows (by default PCFsoft). Can accept `gl.shadowMap` options for fine-tuning,
+     * but also strings: 'basic' | 'percentage' | 'soft' | 'variance'.
+     * @see https://threejs.org/docs/#api/en/renderers/WebGLRenderer.shadowMap
+     */
+    shadows?: boolean | 'basic' | 'percentage' | 'soft' | 'variance' | Partial<THREE.WebGLShadowMap>;
+    /**
+     * Disables three r139 color management.
+     * @see https://threejs.org/docs/#manual/en/introduction/Color-management
+     */
+    legacy?: boolean;
+    /** Switch off automatic sRGB color space and gamma correction */
+    linear?: boolean;
+    /** Use `THREE.NoToneMapping` instead of `THREE.ACESFilmicToneMapping` */
+    flat?: boolean;
+    /** Creates an orthographic camera */
+    orthographic?: boolean;
+    /**
+     * R3F's render mode. Set to `demand` to only render on state change or `never` to take control.
+     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#on-demand-rendering
+     */
+    frameloop?: 'always' | 'demand' | 'never';
+    /**
+     * R3F performance options for adaptive performance.
+     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#movement-regression
+     */
+    performance?: Partial<Omit<NgtPerformance, 'regress'>>;
+    /** Target pixel ratio. Can clamp between a range: `[min, max]` */
+    dpr?: NgtDpr;
+    /** Props that go into the default raycaster */
+    raycaster?: Partial<THREE.Raycaster>;
+    /** A `THREE.Scene` instance or props that go into the default scene */
+    scene?: THREE.Scene | Partial<THREE.Scene>;
+    /** A `Camera` instance or props that go into the default camera */
+    camera?: (NgtCamera | Partial<NgtObject3DNode<THREE.Camera, typeof THREE.Camera> & NgtObject3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera> & NgtObject3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>>) & {
+        /** Flags the camera as manual, putting projection into your own hands */
+        manual?: boolean;
+    };
+    /** An R3F event manager to manage elements' pointer events */
+    events?: (store: NgtSignalStore<NgtState>) => NgtEventManager<HTMLElement>;
+    /** The target where events are being subscribed to, default: the div that wraps canvas */
+    eventSource?: HTMLElement | ElementRef<HTMLElement>;
+    /** The event prefix that is cast into canvas pointer x/y events, default: "offset" */
+    eventPrefix?: 'offset' | 'client' | 'page' | 'layer' | 'screen';
+    /** Default coordinate for the camera to look at */
+    lookAt?: THREE.Vector3 | Parameters<THREE.Vector3['set']>;
+};
+export declare class NgtCanvas {
+    private store;
+    private initRoot;
+    private autoEffect;
+    private host;
+    private zone;
+    private environmentInjector;
+    private injector;
+    sceneGraph: import("@angular/core").InputSignal<Type<any>>;
+    compoundPrefixes: import("@angular/core").InputSignal<string[]>;
+    sceneGraphInputs: import("@angular/core").InputSignal<NgtAnyRecord>;
+    gl: import("@angular/core").InputSignal<NgtGLOptions>;
+    size: import("@angular/core").InputSignal<NgtSize | undefined>;
+    shadows: import("@angular/core").InputSignalWithTransform<boolean | Partial<THREE.WebGLShadowMap> | "basic" | "percentage" | "soft" | "variance", unknown>;
+    legacy: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    linear: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    flat: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    orthographic: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    frameloop: import("@angular/core").InputSignal<"always" | "demand" | "never" | undefined>;
+    performance: import("@angular/core").InputSignal<Partial<Omit<NgtPerformance, "regress">> | undefined>;
+    dpr: import("@angular/core").InputSignal<NgtDpr>;
+    raycaster: import("@angular/core").InputSignal<Partial<THREE.Raycaster> | undefined>;
+    scene: import("@angular/core").InputSignal<THREE.Scene | Partial<THREE.Scene> | undefined>;
+    camera: import("@angular/core").InputSignal<((NgtCamera | Partial<Omit<import("./three-types").NgtExtendedColors<import("./three-types").NgtOverwrite<Partial<{
+        coordinateSystem: THREE.CoordinateSystem;
+        clear: () => THREE.Camera;
+        attach: (object: THREE.Object3D<THREE.Object3DEventMap>) => THREE.Camera;
+        readonly position: THREE.Vector3;
+        up: THREE.Vector3;
+        readonly scale: THREE.Vector3;
+        readonly rotation: THREE.Euler;
+        matrix: THREE.Matrix4;
+        readonly quaternion: THREE.Quaternion;
+        layers: THREE.Layers;
+        readonly isCamera: true;
+        readonly type: string;
+        matrixWorldInverse: THREE.Matrix4;
+        projectionMatrix: THREE.Matrix4;
+        projectionMatrixInverse: THREE.Matrix4;
+        viewport?: THREE.Vector4 | undefined;
+        getWorldDirection: (target: THREE.Vector3) => THREE.Vector3;
+        readonly isObject3D: true;
+        readonly id: number;
+        uuid: string;
+        name: string;
+        parent: THREE.Object3D<THREE.Object3DEventMap> | null;
+        children: THREE.Object3D<THREE.Object3DEventMap>[];
+        readonly modelViewMatrix: THREE.Matrix4;
+        readonly normalMatrix: THREE.Matrix3;
+        matrixWorld: THREE.Matrix4;
+        matrixAutoUpdate: boolean;
+        matrixWorldAutoUpdate: boolean;
+        matrixWorldNeedsUpdate: boolean;
+        visible: boolean;
+        castShadow: boolean;
+        receiveShadow: boolean;
+        frustumCulled: boolean;
+        renderOrder: number;
+        animations: THREE.AnimationClip[];
+        userData: Record<string, any>;
+        customDepthMaterial?: THREE.Material | undefined;
+        customDistanceMaterial?: THREE.Material | undefined;
+        onBeforeShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+        onAfterShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+        onBeforeRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+        onAfterRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+        applyMatrix4: (matrix: THREE.Matrix4) => void;
+        applyQuaternion: (quaternion: THREE.Quaternion) => THREE.Camera;
+        setRotationFromAxisAngle: (axis: THREE.Vector3, angle: number) => void;
+        setRotationFromEuler: (euler: THREE.Euler) => void;
+        setRotationFromMatrix: (m: THREE.Matrix4) => void;
+        setRotationFromQuaternion: (q: THREE.Quaternion) => void;
+        rotateOnAxis: (axis: THREE.Vector3, angle: number) => THREE.Camera;
+        rotateOnWorldAxis: (axis: THREE.Vector3, angle: number) => THREE.Camera;
+        rotateX: (angle: number) => THREE.Camera;
+        rotateY: (angle: number) => THREE.Camera;
+        rotateZ: (angle: number) => THREE.Camera;
+        translateOnAxis: (axis: THREE.Vector3, distance: number) => THREE.Camera;
+        translateX: (distance: number) => THREE.Camera;
+        translateY: (distance: number) => THREE.Camera;
+        translateZ: (distance: number) => THREE.Camera;
+        localToWorld: (vector: THREE.Vector3) => THREE.Vector3;
+        worldToLocal: (vector: THREE.Vector3) => THREE.Vector3;
+        lookAt: {
+            (vector: THREE.Vector3): void;
+            (x: number, y: number, z: number): void;
+        };
+        add: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.Camera;
+        remove: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.Camera;
+        removeFromParent: () => THREE.Camera;
+        getObjectById: (id: number) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+        getObjectByName: (name: string) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+        getObjectByProperty: (name: string, value: any) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+        getObjectsByProperty: (name: string, value: any, optionalTarget?: THREE.Object3D<THREE.Object3DEventMap>[] | undefined) => THREE.Object3D<THREE.Object3DEventMap>[];
+        getWorldPosition: (target: THREE.Vector3) => THREE.Vector3;
+        getWorldQuaternion: (target: THREE.Quaternion) => THREE.Quaternion;
+        getWorldScale: (target: THREE.Vector3) => THREE.Vector3;
+        raycast: (raycaster: THREE.Raycaster, intersects: THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[]) => void;
+        traverse: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+        traverseVisible: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+        traverseAncestors: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+        updateMatrix: () => void;
+        updateMatrixWorld: (force?: boolean | undefined) => void;
+        updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+        toJSON: (meta?: {
+            geometries: any;
+            materials: any;
+            textures: any;
+            images: any;
+        } | undefined) => any;
+        clone: (recursive?: boolean | undefined) => THREE.Camera;
+        copy: (object: THREE.Object3D<THREE.Object3DEventMap>, recursive?: boolean | undefined) => THREE.Camera;
+        hasEventListener: {
+            <T extends keyof THREE.Object3DEventMap>(type: T, listener: THREE.EventListener<THREE.Object3DEventMap[T], T, THREE.Camera>): boolean;
+            <T_1 extends string>(type: T_1, listener: THREE.EventListener<{}, T_1, THREE.Camera>): boolean;
+        };
+        dispatchEvent: <T_2 extends keyof THREE.Object3DEventMap>(event: THREE.BaseEvent<T_2> & THREE.Object3DEventMap[T_2]) => void;
+    }>, import("./three-types").NgtNodeElement<THREE.Camera, typeof THREE.Camera>>>, import("./three-types").NgtNonFunctionKeys<{
+        position: import("./three-types").NgtVector3;
+        up: import("./three-types").NgtVector3;
+        scale: import("./three-types").NgtVector3;
+        rotation: import("./three-types").NgtEuler;
+        matrix: import("./three-types").NgtMatrix4;
+        quaternion: import("./three-types").NgtQuaternion;
+        layers: import("./three-types").NgtLayers;
+        dispose: (() => void) | null;
+        addEventListener<TEventKey extends keyof import("./events").NgtEventHandlers>(type: TEventKey, listener: (this: NgtObject3DNode<TOriginal, TConstructor, Exclude<keyof TOriginal, "addEventListener" | "removeEventListener"> extends infer T extends keyof TOriginal ? { [P in T]: TOriginal[P]; } : never>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey]) => any): void;
+        removeEventListener<TEventKey_1 extends keyof import("./events").NgtEventHandlers>(type: TEventKey_1, listener: (this: NgtObject3DNode<TOriginal, TConstructor, Exclude<keyof TOriginal, "addEventListener" | "removeEventListener"> extends infer T_1 extends keyof TOriginal ? { [P in T_1]: TOriginal[P]; } : never>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey_1]) => any): void; /** Flags the camera as manual, putting projection into your own hands */
+    }>> & {
+        position: import("./three-types").NgtVector3;
+        up: import("./three-types").NgtVector3;
+        scale: import("./three-types").NgtVector3;
+        rotation: import("./three-types").NgtEuler;
+        matrix: import("./three-types").NgtMatrix4;
+        quaternion: import("./three-types").NgtQuaternion;
+        layers: import("./three-types").NgtLayers;
+        dispose: (() => void) | null;
+        addEventListener<TEventKey_2 extends keyof import("./events").NgtEventHandlers>(type: TEventKey_2, listener: (this: NgtObject3DNode<THREE.Camera, typeof THREE.Camera, {
+            coordinateSystem: THREE.CoordinateSystem;
+            clear: () => THREE.Camera;
+            attach: (object: THREE.Object3D<THREE.Object3DEventMap>) => THREE.Camera;
+            readonly position: THREE.Vector3;
+            up: THREE.Vector3;
+            readonly scale: THREE.Vector3;
+            readonly rotation: THREE.Euler;
+            matrix: THREE.Matrix4;
+            readonly quaternion: THREE.Quaternion;
+            layers: THREE.Layers;
+            readonly isCamera: true;
+            readonly type: string;
+            matrixWorldInverse: THREE.Matrix4;
+            projectionMatrix: THREE.Matrix4;
+            projectionMatrixInverse: THREE.Matrix4;
+            viewport?: THREE.Vector4 | undefined;
+            getWorldDirection: (target: THREE.Vector3) => THREE.Vector3;
+            readonly isObject3D: true;
+            readonly id: number;
+            uuid: string;
+            name: string;
+            parent: THREE.Object3D<THREE.Object3DEventMap> | null;
+            children: THREE.Object3D<THREE.Object3DEventMap>[];
+            readonly modelViewMatrix: THREE.Matrix4;
+            readonly normalMatrix: THREE.Matrix3;
+            matrixWorld: THREE.Matrix4;
+            matrixAutoUpdate: boolean;
+            matrixWorldAutoUpdate: boolean;
+            matrixWorldNeedsUpdate: boolean;
+            visible: boolean;
+            castShadow: boolean;
+            receiveShadow: boolean;
+            frustumCulled: boolean;
+            renderOrder: number;
+            animations: THREE.AnimationClip[];
+            userData: Record<string, any>;
+            customDepthMaterial?: THREE.Material | undefined;
+            customDistanceMaterial?: THREE.Material | undefined;
+            onBeforeShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onAfterShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onBeforeRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onAfterRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            applyMatrix4: (matrix: THREE.Matrix4) => void;
+            applyQuaternion: (quaternion: THREE.Quaternion) => THREE.Camera;
+            setRotationFromAxisAngle: (axis: THREE.Vector3, angle: number) => void;
+            setRotationFromEuler: (euler: THREE.Euler) => void;
+            setRotationFromMatrix: (m: THREE.Matrix4) => void;
+            setRotationFromQuaternion: (q: THREE.Quaternion) => void;
+            rotateOnAxis: (axis: THREE.Vector3, angle: number) => THREE.Camera;
+            rotateOnWorldAxis: (axis: THREE.Vector3, angle: number) => THREE.Camera;
+            rotateX: (angle: number) => THREE.Camera;
+            rotateY: (angle: number) => THREE.Camera;
+            rotateZ: (angle: number) => THREE.Camera;
+            translateOnAxis: (axis: THREE.Vector3, distance: number) => THREE.Camera;
+            translateX: (distance: number) => THREE.Camera;
+            translateY: (distance: number) => THREE.Camera;
+            translateZ: (distance: number) => THREE.Camera;
+            localToWorld: (vector: THREE.Vector3) => THREE.Vector3;
+            worldToLocal: (vector: THREE.Vector3) => THREE.Vector3;
+            lookAt: {
+                (vector: THREE.Vector3): void;
+                (x: number, y: number, z: number): void;
+            };
+            add: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.Camera;
+            remove: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.Camera;
+            removeFromParent: () => THREE.Camera;
+            getObjectById: (id: number) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectByName: (name: string) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectByProperty: (name: string, value: any) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: THREE.Object3D<THREE.Object3DEventMap>[] | undefined) => THREE.Object3D<THREE.Object3DEventMap>[];
+            getWorldPosition: (target: THREE.Vector3) => THREE.Vector3;
+            getWorldQuaternion: (target: THREE.Quaternion) => THREE.Quaternion;
+            getWorldScale: (target: THREE.Vector3) => THREE.Vector3;
+            raycast: (raycaster: THREE.Raycaster, intersects: THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[]) => void;
+            traverse: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            traverseVisible: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            traverseAncestors: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            updateMatrix: () => void;
+            updateMatrixWorld: (force?: boolean | undefined) => void;
+            updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+            toJSON: (meta?: {
+                geometries: any;
+                materials: any;
+                textures: any;
+                images: any;
+            } | undefined) => any;
+            clone: (recursive?: boolean | undefined) => THREE.Camera;
+            copy: (object: THREE.Object3D<THREE.Object3DEventMap>, recursive?: boolean | undefined) => THREE.Camera;
+            hasEventListener: {
+                <T_2 extends keyof THREE.Object3DEventMap>(type: T_2, listener: THREE.EventListener<THREE.Object3DEventMap[T_2], T_2, THREE.Camera>): boolean;
+                <T_3 extends string>(type: T_3, listener: THREE.EventListener<{}, T_3, THREE.Camera>): boolean;
+            };
+            dispatchEvent: <T_4 extends keyof THREE.Object3DEventMap>(event: THREE.BaseEvent<T_4> & THREE.Object3DEventMap[T_4]) => void;
+        }>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey_2]) => any): void;
+        removeEventListener<TEventKey_3 extends keyof import("./events").NgtEventHandlers>(type: TEventKey_3, listener: (this: NgtObject3DNode<THREE.Camera, typeof THREE.Camera, {
+            coordinateSystem: THREE.CoordinateSystem;
+            clear: () => THREE.Camera;
+            attach: (object: THREE.Object3D<THREE.Object3DEventMap>) => THREE.Camera;
+            readonly position: THREE.Vector3;
+            up: THREE.Vector3;
+            readonly scale: THREE.Vector3;
+            readonly rotation: THREE.Euler;
+            matrix: THREE.Matrix4;
+            readonly quaternion: THREE.Quaternion;
+            layers: THREE.Layers;
+            readonly isCamera: true;
+            readonly type: string;
+            matrixWorldInverse: THREE.Matrix4;
+            projectionMatrix: THREE.Matrix4;
+            projectionMatrixInverse: THREE.Matrix4;
+            viewport?: THREE.Vector4 | undefined;
+            getWorldDirection: (target: THREE.Vector3) => THREE.Vector3;
+            readonly isObject3D: true;
+            readonly id: number;
+            uuid: string;
+            name: string;
+            parent: THREE.Object3D<THREE.Object3DEventMap> | null;
+            children: THREE.Object3D<THREE.Object3DEventMap>[];
+            readonly modelViewMatrix: THREE.Matrix4;
+            readonly normalMatrix: THREE.Matrix3;
+            matrixWorld: THREE.Matrix4;
+            matrixAutoUpdate: boolean;
+            matrixWorldAutoUpdate: boolean;
+            matrixWorldNeedsUpdate: boolean;
+            visible: boolean;
+            castShadow: boolean;
+            receiveShadow: boolean;
+            frustumCulled: boolean;
+            renderOrder: number;
+            animations: THREE.AnimationClip[];
+            userData: Record<string, any>;
+            customDepthMaterial?: THREE.Material | undefined;
+            customDistanceMaterial?: THREE.Material | undefined;
+            onBeforeShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onAfterShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onBeforeRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onAfterRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            applyMatrix4: (matrix: THREE.Matrix4) => void;
+            applyQuaternion: (quaternion: THREE.Quaternion) => THREE.Camera;
+            setRotationFromAxisAngle: (axis: THREE.Vector3, angle: number) => void;
+            setRotationFromEuler: (euler: THREE.Euler) => void;
+            setRotationFromMatrix: (m: THREE.Matrix4) => void;
+            setRotationFromQuaternion: (q: THREE.Quaternion) => void;
+            rotateOnAxis: (axis: THREE.Vector3, angle: number) => THREE.Camera;
+            rotateOnWorldAxis: (axis: THREE.Vector3, angle: number) => THREE.Camera;
+            rotateX: (angle: number) => THREE.Camera;
+            rotateY: (angle: number) => THREE.Camera;
+            rotateZ: (angle: number) => THREE.Camera;
+            translateOnAxis: (axis: THREE.Vector3, distance: number) => THREE.Camera;
+            translateX: (distance: number) => THREE.Camera;
+            translateY: (distance: number) => THREE.Camera;
+            translateZ: (distance: number) => THREE.Camera;
+            localToWorld: (vector: THREE.Vector3) => THREE.Vector3;
+            worldToLocal: (vector: THREE.Vector3) => THREE.Vector3;
+            lookAt: {
+                (vector: THREE.Vector3): void;
+                (x: number, y: number, z: number): void;
+            };
+            add: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.Camera;
+            remove: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.Camera;
+            removeFromParent: () => THREE.Camera;
+            getObjectById: (id: number) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectByName: (name: string) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectByProperty: (name: string, value: any) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: THREE.Object3D<THREE.Object3DEventMap>[] | undefined) => THREE.Object3D<THREE.Object3DEventMap>[];
+            getWorldPosition: (target: THREE.Vector3) => THREE.Vector3;
+            getWorldQuaternion: (target: THREE.Quaternion) => THREE.Quaternion;
+            getWorldScale: (target: THREE.Vector3) => THREE.Vector3;
+            raycast: (raycaster: THREE.Raycaster, intersects: THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[]) => void;
+            traverse: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            traverseVisible: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            traverseAncestors: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            updateMatrix: () => void;
+            updateMatrixWorld: (force?: boolean | undefined) => void;
+            updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+            toJSON: (meta?: {
+                geometries: any;
+                materials: any;
+                textures: any;
+                images: any;
+            } | undefined) => any;
+            clone: (recursive?: boolean | undefined) => THREE.Camera;
+            copy: (object: THREE.Object3D<THREE.Object3DEventMap>, recursive?: boolean | undefined) => THREE.Camera;
+            hasEventListener: {
+                <T_2 extends keyof THREE.Object3DEventMap>(type: T_2, listener: THREE.EventListener<THREE.Object3DEventMap[T_2], T_2, THREE.Camera>): boolean;
+                <T_3 extends string>(type: T_3, listener: THREE.EventListener<{}, T_3, THREE.Camera>): boolean;
+            };
+            dispatchEvent: <T_4 extends keyof THREE.Object3DEventMap>(event: THREE.BaseEvent<T_4> & THREE.Object3DEventMap[T_4]) => void;
+        }>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey_3]) => any): void; /** Flags the camera as manual, putting projection into your own hands */
+    } & Omit<import("./three-types").NgtExtendedColors<import("./three-types").NgtOverwrite<Partial<{
+        coordinateSystem: THREE.CoordinateSystem;
+        clear: () => THREE.PerspectiveCamera;
+        attach: (object: THREE.Object3D<THREE.Object3DEventMap>) => THREE.PerspectiveCamera;
+        readonly position: THREE.Vector3;
+        up: THREE.Vector3;
+        readonly scale: THREE.Vector3;
+        readonly rotation: THREE.Euler;
+        matrix: THREE.Matrix4;
+        readonly quaternion: THREE.Quaternion;
+        layers: THREE.Layers;
+        readonly isCamera: true;
+        readonly type: string;
+        matrixWorldInverse: THREE.Matrix4;
+        projectionMatrix: THREE.Matrix4;
+        projectionMatrixInverse: THREE.Matrix4;
+        viewport?: THREE.Vector4 | undefined;
+        getWorldDirection: (target: THREE.Vector3) => THREE.Vector3;
+        readonly isObject3D: true;
+        readonly id: number;
+        uuid: string;
+        name: string;
+        parent: THREE.Object3D<THREE.Object3DEventMap> | null;
+        children: THREE.Object3D<THREE.Object3DEventMap>[];
+        readonly modelViewMatrix: THREE.Matrix4;
+        readonly normalMatrix: THREE.Matrix3;
+        matrixWorld: THREE.Matrix4;
+        matrixAutoUpdate: boolean;
+        matrixWorldAutoUpdate: boolean;
+        matrixWorldNeedsUpdate: boolean;
+        visible: boolean;
+        castShadow: boolean;
+        receiveShadow: boolean;
+        frustumCulled: boolean;
+        renderOrder: number;
+        animations: THREE.AnimationClip[];
+        userData: Record<string, any>;
+        customDepthMaterial?: THREE.Material | undefined;
+        customDistanceMaterial?: THREE.Material | undefined;
+        onBeforeShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+        onAfterShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+        onBeforeRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+        onAfterRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+        applyMatrix4: (matrix: THREE.Matrix4) => void;
+        applyQuaternion: (quaternion: THREE.Quaternion) => THREE.PerspectiveCamera;
+        setRotationFromAxisAngle: (axis: THREE.Vector3, angle: number) => void;
+        setRotationFromEuler: (euler: THREE.Euler) => void;
+        setRotationFromMatrix: (m: THREE.Matrix4) => void;
+        setRotationFromQuaternion: (q: THREE.Quaternion) => void;
+        rotateOnAxis: (axis: THREE.Vector3, angle: number) => THREE.PerspectiveCamera;
+        rotateOnWorldAxis: (axis: THREE.Vector3, angle: number) => THREE.PerspectiveCamera;
+        rotateX: (angle: number) => THREE.PerspectiveCamera;
+        rotateY: (angle: number) => THREE.PerspectiveCamera;
+        rotateZ: (angle: number) => THREE.PerspectiveCamera;
+        translateOnAxis: (axis: THREE.Vector3, distance: number) => THREE.PerspectiveCamera;
+        translateX: (distance: number) => THREE.PerspectiveCamera;
+        translateY: (distance: number) => THREE.PerspectiveCamera;
+        translateZ: (distance: number) => THREE.PerspectiveCamera;
+        localToWorld: (vector: THREE.Vector3) => THREE.Vector3;
+        worldToLocal: (vector: THREE.Vector3) => THREE.Vector3;
+        lookAt: {
+            (vector: THREE.Vector3): void;
+            (x: number, y: number, z: number): void;
+        };
+        add: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.PerspectiveCamera;
+        remove: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.PerspectiveCamera;
+        removeFromParent: () => THREE.PerspectiveCamera;
+        getObjectById: (id: number) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+        getObjectByName: (name: string) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+        getObjectByProperty: (name: string, value: any) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+        getObjectsByProperty: (name: string, value: any, optionalTarget?: THREE.Object3D<THREE.Object3DEventMap>[] | undefined) => THREE.Object3D<THREE.Object3DEventMap>[];
+        getWorldPosition: (target: THREE.Vector3) => THREE.Vector3;
+        getWorldQuaternion: (target: THREE.Quaternion) => THREE.Quaternion;
+        getWorldScale: (target: THREE.Vector3) => THREE.Vector3;
+        raycast: (raycaster: THREE.Raycaster, intersects: THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[]) => void;
+        traverse: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+        traverseVisible: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+        traverseAncestors: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+        updateMatrix: () => void;
+        updateMatrixWorld: (force?: boolean | undefined) => void;
+        updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+        toJSON: (meta?: {
+            geometries: any;
+            materials: any;
+            textures: any;
+            images: any;
+        } | undefined) => any;
+        clone: (recursive?: boolean | undefined) => THREE.PerspectiveCamera;
+        copy: (object: THREE.Object3D<THREE.Object3DEventMap>, recursive?: boolean | undefined) => THREE.PerspectiveCamera;
+        hasEventListener: {
+            <T_5 extends keyof THREE.Object3DEventMap>(type: T_5, listener: THREE.EventListener<THREE.Object3DEventMap[T_5], T_5, THREE.PerspectiveCamera>): boolean;
+            <T_6 extends string>(type: T_6, listener: THREE.EventListener<{}, T_6, THREE.PerspectiveCamera>): boolean;
+        };
+        dispatchEvent: <T_2 extends keyof THREE.Object3DEventMap>(event: THREE.BaseEvent<T_2> & THREE.Object3DEventMap[T_2]) => void;
+        readonly isPerspectiveCamera: true;
+        zoom: number;
+        fov: number;
+        aspect: number;
+        near: number;
+        far: number;
+        focus: number;
+        view: {
+            enabled: boolean;
+            fullWidth: number;
+            fullHeight: number;
+            offsetX: number;
+            offsetY: number;
+            width: number;
+            height: number;
+        } | null;
+        filmGauge: number;
+        filmOffset: number;
+        getFocalLength: () => number;
+        setFocalLength: (focalLength: number) => void;
+        getEffectiveFOV: () => number;
+        getFilmWidth: () => number;
+        getFilmHeight: () => number;
+        getViewBounds: (distance: number, minTarget: THREE.Vector2, maxTarget: THREE.Vector2) => void;
+        getViewSize: (distance: number, target: THREE.Vector2) => THREE.Vector2;
+        setViewOffset: (fullWidth: number, fullHeight: number, x: number, y: number, width: number, height: number) => void;
+        clearViewOffset: () => void;
+        updateProjectionMatrix: () => void;
+        setLens: (focalLength: number, frameHeight?: number | undefined) => void;
+    }>, import("./three-types").NgtNodeElement<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera>>>, import("./three-types").NgtNonFunctionKeys<{
+        position: import("./three-types").NgtVector3;
+        up: import("./three-types").NgtVector3;
+        scale: import("./three-types").NgtVector3;
+        rotation: import("./three-types").NgtEuler;
+        matrix: import("./three-types").NgtMatrix4;
+        quaternion: import("./three-types").NgtQuaternion;
+        layers: import("./three-types").NgtLayers;
+        dispose: (() => void) | null;
+        addEventListener<TEventKey extends keyof import("./events").NgtEventHandlers>(type: TEventKey, listener: (this: NgtObject3DNode<TOriginal, TConstructor, Exclude<keyof TOriginal, "addEventListener" | "removeEventListener"> extends infer T_7 extends keyof TOriginal ? { [P in T_7]: TOriginal[P]; } : never>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey]) => any): void;
+        removeEventListener<TEventKey_1 extends keyof import("./events").NgtEventHandlers>(type: TEventKey_1, listener: (this: NgtObject3DNode<TOriginal, TConstructor, Exclude<keyof TOriginal, "addEventListener" | "removeEventListener"> extends infer T_8 extends keyof TOriginal ? { [P in T_8]: TOriginal[P]; } : never>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey_1]) => any): void; /** Flags the camera as manual, putting projection into your own hands */
+    }>> & {
+        position: import("./three-types").NgtVector3;
+        up: import("./three-types").NgtVector3;
+        scale: import("./three-types").NgtVector3;
+        rotation: import("./three-types").NgtEuler;
+        matrix: import("./three-types").NgtMatrix4;
+        quaternion: import("./three-types").NgtQuaternion;
+        layers: import("./three-types").NgtLayers;
+        dispose: (() => void) | null;
+        addEventListener<TEventKey_4 extends keyof import("./events").NgtEventHandlers>(type: TEventKey_4, listener: (this: NgtObject3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera, {
+            coordinateSystem: THREE.CoordinateSystem;
+            clear: () => THREE.PerspectiveCamera;
+            attach: (object: THREE.Object3D<THREE.Object3DEventMap>) => THREE.PerspectiveCamera;
+            readonly position: THREE.Vector3;
+            up: THREE.Vector3;
+            readonly scale: THREE.Vector3;
+            readonly rotation: THREE.Euler;
+            matrix: THREE.Matrix4;
+            readonly quaternion: THREE.Quaternion;
+            layers: THREE.Layers;
+            readonly isCamera: true;
+            readonly type: string;
+            matrixWorldInverse: THREE.Matrix4;
+            projectionMatrix: THREE.Matrix4;
+            projectionMatrixInverse: THREE.Matrix4;
+            viewport?: THREE.Vector4 | undefined;
+            getWorldDirection: (target: THREE.Vector3) => THREE.Vector3;
+            readonly isObject3D: true;
+            readonly id: number;
+            uuid: string;
+            name: string;
+            parent: THREE.Object3D<THREE.Object3DEventMap> | null;
+            children: THREE.Object3D<THREE.Object3DEventMap>[];
+            readonly modelViewMatrix: THREE.Matrix4;
+            readonly normalMatrix: THREE.Matrix3;
+            matrixWorld: THREE.Matrix4;
+            matrixAutoUpdate: boolean;
+            matrixWorldAutoUpdate: boolean;
+            matrixWorldNeedsUpdate: boolean;
+            visible: boolean;
+            castShadow: boolean;
+            receiveShadow: boolean;
+            frustumCulled: boolean;
+            renderOrder: number;
+            animations: THREE.AnimationClip[];
+            userData: Record<string, any>;
+            customDepthMaterial?: THREE.Material | undefined;
+            customDistanceMaterial?: THREE.Material | undefined;
+            onBeforeShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onAfterShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onBeforeRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onAfterRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            applyMatrix4: (matrix: THREE.Matrix4) => void;
+            applyQuaternion: (quaternion: THREE.Quaternion) => THREE.PerspectiveCamera;
+            setRotationFromAxisAngle: (axis: THREE.Vector3, angle: number) => void;
+            setRotationFromEuler: (euler: THREE.Euler) => void;
+            setRotationFromMatrix: (m: THREE.Matrix4) => void;
+            setRotationFromQuaternion: (q: THREE.Quaternion) => void;
+            rotateOnAxis: (axis: THREE.Vector3, angle: number) => THREE.PerspectiveCamera;
+            rotateOnWorldAxis: (axis: THREE.Vector3, angle: number) => THREE.PerspectiveCamera;
+            rotateX: (angle: number) => THREE.PerspectiveCamera;
+            rotateY: (angle: number) => THREE.PerspectiveCamera;
+            rotateZ: (angle: number) => THREE.PerspectiveCamera;
+            translateOnAxis: (axis: THREE.Vector3, distance: number) => THREE.PerspectiveCamera;
+            translateX: (distance: number) => THREE.PerspectiveCamera;
+            translateY: (distance: number) => THREE.PerspectiveCamera;
+            translateZ: (distance: number) => THREE.PerspectiveCamera;
+            localToWorld: (vector: THREE.Vector3) => THREE.Vector3;
+            worldToLocal: (vector: THREE.Vector3) => THREE.Vector3;
+            lookAt: {
+                (vector: THREE.Vector3): void;
+                (x: number, y: number, z: number): void;
+            };
+            add: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.PerspectiveCamera;
+            remove: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.PerspectiveCamera;
+            removeFromParent: () => THREE.PerspectiveCamera;
+            getObjectById: (id: number) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectByName: (name: string) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectByProperty: (name: string, value: any) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: THREE.Object3D<THREE.Object3DEventMap>[] | undefined) => THREE.Object3D<THREE.Object3DEventMap>[];
+            getWorldPosition: (target: THREE.Vector3) => THREE.Vector3;
+            getWorldQuaternion: (target: THREE.Quaternion) => THREE.Quaternion;
+            getWorldScale: (target: THREE.Vector3) => THREE.Vector3;
+            raycast: (raycaster: THREE.Raycaster, intersects: THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[]) => void;
+            traverse: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            traverseVisible: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            traverseAncestors: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            updateMatrix: () => void;
+            updateMatrixWorld: (force?: boolean | undefined) => void;
+            updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+            toJSON: (meta?: {
+                geometries: any;
+                materials: any;
+                textures: any;
+                images: any;
+            } | undefined) => any;
+            clone: (recursive?: boolean | undefined) => THREE.PerspectiveCamera;
+            copy: (object: THREE.Object3D<THREE.Object3DEventMap>, recursive?: boolean | undefined) => THREE.PerspectiveCamera;
+            hasEventListener: {
+                <T_5 extends keyof THREE.Object3DEventMap>(type: T_5, listener: THREE.EventListener<THREE.Object3DEventMap[T_5], T_5, THREE.PerspectiveCamera>): boolean;
+                <T_6 extends string>(type: T_6, listener: THREE.EventListener<{}, T_6, THREE.PerspectiveCamera>): boolean;
+            };
+            dispatchEvent: <T_4 extends keyof THREE.Object3DEventMap>(event: THREE.BaseEvent<T_4> & THREE.Object3DEventMap[T_4]) => void;
+            readonly isPerspectiveCamera: true;
+            zoom: number;
+            fov: number;
+            aspect: number;
+            near: number;
+            far: number;
+            focus: number;
+            view: {
+                enabled: boolean;
+                fullWidth: number;
+                fullHeight: number;
+                offsetX: number;
+                offsetY: number;
+                width: number;
+                height: number;
+            } | null;
+            filmGauge: number;
+            filmOffset: number;
+            getFocalLength: () => number;
+            setFocalLength: (focalLength: number) => void;
+            getEffectiveFOV: () => number;
+            getFilmWidth: () => number;
+            getFilmHeight: () => number;
+            getViewBounds: (distance: number, minTarget: THREE.Vector2, maxTarget: THREE.Vector2) => void;
+            getViewSize: (distance: number, target: THREE.Vector2) => THREE.Vector2;
+            setViewOffset: (fullWidth: number, fullHeight: number, x: number, y: number, width: number, height: number) => void;
+            clearViewOffset: () => void;
+            updateProjectionMatrix: () => void;
+            setLens: (focalLength: number, frameHeight?: number | undefined) => void;
+        }>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey_4]) => any): void;
+        removeEventListener<TEventKey_5 extends keyof import("./events").NgtEventHandlers>(type: TEventKey_5, listener: (this: NgtObject3DNode<THREE.PerspectiveCamera, typeof THREE.PerspectiveCamera, {
+            coordinateSystem: THREE.CoordinateSystem;
+            clear: () => THREE.PerspectiveCamera;
+            attach: (object: THREE.Object3D<THREE.Object3DEventMap>) => THREE.PerspectiveCamera;
+            readonly position: THREE.Vector3;
+            up: THREE.Vector3;
+            readonly scale: THREE.Vector3;
+            readonly rotation: THREE.Euler;
+            matrix: THREE.Matrix4;
+            readonly quaternion: THREE.Quaternion;
+            layers: THREE.Layers;
+            readonly isCamera: true;
+            readonly type: string;
+            matrixWorldInverse: THREE.Matrix4;
+            projectionMatrix: THREE.Matrix4;
+            projectionMatrixInverse: THREE.Matrix4;
+            viewport?: THREE.Vector4 | undefined;
+            getWorldDirection: (target: THREE.Vector3) => THREE.Vector3;
+            readonly isObject3D: true;
+            readonly id: number;
+            uuid: string;
+            name: string;
+            parent: THREE.Object3D<THREE.Object3DEventMap> | null;
+            children: THREE.Object3D<THREE.Object3DEventMap>[];
+            readonly modelViewMatrix: THREE.Matrix4;
+            readonly normalMatrix: THREE.Matrix3;
+            matrixWorld: THREE.Matrix4;
+            matrixAutoUpdate: boolean;
+            matrixWorldAutoUpdate: boolean;
+            matrixWorldNeedsUpdate: boolean;
+            visible: boolean;
+            castShadow: boolean;
+            receiveShadow: boolean;
+            frustumCulled: boolean;
+            renderOrder: number;
+            animations: THREE.AnimationClip[];
+            userData: Record<string, any>;
+            customDepthMaterial?: THREE.Material | undefined;
+            customDistanceMaterial?: THREE.Material | undefined;
+            onBeforeShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onAfterShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onBeforeRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onAfterRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            applyMatrix4: (matrix: THREE.Matrix4) => void;
+            applyQuaternion: (quaternion: THREE.Quaternion) => THREE.PerspectiveCamera;
+            setRotationFromAxisAngle: (axis: THREE.Vector3, angle: number) => void;
+            setRotationFromEuler: (euler: THREE.Euler) => void;
+            setRotationFromMatrix: (m: THREE.Matrix4) => void;
+            setRotationFromQuaternion: (q: THREE.Quaternion) => void;
+            rotateOnAxis: (axis: THREE.Vector3, angle: number) => THREE.PerspectiveCamera;
+            rotateOnWorldAxis: (axis: THREE.Vector3, angle: number) => THREE.PerspectiveCamera;
+            rotateX: (angle: number) => THREE.PerspectiveCamera;
+            rotateY: (angle: number) => THREE.PerspectiveCamera;
+            rotateZ: (angle: number) => THREE.PerspectiveCamera;
+            translateOnAxis: (axis: THREE.Vector3, distance: number) => THREE.PerspectiveCamera;
+            translateX: (distance: number) => THREE.PerspectiveCamera;
+            translateY: (distance: number) => THREE.PerspectiveCamera;
+            translateZ: (distance: number) => THREE.PerspectiveCamera;
+            localToWorld: (vector: THREE.Vector3) => THREE.Vector3;
+            worldToLocal: (vector: THREE.Vector3) => THREE.Vector3;
+            lookAt: {
+                (vector: THREE.Vector3): void;
+                (x: number, y: number, z: number): void;
+            };
+            add: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.PerspectiveCamera;
+            remove: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.PerspectiveCamera;
+            removeFromParent: () => THREE.PerspectiveCamera;
+            getObjectById: (id: number) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectByName: (name: string) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectByProperty: (name: string, value: any) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: THREE.Object3D<THREE.Object3DEventMap>[] | undefined) => THREE.Object3D<THREE.Object3DEventMap>[];
+            getWorldPosition: (target: THREE.Vector3) => THREE.Vector3;
+            getWorldQuaternion: (target: THREE.Quaternion) => THREE.Quaternion;
+            getWorldScale: (target: THREE.Vector3) => THREE.Vector3;
+            raycast: (raycaster: THREE.Raycaster, intersects: THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[]) => void;
+            traverse: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            traverseVisible: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            traverseAncestors: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            updateMatrix: () => void;
+            updateMatrixWorld: (force?: boolean | undefined) => void;
+            updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+            toJSON: (meta?: {
+                geometries: any;
+                materials: any;
+                textures: any;
+                images: any;
+            } | undefined) => any;
+            clone: (recursive?: boolean | undefined) => THREE.PerspectiveCamera;
+            copy: (object: THREE.Object3D<THREE.Object3DEventMap>, recursive?: boolean | undefined) => THREE.PerspectiveCamera;
+            hasEventListener: {
+                <T_5 extends keyof THREE.Object3DEventMap>(type: T_5, listener: THREE.EventListener<THREE.Object3DEventMap[T_5], T_5, THREE.PerspectiveCamera>): boolean;
+                <T_6 extends string>(type: T_6, listener: THREE.EventListener<{}, T_6, THREE.PerspectiveCamera>): boolean;
+            };
+            dispatchEvent: <T_4 extends keyof THREE.Object3DEventMap>(event: THREE.BaseEvent<T_4> & THREE.Object3DEventMap[T_4]) => void;
+            readonly isPerspectiveCamera: true;
+            zoom: number;
+            fov: number;
+            aspect: number;
+            near: number;
+            far: number;
+            focus: number;
+            view: {
+                enabled: boolean;
+                fullWidth: number;
+                fullHeight: number;
+                offsetX: number;
+                offsetY: number;
+                width: number;
+                height: number;
+            } | null;
+            filmGauge: number;
+            filmOffset: number;
+            getFocalLength: () => number;
+            setFocalLength: (focalLength: number) => void;
+            getEffectiveFOV: () => number;
+            getFilmWidth: () => number;
+            getFilmHeight: () => number;
+            getViewBounds: (distance: number, minTarget: THREE.Vector2, maxTarget: THREE.Vector2) => void;
+            getViewSize: (distance: number, target: THREE.Vector2) => THREE.Vector2;
+            setViewOffset: (fullWidth: number, fullHeight: number, x: number, y: number, width: number, height: number) => void;
+            clearViewOffset: () => void;
+            updateProjectionMatrix: () => void;
+            setLens: (focalLength: number, frameHeight?: number | undefined) => void;
+        }>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey_5]) => any): void; /** Flags the camera as manual, putting projection into your own hands */
+    } & Omit<import("./three-types").NgtExtendedColors<import("./three-types").NgtOverwrite<Partial<{
+        coordinateSystem: THREE.CoordinateSystem;
+        clear: () => THREE.OrthographicCamera;
+        attach: (object: THREE.Object3D<THREE.Object3DEventMap>) => THREE.OrthographicCamera;
+        readonly position: THREE.Vector3;
+        up: THREE.Vector3;
+        readonly scale: THREE.Vector3;
+        readonly rotation: THREE.Euler;
+        matrix: THREE.Matrix4;
+        readonly quaternion: THREE.Quaternion;
+        layers: THREE.Layers;
+        readonly isCamera: true;
+        readonly type: string;
+        matrixWorldInverse: THREE.Matrix4;
+        projectionMatrix: THREE.Matrix4;
+        projectionMatrixInverse: THREE.Matrix4;
+        viewport?: THREE.Vector4 | undefined;
+        getWorldDirection: (target: THREE.Vector3) => THREE.Vector3;
+        readonly isObject3D: true;
+        readonly id: number;
+        uuid: string;
+        name: string;
+        parent: THREE.Object3D<THREE.Object3DEventMap> | null;
+        children: THREE.Object3D<THREE.Object3DEventMap>[];
+        readonly modelViewMatrix: THREE.Matrix4;
+        readonly normalMatrix: THREE.Matrix3;
+        matrixWorld: THREE.Matrix4;
+        matrixAutoUpdate: boolean;
+        matrixWorldAutoUpdate: boolean;
+        matrixWorldNeedsUpdate: boolean;
+        visible: boolean;
+        castShadow: boolean;
+        receiveShadow: boolean;
+        frustumCulled: boolean;
+        renderOrder: number;
+        animations: THREE.AnimationClip[];
+        userData: Record<string, any>;
+        customDepthMaterial?: THREE.Material | undefined;
+        customDistanceMaterial?: THREE.Material | undefined;
+        onBeforeShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+        onAfterShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+        onBeforeRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+        onAfterRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+        applyMatrix4: (matrix: THREE.Matrix4) => void;
+        applyQuaternion: (quaternion: THREE.Quaternion) => THREE.OrthographicCamera;
+        setRotationFromAxisAngle: (axis: THREE.Vector3, angle: number) => void;
+        setRotationFromEuler: (euler: THREE.Euler) => void;
+        setRotationFromMatrix: (m: THREE.Matrix4) => void;
+        setRotationFromQuaternion: (q: THREE.Quaternion) => void;
+        rotateOnAxis: (axis: THREE.Vector3, angle: number) => THREE.OrthographicCamera;
+        rotateOnWorldAxis: (axis: THREE.Vector3, angle: number) => THREE.OrthographicCamera;
+        rotateX: (angle: number) => THREE.OrthographicCamera;
+        rotateY: (angle: number) => THREE.OrthographicCamera;
+        rotateZ: (angle: number) => THREE.OrthographicCamera;
+        translateOnAxis: (axis: THREE.Vector3, distance: number) => THREE.OrthographicCamera;
+        translateX: (distance: number) => THREE.OrthographicCamera;
+        translateY: (distance: number) => THREE.OrthographicCamera;
+        translateZ: (distance: number) => THREE.OrthographicCamera;
+        localToWorld: (vector: THREE.Vector3) => THREE.Vector3;
+        worldToLocal: (vector: THREE.Vector3) => THREE.Vector3;
+        lookAt: {
+            (vector: THREE.Vector3): void;
+            (x: number, y: number, z: number): void;
+        };
+        add: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.OrthographicCamera;
+        remove: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.OrthographicCamera;
+        removeFromParent: () => THREE.OrthographicCamera;
+        getObjectById: (id: number) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+        getObjectByName: (name: string) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+        getObjectByProperty: (name: string, value: any) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+        getObjectsByProperty: (name: string, value: any, optionalTarget?: THREE.Object3D<THREE.Object3DEventMap>[] | undefined) => THREE.Object3D<THREE.Object3DEventMap>[];
+        getWorldPosition: (target: THREE.Vector3) => THREE.Vector3;
+        getWorldQuaternion: (target: THREE.Quaternion) => THREE.Quaternion;
+        getWorldScale: (target: THREE.Vector3) => THREE.Vector3;
+        raycast: (raycaster: THREE.Raycaster, intersects: THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[]) => void;
+        traverse: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+        traverseVisible: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+        traverseAncestors: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+        updateMatrix: () => void;
+        updateMatrixWorld: (force?: boolean | undefined) => void;
+        updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+        toJSON: (meta?: {
+            geometries: any;
+            materials: any;
+            textures: any;
+            images: any;
+        } | undefined) => any;
+        clone: (recursive?: boolean | undefined) => THREE.OrthographicCamera;
+        copy: (object: THREE.Object3D<THREE.Object3DEventMap>, recursive?: boolean | undefined) => THREE.OrthographicCamera;
+        hasEventListener: {
+            <T_9 extends keyof THREE.Object3DEventMap>(type: T_9, listener: THREE.EventListener<THREE.Object3DEventMap[T_9], T_9, THREE.OrthographicCamera>): boolean;
+            <T_10 extends string>(type: T_10, listener: THREE.EventListener<{}, T_10, THREE.OrthographicCamera>): boolean;
+        };
+        dispatchEvent: <T_2 extends keyof THREE.Object3DEventMap>(event: THREE.BaseEvent<T_2> & THREE.Object3DEventMap[T_2]) => void;
+        zoom: number;
+        near: number;
+        far: number;
+        view: {
+            enabled: boolean;
+            fullWidth: number;
+            fullHeight: number; /** A `THREE.Scene` instance or props that go into the default scene */
+            offsetX: number;
+            offsetY: number;
+            width: number;
+            height: number;
+        } | null;
+        setViewOffset: (fullWidth: number, fullHeight: number, offsetX: number, offsetY: number, width: number, height: number) => void;
+        clearViewOffset: () => void;
+        updateProjectionMatrix: () => void;
+        readonly isOrthographicCamera: true;
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    }>, import("./three-types").NgtNodeElement<THREE.OrthographicCamera, typeof THREE.OrthographicCamera>>>, import("./three-types").NgtNonFunctionKeys<{
+        position: import("./three-types").NgtVector3;
+        up: import("./three-types").NgtVector3;
+        scale: import("./three-types").NgtVector3;
+        rotation: import("./three-types").NgtEuler;
+        matrix: import("./three-types").NgtMatrix4;
+        quaternion: import("./three-types").NgtQuaternion;
+        layers: import("./three-types").NgtLayers;
+        dispose: (() => void) | null;
+        addEventListener<TEventKey extends keyof import("./events").NgtEventHandlers>(type: TEventKey, listener: (this: NgtObject3DNode<TOriginal, TConstructor, Exclude<keyof TOriginal, "addEventListener" | "removeEventListener"> extends infer T_11 extends keyof TOriginal ? { [P in T_11]: TOriginal[P]; } : never>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey]) => any): void;
+        removeEventListener<TEventKey_1 extends keyof import("./events").NgtEventHandlers>(type: TEventKey_1, listener: (this: NgtObject3DNode<TOriginal, TConstructor, Exclude<keyof TOriginal, "addEventListener" | "removeEventListener"> extends infer T_12 extends keyof TOriginal ? { [P in T_12]: TOriginal[P]; } : never>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey_1]) => any): void; /** Flags the camera as manual, putting projection into your own hands */
+    }>> & {
+        position: import("./three-types").NgtVector3;
+        up: import("./three-types").NgtVector3;
+        scale: import("./three-types").NgtVector3;
+        rotation: import("./three-types").NgtEuler;
+        matrix: import("./three-types").NgtMatrix4;
+        quaternion: import("./three-types").NgtQuaternion;
+        layers: import("./three-types").NgtLayers;
+        dispose: (() => void) | null;
+        addEventListener<TEventKey_6 extends keyof import("./events").NgtEventHandlers>(type: TEventKey_6, listener: (this: NgtObject3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera, {
+            coordinateSystem: THREE.CoordinateSystem;
+            clear: () => THREE.OrthographicCamera;
+            attach: (object: THREE.Object3D<THREE.Object3DEventMap>) => THREE.OrthographicCamera;
+            readonly position: THREE.Vector3;
+            up: THREE.Vector3;
+            readonly scale: THREE.Vector3;
+            readonly rotation: THREE.Euler;
+            matrix: THREE.Matrix4;
+            readonly quaternion: THREE.Quaternion;
+            layers: THREE.Layers;
+            readonly isCamera: true;
+            readonly type: string;
+            matrixWorldInverse: THREE.Matrix4;
+            projectionMatrix: THREE.Matrix4;
+            projectionMatrixInverse: THREE.Matrix4;
+            viewport?: THREE.Vector4 | undefined;
+            getWorldDirection: (target: THREE.Vector3) => THREE.Vector3;
+            readonly isObject3D: true;
+            readonly id: number;
+            uuid: string;
+            name: string;
+            parent: THREE.Object3D<THREE.Object3DEventMap> | null;
+            children: THREE.Object3D<THREE.Object3DEventMap>[];
+            readonly modelViewMatrix: THREE.Matrix4;
+            readonly normalMatrix: THREE.Matrix3;
+            matrixWorld: THREE.Matrix4;
+            matrixAutoUpdate: boolean;
+            matrixWorldAutoUpdate: boolean;
+            matrixWorldNeedsUpdate: boolean;
+            visible: boolean;
+            castShadow: boolean;
+            receiveShadow: boolean;
+            frustumCulled: boolean;
+            renderOrder: number;
+            animations: THREE.AnimationClip[];
+            userData: Record<string, any>;
+            customDepthMaterial?: THREE.Material | undefined;
+            customDistanceMaterial?: THREE.Material | undefined;
+            onBeforeShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onAfterShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onBeforeRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onAfterRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            applyMatrix4: (matrix: THREE.Matrix4) => void;
+            applyQuaternion: (quaternion: THREE.Quaternion) => THREE.OrthographicCamera;
+            setRotationFromAxisAngle: (axis: THREE.Vector3, angle: number) => void;
+            setRotationFromEuler: (euler: THREE.Euler) => void;
+            setRotationFromMatrix: (m: THREE.Matrix4) => void;
+            setRotationFromQuaternion: (q: THREE.Quaternion) => void;
+            rotateOnAxis: (axis: THREE.Vector3, angle: number) => THREE.OrthographicCamera;
+            rotateOnWorldAxis: (axis: THREE.Vector3, angle: number) => THREE.OrthographicCamera;
+            rotateX: (angle: number) => THREE.OrthographicCamera;
+            rotateY: (angle: number) => THREE.OrthographicCamera;
+            rotateZ: (angle: number) => THREE.OrthographicCamera;
+            translateOnAxis: (axis: THREE.Vector3, distance: number) => THREE.OrthographicCamera;
+            translateX: (distance: number) => THREE.OrthographicCamera;
+            translateY: (distance: number) => THREE.OrthographicCamera;
+            translateZ: (distance: number) => THREE.OrthographicCamera;
+            localToWorld: (vector: THREE.Vector3) => THREE.Vector3;
+            worldToLocal: (vector: THREE.Vector3) => THREE.Vector3;
+            lookAt: {
+                (vector: THREE.Vector3): void;
+                (x: number, y: number, z: number): void;
+            };
+            add: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.OrthographicCamera;
+            remove: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.OrthographicCamera;
+            removeFromParent: () => THREE.OrthographicCamera;
+            getObjectById: (id: number) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectByName: (name: string) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectByProperty: (name: string, value: any) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: THREE.Object3D<THREE.Object3DEventMap>[] | undefined) => THREE.Object3D<THREE.Object3DEventMap>[];
+            getWorldPosition: (target: THREE.Vector3) => THREE.Vector3;
+            getWorldQuaternion: (target: THREE.Quaternion) => THREE.Quaternion;
+            getWorldScale: (target: THREE.Vector3) => THREE.Vector3;
+            raycast: (raycaster: THREE.Raycaster, intersects: THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[]) => void;
+            traverse: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            traverseVisible: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            traverseAncestors: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            updateMatrix: () => void;
+            updateMatrixWorld: (force?: boolean | undefined) => void;
+            updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+            toJSON: (meta?: {
+                geometries: any;
+                materials: any;
+                textures: any;
+                images: any;
+            } | undefined) => any;
+            clone: (recursive?: boolean | undefined) => THREE.OrthographicCamera;
+            copy: (object: THREE.Object3D<THREE.Object3DEventMap>, recursive?: boolean | undefined) => THREE.OrthographicCamera;
+            hasEventListener: {
+                <T_9 extends keyof THREE.Object3DEventMap>(type: T_9, listener: THREE.EventListener<THREE.Object3DEventMap[T_9], T_9, THREE.OrthographicCamera>): boolean;
+                <T_10 extends string>(type: T_10, listener: THREE.EventListener<{}, T_10, THREE.OrthographicCamera>): boolean;
+            };
+            dispatchEvent: <T_4 extends keyof THREE.Object3DEventMap>(event: THREE.BaseEvent<T_4> & THREE.Object3DEventMap[T_4]) => void;
+            zoom: number;
+            near: number;
+            far: number;
+            view: {
+                enabled: boolean;
+                fullWidth: number;
+                fullHeight: number; /** A `THREE.Scene` instance or props that go into the default scene */
+                offsetX: number;
+                offsetY: number;
+                width: number;
+                height: number;
+            } | null;
+            setViewOffset: (fullWidth: number, fullHeight: number, offsetX: number, offsetY: number, width: number, height: number) => void;
+            clearViewOffset: () => void;
+            updateProjectionMatrix: () => void;
+            readonly isOrthographicCamera: true;
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+        }>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey_6]) => any): void;
+        removeEventListener<TEventKey_7 extends keyof import("./events").NgtEventHandlers>(type: TEventKey_7, listener: (this: NgtObject3DNode<THREE.OrthographicCamera, typeof THREE.OrthographicCamera, {
+            coordinateSystem: THREE.CoordinateSystem;
+            clear: () => THREE.OrthographicCamera;
+            attach: (object: THREE.Object3D<THREE.Object3DEventMap>) => THREE.OrthographicCamera;
+            readonly position: THREE.Vector3;
+            up: THREE.Vector3;
+            readonly scale: THREE.Vector3;
+            readonly rotation: THREE.Euler;
+            matrix: THREE.Matrix4;
+            readonly quaternion: THREE.Quaternion;
+            layers: THREE.Layers;
+            readonly isCamera: true;
+            readonly type: string;
+            matrixWorldInverse: THREE.Matrix4;
+            projectionMatrix: THREE.Matrix4;
+            projectionMatrixInverse: THREE.Matrix4;
+            viewport?: THREE.Vector4 | undefined;
+            getWorldDirection: (target: THREE.Vector3) => THREE.Vector3;
+            readonly isObject3D: true;
+            readonly id: number;
+            uuid: string;
+            name: string;
+            parent: THREE.Object3D<THREE.Object3DEventMap> | null;
+            children: THREE.Object3D<THREE.Object3DEventMap>[];
+            readonly modelViewMatrix: THREE.Matrix4;
+            readonly normalMatrix: THREE.Matrix3;
+            matrixWorld: THREE.Matrix4;
+            matrixAutoUpdate: boolean;
+            matrixWorldAutoUpdate: boolean;
+            matrixWorldNeedsUpdate: boolean;
+            visible: boolean;
+            castShadow: boolean;
+            receiveShadow: boolean;
+            frustumCulled: boolean;
+            renderOrder: number;
+            animations: THREE.AnimationClip[];
+            userData: Record<string, any>;
+            customDepthMaterial?: THREE.Material | undefined;
+            customDistanceMaterial?: THREE.Material | undefined;
+            onBeforeShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onAfterShadow: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, shadowCamera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, depthMaterial: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onBeforeRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            onAfterRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>, material: THREE.Material, group: THREE.Group<THREE.Object3DEventMap>) => void;
+            applyMatrix4: (matrix: THREE.Matrix4) => void;
+            applyQuaternion: (quaternion: THREE.Quaternion) => THREE.OrthographicCamera;
+            setRotationFromAxisAngle: (axis: THREE.Vector3, angle: number) => void;
+            setRotationFromEuler: (euler: THREE.Euler) => void;
+            setRotationFromMatrix: (m: THREE.Matrix4) => void;
+            setRotationFromQuaternion: (q: THREE.Quaternion) => void;
+            rotateOnAxis: (axis: THREE.Vector3, angle: number) => THREE.OrthographicCamera;
+            rotateOnWorldAxis: (axis: THREE.Vector3, angle: number) => THREE.OrthographicCamera;
+            rotateX: (angle: number) => THREE.OrthographicCamera;
+            rotateY: (angle: number) => THREE.OrthographicCamera;
+            rotateZ: (angle: number) => THREE.OrthographicCamera;
+            translateOnAxis: (axis: THREE.Vector3, distance: number) => THREE.OrthographicCamera;
+            translateX: (distance: number) => THREE.OrthographicCamera;
+            translateY: (distance: number) => THREE.OrthographicCamera;
+            translateZ: (distance: number) => THREE.OrthographicCamera;
+            localToWorld: (vector: THREE.Vector3) => THREE.Vector3;
+            worldToLocal: (vector: THREE.Vector3) => THREE.Vector3;
+            lookAt: {
+                (vector: THREE.Vector3): void;
+                (x: number, y: number, z: number): void;
+            };
+            add: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.OrthographicCamera;
+            remove: (...object: THREE.Object3D<THREE.Object3DEventMap>[]) => THREE.OrthographicCamera;
+            removeFromParent: () => THREE.OrthographicCamera;
+            getObjectById: (id: number) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectByName: (name: string) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectByProperty: (name: string, value: any) => THREE.Object3D<THREE.Object3DEventMap> | undefined;
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: THREE.Object3D<THREE.Object3DEventMap>[] | undefined) => THREE.Object3D<THREE.Object3DEventMap>[];
+            getWorldPosition: (target: THREE.Vector3) => THREE.Vector3;
+            getWorldQuaternion: (target: THREE.Quaternion) => THREE.Quaternion;
+            getWorldScale: (target: THREE.Vector3) => THREE.Vector3;
+            raycast: (raycaster: THREE.Raycaster, intersects: THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[]) => void;
+            traverse: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            traverseVisible: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            traverseAncestors: (callback: (object: THREE.Object3D<THREE.Object3DEventMap>) => any) => void;
+            updateMatrix: () => void;
+            updateMatrixWorld: (force?: boolean | undefined) => void;
+            updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+            toJSON: (meta?: {
+                geometries: any;
+                materials: any;
+                textures: any;
+                images: any;
+            } | undefined) => any;
+            clone: (recursive?: boolean | undefined) => THREE.OrthographicCamera;
+            copy: (object: THREE.Object3D<THREE.Object3DEventMap>, recursive?: boolean | undefined) => THREE.OrthographicCamera;
+            hasEventListener: {
+                <T_9 extends keyof THREE.Object3DEventMap>(type: T_9, listener: THREE.EventListener<THREE.Object3DEventMap[T_9], T_9, THREE.OrthographicCamera>): boolean;
+                <T_10 extends string>(type: T_10, listener: THREE.EventListener<{}, T_10, THREE.OrthographicCamera>): boolean;
+            };
+            dispatchEvent: <T_4 extends keyof THREE.Object3DEventMap>(event: THREE.BaseEvent<T_4> & THREE.Object3DEventMap[T_4]) => void;
+            zoom: number;
+            near: number;
+            far: number;
+            view: {
+                enabled: boolean;
+                fullWidth: number;
+                fullHeight: number; /** A `THREE.Scene` instance or props that go into the default scene */
+                offsetX: number;
+                offsetY: number;
+                width: number;
+                height: number;
+            } | null;
+            setViewOffset: (fullWidth: number, fullHeight: number, offsetX: number, offsetY: number, width: number, height: number) => void;
+            clearViewOffset: () => void;
+            updateProjectionMatrix: () => void;
+            readonly isOrthographicCamera: true;
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+        }>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey_7]) => any): void; /** Flags the camera as manual, putting projection into your own hands */
+    }>) & {
+        /** Flags the camera as manual, putting projection into your own hands */
+        manual?: boolean | undefined;
+    }) | undefined>;
+    events: import("@angular/core").InputSignal<((store: NgtSignalStore<NgtState>) => NgtEventManager<HTMLElement>) | undefined>;
+    eventSource: import("@angular/core").InputSignal<HTMLElement | ElementRef<HTMLElement> | undefined>;
+    eventPrefix: import("@angular/core").InputSignal<"offset" | "client" | "page" | "layer" | "screen" | undefined>;
+    lookAt: import("@angular/core").InputSignal<THREE.Vector3 | [x: number, y: number, z: number] | undefined>;
+    created: import("@angular/core").OutputEmitterRef<NgtState>;
+    pointerMissed: import("@angular/core").OutputRef<MouseEvent>;
+    glCanvas: import("@angular/core").Signal<ElementRef<HTMLCanvasElement>>;
+    glCanvasViewContainerRef: import("@angular/core").Signal<ViewContainerRef>;
+    protected resizeResult: import("@angular/core").WritableSignal<ResizeResult>;
+    protected hbPointerEvents: import("@angular/core").Signal<"none" | "auto">;
+    private configurator?;
+    private glEnvironmentInjector?;
+    private glRef?;
+    constructor();
+    private noZoneResizeEffect;
+    private noZoneRender;
+    private noZoneSceneGraphInputsEffect;
+    private setSceneGraphInputs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtCanvas, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtCanvas, "ngt-canvas", never, { "sceneGraph": { "alias": "sceneGraph"; "required": true; "isSignal": true; }; "compoundPrefixes": { "alias": "compoundPrefixes"; "required": false; "isSignal": true; }; "sceneGraphInputs": { "alias": "sceneGraphInputs"; "required": false; "isSignal": true; }; "gl": { "alias": "gl"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shadows": { "alias": "shadows"; "required": false; "isSignal": true; }; "legacy": { "alias": "legacy"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; "flat": { "alias": "flat"; "required": false; "isSignal": true; }; "orthographic": { "alias": "orthographic"; "required": false; "isSignal": true; }; "frameloop": { "alias": "frameloop"; "required": false; "isSignal": true; }; "performance": { "alias": "performance"; "required": false; "isSignal": true; }; "dpr": { "alias": "dpr"; "required": false; "isSignal": true; }; "raycaster": { "alias": "raycaster"; "required": false; "isSignal": true; }; "scene": { "alias": "scene"; "required": false; "isSignal": true; }; "camera": { "alias": "camera"; "required": false; "isSignal": true; }; "events": { "alias": "events"; "required": false; "isSignal": true; }; "eventSource": { "alias": "eventSource"; "required": false; "isSignal": true; }; "eventPrefix": { "alias": "eventPrefix"; "required": false; "isSignal": true; }; "lookAt": { "alias": "lookAt"; "required": false; "isSignal": true; }; }, { "created": "created"; "pointerMissed": "pointerMissed"; }, never, never, true, never>;
+}