angular-three-soba 2.0.0-beta.8 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-three-soba",
-  "version": "2.0.0-beta.8",
+  "version": "2.0.0",
   "publishConfig": {
     "access": "public"
   },
@@ -24,6 +24,30 @@
   "license": "MIT",
   "exports": {
     "./assets/*": "./assets/*",
+    "./shaders": {
+      "default": "./fesm2022/angular-three-soba-shaders.mjs",
+      "types": "./shaders/index.d.ts",
+      "esm2022": "./esm2022/shaders/angular-three-soba-shaders.mjs",
+      "esm": "./esm2022/shaders/angular-three-soba-shaders.mjs"
+    },
+    "./misc": {
+      "default": "./fesm2022/angular-three-soba-misc.mjs",
+      "types": "./misc/index.d.ts",
+      "esm2022": "./esm2022/misc/angular-three-soba-misc.mjs",
+      "esm": "./esm2022/misc/angular-three-soba-misc.mjs"
+    },
+    "./vanilla-exports": {
+      "default": "./fesm2022/angular-three-soba-vanilla-exports.mjs",
+      "types": "./vanilla-exports/index.d.ts",
+      "esm2022": "./esm2022/vanilla-exports/angular-three-soba-vanilla-exports.mjs",
+      "esm": "./esm2022/vanilla-exports/angular-three-soba-vanilla-exports.mjs"
+    },
+    "./loaders": {
+      "default": "./fesm2022/angular-three-soba-loaders.mjs",
+      "types": "./loaders/index.d.ts",
+      "esm2022": "./esm2022/loaders/angular-three-soba-loaders.mjs",
+      "esm": "./esm2022/loaders/angular-three-soba-loaders.mjs"
+    },
     "./package.json": {
       "default": "./package.json"
     },
@@ -33,35 +57,17 @@
       "esm": "./esm2022/angular-three-soba.mjs",
       "default": "./fesm2022/angular-three-soba.mjs"
     },
-    "./abstractions": {
-      "types": "./abstractions/index.d.ts",
-      "esm2022": "./esm2022/abstractions/angular-three-soba-abstractions.mjs",
-      "esm": "./esm2022/abstractions/angular-three-soba-abstractions.mjs",
-      "default": "./fesm2022/angular-three-soba-abstractions.mjs"
-    },
     "./cameras": {
       "types": "./cameras/index.d.ts",
       "esm2022": "./esm2022/cameras/angular-three-soba-cameras.mjs",
       "esm": "./esm2022/cameras/angular-three-soba-cameras.mjs",
       "default": "./fesm2022/angular-three-soba-cameras.mjs"
     },
-    "./controls": {
-      "types": "./controls/index.d.ts",
-      "esm2022": "./esm2022/controls/angular-three-soba-controls.mjs",
-      "esm": "./esm2022/controls/angular-three-soba-controls.mjs",
-      "default": "./fesm2022/angular-three-soba-controls.mjs"
-    },
-    "./loaders": {
-      "types": "./loaders/index.d.ts",
-      "esm2022": "./esm2022/loaders/angular-three-soba-loaders.mjs",
-      "esm": "./esm2022/loaders/angular-three-soba-loaders.mjs",
-      "default": "./fesm2022/angular-three-soba-loaders.mjs"
-    },
-    "./misc": {
-      "types": "./misc/index.d.ts",
-      "esm2022": "./esm2022/misc/angular-three-soba-misc.mjs",
-      "esm": "./esm2022/misc/angular-three-soba-misc.mjs",
-      "default": "./fesm2022/angular-three-soba-misc.mjs"
+    "./abstractions": {
+      "types": "./abstractions/index.d.ts",
+      "esm2022": "./esm2022/abstractions/angular-three-soba-abstractions.mjs",
+      "esm": "./esm2022/abstractions/angular-three-soba-abstractions.mjs",
+      "default": "./fesm2022/angular-three-soba-abstractions.mjs"
     },
     "./materials": {
       "types": "./materials/index.d.ts",
@@ -69,23 +75,17 @@
       "esm": "./esm2022/materials/angular-three-soba-materials.mjs",
       "default": "./fesm2022/angular-three-soba-materials.mjs"
     },
-    "./modifiers": {
-      "types": "./modifiers/index.d.ts",
-      "esm2022": "./esm2022/modifiers/angular-three-soba-modifiers.mjs",
-      "esm": "./esm2022/modifiers/angular-three-soba-modifiers.mjs",
-      "default": "./fesm2022/angular-three-soba-modifiers.mjs"
-    },
     "./performances": {
       "types": "./performances/index.d.ts",
       "esm2022": "./esm2022/performances/angular-three-soba-performances.mjs",
       "esm": "./esm2022/performances/angular-three-soba-performances.mjs",
       "default": "./fesm2022/angular-three-soba-performances.mjs"
     },
-    "./shaders": {
-      "types": "./shaders/index.d.ts",
-      "esm2022": "./esm2022/shaders/angular-three-soba-shaders.mjs",
-      "esm": "./esm2022/shaders/angular-three-soba-shaders.mjs",
-      "default": "./fesm2022/angular-three-soba-shaders.mjs"
+    "./controls": {
+      "types": "./controls/index.d.ts",
+      "esm2022": "./esm2022/controls/angular-three-soba-controls.mjs",
+      "esm": "./esm2022/controls/angular-three-soba-controls.mjs",
+      "default": "./fesm2022/angular-three-soba-controls.mjs"
     },
     "./staging": {
       "types": "./staging/index.d.ts",
@@ -93,29 +93,70 @@
       "esm": "./esm2022/staging/angular-three-soba-staging.mjs",
       "default": "./fesm2022/angular-three-soba-staging.mjs"
     },
-    "./utils": {
-      "types": "./utils/index.d.ts",
-      "esm2022": "./esm2022/utils/angular-three-soba-utils.mjs",
-      "esm": "./esm2022/utils/angular-three-soba-utils.mjs",
-      "default": "./fesm2022/angular-three-soba-utils.mjs"
+    "./stats": {
+      "types": "./stats/index.d.ts",
+      "esm2022": "./esm2022/stats/angular-three-soba-stats.mjs",
+      "esm": "./esm2022/stats/angular-three-soba-stats.mjs",
+      "default": "./fesm2022/angular-three-soba-stats.mjs"
     }
   },
   "peerDependencies": {
-    "@angular/common": "^16.0.0",
-    "@angular/core": "^16.0.0",
-    "angular-three": "^2.0.0",
+    "@angular/common": ">=18.0.0 <19.0.0",
+    "@angular/core": ">=18.0.0 <19.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": "^1.0.0",
-    "stats.js": "^0.17.0",
-    "three": ">=0.148.0",
-    "three-mesh-bvh": "^0.5.0 || ^0.6.0",
+    "stats-gl": "^2.0.0",
+    "three": ">=0.148.0 <0.169.0",
+    "three-custom-shader-material": "^5.4.0",
+    "three-mesh-bvh": ">=0.5.0 <0.8.0",
     "three-stdlib": "^2.0.0",
-    "troika-three-text": "^0.47.0"
+    "troika-three-text": ">=0.47.0 <0.50.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/index.d.ts

@@ -1,5 +1,6 @@
-export * from './adaptive-dpr/adaptive-dpr';
-export * from './adaptive-events/adaptive-events';
-export * from './points/points';
-export * from './segments/segment-object';
-export * from './segments/segments';
+export * from './lib/adaptive-dpr';
+export * from './lib/adaptive-events';
+export * from './lib/detailed';
+export * from './lib/instances/instances';
+export * from './lib/points/points';
+export * from './lib/segments/segments';

package/performances/lib/adaptive-dpr.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class NgtsAdaptiveDpr {
+    pixelated: import("@angular/core").InputSignal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAdaptiveDpr, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsAdaptiveDpr, "ngts-adaptive-dpr", never, { "pixelated": { "alias": "pixelated"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/performances/{adaptive-events → lib}/adaptive-events.d.ts

@@ -1,8 +1,5 @@
 import * as i0 from "@angular/core";
 export declare class NgtsAdaptiveEvents {
-    private store;
-    private setEvents;
-    private current;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAdaptiveEvents, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsAdaptiveEvents, "ngts-adaptive-events", never, {}, {}, never, never, true, never>;

package/performances/lib/detailed.d.ts

@@ -0,0 +1,17 @@
+import { ElementRef } from '@angular/core';
+import { NgtLOD } from 'angular-three';
+import { LOD } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsDetailedOptions extends Partial<NgtLOD> {
+    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>>>;
+    private hysteresis;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsDetailed, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsDetailed, "ngts-detailed", never, { "distances": { "alias": "distances"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,122 @@
+import { ElementRef } from '@angular/core';
+import { NgtInstancedMesh } from 'angular-three';
+import { InstancedMesh, Matrix4, Quaternion, Vector3 } from 'three';
+import { PositionMesh } from './position-mesh';
+import * as i0 from "@angular/core";
+export declare class NgtsInstance {
+    options: import("@angular/core").InputSignal<Partial<{
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        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);
+        __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;
+    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> {
+    range?: number;
+    limit: number;
+    frames: number;
+}
+export declare class NgtsInstances {
+    protected readonly DynamicDrawUsage: 35048;
+    options: import("@angular/core").InputSignalWithTransform<NgtsInstancesOptions, "" | Partial<NgtsInstancesOptions>>;
+    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>>>;
+    limit: import("@angular/core").Signal<number>;
+    buffers: import("@angular/core").Signal<{
+        matrices: Float32Array;
+        colors: Float32Array;
+    }>;
+    instances: Array<ElementRef<PositionMesh> | PositionMesh>;
+    constructor();
+    subscribe(ref: ElementRef<PositionMesh> | PositionMesh): () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsInstances, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsInstances, "ngts-instances", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/performances/lib/instances/position-mesh.d.ts

@@ -0,0 +1,20 @@
+import { ElementRef } from '@angular/core';
+import { NgtObject3DNode } from 'angular-three';
+import { BufferGeometry, Color, Group, InstancedMesh, Intersection, Raycaster } from 'three';
+export type NgtPositionMesh = NgtObject3DNode<PositionMesh, typeof PositionMesh>;
+export declare class PositionMesh extends Group {
+    color: Color;
+    instance: ElementRef<InstancedMesh> | InstancedMesh | null | undefined;
+    constructor();
+    get geometry(): BufferGeometry<import("three").NormalBufferAttributes> | undefined;
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-group
+         * @rawOptions instance|color
+         */
+        'ngt-position-mesh': NgtPositionMesh;
+    }
+}

package/performances/lib/points/points.d.ts

@@ -0,0 +1,224 @@
+import { ElementRef } from '@angular/core';
+import { NgtPoints } from 'angular-three';
+import { BufferGeometry, Matrix4, Points, Vector3 } from 'three';
+import { PositionPoint } from './position-point';
+import * as i0 from "@angular/core";
+export declare class NgtsPoint {
+    options: import("@angular/core").InputSignal<Partial<{
+        size?: number | undefined;
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        addEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<PositionPoint>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<PositionPoint, typeof PositionPoint>, ev: import("angular-three").NgtNodeEventMap<PositionPoint>[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<PositionPoint>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<PositionPoint, typeof PositionPoint>, ev: import("angular-three").NgtNodeEventMap<PositionPoint>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
+        __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: 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: 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: 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: BufferGeometry, material: import("three").Material, group: import("three").Group) => void) | undefined;
+        applyMatrix4?: ((matrix: Matrix4) => void) | undefined;
+        applyQuaternion?: ((quaternion: import("three").Quaternion) => PositionPoint) | undefined;
+        setRotationFromAxisAngle?: ((axis: Vector3, angle: number) => void) | undefined;
+        setRotationFromEuler?: ((euler: import("three").Euler) => void) | undefined;
+        setRotationFromMatrix?: ((m: Matrix4) => void) | undefined;
+        setRotationFromQuaternion?: ((q: import("three").Quaternion) => void) | undefined;
+        rotateOnAxis?: ((axis: Vector3, angle: number) => PositionPoint) | undefined;
+        rotateOnWorldAxis?: ((axis: Vector3, angle: number) => PositionPoint) | undefined;
+        rotateX?: ((angle: number) => PositionPoint) | undefined;
+        rotateY?: ((angle: number) => PositionPoint) | undefined;
+        rotateZ?: ((angle: number) => PositionPoint) | undefined;
+        translateOnAxis?: ((axis: Vector3, distance: number) => PositionPoint) | undefined;
+        translateX?: ((distance: number) => PositionPoint) | undefined;
+        translateY?: ((distance: number) => PositionPoint) | undefined;
+        translateZ?: ((distance: number) => PositionPoint) | 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[]) => PositionPoint) | undefined;
+        remove?: ((...object: import("three").Object3D[]) => PositionPoint) | undefined;
+        removeFromParent?: (() => PositionPoint) | undefined;
+        clear?: (() => PositionPoint) | 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: import("three").Quaternion) => import("three").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) => PositionPoint) | undefined;
+        copy?: ((object: import("three").Object3D, recursive?: boolean) => PositionPoint) | undefined;
+        hasEventListener?: (<T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, PositionPoint>) => 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<Points> | Points | null | undefined;
+        readonly geometry?: 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;
+    }>>;
+    positionPointRef: import("@angular/core").Signal<ElementRef<PositionPoint>>;
+    points: NgtsPointsInstances;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPoint, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPoint, "ngts-point", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+export declare class NgtsPointsBuffer {
+    positions: import("@angular/core").InputSignal<Float32Array>;
+    colors: import("@angular/core").InputSignal<Float32Array | undefined>;
+    sizes: import("@angular/core").InputSignal<Float32Array | undefined>;
+    stride: import("@angular/core").InputSignal<2 | 3>;
+    options: import("@angular/core").InputSignal<Partial<{
+        size?: number | undefined;
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        addEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<PositionPoint>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<PositionPoint, typeof PositionPoint>, ev: import("angular-three").NgtNodeEventMap<PositionPoint>[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<PositionPoint>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<PositionPoint, typeof PositionPoint>, ev: import("angular-three").NgtNodeEventMap<PositionPoint>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
+        __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: 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: 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: 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: BufferGeometry, material: import("three").Material, group: import("three").Group) => void) | undefined;
+        applyMatrix4?: ((matrix: Matrix4) => void) | undefined;
+        applyQuaternion?: ((quaternion: import("three").Quaternion) => PositionPoint) | undefined;
+        setRotationFromAxisAngle?: ((axis: Vector3, angle: number) => void) | undefined;
+        setRotationFromEuler?: ((euler: import("three").Euler) => void) | undefined;
+        setRotationFromMatrix?: ((m: Matrix4) => void) | undefined;
+        setRotationFromQuaternion?: ((q: import("three").Quaternion) => void) | undefined;
+        rotateOnAxis?: ((axis: Vector3, angle: number) => PositionPoint) | undefined;
+        rotateOnWorldAxis?: ((axis: Vector3, angle: number) => PositionPoint) | undefined;
+        rotateX?: ((angle: number) => PositionPoint) | undefined;
+        rotateY?: ((angle: number) => PositionPoint) | undefined;
+        rotateZ?: ((angle: number) => PositionPoint) | undefined;
+        translateOnAxis?: ((axis: Vector3, distance: number) => PositionPoint) | undefined;
+        translateX?: ((distance: number) => PositionPoint) | undefined;
+        translateY?: ((distance: number) => PositionPoint) | undefined;
+        translateZ?: ((distance: number) => PositionPoint) | 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[]) => PositionPoint) | undefined;
+        remove?: ((...object: import("three").Object3D[]) => PositionPoint) | undefined;
+        removeFromParent?: (() => PositionPoint) | undefined;
+        clear?: (() => PositionPoint) | 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: import("three").Quaternion) => import("three").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) => PositionPoint) | undefined;
+        copy?: ((object: import("three").Object3D, recursive?: boolean) => PositionPoint) | undefined;
+        hasEventListener?: (<T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, PositionPoint>) => 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<Points> | Points | null | undefined;
+        readonly geometry?: 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;
+    }>>;
+    pointsRef: import("@angular/core").Signal<ElementRef<Points<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;
+    constructor();
+    protected readonly DynamicDrawUsage: 35048;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPointsBuffer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPointsBuffer, "ngts-points-buffer", never, { "positions": { "alias": "positions"; "required": true; "isSignal": true; }; "colors": { "alias": "colors"; "required": false; "isSignal": true; }; "sizes": { "alias": "sizes"; "required": false; "isSignal": true; }; "stride": { "alias": "stride"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+export interface NgtsPointsInstancesOptions extends Partial<NgtPoints> {
+    range?: number;
+    limit: number;
+}
+export declare class NgtsPointsInstances {
+    options: import("@angular/core").InputSignalWithTransform<NgtsPointsInstancesOptions, "" | Partial<NgtsPointsInstancesOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsPointsInstancesOptions, "range" | "limit">>;
+    pointsRef: import("@angular/core").Signal<ElementRef<Points<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;
+    private limit;
+    buffers: import("@angular/core").Signal<{
+        positions: Float32Array;
+        colors: Float32Array;
+        sizes: Float32Array;
+    }>;
+    positionPoints: Array<ElementRef<PositionPoint> | PositionPoint>;
+    constructor();
+    subscribe(ref: ElementRef<PositionPoint> | PositionPoint): () => void;
+    protected readonly DynamicDrawUsage: 35048;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPointsInstances, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPointsInstances, "ngts-points-instances", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}