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

package/staging/lib/environment.d.ts

@@ -0,0 +1,132 @@
+import { ElementRef, Injector, TemplateRef } from '@angular/core';
+import { TextureEncoding } from 'angular-three-soba/misc';
+import { CubeCamera, CubeTexture, Euler, Loader, Scene, Texture, WebGLCubeRenderTarget } from 'three';
+import * as i0 from "@angular/core";
+export declare const ENVIRONMENT_PRESETS: {
+    apartment: string;
+    city: string;
+    dawn: string;
+    forest: string;
+    lobby: string;
+    night: string;
+    park: string;
+    studio: string;
+    sunset: string;
+    warehouse: string;
+};
+export type NgtsEnvironmentPresets = keyof typeof ENVIRONMENT_PRESETS;
+export interface NgtsInjectEnvironmentOptions {
+    files: string | string[];
+    path: string;
+    preset?: NgtsEnvironmentPresets;
+    extensions?: (loader: Loader) => void;
+    encoding?: TextureEncoding;
+}
+export declare function injectEnvironment(options?: () => Partial<NgtsInjectEnvironmentOptions>, { injector }?: {
+    injector?: Injector;
+}): import("@angular/core").Signal<Texture | CubeTexture | null>;
+export interface NgtsEnvironmentOptions extends Partial<NgtsInjectEnvironmentOptions> {
+    frames?: number;
+    near?: number;
+    far?: number;
+    resolution?: number;
+    background?: boolean | 'only';
+    /** deprecated, use backgroundBlurriness */
+    blur?: number;
+    backgroundBlurriness?: number;
+    backgroundIntensity?: number;
+    backgroundRotation?: Euler;
+    environmentIntensity?: number;
+    environmentRotation?: Euler;
+    map?: Texture;
+    preset?: NgtsEnvironmentPresets;
+    scene?: Scene | ElementRef<Scene>;
+    ground?: boolean | {
+        radius?: number;
+        height?: number;
+        scale?: number;
+    };
+}
+export declare class NgtsEnvironmentMap {
+    options: import("@angular/core").InputSignalWithTransform<NgtsEnvironmentOptions, "" | Partial<NgtsEnvironmentOptions>>;
+    envSet: import("@angular/core").OutputEmitterRef<void>;
+    private autoEffect;
+    private store;
+    private defaultScene;
+    private envConfig;
+    private map;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentMap, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentMap, "ngts-environment-map", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "envSet": "envSet"; }, never, never, true, never>;
+}
+export declare class NgtsEnvironmentCube {
+    options: import("@angular/core").InputSignalWithTransform<NgtsEnvironmentOptions, "" | Partial<NgtsEnvironmentOptions>>;
+    envSet: import("@angular/core").OutputEmitterRef<void>;
+    private autoEffect;
+    private store;
+    private defaultScene;
+    private injector;
+    private envConfig;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentCube, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentCube, "ngts-environment-cube", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "envSet": "envSet"; }, never, never, true, never>;
+}
+export declare class NgtsEnvironmentPortal {
+    private defaultOptions;
+    options: import("@angular/core").InputSignalWithTransform<NgtsEnvironmentOptions, "" | Partial<NgtsEnvironmentOptions>>;
+    content: import("@angular/core").InputSignal<TemplateRef<unknown>>;
+    envSet: import("@angular/core").OutputEmitterRef<void>;
+    private autoEffect;
+    private store;
+    private defaultScene;
+    private gl;
+    cameraRef: import("@angular/core").Signal<ElementRef<CubeCamera> | undefined>;
+    map: import("@angular/core").Signal<Texture | undefined>;
+    files: import("@angular/core").Signal<string | string[] | undefined>;
+    preset: import("@angular/core").Signal<"apartment" | "city" | "dawn" | "forest" | "lobby" | "night" | "park" | "studio" | "sunset" | "warehouse" | undefined>;
+    private extensions;
+    private path;
+    envMapOptions: import("@angular/core").Signal<{
+        background: boolean;
+        map: Texture | undefined;
+        extensions: ((loader: Loader) => void) | undefined;
+    }>;
+    envCubeOptions: import("@angular/core").Signal<{
+        background: boolean;
+        files: string | string[] | undefined;
+        preset: "apartment" | "city" | "dawn" | "forest" | "lobby" | "night" | "park" | "studio" | "sunset" | "warehouse" | undefined;
+        extensions: ((loader: Loader) => void) | undefined;
+        path: string | undefined;
+    }>;
+    private near;
+    private far;
+    private resolution;
+    private fbo;
+    cameraArgs: import("@angular/core").Signal<(number | WebGLCubeRenderTarget | undefined)[]>;
+    virtualScene: import("angular-three").NgtInstanceNode<Scene>;
+    private setEnvEffectRef?;
+    constructor();
+    onEnvSet(): void;
+    private setPortalEnv;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentPortal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironmentPortal, "ngts-environment-portal", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": true; "isSignal": true; }; }, { "envSet": "envSet"; }, never, never, true, never>;
+}
+export declare class NgtsEnvironmentGround {
+    options: import("@angular/core").InputSignal<NgtsEnvironmentOptions>;
+    envSet: import("@angular/core").OutputEmitterRef<void>;
+    args: import("@angular/core").WritableSignal<[Texture | null]>;
+    height: import("@angular/core").Signal<any>;
+    radius: import("@angular/core").Signal<any>;
+    scale: import("@angular/core").Signal<any>;
+    envMapOptions: import("@angular/core").Signal<NgtsEnvironmentOptions>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentGround, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironmentGround, "ngts-environment-ground", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "envSet": "envSet"; }, never, never, true, never>;
+}
+export declare class NgtsEnvironment {
+    options: import("@angular/core").InputSignal<NgtsEnvironmentOptions>;
+    content: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    envSet: import("@angular/core").OutputEmitterRef<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironment, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironment, "ngts-environment", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "envSet": "envSet"; }, ["content"], never, true, never>;
+}

package/staging/lib/float.d.ts

@@ -0,0 +1,20 @@
+import { ElementRef } from '@angular/core';
+import { NgtGroup } from 'angular-three';
+import { Group } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsFloatOptions extends Partial<NgtGroup> {
+    enabled: boolean;
+    speed: number;
+    rotationIntensity: number;
+    floatIntensity: number;
+    floatingRange: [number?, number?];
+    autoInvalidate: boolean;
+}
+export declare class NgtsFloat {
+    options: import("@angular/core").InputSignalWithTransform<NgtsFloatOptions, "" | Partial<NgtsFloatOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsFloatOptions, "enabled" | "speed" | "rotationIntensity" | "floatIntensity" | "floatingRange" | "autoInvalidate">>;
+    floatRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsFloat, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsFloat, "ngts-float", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/staging/lib/lightformer.d.ts

@@ -0,0 +1,310 @@
+import { ElementRef } from '@angular/core';
+import { NgtVector3 } from 'angular-three';
+import { Mesh, MeshBasicMaterial, Texture } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsLightformerOptions {
+    map?: Texture;
+    toneMapped: boolean;
+    color: string;
+    form: 'circle' | 'ring' | 'rect';
+    scale: number | [number, number, number] | [number, number];
+    intensity: number;
+    target?: NgtVector3;
+}
+export declare class NgtsLightformer {
+    side: 2;
+    options: import("@angular/core").InputSignalWithTransform<Partial<Omit<{
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        addEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
+        removeEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
+        __ngt_args__: [geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined, material?: import("three").Material | import("three").Material[] | undefined];
+        readonly type?: string | undefined;
+        readonly isObject3D?: true | undefined;
+        readonly id?: number | undefined;
+        uuid?: string | undefined;
+        name?: string | undefined;
+        parent?: import("three").Object3D<import("three").Object3DEventMap> | null | undefined;
+        children?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined;
+        readonly modelViewMatrix?: import("three").Matrix4 | undefined;
+        readonly normalMatrix?: import("three").Matrix3 | undefined;
+        matrixWorld?: import("three").Matrix4 | undefined;
+        matrixAutoUpdate?: boolean | undefined;
+        matrixWorldAutoUpdate?: boolean | undefined;
+        matrixWorldNeedsUpdate?: boolean | undefined;
+        visible?: boolean | undefined;
+        castShadow?: boolean | undefined;
+        receiveShadow?: boolean | undefined;
+        frustumCulled?: boolean | undefined;
+        renderOrder?: number | undefined;
+        animations?: import("three").AnimationClip[] | undefined;
+        userData?: Record<string, any> | undefined;
+        customDepthMaterial?: import("three").Material | undefined;
+        customDistanceMaterial?: import("three").Material | undefined;
+        onBeforeShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, 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: import("three").Matrix4) => void) | undefined;
+        applyQuaternion?: ((quaternion: import("three").Quaternion) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        setRotationFromAxisAngle?: ((axis: import("three").Vector3, angle: number) => void) | undefined;
+        setRotationFromEuler?: ((euler: import("three").Euler) => void) | undefined;
+        setRotationFromMatrix?: ((m: import("three").Matrix4) => void) | undefined;
+        setRotationFromQuaternion?: ((q: import("three").Quaternion) => void) | undefined;
+        rotateOnAxis?: ((axis: import("three").Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: import("three").Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateX?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateY?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateZ?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateOnAxis?: ((axis: import("three").Vector3, distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateX?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateY?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateZ?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        localToWorld?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        worldToLocal?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        lookAt?: {
+            (vector: import("three").Vector3): void;
+            (x: number, y: number, z: number): void;
+        } | undefined;
+        add?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        remove?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        getObjectById?: ((id: number) => import("three").Object3D | undefined) | undefined;
+        getObjectByName?: ((name: string) => import("three").Object3D | undefined) | undefined;
+        getObjectByProperty?: ((name: string, value: any) => import("three").Object3D | undefined) | undefined;
+        getObjectsByProperty?: ((name: string, value: any, optionalTarget?: import("three").Object3D[]) => import("three").Object3D[]) | undefined;
+        getWorldPosition?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldQuaternion?: ((target: import("three").Quaternion) => import("three").Quaternion) | undefined;
+        getWorldScale?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldDirection?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        traverse?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        traverseVisible?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        traverseAncestors?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        updateMatrix?: (() => void) | undefined;
+        updateMatrixWorld?: ((force?: boolean) => void) | undefined;
+        updateWorldMatrix?: ((updateParents: boolean, updateChildren: boolean) => void) | undefined;
+        toJSON?: ((meta?: import("three").JSONMeta) => import("three").MeshJSON) | undefined;
+        clone?: ((recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        copy?: ((object: import("three").Object3D, recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        hasEventListener?: (<T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>) => boolean) | undefined;
+        dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
+        readonly isMesh?: true | undefined;
+        geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined;
+        material?: import("three").Material | import("three").Material[] | undefined;
+        morphTargetInfluences?: number[] | undefined;
+        morphTargetDictionary?: {
+            [key: string]: number;
+        } | undefined;
+        updateMorphTargets?: (() => void) | undefined;
+        getVertexPosition?: ((index: number, target: import("three").Vector3) => import("three").Vector3) | undefined;
+        position: NgtVector3;
+        up: NgtVector3;
+        scale: 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;
+    }, "scale">> & NgtsLightformerOptions, "" | Partial<Partial<Omit<{
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        addEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
+        removeEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
+        __ngt_args__: [geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined, material?: import("three").Material | import("three").Material[] | undefined];
+        readonly type?: string | undefined;
+        readonly isObject3D?: true | undefined;
+        readonly id?: number | undefined;
+        uuid?: string | undefined;
+        name?: string | undefined;
+        parent?: import("three").Object3D<import("three").Object3DEventMap> | null | undefined;
+        children?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined;
+        readonly modelViewMatrix?: import("three").Matrix4 | undefined;
+        readonly normalMatrix?: import("three").Matrix3 | undefined;
+        matrixWorld?: import("three").Matrix4 | undefined;
+        matrixAutoUpdate?: boolean | undefined;
+        matrixWorldAutoUpdate?: boolean | undefined;
+        matrixWorldNeedsUpdate?: boolean | undefined;
+        visible?: boolean | undefined;
+        castShadow?: boolean | undefined;
+        receiveShadow?: boolean | undefined;
+        frustumCulled?: boolean | undefined;
+        renderOrder?: number | undefined;
+        animations?: import("three").AnimationClip[] | undefined;
+        userData?: Record<string, any> | undefined;
+        customDepthMaterial?: import("three").Material | undefined;
+        customDistanceMaterial?: import("three").Material | undefined;
+        onBeforeShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, 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: import("three").Matrix4) => void) | undefined;
+        applyQuaternion?: ((quaternion: import("three").Quaternion) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        setRotationFromAxisAngle?: ((axis: import("three").Vector3, angle: number) => void) | undefined;
+        setRotationFromEuler?: ((euler: import("three").Euler) => void) | undefined;
+        setRotationFromMatrix?: ((m: import("three").Matrix4) => void) | undefined;
+        setRotationFromQuaternion?: ((q: import("three").Quaternion) => void) | undefined;
+        rotateOnAxis?: ((axis: import("three").Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: import("three").Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateX?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateY?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateZ?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateOnAxis?: ((axis: import("three").Vector3, distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateX?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateY?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateZ?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        localToWorld?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        worldToLocal?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        lookAt?: {
+            (vector: import("three").Vector3): void;
+            (x: number, y: number, z: number): void;
+        } | undefined;
+        add?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        remove?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        getObjectById?: ((id: number) => import("three").Object3D | undefined) | undefined;
+        getObjectByName?: ((name: string) => import("three").Object3D | undefined) | undefined;
+        getObjectByProperty?: ((name: string, value: any) => import("three").Object3D | undefined) | undefined;
+        getObjectsByProperty?: ((name: string, value: any, optionalTarget?: import("three").Object3D[]) => import("three").Object3D[]) | undefined;
+        getWorldPosition?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldQuaternion?: ((target: import("three").Quaternion) => import("three").Quaternion) | undefined;
+        getWorldScale?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldDirection?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        traverse?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        traverseVisible?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        traverseAncestors?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        updateMatrix?: (() => void) | undefined;
+        updateMatrixWorld?: ((force?: boolean) => void) | undefined;
+        updateWorldMatrix?: ((updateParents: boolean, updateChildren: boolean) => void) | undefined;
+        toJSON?: ((meta?: import("three").JSONMeta) => import("three").MeshJSON) | undefined;
+        clone?: ((recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        copy?: ((object: import("three").Object3D, recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        hasEventListener?: (<T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>) => boolean) | undefined;
+        dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
+        readonly isMesh?: true | undefined;
+        geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined;
+        material?: import("three").Material | import("three").Material[] | undefined;
+        morphTargetInfluences?: number[] | undefined;
+        morphTargetDictionary?: {
+            [key: string]: number;
+        } | undefined;
+        updateMorphTargets?: (() => void) | undefined;
+        getVertexPosition?: ((index: number, target: import("three").Vector3) => import("three").Vector3) | undefined;
+        position: NgtVector3;
+        up: NgtVector3;
+        scale: 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;
+    }, "scale">> & NgtsLightformerOptions>>;
+    parameters: import("@angular/core").Signal<Omit<Partial<Omit<{
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        addEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
+        removeEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
+        __ngt_args__: [geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined, material?: import("three").Material | import("three").Material[] | undefined];
+        readonly type?: string | undefined;
+        readonly isObject3D?: true | undefined;
+        readonly id?: number | undefined;
+        uuid?: string | undefined;
+        name?: string | undefined;
+        parent?: import("three").Object3D<import("three").Object3DEventMap> | null | undefined;
+        children?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined;
+        readonly modelViewMatrix?: import("three").Matrix4 | undefined;
+        readonly normalMatrix?: import("three").Matrix3 | undefined;
+        matrixWorld?: import("three").Matrix4 | undefined;
+        matrixAutoUpdate?: boolean | undefined;
+        matrixWorldAutoUpdate?: boolean | undefined;
+        matrixWorldNeedsUpdate?: boolean | undefined;
+        visible?: boolean | undefined;
+        castShadow?: boolean | undefined;
+        receiveShadow?: boolean | undefined;
+        frustumCulled?: boolean | undefined;
+        renderOrder?: number | undefined;
+        animations?: import("three").AnimationClip[] | undefined;
+        userData?: Record<string, any> | undefined;
+        customDepthMaterial?: import("three").Material | undefined;
+        customDistanceMaterial?: import("three").Material | undefined;
+        onBeforeShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, 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: import("three").Matrix4) => void) | undefined;
+        applyQuaternion?: ((quaternion: import("three").Quaternion) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        setRotationFromAxisAngle?: ((axis: import("three").Vector3, angle: number) => void) | undefined;
+        setRotationFromEuler?: ((euler: import("three").Euler) => void) | undefined;
+        setRotationFromMatrix?: ((m: import("three").Matrix4) => void) | undefined;
+        setRotationFromQuaternion?: ((q: import("three").Quaternion) => void) | undefined;
+        rotateOnAxis?: ((axis: import("three").Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: import("three").Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateX?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateY?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateZ?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateOnAxis?: ((axis: import("three").Vector3, distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateX?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateY?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateZ?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        localToWorld?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        worldToLocal?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        lookAt?: {
+            (vector: import("three").Vector3): void;
+            (x: number, y: number, z: number): void;
+        } | undefined;
+        add?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        remove?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        getObjectById?: ((id: number) => import("three").Object3D | undefined) | undefined;
+        getObjectByName?: ((name: string) => import("three").Object3D | undefined) | undefined;
+        getObjectByProperty?: ((name: string, value: any) => import("three").Object3D | undefined) | undefined;
+        getObjectsByProperty?: ((name: string, value: any, optionalTarget?: import("three").Object3D[]) => import("three").Object3D[]) | undefined;
+        getWorldPosition?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldQuaternion?: ((target: import("three").Quaternion) => import("three").Quaternion) | undefined;
+        getWorldScale?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldDirection?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        traverse?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        traverseVisible?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        traverseAncestors?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        updateMatrix?: (() => void) | undefined;
+        updateMatrixWorld?: ((force?: boolean) => void) | undefined;
+        updateWorldMatrix?: ((updateParents: boolean, updateChildren: boolean) => void) | undefined;
+        toJSON?: ((meta?: import("three").JSONMeta) => import("three").MeshJSON) | undefined;
+        clone?: ((recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        copy?: ((object: import("three").Object3D, recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        hasEventListener?: (<T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>) => boolean) | undefined;
+        dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
+        readonly isMesh?: true | undefined;
+        geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined;
+        material?: import("three").Material | import("three").Material[] | undefined;
+        morphTargetInfluences?: number[] | undefined;
+        morphTargetDictionary?: {
+            [key: string]: number;
+        } | undefined;
+        updateMorphTargets?: (() => void) | undefined;
+        getVertexPosition?: ((index: number, target: import("three").Vector3) => import("three").Vector3) | undefined;
+        position: NgtVector3;
+        up: NgtVector3;
+        scale: 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;
+    }, "scale">> & NgtsLightformerOptions, "scale" | "color" | "toneMapped" | "map" | "target" | "intensity" | "form">>;
+    private intensity;
+    private color;
+    private target;
+    private scale;
+    fixedScale: import("@angular/core").Signal<number | number[]>;
+    form: import("@angular/core").Signal<"circle" | "ring" | "rect">;
+    toneMapped: import("@angular/core").Signal<boolean>;
+    map: import("@angular/core").Signal<Texture | undefined>;
+    meshRef: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;
+    defaultMaterialRef: import("@angular/core").Signal<ElementRef<MeshBasicMaterial> | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsLightformer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsLightformer, "ngts-lightformer", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["[data-lightformer-geometry]", "[data-lightformer-material]", "*"], true, never>;
+}

package/staging/lib/matcap-texture.d.ts

@@ -0,0 +1,32 @@
+import { Injector, Signal } from '@angular/core';
+import { Texture } from 'three';
+import * as i0 from "@angular/core";
+export declare function injectMatcapTexture(id?: () => number | string, { format, onLoad, injector, }?: {
+    format?: () => number;
+    onLoad?: (texture: Texture[]) => void;
+    injector?: Injector;
+}): {
+    url: Signal<string>;
+    texture: Signal<Texture | null>;
+    numTot: Signal<number>;
+};
+export interface NgtsMatcapTextureOptions {
+    id?: number | string;
+    format?: number;
+}
+export declare class NgtsMatcapTexture {
+    matcapTexture: import("@angular/core").InputSignal<NgtsMatcapTextureOptions | undefined>;
+    matcapTextureLoaded: import("@angular/core").OutputEmitterRef<Texture[]>;
+    private injector;
+    private template;
+    private vcr;
+    private id;
+    private format;
+    private ref?;
+    constructor();
+    static ngTemplateContextGuard(_: NgtsMatcapTexture, ctx: unknown): ctx is {
+        $implicit: Signal<Texture | null>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMatcapTexture, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsMatcapTexture, "ng-template[matcapTexture]", never, { "matcapTexture": { "alias": "matcapTexture"; "required": false; "isSignal": true; }; }, { "matcapTextureLoaded": "matcapTextureLoaded"; }, never, never, true, never>;
+}

package/staging/lib/normal-texture.d.ts

@@ -0,0 +1,37 @@
+import { Injector, Signal } from '@angular/core';
+import { Texture } from 'three';
+import * as i0 from "@angular/core";
+interface NgtsNormalTextureSettings {
+    repeat?: number[];
+    anisotropy?: number;
+    offset?: number[];
+}
+export declare function injectNormalTexture(id: (() => string | number) | undefined, { settings, onLoad, injector, }: {
+    settings?: () => NgtsNormalTextureSettings;
+    onLoad?: (texture: Texture[]) => void;
+    injector?: Injector;
+}): {
+    url: Signal<string>;
+    texture: Signal<Texture | null>;
+    numTot: Signal<number>;
+};
+export interface NgtsNormalTextureOptions extends NgtsNormalTextureSettings {
+    id?: number | string;
+}
+export declare class NgtsNormalTexture {
+    normalTexture: import("@angular/core").InputSignal<NgtsNormalTextureOptions | undefined>;
+    normalTextureLoaded: import("@angular/core").OutputEmitterRef<Texture[]>;
+    private injector;
+    private template;
+    private vcr;
+    private id;
+    private settings;
+    private ref?;
+    constructor();
+    static ngTemplateContextGuard(_: NgtsNormalTexture, ctx: unknown): ctx is {
+        $implicit: Signal<Texture | null>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsNormalTexture, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsNormalTexture, "ng-template[normalTexture]", never, { "normalTexture": { "alias": "normalTexture"; "required": false; "isSignal": true; }; }, { "normalTextureLoaded": "normalTextureLoaded"; }, never, never, true, never>;
+}
+export {};

package/staging/lib/randomized-lights.d.ts

@@ -0,0 +1,54 @@
+import { ElementRef } from '@angular/core';
+import { NgtGroup } from 'angular-three';
+import { Group } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsRandomizedLightsOptions extends Partial<NgtGroup> {
+    /** How many frames it will jiggle the lights, 1.
+     *  Frames is context aware, if a provider like AccumulativeShadows exists, frames will be taken from there!  */
+    frames: number;
+    /** Light position, [0, 0, 0] */
+    position: [x: number, y: number, z: number];
+    /** Radius of the jiggle, higher values make softer light, 5 */
+    radius: number;
+    /** Amount of lights, 8 */
+    amount: number;
+    /** Light intensity, 1 */
+    intensity: number;
+    /** Ambient occlusion, lower values mean less AO, hight more, you can mix AO and directional light, 0.5 */
+    ambient: number;
+    /** If the lights cast shadows, this is true by default */
+    castShadow: boolean;
+    /** Default shadow bias, 0 */
+    bias: number;
+    /** Default map size, 512 */
+    mapSize: number;
+    /** Default size of the shadow camera, 10 */
+    size: number;
+    /** Default shadow camera near, 0.5 */
+    near: number;
+    /** Default shadow camera far, 500 */
+    far: number;
+}
+export declare class NgtsRandomizedLights {
+    options: import("@angular/core").InputSignalWithTransform<NgtsRandomizedLightsOptions, "" | Partial<NgtsRandomizedLightsOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsRandomizedLightsOptions, keyof NgtsRandomizedLightsOptions>>;
+    lightsRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    private accumulativeShadows;
+    castShadow: import("@angular/core").Signal<boolean>;
+    bias: import("@angular/core").Signal<number>;
+    intensity: import("@angular/core").Signal<number>;
+    amount: import("@angular/core").Signal<number>;
+    private mapSize;
+    shadowMapSize: import("@angular/core").Signal<number[]>;
+    private position;
+    length: import("@angular/core").Signal<number>;
+    count: import("@angular/core").Signal<number[]>;
+    private size;
+    private near;
+    private far;
+    cameraArgs: import("@angular/core").Signal<number[]>;
+    constructor();
+    update(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsRandomizedLights, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsRandomizedLights, "ngts-randomized-lights", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}