angular-three 2.0.0-beta.23 → 2.0.0-beta.231

package/lib/canvas.d.ts

@@ -1,29 +1,32 @@
-import { ElementRef, EventEmitter, type OnChanges, type OnInit, type SimpleChanges, type Type } from '@angular/core';
-import { type NgxResizeResult } from 'ngx-resize';
-import * as THREE from 'three';
-import type { NgtCamera, NgtEventManager } from './events';
-import { type NgtDpr, type NgtPerformance, type NgtRenderer, 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 { ElementRef, Type, ViewContainerRef } from '@angular/core';
+import { ResizeResult } from 'ngxtension/resize';
+import { Camera, OrthographicCamera, PerspectiveCamera, Raycaster, Scene, Vector3, WebGLRenderer, WebGLRendererParameters, WebGLShadowMap } from 'three';
+import { createPointerEvents } from './dom/events';
+import { NgtCamera, NgtEventManager } from './events';
+import { NgtCanvasElement } from './roots';
+import { NgtDpr, NgtPerformance, NgtRendererLike, NgtSize, NgtState } from './store';
+import { NgtObject3DNode } from './three-types';
+import { NgtAnyRecord, NgtProperties } from './types';
+import { NgtSignalStore } from './utils/signal-store';
 import * as i0 from "@angular/core";
-export type NgtGLOptions = NgtRenderer | ((canvas: HTMLCanvasElement) => NgtRenderer) | Partial<NgtProperties<THREE.WebGLRenderer> | THREE.WebGLRendererParameters> | undefined;
-export type NgtCanvasInputs = {
+export type NgtGLOptions = NgtRendererLike | ((canvas: NgtCanvasElement) => NgtRendererLike) | Partial<NgtProperties<WebGLRenderer> | WebGLRendererParameters> | undefined;
+export interface 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>;
+    shadows?: boolean | 'basic' | 'percentage' | 'soft' | 'variance' | Partial<WebGLShadowMap>;
     /**
      * Disables three r139 color management.
      * @see https://threejs.org/docs/#manual/en/introduction/Color-management
      */
     legacy?: boolean;
-    /** Switch off automatic sRGB encoding and gamma correction */
+    /** Switch off automatic sRGB color space and gamma correction */
     linear?: boolean;
     /** Use `THREE.NoToneMapping` instead of `THREE.ACESFilmicToneMapping` */
     flat?: boolean;
@@ -42,11 +45,11 @@ export type NgtCanvasInputs = {
     /** 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>;
+    raycaster?: Partial<Raycaster>;
+    /** A `Scene` instance or props that go into the default scene */
+    scene?: Scene | Partial<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>>) & {
+    camera?: (NgtCamera | Partial<NgtObject3DNode<Camera, typeof Camera> & NgtObject3DNode<PerspectiveCamera, typeof PerspectiveCamera> & NgtObject3DNode<OrthographicCamera, typeof OrthographicCamera>>) & {
         /** Flags the camera as manual, putting projection into your own hands */
         manual?: boolean;
     };
@@ -57,51 +60,1116 @@ export type NgtCanvasInputs = {
     /** 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 implements OnInit, OnChanges {
+    lookAt?: Vector3 | Parameters<Vector3['set']>;
+}
+export declare class NgtCanvas {
     private store;
     private initRoot;
+    private autoEffect;
     private host;
     private viewContainerRef;
-    private injector;
-    private environmentInjector;
     private zone;
-    private destroyRef;
-    private cdr;
-    private inputs;
-    sceneGraph: Type<unknown>;
-    sceneGraphInputs: NgtAnyRecord;
-    compoundPrefixes: string[];
-    set linear(linear: boolean);
-    set legacy(legacy: boolean);
-    set flat(flat: boolean);
-    set orthographic(orthographic: boolean);
-    set frameloop(frameloop: NgtCanvasInputs['frameloop']);
-    set dpr(dpr: NgtDpr);
-    set raycaster(raycaster: Partial<THREE.Raycaster>);
-    set shadows(shadows: boolean | Partial<THREE.WebGLShadowMap>);
-    set camera(camera: NgtCanvasInputs['camera']);
-    set scene(scene: NgtCanvasInputs['scene']);
-    set gl(gl: NgtCanvasInputs['gl']);
-    set eventSource(eventSource: NgtCanvasInputs['eventSource']);
-    set eventPrefix(eventPrefix: NgtCanvasInputs['eventPrefix']);
-    set lookAt(lookAt: NgtCanvasInputs['lookAt']);
-    set performance(performance: NgtCanvasInputs['performance']);
-    created: EventEmitter<NgtState>;
-    private inputsEventSource;
+    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<NonNullable<boolean | "basic" | "percentage" | "soft" | "variance" | Partial<WebGLShadowMap> | undefined>, 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<NonNullable<"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<Raycaster> | undefined>;
+    scene: import("@angular/core").InputSignal<Scene | Partial<Scene> | undefined>;
+    camera: import("@angular/core").InputSignal<NonNullable<((NgtCamera | Partial<Omit<import("./three-types").NgtExtendedColors<import("./three-types").NgtOverwrite<Partial<{
+        clone: (recursive?: boolean | undefined) => Camera;
+        copy: (object: import("three").Object3D<import("three").Object3DEventMap>, recursive?: boolean | undefined) => Camera;
+        add: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => Camera;
+        applyMatrix4: (matrix: import("three").Matrix4) => void;
+        applyQuaternion: (quaternion: import("three").Quaternion) => Camera;
+        attach: (object: import("three").Object3D<import("three").Object3DEventMap>) => Camera;
+        readonly type: string;
+        readonly position: Vector3;
+        up: Vector3;
+        readonly scale: Vector3;
+        readonly rotation: import("three").Euler;
+        matrix: import("three").Matrix4;
+        readonly quaternion: import("three").Quaternion;
+        layers: import("three").Layers;
+        readonly id: number;
+        uuid: string;
+        name: string;
+        userData: Record<string, any>;
+        rotateX: (angle: number) => Camera;
+        rotateY: (angle: number) => Camera;
+        rotateZ: (angle: number) => Camera;
+        lookAt: {
+            (vector: Vector3): void;
+            (x: number, y: number, z: number): void;
+        };
+        toJSON: (meta?: {
+            geometries: any;
+            materials: any;
+            textures: any;
+            images: any;
+        } | undefined) => any;
+        hasEventListener: {
+            <T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Camera>): boolean;
+            <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, Camera>): boolean;
+        };
+        dispatchEvent: <T_2 extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T_2> & import("three").Object3DEventMap[T_2]) => void;
+        visible: boolean;
+        onBeforeRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+        readonly isObject3D: true;
+        parent: import("three").Object3D<import("three").Object3DEventMap> | null;
+        children: import("three").Object3D<import("three").Object3DEventMap>[];
+        readonly modelViewMatrix: import("three").Matrix4;
+        readonly normalMatrix: import("three").Matrix3;
+        matrixWorld: import("three").Matrix4;
+        matrixAutoUpdate: boolean;
+        matrixWorldAutoUpdate: boolean;
+        matrixWorldNeedsUpdate: boolean;
+        castShadow: boolean;
+        receiveShadow: boolean;
+        frustumCulled: boolean;
+        renderOrder: number;
+        animations: import("three").AnimationClip[];
+        customDepthMaterial?: import("three").Material | undefined;
+        customDistanceMaterial?: import("three").Material | undefined;
+        onBeforeShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+        onAfterShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+        onAfterRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+        setRotationFromAxisAngle: (axis: Vector3, angle: number) => void;
+        setRotationFromEuler: (euler: import("three").Euler) => void;
+        setRotationFromMatrix: (m: import("three").Matrix4) => void;
+        setRotationFromQuaternion: (q: import("three").Quaternion) => void;
+        rotateOnAxis: (axis: Vector3, angle: number) => Camera;
+        rotateOnWorldAxis: (axis: Vector3, angle: number) => Camera;
+        translateOnAxis: (axis: Vector3, distance: number) => Camera;
+        translateX: (distance: number) => Camera;
+        translateY: (distance: number) => Camera;
+        translateZ: (distance: number) => Camera;
+        localToWorld: (vector: Vector3) => Vector3;
+        worldToLocal: (vector: Vector3) => Vector3;
+        remove: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => Camera;
+        removeFromParent: () => Camera;
+        clear: () => Camera;
+        getObjectById: (id: number) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+        getObjectByName: (name: string) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+        getObjectByProperty: (name: string, value: any) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+        getObjectsByProperty: (name: string, value: any, optionalTarget?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined) => import("three").Object3D<import("three").Object3DEventMap>[];
+        getWorldPosition: (target: Vector3) => Vector3;
+        getWorldQuaternion: (target: import("three").Quaternion) => import("three").Quaternion;
+        getWorldScale: (target: Vector3) => Vector3;
+        getWorldDirection: (target: Vector3) => Vector3;
+        raycast: (raycaster: Raycaster, intersects: import("three").Intersection<import("three").Object3D<import("three").Object3DEventMap>>[]) => void;
+        traverse: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+        traverseVisible: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+        traverseAncestors: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+        updateMatrix: () => void;
+        updateMatrixWorld: (force?: boolean | undefined) => void;
+        updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+        readonly isCamera: true;
+        matrixWorldInverse: import("three").Matrix4;
+        projectionMatrix: import("three").Matrix4;
+        projectionMatrixInverse: import("three").Matrix4;
+        coordinateSystem: import("three").CoordinateSystem;
+        viewport?: import("three").Vector4 | undefined;
+    }>, import("./three-types").NgtNodeElement<Camera, typeof 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_3 extends keyof TOriginal ? { [P in T_3]: 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_4 extends keyof TOriginal ? { [P in T_4]: TOriginal[P]; } : never>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey_1]) => any): void;
+    }>> & {
+        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<Camera, typeof Camera, {
+            clone: (recursive?: boolean | undefined) => Camera;
+            copy: (object: import("three").Object3D<import("three").Object3DEventMap>, recursive?: boolean | undefined) => Camera;
+            add: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => Camera;
+            applyMatrix4: (matrix: import("three").Matrix4) => void;
+            applyQuaternion: (quaternion: import("three").Quaternion) => Camera;
+            attach: (object: import("three").Object3D<import("three").Object3DEventMap>) => Camera;
+            readonly type: string;
+            readonly position: Vector3;
+            up: Vector3;
+            readonly scale: Vector3;
+            readonly rotation: import("three").Euler;
+            matrix: import("three").Matrix4;
+            readonly quaternion: import("three").Quaternion;
+            layers: import("three").Layers;
+            readonly id: number;
+            uuid: string;
+            name: string;
+            userData: Record<string, any>;
+            rotateX: (angle: number) => Camera;
+            rotateY: (angle: number) => Camera;
+            rotateZ: (angle: number) => Camera;
+            lookAt: {
+                (vector: Vector3): void;
+                (x: number, y: number, z: number): void;
+            };
+            toJSON: (meta?: {
+                geometries: any;
+                materials: any;
+                textures: any;
+                images: any;
+            } | undefined) => any;
+            hasEventListener: {
+                <T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Camera>): boolean;
+                <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, Camera>): boolean;
+            };
+            dispatchEvent: <T_2 extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T_2> & import("three").Object3DEventMap[T_2]) => void;
+            visible: boolean;
+            onBeforeRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            readonly isObject3D: true;
+            parent: import("three").Object3D<import("three").Object3DEventMap> | null;
+            children: import("three").Object3D<import("three").Object3DEventMap>[];
+            readonly modelViewMatrix: import("three").Matrix4;
+            readonly normalMatrix: import("three").Matrix3;
+            matrixWorld: import("three").Matrix4;
+            matrixAutoUpdate: boolean;
+            matrixWorldAutoUpdate: boolean;
+            matrixWorldNeedsUpdate: boolean;
+            castShadow: boolean;
+            receiveShadow: boolean;
+            frustumCulled: boolean;
+            renderOrder: number;
+            animations: import("three").AnimationClip[];
+            customDepthMaterial?: import("three").Material | undefined;
+            customDistanceMaterial?: import("three").Material | undefined;
+            onBeforeShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            setRotationFromAxisAngle: (axis: Vector3, angle: number) => void;
+            setRotationFromEuler: (euler: import("three").Euler) => void;
+            setRotationFromMatrix: (m: import("three").Matrix4) => void;
+            setRotationFromQuaternion: (q: import("three").Quaternion) => void;
+            rotateOnAxis: (axis: Vector3, angle: number) => Camera;
+            rotateOnWorldAxis: (axis: Vector3, angle: number) => Camera;
+            translateOnAxis: (axis: Vector3, distance: number) => Camera;
+            translateX: (distance: number) => Camera;
+            translateY: (distance: number) => Camera;
+            translateZ: (distance: number) => Camera;
+            localToWorld: (vector: Vector3) => Vector3;
+            worldToLocal: (vector: Vector3) => Vector3;
+            remove: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => Camera;
+            removeFromParent: () => Camera;
+            clear: () => Camera;
+            getObjectById: (id: number) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectByName: (name: string) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectByProperty: (name: string, value: any) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined) => import("three").Object3D<import("three").Object3DEventMap>[];
+            getWorldPosition: (target: Vector3) => Vector3;
+            getWorldQuaternion: (target: import("three").Quaternion) => import("three").Quaternion;
+            getWorldScale: (target: Vector3) => Vector3;
+            getWorldDirection: (target: Vector3) => Vector3;
+            raycast: (raycaster: Raycaster, intersects: import("three").Intersection<import("three").Object3D<import("three").Object3DEventMap>>[]) => void;
+            traverse: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            traverseVisible: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            traverseAncestors: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            updateMatrix: () => void;
+            updateMatrixWorld: (force?: boolean | undefined) => void;
+            updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+            readonly isCamera: true;
+            matrixWorldInverse: import("three").Matrix4;
+            projectionMatrix: import("three").Matrix4;
+            projectionMatrixInverse: import("three").Matrix4;
+            coordinateSystem: import("three").CoordinateSystem;
+            viewport?: import("three").Vector4 | undefined;
+        }>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey_2]) => any): void;
+        removeEventListener<TEventKey_3 extends keyof import("./events").NgtEventHandlers>(type: TEventKey_3, listener: (this: NgtObject3DNode<Camera, typeof Camera, {
+            clone: (recursive?: boolean | undefined) => Camera;
+            copy: (object: import("three").Object3D<import("three").Object3DEventMap>, recursive?: boolean | undefined) => Camera;
+            add: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => Camera;
+            applyMatrix4: (matrix: import("three").Matrix4) => void;
+            applyQuaternion: (quaternion: import("three").Quaternion) => Camera;
+            attach: (object: import("three").Object3D<import("three").Object3DEventMap>) => Camera;
+            readonly type: string;
+            readonly position: Vector3;
+            up: Vector3;
+            readonly scale: Vector3;
+            readonly rotation: import("three").Euler;
+            matrix: import("three").Matrix4;
+            readonly quaternion: import("three").Quaternion;
+            layers: import("three").Layers;
+            readonly id: number;
+            uuid: string;
+            name: string;
+            userData: Record<string, any>;
+            rotateX: (angle: number) => Camera;
+            rotateY: (angle: number) => Camera;
+            rotateZ: (angle: number) => Camera;
+            lookAt: {
+                (vector: Vector3): void;
+                (x: number, y: number, z: number): void;
+            };
+            toJSON: (meta?: {
+                geometries: any;
+                materials: any;
+                textures: any;
+                images: any;
+            } | undefined) => any;
+            hasEventListener: {
+                <T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Camera>): boolean;
+                <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, Camera>): boolean;
+            };
+            dispatchEvent: <T_2 extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T_2> & import("three").Object3DEventMap[T_2]) => void;
+            visible: boolean;
+            onBeforeRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            readonly isObject3D: true;
+            parent: import("three").Object3D<import("three").Object3DEventMap> | null;
+            children: import("three").Object3D<import("three").Object3DEventMap>[];
+            readonly modelViewMatrix: import("three").Matrix4;
+            readonly normalMatrix: import("three").Matrix3;
+            matrixWorld: import("three").Matrix4;
+            matrixAutoUpdate: boolean;
+            matrixWorldAutoUpdate: boolean;
+            matrixWorldNeedsUpdate: boolean;
+            castShadow: boolean;
+            receiveShadow: boolean;
+            frustumCulled: boolean;
+            renderOrder: number;
+            animations: import("three").AnimationClip[];
+            customDepthMaterial?: import("three").Material | undefined;
+            customDistanceMaterial?: import("three").Material | undefined;
+            onBeforeShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            setRotationFromAxisAngle: (axis: Vector3, angle: number) => void;
+            setRotationFromEuler: (euler: import("three").Euler) => void;
+            setRotationFromMatrix: (m: import("three").Matrix4) => void;
+            setRotationFromQuaternion: (q: import("three").Quaternion) => void;
+            rotateOnAxis: (axis: Vector3, angle: number) => Camera;
+            rotateOnWorldAxis: (axis: Vector3, angle: number) => Camera;
+            translateOnAxis: (axis: Vector3, distance: number) => Camera;
+            translateX: (distance: number) => Camera;
+            translateY: (distance: number) => Camera;
+            translateZ: (distance: number) => Camera;
+            localToWorld: (vector: Vector3) => Vector3;
+            worldToLocal: (vector: Vector3) => Vector3;
+            remove: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => Camera;
+            removeFromParent: () => Camera;
+            clear: () => Camera;
+            getObjectById: (id: number) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectByName: (name: string) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectByProperty: (name: string, value: any) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined) => import("three").Object3D<import("three").Object3DEventMap>[];
+            getWorldPosition: (target: Vector3) => Vector3;
+            getWorldQuaternion: (target: import("three").Quaternion) => import("three").Quaternion;
+            getWorldScale: (target: Vector3) => Vector3;
+            getWorldDirection: (target: Vector3) => Vector3;
+            raycast: (raycaster: Raycaster, intersects: import("three").Intersection<import("three").Object3D<import("three").Object3DEventMap>>[]) => void;
+            traverse: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            traverseVisible: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            traverseAncestors: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            updateMatrix: () => void;
+            updateMatrixWorld: (force?: boolean | undefined) => void;
+            updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+            readonly isCamera: true;
+            matrixWorldInverse: import("three").Matrix4;
+            projectionMatrix: import("three").Matrix4;
+            projectionMatrixInverse: import("three").Matrix4;
+            coordinateSystem: import("three").CoordinateSystem;
+            viewport?: import("three").Vector4 | undefined;
+        }>, ev: import("./three-types").NgtObject3DEventsMap[TEventKey_3]) => any): void;
+    } & Omit<import("./three-types").NgtExtendedColors<import("./three-types").NgtOverwrite<Partial<{
+        clone: (recursive?: boolean | undefined) => PerspectiveCamera;
+        copy: (object: import("three").Object3D<import("three").Object3DEventMap>, recursive?: boolean | undefined) => PerspectiveCamera;
+        add: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => PerspectiveCamera;
+        applyMatrix4: (matrix: import("three").Matrix4) => void;
+        applyQuaternion: (quaternion: import("three").Quaternion) => PerspectiveCamera;
+        attach: (object: import("three").Object3D<import("three").Object3DEventMap>) => PerspectiveCamera;
+        view: {
+            enabled: boolean;
+            fullWidth: number;
+            fullHeight: number;
+            offsetX: number;
+            offsetY: number;
+            width: number;
+            height: number;
+        } | null;
+        readonly type: string;
+        readonly position: Vector3;
+        up: Vector3;
+        readonly scale: Vector3;
+        readonly rotation: import("three").Euler;
+        matrix: import("three").Matrix4;
+        readonly quaternion: import("three").Quaternion;
+        layers: import("three").Layers;
+        readonly id: number;
+        uuid: string;
+        name: string;
+        userData: Record<string, any>;
+        rotateX: (angle: number) => PerspectiveCamera;
+        rotateY: (angle: number) => PerspectiveCamera;
+        rotateZ: (angle: number) => PerspectiveCamera;
+        lookAt: {
+            (vector: Vector3): void;
+            (x: number, y: number, z: number): void;
+        };
+        toJSON: (meta?: {
+            geometries: any;
+            materials: any;
+            textures: any;
+            images: any;
+        } | undefined) => any;
+        hasEventListener: {
+            <T_5 extends keyof import("three").Object3DEventMap>(type: T_5, listener: import("three").EventListener<import("three").Object3DEventMap[T_5], T_5, PerspectiveCamera>): boolean;
+            <T_6 extends string>(type: T_6, listener: import("three").EventListener<{}, T_6, PerspectiveCamera>): boolean;
+        };
+        dispatchEvent: <T_2 extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T_2> & import("three").Object3DEventMap[T_2]) => void;
+        visible: boolean;
+        onBeforeRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+        readonly isObject3D: true;
+        parent: import("three").Object3D<import("three").Object3DEventMap> | null;
+        children: import("three").Object3D<import("three").Object3DEventMap>[];
+        readonly modelViewMatrix: import("three").Matrix4;
+        readonly normalMatrix: import("three").Matrix3;
+        matrixWorld: import("three").Matrix4;
+        matrixAutoUpdate: boolean;
+        matrixWorldAutoUpdate: boolean;
+        matrixWorldNeedsUpdate: boolean;
+        castShadow: boolean;
+        receiveShadow: boolean;
+        frustumCulled: boolean;
+        renderOrder: number;
+        animations: import("three").AnimationClip[];
+        customDepthMaterial?: import("three").Material | undefined;
+        customDistanceMaterial?: import("three").Material | undefined;
+        onBeforeShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+        onAfterShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+        onAfterRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+        setRotationFromAxisAngle: (axis: Vector3, angle: number) => void;
+        setRotationFromEuler: (euler: import("three").Euler) => void;
+        setRotationFromMatrix: (m: import("three").Matrix4) => void;
+        setRotationFromQuaternion: (q: import("three").Quaternion) => void;
+        rotateOnAxis: (axis: Vector3, angle: number) => PerspectiveCamera;
+        rotateOnWorldAxis: (axis: Vector3, angle: number) => PerspectiveCamera;
+        translateOnAxis: (axis: Vector3, distance: number) => PerspectiveCamera;
+        translateX: (distance: number) => PerspectiveCamera;
+        translateY: (distance: number) => PerspectiveCamera;
+        translateZ: (distance: number) => PerspectiveCamera;
+        localToWorld: (vector: Vector3) => Vector3;
+        worldToLocal: (vector: Vector3) => Vector3;
+        remove: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => PerspectiveCamera;
+        removeFromParent: () => PerspectiveCamera;
+        clear: () => PerspectiveCamera;
+        getObjectById: (id: number) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+        getObjectByName: (name: string) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+        getObjectByProperty: (name: string, value: any) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+        getObjectsByProperty: (name: string, value: any, optionalTarget?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined) => import("three").Object3D<import("three").Object3DEventMap>[];
+        getWorldPosition: (target: Vector3) => Vector3;
+        getWorldQuaternion: (target: import("three").Quaternion) => import("three").Quaternion;
+        getWorldScale: (target: Vector3) => Vector3;
+        getWorldDirection: (target: Vector3) => Vector3;
+        raycast: (raycaster: Raycaster, intersects: import("three").Intersection<import("three").Object3D<import("three").Object3DEventMap>>[]) => void;
+        traverse: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+        traverseVisible: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+        traverseAncestors: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+        updateMatrix: () => void;
+        updateMatrixWorld: (force?: boolean | undefined) => void;
+        updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+        readonly isCamera: true;
+        matrixWorldInverse: import("three").Matrix4;
+        projectionMatrix: import("three").Matrix4;
+        projectionMatrixInverse: import("three").Matrix4;
+        coordinateSystem: import("three").CoordinateSystem;
+        viewport?: import("three").Vector4 | undefined;
+        readonly isPerspectiveCamera: true;
+        zoom: number;
+        fov: number;
+        aspect: number;
+        near: number;
+        far: number;
+        focus: number;
+        filmGauge: number;
+        filmOffset: number;
+        getFocalLength: () => number;
+        setFocalLength: (focalLength: number) => void;
+        getEffectiveFOV: () => number;
+        getFilmWidth: () => number;
+        getFilmHeight: () => number;
+        getViewBounds: (distance: number, minTarget: import("three").Vector2, maxTarget: import("three").Vector2) => void;
+        getViewSize: (distance: number, target: import("three").Vector2) => import("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<PerspectiveCamera, typeof 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;
+    }>> & {
+        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<PerspectiveCamera, typeof PerspectiveCamera, {
+            clone: (recursive?: boolean | undefined) => PerspectiveCamera;
+            copy: (object: import("three").Object3D<import("three").Object3DEventMap>, recursive?: boolean | undefined) => PerspectiveCamera;
+            add: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => PerspectiveCamera;
+            applyMatrix4: (matrix: import("three").Matrix4) => void;
+            applyQuaternion: (quaternion: import("three").Quaternion) => PerspectiveCamera;
+            attach: (object: import("three").Object3D<import("three").Object3DEventMap>) => PerspectiveCamera;
+            view: {
+                enabled: boolean;
+                fullWidth: number;
+                fullHeight: number;
+                offsetX: number;
+                offsetY: number;
+                width: number;
+                height: number;
+            } | null;
+            readonly type: string;
+            readonly position: Vector3;
+            up: Vector3;
+            readonly scale: Vector3;
+            readonly rotation: import("three").Euler;
+            matrix: import("three").Matrix4;
+            readonly quaternion: import("three").Quaternion;
+            layers: import("three").Layers;
+            readonly id: number;
+            uuid: string;
+            name: string;
+            userData: Record<string, any>;
+            rotateX: (angle: number) => PerspectiveCamera;
+            rotateY: (angle: number) => PerspectiveCamera;
+            rotateZ: (angle: number) => PerspectiveCamera;
+            lookAt: {
+                (vector: Vector3): void;
+                (x: number, y: number, z: number): void;
+            };
+            toJSON: (meta?: {
+                geometries: any;
+                materials: any;
+                textures: any;
+                images: any;
+            } | undefined) => any;
+            hasEventListener: {
+                <T_5 extends keyof import("three").Object3DEventMap>(type: T_5, listener: import("three").EventListener<import("three").Object3DEventMap[T_5], T_5, PerspectiveCamera>): boolean;
+                <T_6 extends string>(type: T_6, listener: import("three").EventListener<{}, T_6, PerspectiveCamera>): boolean;
+            };
+            dispatchEvent: <T_2 extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T_2> & import("three").Object3DEventMap[T_2]) => void;
+            visible: boolean;
+            onBeforeRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            readonly isObject3D: true;
+            parent: import("three").Object3D<import("three").Object3DEventMap> | null;
+            children: import("three").Object3D<import("three").Object3DEventMap>[];
+            readonly modelViewMatrix: import("three").Matrix4;
+            readonly normalMatrix: import("three").Matrix3;
+            matrixWorld: import("three").Matrix4;
+            matrixAutoUpdate: boolean;
+            matrixWorldAutoUpdate: boolean;
+            matrixWorldNeedsUpdate: boolean;
+            castShadow: boolean;
+            receiveShadow: boolean;
+            frustumCulled: boolean;
+            renderOrder: number;
+            animations: import("three").AnimationClip[];
+            customDepthMaterial?: import("three").Material | undefined;
+            customDistanceMaterial?: import("three").Material | undefined;
+            onBeforeShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            setRotationFromAxisAngle: (axis: Vector3, angle: number) => void;
+            setRotationFromEuler: (euler: import("three").Euler) => void;
+            setRotationFromMatrix: (m: import("three").Matrix4) => void;
+            setRotationFromQuaternion: (q: import("three").Quaternion) => void;
+            rotateOnAxis: (axis: Vector3, angle: number) => PerspectiveCamera;
+            rotateOnWorldAxis: (axis: Vector3, angle: number) => PerspectiveCamera;
+            translateOnAxis: (axis: Vector3, distance: number) => PerspectiveCamera;
+            translateX: (distance: number) => PerspectiveCamera;
+            translateY: (distance: number) => PerspectiveCamera;
+            translateZ: (distance: number) => PerspectiveCamera;
+            localToWorld: (vector: Vector3) => Vector3;
+            worldToLocal: (vector: Vector3) => Vector3;
+            remove: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => PerspectiveCamera;
+            removeFromParent: () => PerspectiveCamera;
+            clear: () => PerspectiveCamera;
+            getObjectById: (id: number) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectByName: (name: string) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectByProperty: (name: string, value: any) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined) => import("three").Object3D<import("three").Object3DEventMap>[];
+            getWorldPosition: (target: Vector3) => Vector3;
+            getWorldQuaternion: (target: import("three").Quaternion) => import("three").Quaternion;
+            getWorldScale: (target: Vector3) => Vector3;
+            getWorldDirection: (target: Vector3) => Vector3;
+            raycast: (raycaster: Raycaster, intersects: import("three").Intersection<import("three").Object3D<import("three").Object3DEventMap>>[]) => void;
+            traverse: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            traverseVisible: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            traverseAncestors: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            updateMatrix: () => void;
+            updateMatrixWorld: (force?: boolean | undefined) => void;
+            updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+            readonly isCamera: true;
+            matrixWorldInverse: import("three").Matrix4;
+            projectionMatrix: import("three").Matrix4;
+            projectionMatrixInverse: import("three").Matrix4;
+            coordinateSystem: import("three").CoordinateSystem;
+            viewport?: import("three").Vector4 | undefined;
+            readonly isPerspectiveCamera: true;
+            zoom: number;
+            fov: number;
+            aspect: number;
+            near: number;
+            far: number;
+            focus: number;
+            filmGauge: number;
+            filmOffset: number;
+            getFocalLength: () => number;
+            setFocalLength: (focalLength: number) => void;
+            getEffectiveFOV: () => number;
+            getFilmWidth: () => number;
+            getFilmHeight: () => number;
+            getViewBounds: (distance: number, minTarget: import("three").Vector2, maxTarget: import("three").Vector2) => void;
+            getViewSize: (distance: number, target: import("three").Vector2) => import("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<PerspectiveCamera, typeof PerspectiveCamera, {
+            clone: (recursive?: boolean | undefined) => PerspectiveCamera;
+            copy: (object: import("three").Object3D<import("three").Object3DEventMap>, recursive?: boolean | undefined) => PerspectiveCamera;
+            add: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => PerspectiveCamera;
+            applyMatrix4: (matrix: import("three").Matrix4) => void;
+            applyQuaternion: (quaternion: import("three").Quaternion) => PerspectiveCamera;
+            attach: (object: import("three").Object3D<import("three").Object3DEventMap>) => PerspectiveCamera;
+            view: {
+                enabled: boolean;
+                fullWidth: number;
+                fullHeight: number;
+                offsetX: number;
+                offsetY: number;
+                width: number;
+                height: number;
+            } | null;
+            readonly type: string;
+            readonly position: Vector3;
+            up: Vector3;
+            readonly scale: Vector3;
+            readonly rotation: import("three").Euler;
+            matrix: import("three").Matrix4;
+            readonly quaternion: import("three").Quaternion;
+            layers: import("three").Layers;
+            readonly id: number;
+            uuid: string;
+            name: string;
+            userData: Record<string, any>;
+            rotateX: (angle: number) => PerspectiveCamera;
+            rotateY: (angle: number) => PerspectiveCamera;
+            rotateZ: (angle: number) => PerspectiveCamera;
+            lookAt: {
+                (vector: Vector3): void;
+                (x: number, y: number, z: number): void;
+            };
+            toJSON: (meta?: {
+                geometries: any;
+                materials: any;
+                textures: any;
+                images: any;
+            } | undefined) => any;
+            hasEventListener: {
+                <T_5 extends keyof import("three").Object3DEventMap>(type: T_5, listener: import("three").EventListener<import("three").Object3DEventMap[T_5], T_5, PerspectiveCamera>): boolean;
+                <T_6 extends string>(type: T_6, listener: import("three").EventListener<{}, T_6, PerspectiveCamera>): boolean;
+            };
+            dispatchEvent: <T_2 extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T_2> & import("three").Object3DEventMap[T_2]) => void;
+            visible: boolean;
+            onBeforeRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            readonly isObject3D: true;
+            parent: import("three").Object3D<import("three").Object3DEventMap> | null;
+            children: import("three").Object3D<import("three").Object3DEventMap>[];
+            readonly modelViewMatrix: import("three").Matrix4;
+            readonly normalMatrix: import("three").Matrix3;
+            matrixWorld: import("three").Matrix4;
+            matrixAutoUpdate: boolean;
+            matrixWorldAutoUpdate: boolean;
+            matrixWorldNeedsUpdate: boolean;
+            castShadow: boolean;
+            receiveShadow: boolean;
+            frustumCulled: boolean;
+            renderOrder: number;
+            animations: import("three").AnimationClip[];
+            customDepthMaterial?: import("three").Material | undefined;
+            customDistanceMaterial?: import("three").Material | undefined;
+            onBeforeShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            setRotationFromAxisAngle: (axis: Vector3, angle: number) => void;
+            setRotationFromEuler: (euler: import("three").Euler) => void;
+            setRotationFromMatrix: (m: import("three").Matrix4) => void;
+            setRotationFromQuaternion: (q: import("three").Quaternion) => void;
+            rotateOnAxis: (axis: Vector3, angle: number) => PerspectiveCamera;
+            rotateOnWorldAxis: (axis: Vector3, angle: number) => PerspectiveCamera;
+            translateOnAxis: (axis: Vector3, distance: number) => PerspectiveCamera;
+            translateX: (distance: number) => PerspectiveCamera;
+            translateY: (distance: number) => PerspectiveCamera;
+            translateZ: (distance: number) => PerspectiveCamera;
+            localToWorld: (vector: Vector3) => Vector3;
+            worldToLocal: (vector: Vector3) => Vector3;
+            remove: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => PerspectiveCamera;
+            removeFromParent: () => PerspectiveCamera;
+            clear: () => PerspectiveCamera;
+            getObjectById: (id: number) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectByName: (name: string) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectByProperty: (name: string, value: any) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined) => import("three").Object3D<import("three").Object3DEventMap>[];
+            getWorldPosition: (target: Vector3) => Vector3;
+            getWorldQuaternion: (target: import("three").Quaternion) => import("three").Quaternion;
+            getWorldScale: (target: Vector3) => Vector3;
+            getWorldDirection: (target: Vector3) => Vector3;
+            raycast: (raycaster: Raycaster, intersects: import("three").Intersection<import("three").Object3D<import("three").Object3DEventMap>>[]) => void;
+            traverse: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            traverseVisible: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            traverseAncestors: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            updateMatrix: () => void;
+            updateMatrixWorld: (force?: boolean | undefined) => void;
+            updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+            readonly isCamera: true;
+            matrixWorldInverse: import("three").Matrix4;
+            projectionMatrix: import("three").Matrix4;
+            projectionMatrixInverse: import("three").Matrix4;
+            coordinateSystem: import("three").CoordinateSystem;
+            viewport?: import("three").Vector4 | undefined;
+            readonly isPerspectiveCamera: true;
+            zoom: number;
+            fov: number;
+            aspect: number;
+            near: number;
+            far: number;
+            focus: number;
+            filmGauge: number;
+            filmOffset: number;
+            getFocalLength: () => number;
+            setFocalLength: (focalLength: number) => void;
+            getEffectiveFOV: () => number;
+            getFilmWidth: () => number;
+            getFilmHeight: () => number;
+            getViewBounds: (distance: number, minTarget: import("three").Vector2, maxTarget: import("three").Vector2) => void;
+            getViewSize: (distance: number, target: import("three").Vector2) => import("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;
+    } & Omit<import("./three-types").NgtExtendedColors<import("./three-types").NgtOverwrite<Partial<{
+        clone: (recursive?: boolean | undefined) => OrthographicCamera;
+        copy: (object: import("three").Object3D<import("three").Object3DEventMap>, recursive?: boolean | undefined) => OrthographicCamera;
+        add: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => OrthographicCamera;
+        applyMatrix4: (matrix: import("three").Matrix4) => void;
+        applyQuaternion: (quaternion: import("three").Quaternion) => OrthographicCamera;
+        attach: (object: import("three").Object3D<import("three").Object3DEventMap>) => OrthographicCamera;
+        view: {
+            enabled: boolean;
+            /** Props that go into the default raycaster */
+            fullWidth: number;
+            fullHeight: number;
+            offsetX: number;
+            offsetY: number;
+            width: number;
+            height: number;
+        } | null;
+        readonly type: string;
+        readonly position: Vector3;
+        up: Vector3;
+        readonly scale: Vector3;
+        readonly rotation: import("three").Euler;
+        matrix: import("three").Matrix4;
+        readonly quaternion: import("three").Quaternion;
+        layers: import("three").Layers;
+        readonly id: number;
+        uuid: string;
+        name: string;
+        userData: Record<string, any>;
+        rotateX: (angle: number) => OrthographicCamera;
+        rotateY: (angle: number) => OrthographicCamera;
+        rotateZ: (angle: number) => OrthographicCamera;
+        lookAt: {
+            (vector: Vector3): void;
+            (x: number, y: number, z: number): void;
+        };
+        toJSON: (meta?: {
+            geometries: any;
+            materials: any;
+            textures: any;
+            images: any;
+        } | undefined) => any;
+        hasEventListener: {
+            <T_9 extends keyof import("three").Object3DEventMap>(type: T_9, listener: import("three").EventListener<import("three").Object3DEventMap[T_9], T_9, OrthographicCamera>): boolean;
+            <T_10 extends string>(type: T_10, listener: import("three").EventListener<{}, T_10, OrthographicCamera>): boolean;
+        };
+        dispatchEvent: <T_2 extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T_2> & import("three").Object3DEventMap[T_2]) => void;
+        visible: boolean;
+        onBeforeRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+        readonly isObject3D: true;
+        parent: import("three").Object3D<import("three").Object3DEventMap> | null;
+        children: import("three").Object3D<import("three").Object3DEventMap>[];
+        readonly modelViewMatrix: import("three").Matrix4;
+        readonly normalMatrix: import("three").Matrix3;
+        matrixWorld: import("three").Matrix4;
+        matrixAutoUpdate: boolean;
+        matrixWorldAutoUpdate: boolean;
+        matrixWorldNeedsUpdate: boolean;
+        castShadow: boolean;
+        receiveShadow: boolean;
+        frustumCulled: boolean;
+        renderOrder: number;
+        animations: import("three").AnimationClip[];
+        customDepthMaterial?: import("three").Material | undefined;
+        customDistanceMaterial?: import("three").Material | undefined;
+        onBeforeShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+        onAfterShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+        onAfterRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+        setRotationFromAxisAngle: (axis: Vector3, angle: number) => void;
+        setRotationFromEuler: (euler: import("three").Euler) => void;
+        setRotationFromMatrix: (m: import("three").Matrix4) => void;
+        setRotationFromQuaternion: (q: import("three").Quaternion) => void;
+        rotateOnAxis: (axis: Vector3, angle: number) => OrthographicCamera;
+        rotateOnWorldAxis: (axis: Vector3, angle: number) => OrthographicCamera;
+        translateOnAxis: (axis: Vector3, distance: number) => OrthographicCamera;
+        translateX: (distance: number) => OrthographicCamera;
+        translateY: (distance: number) => OrthographicCamera;
+        translateZ: (distance: number) => OrthographicCamera;
+        localToWorld: (vector: Vector3) => Vector3;
+        worldToLocal: (vector: Vector3) => Vector3;
+        remove: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => OrthographicCamera;
+        removeFromParent: () => OrthographicCamera;
+        clear: () => OrthographicCamera;
+        getObjectById: (id: number) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+        getObjectByName: (name: string) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+        getObjectByProperty: (name: string, value: any) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+        getObjectsByProperty: (name: string, value: any, optionalTarget?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined) => import("three").Object3D<import("three").Object3DEventMap>[];
+        getWorldPosition: (target: Vector3) => Vector3;
+        getWorldQuaternion: (target: import("three").Quaternion) => import("three").Quaternion;
+        getWorldScale: (target: Vector3) => Vector3;
+        getWorldDirection: (target: Vector3) => Vector3;
+        raycast: (raycaster: Raycaster, intersects: import("three").Intersection<import("three").Object3D<import("three").Object3DEventMap>>[]) => void;
+        traverse: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+        traverseVisible: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+        traverseAncestors: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+        updateMatrix: () => void;
+        updateMatrixWorld: (force?: boolean | undefined) => void;
+        updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+        readonly isCamera: true;
+        matrixWorldInverse: import("three").Matrix4;
+        projectionMatrix: import("three").Matrix4;
+        projectionMatrixInverse: import("three").Matrix4;
+        coordinateSystem: import("three").CoordinateSystem;
+        viewport?: import("three").Vector4 | undefined;
+        zoom: number;
+        near: number;
+        far: number;
+        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<OrthographicCamera, typeof 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;
+    }>> & {
+        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<OrthographicCamera, typeof OrthographicCamera, {
+            clone: (recursive?: boolean | undefined) => OrthographicCamera;
+            copy: (object: import("three").Object3D<import("three").Object3DEventMap>, recursive?: boolean | undefined) => OrthographicCamera;
+            add: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => OrthographicCamera;
+            applyMatrix4: (matrix: import("three").Matrix4) => void;
+            applyQuaternion: (quaternion: import("three").Quaternion) => OrthographicCamera;
+            attach: (object: import("three").Object3D<import("three").Object3DEventMap>) => OrthographicCamera;
+            view: {
+                enabled: boolean;
+                /** Props that go into the default raycaster */
+                fullWidth: number;
+                fullHeight: number;
+                offsetX: number;
+                offsetY: number;
+                width: number;
+                height: number;
+            } | null;
+            readonly type: string;
+            readonly position: Vector3;
+            up: Vector3;
+            readonly scale: Vector3;
+            readonly rotation: import("three").Euler;
+            matrix: import("three").Matrix4;
+            readonly quaternion: import("three").Quaternion;
+            layers: import("three").Layers;
+            readonly id: number;
+            uuid: string;
+            name: string;
+            userData: Record<string, any>;
+            rotateX: (angle: number) => OrthographicCamera;
+            rotateY: (angle: number) => OrthographicCamera;
+            rotateZ: (angle: number) => OrthographicCamera;
+            lookAt: {
+                (vector: Vector3): void;
+                (x: number, y: number, z: number): void;
+            };
+            toJSON: (meta?: {
+                geometries: any;
+                materials: any;
+                textures: any;
+                images: any;
+            } | undefined) => any;
+            hasEventListener: {
+                <T_9 extends keyof import("three").Object3DEventMap>(type: T_9, listener: import("three").EventListener<import("three").Object3DEventMap[T_9], T_9, OrthographicCamera>): boolean;
+                <T_10 extends string>(type: T_10, listener: import("three").EventListener<{}, T_10, OrthographicCamera>): boolean;
+            };
+            dispatchEvent: <T_2 extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T_2> & import("three").Object3DEventMap[T_2]) => void;
+            visible: boolean;
+            onBeforeRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            readonly isObject3D: true;
+            parent: import("three").Object3D<import("three").Object3DEventMap> | null;
+            children: import("three").Object3D<import("three").Object3DEventMap>[];
+            readonly modelViewMatrix: import("three").Matrix4;
+            readonly normalMatrix: import("three").Matrix3;
+            matrixWorld: import("three").Matrix4;
+            matrixAutoUpdate: boolean;
+            matrixWorldAutoUpdate: boolean;
+            matrixWorldNeedsUpdate: boolean;
+            castShadow: boolean;
+            receiveShadow: boolean;
+            frustumCulled: boolean;
+            renderOrder: number;
+            animations: import("three").AnimationClip[];
+            customDepthMaterial?: import("three").Material | undefined;
+            customDistanceMaterial?: import("three").Material | undefined;
+            onBeforeShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            setRotationFromAxisAngle: (axis: Vector3, angle: number) => void;
+            setRotationFromEuler: (euler: import("three").Euler) => void;
+            setRotationFromMatrix: (m: import("three").Matrix4) => void;
+            setRotationFromQuaternion: (q: import("three").Quaternion) => void;
+            rotateOnAxis: (axis: Vector3, angle: number) => OrthographicCamera;
+            rotateOnWorldAxis: (axis: Vector3, angle: number) => OrthographicCamera;
+            translateOnAxis: (axis: Vector3, distance: number) => OrthographicCamera;
+            translateX: (distance: number) => OrthographicCamera;
+            translateY: (distance: number) => OrthographicCamera;
+            translateZ: (distance: number) => OrthographicCamera;
+            localToWorld: (vector: Vector3) => Vector3;
+            worldToLocal: (vector: Vector3) => Vector3;
+            remove: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => OrthographicCamera;
+            removeFromParent: () => OrthographicCamera;
+            clear: () => OrthographicCamera;
+            getObjectById: (id: number) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectByName: (name: string) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectByProperty: (name: string, value: any) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined) => import("three").Object3D<import("three").Object3DEventMap>[];
+            getWorldPosition: (target: Vector3) => Vector3;
+            getWorldQuaternion: (target: import("three").Quaternion) => import("three").Quaternion;
+            getWorldScale: (target: Vector3) => Vector3;
+            getWorldDirection: (target: Vector3) => Vector3;
+            raycast: (raycaster: Raycaster, intersects: import("three").Intersection<import("three").Object3D<import("three").Object3DEventMap>>[]) => void;
+            traverse: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            traverseVisible: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            traverseAncestors: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            updateMatrix: () => void;
+            updateMatrixWorld: (force?: boolean | undefined) => void;
+            updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+            readonly isCamera: true;
+            matrixWorldInverse: import("three").Matrix4;
+            projectionMatrix: import("three").Matrix4;
+            projectionMatrixInverse: import("three").Matrix4;
+            coordinateSystem: import("three").CoordinateSystem;
+            viewport?: import("three").Vector4 | undefined;
+            zoom: number;
+            near: number;
+            far: number;
+            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<OrthographicCamera, typeof OrthographicCamera, {
+            clone: (recursive?: boolean | undefined) => OrthographicCamera;
+            copy: (object: import("three").Object3D<import("three").Object3DEventMap>, recursive?: boolean | undefined) => OrthographicCamera;
+            add: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => OrthographicCamera;
+            applyMatrix4: (matrix: import("three").Matrix4) => void;
+            applyQuaternion: (quaternion: import("three").Quaternion) => OrthographicCamera;
+            attach: (object: import("three").Object3D<import("three").Object3DEventMap>) => OrthographicCamera;
+            view: {
+                enabled: boolean;
+                /** Props that go into the default raycaster */
+                fullWidth: number;
+                fullHeight: number;
+                offsetX: number;
+                offsetY: number;
+                width: number;
+                height: number;
+            } | null;
+            readonly type: string;
+            readonly position: Vector3;
+            up: Vector3;
+            readonly scale: Vector3;
+            readonly rotation: import("three").Euler;
+            matrix: import("three").Matrix4;
+            readonly quaternion: import("three").Quaternion;
+            layers: import("three").Layers;
+            readonly id: number;
+            uuid: string;
+            name: string;
+            userData: Record<string, any>;
+            rotateX: (angle: number) => OrthographicCamera;
+            rotateY: (angle: number) => OrthographicCamera;
+            rotateZ: (angle: number) => OrthographicCamera;
+            lookAt: {
+                (vector: Vector3): void;
+                (x: number, y: number, z: number): void;
+            };
+            toJSON: (meta?: {
+                geometries: any;
+                materials: any;
+                textures: any;
+                images: any;
+            } | undefined) => any;
+            hasEventListener: {
+                <T_9 extends keyof import("three").Object3DEventMap>(type: T_9, listener: import("three").EventListener<import("three").Object3DEventMap[T_9], T_9, OrthographicCamera>): boolean;
+                <T_10 extends string>(type: T_10, listener: import("three").EventListener<{}, T_10, OrthographicCamera>): boolean;
+            };
+            dispatchEvent: <T_2 extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T_2> & import("three").Object3DEventMap[T_2]) => void;
+            visible: boolean;
+            onBeforeRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            readonly isObject3D: true;
+            parent: import("three").Object3D<import("three").Object3DEventMap> | null;
+            children: import("three").Object3D<import("three").Object3DEventMap>[];
+            readonly modelViewMatrix: import("three").Matrix4;
+            readonly normalMatrix: import("three").Matrix3;
+            matrixWorld: import("three").Matrix4;
+            matrixAutoUpdate: boolean;
+            matrixWorldAutoUpdate: boolean;
+            matrixWorldNeedsUpdate: boolean;
+            castShadow: boolean;
+            receiveShadow: boolean;
+            frustumCulled: boolean;
+            renderOrder: number;
+            animations: import("three").AnimationClip[];
+            customDepthMaterial?: import("three").Material | undefined;
+            customDistanceMaterial?: import("three").Material | undefined;
+            onBeforeShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterShadow: (renderer: WebGLRenderer, scene: Scene, shadowCamera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            setRotationFromAxisAngle: (axis: Vector3, angle: number) => void;
+            setRotationFromEuler: (euler: import("three").Euler) => void;
+            setRotationFromMatrix: (m: import("three").Matrix4) => void;
+            setRotationFromQuaternion: (q: import("three").Quaternion) => void;
+            rotateOnAxis: (axis: Vector3, angle: number) => OrthographicCamera;
+            rotateOnWorldAxis: (axis: Vector3, angle: number) => OrthographicCamera;
+            translateOnAxis: (axis: Vector3, distance: number) => OrthographicCamera;
+            translateX: (distance: number) => OrthographicCamera;
+            translateY: (distance: number) => OrthographicCamera;
+            translateZ: (distance: number) => OrthographicCamera;
+            localToWorld: (vector: Vector3) => Vector3;
+            worldToLocal: (vector: Vector3) => Vector3;
+            remove: (...object: import("three").Object3D<import("three").Object3DEventMap>[]) => OrthographicCamera;
+            removeFromParent: () => OrthographicCamera;
+            clear: () => OrthographicCamera;
+            getObjectById: (id: number) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectByName: (name: string) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectByProperty: (name: string, value: any) => import("three").Object3D<import("three").Object3DEventMap> | undefined;
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined) => import("three").Object3D<import("three").Object3DEventMap>[];
+            getWorldPosition: (target: Vector3) => Vector3;
+            getWorldQuaternion: (target: import("three").Quaternion) => import("three").Quaternion;
+            getWorldScale: (target: Vector3) => Vector3;
+            getWorldDirection: (target: Vector3) => Vector3;
+            raycast: (raycaster: Raycaster, intersects: import("three").Intersection<import("three").Object3D<import("three").Object3DEventMap>>[]) => void;
+            traverse: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            traverseVisible: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            traverseAncestors: (callback: (object: import("three").Object3D<import("three").Object3DEventMap>) => any) => void;
+            updateMatrix: () => void;
+            updateMatrixWorld: (force?: boolean | undefined) => void;
+            updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
+            readonly isCamera: true;
+            matrixWorldInverse: import("three").Matrix4;
+            projectionMatrix: import("three").Matrix4;
+            projectionMatrixInverse: import("three").Matrix4;
+            coordinateSystem: import("three").CoordinateSystem;
+            viewport?: import("three").Vector4 | undefined;
+            zoom: number;
+            near: number;
+            far: number;
+            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 */
+        manual?: boolean | undefined;
+    }) | undefined> | undefined>;
+    events: import("@angular/core").InputSignal<typeof createPointerEvents>;
+    eventSource: import("@angular/core").InputSignal<HTMLElement | ElementRef<HTMLElement> | undefined>;
+    eventPrefix: import("@angular/core").InputSignal<NonNullable<"offset" | "client" | "page" | "layer" | "screen" | undefined>>;
+    lookAt: import("@angular/core").InputSignal<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">;
-    glCanvas: ElementRef<HTMLCanvasElement>;
-    private resizeEffectRef?;
     private configurator?;
     private glEnvironmentInjector?;
     private glRef?;
-    ngOnChanges(changes: SimpleChanges): void;
-    ngOnInit(): void;
-    onResize(result: NgxResizeResult): void;
-    private render;
-    private overrideChangeDetectorRef;
+    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; }; "sceneGraphInputs": { "alias": "sceneGraphInputs"; "required": false; }; "compoundPrefixes": { "alias": "compoundPrefixes"; "required": false; }; "linear": { "alias": "linear"; "required": false; }; "legacy": { "alias": "legacy"; "required": false; }; "flat": { "alias": "flat"; "required": false; }; "orthographic": { "alias": "orthographic"; "required": false; }; "frameloop": { "alias": "frameloop"; "required": false; }; "dpr": { "alias": "dpr"; "required": false; }; "raycaster": { "alias": "raycaster"; "required": false; }; "shadows": { "alias": "shadows"; "required": false; }; "camera": { "alias": "camera"; "required": false; }; "scene": { "alias": "scene"; "required": false; }; "gl": { "alias": "gl"; "required": false; }; "eventSource": { "alias": "eventSource"; "required": false; }; "eventPrefix": { "alias": "eventPrefix"; "required": false; }; "lookAt": { "alias": "lookAt"; "required": false; }; "performance": { "alias": "performance"; "required": false; }; }, { "created": "created"; }, never, never, true, 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>;
 }