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

package/staging/accumulative-shadows/progressive-light-map.d.ts

@@ -1,34 +0,0 @@
-import * as THREE from 'three';
-export declare class ProgressiveLightMap {
-    renderer: THREE.WebGLRenderer;
-    res: number;
-    scene: THREE.Scene;
-    object: THREE.Mesh | null;
-    buffer1Active: boolean;
-    progressiveLightMap1: THREE.WebGLRenderTarget;
-    progressiveLightMap2: THREE.WebGLRenderTarget;
-    discardMat: THREE.ShaderMaterial;
-    targetMat: THREE.MeshLambertMaterial;
-    previousShadowMap: {
-        value: THREE.Texture;
-    };
-    averagingWindow: {
-        value: number;
-    };
-    clearColor: THREE.Color;
-    clearAlpha: number;
-    lights: {
-        object: THREE.Light;
-        intensity: number;
-    }[];
-    meshes: {
-        object: THREE.Mesh;
-        material: THREE.Material | THREE.Material[];
-    }[];
-    constructor(renderer: THREE.WebGLRenderer, scene: THREE.Scene, res?: number);
-    clear(): void;
-    prepare(): void;
-    finish(): void;
-    configure(object: THREE.Mesh): void;
-    update(camera: THREE.Camera, blendWindow?: number): void;
-}

package/staging/accumulative-shadows/randomized-lights.d.ts

@@ -1,90 +0,0 @@
-import { type NgtGroup } from 'angular-three';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtsRandomizedLightsState = {
-    /** 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;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-randomized-lights': NgtsRandomizedLightsState & NgtGroup;
-    }
-}
-export declare class NgtsRandomizedLights {
-    private inputs;
-    Math: Math;
-    lightsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
-    /** 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!  */
-    set _frames(frames: number);
-    /** Light position, [0, 0, 0] */
-    set _position(position: [x: number, y: number, z: number]);
-    /** Radius of the jiggle, higher values make softer light, 5 */
-    set _radius(radius: number);
-    /** Amount of lights, 8 */
-    set _amount(amount: number);
-    /** Light intensity, 1 */
-    set _intensity(intensity: number);
-    /** Ambient occlusion, lower values mean less AO, hight more, you can mix AO and directional light, 0.5 */
-    set _ambient(ambient: number);
-    /** If the lights cast shadows, this is true by default */
-    set _castShadow(castShadow: boolean);
-    /** Default shadow bias, 0 */
-    set _bias(bias: number);
-    /** Default map size, 512 */
-    set _mapSize(mapSize: number);
-    /** Default size of the shadow camera, 10 */
-    set _size(size: number);
-    /** Default shadow camera near, 0.5 */
-    set _near(near: number);
-    /** Default shadow camera far, 500 */
-    set _far(far: number);
-    private position;
-    private ambient;
-    private radius;
-    private mapSize;
-    private size;
-    private near;
-    private far;
-    private length;
-    private shadowsApi;
-    amount: import("@angular/core").Signal<number>;
-    castShadow: import("@angular/core").Signal<boolean>;
-    intensity: import("@angular/core").Signal<number>;
-    bias: import("@angular/core").Signal<number>;
-    shadowsMapSize: import("@angular/core").Signal<number[]>;
-    cameraArgs: import("@angular/core").Signal<number[]>;
-    api: import("@angular/core").Signal<{
-        update: () => void;
-    }>;
-    constructor();
-    private updateLightMap;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsRandomizedLights, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsRandomizedLights, "ngts-randomized-lights", never, { "lightsRef": { "alias": "lightsRef"; "required": false; }; "_frames": { "alias": "frames"; "required": false; }; "_position": { "alias": "position"; "required": false; }; "_radius": { "alias": "radius"; "required": false; }; "_amount": { "alias": "amount"; "required": false; }; "_intensity": { "alias": "intensity"; "required": false; }; "_ambient": { "alias": "ambient"; "required": false; }; "_castShadow": { "alias": "castShadow"; "required": false; }; "_bias": { "alias": "bias"; "required": false; }; "_mapSize": { "alias": "mapSize"; "required": false; }; "_size": { "alias": "size"; "required": false; }; "_near": { "alias": "near"; "required": false; }; "_far": { "alias": "far"; "required": false; }; }, {}, never, ["*"], true, never>;
-}

package/staging/backdrop/backdrop.d.ts

@@ -1,30 +0,0 @@
-import { type NgtGroup } from 'angular-three';
-import { PlaneGeometry } from 'three';
-import * as i0 from "@angular/core";
-export type NgtsBackdropState = {
-    floor: number;
-    segments: number;
-    receiveShadow: boolean;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-backdrop': NgtsBackdropState & NgtGroup;
-    }
-}
-export declare class NgtsBackdrop {
-    Math: Math;
-    private inputs;
-    set _floor(floor: number);
-    set _segments(segments: number);
-    set _receiveShadow(receiveShadow: boolean);
-    private floor;
-    planeRef: import("angular-three").NgtInjectedRef<PlaneGeometry>;
-    segments: import("@angular/core").Signal<number>;
-    receiveShadow: import("@angular/core").Signal<boolean>;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsBackdrop, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsBackdrop, "ngts-backdrop", never, { "_floor": { "alias": "floor"; "required": false; }; "_segments": { "alias": "segments"; "required": false; }; "_receiveShadow": { "alias": "receiveShadow"; "required": false; }; }, {}, never, ["*"], true, never>;
-}

package/staging/bb-anchor/bb-anchor.d.ts

@@ -1,27 +0,0 @@
-import { type NgtGroup } from 'angular-three';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtsBBAnchorState = {
-    anchor: THREE.Vector3 | [number, number, number];
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-bb-anchor': NgtsBBAnchorState & NgtGroup;
-    }
-}
-export declare class NgtsBBAnchor {
-    private inputs;
-    set _anchor(anchor: NgtsBBAnchorState['anchor']);
-    groupRef: import("angular-three").NgtInjectedRef<THREE.Group>;
-    private parentRef;
-    private anchor;
-    private xyz;
-    constructor();
-    private reattachParent;
-    private beforeRender;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsBBAnchor, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsBBAnchor, "ngts-bb-anchor", never, { "_anchor": { "alias": "anchor"; "required": true; }; }, {}, never, ["*"], true, never>;
-}

package/staging/bounds/bounds.d.ts

@@ -1,134 +0,0 @@
-import { EventEmitter, type Signal } from '@angular/core';
-import { type NgtGroup } from 'angular-three';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtsBoundsSize = {
-    box: THREE.Box3;
-    size: THREE.Vector3;
-    center: THREE.Vector3;
-    distance: number;
-};
-export type NgtsBoundsState = {
-    damping: number;
-    fit: boolean;
-    clip: boolean;
-    observe: boolean;
-    margin: number;
-    eps: number;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-bounds': NgtsBoundsState & NgtGroup;
-    }
-}
-export declare const injectNgtsBoundsApi: {
-    (): Signal<{
-        getSize: () => {
-            box: THREE.Box3;
-            size: THREE.Vector3;
-            center: THREE.Vector3;
-            distance: number;
-        };
-        refresh(object?: THREE.Object3D | THREE.Box3): any;
-        clip(): any;
-        to({ position, target }: {
-            position: [number, number, number];
-            target?: [number, number, number] | undefined;
-        }): any;
-        fit(): any;
-    }>;
-    (injectOptions: import("@angular/core").InjectOptions & {
-        optional?: false | undefined;
-    }): Signal<{
-        getSize: () => {
-            box: THREE.Box3;
-            size: THREE.Vector3;
-            center: THREE.Vector3;
-            distance: number;
-        };
-        refresh(object?: THREE.Object3D | THREE.Box3): any;
-        clip(): any;
-        to({ position, target }: {
-            position: [number, number, number];
-            target?: [number, number, number] | undefined;
-        }): any;
-        fit(): any;
-    }>;
-    (injectOptions: import("@angular/core").InjectOptions): Signal<{
-        getSize: () => {
-            box: THREE.Box3;
-            size: THREE.Vector3;
-            center: THREE.Vector3;
-            distance: number;
-        };
-        refresh(object?: THREE.Object3D | THREE.Box3): any;
-        clip(): any;
-        to({ position, target }: {
-            position: [number, number, number];
-            target?: [number, number, number] | undefined;
-        }): any;
-        fit(): any;
-    }> | null;
-}, provideNgtsBoundsApi: (value?: Signal<{
-    getSize: () => {
-        box: THREE.Box3;
-        size: THREE.Vector3;
-        center: THREE.Vector3;
-        distance: number;
-    };
-    refresh(object?: THREE.Object3D | THREE.Box3): any;
-    clip(): any;
-    to({ position, target }: {
-        position: [number, number, number];
-        target?: [number, number, number] | undefined;
-    }): any;
-    fit(): any;
-}> | undefined) => import("@angular/core").Provider;
-export declare class NgtsBounds {
-    private inputs;
-    boundsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
-    set _damping(damping: number);
-    set _fit(fit: boolean);
-    set _clip(clip: boolean);
-    set _observe(observe: boolean);
-    set _margin(margin: number);
-    set _eps(eps: number);
-    fitted: EventEmitter<NgtsBoundsSize>;
-    private store;
-    private controls;
-    private size;
-    private camera;
-    private invalidate;
-    private fit;
-    private clip;
-    private observe;
-    private margin;
-    private damping;
-    private current;
-    private goal;
-    private box;
-    api: Signal<{
-        getSize: () => {
-            box: THREE.Box3;
-            size: THREE.Vector3;
-            center: THREE.Vector3;
-            distance: number;
-        };
-        refresh(object?: THREE.Object3D | THREE.Box3): any;
-        clip(): any;
-        to({ position, target }: {
-            position: [number, number, number];
-            target?: [number, number, number] | undefined;
-        }): any;
-        fit(): any;
-    }>;
-    constructor();
-    private preventDragHijacking;
-    private scalePointer;
-    private beforeRender;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsBounds, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsBounds, "ngts-bounds", never, { "boundsRef": { "alias": "boundsRef"; "required": false; }; "_damping": { "alias": "damping"; "required": false; }; "_fit": { "alias": "fit"; "required": false; }; "_clip": { "alias": "clip"; "required": false; }; "_observe": { "alias": "observe"; "required": false; }; "_margin": { "alias": "margin"; "required": false; }; "_eps": { "alias": "eps"; "required": false; }; }, { "fitted": "fitted"; }, never, ["*"], true, never>;
-}

package/staging/camera-shake/camera-shake.d.ts

@@ -1,43 +0,0 @@
-import * as i0 from "@angular/core";
-export type NgtsCameraShakeState = {
-    decay?: boolean;
-    intensity: number;
-    decayRate: number;
-    maxYaw: number;
-    maxPitch: number;
-    maxRoll: number;
-    yawFrequency: number;
-    pitchFrequency: number;
-    rollFrequency: number;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        'ngts-camera-shake': NgtsCameraShakeState;
-    }
-}
-export declare class NgtsCameraShake {
-    private inputs;
-    set _intensity(intensity: number);
-    set _decay(decay: boolean);
-    set _decayRate(decayRate: number);
-    set _maxYaw(maxYaw: number);
-    set _maxPitch(maxPitch: number);
-    set _maxRoll(maxRoll: number);
-    set _yawFrequency(yawFrequency: number);
-    set _pitchFrequency(pitchFrequency: number);
-    set _rollFrequency(rollFrequency: number);
-    private store;
-    private camera;
-    private controls;
-    private initialRotation;
-    private yawNoise;
-    private rollNoise;
-    private pitchNoise;
-    private intensity;
-    private constrainedIntensity;
-    constructor();
-    private beforeRender;
-    private setEvents;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCameraShake, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsCameraShake, "ngts-camera-shake", never, { "_intensity": { "alias": "intensity"; "required": false; }; "_decay": { "alias": "decay"; "required": false; }; "_decayRate": { "alias": "decayRate"; "required": false; }; "_maxYaw": { "alias": "maxYaw"; "required": false; }; "_maxPitch": { "alias": "maxPitch"; "required": false; }; "_maxRoll": { "alias": "maxRoll"; "required": false; }; "_yawFrequency": { "alias": "yawFrequency"; "required": false; }; "_pitchFrequency": { "alias": "pitchFrequency"; "required": false; }; "_rollFrequency": { "alias": "rollFrequency"; "required": false; }; }, {}, never, never, true, never>;
-}

package/staging/center/center.d.ts

@@ -1,70 +0,0 @@
-import { EventEmitter } from '@angular/core';
-import { type NgtGroup } from 'angular-three';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtsCenteredEvent = {
-    /** 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;
-};
-export type NgtsCenterState = {
-    top?: boolean;
-    right?: boolean;
-    bottom?: boolean;
-    left?: boolean;
-    front?: boolean;
-    back?: boolean;
-    /** Disable all axes */
-    disable?: boolean;
-    /** Disable x-axis centering */
-    disableX?: boolean;
-    /** Disable y-axis centering */
-    disableY?: boolean;
-    /** Disable z-axis centering */
-    disableZ?: boolean;
-    /** See https://threejs.org/docs/index.html?q=box3#api/en/math/Box3.setFromObject */
-    precise?: boolean;
-    /** Optional cacheKey to keep the component from recalculating on every render */
-    cacheKey?: any;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-center': NgtsCenterState & NgtGroup;
-    }
-}
-export declare class NgtsCenter {
-    private inputs;
-    centerRef: import("angular-three").NgtInjectedRef<THREE.Group>;
-    outerRef: import("angular-three").NgtInjectedRef<THREE.Group>;
-    innerRef: import("angular-three").NgtInjectedRef<THREE.Group>;
-    set _top(top: boolean);
-    set _right(right: boolean);
-    set _bottom(bottom: boolean);
-    set _left(left: boolean);
-    set _front(front: boolean);
-    set _back(back: boolean);
-    set _disableX(disableX: boolean);
-    set _disableY(disableY: boolean);
-    set _disableZ(disableZ: boolean);
-    set _disable(disable: boolean);
-    set _precise(precise: boolean);
-    set _cacheKey(cacheKey: any);
-    centered: EventEmitter<NgtsCenteredEvent>;
-    constructor();
-    private setPosition;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCenter, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCenter, "ngts-center", never, { "centerRef": { "alias": "centerRef"; "required": false; }; "_top": { "alias": "top"; "required": false; }; "_right": { "alias": "right"; "required": false; }; "_bottom": { "alias": "bottom"; "required": false; }; "_left": { "alias": "left"; "required": false; }; "_front": { "alias": "front"; "required": false; }; "_back": { "alias": "back"; "required": false; }; "_disableX": { "alias": "disableX"; "required": false; }; "_disableY": { "alias": "disableY"; "required": false; }; "_disableZ": { "alias": "disableZ"; "required": false; }; "_disable": { "alias": "disable"; "required": false; }; "_precise": { "alias": "precise"; "required": false; }; "_cacheKey": { "alias": "cacheKey"; "required": false; }; }, { "centered": "centered"; }, never, ["*"], true, never>;
-}

package/staging/cloud/cloud.d.ts

@@ -1,51 +0,0 @@
-import { type NgtBeforeRenderEvent, type NgtGroup } from 'angular-three';
-import { Group } from 'three';
-import * as i0 from "@angular/core";
-export type NgtsCloudState = {
-    opacity: number;
-    speed: number;
-    width: number;
-    depth: number;
-    segments: number;
-    texture: string;
-    color: THREE.ColorRepresentation;
-    depthTest: boolean;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-cloud': NgtsCloudState & NgtGroup;
-    }
-}
-export declare class NgtsCloud {
-    private inputs;
-    groupRef: import("angular-three").NgtInjectedRef<Group>;
-    set _opacity(opacity: number);
-    set _speed(speed: number);
-    set _width(width: number);
-    set _depth(depth: number);
-    set _segments(segments: number);
-    set _texture(texture: string);
-    set _color(color: THREE.ColorRepresentation);
-    set _depthTest(depthTest: boolean);
-    private width;
-    private speed;
-    segments: import("@angular/core").Signal<number>;
-    depth: import("@angular/core").Signal<number>;
-    depthTest: import("@angular/core").Signal<boolean>;
-    opacity: import("@angular/core").Signal<number>;
-    color: import("@angular/core").Signal<import("three").ColorRepresentation>;
-    texture: import("@angular/core").Signal<import("three").Texture | null>;
-    clouds: import("@angular/core").Signal<{
-        x: number;
-        y: number;
-        scale: number;
-        density: number;
-        rotation: number;
-    }[]>;
-    onBeforeRender({ state, object }: NgtBeforeRenderEvent<Group>): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCloud, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCloud, "ngts-cloud", never, { "groupRef": { "alias": "groupRef"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; "_speed": { "alias": "speed"; "required": false; }; "_width": { "alias": "width"; "required": false; }; "_depth": { "alias": "depth"; "required": false; }; "_segments": { "alias": "segments"; "required": false; }; "_texture": { "alias": "texture"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_depthTest": { "alias": "depthTest"; "required": false; }; }, {}, never, never, true, never>;
-}

package/staging/contact-shadows/contact-shadows.d.ts

@@ -1,70 +0,0 @@
-import { type NgtGroup } from 'angular-three';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtsContactShadowsState = {
-    opacity: number;
-    width: number;
-    height: number;
-    blur: number;
-    far: number;
-    smooth: boolean;
-    resolution: number;
-    frames: number;
-    scale: number | [x: number, y: number];
-    color: THREE.ColorRepresentation;
-    depthWrite: boolean;
-    renderOrder: number;
-};
-declare global {
-    interface HTMLElementTagNameMap {
-        /**
-         * @extends ngt-group
-         */
-        'ngts-contact-shadows': NgtsContactShadowsState & NgtGroup;
-    }
-}
-export declare class NgtsContactShadows {
-    private inputs;
-    contactShadowsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
-    set _opacity(opacity: number);
-    set _width(width: number);
-    set _height(height: number);
-    set _blur(blur: number);
-    set _far(far: number);
-    set _smooth(smooth: boolean);
-    set _resolution(resolution: number);
-    set _frames(frames: number);
-    set _scale(scale: number | [x: number, y: number]);
-    set _color(color: THREE.ColorRepresentation);
-    set _depthWrite(depthWrite: boolean);
-    set _renderOrder(renderOrder: number);
-    Math: Math;
-    private store;
-    shadowCameraRef: import("angular-three").NgtInjectedRef<THREE.OrthographicCamera>;
-    private scale;
-    private width;
-    private height;
-    private far;
-    private resolution;
-    private color;
-    private scaledWidth;
-    private scaledHeight;
-    renderOrder: import("@angular/core").Signal<number>;
-    opacity: import("@angular/core").Signal<number>;
-    depthWrite: import("@angular/core").Signal<boolean>;
-    cameraArgs: import("@angular/core").Signal<number[]>;
-    contactShadows: import("@angular/core").Signal<{
-        renderTarget: THREE.WebGLRenderTarget<THREE.Texture>;
-        planeGeometry: THREE.PlaneGeometry;
-        depthMaterial: THREE.MeshDepthMaterial;
-        blurPlane: THREE.Mesh<THREE.PlaneGeometry, THREE.Material | THREE.Material[]>;
-        horizontalBlurMaterial: THREE.ShaderMaterial;
-        verticalBlurMaterial: THREE.ShaderMaterial;
-        renderTargetBlur: THREE.WebGLRenderTarget<THREE.Texture>;
-    }>;
-    constructor();
-    private beforeRender;
-    private blurShadows;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsContactShadows, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsContactShadows, "ngts-contact-shadows", never, { "contactShadowsRef": { "alias": "contactShadowsRef"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; "_width": { "alias": "width"; "required": false; }; "_height": { "alias": "height"; "required": false; }; "_blur": { "alias": "blur"; "required": false; }; "_far": { "alias": "far"; "required": false; }; "_smooth": { "alias": "smooth"; "required": false; }; "_resolution": { "alias": "resolution"; "required": false; }; "_frames": { "alias": "frames"; "required": false; }; "_scale": { "alias": "scale"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_depthWrite": { "alias": "depthWrite"; "required": false; }; "_renderOrder": { "alias": "renderOrder"; "required": false; }; }, {}, never, never, true, never>;
-}

package/staging/environment/assets.d.ts

@@ -1,13 +0,0 @@
-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 NgtsEnvironmentPresetsType = keyof typeof ENVIRONMENT_PRESETS;

package/staging/environment/environment-cube.d.ts

@@ -1,15 +0,0 @@
-import { NgtsEnvironmentInput } from './environment-input';
-import * as i0 from "@angular/core";
-export declare class NgtsEnvironmentCube {
-    environmentInput: NgtsEnvironmentInput;
-    private inputs;
-    set _background(background: boolean);
-    private store;
-    private scene;
-    private background;
-    private textureRef;
-    constructor();
-    private setEnvProps;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentCube, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentCube, "ngts-environment-cube", never, { "_background": { "alias": "background"; "required": false; }; }, {}, never, never, true, never>;
-}

package/staging/environment/environment-ground.d.ts

@@ -1,13 +0,0 @@
-import { NgtsEnvironmentInput } from './environment-input';
-import * as i0 from "@angular/core";
-export declare class NgtsEnvironmentGround {
-    environmentInput: NgtsEnvironmentInput;
-    private defaultTexture;
-    texture: import("@angular/core").Signal<import("three").Texture>;
-    groundArgs: import("@angular/core").Signal<import("three").Texture[]>;
-    height: import("@angular/core").Signal<any>;
-    radius: import("@angular/core").Signal<any>;
-    scale: import("@angular/core").Signal<any>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentGround, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironmentGround, "ngts-environment-ground", never, {}, {}, never, never, true, never>;
-}