angular-three 0.0.2 → 0.0.3

package/geometries/lib/circle-geometry/circle-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtCircleGeometry extends THREE.CircleGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtCircleGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtCircleGeometry, "ngt-circle-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/cone-geometry/cone-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtConeGeometry extends THREE.ConeGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtConeGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtConeGeometry, "ngt-cone-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/cylinder-geometry/cylinder-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtCylinderGeometry extends THREE.CylinderGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtCylinderGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtCylinderGeometry, "ngt-cylinder-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/dodecahedron-geometry/dodecahedron-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtDodecahedronGeometry extends THREE.DodecahedronGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtDodecahedronGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtDodecahedronGeometry, "ngt-dodecahedron-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/edges-geometry/edges-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtEdgesGeometry extends THREE.EdgesGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtEdgesGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtEdgesGeometry, "ngt-edges-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/extrude-geometry/extrude-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtExtrudeGeometry extends THREE.ExtrudeGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtExtrudeGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtExtrudeGeometry, "ngt-extrude-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/icosahedron-geometry/icosahedron-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtIcosahedronGeometry extends THREE.IcosahedronGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtIcosahedronGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtIcosahedronGeometry, "ngt-icosahedron-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/instanced-buffer-geometry/instanced-buffer-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtInstancedBufferGeometry extends THREE.InstancedBufferGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtInstancedBufferGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtInstancedBufferGeometry, "ngt-instanced-buffer-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/lathe-geometry/lathe-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtLatheGeometry extends THREE.LatheGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtLatheGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtLatheGeometry, "ngt-lathe-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/octahedron-geometry/octahedron-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtOctahedronGeometry extends THREE.OctahedronGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtOctahedronGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtOctahedronGeometry, "ngt-octahedron-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/plane-geometry/plane-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtPlaneGeometry extends THREE.PlaneGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtPlaneGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtPlaneGeometry, "ngt-plane-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/polyhedron-geometry/polyhedron-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtPolyhedronGeometry extends THREE.PolyhedronGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtPolyhedronGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtPolyhedronGeometry, "ngt-polyhedron-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/ring-geometry/ring-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtRingGeometry extends THREE.RingGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtRingGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtRingGeometry, "ngt-ring-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/shape-geometry/shape-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtShapeGeometry extends THREE.ShapeGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtShapeGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtShapeGeometry, "ngt-shape-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/sphere-geometry/sphere-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtSphereGeometry extends THREE.SphereGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtSphereGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtSphereGeometry, "ngt-sphere-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/tetrahedron-geometry/tetrahedron-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtTetrahedronGeometry extends THREE.TetrahedronGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtTetrahedronGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtTetrahedronGeometry, "ngt-tetrahedron-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/torus-geometry/torus-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtTorusGeometry extends THREE.TorusGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtTorusGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtTorusGeometry, "ngt-torus-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/torus-knot-geometry/torus-knot-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtTorusKnotGeometry extends THREE.TorusKnotGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtTorusKnotGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtTorusKnotGeometry, "ngt-torus-knot-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/tube-geometry/tube-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtTubeGeometry extends THREE.TubeGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtTubeGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtTubeGeometry, "ngt-tube-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/geometries/lib/wireframe-geometry/wireframe-geometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtWireframeGeometry extends THREE.WireframeGeometry {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtWireframeGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtWireframeGeometry, "ngt-wireframe-geometry", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/helpers/README.md

@@ -0,0 +1,3 @@
+# angular-three/helpers
+
+Secondary entry point of `angular-three`. It can be used by importing from `angular-three/helpers`.

package/helpers/index.d.ts

@@ -0,0 +1,13 @@
+export * from './lib/arrow-helper/arrow-helper';
+export * from './lib/axes-helper/axes-helper';
+export * from './lib/grid-helper/grid-helper';
+export * from './lib/polar-grid-helper/polar-grid-helper';
+export * from './lib/box-helper/box-helper';
+export * from './lib/box3-helper/box3-helper';
+export * from './lib/camera-helper/camera-helper';
+export * from './lib/directional-light-helper/directional-light-helper';
+export * from './lib/hemisphere-light-helper/hemisphere-light-helper';
+export * from './lib/plane-helper/plane-helper';
+export * from './lib/point-light-helper/point-light-helper';
+export * from './lib/skeleton-helper/skeleton-helper';
+export * from './lib/spot-light-helper/spot-light-helper';

package/helpers/lib/arrow-helper/arrow-helper.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtArrowHelper extends THREE.ArrowHelper {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtArrowHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtArrowHelper, "ngt-arrow-helper", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/helpers/lib/axes-helper/axes-helper.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtAxesHelper extends THREE.AxesHelper {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtAxesHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtAxesHelper, "ngt-axes-helper", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/helpers/lib/box-helper/box-helper.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtBoxHelper extends THREE.BoxHelper {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtBoxHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtBoxHelper, "ngt-box-helper", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/helpers/lib/box3-helper/box3-helper.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtBox3Helper extends THREE.Box3Helper {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtBox3Helper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtBox3Helper, "ngt-box3-helper", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/helpers/lib/camera-helper/camera-helper.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtCameraHelper extends THREE.CameraHelper {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtCameraHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtCameraHelper, "ngt-camera-helper", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/helpers/lib/directional-light-helper/directional-light-helper.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtDirectionalLightHelper extends THREE.DirectionalLightHelper {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtDirectionalLightHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtDirectionalLightHelper, "ngt-directional-light-helper", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/helpers/lib/grid-helper/grid-helper.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtGridHelper extends THREE.GridHelper {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtGridHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtGridHelper, "ngt-grid-helper", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/helpers/lib/hemisphere-light-helper/hemisphere-light-helper.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtHemisphereLightHelper extends THREE.HemisphereLightHelper {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtHemisphereLightHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtHemisphereLightHelper, "ngt-hemisphere-light-helper", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/helpers/lib/plane-helper/plane-helper.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtPlaneHelper extends THREE.PlaneHelper {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtPlaneHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtPlaneHelper, "ngt-plane-helper", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/helpers/lib/point-light-helper/point-light-helper.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtPointLightHelper extends THREE.PointLightHelper {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtPointLightHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtPointLightHelper, "ngt-point-light-helper", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/helpers/lib/polar-grid-helper/polar-grid-helper.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtPolarGridHelper extends THREE.PolarGridHelper {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtPolarGridHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtPolarGridHelper, "ngt-polar-grid-helper", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/helpers/lib/skeleton-helper/skeleton-helper.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtSkeletonHelper extends THREE.SkeletonHelper {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtSkeletonHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtSkeletonHelper, "ngt-skeleton-helper", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/helpers/lib/spot-light-helper/spot-light-helper.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export declare class NgtSpotLightHelper extends THREE.SpotLightHelper {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtSpotLightHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtSpotLightHelper, "ngt-spot-light-helper", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.NgtInstance; inputs: {}; outputs: {}; }]>;
+}

package/index.d.ts

@@ -1 +1,11 @@
-export * from './lib/angular-three.module';
+export * from './lib/canvas';
+export * from './lib/types';
+export * from './lib/instance';
+export * from './lib/services/loader';
+export * from './lib/services/resize';
+export * from './lib/stores/store';
+export * from './lib/stores/component-store';
+export * from './lib/directives/args';
+export * from './lib/utils/proxy';
+export * from './lib/utils/loop';
+export * from './lib/di/resize';

package/lib/canvas.d.ts

@@ -0,0 +1,46 @@
+import { ElementRef, EventEmitter, OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as THREE from 'three';
+import { NgtResizeResult } from './services/resize';
+import { NgtComponentStore } from './stores/component-store';
+import type { NgtCanvasInputs, NgtDpr, NgtObservableInput, NgtVector3 } from './types';
+import * as i0 from "@angular/core";
+export declare class NgtCanvasContainer {
+    resize: Observable<NgtResizeResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtCanvasContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtCanvasContainer, "ngt-canvas-container", never, {}, { "resize": "resize"; }, never, ["*"], true, never>;
+}
+export declare class NgtCanvas extends NgtComponentStore<NgtCanvasInputs> implements OnInit, OnDestroy {
+    readonly hostClass = true;
+    get pointerEvents(): "auto" | "none";
+    set linear(linear: NgtObservableInput<boolean>);
+    set legacy(legacy: NgtObservableInput<boolean>);
+    set flat(flat: NgtObservableInput<boolean>);
+    set orthographic(orthographic: NgtObservableInput<boolean>);
+    set frameloop(frameloop: NgtObservableInput<'always' | 'demand' | 'never'>);
+    set dpr(dpr: NgtObservableInput<NgtDpr>);
+    set raycaster(raycaster: Partial<THREE.Raycaster>);
+    set shadows(shadows: boolean | Partial<THREE.WebGLShadowMap>);
+    set camera(camera: NgtCanvasInputs['camera']);
+    set gl(gl: NgtCanvasInputs['gl']);
+    set eventSource(eventSource: NgtCanvasInputs['eventSource']);
+    set eventPrefix(eventPrefix: NgtCanvasInputs['eventPrefix']);
+    set lookAt(lookAt: NgtObservableInput<NgtVector3>);
+    set performance(performance: NgtCanvasInputs['performance']);
+    created: EventEmitter<any>;
+    canvasPointerMissed: EventEmitter<any>;
+    glCanvas: ElementRef<HTMLCanvasElement>;
+    canvasContent: TemplateRef<unknown>;
+    private readonly zone;
+    private readonly loader;
+    private readonly store;
+    private readonly host;
+    get sceneRef(): import("./ref").NgtRef<THREE.Scene>;
+    get isConfigured(): boolean;
+    initialize(): void;
+    ngOnInit(): void;
+    onResize(resizeResult: NgtResizeResult): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtCanvas, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtCanvas, "ngt-canvas", never, { "linear": "linear"; "legacy": "legacy"; "flat": "flat"; "orthographic": "orthographic"; "frameloop": "frameloop"; "dpr": "dpr"; "raycaster": "raycaster"; "shadows": "shadows"; "camera": "camera"; "gl": "gl"; "eventSource": "eventSource"; "eventPrefix": "eventPrefix"; "lookAt": "lookAt"; "performance": "performance"; }, { "created": "created"; "canvasPointerMissed": "canvasPointerMissed"; }, ["canvasContent"], ["*"], true, never>;
+}

package/lib/di/resize.d.ts

@@ -0,0 +1,12 @@
+export interface NgtResizeOptions {
+    box: ResizeObserverBoxOptions;
+    debounce: number | {
+        scroll: number;
+        resize: number;
+    };
+    scroll: boolean;
+    offsetSize: boolean;
+}
+export declare const defaultResizeOptions: NgtResizeOptions;
+export declare const injectResizeOptions: (options?: import("@angular/core").InjectOptions | undefined) => NgtResizeOptions, provideResizeOptions: (value: Partial<NgtResizeOptions>) => import("@angular/core").Provider;
+export declare const injectResizeObserverSupport: (options?: import("@angular/core").InjectOptions | undefined) => boolean;

package/lib/di/window.d.ts

@@ -0,0 +1 @@
+export declare const injectWindow: (options?: import("@angular/core").InjectOptions | undefined) => Window & typeof globalThis;

package/lib/directives/args.d.ts

@@ -0,0 +1,19 @@
+import { InjectionToken, InjectOptions } from '@angular/core';
+import { NgtAnyCtor } from '../types';
+import * as i0 from "@angular/core";
+export declare const NGT_ARGS: InjectionToken<unknown[]>;
+export declare function injectArgs<TCtor extends NgtAnyCtor = NgtAnyCtor>(): ConstructorParameters<TCtor>;
+export declare function injectArgs<TCtor extends NgtAnyCtor = NgtAnyCtor>(options: InjectOptions & {
+    optional?: false;
+}): ConstructorParameters<TCtor>;
+export declare function injectArgs<TCtor extends NgtAnyCtor = NgtAnyCtor>(options: InjectOptions & {
+    optional?: true;
+}): ConstructorParameters<TCtor> | null;
+export declare class NgtArgs {
+    private readonly templateRef;
+    private readonly vcr;
+    private view?;
+    set args(args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtArgs, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtArgs, "[args]", never, { "args": "args"; }, {}, never, never, true, never>;
+}

package/lib/events.d.ts

@@ -0,0 +1,2 @@
+import type { NgtEventManager, NgtStateFactory } from './types';
+export declare function createPointerEvents(stateFactory: NgtStateFactory): NgtEventManager<HTMLElement>;

package/lib/instance.d.ts

@@ -0,0 +1,81 @@
+import { EventEmitter, InjectionToken, InjectOptions, OnDestroy, OnInit } from '@angular/core';
+import { NgtRef } from './ref';
+import { NgtComponentStore } from './stores/component-store';
+import type { NgtAnyCtor, NgtAnyFunction, NgtAnyRecord, NgtAttachFunction, NgtBeforeRenderCallback, NgtInstanceLocalState, NgtObservableInput, NgtThreeEvent } from './types';
+import * as i0 from "@angular/core";
+export declare const NGT_PROXY_INSTANCE: unique symbol;
+export declare const NGT_INSTANCE_REF_FACTORY: InjectionToken<NgtAnyFunction<NgtRef<any>>>;
+export declare function provideInstanceRef<TInstanceType extends object = any, TCtor extends NgtAnyCtor<TInstanceType> = NgtAnyCtor<TInstanceType>>(ctor: TCtor, factory?: (instance: InstanceType<TCtor>) => NgtRef): {
+    provide: InjectionToken<NgtAnyFunction<NgtRef<any>>>;
+    useFactory: (instance: InstanceType<TCtor>) => () => any;
+    deps: TCtor[];
+};
+export declare function injectInstanceRef(): NgtAnyFunction<NgtRef>;
+export declare function injectInstanceRef(options: InjectOptions & {
+    optional?: false;
+}): NgtAnyFunction<NgtRef>;
+export declare function injectInstanceRef(options: InjectOptions & {
+    optional?: true;
+}): NgtAnyFunction<NgtRef> | null;
+export interface NgtInstanceState<TInstance extends object = NgtAnyRecord> {
+    instanceRef: NgtRef<TInstance>;
+    instanceArgs: unknown[];
+    attach: string[] | NgtAttachFunction;
+    noAttach: boolean;
+    skipWrapper: boolean;
+    skipInit: boolean;
+}
+export declare function injectInstance<T extends object>(): NgtInstance<T>;
+export declare function injectInstance<T extends object>(options: InjectOptions & {
+    optional?: false;
+}): NgtInstance<T>;
+export declare function injectInstance<T extends object>(options: InjectOptions & {
+    optional?: true;
+}): NgtInstance<T> | null;
+export declare class NgtInstance<TInstance extends object = any, TInstanceState extends NgtInstanceState<TInstance> = NgtInstanceState<TInstance>> extends NgtComponentStore<TInstanceState> implements OnInit, OnDestroy {
+    set ref(instance: TInstance | NgtRef<TInstance>);
+    set skipWrapper(skipWrapper: NgtObservableInput<boolean>);
+    set skipInit(skipInit: NgtObservableInput<boolean>);
+    set noAttach(noAttach: NgtObservableInput<boolean>);
+    set attach(value: string | string[] | [string, ...(string | number)[]] | NgtAttachFunction | undefined);
+    priority: number;
+    beforeRender?: NgtBeforeRenderCallback<TInstance>;
+    readyCallback?: ((instance: TInstance) => void) | (() => void);
+    updateCallback?: ((instance: TInstance) => void) | (() => void);
+    click: EventEmitter<NgtThreeEvent<MouseEvent>>;
+    contextmenu: EventEmitter<NgtThreeEvent<MouseEvent>>;
+    dblclick: EventEmitter<NgtThreeEvent<MouseEvent>>;
+    pointerup: EventEmitter<NgtThreeEvent<PointerEvent>>;
+    pointerdown: EventEmitter<NgtThreeEvent<PointerEvent>>;
+    pointerover: EventEmitter<NgtThreeEvent<PointerEvent>>;
+    pointerout: EventEmitter<NgtThreeEvent<PointerEvent>>;
+    pointerenter: EventEmitter<NgtThreeEvent<PointerEvent>>;
+    pointerleave: EventEmitter<NgtThreeEvent<PointerEvent>>;
+    pointermove: EventEmitter<NgtThreeEvent<PointerEvent>>;
+    pointermissed: EventEmitter<NgtThreeEvent<PointerEvent>>;
+    pointercancel: EventEmitter<NgtThreeEvent<PointerEvent>>;
+    wheel: EventEmitter<NgtThreeEvent<WheelEvent>>;
+    private readonly zone;
+    private readonly store;
+    private readonly parentRef;
+    private _isRaw;
+    set isRaw(val: boolean);
+    private hasEmittedAlready;
+    private readonly instanceReady;
+    private handleEvents;
+    private readonly attachToParent;
+    initialize(): void;
+    ngOnInit(): void;
+    get instanceRef(): NgtRef<TInstance>;
+    get instanceValue(): TInstance;
+    get proxyInstance(): TInstance;
+    get __ngt__(): NgtInstanceLocalState;
+    get parent(): NgtRef | undefined;
+    ngOnDestroy(): void;
+    private destroy;
+    private eventNameToHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtInstance<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtInstance<any, any>, "[ngtInstance]", ["ngtInstance"], { "ref": "ref"; "skipWrapper": "skipWrapper"; "skipInit": "skipInit"; "noAttach": "noAttach"; "attach": "attach"; "priority": "priority"; "beforeRender": "beforeRender"; "readyCallback": "readyCallback"; "updateCallback": "updateCallback"; }, { "click": "click"; "contextmenu": "contextmenu"; "dblclick": "dblclick"; "pointerup": "pointerup"; "pointerdown": "pointerdown"; "pointerover": "pointerover"; "pointerout": "pointerout"; "pointerenter": "pointerenter"; "pointerleave": "pointerleave"; "pointermove": "pointermove"; "pointermissed": "pointermissed"; "pointercancel": "pointercancel"; "wheel": "wheel"; }, never, never, true, never>;
+}
+export declare const NGT_INSTANCE_INPUTS: string[];
+export declare const NGT_INSTANCE_OUTPUTS: ("click" | "contextmenu" | "dblclick" | "pointerup" | "pointerdown" | "pointerover" | "pointerout" | "pointerenter" | "pointerleave" | "pointermove" | "pointermissed" | "pointercancel" | "wheel")[];

package/lib/ref.d.ts

@@ -0,0 +1,5 @@
+import { BehaviorSubject } from 'rxjs';
+export declare class NgtRef<T = any> extends BehaviorSubject<T> {
+    constructor(value?: T | null);
+    set(valueOrFactory: T | ((previous: T) => T)): void;
+}

package/lib/services/loader.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+import type { NgtAnyConstructor, NgtBranchingReturn, NgtLoaderExtensions, NgtLoaderResult, NgtObjectMap } from '../types';
+import * as i0 from "@angular/core";
+export declare class NgtLoader {
+    private readonly cached;
+    use<TReturnType, TUrl extends string | string[]>(loadConstructor: NgtAnyConstructor<NgtLoaderResult<TReturnType>>, input: TUrl, extensions?: NgtLoaderExtensions, onProgress?: (event: ProgressEvent) => void): TUrl extends string[] ? Observable<Array<NgtBranchingReturn<TReturnType, GLTF, GLTF & NgtObjectMap>>> : Observable<NgtBranchingReturn<TReturnType, GLTF, GLTF & NgtObjectMap>>;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtLoader, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgtLoader>;
+}

package/lib/services/resize.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface NgtResizeResult {
+    readonly entries: ReadonlyArray<ResizeObserverEntry>;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly left: number;
+    readonly dpr: number;
+}
+export declare class NgtResize extends Observable<NgtResizeResult> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtResize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgtResize>;
+}