angular-three-soba 3.6.1 → 4.0.0-next.1

package/misc/lib/html/html.d.ts

@@ -1,30 +1,31 @@
 import { ElementRef } from '@angular/core';
-import { NgtGroup } from 'angular-three';
-import { Group, Mesh, Object3D, PlaneGeometry } from 'three';
+import { NgtThreeElements } from 'angular-three';
+import * as THREE from 'three';
+import { NgtsHTMLContent } from './html-content';
 import * as i0 from "@angular/core";
-export interface NgtsHTMLOptions extends Partial<NgtGroup> {
-    occlude: ElementRef<Object3D>[] | Object3D[] | boolean | 'raycast' | 'blending';
+export interface NgtsHTMLOptions extends Partial<NgtThreeElements['ngt-group']> {
+    occlude: ElementRef<THREE.Object3D>[] | THREE.Object3D[] | boolean | 'raycast' | 'blending';
     transform: boolean;
     castShadow: boolean;
     receiveShadow: boolean;
 }
 export declare class NgtsHTML {
     options: import("@angular/core").InputSignalWithTransform<NgtsHTMLOptions, "" | Partial<NgtsHTMLOptions>>;
-    parameters: import("@angular/core").Signal<Omit<NgtsHTMLOptions, "castShadow" | "receiveShadow" | "transform" | "occlude">>;
-    groupRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
-    occlusionMeshRef: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>> | undefined>;
-    occlusionGeometryRef: import("@angular/core").Signal<ElementRef<PlaneGeometry> | undefined>;
-    occlude: import("@angular/core").Signal<boolean | "raycast" | Object3D<import("three").Object3DEventMap>[] | ElementRef<Object3D<import("three").Object3DEventMap>>[] | "blending">;
+    protected parameters: import("@angular/core").Signal<Omit<NgtsHTMLOptions, "castShadow" | "receiveShadow" | "transform" | "occlude">>;
+    groupRef: import("@angular/core").Signal<ElementRef<THREE.Group<THREE.Object3DEventMap>>>;
+    occlusionMeshRef: import("@angular/core").Signal<ElementRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>> | undefined>;
+    occlusionGeometryRef: import("@angular/core").Signal<ElementRef<THREE.PlaneGeometry> | undefined>;
+    protected castShadow: import("@angular/core").Signal<boolean>;
+    protected receiveShadow: import("@angular/core").Signal<boolean>;
+    occlude: import("@angular/core").Signal<boolean | "raycast" | THREE.Object3D<THREE.Object3DEventMap>[] | ElementRef<THREE.Object3D<THREE.Object3DEventMap>>[] | "blending">;
     transform: import("@angular/core").Signal<boolean>;
-    castShadow: import("@angular/core").Signal<boolean>;
-    receiveShadow: import("@angular/core").Signal<boolean>;
-    scale: import("@angular/core").Signal<import("angular-three").NgtVector3 | undefined>;
     isRaycastOcclusion: import("@angular/core").Signal<boolean | 0>;
     private shaders;
-    vertexShader: import("@angular/core").Signal<string | undefined>;
-    fragmentShader: import("@angular/core").Signal<string>;
+    protected vertexShader: import("@angular/core").Signal<string | undefined>;
+    protected fragmentShader: import("@angular/core").Signal<string>;
     constructor();
     protected readonly DoubleSide: 2;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsHTML, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsHTML, "ngts-html", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["[data-occlusion-geometry]", "[data-occlusion-material]", "*"], true, never>;
 }
+export declare const NgtsHTMLDeclarations: readonly [typeof NgtsHTML, typeof NgtsHTMLContent];

package/misc/lib/html/utils.d.ts

@@ -1,14 +1,14 @@
-import { Camera, Matrix4, Object3D, Raycaster } from 'three';
-export declare function defaultCalculatePosition(el: Object3D, camera: Camera, size: {
+import * as THREE from 'three';
+export declare function defaultCalculatePosition(el: THREE.Object3D, camera: THREE.Camera, size: {
     width: number;
     height: number;
 }): number[];
 export type CalculatePosition = typeof defaultCalculatePosition;
-export declare function isObjectBehindCamera(el: Object3D, camera: Camera): boolean;
-export declare function isObjectVisible(el: Object3D, camera: Camera, raycaster: Raycaster, occlude: Object3D[]): boolean;
-export declare function objectScale(el: Object3D, camera: Camera): number;
-export declare function objectZIndex(el: Object3D, camera: Camera, zIndexRange: Array<number>): number | undefined;
+export declare function isObjectBehindCamera(el: THREE.Object3D, camera: THREE.Camera): boolean;
+export declare function isObjectVisible(el: THREE.Object3D, camera: THREE.Camera, raycaster: THREE.Raycaster, occlude: THREE.Object3D[]): boolean;
+export declare function objectScale(el: THREE.Object3D, camera: THREE.Camera): number;
+export declare function objectZIndex(el: THREE.Object3D, camera: THREE.Camera, zIndexRange: Array<number>): number | undefined;
 export declare function epsilon(value: number): number;
-export declare function getCSSMatrix(matrix: Matrix4, multipliers: number[], prepend?: string): string;
-export declare const getCameraCSSMatrix: (matrix: Matrix4) => string;
-export declare const getObjectCSSMatrix: (matrix: Matrix4, factor: number) => string;
+export declare function getCSSMatrix(matrix: THREE.Matrix4, multipliers: number[], prepend?: string): string;
+export declare const getCameraCSSMatrix: (matrix: THREE.Matrix4) => string;
+export declare const getObjectCSSMatrix: (matrix: THREE.Matrix4, factor: number) => string;

package/misc/lib/intersect.d.ts

@@ -1,7 +1,7 @@
 import { ElementRef, Injector, WritableSignal } from '@angular/core';
-import { Object3D } from 'three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export declare function injectIntersect<TObject extends Object3D>(object: () => ElementRef<TObject> | TObject | undefined | null, { injector, source }?: {
+export declare function injectIntersect<TObject extends THREE.Object3D>(object: () => ElementRef<TObject> | TObject | undefined | null, { injector, source }?: {
     injector?: Injector;
     source?: WritableSignal<boolean>;
 }): import("@angular/core").Signal<boolean>;

package/misc/lib/preload.d.ts

@@ -1,14 +1,11 @@
 import { ElementRef } from '@angular/core';
-import { Camera, Object3D } from 'three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
 export declare class NgtsPreload {
     all: import("@angular/core").ModelSignal<boolean | undefined>;
-    scene: import("@angular/core").ModelSignal<Object3D<import("three").Object3DEventMap> | ElementRef<Object3D<import("three").Object3DEventMap>> | undefined>;
-    camera: import("@angular/core").ModelSignal<Camera | ElementRef<Camera> | undefined>;
+    scene: import("@angular/core").ModelSignal<THREE.Object3D<THREE.Object3DEventMap> | ElementRef<THREE.Object3D<THREE.Object3DEventMap>> | undefined>;
+    camera: import("@angular/core").ModelSignal<THREE.Camera | ElementRef<THREE.Camera> | undefined>;
     private store;
-    private gl;
-    private defaultScene;
-    private defaultCamera;
     private trueScene;
     private trueCamera;
     constructor();

package/misc/lib/sampler.d.ts

@@ -1,20 +1,20 @@
-import { ElementRef, Injector } from '@angular/core';
-import { NgtGroup } from 'angular-three';
-import { BufferGeometry, Color, Group, InstancedBufferAttribute, InstancedMesh, Mesh, Object3D, Vector3 } from 'three';
+import { ElementRef } from '@angular/core';
+import { NgtThreeElements } from 'angular-three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
 interface SamplePayload {
     /**
      * The position of the sample.
      */
-    position: Vector3;
+    position: THREE.Vector3;
     /**
      * The normal of the mesh at the sampled position.
      */
-    normal: Vector3;
+    normal: THREE.Vector3;
     /**
      * The vertex color of the mesh at the sampled position.
      */
-    color: Color;
+    color: THREE.Color;
 }
 export type TransformFn = (payload: TransformPayload, i: number) => void;
 interface TransformPayload extends SamplePayload {
@@ -23,23 +23,21 @@ interface TransformPayload extends SamplePayload {
      * This object's matrix will be updated after transforming & it will be used
      * to set the instance's matrix.
      */
-    dummy: Object3D;
+    dummy: THREE.Object3D;
     /**
      * The mesh that's initially passed to the sampler.
      * Use this if you need to apply transforms from your mesh to your instances
      * or if you need to grab attributes from the geometry.
      */
-    sampledMesh: Mesh;
+    sampledMesh: THREE.Mesh;
 }
-export declare function injectSurfaceSampler(mesh: () => ElementRef<Mesh> | Mesh | null | undefined, options?: () => {
-    count?: number;
-    transform?: TransformFn;
-    weight?: string;
-    instanceMesh?: ElementRef<InstancedMesh> | InstancedMesh | null;
-}, { injector }?: {
-    injector?: Injector;
-}): import("@angular/core").Signal<InstancedBufferAttribute>;
-export interface NgtsSamplerOptions extends Partial<NgtGroup> {
+export declare function surfaceSampler(mesh: () => ElementRef<THREE.Mesh> | THREE.Mesh | null | undefined, { count, transform, weight, instancedMesh, }?: {
+    count?: () => number;
+    transform?: () => TransformFn | undefined;
+    weight?: () => string | undefined;
+    instancedMesh?: () => ElementRef<THREE.InstancedMesh> | THREE.InstancedMesh | null | undefined;
+}): import("@angular/core").Signal<THREE.InstancedBufferAttribute>;
+export interface NgtsSamplerOptions extends Partial<NgtThreeElements['ngt-group']> {
     /**
      * The NAME of the weight attribute to use when sampling.
      *
@@ -59,11 +57,14 @@ export interface NgtsSamplerOptions extends Partial<NgtGroup> {
     count: number;
 }
 export declare class NgtsSampler {
-    mesh: import("@angular/core").InputSignal<Mesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> | ElementRef<Mesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>> | null>;
-    instances: import("@angular/core").InputSignal<InstancedMesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").InstancedMeshEventMap> | ElementRef<InstancedMesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").InstancedMeshEventMap>> | null>;
+    mesh: import("@angular/core").InputSignal<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap> | ElementRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>> | null>;
+    instances: import("@angular/core").InputSignal<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.InstancedMeshEventMap> | ElementRef<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.InstancedMeshEventMap>> | null>;
     options: import("@angular/core").InputSignalWithTransform<NgtsSamplerOptions, "" | Partial<NgtsSamplerOptions>>;
-    parameters: import("@angular/core").Signal<Omit<NgtsSamplerOptions, "count" | "transform" | "weight">>;
-    groupRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>> | undefined>;
+    protected parameters: import("@angular/core").Signal<Omit<NgtsSamplerOptions, "count" | "transform" | "weight">>;
+    groupRef: import("@angular/core").Signal<ElementRef<THREE.Group<THREE.Object3DEventMap>>>;
+    private count;
+    private weight;
+    private transform;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSampler, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSampler, "ngts-sampler", never, { "mesh": { "alias": "mesh"; "required": false; "isSignal": true; }; "instances": { "alias": "instances"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;

package/misc/lib/scale-factor.d.ts

@@ -1,3 +1,3 @@
 import { NgtSize } from 'angular-three';
-import { Camera, Vector3 } from 'three';
-export declare function calculateScaleFactor(point3: Vector3, radiusPx: number, camera: Camera, size: NgtSize): number;
+import * as THREE from 'three';
+export declare function calculateScaleFactor(point3: THREE.Vector3, radiusPx: number, camera: THREE.Camera, size: NgtSize): number;

package/package.json

@@ -1,142 +1,142 @@
 {
-  "name": "angular-three-soba",
-  "version": "3.6.1",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/angular-threejs/angular-three/tree/main/libs/soba"
-  },
-  "author": {
-    "name": "Chau Tran",
-    "email": "nartc7789@gmail.com",
-    "url": "https://nartc.me"
-  },
-  "description": "Utilities for Angular Three",
-  "keywords": [
-    "angular",
-    "threejs",
-    "renderer",
-    "utilities",
-    "shaders"
-  ],
-  "license": "MIT",
-  "exports": {
-    "./assets/*": "./assets/*",
-    "./shaders": {
-      "default": "./fesm2022/angular-three-soba-shaders.mjs",
-      "types": "./shaders/index.d.ts"
-    },
-    "./misc": {
-      "default": "./fesm2022/angular-three-soba-misc.mjs",
-      "types": "./misc/index.d.ts"
-    },
-    "./vanilla-exports": {
-      "default": "./fesm2022/angular-three-soba-vanilla-exports.mjs",
-      "types": "./vanilla-exports/index.d.ts"
-    },
-    "./loaders": {
-      "default": "./fesm2022/angular-three-soba-loaders.mjs",
-      "types": "./loaders/index.d.ts"
-    },
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "default": "./fesm2022/angular-three-soba.mjs"
-    },
-    "./abstractions": {
-      "types": "./abstractions/index.d.ts",
-      "default": "./fesm2022/angular-three-soba-abstractions.mjs"
-    },
-    "./cameras": {
-      "types": "./cameras/index.d.ts",
-      "default": "./fesm2022/angular-three-soba-cameras.mjs"
-    },
-    "./gizmos": {
-      "types": "./gizmos/index.d.ts",
-      "default": "./fesm2022/angular-three-soba-gizmos.mjs"
-    },
-    "./controls": {
-      "types": "./controls/index.d.ts",
-      "default": "./fesm2022/angular-three-soba-controls.mjs"
-    },
-    "./materials": {
-      "types": "./materials/index.d.ts",
-      "default": "./fesm2022/angular-three-soba-materials.mjs"
-    },
-    "./performances": {
-      "types": "./performances/index.d.ts",
-      "default": "./fesm2022/angular-three-soba-performances.mjs"
-    },
-    "./staging": {
-      "types": "./staging/index.d.ts",
-      "default": "./fesm2022/angular-three-soba-staging.mjs"
-    },
-    "./stats": {
-      "types": "./stats/index.d.ts",
-      "default": "./fesm2022/angular-three-soba-stats.mjs"
-    }
-  },
-  "peerDependencies": {
-    "@angular/common": ">=19.0.0 <20.0.0",
-    "@angular/core": ">=19.0.0 <20.0.0",
-    "@monogrid/gainmap-js": "^3.0.0",
-    "@pmndrs/vanilla": "^1.19.0",
-    "camera-controls": "^2.8.0",
-    "hls.js": "^1.5.0",
-    "maath": ">=0.10.0 <0.11.0",
-    "meshline": "^3.1.0",
-    "stats-gl": ">=2.0.0",
-    "three": ">=0.148.0 <0.173.0",
-    "three-custom-shader-material": ">=5.5.0 <6.3.0",
-    "three-mesh-bvh": ">=0.5.0 <0.9.0",
-    "three-stdlib": "^2.0.0",
-    "troika-three-text": ">=0.47.0 <0.53.0"
-  },
-  "peerDependenciesMeta": {
-    "@monogrid/gainmap-js": {
-      "optional": true
-    },
-    "@pmndrs/vanilla": {
-      "optional": true
-    },
-    "hls.js": {
-      "optional": true
-    },
-    "troika-three-text": {
-      "optional": true
-    },
-    "three-custom-shader-material": {
-      "optional": true
-    },
-    "three-mesh-bvh": {
-      "optional": true
-    },
-    "maath": {
-      "optional": true
-    },
-    "meshline": {
-      "optional": true
-    },
-    "camera-controls": {
-      "optional": true
-    },
-    "stats-gl": {
-      "optional": true
-    }
-  },
-  "dependencies": {
-    "tslib": "^2.3.0"
-  },
-  "sideEffects": false,
-  "web-types": [
-    "../../node_modules/angular-three/web-types.json",
-    "../../node_modules/angular-three-soba/web-types.json",
-    "./web-types.json"
-  ],
-  "module": "fesm2022/angular-three-soba.mjs",
-  "typings": "index.d.ts"
-}
+	"name": "angular-three-soba",
+	"version": "4.0.0-next.1",
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/angular-threejs/angular-three/tree/main/libs/soba"
+	},
+	"author": {
+		"name": "Chau Tran",
+		"email": "nartc7789@gmail.com",
+		"url": "https://nartc.me"
+	},
+	"description": "Utilities for Angular Three",
+	"keywords": [
+		"angular",
+		"threejs",
+		"renderer",
+		"utilities",
+		"shaders"
+	],
+	"license": "MIT",
+	"exports": {
+		"./assets/*": "./assets/*",
+		"./package.json": {
+			"default": "./package.json"
+		},
+		".": {
+			"types": "./index.d.ts",
+			"default": "./fesm2022/angular-three-soba.mjs"
+		},
+		"./abstractions": {
+			"types": "./abstractions/index.d.ts",
+			"default": "./fesm2022/angular-three-soba-abstractions.mjs"
+		},
+		"./cameras": {
+			"types": "./cameras/index.d.ts",
+			"default": "./fesm2022/angular-three-soba-cameras.mjs"
+		},
+		"./controls": {
+			"types": "./controls/index.d.ts",
+			"default": "./fesm2022/angular-three-soba-controls.mjs"
+		},
+		"./loaders": {
+			"types": "./loaders/index.d.ts",
+			"default": "./fesm2022/angular-three-soba-loaders.mjs"
+		},
+		"./materials": {
+			"types": "./materials/index.d.ts",
+			"default": "./fesm2022/angular-three-soba-materials.mjs"
+		},
+		"./misc": {
+			"types": "./misc/index.d.ts",
+			"default": "./fesm2022/angular-three-soba-misc.mjs"
+		},
+		"./gizmos": {
+			"types": "./gizmos/index.d.ts",
+			"default": "./fesm2022/angular-three-soba-gizmos.mjs"
+		},
+		"./performances": {
+			"types": "./performances/index.d.ts",
+			"default": "./fesm2022/angular-three-soba-performances.mjs"
+		},
+		"./shaders": {
+			"types": "./shaders/index.d.ts",
+			"default": "./fesm2022/angular-three-soba-shaders.mjs"
+		},
+		"./staging": {
+			"types": "./staging/index.d.ts",
+			"default": "./fesm2022/angular-three-soba-staging.mjs"
+		},
+		"./stats": {
+			"types": "./stats/index.d.ts",
+			"default": "./fesm2022/angular-three-soba-stats.mjs"
+		},
+		"./vanilla-exports": {
+			"types": "./vanilla-exports/index.d.ts",
+			"default": "./fesm2022/angular-three-soba-vanilla-exports.mjs"
+		}
+	},
+	"peerDependencies": {
+		"@angular/common": ">=19.0.0 <20.0.0",
+		"@angular/core": ">=19.0.0 <20.0.0",
+		"@monogrid/gainmap-js": "^3.0.0",
+		"@pmndrs/vanilla": "^1.19.0",
+		"camera-controls": "^2.8.0",
+		"hls.js": "^1.5.0",
+		"maath": ">=0.10.0 <0.11.0",
+		"meshline": "^3.1.0",
+		"stats-gl": ">=2.0.0",
+		"three": ">=0.148.0 <0.173.0",
+		"three-custom-shader-material": ">=5.5.0 <6.3.0",
+		"three-mesh-bvh": ">=0.5.0 <0.9.0",
+		"three-stdlib": "^2.0.0",
+		"troika-three-text": ">=0.47.0 <0.53.0"
+	},
+	"peerDependenciesMeta": {
+		"@monogrid/gainmap-js": {
+			"optional": true
+		},
+		"@pmndrs/vanilla": {
+			"optional": true
+		},
+		"hls.js": {
+			"optional": true
+		},
+		"troika-three-text": {
+			"optional": true
+		},
+		"three-custom-shader-material": {
+			"optional": true
+		},
+		"three-mesh-bvh": {
+			"optional": true
+		},
+		"maath": {
+			"optional": true
+		},
+		"meshline": {
+			"optional": true
+		},
+		"camera-controls": {
+			"optional": true
+		},
+		"stats-gl": {
+			"optional": true
+		}
+	},
+	"dependencies": {
+		"tslib": "^2.3.0"
+	},
+	"sideEffects": false,
+	"web-types": [
+		"../../node_modules/angular-three/web-types.json",
+		"../../node_modules/angular-three-soba/web-types.json",
+		"./web-types.json"
+	],
+	"module": "fesm2022/angular-three-soba.mjs",
+	"typings": "index.d.ts"
+}

package/performances/lib/detailed.d.ts

@@ -1,15 +1,15 @@
 import { ElementRef } from '@angular/core';
-import { NgtLOD } from 'angular-three';
-import { LOD } from 'three';
+import { NgtThreeElements } from 'angular-three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export interface NgtsDetailedOptions extends Partial<NgtLOD> {
+export interface NgtsDetailedOptions extends Partial<NgtThreeElements['ngt-lOD']> {
     hysteresis: number;
 }
 export declare class NgtsDetailed {
     distances: import("@angular/core").InputSignal<number[]>;
     options: import("@angular/core").InputSignalWithTransform<NgtsDetailedOptions, "" | Partial<NgtsDetailedOptions>>;
-    parameters: import("@angular/core").Signal<Omit<NgtsDetailedOptions, "hysteresis">>;
-    lodRef: import("@angular/core").Signal<ElementRef<LOD<import("three").Object3DEventMap>>>;
+    protected parameters: import("@angular/core").Signal<Omit<NgtsDetailedOptions, "hysteresis">>;
+    lodRef: import("@angular/core").Signal<ElementRef<THREE.LOD<THREE.Object3DEventMap>>>;
     private hysteresis;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsDetailed, never>;

package/performances/lib/instances/instances.d.ts

@@ -1,105 +1,17 @@
 import { ElementRef } from '@angular/core';
-import { NgtInstancedMesh } from 'angular-three';
-import { InstancedMesh, Matrix4, Quaternion, Vector3 } from 'three';
-import { PositionMesh } from './position-mesh';
+import { NgtThreeElements } from 'angular-three';
+import * as THREE from 'three';
+import { NgtPositionMesh, PositionMesh } from './position-mesh';
 import * as i0 from "@angular/core";
 export declare class NgtsInstance {
-    options: import("@angular/core").InputSignal<Partial<{
-        addEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<PositionMesh>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<PositionMesh, typeof PositionMesh>, ev: import("angular-three").NgtNodeEventMap<PositionMesh>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
-        removeEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<PositionMesh>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<PositionMesh, typeof PositionMesh>, ev: import("angular-three").NgtNodeEventMap<PositionMesh>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
-        attach: string | string[] | import("angular-three").NgtAttachFunction;
-        __ngt_args__: [];
-        readonly type?: string | undefined;
-        toJSON?: ((meta?: import("three").JSONMeta) => import("three").Object3DJSON) | 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?: Matrix4 | undefined;
-        readonly normalMatrix?: import("three").Matrix3 | undefined;
-        matrixWorld?: 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, camera: import("three").Camera, 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, camera: import("three").Camera, 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: Matrix4) => void) | undefined;
-        applyQuaternion?: ((quaternion: Quaternion) => PositionMesh) | undefined;
-        setRotationFromAxisAngle?: ((axis: Vector3, angle: number) => void) | undefined;
-        setRotationFromEuler?: ((euler: import("three").Euler) => void) | undefined;
-        setRotationFromMatrix?: ((m: Matrix4) => void) | undefined;
-        setRotationFromQuaternion?: ((q: Quaternion) => void) | undefined;
-        rotateOnAxis?: ((axis: Vector3, angle: number) => PositionMesh) | undefined;
-        rotateOnWorldAxis?: ((axis: Vector3, angle: number) => PositionMesh) | undefined;
-        rotateX?: ((angle: number) => PositionMesh) | undefined;
-        rotateY?: ((angle: number) => PositionMesh) | undefined;
-        rotateZ?: ((angle: number) => PositionMesh) | undefined;
-        translateOnAxis?: ((axis: Vector3, distance: number) => PositionMesh) | undefined;
-        translateX?: ((distance: number) => PositionMesh) | undefined;
-        translateY?: ((distance: number) => PositionMesh) | undefined;
-        translateZ?: ((distance: number) => PositionMesh) | undefined;
-        localToWorld?: ((vector: Vector3) => Vector3) | undefined;
-        worldToLocal?: ((vector: Vector3) => Vector3) | undefined;
-        lookAt?: {
-            (vector: Vector3): void;
-            (x: number, y: number, z: number): void;
-        } | undefined;
-        add?: ((...object: import("three").Object3D[]) => PositionMesh) | undefined;
-        remove?: ((...object: import("three").Object3D[]) => PositionMesh) | undefined;
-        removeFromParent?: (() => PositionMesh) | undefined;
-        clear?: (() => PositionMesh) | 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: Vector3) => Vector3) | undefined;
-        getWorldQuaternion?: ((target: Quaternion) => Quaternion) | undefined;
-        getWorldScale?: ((target: Vector3) => Vector3) | undefined;
-        getWorldDirection?: ((target: Vector3) => Vector3) | 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;
-        clone?: ((recursive?: boolean) => PositionMesh) | undefined;
-        copy?: ((object: import("three").Object3D, recursive?: boolean) => PositionMesh) | undefined;
-        hasEventListener?: (<T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, PositionMesh>) => boolean) | undefined;
-        dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
-        color?: import("three").ColorRepresentation | undefined;
-        instance?: ElementRef<InstancedMesh> | InstancedMesh | null | undefined;
-        readonly geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined;
-        readonly isGroup?: true | 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;
-        raycast: import("three").Object3D["raycast"] | null;
-    }>>;
-    instances: NgtsInstances;
+    options: import("@angular/core").InputSignal<Partial<NgtPositionMesh>>;
+    protected instances: NgtsInstances;
     positionMeshRef: import("@angular/core").Signal<ElementRef<PositionMesh>>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsInstance, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsInstance, "ngts-instance", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
-export interface NgtsInstancesOptions extends Partial<NgtInstancedMesh> {
+export interface NgtsInstancesOptions extends Partial<NgtThreeElements['ngt-instanced-mesh']> {
     range?: number;
     limit: number;
     frames: number;
@@ -107,8 +19,8 @@ export interface NgtsInstancesOptions extends Partial<NgtInstancedMesh> {
 export declare class NgtsInstances {
     protected readonly DynamicDrawUsage: 35048;
     options: import("@angular/core").InputSignalWithTransform<NgtsInstancesOptions, "" | Partial<NgtsInstancesOptions>>;
-    protected parameters: import("@angular/core").Signal<Omit<NgtsInstancesOptions, "frames" | "range" | "limit">>;
-    instancedMeshRef: import("@angular/core").Signal<ElementRef<InstancedMesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").InstancedMeshEventMap>>>;
+    protected parameters: import("@angular/core").Signal<Omit<NgtsInstancesOptions, "limit" | "range" | "frames">>;
+    instancedMeshRef: import("@angular/core").Signal<ElementRef<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.InstancedMeshEventMap>>>;
     private limit;
     protected buffers: import("@angular/core").Signal<{
         matrices: Float32Array;