angular-three 4.0.0-next.99 → 4.0.0

package/types/angular-three.d.ts

@@ -0,0 +1,2267 @@
+import * as _angular_core from '@angular/core';
+import { Injector, Signal, WritableSignal, ElementRef, Provider, ProviderToken, Type, AbstractType, InjectionToken, ResourceRef, RendererFactory2, RendererType2, Renderer2, ChangeDetectorRef, InjectOptions, OutputEmitterRef, ValueEqualityFn } from '@angular/core';
+import * as THREE from 'three';
+import { Object3D } from 'three';
+import { Observable } from 'rxjs';
+import { Router } from '@angular/router';
+import * as angular_three from 'angular-three';
+
+/**
+ * Abstract base class for Angular Three structural directives.
+ *
+ * This class provides common functionality for structural directives like `NgtArgs` and `NgtParent`,
+ * including view management, value injection, and change detection.
+ *
+ * Subclasses must implement:
+ * - `validate()`: Returns true if the directive has a valid value to inject
+ * - `linkedValue`: A signal containing the current value
+ * - `shouldSkipRender`: A signal indicating whether rendering should be skipped
+ *
+ * @typeParam TValue - The type of value this directive manages
+ */
+declare abstract class NgtCommonDirective<TValue> {
+    private vcr;
+    private template;
+    protected injector: Injector;
+    protected injected: boolean;
+    protected injectedValue: TValue | null;
+    private view?;
+    protected get commentNode(): any;
+    abstract validate(): boolean;
+    protected abstract linkedValue: Signal<TValue | null>;
+    protected abstract shouldSkipRender: Signal<boolean>;
+    protected constructor();
+    get value(): TValue | null;
+    protected beforeCreateView(): void;
+    private createView;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgtCommonDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgtCommonDirective<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Structural directive for passing constructor arguments to Three.js elements.
+ *
+ * The `NgtArgs` directive allows you to pass constructor arguments to Three.js objects
+ * when they are created. This is essential for objects that require constructor arguments
+ * like geometries, materials, and custom objects.
+ *
+ * @example
+ * ```html
+ * <!-- Pass arguments to BoxGeometry constructor -->
+ * <ngt-mesh>
+ *   <ngt-box-geometry *args="[1, 2, 3]" />
+ * </ngt-mesh>
+ *
+ * <!-- Use with primitive for external objects -->
+ * <ngt-primitive *args="[myObject]" />
+ * ```
+ */
+declare class NgtArgs extends NgtCommonDirective<any[]> {
+    args: _angular_core.InputSignal<any[] | null>;
+    protected linkedValue: _angular_core.WritableSignal<any[] | null>;
+    protected shouldSkipRender: _angular_core.Signal<boolean>;
+    constructor();
+    validate(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgtArgs, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgtArgs, "ng-template[args]", never, { "args": { "alias": "args"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NgtNonFunctionKeys<T> = {
+    [K in keyof T]-?: T[K] extends Function ? never : K;
+}[keyof T];
+type NgtOverwrite<T, O> = Omit<T, NgtNonFunctionKeys<O>> & O;
+type NgtProperties<T> = Pick<T, NgtNonFunctionKeys<T>>;
+type NgtMutable<P> = {
+    [K in keyof P]: P[K] extends Array<any> ? P[K] : P[K] | Readonly<P[K]>;
+};
+interface NgtMathRepresentation {
+    set(...args: number[]): any;
+}
+interface NgtVectorRepresentation extends NgtMathRepresentation {
+    setScalar(value: number): any;
+}
+type NgtMathTypes = NgtMathRepresentation | THREE.Euler | THREE.Color;
+type NgtMathType<T extends NgtMathTypes> = T extends THREE.Color ? NgtArguments<typeof THREE.Color> | THREE.ColorRepresentation : T extends NgtVectorRepresentation | THREE.Layers | THREE.Euler ? T | Parameters<T['set']> | number : T | Parameters<T['set']>;
+type NgtMathProperties<P> = {
+    [K in keyof P as P[K] extends NgtMathTypes ? K : never]: P[K] extends NgtMathTypes ? NgtMathType<P[K]> : never;
+};
+type NgtIsProperties<P> = {
+    [K in keyof P as P[K] extends true ? K : never]: true;
+};
+type NgtNonMutableProperties = 'id' | 'uuid' | 'name' | 'type' | 'parent' | 'children';
+type NgtNonPartialProperties<P> = {
+    [K in keyof P as K extends NgtNonMutableProperties ? K : never]: P[K];
+};
+type NgtNullableRaycast<P> = {
+    [K in keyof P as K extends 'raycast' ? K : never]: K extends 'raycast' ? P[K] | null : never;
+};
+type NgtVector2 = NgtMathType<THREE.Vector2>;
+type NgtVector3 = NgtMathType<THREE.Vector3>;
+type NgtVector4 = NgtMathType<THREE.Vector4>;
+type NgtColor = NgtMathType<THREE.Color>;
+type NgtLayers = NgtMathType<THREE.Layers>;
+type NgtQuaternion = NgtMathType<THREE.Quaternion>;
+type NgtEuler = NgtMathType<THREE.Euler>;
+type NgtMatrix3 = NgtMathType<THREE.Matrix3>;
+type NgtMatrix4 = NgtMathType<THREE.Matrix4>;
+interface NgtRaycastableRepresentation {
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+}
+type ThreeDisposeEvent = {
+    type: 'dispose';
+    target: any;
+};
+type ThreeChangeEvent = {
+    type: 'change';
+    target: any;
+};
+type ThreeAddedEvent = {
+    type: 'added';
+    target: any;
+};
+type ThreeRemovedEvent = {
+    type: 'removed';
+    target: any;
+};
+type ThreeChildAddedEvent = {
+    type: 'childadded';
+    target: any;
+    child: any;
+};
+type ThreeChildRemovedEvent = {
+    type: 'childremoved';
+    target: any;
+    child: any;
+};
+interface NgtNodeEventMap<TInstance = NgtAnyRecord> {
+    attached: NgtAfterAttach<TInstance, any>;
+    updated: TInstance;
+    created: TInstance;
+    disposed: ThreeDisposeEvent;
+}
+type NgtObject3DEventsMap = {
+    [TEvent in keyof NgtEventHandlers]-?: Parameters<NonNullable<NgtEventHandlers[TEvent]>>[0];
+} & {
+    added: ThreeAddedEvent;
+    removed: ThreeRemovedEvent;
+    childadded: ThreeChildAddedEvent;
+    childremoved: ThreeChildRemovedEvent;
+    change: ThreeChangeEvent;
+};
+type NgtAllObject3DEventsMap<TInstance> = NgtObject3DEventsMap & NgtNodeEventMap<TInstance>;
+interface NgtNodeElement<TConstructor extends NgtConstructorRepresentation, TInstance = InstanceType<TConstructor>> {
+    attach: string | string[] | NgtAttachFunction;
+    dispose?: (() => void) | null;
+    parameters: Partial<TInstance>;
+    __ngt_args__?: NgtArguments<TConstructor>;
+}
+interface NgtNodeEventListener<TConstructor extends NgtConstructorRepresentation, TInstance = InstanceType<TConstructor>, TEventMap extends NgtNodeEventMap<TInstance> = TInstance extends NgtRaycastableRepresentation ? NgtAllObject3DEventsMap<TInstance> : NgtNodeEventMap<TInstance>> {
+    addEventListener<TEventKey extends keyof TEventMap>(type: TEventKey, listener: (this: NgtNodeElement<TConstructor, TInstance>, ev: TEventMap[TEventKey]) => any): void;
+    removeEventListener<TEventKey extends keyof TEventMap>(type: TEventKey, listener: (this: NgtNodeElement<TConstructor, TInstance>, ev: TEventMap[TEventKey]) => any): void;
+}
+type NgtElementProperties<TConstructor extends NgtConstructorRepresentation, TInstance = InstanceType<TConstructor>> = Partial<NgtOverwrite<TInstance, NgtMathProperties<TInstance> & NgtNullableRaycast<TInstance>>> & NgtIsProperties<TInstance> & NgtNonPartialProperties<TInstance> & NgtNodeElement<TConstructor, TInstance>;
+type NgtThreeElement<TConstructor extends NgtConstructorRepresentation> = NgtMutable<NgtElementProperties<TConstructor>> & NgtNodeEventListener<TConstructor>;
+type ThreeExports = typeof THREE;
+type NgtThreeElementsImpl = {
+    [K in keyof ThreeExports]: ThreeExports[K] extends NgtConstructorRepresentation ? NgtThreeElement<ThreeExports[K]> : never;
+};
+interface NgtThreeElements {
+    'ngt-scene': NgtThreeElementsImpl['Scene'];
+    'ngt-object3D': NgtThreeElementsImpl['Object3D'];
+    'ngt-lOD': NgtThreeElementsImpl['LOD'];
+    'ngt-mesh': NgtThreeElementsImpl['Mesh'];
+    'ngt-instanced-mesh': NgtThreeElementsImpl['InstancedMesh'];
+    'ngt-skinned-mesh': NgtThreeElementsImpl['SkinnedMesh'];
+    'ngt-bone': NgtThreeElementsImpl['Bone'];
+    'ngt-material': NgtThreeElementsImpl['Material'];
+    'ngt-mesh-basic-material': NgtThreeElementsImpl['MeshBasicMaterial'];
+    'ngt-mesh-physical-material': NgtThreeElementsImpl['MeshPhysicalMaterial'];
+    'ngt-mesh-standard-material': NgtThreeElementsImpl['MeshStandardMaterial'];
+    'ngt-mesh-toon-material': NgtThreeElementsImpl['MeshToonMaterial'];
+    'ngt-mesh-normal-material': NgtThreeElementsImpl['MeshNormalMaterial'];
+    'ngt-mesh-depth-material': NgtThreeElementsImpl['MeshDepthMaterial'];
+    'ngt-mesh-distance-material': NgtThreeElementsImpl['MeshDistanceMaterial'];
+    'ngt-mesh-matcap-material': NgtThreeElementsImpl['MeshMatcapMaterial'];
+    'ngt-mesh-phong-material': NgtThreeElementsImpl['MeshPhongMaterial'];
+    'ngt-line-basic-material': NgtThreeElementsImpl['LineBasicMaterial'];
+    'ngt-line-dashed-material': NgtThreeElementsImpl['LineDashedMaterial'];
+    'ngt-mesh-lambert-material': NgtThreeElementsImpl['MeshLambertMaterial'];
+    'ngt-points-material': NgtThreeElementsImpl['PointsMaterial'];
+    'ngt-raw-shader-material': NgtThreeElementsImpl['RawShaderMaterial'];
+    'ngt-shader-material': NgtThreeElementsImpl['ShaderMaterial'];
+    'ngt-shadow-material': NgtThreeElementsImpl['ShadowMaterial'];
+    'ngt-sprite-material': NgtThreeElementsImpl['SpriteMaterial'];
+    'ngt-instanced-buffer-geometry': NgtThreeElementsImpl['InstancedBufferGeometry'];
+    'ngt-buffer-geometry': NgtThreeElementsImpl['BufferGeometry'];
+    'ngt-wireframe-geometry': NgtThreeElementsImpl['WireframeGeometry'];
+    'ngt-box-geometry': NgtThreeElementsImpl['BoxGeometry'];
+    'ngt-extrude-geometry': NgtThreeElementsImpl['ExtrudeGeometry'];
+    'ngt-shape-geometry': NgtThreeElementsImpl['ShapeGeometry'];
+    'ngt-circle-geometry': NgtThreeElementsImpl['CircleGeometry'];
+    'ngt-cylinder-geometry': NgtThreeElementsImpl['CylinderGeometry'];
+    'ngt-capsule-geometry': NgtThreeElementsImpl['CapsuleGeometry'];
+    'ngt-cone-geometry': NgtThreeElementsImpl['ConeGeometry'];
+    'ngt-edges-geometry': NgtThreeElementsImpl['EdgesGeometry'];
+    'ngt-tetrahedron-geometry': NgtThreeElementsImpl['TetrahedronGeometry'];
+    'ngt-octahedron-geometry': NgtThreeElementsImpl['OctahedronGeometry'];
+    'ngt-icosahedron-geometry': NgtThreeElementsImpl['IcosahedronGeometry'];
+    'ngt-polyhedron-geometry': NgtThreeElementsImpl['PolyhedronGeometry'];
+    'ngt-dodecahedron-geometry': NgtThreeElementsImpl['DodecahedronGeometry'];
+    'ngt-tube-geometry': NgtThreeElementsImpl['TubeGeometry'];
+    'ngt-torus-knot-geometry': NgtThreeElementsImpl['TorusKnotGeometry'];
+    'ngt-torus-geometry': NgtThreeElementsImpl['TorusGeometry'];
+    'ngt-sphere-geometry': NgtThreeElementsImpl['SphereGeometry'];
+    'ngt-ring-geometry': NgtThreeElementsImpl['RingGeometry'];
+    'ngt-plane-geometry': NgtThreeElementsImpl['PlaneGeometry'];
+    'ngt-lathe-geometry': NgtThreeElementsImpl['LatheGeometry'];
+    'ngt-line': NgtThreeElementsImpl['Line'];
+    'ngt-line-segments': NgtThreeElementsImpl['LineSegments'];
+    'ngt-line-loop': NgtThreeElementsImpl['LineLoop'];
+    'ngt-points': NgtThreeElementsImpl['Points'];
+    'ngt-group': NgtThreeElementsImpl['Group'];
+    'ngt-camera': NgtThreeElementsImpl['Camera'];
+    'ngt-perspective-camera': NgtThreeElementsImpl['PerspectiveCamera'];
+    'ngt-orthographic-camera': NgtThreeElementsImpl['OrthographicCamera'];
+    'ngt-cube-camera': NgtThreeElementsImpl['CubeCamera'];
+    'ngt-array-camera': NgtThreeElementsImpl['ArrayCamera'];
+    'ngt-spot-light': NgtThreeElementsImpl['SpotLight'];
+    'ngt-point-light': NgtThreeElementsImpl['PointLight'];
+    'ngt-rect-area-light': NgtThreeElementsImpl['RectAreaLight'];
+    'ngt-hemisphere-light': NgtThreeElementsImpl['HemisphereLight'];
+    'ngt-directional-light': NgtThreeElementsImpl['DirectionalLight'];
+    'ngt-ambient-light': NgtThreeElementsImpl['AmbientLight'];
+    'ngt-light-probe': NgtThreeElementsImpl['LightProbe'];
+    'ngt-spot-light-helper': NgtThreeElementsImpl['SpotLightHelper'];
+    'ngt-skeleton-helper': NgtThreeElementsImpl['SkeletonHelper'];
+    'ngt-point-light-helper': NgtThreeElementsImpl['PointLightHelper'];
+    'ngt-hemisphere-light-helper': NgtThreeElementsImpl['HemisphereLightHelper'];
+    'ngt-grid-helper': NgtThreeElementsImpl['GridHelper'];
+    'ngt-polar-grid-helper': NgtThreeElementsImpl['PolarGridHelper'];
+    'ngt-directional-light-helper': NgtThreeElementsImpl['DirectionalLightHelper'];
+    'ngt-camera-helper': NgtThreeElementsImpl['CameraHelper'];
+    'ngt-box-helper': NgtThreeElementsImpl['BoxHelper'];
+    'ngt-box3-helper': NgtThreeElementsImpl['Box3Helper'];
+    'ngt-plane-helper': NgtThreeElementsImpl['PlaneHelper'];
+    'ngt-arrow-helper': NgtThreeElementsImpl['ArrowHelper'];
+    'ngt-axes-helper': NgtThreeElementsImpl['AxesHelper'];
+    'ngt-audio': NgtThreeElementsImpl['Audio'];
+    'ngt-positional-audio': NgtThreeElementsImpl['PositionalAudio'];
+    'ngt-audio-listener': NgtThreeElementsImpl['AudioListener'];
+    'ngt-texture': NgtThreeElementsImpl['Texture'];
+    'ngt-compressed-texture': NgtThreeElementsImpl['CompressedTexture'];
+    'ngt-video-texture': NgtThreeElementsImpl['VideoTexture'];
+    'ngt-data-texture': NgtThreeElementsImpl['DataTexture'];
+    'ngt-data3D-texture': NgtThreeElementsImpl['Data3DTexture'];
+    'ngt-cube-texture': NgtThreeElementsImpl['CubeTexture'];
+    'ngt-canvas-texture': NgtThreeElementsImpl['CanvasTexture'];
+    'ngt-depth-texture': NgtThreeElementsImpl['DepthTexture'];
+    'ngt-raycaster': NgtThreeElementsImpl['Raycaster'];
+    'ngt-sprite': NgtThreeElementsImpl['Sprite'];
+    'ngt-vector2': NgtThreeElementsImpl['Vector2'];
+    'ngt-vector3': NgtThreeElementsImpl['Vector3'];
+    'ngt-vector4': NgtThreeElementsImpl['Vector4'];
+    'ngt-euler': NgtThreeElementsImpl['Euler'];
+    'ngt-matrix3': NgtThreeElementsImpl['Matrix3'];
+    'ngt-matrix4': NgtThreeElementsImpl['Matrix4'];
+    'ngt-quaternion': NgtThreeElementsImpl['Quaternion'];
+    'ngt-buffer-attribute': NgtThreeElementsImpl['BufferAttribute'];
+    'ngt-float16-buffer-attribute': NgtThreeElementsImpl['Float16BufferAttribute'];
+    'ngt-float32-buffer-attribute': NgtThreeElementsImpl['Float32BufferAttribute'];
+    'ngt-int8-buffer-attribute': NgtThreeElementsImpl['Int8BufferAttribute'];
+    'ngt-int16-buffer-attribute': NgtThreeElementsImpl['Int16BufferAttribute'];
+    'ngt-int32-buffer-attribute': NgtThreeElementsImpl['Int32BufferAttribute'];
+    'ngt-uint8-buffer-attribute': NgtThreeElementsImpl['Uint8BufferAttribute'];
+    'ngt-uint16-buffer-attribute': NgtThreeElementsImpl['Uint16BufferAttribute'];
+    'ngt-uint32-buffer-attribute': NgtThreeElementsImpl['Uint32BufferAttribute'];
+    'ngt-instanced-buffer-attribute': NgtThreeElementsImpl['InstancedBufferAttribute'];
+    'ngt-color': NgtThreeElementsImpl['Color'];
+    'ngt-fog': NgtThreeElementsImpl['Fog'];
+    'ngt-fog-exp2': NgtThreeElementsImpl['FogExp2'];
+    'ngt-shape': NgtThreeElementsImpl['Shape'];
+    'ngt-primitive': NgtThreeElement<any>;
+    'ngt-value': NgtThreeElement<any> & {
+        rawValue: any;
+    };
+}
+declare global {
+    interface HTMLElementTagNameMap extends NgtThreeElements {
+    }
+    interface HTMLElementEventMap extends NgtAllObject3DEventsMap<any> {
+    }
+}
+
+/**
+ * @fileoverview Signal-based state management ported from ngrx/signals.
+ *
+ * This module provides a reactive state management solution using Angular signals.
+ * It supports deep signal access for nested state properties and efficient state updates.
+ *
+ * Ported from ngrx/signals. Last synced: 08/16/2025
+ */
+
+type NonRecord = Iterable<any> | WeakSet<any> | WeakMap<any, any> | Promise<any> | Date | Error | RegExp | ArrayBuffer | DataView | Function;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type IsRecord<T> = T extends object ? (T extends NonRecord ? false : true) : false;
+type IsUnknownRecord<T> = string extends keyof T ? true : number extends keyof T ? true : false;
+type IsKnownRecord<T> = IsRecord<T> extends true ? (IsUnknownRecord<T> extends true ? false : true) : false;
+declare const STATE_SOURCE: unique symbol;
+/**
+ * Type representing a writable state source with signals for each property.
+ */
+type WritableStateSource<State extends object> = {
+    [STATE_SOURCE]: {
+        [K in keyof State]: WritableSignal<State[K]>;
+    };
+};
+/**
+ * Type representing a readonly state source with signals for each property.
+ */
+type StateSource<State extends object> = {
+    [STATE_SOURCE]: {
+        [K in keyof State]: Signal<State[K]>;
+    };
+};
+/**
+ * Function type for partial state updates.
+ */
+type PartialStateUpdater<State extends object> = (state: State) => Partial<State>;
+/**
+ * A signal that provides deep access to nested properties as signals.
+ *
+ * Allows accessing nested properties directly on the signal, e.g., `state.user.name()`
+ * instead of `state().user.name`.
+ */
+type DeepSignal<T> = Signal<T> & (IsKnownRecord<T> extends true ? Readonly<{
+    [K in keyof T]: IsKnownRecord<T[K]> extends true ? DeepSignal<T[K]> : Signal<T[K]>;
+}> : unknown);
+/**
+ * Converts a regular signal to a deep signal that allows nested property access.
+ *
+ * @typeParam T - The type of the signal's value
+ * @param signal - The signal to convert
+ * @returns A DeepSignal with nested property access
+ */
+declare function toDeepSignal<T>(signal: Signal<T>): DeepSignal<T>;
+/**
+ * A reactive state container built on Angular signals.
+ *
+ * Provides deep signal access to nested properties, an update method for
+ * modifying state, and a snapshot getter for non-reactive access.
+ */
+type SignalState<State extends object> = DeepSignal<State> & WritableStateSource<State> & {
+    /** Updates the state with partial updates or updater functions */
+    update: (...updaters: Array<Partial<Prettify<State>> | PartialStateUpdater<Prettify<State>>>) => void;
+    /** Gets the current state value without triggering reactivity */
+    get snapshot(): State;
+};
+/**
+ * Creates a reactive state container from an initial state object.
+ *
+ * The returned SignalState provides:
+ * - Deep signal access to nested properties (e.g., `state.camera()`)
+ * - An `update` method for modifying state
+ * - A `snapshot` getter for non-reactive access
+ *
+ * @typeParam State - The shape of the state object
+ * @param initialState - The initial state values
+ * @returns A SignalState instance
+ *
+ * @example
+ * ```typescript
+ * const store = signalState({
+ *   camera: null,
+ *   scene: null,
+ *   size: { width: 0, height: 0 }
+ * });
+ *
+ * // Access reactively
+ * const width = store.size.width();
+ *
+ * // Update state
+ * store.update({ camera: new THREE.PerspectiveCamera() });
+ *
+ * // Access snapshot
+ * const { scene } = store.snapshot;
+ * ```
+ */
+declare function signalState<State extends object>(initialState: State): SignalState<State>;
+
+type NgtArguments<T> = T extends NgtConstructorRepresentation ? T extends typeof THREE.Color ? [r: number, g: number, b: number] | [color: THREE.ColorRepresentation] : ConstructorParameters<T> : any[];
+type NgtConstructorRepresentation<T = any> = new (...args: any[]) => T;
+type NgtAnyRecord = Record<string, any>;
+type NgtNullish<T> = T | null | undefined;
+interface NgtDisposable {
+    type?: string;
+    dispose?: () => void;
+}
+interface NgtEquConfig {
+    /** Compare arrays by reference equality a === b (default), or by shallow equality */
+    arrays?: 'reference' | 'shallow';
+    /** Compare objects by reference equality a === b (default), or by shallow equality */
+    objects?: 'reference' | 'shallow';
+    /** If true the keys in both a and b must match 1:1 (default), if false a's keys must intersect b's */
+    strict?: boolean;
+}
+type NgtCameraLike = THREE.OrthographicCamera | THREE.PerspectiveCamera;
+type NgtCamera = NgtCameraLike & {
+    manual?: boolean;
+};
+type NgtCameraParameters = Partial<NgtThreeElement<typeof THREE.Camera> & NgtThreeElement<typeof THREE.PerspectiveCamera> & NgtThreeElement<typeof THREE.OrthographicCamera>> & {
+    manual?: boolean;
+};
+interface NgtRendererLike {
+    render: (scene: THREE.Scene, camera: THREE.Camera) => any;
+    dispose?: () => void;
+}
+type NgtCanvasElement = HTMLCanvasElement | OffscreenCanvas;
+type NgtGlobalRenderCallback = (timeStamp: number) => void;
+type NgtGLDefaultOptions = Omit<THREE.WebGLRendererParameters, 'canvas'> & {
+    canvas: NgtCanvasElement;
+};
+type NgtGLOptions = NgtRendererLike | ((defaultGLOptions: NgtGLDefaultOptions) => NgtRendererLike) | Partial<NgtProperties<THREE.WebGLRenderer> | THREE.WebGLRendererParameters> | undefined;
+type NgtDpr = number | [min: number, max: number];
+interface NgtSize {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+}
+interface NgtViewport extends NgtSize {
+    /** The initial pixel ratio */
+    initialDpr: number;
+    /** Current pixel ratio */
+    dpr: number;
+    /** size.width / viewport.width */
+    factor: number;
+    /** Camera distance */
+    distance: number;
+    /** Camera aspect ratio: width / height */
+    aspect: number;
+}
+type NgtShadows = boolean | 'basic' | 'percentage' | 'soft' | 'variance' | Partial<THREE.WebGLShadowMap>;
+type NgtFrameloop = 'always' | 'demand' | 'never';
+interface NgtPerformance {
+    /** Current performance normal, between min and max */
+    current: number;
+    /** How low the performance can go, between 0 and max */
+    min: number;
+    /** How high the performance can go, between min and max */
+    max: number;
+    /** Time until current returns to max in ms */
+    debounce: number;
+    /** Sets current to min, puts the system in regression */
+    regress: () => void;
+}
+type NgtEventPrefix = 'offset' | 'client' | 'page' | 'layer' | 'screen';
+interface NgtIntersection extends THREE.Intersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: THREE.Object3D;
+}
+interface NgtIntersectionEvent<TSourceEvent> extends NgtIntersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: THREE.Object3D;
+    /** An array of intersections */
+    intersections: NgtIntersection[];
+    /** vec3.set(pointer.x, pointer.y, 0).unproject(camera) */
+    unprojectedPoint: THREE.Vector3;
+    /** Normalized event coordinates */
+    pointer: THREE.Vector2;
+    /** Delta between first click and this event */
+    delta: number;
+    /** The ray that pierced it */
+    ray: THREE.Ray;
+    /** The camera that was used by the raycaster */
+    camera: NgtCamera;
+    /** stopPropagation will stop underlying handlers from firing */
+    stopPropagation: () => void;
+    /** The original host event */
+    nativeEvent: TSourceEvent;
+    /** If the event was stopped by calling stopPropagation */
+    stopped: boolean;
+}
+type NgtThreeEvent<TEvent> = NgtIntersectionEvent<TEvent> & NgtProperties<TEvent>;
+type NgtDomEvent = PointerEvent | MouseEvent | WheelEvent;
+interface NgtEventHandlers {
+    click?: (event: NgtThreeEvent<MouseEvent>) => void;
+    contextmenu?: (event: NgtThreeEvent<MouseEvent>) => void;
+    dblclick?: (event: NgtThreeEvent<MouseEvent>) => void;
+    pointerup?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerdown?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerover?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerout?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerenter?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerleave?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointermove?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointermissed?: (event: MouseEvent) => void;
+    pointercancel?: (event: NgtThreeEvent<PointerEvent>) => void;
+    wheel?: (event: NgtThreeEvent<WheelEvent>) => void;
+}
+type NgtEvents = {
+    [TEvent in keyof NgtEventHandlers]-?: EventListener;
+};
+type NgtFilterFunction = (items: THREE.Intersection[], store: SignalState<NgtState>) => THREE.Intersection[];
+type NgtComputeFunction = (event: NgtDomEvent, root: SignalState<NgtState>, previous: SignalState<NgtState> | null) => void;
+interface NgtEventManager<TTarget> {
+    /** Determines if the event layer is active */
+    enabled: boolean;
+    /** Event layer priority, higher prioritized layers come first and may stop(-propagate) lower layer  */
+    priority: number;
+    /** The compute function needs to set up the raycaster and an xy- pointer  */
+    compute?: NgtComputeFunction;
+    /** The filter can re-order or re-structure the intersections  */
+    filter?: NgtFilterFunction;
+    /** The target node the event layer is tied to */
+    connected?: TTarget;
+    /** All the pointer event handlers through which the host forwards native events */
+    handlers?: NgtEvents;
+    /** Allows re-connecting to another target */
+    connect?: (target: TTarget) => void;
+    /** Removes all existing events handlers from the target */
+    disconnect?: () => void;
+    /** Triggers a onPointerMove with the last known event. This can be useful to enable raycasting without
+     *  explicit user interaction, for instance when the camera moves a hoverable object underneath the cursor.
+     */
+    update?: () => void;
+}
+interface NgtPointerCaptureTarget {
+    intersection: NgtIntersection;
+    target: Element;
+}
+interface NgtInstanceHierarchyState {
+    objects: NgtInstanceNode[];
+    nonObjects: NgtInstanceNode[];
+    parent: NgtInstanceNode | null;
+    geometryStamp: number;
+}
+interface NgtInstanceState<TObject extends NgtAnyRecord = NgtAnyRecord> {
+    /**
+     * The store that the intsance is being rendered with
+     */
+    store: SignalState<NgtState> | null;
+    /**
+     * hierachy store for the instance
+     */
+    hierarchyStore: SignalState<NgtInstanceHierarchyState>;
+    parent: Signal<NgtInstanceHierarchyState['parent']>;
+    objects: Signal<NgtInstanceHierarchyState['objects']>;
+    nonObjects: Signal<NgtInstanceHierarchyState['nonObjects']>;
+    /**
+     * reference back to the object
+     */
+    object: TObject & {
+        __ngt__?: NgtInstanceState<TObject>;
+    };
+    add: (instance: NgtInstanceNode, type: 'objects' | 'nonObjects') => void;
+    remove: (instance: NgtInstanceNode, type: 'objects' | 'nonObjects') => void;
+    setParent: (parent: NgtInstanceNode | null) => void;
+    updateGeometryStamp: () => void;
+    /**
+     * event count for the instance
+     */
+    eventCount: number;
+    /**
+     * handlers for the instance
+     */
+    handlers: Partial<NgtEventHandlers>;
+    /**
+     * attach information so that we can detach as well as reset
+     */
+    attach?: string[] | NgtAttachFunction;
+    /**
+     * previously attach information so we can reset as well as clean up
+     */
+    previousAttach?: unknown | (() => void);
+    /**
+     * the element tag used to create this instance
+     */
+    type: string;
+    onUpdate?: (node: NgtInstanceNode) => void;
+    onAttach?: (afterAttach: NgtAfterAttach) => void;
+    setPointerEvent?: <TEvent extends keyof NgtEventHandlers>(eventName: TEvent, callback: NgtEventHandlers[TEvent]) => () => void;
+    addInteraction?: (store?: SignalState<NgtState> | null) => void;
+    removeInteraction?: (store?: SignalState<NgtState> | null) => void;
+}
+type NgtInstanceNode<TObject extends NgtAnyRecord = NgtAnyRecord> = TObject & {
+    __ngt_id__: string;
+    __ngt__: NgtInstanceState<TObject>;
+};
+type NgtAttachFunction<TChild = any, TParent = any> = (parent: TParent, child: TChild, store: SignalState<NgtState>) => void | (() => void);
+type NgtAttachable<TChild = any, TParent = any> = NgtAttachFunction<TChild, TParent> | string | (string | number)[];
+interface NgtAfterAttach<TChild = NgtInstanceNode, TParent = NgtInstanceNode> {
+    parent: TParent;
+    node: TChild;
+}
+interface NgtRenderState extends NgtState {
+    delta: number;
+    frame?: XRFrame;
+}
+interface NgtBeforeRenderEvent<TObject = NgtInstanceNode> {
+    state: NgtRenderState;
+    object: TObject;
+}
+interface NgtBeforeRenderRecord {
+    callback: (state: NgtRenderState) => void;
+    store: SignalState<NgtState>;
+    priority?: number;
+}
+interface NgtXRManager {
+    connect: () => void;
+    disconnect: () => void;
+}
+interface NgtInternalState {
+    active: boolean;
+    priority: number;
+    frames: number;
+    lastEvent: ElementRef<NgtDomEvent | null>;
+    interaction: THREE.Object3D[];
+    hovered: Map<string, NgtThreeEvent<NgtDomEvent>>;
+    capturedMap: Map<number, Map<THREE.Object3D, NgtPointerCaptureTarget>>;
+    initialClick: [x: number, y: number];
+    initialHits: THREE.Object3D[];
+    subscribers: NgtBeforeRenderRecord[];
+    subscribe: (callback: NgtBeforeRenderRecord['callback'], priority?: number, store?: SignalState<NgtState>) => () => void;
+}
+interface NgtState {
+    /** id **/
+    id: string;
+    /** The instance of the renderer */
+    gl: THREE.WebGLRenderer;
+    /** Default camera */
+    camera: NgtCamera;
+    /** Default scene */
+    scene: THREE.Scene;
+    /** Default raycaster */
+    raycaster: THREE.Raycaster;
+    /** Default clock */
+    clock: THREE.Clock;
+    /** Event layer interface, contains the event handler and the node they're connected to */
+    events: NgtEventManager<any>;
+    /** XR interface */
+    xr: NgtXRManager;
+    /** Currently used controls */
+    controls: THREE.EventDispatcher | null;
+    /** Normalized event coordinates */
+    pointer: THREE.Vector2;
+    legacy: boolean;
+    /** Shortcut to gl.outputColorSpace = LinearSRGBColorSpace */
+    linear: boolean;
+    /** Shortcut to gl.toneMapping = NoTonemapping */
+    flat: boolean;
+    /** Render loop flags */
+    frameloop: NgtFrameloop;
+    /** Adaptive performance interface */
+    performance: NgtPerformance;
+    /** Reactive pixel-size of the canvas */
+    size: NgtSize;
+    /** Reactive size of the viewport in threejs units */
+    viewport: NgtViewport & {
+        getCurrentViewport: (camera: NgtCamera, target?: THREE.Vector3 | Parameters<THREE.Vector3['set']>, size?: NgtSize) => Omit<NgtViewport, 'dpr' | 'initialDpr'>;
+    };
+    /** Flags the canvas for render, but doesn't render in itself */
+    invalidate: (frames?: number) => void;
+    /** Advance (render) one step */
+    advance: (timestamp: number, runGlobalEffects?: boolean) => void;
+    /** Shortcut to setting the event layer */
+    setEvents: (events: Partial<NgtEventManager<any>>) => void;
+    /**
+     * Shortcut to manual sizing
+     */
+    setSize: (width: number, height: number, top?: number, left?: number) => void;
+    /** Shortcut to manual setting the pixel ratio */
+    setDpr: (dpr: NgtDpr) => void;
+    /** Shortcut to frameloop flags */
+    setFrameloop: (frameloop?: NgtFrameloop) => void;
+    /** When the canvas was clicked but nothing was hit */
+    /** PointerMissed Observable */
+    pointerMissed$: Observable<MouseEvent>;
+    /** If this state model is layered (via createPortal) then this contains the previous layer */
+    previousRoot: SignalState<NgtState> | null;
+    /** Internals */
+    internal: NgtInternalState;
+    /** maxSkipCount from renderer options */
+    maxNotificationSkipCount?: number;
+}
+interface NgtCanvasOptions {
+    gl?: NgtGLOptions;
+    size?: NgtSize;
+    shadows?: NgtShadows;
+    legacy?: boolean;
+    linear?: boolean;
+    flat?: boolean;
+    orthographic?: boolean;
+    frameloop?: NgtFrameloop;
+    performance?: Partial<Omit<NgtPerformance, 'regress'>>;
+    dpr?: NgtDpr;
+    raycaster?: Partial<THREE.Raycaster>;
+    scene?: THREE.Scene | Partial<THREE.Scene>;
+    camera?: NgtCamera | NgtCameraParameters;
+    events?: (store: SignalState<NgtState>) => NgtEventManager<HTMLElement>;
+    eventSource?: HTMLElement | ElementRef<HTMLElement>;
+    eventPrefix?: NgtEventPrefix;
+    lookAt?: NgtVector3;
+}
+
+/**
+ * Structural directive for specifying a custom parent for Three.js objects.
+ *
+ * By default, Three.js objects are parented to the nearest Object3D ancestor in the template.
+ * The `NgtParent` directive allows you to override this behavior and specify a different parent.
+ *
+ * The parent can be specified as:
+ * - A string (name of an object in the scene)
+ * - A THREE.Object3D reference
+ * - An ElementRef containing a THREE.Object3D
+ * - A Signal of any of the above
+ *
+ * @example
+ * ```html
+ * <!-- Parent to a named object in the scene -->
+ * <ngt-mesh *parent="'myGroup'">
+ *   <ngt-box-geometry />
+ * </ngt-mesh>
+ *
+ * <!-- Parent to a reference -->
+ * <ngt-mesh *parent="myGroupRef">
+ *   <ngt-box-geometry />
+ * </ngt-mesh>
+ * ```
+ */
+declare class NgtParent extends NgtCommonDirective<THREE.Object3D | null | undefined> {
+    parent: _angular_core.InputSignal<string | THREE.Object3D<THREE.Object3DEventMap> | ElementRef<THREE.Object3D<THREE.Object3DEventMap>> | (() => NgtNullish<ElementRef<THREE.Object3D> | THREE.Object3D | string>)>;
+    private store;
+    private _parent;
+    protected linkedValue: _angular_core.WritableSignal<THREE.Object3D<THREE.Object3DEventMap> | null | undefined>;
+    protected shouldSkipRender: _angular_core.Signal<boolean>;
+    constructor();
+    validate(): boolean;
+    protected beforeCreateView(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgtParent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgtParent, "ng-template[parent]", never, { "parent": { "alias": "parent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive for managing selection state of Three.js objects.
+ *
+ * This directive creates a selection context that child `NgtSelect` directives can use
+ * to register themselves as selectable. The selection state is exposed as a readonly signal.
+ *
+ * @example
+ * ```html
+ * <ngt-group [selection]="true">
+ *   <ngt-mesh [select]="isSelected()">
+ *     <ngt-box-geometry />
+ *   </ngt-mesh>
+ * </ngt-group>
+ * ```
+ */
+declare class NgtSelectionApi {
+    enabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private source;
+    selected: _angular_core.Signal<(Object3D<THREE.Object3DEventMap> | ElementRef<Object3D<THREE.Object3DEventMap>>)[]>;
+    update(...args: Parameters<typeof this$1.source.update>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgtSelectionApi, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgtSelectionApi, "[selection]", never, { "enabled": { "alias": "selection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Directive for marking Three.js objects as selectable.
+ *
+ * When applied to a mesh or group, this directive registers the object with the parent
+ * `NgtSelectionApi` when enabled. For groups, all child meshes are automatically registered.
+ *
+ * @example
+ * ```html
+ * <ngt-mesh [select]="true">
+ *   <ngt-box-geometry />
+ * </ngt-mesh>
+ * ```
+ */
+declare class NgtSelect {
+    enabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgtSelect, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgtSelect, "ngt-group[select], ngt-mesh[select]", never, { "enabled": { "alias": "select"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Array containing NgtSelectionApi and NgtSelect directives for convenient importing.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   imports: [NgtSelection],
+ * })
+ * export class MyComponent {}
+ * ```
+ */
+declare const NgtSelection: readonly [typeof NgtSelectionApi, typeof NgtSelect];
+
+/**
+ * Removes all traces of an object from the event handling system.
+ *
+ * This function cleans up:
+ * - Interaction array
+ * - Initial hits
+ * - Hovered elements map
+ * - Pointer captures
+ *
+ * @param store - The Angular Three store
+ * @param object - The object to remove from interactivity
+ */
+declare function removeInteractivity(store: SignalState<NgtState>, object: THREE.Object3D): void;
+/**
+ * Creates the event handling system for a store.
+ *
+ * Returns an object with a `handlePointer` function that creates event handlers
+ * for different pointer event types. These handlers perform raycasting,
+ * event propagation, and callback invocation.
+ *
+ * @param store - The Angular Three store to create events for
+ * @returns An object containing the handlePointer factory function
+ */
+declare function createEvents(store: SignalState<NgtState>): {
+    handlePointer: (name: string) => (event: NgtDomEvent) => void;
+};
+
+/**
+ * @fileoverview Internal constants used by the Angular Three renderer.
+ *
+ * These flags are used to mark DOM nodes and track renderer state.
+ * @internal
+ */
+/** Flag indicating a node is managed by the Angular Three renderer */
+declare const NGT_RENDERER_NODE_FLAG = "__ngt_renderer__";
+/** Flag for canvas content template comments */
+declare const NGT_CANVAS_CONTENT_FLAG = "__ngt_renderer_canvas_content__";
+/** Flag for portal content template comments */
+declare const NGT_PORTAL_CONTENT_FLAG = "__ngt_renderer_portal_content__";
+/** Flag for args directive comments */
+declare const NGT_ARGS_FLAG = "__ngt_renderer_args__";
+/** Flag for parent directive comments */
+declare const NGT_PARENT_FLAG = "__ngt_renderer_parent__";
+/** Internal flag for adding comment nodes */
+declare const NGT_INTERNAL_ADD_COMMENT_FLAG = "__ngt_renderer_add_comment__";
+/** Internal flag for setting parent on comment nodes */
+declare const NGT_INTERNAL_SET_PARENT_COMMENT_FLAG = "__ngt_renderer_set_parent_comment__";
+/** Flag for getting node attributes */
+declare const NGT_GET_NODE_ATTRIBUTE_FLAG = "__ngt_get_node_attribute__";
+/** Flag for DOM parent element reference */
+declare const NGT_DOM_PARENT_FLAG = "__ngt_dom_parent__";
+/** Flag indicating the delegate renderer's destroyNode has been patched */
+declare const NGT_DELEGATE_RENDERER_DESTROY_NODE_PATCHED_FLAG = "__ngt_delegate_renderer_destroy_node_patched__";
+/** Flag for HTML directive classes */
+declare const NGT_HTML_FLAG = "__ngt_html__";
+/** Native Three.js EventDispatcher events */
+declare const THREE_NATIVE_EVENTS: string[];
+
+/**
+ * Provider function for configuring the DOM element for HTML components in Angular Three.
+ *
+ * This function creates a provider that specifies where HTML content should be rendered
+ * relative to the Three.js canvas. By default, HTML content is appended to the canvas's parent element.
+ *
+ * @returns A provider for the HTML DOM element configuration
+ *
+ * @example
+ * ```typescript
+ * // Default: append to canvas parent
+ * @Component({
+ *   providers: [provideHTMLDomElement()],
+ * })
+ *
+ * // Custom element
+ * @Component({
+ *   providers: [provideHTMLDomElement(() => document.getElementById('my-container')!)],
+ * })
+ * ```
+ */
+declare function provideHTMLDomElement(): Provider;
+declare function provideHTMLDomElement(factory: () => HTMLElement): Provider;
+declare function provideHTMLDomElement<TDeps extends Array<ProviderToken<any>>, TValues extends {
+    [K in keyof TDeps]: TDeps[K] extends Type<infer T> | AbstractType<infer T> | InjectionToken<infer T> ? T : never;
+}>(deps: TDeps, factory: (...args: TValues) => HTMLElement): Provider;
+/**
+ * Abstract base directive for creating HTML components that render alongside the Three.js canvas.
+ *
+ * Extend this class to create components that render DOM elements positioned relative to the
+ * Three.js scene. The DOM element will be appended to either the canvas's parent element
+ * or a custom element specified via `provideHTMLDomElement`.
+ *
+ * @example
+ * ```typescript
+ * @Directive({ selector: '[myHtml]', providers: [provideHTMLDomElement()] })
+ * export class MyHtmlDirective extends NgtHTML {
+ *   // Implementation
+ * }
+ * ```
+ */
+declare abstract class NgtHTML {
+    static [NGT_HTML_FLAG]: boolean;
+    protected domElement: HTMLElement | "gl" | null;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgtHTML, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgtHTML, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated Use `getInstanceState` instead. Will be removed in 5.0.0
+ * @param obj - The object to get local state from
+ * @returns The instance state if the object has been prepared, undefined otherwise
+ */
+declare function getLocalState<TInstance extends object>(obj: TInstance | undefined): NgtInstanceState | undefined;
+/**
+ * Retrieves the Angular Three instance state from a Three.js object.
+ *
+ * Every Three.js object managed by Angular Three has an associated instance state
+ * that contains metadata such as the store reference, parent/child relationships,
+ * event handlers, and attach information.
+ *
+ * @typeParam TInstance - The type of the Three.js object
+ * @param obj - The Three.js object to get instance state from
+ * @returns The instance state if the object has been prepared, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * const mesh = new THREE.Mesh();
+ * prepare(mesh, 'ngt-mesh');
+ * const state = getInstanceState(mesh);
+ * console.log(state?.type); // 'ngt-mesh'
+ * ```
+ */
+declare function getInstanceState<TInstance extends NgtAnyRecord>(obj: TInstance | undefined): NgtInstanceState<TInstance> | undefined;
+/**
+ * Invalidates an instance, triggering a re-render of the scene.
+ *
+ * This function marks the instance as needing an update and triggers the render loop
+ * to re-render the scene. It traverses up to the root store to ensure proper invalidation
+ * even for objects in portals.
+ *
+ * @typeParam TInstance - The type of the Three.js object
+ * @param instance - The instance node to invalidate
+ *
+ * @example
+ * ```typescript
+ * // After modifying a mesh's properties
+ * mesh.position.x = 10;
+ * invalidateInstance(mesh);
+ * ```
+ */
+declare function invalidateInstance<TInstance extends NgtAnyRecord>(instance: NgtInstanceNode<TInstance>): void;
+/**
+ * Prepares a Three.js object for use with Angular Three.
+ *
+ * This function attaches the Angular Three instance state to a Three.js object,
+ * enabling it to be managed by the Angular Three renderer. The instance state
+ * includes parent/child relationships, event handlers, and store references.
+ *
+ * @typeParam TInstance - The type of the Three.js object
+ * @param object - The Three.js object to prepare
+ * @param type - The element type name (e.g., 'ngt-mesh', 'ngt-primitive')
+ * @param instanceState - Optional partial instance state to merge with defaults
+ * @returns The prepared instance node
+ *
+ * @example
+ * ```typescript
+ * // Prepare a mesh for Angular Three
+ * const mesh = new THREE.Mesh(geometry, material);
+ * const prepared = prepare(mesh, 'ngt-mesh', { store });
+ * ```
+ */
+declare function prepare<TInstance extends NgtAnyRecord = NgtAnyRecord>(object: TInstance, type: string, instanceState?: Partial<NgtInstanceState>): NgtInstanceNode<TInstance>;
+
+/**
+ * Generates a unique identifier.
+ *
+ * When called with an intersection event, creates a deterministic ID based on
+ * the object UUID, index, and instance ID. Otherwise, generates a new UUID.
+ *
+ * @param event - Optional intersection event to generate ID from
+ * @returns A unique string identifier
+ */
+declare function makeId(event?: NgtIntersection): string;
+/**
+ * Resolves the device pixel ratio within specified bounds.
+ *
+ * When given a range [min, max], clamps the device's actual DPR to this range.
+ * Falls back to 2x DPR in environments where it cannot be detected (e.g., workers).
+ *
+ * @param dpr - A single DPR value or [min, max] range
+ * @param window - Optional window object to get devicePixelRatio from
+ * @returns The resolved DPR value
+ */
+declare function makeDpr(dpr: NgtDpr, window?: Window): number;
+/**
+ * Creates a WebGL renderer instance with sensible defaults.
+ *
+ * If a custom renderer is provided via glOptions, it will be used directly.
+ * Otherwise, creates a new WebGLRenderer with high-performance defaults.
+ *
+ * @typeParam TCanvas - The type of canvas element
+ * @param glOptions - Renderer configuration or custom renderer
+ * @param canvas - The canvas element to render to
+ * @returns A WebGLRenderer instance
+ */
+declare function makeRendererInstance<TCanvas extends NgtCanvasElement>(glOptions: NgtGLOptions, canvas: TCanvas): THREE.WebGLRenderer;
+/**
+ * Creates a camera instance based on the projection type.
+ *
+ * @param isOrthographic - Whether to create an orthographic camera
+ * @param size - The viewport size for calculating aspect ratio
+ * @returns Either an OrthographicCamera or PerspectiveCamera
+ */
+declare function makeCameraInstance(isOrthographic: boolean, size: NgtSize): THREE.PerspectiveCamera | THREE.OrthographicCamera;
+/**
+ * Type representing a parsed object graph from a loaded 3D model.
+ *
+ * Contains maps of named nodes, materials, and meshes for easy access.
+ */
+type NgtObjectMap = {
+    /** Map of named Object3D nodes */
+    nodes: Record<string, THREE.Object3D<any>>;
+    /** Map of named materials */
+    materials: Record<string, THREE.Material>;
+    /** Map of named meshes */
+    meshes: Record<string, THREE.Mesh>;
+    [key: string]: any;
+};
+/**
+ * Creates an object graph from a Three.js scene hierarchy.
+ *
+ * Traverses the object and extracts named nodes, materials, and meshes
+ * into lookup tables for convenient access.
+ *
+ * @param object - The root Object3D to traverse
+ * @returns An object containing nodes, materials, and meshes maps
+ *
+ * @example
+ * ```typescript
+ * const gltf = await loader.loadAsync('model.gltf');
+ * const { nodes, materials } = makeObjectGraph(gltf.scene);
+ * // Access named objects: nodes['MyMesh'], materials['MyMaterial']
+ * ```
+ */
+declare function makeObjectGraph(object: THREE.Object3D): NgtObjectMap;
+
+/**
+ * Type representing a GLTF-like object with a scene property.
+ */
+type NgtGLTFLike = {
+    scene: THREE.Object3D;
+};
+/**
+ * Interface for Three.js loaders that support async loading.
+ *
+ * @typeParam T - The type of data the loader returns
+ */
+interface NgtLoader<T> extends THREE.Loader {
+    load(url: string, onLoad?: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: unknown) => void): unknown;
+    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<T>;
+}
+/**
+ * Type representing a loader constructor.
+ */
+type NgtLoaderProto<T> = new (...args: any) => NgtLoader<T extends unknown ? any : T>;
+/**
+ * Utility type to extract the return type of a loader.
+ */
+type NgtLoaderReturnType<T, L extends NgtLoaderProto<T>> = T extends unknown ? Awaited<ReturnType<InstanceType<L>['loadAsync']>> : T;
+/**
+ * Type for loader extension functions that configure the loader before use.
+ */
+type NgtLoaderExtensions<T extends {
+    prototype: NgtLoaderProto<any>;
+}> = (loader: T['prototype']) => void;
+/**
+ * Conditional type utility.
+ */
+type NgtConditionalType<Child, Parent, Truthy, Falsy> = Child extends Parent ? Truthy : Falsy;
+/**
+ * Branching return type utility.
+ */
+type NgtBranchingReturn<T, Parent, Coerced> = NgtConditionalType<T, Parent, Coerced, T>;
+/**
+ * Type representing the result of loading based on input type.
+ * - String input returns a single result
+ * - Array input returns an array of results
+ * - Object input returns an object with the same keys and loaded values
+ */
+type NgtLoaderResults<TInput extends string | string[] | Record<string, string>, TReturn> = TInput extends string[] ? TReturn[] : TInput extends object ? {
+    [key in keyof TInput]: TReturn;
+} : TReturn;
+/**
+ * @deprecated Use loaderResource instead. Will be removed in v5.0.0
+ * @since v4.0.0~
+ */
+declare function _injectLoader<TData, TUrl extends string | string[] | Record<string, string>, TLoaderConstructor extends NgtLoaderProto<TData>, TReturn = NgtLoaderReturnType<TData, TLoaderConstructor>>(loaderConstructorFactory: (inputs: string[]) => TLoaderConstructor, inputs: () => TUrl, { extensions, onProgress, onLoad, injector, }?: {
+    extensions?: NgtLoaderExtensions<TLoaderConstructor>;
+    onProgress?: (event: ProgressEvent) => void;
+    onLoad?: (data: NoInfer<TReturn>) => void;
+    injector?: Injector;
+}): Signal<NgtLoaderResults<TUrl, NgtBranchingReturn<TReturn, NgtGLTFLike, NgtGLTFLike & NgtObjectMap>> | null>;
+declare namespace _injectLoader {
+    var preload: <TData, TUrl extends string | string[] | Record<string, string>, TLoaderConstructor extends NgtLoaderProto<TData>>(loaderConstructorFactory: (inputs: string[]) => TLoaderConstructor, inputs: () => TUrl, extensions?: NgtLoaderExtensions<TLoaderConstructor>, onLoad?: (data: NoInfer<TData>) => void) => void;
+    var destroy: () => void;
+    var clear: (urls: string | string[]) => void;
+}
+type NgtInjectedLoader = typeof _injectLoader;
+/**
+ * @deprecated Use loaderResource instead. Will be removed in v5.0.0
+ * @since v4.0.0~
+ */
+declare const injectLoader: NgtInjectedLoader;
+
+/**
+ * Loads Three.js assets using Angular's resource API.
+ *
+ * This function provides a signal-based approach to loading Three.js assets like
+ * GLTF models, textures, and other files. It leverages Angular's resource API
+ * for better integration with Angular's reactivity system.
+ *
+ * Features:
+ * - Automatic caching of loaded assets
+ * - Support for single URLs, arrays, or object maps
+ * - GLTF scene graph extraction
+ * - Progress and completion callbacks
+ *
+ * @typeParam TData - The type of data returned by the loader
+ * @typeParam TUrl - The type of URL input (string, string[], or Record<string, string>)
+ * @typeParam TLoaderConstructor - The loader constructor type
+ * @typeParam TReturn - The return type after loading
+ *
+ * @param loaderConstructorFactory - Factory function that returns the loader constructor
+ * @param input - Signal containing the URL(s) to load
+ * @param options - Optional configuration including extensions, callbacks, and injector
+ * @returns A ResourceRef containing the loaded data
+ *
+ * @example
+ * ```typescript
+ * // Load a single GLTF model
+ * const model = loaderResource(
+ *   () => GLTFLoader,
+ *   () => '/assets/model.gltf'
+ * );
+ *
+ * // Access in template
+ * @if (model.value(); as gltf) {
+ *   <ngt-primitive *args="[gltf.scene]" />
+ * }
+ * ```
+ */
+declare function loaderResource<TData, TUrl extends string | string[] | Record<string, string>, TLoaderConstructor extends NgtLoaderProto<TData>, TReturn = NgtLoaderReturnType<TData, TLoaderConstructor>>(loaderConstructorFactory: (url: TUrl) => TLoaderConstructor, input: () => TUrl, { extensions, onLoad, onProgress, injector, }?: {
+    extensions?: NgtLoaderExtensions<TLoaderConstructor>;
+    onLoad?: (data: NoInfer<NgtLoaderResults<TUrl, NgtBranchingReturn<TReturn, NgtGLTFLike, NgtGLTFLike & NgtObjectMap>>>) => void;
+    onProgress?: (event: ProgressEvent) => void;
+    injector?: Injector;
+}): ResourceRef<NgtLoaderResults<TUrl, NgtBranchingReturn<TReturn, NgtGLTFLike, NgtGLTFLike & NgtObjectMap>> | undefined>;
+declare namespace loaderResource {
+    var preload: <TData, TUrl extends string | string[] | Record<string, string>, TLoaderConstructor extends NgtLoaderProto<TData>>(loaderConstructor: TLoaderConstructor, inputs: TUrl, extensions?: NgtLoaderExtensions<TLoaderConstructor>) => void;
+    var destroy: () => void;
+    var clear: (urls: string | string[]) => void;
+}
+
+/**
+ * Global map of canvas elements to their associated stores.
+ *
+ * This map maintains references to all active Angular Three canvas roots,
+ * allowing the render loop to iterate over and render all active scenes.
+ */
+declare const roots: Map<NgtCanvasElement, SignalState<NgtState>>;
+/**
+ * Adds a global render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
+ */
+declare const addEffect: (callback: NgtGlobalRenderCallback) => () => void;
+/**
+ * Adds a global after-render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect
+ */
+declare const addAfterEffect: (callback: NgtGlobalRenderCallback) => () => void;
+/**
+ * Adds a global callback which is called when rendering stops.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail
+ */
+declare const addTail: (callback: NgtGlobalRenderCallback) => () => void;
+/**
+ * Type of global effect in the render loop.
+ * - 'before': Runs before the main render
+ * - 'after': Runs after the main render
+ * - 'tail': Runs when rendering stops
+ */
+type NgtGlobalEffectType = 'before' | 'after' | 'tail';
+/**
+ * Executes all global effects of the specified type.
+ *
+ * @param type - The type of global effects to flush ('before', 'after', or 'tail')
+ * @param timestamp - The current timestamp from requestAnimationFrame
+ */
+declare function flushGlobalEffects(type: NgtGlobalEffectType, timestamp: number): void;
+/**
+ * Injection token for the Angular Three render loop.
+ *
+ * Provides access to the render loop controls including invalidate and advance functions.
+ */
+declare const NGT_LOOP: InjectionToken<{
+    loop: (timestamp: number) => void;
+    invalidate: (store?: SignalState<NgtState>, frames?: number) => void;
+    advance: (timestamp: number, runGlobalEffects?: boolean, store?: SignalState<NgtState>, frame?: XRFrame) => void;
+}>;
+/**
+ * Injects the Angular Three render loop controller.
+ *
+ * The loop controller provides methods to control the render loop:
+ * - `invalidate`: Marks the scene as needing a re-render
+ * - `advance`: Manually advances the render loop by one frame
+ * - `loop`: The main animation loop function
+ *
+ * @returns The render loop controller
+ *
+ * @example
+ * ```typescript
+ * const loop = injectLoop();
+ * // Trigger a re-render
+ * loop.invalidate();
+ * // Manually advance one frame
+ * loop.advance(performance.now());
+ * ```
+ */
+declare function injectLoop(): {
+    loop: (timestamp: number) => void;
+    invalidate: (store?: SignalState<NgtState>, frames?: number) => void;
+    advance: (timestamp: number, runGlobalEffects?: boolean, store?: SignalState<NgtState>, frame?: XRFrame) => void;
+};
+
+/**
+ * Pipe for converting CSS color strings to hexadecimal numbers.
+ *
+ * Supports various color formats:
+ * - Hex strings: '#ff0000' -> 0xff0000
+ * - RGB: 'rgb(255, 0, 0)' -> 0xff0000
+ * - RGBA: 'rgba(255, 0, 0, 0.5)' -> hex with alpha
+ * - CSS color names: 'red' -> 0xff0000
+ *
+ * Returns 0x000000 (black) for invalid or null values.
+ *
+ * @example
+ * ```html
+ * <ngt-mesh-basic-material [color]="'red' | hexify" />
+ * <ngt-mesh-basic-material [color]="'#ff0000' | hexify" />
+ * ```
+ */
+declare class NgtHexify {
+    private document;
+    private ctx?;
+    private cache;
+    /**
+     * transforms a:
+     * - hex string to a hex number
+     * - rgb string to a hex number
+     * - rgba string to a hex number
+     * - css color string to a hex number
+     *
+     * always default to black if failed
+     * @param value
+     */
+    transform(value: string): number;
+    private hexStringToNumber;
+    private componentToHex;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgtHexify, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NgtHexify, "hexify", true>;
+}
+
+/**
+ * Directive to enable automatic rendering for portal content.
+ *
+ * When applied to an `ngt-portal`, this directive sets up automatic rendering
+ * of the portal's scene on each frame. The render priority can be configured
+ * to control the order of rendering relative to other subscriptions.
+ *
+ * @example
+ * ```html
+ * <ngt-portal [container]="container" [autoRender]="2">
+ *   <ng-template portalContent>
+ *     <ngt-mesh />
+ *   </ng-template>
+ * </ngt-portal>
+ * ```
+ */
+declare class NgtPortalAutoRender {
+    private portalStore;
+    private parentStore;
+    private portal;
+    renderPriority: _angular_core.InputSignalWithTransform<number, unknown>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgtPortalAutoRender, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgtPortalAutoRender, "ngt-portal[autoRender]", never, { "renderPriority": { "alias": "autoRender"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Structural directive for defining portal content.
+ *
+ * This directive marks the template content that will be rendered inside the portal.
+ * It must be used inside an `ngt-portal` component.
+ *
+ * @example
+ * ```html
+ * <ngt-portal [container]="myGroup">
+ *   <ng-template portalContent let-injector="injector">
+ *     <ngt-mesh />
+ *   </ng-template>
+ * </ngt-portal>
+ * ```
+ */
+declare class NgtPortalContent {
+    static ngTemplateContextGuard(_: NgtPortalContent, ctx: unknown): ctx is {
+        injector: Injector;
+    };
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgtPortalContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgtPortalContent, "ng-template[portalContent]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * State interface for portal configuration.
+ *
+ * Extends the base NgtState with customizable event handling configuration.
+ */
+interface NgtPortalState extends Omit<NgtState, 'events'> {
+    /** Portal-specific event configuration */
+    events: {
+        /** Whether events are enabled for this portal */
+        enabled?: boolean;
+        /** Event handling priority */
+        priority?: number;
+        /** Custom compute function for raycasting */
+        compute?: NgtComputeFunction;
+        /** Connected event target */
+        connected?: any;
+    };
+}
+/**
+ * Component for creating a portal to render Three.js content into a different container.
+ *
+ * Portals allow you to render content into a separate Three.js object while maintaining
+ * the React-like declarative structure. Each portal has its own store with separate
+ * raycaster and pointer state.
+ *
+ * @example
+ * ```html
+ * <ngt-group #portalContainer />
+ *
+ * <ngt-portal [container]="portalContainer">
+ *   <ng-template portalContent>
+ *     <ngt-mesh>
+ *       <ngt-box-geometry />
+ *     </ngt-mesh>
+ *   </ng-template>
+ * </ngt-portal>
+ * ```
+ */
+declare class NgtPortalImpl {
+    container: _angular_core.InputSignal<THREE.Object3D<THREE.Object3DEventMap>>;
+    state: _angular_core.InputSignal<Partial<NgtPortalState>>;
+    private contentRef;
+    private anchorRef;
+    private previousStore;
+    private portalStore;
+    private injector;
+    private size;
+    private events;
+    private restState;
+    private portalContentRendered;
+    portalRendered: _angular_core.Signal<boolean>;
+    private portalViewRef?;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgtPortalImpl, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgtPortalImpl, "ngt-portal", never, { "container": { "alias": "container"; "required": true; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; }, {}, ["contentRef", "anchorRef"], never, true, never>;
+}
+/**
+ * Array containing NgtPortalImpl and NgtPortalContent for convenient importing.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   imports: [NgtPortal],
+ * })
+ * export class MyComponent {}
+ * ```
+ */
+declare const NgtPortal: readonly [typeof NgtPortalImpl, typeof NgtPortalContent];
+
+/**
+ * Registers Three.js constructors for use in templates.
+ *
+ * Call this function to make Three.js classes available for use as custom elements.
+ * The function returns a cleanup function that removes the registered entries.
+ *
+ * @param objects - An object mapping names to Three.js constructors
+ * @returns A cleanup function to remove the registered entries
+ *
+ * @example
+ * ```typescript
+ * import { extend } from 'angular-three';
+ * import { Mesh, BoxGeometry, MeshStandardMaterial } from 'three';
+ *
+ * // Register at component level
+ * extend({ Mesh, BoxGeometry, MeshStandardMaterial });
+ *
+ * // Now you can use in templates:
+ * // <ngt-mesh>
+ * //   <ngt-box-geometry />
+ * //   <ngt-mesh-standard-material />
+ * // </ngt-mesh>
+ * ```
+ */
+declare function extend(objects: object): () => void;
+/**
+ * Removes entries from the catalogue by key.
+ *
+ * @param keys - The keys to remove from the catalogue
+ */
+declare function remove(...keys: string[]): void;
+/**
+ * Injection token for the Three.js constructor catalogue.
+ */
+declare const NGT_CATALOGUE: InjectionToken<Record<string, NgtConstructorRepresentation>>;
+/**
+ * Injects the Three.js constructor catalogue.
+ *
+ * @returns The catalogue mapping names to constructors
+ */
+declare function injectCatalogue(): Record<string, NgtConstructorRepresentation>;
+
+type ThreeRendererState = [
+    type: 'three',
+    destroyed: boolean,
+    rawValue: any | undefined,
+    portalContainer: never | undefined,
+    injector: never | undefined,
+    parent: NgtRendererNode<'platform' | 'portal' | 'three'> | undefined,
+    children: Array<NgtRendererNode<'platform' | 'portal' | 'comment'>>
+];
+type PortalRendererState = [
+    type: 'portal',
+    destroyed: boolean,
+    rawValue: never | undefined,
+    portalContainer: NgtRendererNode<'three'> | undefined,
+    injector: Injector | undefined,
+    parent: any | undefined,
+    children: any[]
+];
+type PlatformRendererState = [
+    type: 'platform',
+    destroyed: boolean,
+    rawValue: never | undefined,
+    portalContainer: never | undefined,
+    injector: never | undefined,
+    parent: NgtRendererNode<'three' | 'portal'> | undefined,
+    children: Array<NgtRendererNode<'three' | 'portal' | 'comment'>>
+];
+type CommentRendererState = [
+    type: 'comment',
+    destroyed: boolean,
+    rawValue: never | undefined,
+    portalContainer: never | undefined,
+    injector: Injector | undefined,
+    parent: NgtRendererNode | undefined,
+    children: NgtRendererNode[]
+];
+type TextRendererState = [
+    type: 'text',
+    destroyed: boolean,
+    rawValue: never | undefined,
+    portalContainer: never | undefined,
+    injector: never | undefined,
+    parent: NgtRendererNode | undefined,
+    children: NgtRendererNode[]
+];
+type NgtRendererStateMap = {
+    three: ThreeRendererState;
+    portal: PortalRendererState;
+    platform: PlatformRendererState;
+    comment: CommentRendererState;
+    text: TextRendererState;
+};
+interface NgtRendererNode<TType extends keyof NgtRendererStateMap = keyof NgtRendererStateMap> extends NgtAnyRecord {
+    [NGT_RENDERER_NODE_FLAG]: NgtRendererStateMap[TType];
+    [NGT_DOM_PARENT_FLAG]?: HTMLElement;
+}
+
+/**
+ * Configuration options for the Angular Three renderer factory.
+ */
+interface NgtRendererFactory2Options {
+    /**
+     * Enable verbose logging for debugging renderer operations.
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * When a change happens to an object's direct children, Angular Three will notify the object's ancestors
+     * of this change so the ancestors are aware of the updated matrices of the object. In order to reduce the
+     * number of notifications, Angular Three caches and skips notifications when possible.
+     *
+     * However, this can cause missed notifications in some cases. Control the number of skips with this option.
+     *
+     * @default 5
+     */
+    maxNotificationSkipCount?: number;
+}
+/**
+ * Injection token for renderer factory options.
+ */
+declare const NGT_RENDERER_OPTIONS: InjectionToken<NgtRendererFactory2Options>;
+/**
+ * Angular renderer factory for Three.js elements.
+ *
+ * This factory creates NgtRenderer2 instances for components that use Angular Three.
+ * It intercepts Angular's rendering operations and translates them to Three.js object
+ * creation and manipulation.
+ *
+ * The factory is typically provided via `provideNgtRenderer()` in your application config.
+ *
+ * @example
+ * ```typescript
+ * // In app.config.ts
+ * import { provideNgtRenderer } from 'angular-three/dom';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [provideNgtRenderer()]
+ * };
+ * ```
+ */
+declare class NgtRendererFactory2 implements RendererFactory2 {
+    private delegateRendererFactory;
+    private catalogue;
+    private document;
+    private options;
+    private rendererMap;
+    /**
+     * NOTE: We use `useFactory` to instantiate `NgtRendererFactory2`
+     */
+    constructor(delegateRendererFactory: RendererFactory2);
+    createRenderer(hostElement: any, type: RendererType2 | null): Renderer2;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgtRendererFactory2, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NgtRendererFactory2>;
+}
+/**
+ * Custom Angular renderer for Three.js elements.
+ *
+ * This renderer intercepts Angular's DOM operations and translates them to Three.js
+ * object manipulations. It handles:
+ * - Element creation (converting ngt-* elements to Three.js objects)
+ * - Property/attribute setting (applying props to Three.js objects)
+ * - Event listening (setting up Three.js event handlers)
+ * - Parent-child relationships (managing the Three.js scene graph)
+ *
+ * @internal
+ */
+declare class NgtRenderer2 implements Renderer2 {
+    delegateRenderer: Renderer2;
+    private catalogue;
+    private document;
+    private options;
+    count: number;
+    private argsInjectors;
+    private parentInjectors;
+    constructor(delegateRenderer: Renderer2, catalogue: Record<string, NgtConstructorRepresentation>, document: Document, options: NgtRendererFactory2Options, count?: number);
+    get data(): {
+        [key: string]: any;
+    };
+    destroy(): void;
+    createElement(name: string, namespace?: string | null): NgtRendererNode<"three"> | NgtRendererNode<"platform"> | NgtRendererNode<"portal">;
+    createComment(value: string): NgtRendererNode<"comment">;
+    createText(value: string): NgtRendererNode<"text">;
+    destroyNode: (node: NgtRendererNode) => void;
+    appendChild(parent: NgtRendererNode, newChild: NgtRendererNode, refChild?: NgtRendererNode, isMove?: boolean): void;
+    insertBefore(parent: NgtRendererNode, newChild: NgtRendererNode, refChild: NgtRendererNode, isMove?: boolean): void;
+    removeChild(parent: NgtRendererNode, oldChild: NgtRendererNode, isHostElement?: boolean): void;
+    parentNode(node: NgtRendererNode): any;
+    removeAttribute(el: NgtRendererNode, name: string, namespace?: string | null): void;
+    setAttribute(el: NgtRendererNode, name: string, value: string, namespace?: string | null): void;
+    setProperty(el: NgtRendererNode, name: string, value: any): void;
+    listen(target: 'window' | 'document' | 'body' | NgtRendererNode, eventName: string, callback: (event: any) => boolean | void): () => void;
+    private appendThreeRendererNodes;
+    private setNodeRelationship;
+    private getNgtDirective;
+    private normalizeAttach;
+    addClass: (el: any, name: string) => void;
+    removeClass: (el: any, name: string) => void;
+    setStyle: (el: any, style: string, value: any, flags?: _angular_core.RendererStyleFlags2) => void;
+    removeStyle: (el: any, style: string, flags?: _angular_core.RendererStyleFlags2) => void;
+    selectRootElement: (selectorOrNode: string | any, preserveContent?: boolean) => any;
+    nextSibling: (node: any) => any;
+    setValue: (node: any, value: string) => void;
+}
+
+/**
+ * Creates a canvas root initializer function.
+ *
+ * This function sets up the Three.js rendering context including the WebGL renderer,
+ * camera, scene, and all related state. It returns a configurator object that can
+ * be used to update canvas options and destroy the root.
+ *
+ * @param injector - Optional injector for dependency injection
+ * @returns A function that takes a canvas element and returns a configurator
+ *
+ * @example
+ * ```typescript
+ * const initRoot = canvasRootInitializer();
+ * const configurator = initRoot(canvasElement);
+ * configurator.configure({ shadows: true, dpr: [1, 2] });
+ * ```
+ */
+declare function canvasRootInitializer(injector?: Injector): (canvas: NgtCanvasElement) => {
+    isConfigured: boolean;
+    destroy: (timeout?: number) => void;
+    configure: (inputs: NgtCanvasOptions) => void;
+};
+/**
+ * Type representing the canvas configurator returned by canvasRootInitializer.
+ */
+type NgtCanvasConfigurator = ReturnType<ReturnType<typeof canvasRootInitializer>>;
+/**
+ * Disposes an object and all its disposable properties.
+ *
+ * Recursively calls dispose() on the object and all its properties that have
+ * a dispose method, except for Scene objects which are handled separately.
+ *
+ * @typeParam T - The type of the object to dispose
+ * @param obj - The object to dispose
+ */
+declare function dispose<T extends NgtDisposable>(obj: T): void;
+
+/**
+ * Component for rendering Three.js scenes based on Angular Router routes.
+ *
+ * This component wraps a router-outlet and ensures proper change detection
+ * when routes change. Use this when you want to have different Three.js scenes
+ * for different routes in your application.
+ *
+ * @example
+ * ```typescript
+ * // In your routes configuration
+ * const routes: Routes = [
+ *   { path: 'scene1', component: Scene1Component },
+ *   { path: 'scene2', component: Scene2Component },
+ * ];
+ *
+ * // In your template
+ * <ngt-canvas>
+ *   <ngt-routed-scene *canvasContent />
+ * </ngt-canvas>
+ * ```
+ */
+declare class NgtRoutedScene {
+    constructor(router: Router, cdr: ChangeDetectorRef);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgtRoutedScene, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgtRoutedScene, "ngt-routed-scene", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Factory function to create the Angular Three store.
+ *
+ * Creates and initializes the central state management store for the Angular Three application.
+ * This store contains all the state needed for rendering including the WebGL renderer, camera, scene,
+ * raycaster, and internal state for managing the render loop and event handling.
+ *
+ * @returns A SignalState containing the NgtState object with reactive signals for all state properties
+ *
+ * @example
+ * ```typescript
+ * // Usually provided automatically by NgtCanvas
+ * providers: [{ provide: NGT_STORE, useFactory: storeFactory }]
+ * ```
+ */
+declare function storeFactory(): SignalState<NgtState>;
+/**
+ * Injection token for the Angular Three store.
+ *
+ * Use this token to access the store directly via Angular's dependency injection system.
+ * The store contains the complete state of the Three.js scene including renderer, camera, scene, and more.
+ *
+ * @example
+ * ```typescript
+ * const store = inject(NGT_STORE);
+ * const camera = store.camera();
+ * ```
+ */
+declare const NGT_STORE: InjectionToken<SignalState<NgtState>>;
+/**
+ * Injects the Angular Three store into the current injection context.
+ *
+ * This is the primary way to access the store in components, directives, and services.
+ * The store provides reactive signals for all Three.js state including the renderer,
+ * camera, scene, raycaster, and more.
+ *
+ * @param options - Optional injection options (e.g., { optional: true, skipSelf: true })
+ * @returns The Angular Three store as a SignalState, or null if optional and not found
+ *
+ * @example
+ * ```typescript
+ * // In a component or directive
+ * const store = injectStore();
+ *
+ * // Access reactive state
+ * const camera = store.camera();
+ * const scene = store.scene();
+ *
+ * // Access snapshot (non-reactive)
+ * const { gl, size } = store.snapshot;
+ * ```
+ */
+declare function injectStore(options: InjectOptions & {
+    optional?: false;
+}): SignalState<NgtState>;
+declare function injectStore(options: InjectOptions): SignalState<NgtState> | null;
+declare function injectStore(): SignalState<NgtState>;
+
+/**
+ * Internal symbol used to temporarily store the parent's store on an instance.
+ * This is a workaround to give the instance access to the store from its parent
+ * during property application. The property is cleared after applyProps completes.
+ * @internal
+ */
+declare const NGT_APPLY_PROPS = "__ngt_apply_props__";
+/**
+ * Resolves a property key that may contain dot notation (pierced props).
+ *
+ * This function handles nested property access like 'position.x' by traversing
+ * the object hierarchy and returning the final target object and key.
+ *
+ * @param instance - The root instance to start from
+ * @param key - The property key, potentially with dot notation
+ * @returns An object containing the root object, target key, and target property value
+ *
+ * @example
+ * ```typescript
+ * const mesh = new THREE.Mesh();
+ * const result = resolveInstanceKey(mesh, 'position.x');
+ * // result.root = mesh.position
+ * // result.targetKey = 'x'
+ * // result.targetProp = mesh.position.x
+ * ```
+ */
+declare function resolveInstanceKey(instance: any, key: string): {
+    root: any;
+    targetKey: string;
+    targetProp: any;
+};
+/**
+ * Applies a set of properties to a Three.js instance.
+ *
+ * This is the core function for updating Three.js objects with new property values.
+ * It handles various property types including:
+ * - Math types (Vector3, Color, Euler, etc.) with automatic conversion
+ * - Pierced props (dot notation like 'position.x')
+ * - Arrays (converted to set/fromArray calls)
+ * - Layers (mask copying)
+ * - Textures (automatic color space management)
+ *
+ * After applying props, the function triggers necessary updates like
+ * camera projection matrix updates and texture needsUpdate flags.
+ *
+ * @typeParam T - The type of the Three.js instance
+ * @param instance - The Three.js instance to update
+ * @param props - An object containing the properties to apply
+ * @returns The updated instance
+ *
+ * @example
+ * ```typescript
+ * const mesh = new THREE.Mesh();
+ * applyProps(mesh, {
+ *   position: [1, 2, 3],
+ *   'rotation.x': Math.PI / 2,
+ *   visible: true
+ * });
+ * ```
+ */
+declare function applyProps<T extends NgtAnyRecord>(instance: NgtInstanceState<T>['object'], props: NgtAnyRecord): T & {
+    __ngt__?: NgtInstanceState<T> | undefined;
+};
+
+/**
+ * Attaches a value to an object at the specified path.
+ *
+ * This function recursively traverses the path and sets the value at the final key.
+ * It's used internally to implement the `attach` property on Three.js elements.
+ *
+ * @param object - The target object to attach to
+ * @param value - The value to attach
+ * @param paths - An array of path segments (e.g., ['material', 'map'])
+ * @param useApplyProps - Whether to use applyProps for setting the value
+ *
+ * @example
+ * ```typescript
+ * const mesh = new THREE.Mesh();
+ * attach(mesh, texture, ['material', 'map']);
+ * // mesh.material.map = texture
+ * ```
+ */
+declare function attach(object: NgtInstanceNode, value: unknown, paths?: string[], useApplyProps?: boolean): void;
+/**
+ * Detaches a child from its parent, restoring the previous value.
+ *
+ * This function reverses the attach operation by restoring the previous value
+ * that was stored when the child was attached.
+ *
+ * @param parent - The parent object
+ * @param child - The child object to detach
+ * @param attachProp - The attach path or function that was used
+ */
+declare function detach(parent: NgtInstanceNode, child: NgtInstanceNode, attachProp: string[] | NgtAttachFunction): void;
+/**
+ * Creates a custom attach function for advanced attachment scenarios.
+ *
+ * Use this when you need custom logic for attaching a child to a parent,
+ * such as when the relationship isn't a simple property assignment.
+ *
+ * @typeParam TChild - The type of the child object
+ * @typeParam TParent - The type of the parent object
+ * @param cb - Callback that performs the attachment and optionally returns a cleanup function
+ * @returns An attach function compatible with the `attach` property
+ *
+ * @example
+ * ```typescript
+ * const customAttach = createAttachFunction<THREE.Mesh, THREE.Group>(
+ *   ({ parent, child, store }) => {
+ *     parent.add(child);
+ *     return () => parent.remove(child);
+ *   }
+ * );
+ * ```
+ */
+declare function createAttachFunction<TChild = any, TParent = any>(cb: (params: {
+    parent: TParent;
+    child: TChild;
+    store: SignalState<NgtState>;
+}) => (() => void) | void): NgtAttachFunction<TChild, TParent>;
+
+/**
+ * `beforeRender` invokes its callback on every frame. Hence, the notion of tracking
+ * changes (i.e: signals) does not really matter since we're getting latest values of the things we need on every frame anyway.
+ *
+ * If `priority` is a Signal, `beforeRender` will set up an Effect internally and returns the `EffectRef#destroy` instead.
+ *
+ * @example
+ * ```ts
+ * const destroy = beforeRender(
+ *  ({ gl, camera }) => {
+ *    // before render logic
+ *  },
+ *  {
+ *    priority: this.priority, // this.priority is a Signal<number>
+ *  }
+ * )
+ * ```
+ */
+declare function beforeRender(cb: NgtBeforeRenderRecord['callback'], { priority, injector }?: {
+    priority?: number | (() => number);
+    injector?: Injector;
+}): () => void;
+/**
+ * @deprecated Use `beforeRender` instead. Will be removed in v5.0.0
+ * @since v4.0.0
+ */
+declare const injectBeforeRender: typeof beforeRender;
+
+/**
+ * Directive for binding Three.js element lifecycle events to outputs.
+ *
+ * This directive provides outputs for Angular Three element events and native
+ * Three.js events like added, removed, and disposed. It's designed to be used
+ * as a host directive.
+ *
+ * Outputs:
+ * - Angular Three: created, attached, updated
+ * - Three.js: added, removed, childadded, childremoved, change, disposed
+ *
+ * Input: `elementEvents` - The element to listen for events on
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   hostDirectives: [{
+ *     directive: NgtElementEvents,
+ *     inputs: ['elementEvents: events'],
+ *     outputs: ['attached', 'updated']
+ *   }]
+ * })
+ * export class MyMesh {
+ *   elementEvents = inject(NgtElementEvents, { host: true });
+ *
+ *   constructor() {
+ *     this.elementEvents.events.set(this.meshRef);
+ *   }
+ * }
+ * ```
+ */
+declare class NgtElementEvents<TElement extends object> {
+    created: _angular_core.OutputEmitterRef<TElement>;
+    attached: _angular_core.OutputEmitterRef<NgtAfterAttach<TElement, angular_three.NgtInstanceNode<angular_three.NgtAnyRecord>>>;
+    updated: _angular_core.OutputEmitterRef<TElement>;
+    added: _angular_core.OutputEmitterRef<any>;
+    removed: _angular_core.OutputEmitterRef<any>;
+    childadded: _angular_core.OutputEmitterRef<any>;
+    childremoved: _angular_core.OutputEmitterRef<any>;
+    change: _angular_core.OutputEmitterRef<any>;
+    disposed: _angular_core.OutputEmitterRef<any>;
+    events: _angular_core.ModelSignal<TElement | ElementRef<TElement> | (() => ElementRef<TElement> | TElement | null | undefined) | null | undefined>;
+    constructor();
+    private emitEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgtElementEvents<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgtElementEvents<any>, "[elementEvents]", never, { "events": { "alias": "elementEvents"; "required": false; "isSignal": true; }; }, { "created": "created"; "attached": "attached"; "updated": "updated"; "added": "added"; "removed": "removed"; "childadded": "childadded"; "childremoved": "childremoved"; "change": "change"; "disposed": "disposed"; "events": "elementEventsChange"; }, never, never, true, never>;
+}
+/**
+ * Sets up element lifecycle event listeners on a Three.js element.
+ *
+ * @typeParam TElement - The type of the element
+ * @param target - Signal containing the target element
+ * @param events - Object mapping event names to handler functions
+ * @param options - Optional injector for dependency injection
+ * @returns Array of cleanup functions
+ *
+ * @example
+ * ```typescript
+ * elementEvents(
+ *   () => this.meshRef.nativeElement,
+ *   {
+ *     created: (mesh) => console.log('Mesh created'),
+ *     attached: ({ parent, node }) => console.log('Attached to', parent),
+ *   }
+ * );
+ * ```
+ */
+declare function elementEvents<TElement extends object>(target: () => ElementRef<TElement> | TElement | null | undefined, events: {
+    created?: (element: TElement) => void;
+    updated?: (element: TElement) => void;
+    attached?: (element: NgtAfterAttach<TElement>) => void;
+    added?: (event: any) => void;
+    removed?: (event: any) => void;
+    childadded?: (event: any) => void;
+    childremoved?: (event: any) => void;
+    change?: (event: any) => void;
+    disposed?: (event: any) => void;
+}, { injector }?: {
+    injector?: Injector;
+}): (() => void)[];
+
+/**
+ * Collection of type checking and comparison utilities for Angular Three.
+ *
+ * These utilities help with runtime type checking of Three.js objects,
+ * Angular references, and general equality comparisons.
+ *
+ * @example
+ * ```typescript
+ * // Check if something is a Three.js mesh
+ * if (is.three<THREE.Mesh>(obj, 'isMesh')) {
+ *   // obj is typed as THREE.Mesh
+ * }
+ *
+ * // Check if two values are equal
+ * if (is.equ(a, b, { objects: 'shallow' })) {
+ *   // values are considered equal
+ * }
+ * ```
+ */
+declare const is: {
+    /** Checks if value is a plain object (not array or function) */
+    obj: (a: unknown) => a is object;
+    /** Checks if value is a Three.js Material */
+    material: (a: unknown) => a is THREE.Material;
+    /** Checks if value is a Three.js BufferGeometry */
+    geometry: (a: unknown) => a is THREE.BufferGeometry;
+    /** Checks if value is a Three.js OrthographicCamera */
+    orthographicCamera: (a: unknown) => a is THREE.OrthographicCamera;
+    /** Checks if value is a Three.js PerspectiveCamera */
+    perspectiveCamera: (a: unknown) => a is THREE.PerspectiveCamera;
+    /** Checks if value is a Three.js Camera */
+    camera: (a: unknown) => a is THREE.Camera;
+    /** Checks if value is a renderer-like object with a render method */
+    renderer: (a: unknown) => boolean;
+    /** Checks if value is a Three.js Scene */
+    scene: (a: unknown) => a is THREE.Scene;
+    /** Checks if value is an Angular ElementRef */
+    ref: (a: unknown) => a is ElementRef;
+    /** Checks if value is an Angular Three instance node (prepared object) */
+    instance: (a: unknown) => a is NgtInstanceNode;
+    /** Checks if value is a Three.js Object3D */
+    object3D: (a: unknown) => a is THREE.Object3D;
+    /**
+     * Generic Three.js type check using the is* pattern.
+     * @example is.three<THREE.Mesh>(obj, 'isMesh')
+     */
+    three: <TThreeEntity extends object, TKey extends keyof TThreeEntity = keyof TThreeEntity>(a: unknown, isKey: TKey extends `is${infer K}` ? TKey : never) => a is TThreeEntity;
+    /** Checks if value is a valid Three.js ColorRepresentation */
+    colorRepresentation: (a: unknown) => a is THREE.ColorRepresentation;
+    /** Checks if object has colorSpace or outputColorSpace property */
+    colorSpaceExist: <T extends NgtRendererLike | THREE.Texture | object, P = T extends NgtRendererLike ? {
+        outputColorSpace: string;
+    } : {
+        colorSpace: string;
+    }>(object: T) => object is T & P;
+    /**
+     * Deep equality comparison with configurable behavior for arrays and objects.
+     * @param a - First value to compare
+     * @param b - Second value to compare
+     * @param config - Comparison configuration
+     */
+    equ(a: any, b: any, { arrays, objects, strict }?: NgtEquConfig): boolean;
+};
+
+/**
+ * Directive for binding Three.js pointer events to outputs.
+ *
+ * This directive provides outputs for all Three.js pointer events that can be used
+ * with standard Angular event binding syntax. It's designed to be used as a host directive.
+ *
+ * Outputs: click, dblclick, contextmenu, pointerup, pointerdown, pointerover,
+ * pointerout, pointerenter, pointerleave, pointermove, pointermissed, pointercancel, wheel
+ *
+ * Input: `objectEvents` - The Three.js object to listen for events on
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   hostDirectives: [{
+ *     directive: NgtObjectEvents,
+ *     inputs: ['objectEvents: events'],
+ *     outputs: ['click', 'pointerover', 'pointerout']
+ *   }]
+ * })
+ * export class MyMesh {
+ *   objectEvents = inject(NgtObjectEvents, { host: true });
+ *
+ *   constructor() {
+ *     this.objectEvents.events.set(this.meshRef);
+ *   }
+ * }
+ * ```
+ */
+declare class NgtObjectEvents {
+    click: _angular_core.OutputEmitterRef<NgtThreeEvent<MouseEvent>>;
+    dblclick: _angular_core.OutputEmitterRef<NgtThreeEvent<MouseEvent>>;
+    contextmenu: _angular_core.OutputEmitterRef<NgtThreeEvent<MouseEvent>>;
+    pointerup: _angular_core.OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerdown: _angular_core.OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerover: _angular_core.OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerout: _angular_core.OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerenter: _angular_core.OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerleave: _angular_core.OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointermove: _angular_core.OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointermissed: _angular_core.OutputEmitterRef<NgtThreeEvent<MouseEvent>>;
+    pointercancel: _angular_core.OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    wheel: _angular_core.OutputEmitterRef<NgtThreeEvent<WheelEvent>>;
+    events: _angular_core.ModelSignal<THREE.Object3D<THREE.Object3DEventMap> | ElementRef<THREE.Object3D<THREE.Object3DEventMap>> | (() => ElementRef<THREE.Object3D> | THREE.Object3D | null | undefined) | null | undefined>;
+    constructor();
+    private emitEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgtObjectEvents, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgtObjectEvents, "[objectEvents]", never, { "events": { "alias": "objectEvents"; "required": false; "isSignal": true; }; }, { "click": "click"; "dblclick": "dblclick"; "contextmenu": "contextmenu"; "pointerup": "pointerup"; "pointerdown": "pointerdown"; "pointerover": "pointerover"; "pointerout": "pointerout"; "pointerenter": "pointerenter"; "pointerleave": "pointerleave"; "pointermove": "pointermove"; "pointermissed": "pointermissed"; "pointercancel": "pointercancel"; "wheel": "wheel"; "events": "objectEventsChange"; }, never, never, true, never>;
+}
+/**
+ * @deprecated Use objectEvents instead. Will be removed in v5.0.0
+ * @since v4.0.0
+ */
+declare const injectObjectEvents: typeof objectEvents;
+/**
+ * Sets up event listeners on a Three.js object.
+ *
+ * This function creates reactive event bindings that automatically clean up
+ * when the target changes or the component is destroyed.
+ *
+ * @param target - Signal containing the target Object3D
+ * @param events - Object mapping event names to handler functions
+ * @param options - Optional injector for dependency injection
+ * @returns Array of cleanup functions
+ *
+ * @example
+ * ```typescript
+ * objectEvents(
+ *   () => this.meshRef.nativeElement,
+ *   {
+ *     click: (event) => console.log('Clicked!', event),
+ *     pointerover: (event) => console.log('Hover start'),
+ *   }
+ * );
+ * ```
+ */
+declare function objectEvents(target: () => ElementRef<THREE.Object3D> | THREE.Object3D | null | undefined, events: NgtEventHandlers, { injector }?: {
+    injector?: Injector;
+}): (() => void)[];
+
+/**
+ * Gets the emit function from an OutputEmitterRef if it has active listeners.
+ *
+ * @typeParam T - The type of value the emitter emits
+ * @param emitterRef - The output emitter reference
+ * @returns The bound emit function, or undefined if no listeners
+ */
+declare function getEmitter<T>(emitterRef: OutputEmitterRef<T> | undefined): ((value: T) => void) | undefined;
+/**
+ * Checks if any of the provided emitter refs have active listeners.
+ *
+ * @param emitterRefs - The output emitter references to check
+ * @returns true if any emitter has listeners
+ */
+declare function hasListener(...emitterRefs: (OutputEmitterRef<unknown> | undefined)[]): boolean;
+
+/**
+ * @fileoverview Signal utilities for transforming and accessing object properties.
+ *
+ * This module provides computed signal utilities for working with object properties,
+ * including `omit`, `pick`, `merge`, and vector conversion functions.
+ */
+type KeysOfType<TObject extends object, TType> = Exclude<{
+    [K in keyof TObject]: TObject[K] extends TType | undefined | null ? K : never;
+}[keyof TObject], undefined>;
+/**
+ * Creates a computed signal that omits specified keys from an object.
+ *
+ * @typeParam TObject - The type of the source object
+ * @typeParam TKeys - The keys to omit
+ * @param objFn - Function returning the source object
+ * @param keysToOmit - Array of keys to omit
+ * @param equal - Optional equality function for change detection
+ * @returns A signal containing the object without the omitted keys
+ *
+ * @example
+ * ```typescript
+ * const state = signal({ a: 1, b: 2, c: 3 });
+ * const withoutB = omit(() => state(), ['b']);
+ * // withoutB() => { a: 1, c: 3 }
+ * ```
+ */
+declare function omit<TObject extends object, TKeys extends (keyof TObject)[]>(objFn: () => TObject, keysToOmit: TKeys, equal?: ValueEqualityFn<NoInfer<Omit<TObject, TKeys[number]>>>): Signal<Omit<TObject, TKeys[number]>>;
+/**
+ * Creates a computed signal that picks specified keys from an object.
+ *
+ * Can pick a single key (returning the value) or multiple keys (returning a partial object).
+ *
+ * @example
+ * ```typescript
+ * const state = signal({ a: 1, b: 2, c: 3 });
+ *
+ * // Pick single key
+ * const a = pick(() => state(), 'a');
+ * // a() => 1
+ *
+ * // Pick multiple keys
+ * const ab = pick(() => state(), ['a', 'b']);
+ * // ab() => { a: 1, b: 2 }
+ * ```
+ */
+declare function pick<TObject extends object, TKey extends keyof TObject>(objFn: () => TObject, key: TKey, equal?: ValueEqualityFn<NoInfer<TObject[TKey]>>): Signal<TObject[TKey]>;
+declare function pick<TObject extends object, TKeys extends (keyof TObject)[]>(objFn: () => TObject, keys: TKeys, equal?: ValueEqualityFn<NoInfer<Pick<TObject, TKeys[number]>>>): Signal<Pick<TObject, TKeys[number]>>;
+/**
+ * Creates a computed signal that merges an object with static values.
+ *
+ * @param objFn - Function returning the source object
+ * @param toMerge - Static values to merge
+ * @param mode - 'override' (default) puts toMerge values on top, 'backfill' puts them underneath
+ * @param equal - Optional equality function
+ * @returns A signal containing the merged object
+ *
+ * @example
+ * ```typescript
+ * const options = signal({ size: 10 });
+ * const withDefaults = merge(() => options(), { color: 'red' }, 'backfill');
+ * // withDefaults() => { color: 'red', size: 10 }
+ * ```
+ */
+declare function merge<TObject extends object>(objFn: () => TObject, toMerge: Partial<TObject>, mode?: 'override' | 'backfill', equal?: ValueEqualityFn<NoInfer<TObject>>): Signal<TObject & Partial<TObject>>;
+type NgtVectorComputed<TVector extends THREE.Vector2 | THREE.Vector3 | THREE.Vector4, TNgtVector = TVector extends THREE.Vector2 ? NgtVector2 : TVector extends THREE.Vector3 ? NgtVector3 : NgtVector4> = {
+    (input: Signal<TNgtVector>): Signal<TVector>;
+    (input: Signal<TNgtVector>, keepUndefined: true): Signal<TVector | undefined>;
+    <TObject extends object>(options: Signal<TObject>, key: KeysOfType<TObject, TNgtVector>): Signal<TVector>;
+    <TObject extends object>(options: Signal<TObject>, key: KeysOfType<TObject, TNgtVector>, keepUndefined: true): Signal<TVector | undefined>;
+};
+/**
+ * Creates a computed Vector2 signal from various input formats.
+ *
+ * Accepts: number (scalar), [x, y] array, or Vector2 instance.
+ *
+ * @example
+ * ```typescript
+ * const pos = vector2(input);
+ * // or from options object
+ * const pos = vector2(options, 'position');
+ * ```
+ */
+declare const vector2: NgtVectorComputed<THREE.Vector2, number | THREE.Vector2 | [x: number, y: number]>;
+/**
+ * Creates a computed Vector3 signal from various input formats.
+ *
+ * Accepts: number (scalar), [x, y, z] array, or Vector3 instance.
+ *
+ * @example
+ * ```typescript
+ * const pos = vector3(input);
+ * // or from options object
+ * const pos = vector3(options, 'position');
+ * ```
+ */
+declare const vector3: NgtVectorComputed<THREE.Vector3, number | THREE.Vector3 | [x: number, y: number, z: number]>;
+/**
+ * Creates a computed Vector4 signal from various input formats.
+ *
+ * Accepts: number (scalar), [x, y, z, w] array, or Vector4 instance.
+ *
+ * @example
+ * ```typescript
+ * const pos = vector4(input);
+ * // or from options object
+ * const pos = vector4(options, 'position');
+ * ```
+ */
+declare const vector4: NgtVectorComputed<THREE.Vector4, number | THREE.Vector4 | [x: number, y: number, z: number, w: number]>;
+
+/**
+ * Resolves a value that may be wrapped in an Angular ElementRef.
+ *
+ * If the value is an ElementRef, returns its nativeElement.
+ * Otherwise, returns the value directly.
+ *
+ * @typeParam TObject - The type of the object
+ * @param ref - An ElementRef or direct value
+ * @returns The unwrapped value
+ *
+ * @example
+ * ```typescript
+ * // With ElementRef
+ * const mesh = resolveRef(meshRef); // returns meshRef.nativeElement
+ *
+ * // With direct value
+ * const mesh = resolveRef(myMesh); // returns myMesh
+ * ```
+ */
+declare function resolveRef<TObject>(ref: ElementRef<TObject | undefined> | TObject | undefined): TObject | undefined;
+
+/**
+ * Sets the needsUpdate flag on an object if it has one.
+ *
+ * Also sets uniformsNeedUpdate for shader materials.
+ *
+ * @param value - The object to update
+ */
+declare function checkNeedsUpdate(value: unknown): void;
+/**
+ * Performs necessary updates on a Three.js object after property changes.
+ *
+ * For cameras, updates projection matrix and world matrix.
+ * For other objects, sets the needsUpdate flag.
+ *
+ * @param value - The object to update
+ */
+declare function checkUpdate(value: unknown): void;
+/**
+ * Updates a camera's projection based on the viewport size.
+ *
+ * For orthographic cameras, updates the frustum bounds.
+ * For perspective cameras, updates the aspect ratio.
+ * Skips update if the camera is marked as manual.
+ *
+ * @param camera - The camera to update
+ * @param size - The current viewport size
+ */
+declare function updateCamera(camera: NgtCamera, size: NgtSize): void;
+
+export { NGT_APPLY_PROPS, NGT_ARGS_FLAG, NGT_CANVAS_CONTENT_FLAG, NGT_CATALOGUE, NGT_DELEGATE_RENDERER_DESTROY_NODE_PATCHED_FLAG, NGT_DOM_PARENT_FLAG, NGT_GET_NODE_ATTRIBUTE_FLAG, NGT_HTML_FLAG, NGT_INTERNAL_ADD_COMMENT_FLAG, NGT_INTERNAL_SET_PARENT_COMMENT_FLAG, NGT_LOOP, NGT_PARENT_FLAG, NGT_PORTAL_CONTENT_FLAG, NGT_RENDERER_NODE_FLAG, NGT_RENDERER_OPTIONS, NGT_STORE, NgtArgs, NgtElementEvents, NgtHTML, NgtHexify, NgtObjectEvents, NgtParent, NgtPortal, NgtPortalAutoRender, NgtPortalContent, NgtPortalImpl, NgtRenderer2, NgtRendererFactory2, NgtRoutedScene, NgtSelect, NgtSelection, NgtSelectionApi, THREE_NATIVE_EVENTS, addAfterEffect, addEffect, addTail, applyProps, attach, beforeRender, canvasRootInitializer, checkNeedsUpdate, checkUpdate, createAttachFunction, createEvents, detach, dispose, elementEvents, extend, flushGlobalEffects, getEmitter, getInstanceState, getLocalState, hasListener, injectBeforeRender, injectCatalogue, injectLoader, injectLoop, injectObjectEvents, injectStore, invalidateInstance, is, loaderResource, makeCameraInstance, makeDpr, makeId, makeObjectGraph, makeRendererInstance, merge, objectEvents, omit, pick, prepare, provideHTMLDomElement, remove, removeInteractivity, resolveInstanceKey, resolveRef, roots, signalState, storeFactory, toDeepSignal, updateCamera, vector2, vector3, vector4 };
+export type { DeepSignal, NgtAfterAttach, NgtAllObject3DEventsMap, NgtAnyRecord, NgtArguments, NgtAttachFunction, NgtAttachable, NgtBeforeRenderEvent, NgtBeforeRenderRecord, NgtBranchingReturn, NgtCamera, NgtCameraLike, NgtCameraParameters, NgtCanvasConfigurator, NgtCanvasElement, NgtCanvasOptions, NgtColor, NgtComputeFunction, NgtConditionalType, NgtConstructorRepresentation, NgtDisposable, NgtDomEvent, NgtDpr, NgtElementProperties, NgtEquConfig, NgtEuler, NgtEventHandlers, NgtEventManager, NgtEventPrefix, NgtEvents, NgtFilterFunction, NgtFrameloop, NgtGLDefaultOptions, NgtGLOptions, NgtGLTFLike, NgtGlobalEffectType, NgtGlobalRenderCallback, NgtInjectedLoader, NgtInstanceHierarchyState, NgtInstanceNode, NgtInstanceState, NgtInternalState, NgtIntersection, NgtIntersectionEvent, NgtIsProperties, NgtLayers, NgtLoader, NgtLoaderExtensions, NgtLoaderProto, NgtLoaderResults, NgtLoaderReturnType, NgtMathProperties, NgtMathRepresentation, NgtMathType, NgtMathTypes, NgtMatrix3, NgtMatrix4, NgtMutable, NgtNodeElement, NgtNodeEventListener, NgtNodeEventMap, NgtNonFunctionKeys, NgtNonMutableProperties, NgtNonPartialProperties, NgtNullableRaycast, NgtNullish, NgtObject3DEventsMap, NgtObjectMap, NgtOverwrite, NgtPerformance, NgtPointerCaptureTarget, NgtPortalState, NgtProperties, NgtQuaternion, NgtRaycastableRepresentation, NgtRenderState, NgtRendererFactory2Options, NgtRendererLike, NgtShadows, NgtSize, NgtState, NgtThreeElement, NgtThreeElements, NgtThreeEvent, NgtVector2, NgtVector3, NgtVector4, NgtVectorRepresentation, NgtViewport, NgtXRManager, PartialStateUpdater, SignalState, StateSource, ThreeAddedEvent, ThreeChangeEvent, ThreeChildAddedEvent, ThreeChildRemovedEvent, ThreeDisposeEvent, ThreeRemovedEvent, WritableStateSource };