angular-three-soba 2.0.0-beta.26 → 2.0.0-beta.261

package/abstractions/lib/text-3d.d.ts

@@ -0,0 +1,338 @@
+import { ElementRef } from '@angular/core';
+import { NgtsFontInput } from 'angular-three-soba/loaders';
+import { Mesh } from 'three';
+import { TextGeometryParameters } from 'three-stdlib';
+import * as i0 from "@angular/core";
+export interface NgtsText3DOptions extends Omit<TextGeometryParameters, 'font'> {
+    bevelSegments: number;
+    smooth?: number;
+}
+export declare class NgtsText3D {
+    font: import("@angular/core").InputSignal<NgtsFontInput>;
+    text: import("@angular/core").InputSignal<string>;
+    options: import("@angular/core").InputSignalWithTransform<Partial<{
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        addEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtObject3DEventsMap[TEventKey]) => any) => void);
+        removeEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtObject3DEventsMap[TEventKey]) => any) => void);
+        __ngt_args__: [geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined, material?: import("three").Material | import("three").Material[] | undefined];
+        geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined;
+        material?: import("three").Material | import("three").Material[] | undefined;
+        readonly isMesh?: true | undefined;
+        readonly type?: string | undefined;
+        morphTargetInfluences?: number[] | undefined;
+        morphTargetDictionary?: {
+            [key: string]: number;
+        } | undefined;
+        updateMorphTargets?: (() => void) | undefined;
+        getVertexPosition?: ((index: number, target: import("three").Vector3) => import("three").Vector3) | undefined;
+        readonly isObject3D?: true | undefined;
+        readonly id?: number | undefined;
+        uuid?: string | undefined;
+        name?: string | undefined;
+        parent?: import("three").Object3D<import("three").Object3DEventMap> | null | undefined;
+        children?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined;
+        readonly modelViewMatrix?: import("three").Matrix4 | undefined;
+        readonly normalMatrix?: import("three").Matrix3 | undefined;
+        matrixWorld?: import("three").Matrix4 | undefined;
+        matrixAutoUpdate?: boolean | undefined;
+        matrixWorldAutoUpdate?: boolean | undefined;
+        matrixWorldNeedsUpdate?: boolean | undefined;
+        visible?: boolean | undefined;
+        castShadow?: boolean | undefined;
+        receiveShadow?: boolean | undefined;
+        frustumCulled?: boolean | undefined;
+        renderOrder?: number | undefined;
+        animations?: import("three").AnimationClip[] | undefined;
+        userData?: Record<string, any> | undefined;
+        customDepthMaterial?: import("three").Material | undefined;
+        customDistanceMaterial?: import("three").Material | undefined;
+        onBeforeShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: import("three").Group) => void) | undefined;
+        onAfterShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: import("three").Group) => void) | undefined;
+        onBeforeRender?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: import("three").Group) => void) | undefined;
+        onAfterRender?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: import("three").Group) => void) | undefined;
+        applyMatrix4?: ((matrix: import("three").Matrix4) => void) | undefined;
+        applyQuaternion?: ((quaternion: import("three").Quaternion) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        setRotationFromAxisAngle?: ((axis: import("three").Vector3, angle: number) => void) | undefined;
+        setRotationFromEuler?: ((euler: import("three").Euler) => void) | undefined;
+        setRotationFromMatrix?: ((m: import("three").Matrix4) => void) | undefined;
+        setRotationFromQuaternion?: ((q: import("three").Quaternion) => void) | undefined;
+        rotateOnAxis?: ((axis: import("three").Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: import("three").Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateX?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateY?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateZ?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateOnAxis?: ((axis: import("three").Vector3, distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateX?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateY?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateZ?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        localToWorld?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        worldToLocal?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        lookAt?: {
+            (vector: import("three").Vector3): void;
+            (x: number, y: number, z: number): void;
+        } | undefined;
+        add?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        remove?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        getObjectById?: ((id: number) => import("three").Object3D | undefined) | undefined;
+        getObjectByName?: ((name: string) => import("three").Object3D | undefined) | undefined;
+        getObjectByProperty?: ((name: string, value: any) => import("three").Object3D | undefined) | undefined;
+        getObjectsByProperty?: ((name: string, value: any, optionalTarget?: import("three").Object3D[]) => import("three").Object3D[]) | undefined;
+        getWorldPosition?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldQuaternion?: ((target: import("three").Quaternion) => import("three").Quaternion) | undefined;
+        getWorldScale?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldDirection?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        raycast?: ((raycaster: import("three").Raycaster, intersects: import("three").Intersection[]) => void) | undefined;
+        traverse?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        traverseVisible?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        traverseAncestors?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        updateMatrix?: (() => void) | undefined;
+        updateMatrixWorld?: ((force?: boolean) => void) | undefined;
+        updateWorldMatrix?: ((updateParents: boolean, updateChildren: boolean) => void) | undefined;
+        toJSON?: ((meta?: {
+            geometries: any;
+            materials: any;
+            textures: any;
+            images: any;
+        }) => any) | undefined;
+        clone?: ((recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        copy?: ((object: import("three").Object3D, recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        hasEventListener?: {
+            <T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>): boolean;
+            <T extends string>(type: T, listener: import("three").EventListener<{}, T, Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>): boolean;
+        } | undefined;
+        dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
+        position: import("angular-three").NgtVector3;
+        up: import("angular-three").NgtVector3;
+        scale: import("angular-three").NgtVector3;
+        rotation: import("angular-three").NgtEuler;
+        matrix: import("angular-three").NgtMatrix4;
+        quaternion: import("angular-three").NgtQuaternion;
+        layers: import("angular-three").NgtLayers;
+        dispose: (() => void) | null;
+    }> & NgtsText3DOptions, "" | Partial<Partial<{
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        addEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtObject3DEventsMap[TEventKey]) => any) => void);
+        removeEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtObject3DEventsMap[TEventKey]) => any) => void);
+        __ngt_args__: [geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined, material?: import("three").Material | import("three").Material[] | undefined];
+        geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined;
+        material?: import("three").Material | import("three").Material[] | undefined;
+        readonly isMesh?: true | undefined;
+        readonly type?: string | undefined;
+        morphTargetInfluences?: number[] | undefined;
+        morphTargetDictionary?: {
+            [key: string]: number;
+        } | undefined;
+        updateMorphTargets?: (() => void) | undefined;
+        getVertexPosition?: ((index: number, target: import("three").Vector3) => import("three").Vector3) | undefined;
+        readonly isObject3D?: true | undefined;
+        readonly id?: number | undefined;
+        uuid?: string | undefined;
+        name?: string | undefined;
+        parent?: import("three").Object3D<import("three").Object3DEventMap> | null | undefined;
+        children?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined;
+        readonly modelViewMatrix?: import("three").Matrix4 | undefined;
+        readonly normalMatrix?: import("three").Matrix3 | undefined;
+        matrixWorld?: import("three").Matrix4 | undefined;
+        matrixAutoUpdate?: boolean | undefined;
+        matrixWorldAutoUpdate?: boolean | undefined;
+        matrixWorldNeedsUpdate?: boolean | undefined;
+        visible?: boolean | undefined;
+        castShadow?: boolean | undefined;
+        receiveShadow?: boolean | undefined;
+        frustumCulled?: boolean | undefined;
+        renderOrder?: number | undefined;
+        animations?: import("three").AnimationClip[] | undefined;
+        userData?: Record<string, any> | undefined;
+        customDepthMaterial?: import("three").Material | undefined;
+        customDistanceMaterial?: import("three").Material | undefined;
+        onBeforeShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: import("three").Group) => void) | undefined;
+        onAfterShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: import("three").Group) => void) | undefined;
+        onBeforeRender?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: import("three").Group) => void) | undefined;
+        onAfterRender?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: import("three").Group) => void) | undefined;
+        applyMatrix4?: ((matrix: import("three").Matrix4) => void) | undefined;
+        applyQuaternion?: ((quaternion: import("three").Quaternion) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        setRotationFromAxisAngle?: ((axis: import("three").Vector3, angle: number) => void) | undefined;
+        setRotationFromEuler?: ((euler: import("three").Euler) => void) | undefined;
+        setRotationFromMatrix?: ((m: import("three").Matrix4) => void) | undefined;
+        setRotationFromQuaternion?: ((q: import("three").Quaternion) => void) | undefined;
+        rotateOnAxis?: ((axis: import("three").Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: import("three").Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateX?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateY?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateZ?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateOnAxis?: ((axis: import("three").Vector3, distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateX?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateY?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateZ?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        localToWorld?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        worldToLocal?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        lookAt?: {
+            (vector: import("three").Vector3): void;
+            (x: number, y: number, z: number): void;
+        } | undefined;
+        add?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        remove?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        getObjectById?: ((id: number) => import("three").Object3D | undefined) | undefined;
+        getObjectByName?: ((name: string) => import("three").Object3D | undefined) | undefined;
+        getObjectByProperty?: ((name: string, value: any) => import("three").Object3D | undefined) | undefined;
+        getObjectsByProperty?: ((name: string, value: any, optionalTarget?: import("three").Object3D[]) => import("three").Object3D[]) | undefined;
+        getWorldPosition?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldQuaternion?: ((target: import("three").Quaternion) => import("three").Quaternion) | undefined;
+        getWorldScale?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldDirection?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        raycast?: ((raycaster: import("three").Raycaster, intersects: import("three").Intersection[]) => void) | undefined;
+        traverse?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        traverseVisible?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        traverseAncestors?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        updateMatrix?: (() => void) | undefined;
+        updateMatrixWorld?: ((force?: boolean) => void) | undefined;
+        updateWorldMatrix?: ((updateParents: boolean, updateChildren: boolean) => void) | undefined;
+        toJSON?: ((meta?: {
+            geometries: any;
+            materials: any;
+            textures: any;
+            images: any;
+        }) => any) | undefined;
+        clone?: ((recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        copy?: ((object: import("three").Object3D, recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        hasEventListener?: {
+            <T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>): boolean;
+            <T extends string>(type: T, listener: import("three").EventListener<{}, T, Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>): boolean;
+        } | undefined;
+        dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
+        position: import("angular-three").NgtVector3;
+        up: import("angular-three").NgtVector3;
+        scale: import("angular-three").NgtVector3;
+        rotation: import("angular-three").NgtEuler;
+        matrix: import("angular-three").NgtMatrix4;
+        quaternion: import("angular-three").NgtQuaternion;
+        layers: import("angular-three").NgtLayers;
+        dispose: (() => void) | null;
+    }> & NgtsText3DOptions>>;
+    parameters: import("@angular/core").Signal<Omit<Partial<{
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        addEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtObject3DEventsMap[TEventKey]) => any) => void);
+        removeEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtObject3DEventsMap[TEventKey]) => any) => void);
+        __ngt_args__: [geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined, material?: import("three").Material | import("three").Material[] | undefined];
+        geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined;
+        material?: import("three").Material | import("three").Material[] | undefined;
+        readonly isMesh?: true | undefined;
+        readonly type?: string | undefined;
+        morphTargetInfluences?: number[] | undefined;
+        morphTargetDictionary?: {
+            [key: string]: number;
+        } | undefined;
+        updateMorphTargets?: (() => void) | undefined;
+        getVertexPosition?: ((index: number, target: import("three").Vector3) => import("three").Vector3) | undefined;
+        readonly isObject3D?: true | undefined;
+        readonly id?: number | undefined;
+        uuid?: string | undefined;
+        name?: string | undefined;
+        parent?: import("three").Object3D<import("three").Object3DEventMap> | null | undefined;
+        children?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined;
+        readonly modelViewMatrix?: import("three").Matrix4 | undefined;
+        readonly normalMatrix?: import("three").Matrix3 | undefined;
+        matrixWorld?: import("three").Matrix4 | undefined;
+        matrixAutoUpdate?: boolean | undefined;
+        matrixWorldAutoUpdate?: boolean | undefined;
+        matrixWorldNeedsUpdate?: boolean | undefined;
+        visible?: boolean | undefined;
+        castShadow?: boolean | undefined;
+        receiveShadow?: boolean | undefined;
+        frustumCulled?: boolean | undefined;
+        renderOrder?: number | undefined;
+        animations?: import("three").AnimationClip[] | undefined;
+        userData?: Record<string, any> | undefined;
+        customDepthMaterial?: import("three").Material | undefined;
+        customDistanceMaterial?: import("three").Material | undefined;
+        onBeforeShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: import("three").Group) => void) | undefined;
+        onAfterShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: import("three").Group) => void) | undefined;
+        onBeforeRender?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: import("three").Group) => void) | undefined;
+        onAfterRender?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: import("three").Group) => void) | undefined;
+        applyMatrix4?: ((matrix: import("three").Matrix4) => void) | undefined;
+        applyQuaternion?: ((quaternion: import("three").Quaternion) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        setRotationFromAxisAngle?: ((axis: import("three").Vector3, angle: number) => void) | undefined;
+        setRotationFromEuler?: ((euler: import("three").Euler) => void) | undefined;
+        setRotationFromMatrix?: ((m: import("three").Matrix4) => void) | undefined;
+        setRotationFromQuaternion?: ((q: import("three").Quaternion) => void) | undefined;
+        rotateOnAxis?: ((axis: import("three").Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: import("three").Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateX?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateY?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateZ?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateOnAxis?: ((axis: import("three").Vector3, distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateX?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateY?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateZ?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        localToWorld?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        worldToLocal?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        lookAt?: {
+            (vector: import("three").Vector3): void;
+            (x: number, y: number, z: number): void;
+        } | undefined;
+        add?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        remove?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        getObjectById?: ((id: number) => import("three").Object3D | undefined) | undefined;
+        getObjectByName?: ((name: string) => import("three").Object3D | undefined) | undefined;
+        getObjectByProperty?: ((name: string, value: any) => import("three").Object3D | undefined) | undefined;
+        getObjectsByProperty?: ((name: string, value: any, optionalTarget?: import("three").Object3D[]) => import("three").Object3D[]) | undefined;
+        getWorldPosition?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldQuaternion?: ((target: import("three").Quaternion) => import("three").Quaternion) | undefined;
+        getWorldScale?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldDirection?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        raycast?: ((raycaster: import("three").Raycaster, intersects: import("three").Intersection[]) => void) | undefined;
+        traverse?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        traverseVisible?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        traverseAncestors?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        updateMatrix?: (() => void) | undefined;
+        updateMatrixWorld?: ((force?: boolean) => void) | undefined;
+        updateWorldMatrix?: ((updateParents: boolean, updateChildren: boolean) => void) | undefined;
+        toJSON?: ((meta?: {
+            geometries: any;
+            materials: any;
+            textures: any;
+            images: any;
+        }) => any) | undefined;
+        clone?: ((recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        copy?: ((object: import("three").Object3D, recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        hasEventListener?: {
+            <T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>): boolean;
+            <T extends string>(type: T, listener: import("three").EventListener<{}, T, Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>): boolean;
+        } | undefined;
+        dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
+        position: import("angular-three").NgtVector3;
+        up: import("angular-three").NgtVector3;
+        scale: import("angular-three").NgtVector3;
+        rotation: import("angular-three").NgtEuler;
+        matrix: import("angular-three").NgtMatrix4;
+        quaternion: import("angular-three").NgtQuaternion;
+        layers: import("angular-three").NgtLayers;
+        dispose: (() => void) | null;
+    }> & NgtsText3DOptions, "size" | "height" | "curveSegments" | "bevelEnabled" | "bevelThickness" | "bevelSize" | "bevelOffset" | "bevelSegments" | "lineHeight" | "letterSpacing" | "smooth">>;
+    mesh: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>> | undefined>;
+    loadedFont: import("@angular/core").Signal<import("three-stdlib").Font | null>;
+    private smooth;
+    private textOptions;
+    textArgs: import("@angular/core").Signal<(string | {
+        size?: number;
+        height?: number;
+        curveSegments?: number;
+        bevelEnabled?: boolean;
+        bevelThickness?: number;
+        bevelSize?: number;
+        bevelOffset?: number;
+        bevelSegments: number;
+        lineHeight?: number;
+        letterSpacing?: number;
+        font: import("three-stdlib").Font;
+    })[] | null>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsText3D, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsText3D, "ngts-text-3d", never, { "font": { "alias": "font"; "required": true; "isSignal": true; }; "text": { "alias": "text"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/abstractions/lib/text.d.ts

@@ -0,0 +1,55 @@
+import { NgtMesh } from 'angular-three';
+import { ColorRepresentation } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsTextOptions extends Partial<NgtMesh> {
+    characters?: string;
+    color?: ColorRepresentation;
+    /** Font size, default: 1 */
+    fontSize: number;
+    fontWeight?: number | string;
+    fontStyle?: 'italic' | 'normal';
+    maxWidth?: number;
+    lineHeight?: number;
+    letterSpacing?: number;
+    textAlign?: 'left' | 'right' | 'center' | 'justify';
+    font?: string;
+    anchorX: number | 'left' | 'center' | 'right';
+    anchorY: number | 'top' | 'top-baseline' | 'middle' | 'bottom-baseline' | 'bottom';
+    clipRect?: [number, number, number, number];
+    depthOffset?: number;
+    direction?: 'auto' | 'ltr' | 'rtl';
+    overflowWrap?: 'normal' | 'break-word';
+    whiteSpace?: 'normal' | 'overflowWrap' | 'nowrap';
+    outlineWidth?: number | string;
+    outlineOffsetX?: number | string;
+    outlineOffsetY?: number | string;
+    outlineBlur?: number | string;
+    outlineColor?: ColorRepresentation;
+    outlineOpacity?: number;
+    strokeWidth?: number | string;
+    strokeColor?: ColorRepresentation;
+    strokeOpacity?: number;
+    fillOpacity?: number;
+    sdfGlyphSize: number;
+    debugSDF?: boolean;
+}
+export declare class NgtsText {
+    text: import("@angular/core").InputSignal<string>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsTextOptions, "" | Partial<NgtsTextOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsTextOptions, "characters" | "fontSize" | "font" | "anchorX" | "anchorY" | "sdfGlyphSize">>;
+    synced: import("@angular/core").OutputEmitterRef<Text>;
+    private autoEffect;
+    private store;
+    private invalidate;
+    private characters;
+    font: import("@angular/core").Signal<string | undefined>;
+    anchorX: import("@angular/core").Signal<number | "center" | "left" | "right">;
+    anchorY: import("@angular/core").Signal<number | "top" | "top-baseline" | "middle" | "bottom-baseline" | "bottom">;
+    sdfGlyphSize: import("@angular/core").Signal<number>;
+    fontSize: import("@angular/core").Signal<number>;
+    troikaMesh: import("@angular/core").Signal<any>;
+    args: import("@angular/core").Signal<any[]>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsText, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsText, "ngts-text", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "synced": "synced"; }, never, ["*"], true, never>;
+}

package/cameras/README.md

@@ -1,3 +1,92 @@
-# angular-three-soba/cameras
+# `angular-three-soba/cameras`
 
-Secondary entry point of `angular-three-soba`. It can be used by importing from `angular-three-soba/cameras`.
+This module provides a variety of camera components for Angular Three, including specialized cameras and helper components for camera controls.
+
+All camera implementations share the following features:
+
+- `makeDefault` option: Allows the consumer to make this camera the default camera in the Canvas Store (via injectStore()). Default is `false`.
+- `manual` option: Allows the consumer to take over updating the camera. When set to `true`, the camera won't be responsive, and the consumer will need to update its properties upon viewport change. Default is `false`.
+- `cameraContent` directive: Allows you to render content from the perspective of the camera. This can be used for various effects, including portals, minimaps, security cameras, picture-in-picture, and rendering to textures.
+
+Within the template of the `cameraContent` directive, you have access to a `texture` variable representing the rendered view. This `texture` is of type `Signal<Texture>`.
+
+```html
+<ngts-perspective-camera>
+	<ngt-mesh *cameraContent="let texture">
+		<ngt-mesh-basic-material [map]="texture()" />
+	</ngt-mesh>
+</ngts-perspective-camera>
+```
+
+## TOC
+
+- [NgtsPerspectiveCamera](#ngtsperspectivecamera)
+- [NgtsOrthographicCamera](#ngtsorthographiccamera)
+- [NgtsCubeCamera](#ngtscubecamera)
+
+## NgtsPerspectiveCamera
+
+A responsive `THREE.PerspectiveCamera` that can be set as the default camera. By default, it automatically tracks the size of the canvas and updates accordingly.
+
+### Object Inputs (NgtsPerspectiveCameraOptions)
+
+| Property | Description               | Default value |
+| -------- | ------------------------- | ------------- |
+| fov      | Field of view in degrees. | 50            |
+| near     | Near clipping plane.      | 0.1           |
+| far      | Far clipping plane.       | 1000          |
+
+### Usage
+
+```html
+<ngts-perspective-camera [options]="{ makeDefault: true, fov: 75, near: 0.1, far: 1000 }" />
+```
+
+## NgtsOrthographicCamera
+
+A responsive `THREE.OrthographicCamera` that can be set as the default camera. By default, it automatically tracks the size of the canvas and updates accordingly.
+
+### Object Inputs (NgtsOrthographicCameraOptions)
+
+| Property | Description                                 | Default value |
+| -------- | ------------------------------------------- | ------------- |
+| left     | Camera frustum left plane.                  | -1            |
+| right    | Camera frustum right plane.                 | 1             |
+| top      | Camera frustum top plane.                   | 1             |
+| bottom   | Camera frustum bottom plane.                | -1            |
+| near     | Camera frustum near plane.                  | 0.1           |
+| far      | Camera frustum far plane.                   | 1000          |
+| zoom     | Gets or sets the zoom factor of the camera. | 1             |
+
+### Usage
+
+```html
+<ngts-orthographic-camera
+	[options]="{ makeDefault: true, left: -10, right: 10, top: 10, bottom: -10, near: 0.1, far: 1000 }"
+/>
+```
+
+## NgtsCubeCamera
+
+A responsive `THREE.CubeCamera` that renders to a `WebGLCubeRenderTarget`. You can either use it as a regular environment map or use it for the `NgtsCameraContent` directive for more advanced use cases.
+
+### Object Inputs (NgtsCubeCameraOptions)
+
+| Property   | Description                    | Default value |
+| ---------- | ------------------------------ | ------------- |
+| near       | Near clipping plane.           | 0.1           |
+| far        | Far clipping plane.            | 1000          |
+| resolution | Cube render target resolution. | 256           |
+| frames     | Number of frames to render.    | 1             |
+| envMap     | Custom environment map.        | null          |
+| fog        | Custom fog.                    | null          |
+
+### Usage
+
+```html
+<ngts-cube-camera [options]="{ near: 0.1, far: 1000, resolution: 256 }">
+	<ngt-mesh *cameraContent="let texture">
+		<ngt-mesh-basic-material [map]="texture()" />
+	</ngt-mesh>
+</ngts-cube-camera>
+```

package/cameras/index.d.ts

@@ -1,4 +1,4 @@
-export * from './camera/camera-content';
-export * from './cube-camera/cube-camera';
-export * from './orthographic-camera/orthographic-camera';
-export * from './perspective-camera/perspective-camera';
+export * from './lib/camera-content';
+export * from './lib/cube-camera';
+export * from './lib/orthographic-camera';
+export * from './lib/perspective-camera';

package/cameras/lib/camera-content.d.ts

@@ -0,0 +1,10 @@
+import { Signal } from '@angular/core';
+import { Texture } from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsCameraContent {
+    static ngTemplateContextGuard(_: NgtsCameraContent, ctx: unknown): ctx is {
+        $implicit: Signal<Texture>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCameraContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsCameraContent, "ng-template[cameraContent]", never, {}, {}, never, never, true, never>;
+}

package/cameras/lib/cube-camera.d.ts

@@ -0,0 +1,38 @@
+import { ElementRef, Injector, TemplateRef } from '@angular/core';
+import { NgtGroup } from 'angular-three';
+import { CubeCamera, Fog, FogExp2, Group, Texture, WebGLCubeRenderTarget } from 'three';
+import * as i0 from "@angular/core";
+export interface CubeCameraOptions {
+    /** Resolution of the FBO, 256 */
+    resolution?: number;
+    /** Camera near, 0.1 */
+    near?: number;
+    /** Camera far, 1000 */
+    far?: number;
+    /** Custom environment map that is temporarily set as the scenes background */
+    envMap?: Texture;
+    /** Custom fog that is temporarily set as the scenes fog */
+    fog?: Fog | FogExp2;
+}
+export declare function injectCubeCamera(options: () => CubeCameraOptions, { injector }?: {
+    injector?: Injector;
+}): {
+    fbo: import("@angular/core").Signal<WebGLCubeRenderTarget>;
+    camera: import("@angular/core").Signal<CubeCamera>;
+    update: import("@angular/core").Signal<() => void>;
+};
+export interface NgtsCubeCameraOptions extends Partial<NgtGroup>, CubeCameraOptions {
+    frames: number;
+}
+export declare class NgtsCubeCamera {
+    options: import("@angular/core").InputSignalWithTransform<NgtsCubeCameraOptions, "" | Partial<NgtsCubeCameraOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsCubeCameraOptions, "resolution" | "near" | "far" | "envMap" | "fog" | "frames">>;
+    private cubeCamera;
+    camera: import("@angular/core").Signal<CubeCamera>;
+    texture: import("@angular/core").Signal<import("three").CubeTexture>;
+    group: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    cameraContent: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCubeCamera, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCubeCamera, "ngts-cube-camera", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, ["cameraContent"], never, true, never>;
+}

package/cameras/lib/orthographic-camera.d.ts

@@ -0,0 +1,40 @@
+import { ElementRef, TemplateRef } from '@angular/core';
+import { NgtOrthographicCamera } from 'angular-three';
+import { Group, OrthographicCamera, Texture } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsOrthographicCameraOptions extends Partial<NgtOrthographicCamera> {
+    /** Registers the camera as the system default, fiber will start rendering with it */
+    makeDefault?: boolean;
+    /** Making it manual will stop responsiveness and you have to calculate aspect ratio yourself. */
+    manual?: boolean;
+    /** Number of frames to render, Infinity */
+    frames: number;
+    /** Resolution of the FBO, 256 */
+    resolution: number;
+    /** Optional environment map for functional use */
+    envMap?: Texture;
+}
+export declare class NgtsOrthographicCamera {
+    options: import("@angular/core").InputSignalWithTransform<NgtsOrthographicCameraOptions, "" | Partial<NgtsOrthographicCameraOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsOrthographicCameraOptions, "resolution" | "envMap" | "frames" | "left" | "right" | "top" | "bottom" | "makeDefault" | "manual">>;
+    content: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    cameraContent: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    cameraRef: import("@angular/core").Signal<ElementRef<OrthographicCamera>>;
+    groupRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    private autoEffect;
+    private store;
+    private camera;
+    size: import("@angular/core").Signal<import("angular-three").NgtSize>;
+    left: import("@angular/core").Signal<number>;
+    right: import("@angular/core").Signal<number>;
+    top: import("@angular/core").Signal<number>;
+    bottom: import("@angular/core").Signal<number>;
+    private manual;
+    private makeDefault;
+    private resolution;
+    private fbo;
+    texture: import("@angular/core").Signal<Texture>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsOrthographicCamera, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsOrthographicCamera, "ngts-orthographic-camera", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, ["content", "cameraContent"], never, true, never>;
+}