angular-three-soba 1.14.0 → 2.0.0-beta.10

package/shaders/star-field-material/star-field-material.d.ts

@@ -0,0 +1,13 @@
+import type { NgtShaderMaterial } from 'angular-three';
+import * as THREE from 'three';
+export declare const StarFieldMaterial: typeof THREE.ShaderMaterial & {
+    key: string;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-shader-material
+         */
+        'ngt-star-field-material': NgtShaderMaterial;
+    }
+}

package/shaders/wireframe-material/wireframe-material.d.ts

@@ -0,0 +1,58 @@
+import { type Injector } from '@angular/core';
+import { type NgtShaderMaterial } from 'angular-three';
+import * as THREE from 'three';
+export type WireframeMaterialState = {
+    fillOpacity?: number;
+    fillMix?: number;
+    strokeOpacity?: number;
+    thickness?: number;
+    colorBackfaces?: boolean;
+    dashInvert?: boolean;
+    dash?: boolean;
+    dashRepeats?: number;
+    dashLength?: number;
+    squeeze?: boolean;
+    squeezeMin?: number;
+    squeezeMax?: number;
+    stroke?: THREE.ColorRepresentation;
+    backfaceStroke?: THREE.ColorRepresentation;
+    fill?: THREE.ColorRepresentation;
+};
+export declare const WireframeMaterialShaders: {
+    uniforms: {
+        strokeOpacity: number;
+        fillOpacity: number;
+        fillMix: number;
+        thickness: number;
+        colorBackfaces: boolean;
+        dashInvert: boolean;
+        dash: boolean;
+        dashRepeats: number;
+        dashLength: number;
+        squeeze: boolean;
+        squeezeMin: number;
+        squeezeMax: number;
+        stroke: THREE.Color;
+        backfaceStroke: THREE.Color;
+        fill: THREE.Color;
+    };
+    vertex: string;
+    fragment: string;
+};
+export declare const WireframeMaterial: typeof THREE.ShaderMaterial & {
+    key: string;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-shader-material
+         */
+        'ngt-wireframe-material': WireframeMaterialState & NgtShaderMaterial;
+    }
+}
+export declare function setWireframeOverride(material: THREE.Material, uniforms: {
+    [key: string]: THREE.IUniform<any>;
+}): void;
+export declare function injectNgtsWireframeUniforms(uniformsFactory: () => Record<string, THREE.IUniform<any>>, stateFactory: () => Partial<WireframeMaterialState>, { injector }?: {
+    injector?: Injector;
+}): void;

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

@@ -0,0 +1,146 @@
+import { Signal } from '@angular/core';
+import { type NgtGroup } from 'angular-three';
+import { type NgtSoftShadowMaterialState } from 'angular-three-soba/shaders';
+import { Group, Mesh, PlaneGeometry } from 'three';
+import { ProgressiveLightMap } from './progressive-light-map';
+import * as i0 from "@angular/core";
+export type NgtsAccumulativeShadowsState = {
+    /** How many frames it can render, more yields cleaner results but takes more time, 40 */
+    frames: number;
+    /** If frames === Infinity blend controls the refresh ratio, 100 */
+    blend: number;
+    /** Can limit the amount of frames rendered if frames === Infinity, usually to get some performance back once a movable scene has settled, Infinity */
+    limit: number;
+    /** Scale of the plane,  */
+    scale: number;
+    /** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */
+    temporal: boolean;
+    /** Opacity of the plane, 1 */
+    opacity: number;
+    /** Discards alpha pixels, 0.65 */
+    alphaTest: number;
+    /** Shadow color, black */
+    color: string;
+    /** Colorblend, how much colors turn to black, 0 is black, 2 */
+    colorBlend: number;
+    /** Buffer resolution, 1024 */
+    resolution: number;
+    /** Texture tonemapping */
+    toneMapped: boolean;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-group
+         */
+        'ngts-accumulative-shadows': NgtsAccumulativeShadowsState & NgtGroup;
+    }
+}
+export type NgtsAccumulativeShadowsLightApi = {
+    update: () => void;
+};
+export declare const injectNgtsAccumulativeShadowsApi: {
+    (): Signal<{
+        lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
+        temporal: boolean;
+        frames: number;
+        blend: number;
+        count: number;
+        getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial>;
+        reset: () => void;
+        update: (frames?: number) => void;
+    }>;
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    }): Signal<{
+        lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
+        temporal: boolean;
+        frames: number;
+        blend: number;
+        count: number;
+        getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial>;
+        reset: () => void;
+        update: (frames?: number) => void;
+    }>;
+    (injectOptions: import("@angular/core").InjectOptions): Signal<{
+        lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
+        temporal: boolean;
+        frames: number;
+        blend: number;
+        count: number;
+        getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial>;
+        reset: () => void;
+        update: (frames?: number) => void;
+    }> | null;
+}, provideNgtsAccumulativeShadowsApi: (value?: Signal<{
+    lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
+    temporal: boolean;
+    frames: number;
+    blend: number;
+    count: number;
+    getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial>;
+    reset: () => void;
+    update: (frames?: number) => void;
+}> | undefined) => import("@angular/core").Provider;
+export declare class NgtsAccumulativeShadows {
+    private inputs;
+    nullTraverse: () => null;
+    Math: Math;
+    accumulativeShadowsRef: import("angular-three").NgtInjectedRef<Group>;
+    /** How many frames it can render, more yields cleaner results but takes more time, 40 */
+    set _frames(frames: number);
+    /** If frames === Infinity blend controls the refresh ratio, 100 */
+    set _blend(blend: number);
+    /** Can limit the amount of frames rendered if frames === Infinity, usually to get some performance back once a movable scene has settled, Infinity */
+    set _limit(limit: number);
+    /** Scale of the plane,  */
+    set _scale(scale: number);
+    /** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */
+    set _temporal(temporal: boolean);
+    /** Opacity of the plane, 1 */
+    set _opacity(opacity: number);
+    /** Discards alpha pixels, 0.65 */
+    set _alphaTest(alphaTest: number);
+    /** Shadow color, black */
+    set _color(color: string);
+    /** Colorblend, how much colors turn to black, 0 is black, 2 */
+    set _colorBlend(colorBlend: number);
+    /** Buffer resolution, 1024 */
+    set _resolution(resolution: number);
+    /** Texture tonemapping */
+    set _toneMapped(toneMapped: boolean);
+    meshRef: import("angular-three").NgtInjectedRef<Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial>>;
+    private store;
+    private gl;
+    private scene;
+    private camera;
+    private invalidate;
+    private resolution;
+    private alphaTest;
+    private opacity;
+    private temporal;
+    private blend;
+    private frames;
+    pLM: Signal<ProgressiveLightMap>;
+    scale: Signal<number>;
+    toneMapped: Signal<boolean>;
+    color: Signal<string>;
+    colorBlend: Signal<number>;
+    map: Signal<import("three").Texture>;
+    api: Signal<{
+        lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
+        temporal: boolean;
+        frames: number;
+        blend: number;
+        count: number;
+        getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial>;
+        reset: () => void;
+        update: (frames?: number) => void;
+    }>;
+    constructor();
+    private configure;
+    private resetAndUpdate;
+    private beforeRender;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAccumulativeShadows, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsAccumulativeShadows, "ngts-accumulative-shadows", never, { "accumulativeShadowsRef": { "alias": "accumulativeShadowsRef"; "required": false; }; "_frames": { "alias": "frames"; "required": false; }; "_blend": { "alias": "blend"; "required": false; }; "_limit": { "alias": "limit"; "required": false; }; "_scale": { "alias": "scale"; "required": false; }; "_temporal": { "alias": "temporal"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; "_alphaTest": { "alias": "alphaTest"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_colorBlend": { "alias": "colorBlend"; "required": false; }; "_resolution": { "alias": "resolution"; "required": false; }; "_toneMapped": { "alias": "toneMapped"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/staging/{lib/accumulative-shadows → accumulative-shadows}/progressive-light-map.d.ts

@@ -29,6 +29,6 @@ export declare class ProgressiveLightMap {
     clear(): void;
     prepare(): void;
     finish(): void;
-    configure(object: any): void;
-    update(camera: any, blendWindow?: number): void;
+    configure(object: THREE.Mesh): void;
+    update(camera: THREE.Camera, blendWindow?: number): void;
 }

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

@@ -0,0 +1,90 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,134 @@
+import { EventEmitter, 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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,70 @@
+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>;
+}