angular-three-soba 2.0.0-beta.2 → 2.0.0-beta.21

package/staging/sky/sky.d.ts

@@ -1,4 +1,4 @@
-import { NgtSignalStore } from 'angular-three';
+import { type NgtMesh } from 'angular-three';
 import * as THREE from 'three';
 import { Sky } from 'three-stdlib';
 import * as i0 from "@angular/core";
@@ -14,28 +14,35 @@ export interface NgtsSkyState {
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'ngts-sky': NgtsSkyState & Sky;
+        /**
+         * @extends three-stdlib|Sky
+         * @extends ngt-mesh
+         */
+        'ngts-sky': NgtsSkyState & Sky & NgtMesh;
     }
 }
-export declare class NgtsSky extends NgtSignalStore<NgtsSkyState> {
-    #private;
+export declare class NgtsSky {
+    private inputs;
     skyRef: import("angular-three").NgtInjectedRef<Sky>;
-    set distance(distance: number);
-    set sunPosition(sunPosition: THREE.Vector3 | Parameters<THREE.Vector3['set']>);
-    set inclination(inclination: number);
-    set azimuth(azimuth: number);
-    set mieCoefficient(mieCoefficient: number);
-    set mieDirectionalG(mieDirectionalG: number);
-    set rayleigh(rayleigh: number);
-    set turbidity(turbidity: number);
-    readonly sky: Sky;
-    readonly skyMieCoefficient: import("@angular/core").Signal<number>;
-    readonly skyMieDirectionalG: import("@angular/core").Signal<number>;
-    readonly skyRayleigh: import("@angular/core").Signal<number>;
-    readonly skyTurbidity: import("@angular/core").Signal<number>;
-    readonly calculatedSunPosition: import("@angular/core").Signal<THREE.Vector3 | [x: number, y: number, z: number]>;
-    readonly scale: import("@angular/core").Signal<THREE.Vector3>;
-    constructor();
+    set _distance(distance: number);
+    set _sunPosition(sunPosition: THREE.Vector3 | Parameters<THREE.Vector3['set']>);
+    set _inclination(inclination: number);
+    set _azimuth(azimuth: number);
+    set _mieCoefficient(mieCoefficient: number);
+    set _mieDirectionalG(mieDirectionalG: number);
+    set _rayleigh(rayleigh: number);
+    set _turbidity(turbidity: number);
+    private inclination;
+    private azimuth;
+    private sunPos;
+    private distance;
+    sunPosition: import("@angular/core").Signal<THREE.Vector3 | [x: number, y: number, z: number]>;
+    scale: import("@angular/core").Signal<THREE.Vector3>;
+    mieCoefficient: import("@angular/core").Signal<number>;
+    mieDirectionalG: import("@angular/core").Signal<number>;
+    rayleigh: import("@angular/core").Signal<number>;
+    turbidity: import("@angular/core").Signal<number>;
+    sky: Sky;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSky, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSky, "ngts-sky", never, { "skyRef": { "alias": "skyRef"; "required": false; }; "distance": { "alias": "distance"; "required": false; }; "sunPosition": { "alias": "sunPosition"; "required": false; }; "inclination": { "alias": "inclination"; "required": false; }; "azimuth": { "alias": "azimuth"; "required": false; }; "mieCoefficient": { "alias": "mieCoefficient"; "required": false; }; "mieDirectionalG": { "alias": "mieDirectionalG"; "required": false; }; "rayleigh": { "alias": "rayleigh"; "required": false; }; "turbidity": { "alias": "turbidity"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSky, "ngts-sky", never, { "skyRef": { "alias": "skyRef"; "required": false; }; "_distance": { "alias": "distance"; "required": false; }; "_sunPosition": { "alias": "sunPosition"; "required": false; }; "_inclination": { "alias": "inclination"; "required": false; }; "_azimuth": { "alias": "azimuth"; "required": false; }; "_mieCoefficient": { "alias": "mieCoefficient"; "required": false; }; "_mieDirectionalG": { "alias": "mieDirectionalG"; "required": false; }; "_rayleigh": { "alias": "rayleigh"; "required": false; }; "_turbidity": { "alias": "turbidity"; "required": false; }; }, {}, never, ["*"], true, never>;
 }

package/staging/sparkles/sparkles.d.ts

@@ -1,8 +1,8 @@
-import { Signal } from '@angular/core';
-import { NgtSignalStore } from 'angular-three';
+import { type Signal } from '@angular/core';
+import { type NgtPoints } from 'angular-three';
 import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export interface NgtsSparklesState {
+export type NgtsSparklesState = {
     /** Number of particles (default: 100) */
     count: number;
     /** Speed of particles (default: 1) */
@@ -17,33 +17,47 @@ export interface NgtsSparklesState {
     scale: number | [number, number, number] | THREE.Vector3;
     /** Movement factor (default: 1) */
     noise: number | [number, number, number] | THREE.Vector3 | Float32Array;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-points
+         */
+        'ngts-sparkles': NgtsSparklesState & NgtPoints;
+    }
 }
-export declare class NgtsSparkles extends NgtSignalStore<NgtsSparklesState> {
-    #private;
-    pointsRef: import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
+export declare class NgtsSparkles {
+    private inputs;
+    sparklesRef: import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
     /** Number of particles (default: 100) */
-    set count(count: number);
+    set _count(count: number);
     /** Speed of particles (default: 1) */
-    set speed(speed: number | Float32Array);
+    set _speed(speed: number | Float32Array);
     /** Opacity of particles (default: 1) */
-    set opacity(opacity: number | Float32Array);
+    set _opacity(opacity: number | Float32Array);
     /** Color of particles (default: 100) */
-    set color(color: THREE.ColorRepresentation | Float32Array);
+    set _color(color: THREE.ColorRepresentation | Float32Array);
     /** Size of particles (default: randomized between 0 and 1) */
-    set size(size: number | Float32Array);
+    set _size(size: number | Float32Array);
     /** The space the particles occupy (default: 1) */
-    set scale(scale: number | [number, number, number] | THREE.Vector3);
+    set _scale(scale: number | [number, number, number] | THREE.Vector3);
     /** Movement factor (default: 1) */
-    set noise(noise: number | [number, number, number] | THREE.Vector3 | Float32Array);
-    readonly materialRef: import("angular-three").NgtInjectedRef<THREE.ShaderMaterial>;
-    readonly dpr: Signal<number>;
-    readonly positions: Signal<Float32Array>;
-    readonly sizes: Signal<Float32Array>;
-    readonly opacities: Signal<Float32Array>;
-    readonly speeds: Signal<Float32Array>;
-    readonly noises: Signal<Float32Array>;
-    readonly colors: Signal<Float32Array>;
+    set _noise(noise: number | [number, number, number] | THREE.Vector3 | Float32Array);
+    private store;
+    dpr: Signal<number>;
+    private scale;
+    private count;
+    private color;
+    positions: Signal<Float32Array>;
+    sizes: Signal<Float32Array>;
+    opacities: Signal<Float32Array>;
+    speeds: Signal<Float32Array>;
+    noises: Signal<Float32Array>;
+    colors: Signal<Float32Array>;
+    key: Signal<string>;
     constructor();
+    private beforeRender;
+    private getComputed;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSparkles, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSparkles, "ngts-sparkles", never, { "pointsRef": { "alias": "pointsRef"; "required": false; }; "count": { "alias": "count"; "required": false; }; "speed": { "alias": "speed"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "scale": { "alias": "scale"; "required": false; }; "noise": { "alias": "noise"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSparkles, "ngts-sparkles", never, { "sparklesRef": { "alias": "sparklesRef"; "required": false; }; "_count": { "alias": "count"; "required": false; }; "_speed": { "alias": "speed"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_size": { "alias": "size"; "required": false; }; "_scale": { "alias": "scale"; "required": false; }; "_noise": { "alias": "noise"; "required": false; }; }, {}, never, never, true, never>;
 }

package/staging/spot-light/shadow-mesh-input.d.ts

@@ -0,0 +1,29 @@
+import * as i0 from "@angular/core";
+export type NgtsSpotLightShadowMeshInputState = {
+    distance: number;
+    alphaTest: number;
+    scale: number;
+    map: THREE.Texture;
+    shader: string;
+    width: number;
+    height: number;
+};
+export declare abstract class NgtsSpotLightShadowMeshInput {
+    inputs: import("angular-three").NgtSignalStore<NgtsSpotLightShadowMeshInputState>;
+    set _distance(distance: number);
+    set _alphaTest(alphaTest: number);
+    set _scale(scale: number);
+    set _map(map: THREE.Texture);
+    set _shader(shader: string);
+    set _width(width: number);
+    set _height(height: number);
+    distance: import("@angular/core").Signal<number>;
+    alphaTest: import("@angular/core").Signal<number>;
+    scale: import("@angular/core").Signal<number>;
+    map: import("@angular/core").Signal<import("three").Texture>;
+    shader: import("@angular/core").Signal<string>;
+    width: import("@angular/core").Signal<number>;
+    height: import("@angular/core").Signal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadowMeshInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsSpotLightShadowMeshInput, never, never, { "_distance": { "alias": "distance"; "required": false; }; "_alphaTest": { "alias": "alphaTest"; "required": false; }; "_scale": { "alias": "scale"; "required": false; }; "_map": { "alias": "map"; "required": false; }; "_shader": { "alias": "shader"; "required": false; }; "_width": { "alias": "width"; "required": false; }; "_height": { "alias": "height"; "required": false; }; }, {}, never, never, false, never>;
+}

package/staging/spot-light/shadow-mesh.d.ts

@@ -0,0 +1,37 @@
+import { type NgtInjectedRef } from 'angular-three';
+import * as THREE from 'three';
+import { NgtsSpotLightShadowMeshInput, type NgtsSpotLightShadowMeshInputState } from './shadow-mesh-input';
+import * as i0 from "@angular/core";
+export declare class NgtsSpotLightShadowMeshNoShader {
+    shadowMeshInput: NgtsSpotLightShadowMeshInput;
+    meshRef: NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    DoubleSide: 2;
+    private spotLightApi;
+    debug: import("@angular/core").Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadowMeshNoShader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadowMeshNoShader, "ngts-spot-light-shadow-mesh-no-shader", never, {}, {}, never, ["*"], true, never>;
+}
+export declare class NgtsSpotLightShadowMeshShader {
+    shadowMeshInput: NgtsSpotLightShadowMeshInput;
+    meshRef: NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    DoubleSide: 2;
+    RepeatWrapping: 1000;
+    private spotLightApi;
+    debug: import("@angular/core").Signal<boolean>;
+    renderTarget: import("@angular/core").Signal<THREE.WebGLRenderTarget<THREE.Texture>>;
+    private uniforms;
+    private fsQuad;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadowMeshShader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadowMeshShader, "ngts-spot-light-shadow-mesh-shader", never, {}, {}, never, ["*"], true, never>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-spot-light-shadow': NgtsSpotLightShadowMeshInputState;
+    }
+}
+export declare class NgtsSpotLightShadow extends NgtsSpotLightShadowMeshInput {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadow, "ngts-spot-light-shadow", never, {}, {}, never, never, true, never>;
+}

package/staging/spot-light/spot-light-input.d.ts

@@ -1,6 +1,5 @@
-import { NgtSignalStore } from 'angular-three';
 import * as i0 from "@angular/core";
-export interface NgtsSpotLightInputState {
+export type NgtsSpotLightInputState = {
     depthBuffer?: THREE.DepthTexture;
     angle: number;
     distance: number;
@@ -11,28 +10,29 @@ export interface NgtsSpotLightInputState {
     opacity: number;
     color: string | number;
     debug: boolean;
-}
-export declare abstract class NgtsSpotLightInput extends NgtSignalStore<NgtsSpotLightInputState> {
-    set depthBuffer(depthBuffer: THREE.DepthTexture);
-    set angle(angle: number);
-    set distance(distance: number);
-    set attenuation(attenuation: number);
-    set anglePower(anglePower: number);
-    set radiusTop(radiusTop: number);
-    set radiusBottom(radiusBottom: number);
-    set opacity(opacity: number);
-    set color(color: string | number);
-    set debug(debug: boolean);
-    readonly lightDebug: import("@angular/core").Signal<boolean>;
-    readonly lightColor: import("@angular/core").Signal<string | number>;
-    readonly lightOpacity: import("@angular/core").Signal<number>;
-    readonly lightRadiusBottom: import("@angular/core").Signal<number>;
-    readonly lightRadiusTop: import("@angular/core").Signal<number>;
-    readonly lightAnglePower: import("@angular/core").Signal<number>;
-    readonly lightAttenuation: import("@angular/core").Signal<number>;
-    readonly lightDistance: import("@angular/core").Signal<number>;
-    readonly lightAngle: import("@angular/core").Signal<number>;
-    readonly lightDepthBuffer: import("@angular/core").Signal<import("three").DepthTexture | undefined>;
+};
+export declare abstract class NgtsSpotLightInput {
+    inputs: import("angular-three").NgtSignalStore<NgtsSpotLightInputState>;
+    set _depthBuffer(depthBuffer: THREE.DepthTexture);
+    set _angle(angle: number);
+    set _distance(distance: number);
+    set _attenuation(attenuation: number);
+    set _anglePower(anglePower: number);
+    set _radiusTop(radiusTop: number);
+    set _radiusBottom(radiusBottom: number);
+    set _opacity(opacity: number);
+    set _color(color: string | number);
+    set _debug(debug: boolean);
+    debug: import("@angular/core").Signal<boolean>;
+    color: import("@angular/core").Signal<string | number>;
+    opacity: import("@angular/core").Signal<number>;
+    radiusBottom: import("@angular/core").Signal<number>;
+    radiusTop: import("@angular/core").Signal<number>;
+    anglePower: import("@angular/core").Signal<number>;
+    attenuation: import("@angular/core").Signal<number>;
+    distance: import("@angular/core").Signal<number>;
+    angle: import("@angular/core").Signal<number>;
+    depthBuffer: import("@angular/core").Signal<import("three").DepthTexture | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightInput, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsSpotLightInput, never, never, { "depthBuffer": { "alias": "depthBuffer"; "required": false; }; "angle": { "alias": "angle"; "required": false; }; "distance": { "alias": "distance"; "required": false; }; "attenuation": { "alias": "attenuation"; "required": false; }; "anglePower": { "alias": "anglePower"; "required": false; }; "radiusTop": { "alias": "radiusTop"; "required": false; }; "radiusBottom": { "alias": "radiusBottom"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "color": { "alias": "color"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsSpotLightInput, never, never, { "_depthBuffer": { "alias": "depthBuffer"; "required": false; }; "_angle": { "alias": "angle"; "required": false; }; "_distance": { "alias": "distance"; "required": false; }; "_attenuation": { "alias": "attenuation"; "required": false; }; "_anglePower": { "alias": "anglePower"; "required": false; }; "_radiusTop": { "alias": "radiusTop"; "required": false; }; "_radiusBottom": { "alias": "radiusBottom"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_debug": { "alias": "debug"; "required": false; }; }, {}, never, never, false, never>;
 }

package/staging/spot-light/spot-light.d.ts

@@ -1,23 +1,39 @@
-import { InjectionToken } from '@angular/core';
-import { NgtInjectedRef } from 'angular-three';
+import { type NgtSpotLight } from 'angular-three';
 import { SpotLight } from 'three';
-import { NgtsSpotLightInput } from './spot-light-input';
+import { NgtsSpotLightInput, type NgtsSpotLightInputState } from './spot-light-input';
 import * as i0 from "@angular/core";
-declare module './spot-light-input' {
-    interface NgtsSpotLightInputState {
-        volumetric: boolean;
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-spot-light
+         */
+        'ngts-spot-light': NgtsSpotLightInputState & NgtSpotLight;
     }
 }
-export type NgtsSpotLightApi = {
-    spotLight: NgtInjectedRef<THREE.SpotLight>;
-    debug: () => boolean;
-};
-export declare const NGTS_SPOT_LIGHT_API: InjectionToken<NgtsSpotLightApi>;
+export declare const injectNgtsSpotLightApi: {
+    (): {
+        spotLight: import("angular-three").NgtInjectedRef<SpotLight>;
+        debug: import("@angular/core").Signal<boolean>;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    }): {
+        spotLight: import("angular-three").NgtInjectedRef<SpotLight>;
+        debug: import("@angular/core").Signal<boolean>;
+    };
+    (injectOptions: import("@angular/core").InjectOptions): {
+        spotLight: import("angular-three").NgtInjectedRef<SpotLight>;
+        debug: import("@angular/core").Signal<boolean>;
+    } | null;
+}, provideNgtsSpotLightApi: (value?: {
+    spotLight: import("angular-three").NgtInjectedRef<SpotLight>;
+    debug: import("@angular/core").Signal<boolean>;
+} | undefined) => import("@angular/core").Provider;
 export declare class NgtsSpotLight extends NgtsSpotLightInput {
-    spotLightRef: NgtInjectedRef<SpotLight>;
-    set volumetric(volumetric: boolean);
-    readonly showVolumetric: import("@angular/core").Signal<boolean>;
+    spotLightRef: import("angular-three").NgtInjectedRef<SpotLight>;
+    volumetric: import("@angular/core").WritableSignal<boolean>;
+    set _volumetric(volumetric: boolean);
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLight, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLight, "ngts-spot-light", never, { "spotLightRef": { "alias": "spotLightRef"; "required": false; }; "volumetric": { "alias": "volumetric"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLight, "ngts-spot-light", never, { "spotLightRef": { "alias": "spotLightRef"; "required": false; }; "_volumetric": { "alias": "volumetric"; "required": false; }; }, {}, never, ["*"], true, never>;
 }

package/staging/spot-light/volumetric-mesh.d.ts

@@ -3,16 +3,22 @@ import * as THREE from 'three';
 import { NgtsSpotLightInput } from './spot-light-input';
 import * as i0 from "@angular/core";
 export declare class NgtsVolumetricMesh {
-    #private;
-    protected readonly spotLightInput: NgtsSpotLightInput;
-    readonly mesh: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
-    readonly material: SpotLightMaterial;
-    readonly nullRaycast: () => null;
-    readonly geometry: import("@angular/core").Signal<THREE.CylinderGeometry>;
-    readonly near: import("@angular/core").Signal<number>;
-    readonly far: import("@angular/core").Signal<number>;
-    readonly resolution: import("@angular/core").Signal<number[]>;
+    spotLightInput: NgtsSpotLightInput;
+    mesh: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    material: SpotLightMaterial;
+    nullRaycast: () => null;
+    private vec;
+    private store;
+    private size;
+    private dpr;
+    private radiusTop;
+    private radiusBottom;
+    near: import("@angular/core").Signal<number>;
+    far: import("@angular/core").Signal<number>;
+    resolution: import("@angular/core").Signal<number[]>;
+    geometry: import("@angular/core").Signal<THREE.CylinderGeometry>;
     constructor();
+    private beforeRender;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsVolumetricMesh, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsVolumetricMesh, "ngts-volumetric-mesh", never, {}, {}, never, never, true, never>;
 }

package/staging/stage/stage.d.ts

@@ -1,13 +1,12 @@
-import { EventEmitter, OnChanges } from '@angular/core';
-import { NgtSignalStore } from 'angular-three';
-import { NgtsAccumulativeShadows } from '../accumulative-shadows/accumulative-shadows';
-import { NgtsRandomizedLights } from '../accumulative-shadows/randomized-lights';
-import { NgtsCenter } from '../center/center';
-import { NgtsContactShadows } from '../contact-shadows/contact-shadows';
-import { NgtsEnvironmentPresetsType } from '../environment/assets';
-import { NgtsEnvironmentInput } from '../environment/environment-input';
+import { EventEmitter, type OnChanges } from '@angular/core';
+import { type NgtsAccumulativeShadowsState } from '../accumulative-shadows/accumulative-shadows';
+import { type NgtsRandomizedLightsState } from '../accumulative-shadows/randomized-lights';
+import { type NgtsCenterState, type NgtsCenteredEvent } from '../center/center';
+import { type NgtsContactShadowsState } from '../contact-shadows/contact-shadows';
+import type { NgtsEnvironmentPresetsType } from '../environment/assets';
+import { type NgtsEnvironmentInputState } from '../environment/environment-input';
 import * as i0 from "@angular/core";
-type NgtsStageShadows = Partial<NgtsAccumulativeShadows> & Partial<NgtsRandomizedLights> & Partial<NgtsContactShadows> & {
+type NgtsStageShadowsState = Partial<NgtsAccumulativeShadowsState> & Partial<NgtsRandomizedLightsState> & Partial<NgtsContactShadowsState> & {
     type: 'contact' | 'accumulative';
     /** Shadow plane offset, default: 0 */
     offset?: number;
@@ -18,89 +17,114 @@ type NgtsStageShadows = Partial<NgtsAccumulativeShadows> & Partial<NgtsRandomize
     /** Shadow map size, default: 1024 */
     size?: number;
 };
-interface NgtsStageProps {
+export type NgtsStageState = {
     /** Lighting setup, default: "rembrandt" */
     preset: 'rembrandt' | 'portrait' | 'upfront' | 'soft' | {
         main: [x: number, y: number, z: number];
         fill: [x: number, y: number, z: number];
     };
     /** Controls the ground shadows, default: "contact" */
-    shadows: boolean | 'contact' | 'accumulative' | NgtsStageShadows;
+    shadows: boolean | 'contact' | 'accumulative' | NgtsStageShadowsState;
     /** Optionally wraps and thereby centers the models using <Bounds>, can also be a margin, default: true */
     adjustCamera: boolean | number;
     /** The default environment, default: "city" */
-    environment: NgtsEnvironmentPresetsType | Partial<NgtsEnvironmentInput>;
+    environment: NgtsEnvironmentPresetsType | Partial<NgtsEnvironmentInputState>;
     /** The lighting intensity, default: 0.5 */
     intensity: number;
     /** To adjust centering, default: undefined */
-    center?: Partial<NgtsCenter>;
+    center?: Partial<NgtsCenterState>;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-stage': NgtsStageState;
+    }
 }
 export declare class NgtsStageRefit implements OnChanges {
-    #private;
+    boundsApi: import("@angular/core").Signal<{
+        getSize: () => {
+            box: import("three").Box3;
+            size: import("three").Vector3;
+            center: import("three").Vector3;
+            distance: number;
+        };
+        refresh(object?: import("three").Object3D<import("three").Event> | import("three").Box3 | undefined): any;
+        clip(): any;
+        to({ position, target }: {
+            position: [number, number, number];
+            target?: [number, number, number] | undefined;
+        }): any;
+        fit(): any;
+    }>;
     radius: number;
-    adjustCamera: boolean;
+    adjustCamera: boolean | number;
     ngOnChanges(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsStageRefit, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsStageRefit, "ngts-stage-refit", never, { "radius": { "alias": "radius"; "required": false; }; "adjustCamera": { "alias": "adjustCamera"; "required": false; }; }, {}, never, never, true, never>;
 }
-export declare class NgtsStage extends NgtSignalStore<NgtsStageProps> {
-    #private;
-    readonly Number: NumberConstructor;
-    set preset(preset: NgtsStageProps['preset']);
-    set shadows(shadows: NgtsStageProps['shadows']);
-    set adjustCamera(adjustCamera: NgtsStageProps['adjustCamera']);
-    set environment(environment: NgtsStageProps['environment']);
-    set intensity(intensity: NgtsStageProps['intensity']);
-    set center(center: NgtsStageProps['center']);
-    centered: EventEmitter<{
-        parent: import("three").Object3D<import("three").Event>;
-        /** To adjust centering, default: undefined */
-        container: import("three").Object3D<import("three").Event>;
-        width: number;
-        height: number;
-        depth: number;
-        boundingBox: import("three").Box3;
-        boundingSphere: import("three").Sphere;
-        center: import("three").Vector3;
-        verticalAlignment: number;
-        horizontalAlignment: number;
-        depthAlignment: number;
-    }>;
-    readonly boundingState: import("@angular/core").WritableSignal<{
+export declare class NgtsStage {
+    Number: NumberConstructor;
+    private inputs;
+    set _preset(preset: NgtsStageState['preset']);
+    set _shadows(shadows: NgtsStageState['shadows']);
+    set _adjustCamera(adjustCamera: NgtsStageState['adjustCamera']);
+    set _environment(environment: NgtsStageState['environment']);
+    set _intensity(intensity: NgtsStageState['intensity']);
+    set _center(center: NgtsStageState['center']);
+    centered: EventEmitter<NgtsCenteredEvent>;
+    private preset;
+    private environment;
+    boundingState: import("angular-three").NgtSignalStore<{
         radius: number;
         width: number;
         height: number;
         depth: number;
     }>;
-    readonly stageShadows: import("@angular/core").Signal<boolean | "contact" | "accumulative" | NgtsStageShadows>;
-    readonly stageIntensity: import("@angular/core").Signal<number>;
-    readonly stageAdjustCamera: import("@angular/core").Signal<number | boolean>;
-    readonly stageCenter: import("@angular/core").Signal<Partial<NgtsCenter> | undefined>;
-    readonly config: import("@angular/core").Signal<{
+    config: import("@angular/core").Signal<{
         main: number[];
         fill: number[];
     }>;
-    readonly shadowsInfo: import("@angular/core").Signal<any>;
-    readonly spotLightPosition: import("@angular/core").Signal<[number, number, number]>;
-    readonly pointLightPosition: import("@angular/core").Signal<number[]>;
-    readonly environmentInfo: import("@angular/core").Signal<Partial<NgtsEnvironmentInput> | null>;
-    constructor();
-    onCentered(props: {
-        /** The next parent above <Center> */
-        parent: THREE.Object3D;
-        /** The outmost container group of the <Center> component */
-        container: THREE.Object3D;
-        width: number;
-        height: number;
-        depth: number;
-        boundingBox: THREE.Box3;
-        boundingSphere: THREE.Sphere;
-        center: THREE.Vector3;
-        verticalAlignment: number;
-        horizontalAlignment: number;
-        depthAlignment: number;
-    }): void;
+    shadows: import("@angular/core").Signal<boolean | "contact" | "accumulative" | NgtsStageShadowsState>;
+    intensity: import("@angular/core").Signal<number>;
+    adjustCamera: import("@angular/core").Signal<number | boolean>;
+    center: import("@angular/core").Signal<Partial<NgtsCenterState> | undefined>;
+    shadowsState: import("@angular/core").Signal<{
+        frames?: number | undefined;
+        blend?: number | undefined;
+        limit?: number | undefined;
+        scale?: number | (number & [x: number, y: number]) | undefined;
+        temporal?: boolean | undefined;
+        opacity?: number | undefined;
+        alphaTest?: number | undefined;
+        color?: (string & import("three").ColorRepresentation) | undefined;
+        colorBlend?: number | undefined;
+        resolution?: number | undefined;
+        toneMapped?: boolean | undefined;
+        position?: [x: number, y: number, z: number] | undefined;
+        radius?: number | undefined;
+        amount?: number | undefined;
+        intensity?: number | undefined;
+        ambient?: number | undefined;
+        castShadow?: boolean | undefined;
+        mapSize?: number | undefined;
+        near?: number | undefined;
+        far?: number | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        blur?: number | undefined;
+        smooth?: boolean | undefined;
+        depthWrite?: boolean | undefined;
+        renderOrder?: number | undefined;
+        type: "contact" | "accumulative";
+        contactShadow: boolean;
+        accumulativeShadow: boolean;
+        shadowBias: number;
+        normalBias: number;
+        shadowSize: number;
+        shadowOffset: number;
+    }>;
+    environmentState: import("@angular/core").Signal<Partial<NgtsEnvironmentInputState> | null>;
+    onCentered($event: NgtsCenteredEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsStage, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsStage, "ngts-stage", never, { "preset": { "alias": "preset"; "required": false; }; "shadows": { "alias": "shadows"; "required": false; }; "adjustCamera": { "alias": "adjustCamera"; "required": false; }; "environment": { "alias": "environment"; "required": false; }; "intensity": { "alias": "intensity"; "required": false; }; "center": { "alias": "center"; "required": false; }; }, { "centered": "centered"; }, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsStage, "ngts-stage", never, { "_preset": { "alias": "preset"; "required": false; }; "_shadows": { "alias": "shadows"; "required": false; }; "_adjustCamera": { "alias": "adjustCamera"; "required": false; }; "_environment": { "alias": "environment"; "required": false; }; "_intensity": { "alias": "intensity"; "required": false; }; "_center": { "alias": "center"; "required": false; }; }, { "centered": "centered"; }, never, ["*"], true, never>;
 }
 export {};