import * as i0 from '@angular/core';
import { Type, OnChanges, OnInit, OnDestroy, EventEmitter, SimpleChanges, AfterViewInit, ElementRef, InjectionToken, Provider, AfterContentChecked, isDevMode, QueryList, NgZone, PipeTransform } from '@angular/core';
import * as three from 'three';
import { EventListener, Event, Object3D, Vector3, Object3DEventMap, EulerOrder, Layers, Camera, Matrix4 as Matrix4$1, Vector4, Intersection, Vector2, Scene, Color, ColorRepresentation, Euler as Euler$1, WebGLRenderer, WebGLRendererParameters, WebGLRenderTarget, Clock, Material as Material$1, Controls, EventDispatcher, ShaderMaterial, Light, LightEventMap, AmbientLight, PerspectiveCamera, ArrayCamera, ArrowHelper, Audio, AudioListener as AudioListener$1, Line as Line$1, LineSegments, AxesHelper, Mesh as Mesh$1, BatchedMesh, Box3, MeshDepthMaterial, Bone, Box3Helper, BufferGeometry as BufferGeometry$1, NormalOrGLBufferAttributes, NormalBufferAttributes, BufferGeometryEventMap, BufferAttribute, GeometryGroup, BoxGeometry, BoxHelper, CameraHelper, Texture as Texture$1, Matrix3 as Matrix3$1, CanvasTexture, CapsuleGeometry, CircleGeometry, CompressedTextureImageData, CompressedTexture, CompressedTextureMipmap as CompressedTextureMipmap$1, CompressedArrayTexture, CompressedArrayTextureImageData, CompressedCubeTexture, CylinderGeometry, ConeGeometry, CubeCamera, CubeTexture as CubeTexture$1, Data3DTexture, Data3DTextureImageData, DataArrayTexture, DataArrayTextureImageData, DataTexture, DataTextureImageData, DepthTexture, DepthTextureImageData, DirectionalLight, DirectionalLightHelper, PolyhedronGeometry, DodecahedronGeometry, Raycaster, MOUSE, TOUCH, EdgesGeometry, ExternalTexture, ExtrudeGeometry, ExtrudeGeometryOptions, FramebufferTexture, FramebufferTextureImageData, GridHelper, Group, HemisphereLight, HemisphereLightHelper, IcosahedronGeometry, InstancedBufferGeometry, InstancedMeshEventMap, InstancedMesh, LatheGeometry, LightProbe, SphericalHarmonics3, LightShadow as LightShadow$1, LineBasicMaterial as LineBasicMaterial$1, LineBasicMaterialParameters, LineDashedMaterial, LineDashedMaterialParameters, LineLoop, LOD, MeshBasicMaterial as MeshBasicMaterial$1, MeshBasicMaterialParameters, MeshDepthMaterialParameters, MeshDistanceMaterial, MeshDistanceMaterialParameters, MeshLambertMaterial, MeshLambertMaterialParameters, MeshMatcapMaterial, MeshMatcapMaterialParameters, MeshNormalMaterial, MeshNormalMaterialParameters, MeshPhongMaterial, MeshPhongMaterialParameters, MeshStandardMaterial, MeshStandardMaterialParameters, MeshPhysicalMaterial, MeshPhysicalMaterialParameters, MeshToonMaterial, MeshToonMaterialParameters, OctahedronGeometry, OrthographicCamera, RawShaderMaterial, PlaneGeometry, PlaneHelper, Plane as Plane$1, PointLight, PointLightHelper, Points, PointsMaterial, PointsMaterialParameters, PolarGridHelper, PositionalAudio, ShaderMaterialParameters, RectAreaLight, RingGeometry, ShadowMaterial, ShadowMaterialParameters, ShapeGeometry, SkeletonHelper, SkinnedMesh as SkinnedMesh$1, SphereGeometry, SpotLight, SpotLightHelper, Sprite, SpriteMaterial as SpriteMaterial$1, SpriteMaterialParameters, StereoCamera, TetrahedronGeometry, Shape as Shape$1, TorusGeometry, TorusKnotGeometry, TubeGeometry, VideoTexture, VideoFrameTexture, WireframeGeometry, Loader, Fog as Fog$1, TextureLoader, CubeTextureLoader } from 'three';
import { CoordinateSystem, Mapping, Wrapping, MagnificationTextureFilter, MinificationTextureFilter, PixelFormat, TextureDataType, ColorSpace, AnyMapping, AnyPixelFormat, PixelFormatGPU, CompressedPixelFormat, CubeTextureMapping, DepthTexturePixelFormat, TextureComparisonFunction, Blending, Side, BlendingSrcFactor, BlendingDstFactor, BlendingEquation, DepthModes, StencilFunc, StencilOp, Combine, DepthPackingStrategies, NormalMapTypes, GLSLVersion, BindMode } from 'three/src/constants.js';
import { AnimationClip } from 'three/src/animation/AnimationClip.js';
import { Material } from 'three/src/materials/Material.js';
import { Euler } from 'three/src/math/Euler.js';
import { Matrix3 } from 'three/src/math/Matrix3.js';
import { Matrix4 } from 'three/src/math/Matrix4.js';
import { Quaternion } from 'three/src/math/Quaternion.js';
import * as rxjs from 'rxjs';
import { ReplaySubject, Observable, Subscription } from 'rxjs';
import * as three_examples_jsm_postprocessing_EffectComposer_js from 'three/examples/jsm/postprocessing/EffectComposer.js';
import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
import { Object3DEventMap as Object3DEventMap$1, Object3D as Object3D$1 } from 'three/src/core/Object3D.js';
import { Fog } from 'three/src/scenes/Fog.js';
import { FogExp2 } from 'three/src/scenes/FogExp2.js';
import { CubeTexture } from 'three/src/textures/CubeTexture.js';
import { Texture } from 'three/src/textures/Texture.js';
import { CSS3DObject, CSS3DRenderer, CSS3DParameters } from 'three/examples/jsm/renderers/CSS3DRenderer.js';
import { CSS2DObject, CSS2DRenderer, CSS2DParameters } from 'three/examples/jsm/renderers/CSS2DRenderer.js';
import { GLTF, GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
import { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';
import { OBJLoader } from 'three/examples/jsm/loaders/OBJLoader.js';
import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader.js';
import { PLYLoader } from 'three/examples/jsm/loaders/PLYLoader.js';
import { InterleavedBufferAttribute } from 'three/src/core/InterleavedBufferAttribute.js';
import { Sphere } from 'three/src/math/Sphere.js';
import { Vector3 as Vector3$1 } from 'three/src/math/Vector3.js';
import IndirectStorageBufferAttribute from 'three/src/renderers/common/IndirectStorageBufferAttribute.js';
import * as ngx_three from 'ngx-three';
import { RenderTarget } from 'three/src/core/RenderTarget.js';
import { Vector2 as Vector2$1 } from 'three/src/math/Vector2.js';
import { CompressedTextureMipmap, CompressedTextureImageData as CompressedTextureImageData$1 } from 'three/src/textures/CompressedTexture.js';
import { Source } from 'three/src/textures/Source.js';
import { DDSLoader } from 'three/examples/jsm/loaders/DDSLoader.js';
import { KTXLoader } from 'three/examples/jsm/loaders/KTXLoader.js';
import { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader.js';
import { PVRLoader } from 'three/examples/jsm/loaders/PVRLoader.js';
import { EXRLoader } from 'three/examples/jsm/loaders/EXRLoader.js';
import { TypedArray } from 'three/src/core/BufferAttribute.js';
import { RGBELoader } from 'three/examples/jsm/loaders/RGBELoader.js';
import { TGALoader } from 'three/examples/jsm/loaders/TGALoader.js';
import { UltraHDRLoader } from 'three/examples/jsm/loaders/UltraHDRLoader.js';
import { TransformControls, TransformControlsEventMap, TransformControlsMode } from 'three/examples/jsm/controls/TransformControls.js';
import { ArcballControls, ArcballControlsEventMap } from 'three/examples/jsm/controls/ArcballControls.js';
import { DragControls, DragControlsEventMap } from 'three/examples/jsm/controls/DragControls.js';
import { Camera as Camera$1 } from 'three/src/cameras/Camera.js';
import { FirstPersonControls } from 'three/examples/jsm/controls/FirstPersonControls.js';
import { FlyControls, FlyControlsEventMap } from 'three/examples/jsm/controls/FlyControls.js';
import { OrbitControls, OrbitControlsEventMap } from 'three/examples/jsm/controls/OrbitControls.js';
import { MapControls } from 'three/examples/jsm/controls/MapControls.js';
import { PointerLockControls, PointerLockControlsEventMap } from 'three/examples/jsm/controls/PointerLockControls.js';
import { TrackballControls, TrackballControlsEventMap } from 'three/examples/jsm/controls/TrackballControls.js';
import { AudioListener } from 'three/src/audio/AudioListener.js';
import { PerspectiveCamera as PerspectiveCamera$1 } from 'three/src/cameras/PerspectiveCamera.js';
import { WebGLCubeRenderTarget } from 'three/src/renderers/WebGLCubeRenderTarget.js';
import { ColorRepresentation as ColorRepresentation$1 } from 'three/src/math/Color.js';
import { Line } from 'three/src/objects/Line.js';
import { Mesh } from 'three/src/objects/Mesh.js';
import { BufferGeometry, NormalOrGLBufferAttributes as NormalOrGLBufferAttributes$1 } from 'three/src/core/BufferGeometry.js';
import { LineBasicMaterial } from 'three/src/materials/LineBasicMaterial.js';
import { DirectionalLight as DirectionalLight$1 } from 'three/src/lights/DirectionalLight.js';
import { HemisphereLight as HemisphereLight$1 } from 'three/src/lights/HemisphereLight.js';
import { MeshBasicMaterial } from 'three/src/materials/MeshBasicMaterial.js';
import { PointLight as PointLight$1 } from 'three/src/lights/PointLight.js';
import { Bone as Bone$1 } from 'three/src/objects/Bone.js';
import { SkinnedMesh } from 'three/src/objects/SkinnedMesh.js';
import { Light as Light$1 } from 'three/src/lights/Light.js';
import { LineSegments as LineSegments$1 } from 'three/src/objects/LineSegments.js';
import { LightShadow } from 'three/src/lights/LightShadow.js';
import { DirectionalLightShadow } from 'three/src/lights/DirectionalLightShadow.js';
import { PointLightShadow } from 'three/src/lights/PointLightShadow.js';
import { SpotLightShadow } from 'three/src/lights/SpotLightShadow.js';
import { InstancedBufferAttribute } from 'three/src/core/InstancedBufferAttribute.js';
import { DataTexture as DataTexture$1 } from 'three/src/textures/DataTexture.js';
import { Skeleton } from 'three/src/objects/Skeleton.js';
import { SpriteMaterial } from 'three/src/materials/Materials.js';
import { Plane } from 'three/src/math/Plane.js';
import { UniformsGroup } from 'three/src/core/UniformsGroup.js';
import { IUniform } from 'three/src/renderers/shaders/UniformsLib.js';
import { Shape } from 'three/src/extras/core/Shape.js';
import { Curve } from 'three/src/extras/core/Curve.js';
import { BoxLineGeometry } from 'three/examples/jsm/geometries/BoxLineGeometry.js';
import { ConvexGeometry } from 'three/examples/jsm/geometries/ConvexGeometry.js';
import { DecalGeometry } from 'three/examples/jsm/geometries/DecalGeometry.js';
import { ParametricGeometry } from 'three/examples/jsm/geometries/ParametricGeometry.js';
import { RoundedBoxGeometry } from 'three/examples/jsm/geometries/RoundedBoxGeometry.js';
import { TeapotGeometry } from 'three/examples/jsm/geometries/TeapotGeometry.js';
import { TextGeometry, TextGeometryParameters } from 'three/examples/jsm/geometries/TextGeometry.js';
import { Pass, FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
import { ShaderPass } from 'three/examples/jsm/postprocessing/ShaderPass.js';
import { AfterimagePass } from 'three/examples/jsm/postprocessing/AfterimagePass.js';
import { BloomPass } from 'three/examples/jsm/postprocessing/BloomPass.js';
import { BokehPass, BokehPassParameters } from 'three/examples/jsm/postprocessing/BokehPass.js';
import { ClearPass } from 'three/examples/jsm/postprocessing/ClearPass.js';
import { CubeTexturePass } from 'three/examples/jsm/postprocessing/CubeTexturePass.js';
import { DotScreenPass } from 'three/examples/jsm/postprocessing/DotScreenPass.js';
import { FilmPass } from 'three/examples/jsm/postprocessing/FilmPass.js';
import { GlitchPass } from 'three/examples/jsm/postprocessing/GlitchPass.js';
import { HalftonePass, HalftonePassParameters } from 'three/examples/jsm/postprocessing/HalftonePass.js';
import { LUTPass, LUTPassParameters } from 'three/examples/jsm/postprocessing/LUTPass.js';
import { ClearMaskPass, MaskPass } from 'three/examples/jsm/postprocessing/MaskPass.js';
import { OutlinePass } from 'three/examples/jsm/postprocessing/OutlinePass.js';
import { OutputPass } from 'three/examples/jsm/postprocessing/OutputPass.js';
import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass.js';
import * as three_examples_jsm_postprocessing_SAOPass_js from 'three/examples/jsm/postprocessing/SAOPass.js';
import { SAOPass, SAOPassParams } from 'three/examples/jsm/postprocessing/SAOPass.js';
import { SMAAPass } from 'three/examples/jsm/postprocessing/SMAAPass.js';
import { SSAARenderPass } from 'three/examples/jsm/postprocessing/SSAARenderPass.js';
import { SSAOPass, SSAOPassOUTPUT } from 'three/examples/jsm/postprocessing/SSAOPass.js';
import { ReflectorForSSRPass } from 'three/examples/jsm/objects/ReflectorForSSRPass.js';
import { SSRPass, SSRPassParams } from 'three/examples/jsm/postprocessing/SSRPass.js';
import { SavePass } from 'three/examples/jsm/postprocessing/SavePass.js';
import { TAARenderPass } from 'three/examples/jsm/postprocessing/TAARenderPass.js';
import { TexturePass } from 'three/examples/jsm/postprocessing/TexturePass.js';
import { UnrealBloomPass } from 'three/examples/jsm/postprocessing/UnrealBloomPass.js';
import * as i34 from '@angular/common';

/**
 * This interface represents the lifecycle of a three.js wrapper instance
 * The members are ordered with respect to their appearance in the lifecycle
 *
 * In general the lifecycle consists of 4 steps
 * 1) three.js object creation (Object3d, Material, Geometry ...)
 *   - either by createThreeInstance
 *   - or by setting an external objRef (i.e. Object3d ...)
 * 2) add three.js object to render tree
 *   - can be suppressed by setting "autoAddToParent" to false
 *   - this usually happens when ngOnInit is called or when an external objRef is set
 * -------------------------
 *  ...
 * -------------------------
 * 3) remove three.js object from render tree
 *   - happens in ngOnDestroy
 * 4) dispose object
 *   - can be suppressed by setting "autoDispose" to false
 *   - happens in ngOnDestroy
 *
 *
 * In the most simple form
 * Step 1 and 2 are equal to ngOnInit
 * Step 3 and 4 are equal to ngOnDestroy
 *
 */
interface ThWrapperLifeCycle {
    /**
     * reference to the corresponding three.js object (i.e.: Object3d, Material, Geometry ...)
     * set this member if you want to add your custom three.js instance to the wrapper
     */
    objRef: any;
    /**
     * implement this
     * returns the three.js type/class
     */
    getType(): Type<any>;
    /**
     * create the instance of the class return by @getType
     * override this method if you need custom construction code
     *
     * @param args the arguments to pass to the constructor
     */
    createThreeInstance(args?: unknown): any;
    /**
     * set to false if you do not want the three.js object to be added to the parent automatically
     * default: true
     */
    autoAddToParent: boolean;
    /**
     * adds the three.js objRef to the three.js parent
     * typically called in ngOnInit or when objRef is set
     */
    addToParent(): void;
    /**
     * called in ngOnDestroy
     *
     * override if you need custom behaviour
     */
    removeFromParent(): void;
    /**
     * set to false if you do not want that dispose is called on the three corresponding three.js class (if available)
     * ing ngOnDestroy
     *
     * default: true
     */
    autoDispose: boolean;
    /**
     * many three classes have dispose methods
     * by default this method is called in ngOnDestroy
     *
     * override if you need custom despose behaviour.
     */
    disposeObjRef(): void;
}

declare class ThWrapperBase<T, ARGS = unknown> implements ThWrapperLifeCycle, OnChanges, OnInit, OnDestroy {
    protected _objRef?: T;
    protected _objRef$?: ReplaySubject<T>;
    autoAddToParent: boolean;
    autoDispose: boolean;
    set objRef(ref: T | undefined);
    get objRef(): T | undefined;
    protected updateEmitter?: EventEmitter<SimpleChanges>;
    constructor();
    addToParent(): void;
    removeFromParent(): void;
    args?: ARGS;
    protected eventListeners?: {
        [key: Event['type']]: EventListener<Event, Event['type'], T>;
    };
    set threeEvents(eventMap: {
        [key: Event['type']]: EventListener<Event, Event['type'], T>;
    } | undefined);
    get threeEvents(): {
        [key: Event["type"]]: EventListener<Event, Event["type"], T>;
    } | undefined;
    get onUpdate(): Observable<SimpleChanges>;
    /**
     * emits the last assigned object ref
     */
    get objRef$(): Observable<T>;
    ngOnInit(): void;
    getType(): Type<any>;
    createThreeInstance(args?: unknown): any;
    ngOnChanges(changes: SimpleChanges): void;
    disposeObjRef(): void;
    ngOnDestroy(): void;
    protected applyObjRef(objRef: T | undefined): void;
    protected emitObjRefChange(): void;
    protected emitRemoveEvent(): void;
    protected emitPropertyChanges(changes: SimpleChanges): void;
    private removeEvents;
    private applyEvents;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThWrapperBase<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThWrapperBase<any, any>, "th-abs-wrapper", never, { "autoAddToParent": { "alias": "autoAddToParent"; "required": false; }; "autoDispose": { "alias": "autoDispose"; "required": false; }; "objRef": { "alias": "objRef"; "required": false; }; "args": { "alias": "args"; "required": false; }; "threeEvents": { "alias": "threeEvents"; "required": false; }; }, { "onUpdate": "onUpdate"; "objRef$": "objRef$"; }, never, never, true, never>;
}

declare class ThObjectBase<T extends Object3D, ARGS = unknown> extends ThWrapperBase<T, ARGS> implements OnInit {
    parent: ThObjectBase<any>;
    addToParent(): void;
    removeFromParent(): void;
    protected applyObjRef(objRef: T | undefined): void;
    protected attachToParent(newRef?: T, oldRef?: T): void;
    set lookAt(vector: Vector3 | [x: number, y: number, z: number]);
    static ɵfac: i0.ɵɵFactoryDeclaration<ThObjectBase<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThObjectBase<any, any>, "th-abs-object", never, { "lookAt": { "alias": "lookAt"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThObject3D<TEventMap extends Object3DEventMap = Object3DEventMap, T extends Object3D<TEventMap> = Object3D<TEventMap>, TARGS = []> extends ThObjectBase<T, TARGS> {
    parent: ThObject3D<Object3DEventMap, Object3D<Object3DEventMap>, []>;
    getType(): Type<Object3D<TEventMap>>;
    get isObject3D(): true | undefined;
    get id(): number | undefined;
    set uuid(value: string);
    get uuid(): string | undefined;
    set name(value: string);
    get name(): string | undefined;
    get type(): string | undefined;
    set children(value: Object3D[]);
    get children(): Object3D[] | undefined;
    set up(value: Vector3 | [x: number, y: number, z: number]);
    get up(): Vector3 | undefined;
    set position(value: Vector3 | [x: number, y: number, z: number]);
    get position(): Vector3 | undefined;
    set rotation(value: Euler | [x: number, y: number, z: number, order?: EulerOrder]);
    get rotation(): Euler | undefined;
    set quaternion(value: Quaternion | [x: number, y: number, z: number, w: number]);
    get quaternion(): Quaternion | undefined;
    set scale(value: Vector3 | [x: number, y: number, z: number]);
    get scale(): Vector3 | undefined;
    set modelViewMatrix(value: Matrix4 | [
        n11: number,
        n12: number,
        n13: number,
        n14: number,
        n21: number,
        n22: number,
        n23: number,
        n24: number,
        n31: number,
        n32: number,
        n33: number,
        n34: number,
        n41: number,
        n42: number,
        n43: number,
        n44: number
    ]);
    get modelViewMatrix(): Matrix4 | undefined;
    set normalMatrix(value: Matrix3 | [
        n11: number,
        n12: number,
        n13: number,
        n21: number,
        n22: number,
        n23: number,
        n31: number,
        n32: number,
        n33: number
    ]);
    get normalMatrix(): Matrix3 | undefined;
    set matrix(value: Matrix4 | [
        n11: number,
        n12: number,
        n13: number,
        n14: number,
        n21: number,
        n22: number,
        n23: number,
        n24: number,
        n31: number,
        n32: number,
        n33: number,
        n34: number,
        n41: number,
        n42: number,
        n43: number,
        n44: number
    ]);
    get matrix(): Matrix4 | undefined;
    set matrixWorld(value: Matrix4 | [
        n11: number,
        n12: number,
        n13: number,
        n14: number,
        n21: number,
        n22: number,
        n23: number,
        n24: number,
        n31: number,
        n32: number,
        n33: number,
        n34: number,
        n41: number,
        n42: number,
        n43: number,
        n44: number
    ]);
    get matrixWorld(): Matrix4 | undefined;
    set matrixAutoUpdate(value: boolean);
    get matrixAutoUpdate(): boolean | undefined;
    set matrixWorldAutoUpdate(value: boolean);
    get matrixWorldAutoUpdate(): boolean | undefined;
    set matrixWorldNeedsUpdate(value: boolean);
    get matrixWorldNeedsUpdate(): boolean | undefined;
    set layers(value: Layers | [layer: number]);
    get layers(): Layers | undefined;
    set visible(value: boolean);
    get visible(): boolean | undefined;
    set castShadow(value: boolean);
    get castShadow(): boolean | undefined;
    set receiveShadow(value: boolean);
    get receiveShadow(): boolean | undefined;
    set frustumCulled(value: boolean);
    get frustumCulled(): boolean | undefined;
    set renderOrder(value: number);
    get renderOrder(): number | undefined;
    set animations(value: AnimationClip[]);
    get animations(): AnimationClip[] | undefined;
    set userData(value: Record<string, any>);
    get userData(): Record<string, any> | undefined;
    set customDepthMaterial(value: Material | undefined);
    get customDepthMaterial(): (Material | undefined) | undefined;
    set customDistanceMaterial(value: Material | undefined);
    get customDistanceMaterial(): (Material | undefined) | undefined;
    static readonly DEFAULT_UP: Vector3;
    static readonly DEFAULT_MATRIX_AUTO_UPDATE: boolean;
    static readonly DEFAULT_MATRIX_WORLD_AUTO_UPDATE: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThObject3D<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThObject3D<any, any, any>, "th-object3D", never, { "uuid": { "alias": "uuid"; "required": false; }; "name": { "alias": "name"; "required": false; }; "children": { "alias": "children"; "required": false; }; "up": { "alias": "up"; "required": false; }; "position": { "alias": "position"; "required": false; }; "rotation": { "alias": "rotation"; "required": false; }; "quaternion": { "alias": "quaternion"; "required": false; }; "scale": { "alias": "scale"; "required": false; }; "modelViewMatrix": { "alias": "modelViewMatrix"; "required": false; }; "normalMatrix": { "alias": "normalMatrix"; "required": false; }; "matrix": { "alias": "matrix"; "required": false; }; "matrixWorld": { "alias": "matrixWorld"; "required": false; }; "matrixAutoUpdate": { "alias": "matrixAutoUpdate"; "required": false; }; "matrixWorldAutoUpdate": { "alias": "matrixWorldAutoUpdate"; "required": false; }; "matrixWorldNeedsUpdate": { "alias": "matrixWorldNeedsUpdate"; "required": false; }; "layers": { "alias": "layers"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "castShadow": { "alias": "castShadow"; "required": false; }; "receiveShadow": { "alias": "receiveShadow"; "required": false; }; "frustumCulled": { "alias": "frustumCulled"; "required": false; }; "renderOrder": { "alias": "renderOrder"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; "userData": { "alias": "userData"; "required": false; }; "customDepthMaterial": { "alias": "customDepthMaterial"; "required": false; }; "customDistanceMaterial": { "alias": "customDistanceMaterial"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThCamera<T extends Camera = Camera, TARGS = []> extends ThObject3D<Object3DEventMap, T, TARGS> {
    getType(): Type<Camera>;
    get isCamera(): true | undefined;
    get type(): (string | 'Camera') | undefined;
    set layers(value: Layers | [layer: number]);
    get layers(): Layers | undefined;
    set matrixWorldInverse(value: Matrix4$1 | [
        n11: number,
        n12: number,
        n13: number,
        n14: number,
        n21: number,
        n22: number,
        n23: number,
        n24: number,
        n31: number,
        n32: number,
        n33: number,
        n34: number,
        n41: number,
        n42: number,
        n43: number,
        n44: number
    ]);
    get matrixWorldInverse(): Matrix4$1 | undefined;
    set projectionMatrix(value: Matrix4$1 | [
        n11: number,
        n12: number,
        n13: number,
        n14: number,
        n21: number,
        n22: number,
        n23: number,
        n24: number,
        n31: number,
        n32: number,
        n33: number,
        n34: number,
        n41: number,
        n42: number,
        n43: number,
        n44: number
    ]);
    get projectionMatrix(): Matrix4$1 | undefined;
    set projectionMatrixInverse(value: Matrix4$1 | [
        n11: number,
        n12: number,
        n13: number,
        n14: number,
        n21: number,
        n22: number,
        n23: number,
        n24: number,
        n31: number,
        n32: number,
        n33: number,
        n34: number,
        n41: number,
        n42: number,
        n43: number,
        n44: number
    ]);
    get projectionMatrixInverse(): Matrix4$1 | undefined;
    set coordinateSystem(value: CoordinateSystem);
    get coordinateSystem(): CoordinateSystem | undefined;
    set viewport(value: Vector4 | [x: number, y: number, z: number, w: number]);
    get viewport(): Vector4 | undefined;
    get reversedDepth(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCamera<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCamera<any, any>, "th-camera", never, { "layers": { "alias": "layers"; "required": false; }; "matrixWorldInverse": { "alias": "matrixWorldInverse"; "required": false; }; "projectionMatrix": { "alias": "projectionMatrix"; "required": false; }; "projectionMatrixInverse": { "alias": "projectionMatrixInverse"; "required": false; }; "coordinateSystem": { "alias": "coordinateSystem"; "required": false; }; "viewport": { "alias": "viewport"; "required": false; }; }, {}, never, ["*"], true, never>;
}

interface RaycasterEmitEvent extends Intersection {
    type: RaycasterEvent;
    component: ThObject3D<RaycasterEventMap & Object3DEventMap>;
}
declare class RaycasterEventDirective implements AfterViewInit, OnDestroy {
    readonly host: ThObject3D<RaycasterEventMap & Object3DEventMap, three.Object3D<RaycasterEventMap & Object3DEventMap>, []>;
    private raycasterService;
    get onMouseEnter(): EventEmitter<RaycasterEmitEvent>;
    protected mouseEnter?: EventEmitter<RaycasterEmitEvent>;
    get onMouseExit(): EventEmitter<{
        component: ThObject3D<Object3DEventMap & RaycasterEventMap>;
        type: RaycasterEvent;
    }>;
    protected mouseExit?: EventEmitter<{
        component: ThObject3D<Object3DEventMap & RaycasterEventMap>;
        type: RaycasterEvent;
    }>;
    get onClick(): EventEmitter<RaycasterEmitEvent>;
    protected click?: EventEmitter<RaycasterEmitEvent>;
    get onPointerDown(): EventEmitter<RaycasterEmitEvent>;
    protected pointerDown?: EventEmitter<RaycasterEmitEvent>;
    get onPointerUp(): EventEmitter<RaycasterEmitEvent>;
    protected pointerUp?: EventEmitter<RaycasterEmitEvent>;
    constructor();
    ngAfterViewInit(): void;
    private subscribeEvents;
    private unSubscribeEvents;
    emitOnMouseExit(): void;
    emitOnMouseEnter(event: RaycasterEmitEvent): void;
    emitOnClick(event: RaycasterEmitEvent): void;
    emitOnPointerDown(event: RaycasterEmitEvent): void;
    emitOnPointerUp(event: RaycasterEmitEvent): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RaycasterEventDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RaycasterEventDirective, "[onClick], [onMouseEnter], [onMouseExit], [onPointerDown], [onPointerUp]", never, {}, { "onMouseEnter": "onMouseEnter"; "onMouseExit": "onMouseExit"; "onClick": "onClick"; "onPointerDown": "onPointerDown"; "onPointerUp": "onPointerUp"; }, never, never, true, never>;
}

declare class ThCSS2DObjectGen<T extends CSS2DObject = CSS2DObject, TARGS = HTMLElement> extends ThObject3D<Object3DEventMap, T, TARGS> {
    getType(): Type<CSS2DObject>;
    set element(value: HTMLElement);
    get element(): HTMLElement | undefined;
    set center(value: Vector2 | [x: number, y: number]);
    get center(): Vector2 | undefined;
    set onBeforeRender(value: (renderer: unknown, scene: Scene, camera: Camera) => void);
    get onBeforeRender(): ((renderer: unknown, scene: Scene, camera: Camera) => void) | undefined;
    set onAfterRender(value: (renderer: unknown, scene: Scene, camera: Camera) => void);
    get onAfterRender(): ((renderer: unknown, scene: Scene, camera: Camera) => void) | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCSS2DObjectGen<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCSS2DObjectGen<any, any>, "th-cSS2DObjectGen", never, { "element": { "alias": "element"; "required": false; }; "center": { "alias": "center"; "required": false; }; "onBeforeRender": { "alias": "onBeforeRender"; "required": false; }; "onAfterRender": { "alias": "onAfterRender"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThCSS2DObject<T extends CSS2DObject = CSS2DObject, TARGS = HTMLElement> extends ThCSS2DObjectGen<T, TARGS> {
    elementRef: ElementRef<any>;
    getType(): Type<CSS2DObject>;
    createThreeInstance(args?: unknown): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCSS2DObject<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCSS2DObject<any, any>, "th-cSS2DObject", never, {}, {}, never, ["*"], true, never>;
}

declare class ThCSS3DObjectGen<T extends CSS3DObject = CSS3DObject, TARGS = HTMLElement> extends ThObject3D<Object3DEventMap, T, TARGS> {
    getType(): Type<CSS3DObject>;
    set element(value: HTMLElement);
    get element(): HTMLElement | undefined;
    set onBeforeRender(value: (renderer: unknown, scene: Scene, camera: Camera) => void);
    get onBeforeRender(): ((renderer: unknown, scene: Scene, camera: Camera) => void) | undefined;
    set onAfterRender(value: (renderer: unknown, scene: Scene, camera: Camera) => void);
    get onAfterRender(): ((renderer: unknown, scene: Scene, camera: Camera) => void) | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCSS3DObjectGen<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCSS3DObjectGen<any, any>, "th-cSS3DObjectGen", never, { "element": { "alias": "element"; "required": false; }; "onBeforeRender": { "alias": "onBeforeRender"; "required": false; }; "onAfterRender": { "alias": "onAfterRender"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThCSS3DObject<T extends CSS3DObject = CSS3DObject, TARGS = HTMLElement> extends ThCSS3DObjectGen<T, TARGS> {
    elementRef: ElementRef<any>;
    getType(): Type<CSS3DObject>;
    createThreeInstance(args?: unknown): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCSS3DObject<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCSS3DObject<any, any>, "th-cSS3DObject", never, {}, {}, never, ["*"], true, never>;
}

declare class ThScene<TEventMap extends Object3DEventMap$1 = Object3DEventMap$1, T extends Scene<TEventMap> = Scene<TEventMap>, TARGS = []> extends ThObject3D<TEventMap, T, TARGS> {
    getType(): Type<Scene<TEventMap>>;
    get isScene(): true | undefined;
    set type(value: 'Scene');
    get type(): 'Scene' | undefined;
    set fog(value: Fog | FogExp2 | null);
    get fog(): (Fog | FogExp2 | null) | undefined;
    set backgroundBlurriness(value: number);
    get backgroundBlurriness(): number | undefined;
    set backgroundIntensity(value: number);
    get backgroundIntensity(): number | undefined;
    set overrideMaterial(value: Material | null);
    get overrideMaterial(): (Material | null) | undefined;
    set background(value: Color | Texture | CubeTexture | null | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get background(): (Color | Texture | CubeTexture | null) | undefined;
    set backgroundRotation(value: Euler$1 | [x: number, y: number, z: number, order?: EulerOrder]);
    get backgroundRotation(): Euler$1 | undefined;
    set environment(value: Texture | null);
    get environment(): (Texture | null) | undefined;
    set environmentIntensity(value: number);
    get environmentIntensity(): number | undefined;
    set environmentRotation(value: Euler$1 | [x: number, y: number, z: number, order?: EulerOrder]);
    get environmentRotation(): Euler$1 | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThScene<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThScene<any, any, any>, "th-scene", never, { "type": { "alias": "type"; "required": false; }; "fog": { "alias": "fog"; "required": false; }; "backgroundBlurriness": { "alias": "backgroundBlurriness"; "required": false; }; "backgroundIntensity": { "alias": "backgroundIntensity"; "required": false; }; "overrideMaterial": { "alias": "overrideMaterial"; "required": false; }; "background": { "alias": "background"; "required": false; }; "backgroundRotation": { "alias": "backgroundRotation"; "required": false; }; "environment": { "alias": "environment"; "required": false; }; "environmentIntensity": { "alias": "environmentIntensity"; "required": false; }; "environmentRotation": { "alias": "environmentRotation"; "required": false; }; }, {}, never, ["*"], true, never>;
}

type Renderer = WebGLRenderer | CSS3DRenderer | CSS2DRenderer;
type ThRendererParameters = Partial<WebGLRendererParameters>;
declare const RENDERER_PROVIDERS: InjectionToken<Renderer[]>;
declare const CSS3D_RENDERER: InjectionToken<CSS3DRenderer>;
declare const CSS2D_RENDERER: InjectionToken<CSS2DRenderer>;
declare const WEBGL_RENDERER: InjectionToken<WebGLRenderer>;
declare class RendererProviderDirective implements OnChanges {
    private viewContainer;
    private templateRef;
    private parentInjector;
    rendererParameters?: ThRendererParameters;
    css3DParameters?: CSS3DParameters;
    css2DParameters?: CSS2DParameters;
    private view?;
    private injector?;
    getInjectedRenderers(): Renderer[] | undefined;
    ngOnChanges(_changes: SimpleChanges): void;
    private createView;
    private createInjector;
    static ɵfac: i0.ɵɵFactoryDeclaration<RendererProviderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RendererProviderDirective, "ng-template[rendererParameters], ng-template[css2dRendererParameters], ng-template[css3dRendererParameters], ng-template[webgpuRendererParameters]", never, { "rendererParameters": { "alias": "rendererParameters"; "required": false; }; "css3DParameters": { "alias": "css3DParameters"; "required": false; }; "css2DParameters": { "alias": "css2DParameters"; "required": false; }; }, {}, never, never, true, never>;
}
declare function provideWebGLRenderer(parameters?: ThRendererParameters): Provider[];
declare function provideCSS3dRenderer(parameters?: CSS3DParameters): Provider[];
declare function provideCSS2dRenderer(parameters?: CSS2DParameters): Provider[];
declare function provideWebGPURenderer(parameters?: WebGLRendererParameters): Provider[];

declare const HOST_ELEMENT: InjectionToken<ElementRef<HTMLElement>>;
declare class ThView implements OnInit {
    protected engServ: ThEngineService;
    protected raycaster: RaycasterService;
    readonly hostElement: ElementRef<HTMLElement>;
    protected _camera?: ThCamera;
    protected _viewPort?: Vector4 | {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    protected _effectComposer?: EffectComposer;
    scene?: ThScene;
    /**
     * Emits before the render loop starts for this view (before effectComposer or main render pass, but after setting up the viewPort on the renderer).
     * It emits for every renderer.
     * It can be used to modify the scene, camera or renderer before rendering
     * and to do additional render passes
     *
     * @Note onRender is called before this event (and only once for all renderers)
     */
    onCurrentRendererPass: EventEmitter<{
        renderer: Renderer;
        scene: ThScene;
        camera: ThCamera;
        engine: ThEngineService;
    }>;
    set contentScene(scene: ThScene | undefined);
    set effectComposer(effectComposer: EffectComposer | undefined);
    get effectComposer(): EffectComposer | undefined;
    set camera(camera: ThCamera | undefined);
    get camera(): ThCamera | undefined;
    set contentCamera(camera: ThCamera<any> | undefined);
    /**
     * enable / disable shadows
     */
    shadow?: boolean;
    set viewPort(viewPort: Vector4 | {
        x: number;
        y: number;
        width: number;
        height: number;
    } | undefined);
    get viewPort(): Vector4 | {
        x: number;
        y: number;
        width: number;
        height: number;
    } | undefined;
    scissor?: Vector4 | {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    /**
     * Enable the scissor test. When this is enabled,
     * only the pixels within the defined scissor area will be affected by further renderer actions.
     */
    scissorTest?: boolean;
    /**
     * Sets the clear color
     */
    clearColor?: Color | string | number;
    /**
     * a float with the current clear alpha. Ranges from 0 to 1.
     */
    clearAlpha?: number;
    readonly onRender: EventEmitter<{
        renderer: Renderer[];
        scene: ThScene;
        camera: ThCamera;
    }>;
    ngOnInit(): void;
    private initRaycaster;
    add(_scene: Object3D): void;
    remove(_scene: Object3D): void;
    private configureEffectComposerRenderTarget;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThView, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThView, "th-view", never, { "scene": { "alias": "scene"; "required": false; }; "effectComposer": { "alias": "effectComposer"; "required": false; }; "camera": { "alias": "camera"; "required": false; }; "shadow": { "alias": "shadow"; "required": false; }; "viewPort": { "alias": "viewPort"; "required": false; }; "scissor": { "alias": "scissor"; "required": false; }; "scissorTest": { "alias": "scissorTest"; "required": false; }; "clearColor": { "alias": "clearColor"; "required": false; }; "clearAlpha": { "alias": "clearAlpha"; "required": false; }; }, { "onCurrentRendererPass": "onCurrentRendererPass"; "onRender": "onRender"; }, ["contentScene", "contentCamera"], ["*"], true, never>;
}

interface RenderState {
    engine: ThEngineService;
    delta: number;
}
declare class ThEngineService implements OnDestroy {
    private ngZone;
    readonly beforeRender$: Observable<RenderState>;
    readonly resize$: Observable<{
        width: number;
        height: number;
    }>;
    private readonly hostElement;
    readonly canvas?: HTMLCanvasElement;
    readonly wegblRenderer?: three.WebGLRenderer;
    /**
     * all injected renderers
     */
    readonly renderers: Renderer[];
    private clock;
    private destroyed$;
    private readonly resizeEmitter;
    private readonly beforeRenderEmitter;
    private views;
    private resizeObserver?;
    constructor();
    ngOnDestroy(): void;
    private initResizeObserver;
    private initCanvasSize;
    private initRenderer;
    setViews(views: ThView[]): void;
    addView(view: ThView): void;
    render(): void;
    protected renderView(view: ThView): void;
    protected applyRendererParametersFromView(view: ThView, renderer: Partial<WebGLRenderer>): void;
    resize(): boolean;
    protected calcRendererSize(): {
        width: number;
        height: number;
    };
    protected adjustViewDimensions(view: ThView, width: number, height: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThEngineService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ThEngineService>;
}

declare class ThEffectComposerGen<T extends EffectComposer = EffectComposer, TARGS = [renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget]> extends ThWrapperBase<T, TARGS> {
    getType(): Type<EffectComposer>;
    set renderer(value: WebGLRenderer);
    get renderer(): WebGLRenderer | undefined;
    set renderTarget1(value: WebGLRenderTarget);
    get renderTarget1(): WebGLRenderTarget | undefined;
    set renderTarget2(value: WebGLRenderTarget);
    get renderTarget2(): WebGLRenderTarget | undefined;
    set writeBuffer(value: WebGLRenderTarget);
    get writeBuffer(): WebGLRenderTarget | undefined;
    set readBuffer(value: WebGLRenderTarget);
    get readBuffer(): WebGLRenderTarget | undefined;
    set passes(value: Pass[]);
    get passes(): Pass[] | undefined;
    set copyPass(value: ShaderPass);
    get copyPass(): ShaderPass | undefined;
    set clock(value: Clock);
    get clock(): Clock | undefined;
    set renderToScreen(value: boolean);
    get renderToScreen(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThEffectComposerGen<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThEffectComposerGen<any, any>, "th-effectComposerGen", never, { "renderer": { "alias": "renderer"; "required": false; }; "renderTarget1": { "alias": "renderTarget1"; "required": false; }; "renderTarget2": { "alias": "renderTarget2"; "required": false; }; "writeBuffer": { "alias": "writeBuffer"; "required": false; }; "readBuffer": { "alias": "readBuffer"; "required": false; }; "passes": { "alias": "passes"; "required": false; }; "copyPass": { "alias": "copyPass"; "required": false; }; "clock": { "alias": "clock"; "required": false; }; "renderToScreen": { "alias": "renderToScreen"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThEffectComposer<T extends EffectComposer = EffectComposer, TARGS extends any[] = [renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget]> extends ThEffectComposerGen<T, TARGS> {
    protected view: ThView;
    protected engineService: ThEngineService;
    createThreeInstance(args?: TARGS): EffectComposer;
    private initRenderTarget;
    addToParent(): void;
    removeFromParent(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThEffectComposer<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThEffectComposer<any, any>, "th-effectComposer", never, {}, {}, never, ["*"], true, never>;
}

declare class ThPassBase<T extends Pass = Pass, ARGS = unknown> extends ThWrapperBase<T, ARGS> implements OnInit {
    protected effectComposer?: ThEffectComposer<three_examples_jsm_postprocessing_EffectComposer_js.EffectComposer, any[]> | null | undefined;
    addToParent(): void;
    removeFromParent(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPassBase<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThPassBase<any, any>, "th-abs-control", never, {}, {}, never, never, true, never>;
}

declare class ThPass<T extends Pass = Pass, TARGS = []> extends ThPassBase<T, TARGS> {
    getType(): Type<Pass>;
    set isPass(value: boolean);
    get isPass(): boolean | undefined;
    set enabled(value: boolean);
    get enabled(): boolean | undefined;
    set needsSwap(value: boolean);
    get needsSwap(): boolean | undefined;
    set clear(value: boolean);
    get clear(): boolean | undefined;
    set renderToScreen(value: boolean);
    get renderToScreen(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThPass<any, any>, "th-pass", never, { "isPass": { "alias": "isPass"; "required": false; }; "enabled": { "alias": "enabled"; "required": false; }; "needsSwap": { "alias": "needsSwap"; "required": false; }; "clear": { "alias": "clear"; "required": false; }; "renderToScreen": { "alias": "renderToScreen"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThRenderPassGen<T extends RenderPass = RenderPass, TARGS = [
    scene: Scene,
    camera: Camera,
    overrideMaterial?: Material$1 | null,
    clearColor?: Color | null,
    clearAlpha?: number | null
]> extends ThPass<T, TARGS> {
    getType(): Type<RenderPass>;
    set scene(value: Scene);
    get scene(): Scene | undefined;
    set camera(value: Camera);
    get camera(): Camera | undefined;
    set overrideMaterial(value: Material$1 | null);
    get overrideMaterial(): (Material$1 | null) | undefined;
    set clearColor(value: Color | null | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get clearColor(): (Color | null) | undefined;
    set clearAlpha(value: number | null);
    get clearAlpha(): (number | null) | undefined;
    set clear(value: boolean);
    get clear(): boolean | undefined;
    set clearDepth(value: boolean);
    get clearDepth(): boolean | undefined;
    set needsSwap(value: boolean);
    get needsSwap(): boolean | undefined;
    get isRenderPass(): true | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThRenderPassGen<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThRenderPassGen<any, any>, "th-renderPassGen", never, { "scene": { "alias": "scene"; "required": false; }; "camera": { "alias": "camera"; "required": false; }; "overrideMaterial": { "alias": "overrideMaterial"; "required": false; }; "clearColor": { "alias": "clearColor"; "required": false; }; "clearAlpha": { "alias": "clearAlpha"; "required": false; }; "clear": { "alias": "clear"; "required": false; }; "clearDepth": { "alias": "clearDepth"; "required": false; }; "needsSwap": { "alias": "needsSwap"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThRenderPass<T extends RenderPass = RenderPass, TARGS extends any[] = [
    scene: Scene,
    camera: Camera,
    overrideMaterial?: Material$1,
    clearColor?: Color,
    clearAlpha?: number
]> extends ThRenderPassGen<T, TARGS> implements AfterContentChecked {
    private view;
    createThreeInstance(args?: TARGS): RenderPass;
    ngAfterContentChecked(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThRenderPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThRenderPass<any, any>, "th-renderPass", never, {}, {}, never, ["*"], true, never>;
}

declare class ThAnimationLoopService implements OnDestroy {
    private engineService;
    private ngZone;
    private active;
    private frameId?;
    readonly beforeRender$: Observable<RenderState>;
    private destroyed$;
    constructor();
    ngOnDestroy(): void;
    /**
     * start the loop
     */
    start(): void;
    /**
     * stop the loop
     */
    stop(): void;
    /**
     *
     * @returns true if the render loop is active
     */
    isActive(): boolean;
    /**
     * trigger an animation frame request
     */
    requestAnimationFrame(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThAnimationLoopService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ThAnimationLoopService>;
}

declare class ThControlBase<TEventMap extends object = object, T extends Controls<TEventMap> = Controls<TEventMap>, TARGS = []> extends ThWrapperBase<T, TARGS> implements OnDestroy {
    protected _camera: ThObject3D<any, Object3D<any>, []>;
    protected canvas?: ThCanvas | undefined;
    protected renderLoop: ThAnimationLoopService;
    protected origDispatchEventMethod?: EventDispatcher['dispatchEvent'];
    protected beforeRenderSubscription?: Subscription;
    set domElement(value: HTMLElement);
    get domElement(): HTMLElement | SVGElement | null | undefined;
    set object(value: Object3D);
    get object(): Object3D | undefined;
    set enabled(value: boolean);
    get enabled(): boolean | undefined;
    createThreeInstance(args?: Iterable<any>): Partial<EventDispatcher<{}>>;
    protected patchDispatchEvent(dispatcher: Partial<EventDispatcher>): void;
    ngOnDestroy(): void;
    protected unpatchDispatchEvent(): void;
    protected subscribeControlUpdater(control: {
        update: (delta: number) => void;
    }): void;
    protected unsubscribeControlUpdater(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThControlBase<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThControlBase<any, any, any>, "th-abs-control", never, { "domElement": { "alias": "domElement"; "required": false; }; "object": { "alias": "object"; "required": false; }; "enabled": { "alias": "enabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ThTransformControlsGen<T extends TransformControls = TransformControls, TARGS = [camera: Camera, domElement?: HTMLElement | SVGElement | null]> extends ThControlBase<TransformControlsEventMap, T, TARGS> {
    getType(): Type<TransformControls>;
    set camera(value: Camera);
    get camera(): Camera | undefined;
    set axis(value: 'X' | 'Y' | 'Z' | 'E' | 'XY' | 'YZ' | 'XZ' | 'XYZ' | 'XYZE' | null);
    get axis(): ('X' | 'Y' | 'Z' | 'E' | 'XY' | 'YZ' | 'XZ' | 'XYZ' | 'XYZE' | null) | undefined;
    set mode(value: TransformControlsMode);
    get mode(): TransformControlsMode | undefined;
    set translationSnap(value: number | null);
    get translationSnap(): (number | null) | undefined;
    set rotationSnap(value: number | null);
    get rotationSnap(): (number | null) | undefined;
    set scaleSnap(value: number | null);
    get scaleSnap(): (number | null) | undefined;
    set space(value: 'world' | 'local');
    get space(): ('world' | 'local') | undefined;
    set size(value: number);
    get size(): number | undefined;
    set dragging(value: boolean);
    get dragging(): boolean | undefined;
    set showX(value: boolean);
    get showX(): boolean | undefined;
    set showY(value: boolean);
    get showY(): boolean | undefined;
    set showZ(value: boolean);
    get showZ(): boolean | undefined;
    set minx(value: number);
    get minx(): number | undefined;
    set maxX(value: number);
    get maxX(): number | undefined;
    set minY(value: number);
    get minY(): number | undefined;
    set maxY(value: number);
    get maxY(): number | undefined;
    set minZ(value: number);
    get minZ(): number | undefined;
    set maxZ(value: number);
    get maxZ(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTransformControlsGen<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThTransformControlsGen<any, any>, "th-transformControlsGen", never, { "camera": { "alias": "camera"; "required": false; }; "axis": { "alias": "axis"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "translationSnap": { "alias": "translationSnap"; "required": false; }; "rotationSnap": { "alias": "rotationSnap"; "required": false; }; "scaleSnap": { "alias": "scaleSnap"; "required": false; }; "space": { "alias": "space"; "required": false; }; "size": { "alias": "size"; "required": false; }; "dragging": { "alias": "dragging"; "required": false; }; "showX": { "alias": "showX"; "required": false; }; "showY": { "alias": "showY"; "required": false; }; "showZ": { "alias": "showZ"; "required": false; }; "minx": { "alias": "minx"; "required": false; }; "maxX": { "alias": "maxX"; "required": false; }; "minY": { "alias": "minY"; "required": false; }; "maxY": { "alias": "maxY"; "required": false; }; "minZ": { "alias": "minZ"; "required": false; }; "maxZ": { "alias": "maxZ"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThTransformControls<T extends TransformControls = TransformControls, TARGS = [object: Camera, domElement?: HTMLElement]> extends ThTransformControlsGen<T, TARGS> implements OnDestroy {
    protected scene: ThScene<three.Object3DEventMap, three.Scene<three.Object3DEventMap>, unknown>;
    private targetObject;
    getType(): Type<TransformControls>;
    set object(value: Object3D | undefined);
    protected objectAdded: () => void;
    protected objectRemoved: () => void;
    addToParent(): void;
    removeFromParent(): void;
    ngOnDestroy(): void;
    protected removeObjectListeners(): void;
    protected addObjectListeners(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTransformControls<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThTransformControls<any, any>, "th-transformControls", never, { "object": { "alias": "object"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThAfterimagePass<T extends AfterimagePass = AfterimagePass, TARGS = number> extends ThPass<T, TARGS> {
    getType(): Type<AfterimagePass>;
    set uniforms(map: {
        [name: string]: {
            value: any;
        };
    });
    get uniforms(): {
        [name: string]: {
            value: any;
        };
    } | undefined;
    set compFsMaterial(value: ShaderMaterial);
    get compFsMaterial(): ShaderMaterial | undefined;
    set copyFsMaterial(value: ShaderMaterial);
    get copyFsMaterial(): ShaderMaterial | undefined;
    get damp(): number | undefined;
    set damp(value: number);
    static ɵfac: i0.ɵɵFactoryDeclaration<ThAfterimagePass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThAfterimagePass<any, any>, "th-afterimagePass", never, { "uniforms": { "alias": "uniforms"; "required": false; }; "compFsMaterial": { "alias": "compFsMaterial"; "required": false; }; "copyFsMaterial": { "alias": "copyFsMaterial"; "required": false; }; "damp": { "alias": "damp"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare abstract class ThLight<TShadowSupport extends LightShadow | undefined = LightShadow | undefined, T extends Light<TShadowSupport> = Light<TShadowSupport>, TARGS = [color?: ColorRepresentation, intensity?: number]> extends ThObject3D<LightEventMap, T, TARGS> {
    get isLight(): true | undefined;
    get type(): (string | 'Light') | undefined;
    set color(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get color(): Color | undefined;
    set intensity(value: number);
    get intensity(): number | undefined;
    set shadow(value: TShadowSupport);
    get shadow(): TShadowSupport | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThLight<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThLight<any, any, any>, "th-light", never, { "color": { "alias": "color"; "required": false; }; "intensity": { "alias": "intensity"; "required": false; }; "shadow": { "alias": "shadow"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThAmbientLight<T extends AmbientLight = AmbientLight, TARGS = [color?: ColorRepresentation$1, intensity?: number]> extends ThLight<undefined, T, TARGS> {
    getType(): Type<AmbientLight>;
    get isAmbientLight(): true | undefined;
    get type(): (string | 'AmbientLight') | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThAmbientLight<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThAmbientLight<any, any>, "th-ambientLight", never, {}, {}, never, ["*"], true, never>;
}

declare class ThArcballControls<T extends ArcballControls = ArcballControls, TARGS = [
    camera: Camera,
    domElement?: HTMLElement | SVGElement | null,
    scene?: Scene | null
]> extends ThControlBase<ArcballControlsEventMap, T, TARGS> {
    getType(): Type<ArcballControls>;
    set scene(value: Scene | null);
    get scene(): (Scene | null) | undefined;
    set radiusFactor(value: number);
    get radiusFactor(): number | undefined;
    set focusAnimationTime(value: number);
    get focusAnimationTime(): number | undefined;
    set adjustNearFar(value: boolean);
    get adjustNearFar(): boolean | undefined;
    set scaleFactor(value: number);
    get scaleFactor(): number | undefined;
    set dampingFactor(value: number);
    get dampingFactor(): number | undefined;
    set wMax(value: number);
    get wMax(): number | undefined;
    set enableAnimations(value: boolean);
    get enableAnimations(): boolean | undefined;
    set enableFocus(value: boolean);
    get enableFocus(): boolean | undefined;
    set enableGrid(value: boolean);
    get enableGrid(): boolean | undefined;
    set cursorZoom(value: boolean);
    get cursorZoom(): boolean | undefined;
    set rotateSpeed(value: number);
    get rotateSpeed(): number | undefined;
    set enablePan(value: boolean);
    get enablePan(): boolean | undefined;
    set enableRotate(value: boolean);
    get enableRotate(): boolean | undefined;
    set enableZoom(value: boolean);
    get enableZoom(): boolean | undefined;
    set minDistance(value: number);
    get minDistance(): number | undefined;
    set maxDistance(value: number);
    get maxDistance(): number | undefined;
    set minZoom(value: number);
    get minZoom(): number | undefined;
    set maxZoom(value: number);
    get maxZoom(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThArcballControls<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThArcballControls<any, any>, "th-arcballControls", never, { "scene": { "alias": "scene"; "required": false; }; "radiusFactor": { "alias": "radiusFactor"; "required": false; }; "focusAnimationTime": { "alias": "focusAnimationTime"; "required": false; }; "adjustNearFar": { "alias": "adjustNearFar"; "required": false; }; "scaleFactor": { "alias": "scaleFactor"; "required": false; }; "dampingFactor": { "alias": "dampingFactor"; "required": false; }; "wMax": { "alias": "wMax"; "required": false; }; "enableAnimations": { "alias": "enableAnimations"; "required": false; }; "enableFocus": { "alias": "enableFocus"; "required": false; }; "enableGrid": { "alias": "enableGrid"; "required": false; }; "cursorZoom": { "alias": "cursorZoom"; "required": false; }; "rotateSpeed": { "alias": "rotateSpeed"; "required": false; }; "enablePan": { "alias": "enablePan"; "required": false; }; "enableRotate": { "alias": "enableRotate"; "required": false; }; "enableZoom": { "alias": "enableZoom"; "required": false; }; "minDistance": { "alias": "minDistance"; "required": false; }; "maxDistance": { "alias": "maxDistance"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "maxZoom": { "alias": "maxZoom"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThPerspectiveCamera<T extends PerspectiveCamera = PerspectiveCamera, TARGS = [fov?: number, aspect?: number, near?: number, far?: number]> extends ThCamera<T, TARGS> {
    getType(): Type<PerspectiveCamera>;
    get isPerspectiveCamera(): true | undefined;
    get type(): (string | 'PerspectiveCamera') | undefined;
    set zoom(value: number);
    get zoom(): number | undefined;
    set fov(value: number);
    get fov(): number | undefined;
    set aspect(value: number);
    get aspect(): number | undefined;
    set near(value: number);
    get near(): number | undefined;
    set far(value: number);
    get far(): number | undefined;
    set focus(value: number);
    get focus(): number | undefined;
    set view(value: null | {
        enabled: boolean;
        fullWidth: number;
        fullHeight: number;
        offsetX: number;
        offsetY: number;
        width: number;
        height: number;
    });
    get view(): (null | {
        enabled: boolean;
        fullWidth: number;
        fullHeight: number;
        offsetX: number;
        offsetY: number;
        width: number;
        height: number;
    }) | undefined;
    set filmGauge(value: number);
    get filmGauge(): number | undefined;
    set filmOffset(value: number);
    get filmOffset(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPerspectiveCamera<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThPerspectiveCamera<any, any>, "th-perspectiveCamera", never, { "zoom": { "alias": "zoom"; "required": false; }; "fov": { "alias": "fov"; "required": false; }; "aspect": { "alias": "aspect"; "required": false; }; "near": { "alias": "near"; "required": false; }; "far": { "alias": "far"; "required": false; }; "focus": { "alias": "focus"; "required": false; }; "view": { "alias": "view"; "required": false; }; "filmGauge": { "alias": "filmGauge"; "required": false; }; "filmOffset": { "alias": "filmOffset"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThArrayCamera<T extends ArrayCamera = ArrayCamera, TARGS = PerspectiveCamera$1[]> extends ThPerspectiveCamera<T, TARGS> {
    getType(): Type<ArrayCamera>;
    get isArrayCamera(): true | undefined;
    set isMultiViewCamera(value: boolean);
    get isMultiViewCamera(): boolean | undefined;
    set cameras(value: PerspectiveCamera$1[]);
    get cameras(): PerspectiveCamera$1[] | undefined;
    set index(value: number);
    get index(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThArrayCamera<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThArrayCamera<any, any>, "th-arrayCamera", never, { "isMultiViewCamera": { "alias": "isMultiViewCamera"; "required": false; }; "cameras": { "alias": "cameras"; "required": false; }; "index": { "alias": "index"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThArrowHelper<T extends ArrowHelper = ArrowHelper, TARGS = [
    dir?: Vector3$1,
    origin?: Vector3$1,
    length?: number,
    color?: ColorRepresentation$1,
    headLength?: number,
    headWidth?: number
]> extends ThObject3D<Object3DEventMap, T, TARGS> {
    getType(): Type<ArrowHelper>;
    get type(): (string | 'ArrowHelper') | undefined;
    set line(value: Line);
    get line(): Line | undefined;
    set cone(value: Mesh);
    get cone(): Mesh | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThArrowHelper<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThArrowHelper<any, any>, "th-arrowHelper", never, { "line": { "alias": "line"; "required": false; }; "cone": { "alias": "cone"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThAudio<NodeType extends AudioNode = GainNode, T extends Audio<NodeType> = Audio<NodeType>, TARGS = AudioListener> extends ThObject3D<Object3DEventMap, T, TARGS> {
    getType(): Type<Audio<NodeType>>;
    get type(): (string | 'Audio') | undefined;
    set listener(value: AudioListener);
    get listener(): AudioListener | undefined;
    set context(value: AudioContext);
    get context(): AudioContext | undefined;
    set gain(value: GainNode);
    get gain(): GainNode | undefined;
    set autoplay(value: boolean);
    get autoplay(): boolean | undefined;
    set buffer(value: AudioBuffer | null);
    get buffer(): (AudioBuffer | null) | undefined;
    set detune(value: number);
    get detune(): number | undefined;
    set loop(value: boolean);
    get loop(): boolean | undefined;
    set loopStart(value: number);
    get loopStart(): number | undefined;
    set loopEnd(value: number);
    get loopEnd(): number | undefined;
    set offset(value: number);
    get offset(): number | undefined;
    set duration(value: number | undefined);
    get duration(): (number | undefined) | undefined;
    set playbackRate(value: number);
    get playbackRate(): number | undefined;
    set isPlaying(value: boolean);
    get isPlaying(): boolean | undefined;
    set hasPlaybackControl(value: boolean);
    get hasPlaybackControl(): boolean | undefined;
    set sourceType(value: string);
    get sourceType(): string | undefined;
    set source(value: AudioScheduledSourceNode | null);
    get source(): (AudioScheduledSourceNode | null) | undefined;
    set filters(value: AudioNode[]);
    get filters(): AudioNode[] | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThAudio<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThAudio<any, any, any>, "th-audio", never, { "listener": { "alias": "listener"; "required": false; }; "context": { "alias": "context"; "required": false; }; "gain": { "alias": "gain"; "required": false; }; "autoplay": { "alias": "autoplay"; "required": false; }; "buffer": { "alias": "buffer"; "required": false; }; "detune": { "alias": "detune"; "required": false; }; "loop": { "alias": "loop"; "required": false; }; "loopStart": { "alias": "loopStart"; "required": false; }; "loopEnd": { "alias": "loopEnd"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; "playbackRate": { "alias": "playbackRate"; "required": false; }; "isPlaying": { "alias": "isPlaying"; "required": false; }; "hasPlaybackControl": { "alias": "hasPlaybackControl"; "required": false; }; "sourceType": { "alias": "sourceType"; "required": false; }; "source": { "alias": "source"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThAudioListener<T extends AudioListener$1 = AudioListener$1, TARGS = []> extends ThObject3D<Object3DEventMap, T, TARGS> {
    getType(): Type<AudioListener$1>;
    get type(): (string | 'AudioListener') | undefined;
    set context(value: AudioContext);
    get context(): AudioContext | undefined;
    set gain(value: GainNode);
    get gain(): GainNode | undefined;
    set filter(value: AudioNode);
    get filter(): AudioNode | undefined;
    set timeDelta(value: number);
    get timeDelta(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThAudioListener<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThAudioListener<any, any>, "th-audioListener", never, { "context": { "alias": "context"; "required": false; }; "gain": { "alias": "gain"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "timeDelta": { "alias": "timeDelta"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThLine<TGeometry extends BufferGeometry = BufferGeometry, TMaterial extends Material | Material[] = Material | Material[], TEventMap extends Object3DEventMap$1 = Object3DEventMap$1, T extends Line$1<TGeometry, TMaterial, TEventMap> = Line$1<TGeometry, TMaterial, TEventMap>, TARGS = [geometry?: TGeometry, material?: TMaterial]> extends ThObject3D<TEventMap, T, TARGS> {
    getType(): Type<Line$1<TGeometry, TMaterial, TEventMap>>;
    get isLine(): true | undefined;
    get type(): (string | 'Line') | undefined;
    set geometry(value: TGeometry);
    get geometry(): TGeometry | undefined;
    set material(value: TMaterial);
    get material(): TMaterial | undefined;
    set morphTargetInfluences(value: number[] | undefined);
    get morphTargetInfluences(): (number[] | undefined) | undefined;
    set morphTargetDictionary(value: {
        [key: string]: number;
    } | undefined);
    get morphTargetDictionary(): ({
        [key: string]: number;
    } | undefined) | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThLine<any, any, any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThLine<any, any, any, any, any>, "th-line", never, { "geometry": { "alias": "geometry"; "required": false; }; "material": { "alias": "material"; "required": false; }; "morphTargetInfluences": { "alias": "morphTargetInfluences"; "required": false; }; "morphTargetDictionary": { "alias": "morphTargetDictionary"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThLineSegments<TGeometry extends BufferGeometry = BufferGeometry, TMaterial extends Material | Material[] = Material | Material[], TEventMap extends Object3DEventMap$1 = Object3DEventMap$1, T extends LineSegments<TGeometry, TMaterial, TEventMap> = LineSegments<TGeometry, TMaterial, TEventMap>, TARGS = [geometry?: TGeometry, material?: TMaterial]> extends ThLine<TGeometry, TMaterial, TEventMap, T, TARGS> {
    getType(): Type<LineSegments<TGeometry, TMaterial, TEventMap>>;
    get isLineSegments(): true | undefined;
    get type(): (string | 'LineSegments') | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThLineSegments<any, any, any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThLineSegments<any, any, any, any, any>, "th-lineSegments", never, {}, {}, never, ["*"], true, never>;
}

declare class ThAxesHelper<T extends AxesHelper = AxesHelper, TARGS = number> extends ThLineSegments<BufferGeometry, LineBasicMaterial, Object3DEventMap, T, TARGS> {
    getType(): Type<AxesHelper>;
    get type(): (string | 'AxesHelper') | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThAxesHelper<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThAxesHelper<any, any>, "th-axesHelper", never, {}, {}, never, ["*"], true, never>;
}

declare class ThMesh<TGeometry extends BufferGeometry = BufferGeometry, TMaterial extends Material | Material[] = Material | Material[], TEventMap extends Object3DEventMap$1 = Object3DEventMap$1, T extends Mesh$1<TGeometry, TMaterial, TEventMap> = Mesh$1<TGeometry, TMaterial, TEventMap>, TARGS = [geometry?: TGeometry, material?: TMaterial]> extends ThObject3D<TEventMap, T, TARGS> {
    getType(): Type<Mesh$1<TGeometry, TMaterial, TEventMap>>;
    get isMesh(): true | undefined;
    get type(): (string | 'Mesh') | undefined;
    set geometry(value: TGeometry);
    get geometry(): TGeometry | undefined;
    set material(value: TMaterial);
    get material(): TMaterial | undefined;
    set morphTargetInfluences(value: number[] | undefined);
    get morphTargetInfluences(): (number[] | undefined) | undefined;
    set morphTargetDictionary(value: {
        [key: string]: number;
    } | undefined);
    get morphTargetDictionary(): ({
        [key: string]: number;
    } | undefined) | undefined;
    set count(value: number);
    get count(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMesh<any, any, any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMesh<any, any, any, any, any>, "th-mesh", never, { "geometry": { "alias": "geometry"; "required": false; }; "material": { "alias": "material"; "required": false; }; "morphTargetInfluences": { "alias": "morphTargetInfluences"; "required": false; }; "morphTargetDictionary": { "alias": "morphTargetDictionary"; "required": false; }; "count": { "alias": "count"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThBatchedMesh<T extends BatchedMesh = BatchedMesh, TARGS = [
    maxInstanceCount: number,
    maxVertexCount: number,
    maxIndexCount?: number,
    material?: Material
]> extends ThMesh<BufferGeometry, Material, Object3DEventMap, T, TARGS> {
    getType(): Type<BatchedMesh>;
    set boundingBox(value: Box3 | null | [min: Vector3$1, max: Vector3$1]);
    get boundingBox(): (Box3 | null) | undefined;
    set boundingSphere(value: Sphere | null | [center: Vector3$1, radius: number]);
    get boundingSphere(): (Sphere | null) | undefined;
    set customSort(value: ((this: T, list: Array<{
        start: number;
        count: number;
        z: number;
    }>, camera: Camera$1) => void) | null);
    get customSort(): (((this: T, list: Array<{
        start: number;
        count: number;
        z: number;
    }>, camera: Camera$1) => void) | null) | undefined;
    set perObjectFrustumCulled(value: boolean);
    get perObjectFrustumCulled(): boolean | undefined;
    set sortObjects(value: boolean);
    get sortObjects(): boolean | undefined;
    get maxInstanceCount(): number | undefined;
    get instanceCount(): number | undefined;
    get unusedVertexCount(): number | undefined;
    get unusedIndexCount(): number | undefined;
    get isBatchedMesh(): true | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThBatchedMesh<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThBatchedMesh<any, any>, "th-batchedMesh", never, { "boundingBox": { "alias": "boundingBox"; "required": false; }; "boundingSphere": { "alias": "boundingSphere"; "required": false; }; "customSort": { "alias": "customSort"; "required": false; }; "perObjectFrustumCulled": { "alias": "perObjectFrustumCulled"; "required": false; }; "sortObjects": { "alias": "sortObjects"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThBloomPass<T extends BloomPass = BloomPass, TARGS = [strength?: number, kernelSize?: number, sigma?: number]> extends ThPass<T, TARGS> {
    getType(): Type<BloomPass>;
    set renderTargetX(value: WebGLRenderTarget);
    get renderTargetX(): WebGLRenderTarget | undefined;
    set renderTargetY(value: WebGLRenderTarget);
    get renderTargetY(): WebGLRenderTarget | undefined;
    set copyUniforms(value: object);
    get copyUniforms(): object | undefined;
    set materialCopy(value: ShaderMaterial);
    get materialCopy(): ShaderMaterial | undefined;
    set convolutionUniforms(value: object);
    get convolutionUniforms(): object | undefined;
    set materialConvolution(value: ShaderMaterial);
    get materialConvolution(): ShaderMaterial | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThBloomPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThBloomPass<any, any>, "th-bloomPass", never, { "renderTargetX": { "alias": "renderTargetX"; "required": false; }; "renderTargetY": { "alias": "renderTargetY"; "required": false; }; "copyUniforms": { "alias": "copyUniforms"; "required": false; }; "materialCopy": { "alias": "materialCopy"; "required": false; }; "convolutionUniforms": { "alias": "convolutionUniforms"; "required": false; }; "materialConvolution": { "alias": "materialConvolution"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThBokehPass<T extends BokehPass = BokehPass, TARGS = [scene: Scene, camera: Camera, params: BokehPassParameters]> extends ThPass<T, TARGS> {
    getType(): Type<BokehPass>;
    set scene(value: Scene);
    get scene(): Scene | undefined;
    set camera(value: Camera);
    get camera(): Camera | undefined;
    set renderTargetColor(value: WebGLRenderTarget);
    get renderTargetColor(): WebGLRenderTarget | undefined;
    set renderTargetDepth(value: WebGLRenderTarget);
    get renderTargetDepth(): WebGLRenderTarget | undefined;
    set materialDepth(value: MeshDepthMaterial);
    get materialDepth(): MeshDepthMaterial | undefined;
    set materialBokeh(value: ShaderMaterial);
    get materialBokeh(): ShaderMaterial | undefined;
    set uniforms(map: {
        [name: string]: {
            value: any;
        };
    });
    get uniforms(): {
        [name: string]: {
            value: any;
        };
    } | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    set oldClearColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get oldClearColor(): Color | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThBokehPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThBokehPass<any, any>, "th-bokehPass", never, { "scene": { "alias": "scene"; "required": false; }; "camera": { "alias": "camera"; "required": false; }; "renderTargetColor": { "alias": "renderTargetColor"; "required": false; }; "renderTargetDepth": { "alias": "renderTargetDepth"; "required": false; }; "materialDepth": { "alias": "materialDepth"; "required": false; }; "materialBokeh": { "alias": "materialBokeh"; "required": false; }; "uniforms": { "alias": "uniforms"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; "oldClearColor": { "alias": "oldClearColor"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThBone<TEventMap extends Object3DEventMap$1 = Object3DEventMap$1, T extends Bone<TEventMap> = Bone<TEventMap>, TARGS = []> extends ThObject3D<TEventMap, T, TARGS> {
    getType(): Type<Bone<TEventMap>>;
    get isBone(): true | undefined;
    get type(): (string | 'Bone') | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThBone<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThBone<any, any, any>, "th-bone", never, {}, {}, never, ["*"], true, never>;
}

declare class ThBox3Helper<T extends Box3Helper = Box3Helper, TARGS = [box: Box3, color?: ColorRepresentation$1]> extends ThLineSegments<BufferGeometry$1, Material$1 | Material$1[], Object3DEventMap, T, TARGS> {
    getType(): Type<Box3Helper>;
    get type(): (string | 'Box3Helper') | undefined;
    set box(value: Box3 | [min: Vector3$1, max: Vector3$1]);
    get box(): Box3 | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThBox3Helper<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThBox3Helper<any, any>, "th-box3Helper", never, { "box": { "alias": "box"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThGeometryBase<T extends BufferGeometry$1<NormalOrGLBufferAttributes>, ARGS> extends ThWrapperBase<T, ARGS> {
    protected parent: ThObject3D<three.Object3DEventMap, three.Object3D<three.Object3DEventMap>, unknown>;
    addToParent(): void;
    removeFromParent(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThGeometryBase<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThGeometryBase<any, any>, "th-abs-geometry", never, {}, {}, never, never, true, never>;
}

declare class ThBufferGeometry<Attributes extends NormalOrGLBufferAttributes = NormalBufferAttributes, TEventMap extends BufferGeometryEventMap = BufferGeometryEventMap, T extends BufferGeometry$1<Attributes, TEventMap> = BufferGeometry$1<Attributes, TEventMap>, TARGS = []> extends ThGeometryBase<T, TARGS> {
    parent: ThObject3D<three.Object3DEventMap, three.Object3D<three.Object3DEventMap>, []>;
    getType(): Type<BufferGeometry$1<Attributes, TEventMap>>;
    set id(value: number);
    get id(): number | undefined;
    set uuid(value: string);
    get uuid(): string | undefined;
    set name(value: string);
    get name(): string | undefined;
    get type(): (string | 'BufferGeometry') | undefined;
    set index(value: BufferAttribute | null | [value: ArrayLike<number> | ArrayBufferView, offset?: number]);
    get index(): (BufferAttribute | null) | undefined;
    set indirect(value: IndirectStorageBufferAttribute | null | [value: ArrayLike<number> | ArrayBufferView, offset?: number]);
    get indirect(): (IndirectStorageBufferAttribute | null) | undefined;
    set indirectOffset(value: number | number[]);
    get indirectOffset(): (number | number[]) | undefined;
    set attributes(value: Attributes);
    get attributes(): Attributes | undefined;
    set morphAttributes(value: {
        position?: Array<BufferAttribute | InterleavedBufferAttribute> | undefined;
        normal?: Array<BufferAttribute | InterleavedBufferAttribute> | undefined;
        color?: Array<BufferAttribute | InterleavedBufferAttribute> | undefined;
    });
    get morphAttributes(): {
        position?: Array<BufferAttribute | InterleavedBufferAttribute> | undefined;
        normal?: Array<BufferAttribute | InterleavedBufferAttribute> | undefined;
        color?: Array<BufferAttribute | InterleavedBufferAttribute> | undefined;
    } | undefined;
    set morphTargetsRelative(value: boolean);
    get morphTargetsRelative(): boolean | undefined;
    set groups(value: GeometryGroup[]);
    get groups(): GeometryGroup[] | undefined;
    set boundingBox(value: Box3 | null | [min: Vector3$1, max: Vector3$1]);
    get boundingBox(): (Box3 | null) | undefined;
    set boundingSphere(value: Sphere | null | [center: Vector3$1, radius: number]);
    get boundingSphere(): (Sphere | null) | undefined;
    set drawRange(value: {
        start: number;
        count: number;
    });
    get drawRange(): {
        start: number;
        count: number;
    } | undefined;
    set userData(value: Record<string, any>);
    get userData(): Record<string, any> | undefined;
    get isBufferGeometry(): true | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThBufferGeometry<any, any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThBufferGeometry<any, any, any, any>, "th-bufferGeometry", never, { "id": { "alias": "id"; "required": false; }; "uuid": { "alias": "uuid"; "required": false; }; "name": { "alias": "name"; "required": false; }; "index": { "alias": "index"; "required": false; }; "indirect": { "alias": "indirect"; "required": false; }; "indirectOffset": { "alias": "indirectOffset"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "morphAttributes": { "alias": "morphAttributes"; "required": false; }; "morphTargetsRelative": { "alias": "morphTargetsRelative"; "required": false; }; "groups": { "alias": "groups"; "required": false; }; "boundingBox": { "alias": "boundingBox"; "required": false; }; "boundingSphere": { "alias": "boundingSphere"; "required": false; }; "drawRange": { "alias": "drawRange"; "required": false; }; "userData": { "alias": "userData"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThBoxGeometry<T extends BoxGeometry = BoxGeometry, TARGS = [
    width?: number,
    height?: number,
    depth?: number,
    widthSegments?: number,
    heightSegments?: number,
    depthSegments?: number
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<BoxGeometry>;
    get type(): (string | 'BoxGeometry') | undefined;
    get parameters(): {
        readonly width: number;
        readonly height: number;
        readonly depth: number;
        readonly widthSegments: number;
        readonly heightSegments: number;
        readonly depthSegments: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThBoxGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThBoxGeometry<any, any>, "th-boxGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThBoxHelper<T extends BoxHelper = BoxHelper, TARGS = [object: Object3D$1, color?: ColorRepresentation$1]> extends ThLineSegments<BufferGeometry, LineBasicMaterial, Object3DEventMap, T, TARGS> {
    getType(): Type<BoxHelper>;
    get type(): (string | 'BoxHelper') | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThBoxHelper<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThBoxHelper<any, any>, "th-boxHelper", never, {}, {}, never, ["*"], true, never>;
}

declare class ThBoxLineGeometry<T extends BoxLineGeometry = BoxLineGeometry, TARGS = [
    width?: number,
    height?: number,
    depth?: number,
    widthSegments?: number,
    heightSegments?: number,
    depthSegments?: number
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<BoxLineGeometry>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThBoxLineGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThBoxLineGeometry<any, any>, "th-boxLineGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThCameraHelper<T extends CameraHelper = CameraHelper, TARGS = Camera$1> extends ThLineSegments<BufferGeometry$1, Material$1 | Material$1[], Object3DEventMap, T, TARGS> {
    getType(): Type<CameraHelper>;
    get type(): (string | 'CameraHelper') | undefined;
    set camera(value: Camera$1);
    get camera(): Camera$1 | undefined;
    set pointMap(value: {
        [id: string]: number[];
    });
    get pointMap(): {
        [id: string]: number[];
    } | undefined;
    set matrix(value: Matrix4$1 | [
        n11: number,
        n12: number,
        n13: number,
        n14: number,
        n21: number,
        n22: number,
        n23: number,
        n24: number,
        n31: number,
        n32: number,
        n33: number,
        n34: number,
        n41: number,
        n42: number,
        n43: number,
        n44: number
    ]);
    get matrix(): Matrix4$1 | undefined;
    set matrixAutoUpdate(value: boolean);
    get matrixAutoUpdate(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCameraHelper<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCameraHelper<any, any>, "th-cameraHelper", never, { "camera": { "alias": "camera"; "required": false; }; "pointMap": { "alias": "pointMap"; "required": false; }; "matrix": { "alias": "matrix"; "required": false; }; "matrixAutoUpdate": { "alias": "matrixAutoUpdate"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThTextureBase<T extends Texture$1, ARGS> extends ThWrapperBase<T, ARGS> {
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTextureBase<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThTextureBase<any, any>, "th-abs-texture", never, {}, {}, never, never, true, never>;
}

declare class ThTexture<TImage = unknown, T extends Texture$1<TImage> = Texture$1<TImage>, TARGS = [
    image?: TImage,
    mapping?: Mapping,
    wrapS?: Wrapping,
    wrapT?: Wrapping,
    magFilter?: MagnificationTextureFilter,
    minFilter?: MinificationTextureFilter,
    format?: PixelFormat,
    type?: TextureDataType,
    anisotropy?: number,
    colorSpace?: ColorSpace
] | [
    image: TImage,
    mapping: Mapping,
    wrapS: Wrapping,
    wrapT: Wrapping,
    magFilter: MagnificationTextureFilter,
    minFilter: MinificationTextureFilter,
    format: PixelFormat,
    type: TextureDataType,
    anisotropy: number
]> extends ThTextureBase<T, TARGS> {
    getType(): Type<Texture$1<TImage>>;
    get isTexture(): true | undefined;
    get id(): number | undefined;
    set uuid(value: string);
    get uuid(): string | undefined;
    set name(value: string);
    get name(): string | undefined;
    set source(value: Source<TImage>);
    get source(): Source<TImage> | undefined;
    get width(): number | undefined;
    get height(): number | undefined;
    get depth(): number | undefined;
    get image(): TImage | undefined;
    set image(value: TImage);
    set mipmaps(value: CompressedTextureMipmap[] | CubeTexture[] | HTMLCanvasElement[]);
    get mipmaps(): (CompressedTextureMipmap[] | CubeTexture[] | HTMLCanvasElement[]) | undefined;
    set mapping(value: AnyMapping);
    get mapping(): AnyMapping | undefined;
    set channel(value: number);
    get channel(): number | undefined;
    set wrapS(value: Wrapping);
    get wrapS(): Wrapping | undefined;
    set wrapT(value: Wrapping);
    get wrapT(): Wrapping | undefined;
    set magFilter(value: MagnificationTextureFilter);
    get magFilter(): MagnificationTextureFilter | undefined;
    set minFilter(value: MinificationTextureFilter);
    get minFilter(): MinificationTextureFilter | undefined;
    set anisotropy(value: number);
    get anisotropy(): number | undefined;
    set format(value: AnyPixelFormat);
    get format(): AnyPixelFormat | undefined;
    set type(value: TextureDataType);
    get type(): TextureDataType | undefined;
    set internalFormat(value: PixelFormatGPU | null);
    get internalFormat(): (PixelFormatGPU | null) | undefined;
    set matrix(value: Matrix3$1 | [
        n11: number,
        n12: number,
        n13: number,
        n21: number,
        n22: number,
        n23: number,
        n31: number,
        n32: number,
        n33: number
    ]);
    get matrix(): Matrix3$1 | undefined;
    set matrixAutoUpdate(value: boolean);
    get matrixAutoUpdate(): boolean | undefined;
    set offset(value: Vector2$1 | [x: number, y: number]);
    get offset(): Vector2$1 | undefined;
    set repeat(value: Vector2$1 | [x: number, y: number]);
    get repeat(): Vector2$1 | undefined;
    set center(value: Vector2$1 | [x: number, y: number]);
    get center(): Vector2$1 | undefined;
    set rotation(value: number);
    get rotation(): number | undefined;
    set generateMipmaps(value: boolean);
    get generateMipmaps(): boolean | undefined;
    set premultiplyAlpha(value: boolean);
    get premultiplyAlpha(): boolean | undefined;
    set flipY(value: boolean);
    get flipY(): boolean | undefined;
    set unpackAlignment(value: number);
    get unpackAlignment(): number | undefined;
    set colorSpace(value: string);
    get colorSpace(): string | undefined;
    set isRenderTargetTexture(value: boolean);
    get isRenderTargetTexture(): boolean | undefined;
    set isArrayTexture(value: boolean);
    get isArrayTexture(): boolean | undefined;
    set userData(value: Record<string, any>);
    get userData(): Record<string, any> | undefined;
    set updateRanges(value: Array<{
        start: number;
        count: number;
    }>);
    get updateRanges(): Array<{
        start: number;
        count: number;
    }> | undefined;
    set version(value: number);
    get version(): number | undefined;
    set pmremVersion(value: number);
    get pmremVersion(): number | undefined;
    set needsUpdate(value: boolean);
    set needsPMREMUpdate(value: boolean);
    static readonly DEFAULT_ANISOTROPY: number;
    static readonly DEFAULT_IMAGE: null;
    static readonly DEFAULT_MAPPING: Mapping;
    set renderTarget(value: RenderTarget | null);
    get renderTarget(): (RenderTarget | null) | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTexture<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThTexture<any, any, any>, "th-texture", never, { "uuid": { "alias": "uuid"; "required": false; }; "name": { "alias": "name"; "required": false; }; "source": { "alias": "source"; "required": false; }; "image": { "alias": "image"; "required": false; }; "mipmaps": { "alias": "mipmaps"; "required": false; }; "mapping": { "alias": "mapping"; "required": false; }; "channel": { "alias": "channel"; "required": false; }; "wrapS": { "alias": "wrapS"; "required": false; }; "wrapT": { "alias": "wrapT"; "required": false; }; "magFilter": { "alias": "magFilter"; "required": false; }; "minFilter": { "alias": "minFilter"; "required": false; }; "anisotropy": { "alias": "anisotropy"; "required": false; }; "format": { "alias": "format"; "required": false; }; "type": { "alias": "type"; "required": false; }; "internalFormat": { "alias": "internalFormat"; "required": false; }; "matrix": { "alias": "matrix"; "required": false; }; "matrixAutoUpdate": { "alias": "matrixAutoUpdate"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "repeat": { "alias": "repeat"; "required": false; }; "center": { "alias": "center"; "required": false; }; "rotation": { "alias": "rotation"; "required": false; }; "generateMipmaps": { "alias": "generateMipmaps"; "required": false; }; "premultiplyAlpha": { "alias": "premultiplyAlpha"; "required": false; }; "flipY": { "alias": "flipY"; "required": false; }; "unpackAlignment": { "alias": "unpackAlignment"; "required": false; }; "colorSpace": { "alias": "colorSpace"; "required": false; }; "isRenderTargetTexture": { "alias": "isRenderTargetTexture"; "required": false; }; "isArrayTexture": { "alias": "isArrayTexture"; "required": false; }; "userData": { "alias": "userData"; "required": false; }; "updateRanges": { "alias": "updateRanges"; "required": false; }; "version": { "alias": "version"; "required": false; }; "pmremVersion": { "alias": "pmremVersion"; "required": false; }; "needsUpdate": { "alias": "needsUpdate"; "required": false; }; "needsPMREMUpdate": { "alias": "needsPMREMUpdate"; "required": false; }; "renderTarget": { "alias": "renderTarget"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThCanvasTexture<TCanvas = HTMLCanvasElement, T extends CanvasTexture<TCanvas> = CanvasTexture<TCanvas>, TARGS = [
    canvas?: TCanvas,
    mapping?: Mapping,
    wrapS?: Wrapping,
    wrapT?: Wrapping,
    magFilter?: MagnificationTextureFilter,
    minFilter?: MinificationTextureFilter,
    format?: PixelFormat,
    type?: TextureDataType,
    anisotropy?: number
]> extends ThTexture<TCanvas, T, TARGS> {
    getType(): Type<CanvasTexture<TCanvas>>;
    get isCanvasTexture(): true | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCanvasTexture<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCanvasTexture<any, any, any>, "th-canvasTexture", never, {}, {}, never, ["*"], true, never>;
}

declare class ThCapsuleGeometry<T extends CapsuleGeometry = CapsuleGeometry, TARGS = [
    radius?: number,
    height?: number,
    capSegments?: number,
    radialSegments?: number,
    heightSegments?: number
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<CapsuleGeometry>;
    get type(): (string | 'CapsuleGeometry') | undefined;
    get parameters(): {
        readonly radius: number;
        readonly height: number;
        readonly capSegments: number;
        readonly radialSegments: number;
        readonly heightSegments: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCapsuleGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCapsuleGeometry<any, any>, "th-capsuleGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThCircleGeometry<T extends CircleGeometry = CircleGeometry, TARGS = [
    radius?: number,
    segments?: number,
    thetaStart?: number,
    thetaLength?: number
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<CircleGeometry>;
    get type(): (string | 'CircleGeometry') | undefined;
    get parameters(): {
        readonly radius: number;
        readonly segments: number;
        readonly thetaStart: number;
        readonly thetaLength: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCircleGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCircleGeometry<any, any>, "th-circleGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThClearMaskPass<T extends ClearMaskPass = ClearMaskPass, TARGS = []> extends ThPass<T, TARGS> {
    getType(): Type<ClearMaskPass>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThClearMaskPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThClearMaskPass<any, any>, "th-clearMaskPass", never, {}, {}, never, ["*"], true, never>;
}

declare class ThClearPass<T extends ClearPass = ClearPass, TARGS = [clearColor?: ColorRepresentation, clearAlpha?: number]> extends ThPass<T, TARGS> {
    getType(): Type<ClearPass>;
    set clearColor(value: ColorRepresentation);
    get clearColor(): ColorRepresentation | undefined;
    set clearAlpha(value: number);
    get clearAlpha(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThClearPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThClearPass<any, any>, "th-clearPass", never, { "clearColor": { "alias": "clearColor"; "required": false; }; "clearAlpha": { "alias": "clearAlpha"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThCompressedTexture<TImageData = CompressedTextureImageData, T extends CompressedTexture<TImageData> = CompressedTexture<TImageData>, TARGS = [
    mipmaps: CompressedTextureMipmap$1[],
    width: number,
    height: number,
    format?: CompressedPixelFormat,
    type?: TextureDataType,
    mapping?: Mapping,
    wrapS?: Wrapping,
    wrapT?: Wrapping,
    magFilter?: MagnificationTextureFilter,
    minFilter?: MinificationTextureFilter,
    anisotropy?: number,
    colorSpace?: string
]> extends ThTexture<TImageData, T, TARGS> {
    getType(): Type<CompressedTexture<TImageData>>;
    get isCompressedTexture(): true | undefined;
    set mipmaps(value: CompressedTextureMipmap$1[]);
    get mipmaps(): CompressedTextureMipmap$1[] | undefined;
    set format(value: CompressedPixelFormat);
    get format(): CompressedPixelFormat | undefined;
    set flipY(value: boolean);
    get flipY(): boolean | undefined;
    set generateMipmaps(value: boolean);
    get generateMipmaps(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCompressedTexture<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCompressedTexture<any, any, any>, "th-compressedTexture", never, { "mipmaps": { "alias": "mipmaps"; "required": false; }; "format": { "alias": "format"; "required": false; }; "flipY": { "alias": "flipY"; "required": false; }; "generateMipmaps": { "alias": "generateMipmaps"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThCompressedArrayTexture<T extends CompressedArrayTexture = CompressedArrayTexture, TARGS = [
    mipmaps: CompressedTextureMipmap[],
    width: number,
    height: number,
    depth: number,
    format: CompressedPixelFormat,
    type?: TextureDataType
]> extends ThCompressedTexture<CompressedArrayTextureImageData, T, TARGS> {
    getType(): Type<CompressedArrayTexture>;
    get isCompressedArrayTexture(): true | undefined;
    set wrapR(value: Wrapping);
    get wrapR(): Wrapping | undefined;
    set layerUpdates(value: Set<number>);
    get layerUpdates(): Set<number> | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCompressedArrayTexture<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCompressedArrayTexture<any, any>, "th-compressedArrayTexture", never, { "wrapR": { "alias": "wrapR"; "required": false; }; "layerUpdates": { "alias": "layerUpdates"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThCompressedCubeTexture<T extends CompressedCubeTexture = CompressedCubeTexture, TARGS = [
    images: CompressedTextureImageData$1[],
    format?: CompressedPixelFormat,
    type?: TextureDataType
]> extends ThCompressedTexture<CompressedTextureImageData$1[], T, TARGS> {
    getType(): Type<CompressedCubeTexture>;
    get isCompressedCubeTexture(): true | undefined;
    get isCubeTexture(): true | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCompressedCubeTexture<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCompressedCubeTexture<any, any>, "th-compressedCubeTexture", never, {}, {}, never, ["*"], true, never>;
}

declare class ThCylinderGeometry<T extends CylinderGeometry = CylinderGeometry, TARGS = [
    radiusTop?: number,
    radiusBottom?: number,
    height?: number,
    radialSegments?: number,
    heightSegments?: number,
    openEnded?: boolean,
    thetaStart?: number,
    thetaLength?: number
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<CylinderGeometry>;
    get type(): (string | 'CylinderGeometry') | undefined;
    get parameters(): {
        readonly radiusTop: number;
        readonly radiusBottom: number;
        readonly height: number;
        readonly radialSegments: number;
        readonly heightSegments: number;
        readonly openEnded: boolean;
        readonly thetaStart: number;
        readonly thetaLength: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCylinderGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCylinderGeometry<any, any>, "th-cylinderGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThConeGeometry<T extends ConeGeometry = ConeGeometry, TARGS = [
    radius?: number,
    height?: number,
    radialSegments?: number,
    heightSegments?: number,
    openEnded?: boolean,
    thetaStart?: number,
    thetaLength?: number
]> extends ThCylinderGeometry<T, TARGS> {
    getType(): Type<ConeGeometry>;
    get type(): (string | 'ConeGeometry') | undefined;
    get parameters(): {
        readonly radius: number;
        readonly radiusTop: number;
        readonly radiusBottom: number;
        readonly height: number;
        readonly radialSegments: number;
        readonly heightSegments: number;
        readonly openEnded: boolean;
        readonly thetaStart: number;
        readonly thetaLength: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThConeGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThConeGeometry<any, any>, "th-coneGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThConvexGeometry<T extends ConvexGeometry = ConvexGeometry, TARGS = Vector3[]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<ConvexGeometry>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThConvexGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThConvexGeometry<any, any>, "th-convexGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThCubeCamera<T extends CubeCamera = CubeCamera, TARGS = [near: number, far: number, renderTarget: WebGLCubeRenderTarget]> extends ThObject3D<Object3DEventMap, T, TARGS> {
    getType(): Type<CubeCamera>;
    get type(): (string | 'CubeCamera') | undefined;
    set renderTarget(value: WebGLCubeRenderTarget);
    get renderTarget(): WebGLCubeRenderTarget | undefined;
    set coordinateSystem(value: CoordinateSystem);
    get coordinateSystem(): CoordinateSystem | undefined;
    set activeMipmapLevel(value: number);
    get activeMipmapLevel(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCubeCamera<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCubeCamera<any, any>, "th-cubeCamera", never, { "renderTarget": { "alias": "renderTarget"; "required": false; }; "coordinateSystem": { "alias": "coordinateSystem"; "required": false; }; "activeMipmapLevel": { "alias": "activeMipmapLevel"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThCubeTexture<TImage = unknown, T extends CubeTexture$1<TImage> = CubeTexture$1<TImage>, TARGS = [
    images?: TImage[],
    mapping?: CubeTextureMapping,
    wrapS?: Wrapping,
    wrapT?: Wrapping,
    magFilter?: MagnificationTextureFilter,
    minFilter?: MinificationTextureFilter,
    format?: PixelFormat,
    type?: TextureDataType,
    anisotropy?: number,
    colorSpace?: string
]> extends ThTexture<TImage[], T, TARGS> {
    getType(): Type<CubeTexture$1<TImage>>;
    get isCubeTexture(): true | undefined;
    get images(): TImage[] | undefined;
    set images(value: TImage[]);
    set mapping(value: CubeTextureMapping);
    get mapping(): CubeTextureMapping | undefined;
    set flipY(value: boolean);
    get flipY(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCubeTexture<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCubeTexture<any, any, any>, "th-cubeTexture", never, { "images": { "alias": "images"; "required": false; }; "mapping": { "alias": "mapping"; "required": false; }; "flipY": { "alias": "flipY"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThCubeTexturePass<T extends CubeTexturePass = CubeTexturePass, TARGS = [camera: PerspectiveCamera, envMap?: CubeTexture$1, opacity?: number]> extends ThPass<T, TARGS> {
    getType(): Type<CubeTexturePass>;
    set camera(value: PerspectiveCamera);
    get camera(): PerspectiveCamera | undefined;
    set cubeShader(value: object);
    get cubeShader(): object | undefined;
    set cubeMesh(value: Mesh$1);
    get cubeMesh(): Mesh$1 | undefined;
    set envMap(value: CubeTexture$1);
    get envMap(): CubeTexture$1 | undefined;
    set opacity(value: number);
    get opacity(): number | undefined;
    set cubeScene(value: Scene);
    get cubeScene(): Scene | undefined;
    set cubeCamera(value: PerspectiveCamera);
    get cubeCamera(): PerspectiveCamera | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCubeTexturePass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCubeTexturePass<any, any>, "th-cubeTexturePass", never, { "camera": { "alias": "camera"; "required": false; }; "cubeShader": { "alias": "cubeShader"; "required": false; }; "cubeMesh": { "alias": "cubeMesh"; "required": false; }; "envMap": { "alias": "envMap"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "cubeScene": { "alias": "cubeScene"; "required": false; }; "cubeCamera": { "alias": "cubeCamera"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThData3DTexture<T extends Data3DTexture = Data3DTexture, TARGS = [
    data?: TypedArray | null,
    width?: number,
    height?: number,
    depth?: number
]> extends ThTexture<Data3DTextureImageData, T, TARGS> {
    getType(): Type<Data3DTexture>;
    get isData3DTexture(): true | undefined;
    set magFilter(value: MagnificationTextureFilter);
    get magFilter(): MagnificationTextureFilter | undefined;
    set minFilter(value: MinificationTextureFilter);
    get minFilter(): MinificationTextureFilter | undefined;
    set wrapR(value: Wrapping);
    get wrapR(): Wrapping | undefined;
    set flipY(value: boolean);
    get flipY(): boolean | undefined;
    set generateMipmaps(value: boolean);
    get generateMipmaps(): boolean | undefined;
    set unpackAlignment(value: number);
    get unpackAlignment(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThData3DTexture<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThData3DTexture<any, any>, "th-data3DTexture", never, { "magFilter": { "alias": "magFilter"; "required": false; }; "minFilter": { "alias": "minFilter"; "required": false; }; "wrapR": { "alias": "wrapR"; "required": false; }; "flipY": { "alias": "flipY"; "required": false; }; "generateMipmaps": { "alias": "generateMipmaps"; "required": false; }; "unpackAlignment": { "alias": "unpackAlignment"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThDataArrayTexture<T extends DataArrayTexture = DataArrayTexture, TARGS = [
    data?: TypedArray | null,
    width?: number,
    height?: number,
    depth?: number
]> extends ThTexture<DataArrayTextureImageData, T, TARGS> {
    getType(): Type<DataArrayTexture>;
    get isDataArrayTexture(): true | undefined;
    set magFilter(value: MagnificationTextureFilter);
    get magFilter(): MagnificationTextureFilter | undefined;
    set minFilter(value: MinificationTextureFilter);
    get minFilter(): MinificationTextureFilter | undefined;
    set wrapR(value: boolean);
    get wrapR(): boolean | undefined;
    set generateMipmaps(value: boolean);
    get generateMipmaps(): boolean | undefined;
    set flipY(value: boolean);
    get flipY(): boolean | undefined;
    set unpackAlignment(value: number);
    get unpackAlignment(): number | undefined;
    set layerUpdates(value: Set<number>);
    get layerUpdates(): Set<number> | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThDataArrayTexture<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThDataArrayTexture<any, any>, "th-dataArrayTexture", never, { "magFilter": { "alias": "magFilter"; "required": false; }; "minFilter": { "alias": "minFilter"; "required": false; }; "wrapR": { "alias": "wrapR"; "required": false; }; "generateMipmaps": { "alias": "generateMipmaps"; "required": false; }; "flipY": { "alias": "flipY"; "required": false; }; "unpackAlignment": { "alias": "unpackAlignment"; "required": false; }; "layerUpdates": { "alias": "layerUpdates"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThDataTexture<T extends DataTexture = DataTexture, TARGS = [
    data?: TypedArray | null,
    width?: number,
    height?: number,
    format?: PixelFormat,
    type?: TextureDataType,
    mapping?: Mapping,
    wrapS?: Wrapping,
    wrapT?: Wrapping,
    magFilter?: MagnificationTextureFilter,
    minFilter?: MinificationTextureFilter,
    anisotropy?: number,
    colorSpace?: string
]> extends ThTexture<DataTextureImageData, T, TARGS> {
    getType(): Type<DataTexture>;
    get isDataTexture(): true | undefined;
    set magFilter(value: MagnificationTextureFilter);
    get magFilter(): MagnificationTextureFilter | undefined;
    set minFilter(value: MinificationTextureFilter);
    get minFilter(): MinificationTextureFilter | undefined;
    set flipY(value: boolean);
    get flipY(): boolean | undefined;
    set generateMipmaps(value: boolean);
    get generateMipmaps(): boolean | undefined;
    set unpackAlignment(value: number);
    get unpackAlignment(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThDataTexture<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThDataTexture<any, any>, "th-dataTexture", never, { "magFilter": { "alias": "magFilter"; "required": false; }; "minFilter": { "alias": "minFilter"; "required": false; }; "flipY": { "alias": "flipY"; "required": false; }; "generateMipmaps": { "alias": "generateMipmaps"; "required": false; }; "unpackAlignment": { "alias": "unpackAlignment"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThDecalGeometry<T extends DecalGeometry = DecalGeometry, TARGS = [
    mesh?: Mesh$1,
    position?: Vector3,
    orientation?: Euler$1,
    size?: Vector3
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<DecalGeometry>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThDecalGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThDecalGeometry<any, any>, "th-decalGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThDepthTexture<T extends DepthTexture = DepthTexture, TARGS = [
    width: number,
    height: number,
    type?: TextureDataType,
    mapping?: Mapping,
    wrapS?: Wrapping,
    wrapT?: Wrapping,
    magFilter?: MagnificationTextureFilter,
    minFilter?: MinificationTextureFilter,
    anisotropy?: number,
    format?: DepthTexturePixelFormat,
    depth?: number
]> extends ThTexture<DepthTextureImageData, T, TARGS> {
    getType(): Type<DepthTexture>;
    get isDepthTexture(): true | undefined;
    set flipY(value: boolean);
    get flipY(): boolean | undefined;
    set magFilter(value: MagnificationTextureFilter);
    get magFilter(): MagnificationTextureFilter | undefined;
    set minFilter(value: MinificationTextureFilter);
    get minFilter(): MinificationTextureFilter | undefined;
    set generateMipmaps(value: boolean);
    get generateMipmaps(): boolean | undefined;
    set format(value: DepthTexturePixelFormat);
    get format(): DepthTexturePixelFormat | undefined;
    set type(value: TextureDataType);
    get type(): TextureDataType | undefined;
    set compareFunction(value: TextureComparisonFunction | null);
    get compareFunction(): (TextureComparisonFunction | null) | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThDepthTexture<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThDepthTexture<any, any>, "th-depthTexture", never, { "flipY": { "alias": "flipY"; "required": false; }; "magFilter": { "alias": "magFilter"; "required": false; }; "minFilter": { "alias": "minFilter"; "required": false; }; "generateMipmaps": { "alias": "generateMipmaps"; "required": false; }; "format": { "alias": "format"; "required": false; }; "type": { "alias": "type"; "required": false; }; "compareFunction": { "alias": "compareFunction"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThDirectionalLight<T extends DirectionalLight = DirectionalLight, TARGS = [color?: ColorRepresentation$1, intensity?: number]> extends ThLight<DirectionalLightShadow, T, TARGS> {
    getType(): Type<DirectionalLight>;
    get isDirectionalLight(): true | undefined;
    get type(): (string | 'DirectionalLight') | undefined;
    set castShadow(value: boolean);
    get castShadow(): boolean | undefined;
    set position(value: Vector3 | [x: number, y: number, z: number]);
    get position(): Vector3 | undefined;
    set shadow(value: DirectionalLightShadow);
    get shadow(): DirectionalLightShadow | undefined;
    set target(value: Object3D$1);
    get target(): Object3D$1 | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThDirectionalLight<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThDirectionalLight<any, any>, "th-directionalLight", never, { "castShadow": { "alias": "castShadow"; "required": false; }; "position": { "alias": "position"; "required": false; }; "shadow": { "alias": "shadow"; "required": false; }; "target": { "alias": "target"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThDirectionalLightHelper<T extends DirectionalLightHelper = DirectionalLightHelper, TARGS = [light: DirectionalLight$1, size?: number, color?: ColorRepresentation$1]> extends ThObject3D<Object3DEventMap, T, TARGS> {
    getType(): Type<DirectionalLightHelper>;
    get type(): (string | 'DirectionalLightHelper') | undefined;
    set lightPlane(value: Line);
    get lightPlane(): Line | undefined;
    set light(value: DirectionalLight$1);
    get light(): DirectionalLight$1 | undefined;
    set matrix(value: Matrix4$1 | [
        n11: number,
        n12: number,
        n13: number,
        n14: number,
        n21: number,
        n22: number,
        n23: number,
        n24: number,
        n31: number,
        n32: number,
        n33: number,
        n34: number,
        n41: number,
        n42: number,
        n43: number,
        n44: number
    ]);
    get matrix(): Matrix4$1 | undefined;
    set matrixAutoUpdate(value: boolean);
    get matrixAutoUpdate(): boolean | undefined;
    set color(value: ColorRepresentation$1 | undefined);
    get color(): (ColorRepresentation$1 | undefined) | undefined;
    set targetLine(value: Line);
    get targetLine(): Line | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThDirectionalLightHelper<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThDirectionalLightHelper<any, any>, "th-directionalLightHelper", never, { "lightPlane": { "alias": "lightPlane"; "required": false; }; "light": { "alias": "light"; "required": false; }; "matrix": { "alias": "matrix"; "required": false; }; "matrixAutoUpdate": { "alias": "matrixAutoUpdate"; "required": false; }; "color": { "alias": "color"; "required": false; }; "targetLine": { "alias": "targetLine"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThPolyhedronGeometry<T extends PolyhedronGeometry = PolyhedronGeometry, TARGS = [
    vertices?: number[],
    indices?: number[],
    radius?: number,
    detail?: number
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<PolyhedronGeometry>;
    get type(): (string | 'PolyhedronGeometry') | undefined;
    get parameters(): {
        readonly vertices: number[];
        readonly indices: number[];
        readonly radius: number;
        readonly detail: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPolyhedronGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThPolyhedronGeometry<any, any>, "th-polyhedronGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThDodecahedronGeometry<T extends DodecahedronGeometry = DodecahedronGeometry, TARGS = [radius?: number, detail?: number]> extends ThPolyhedronGeometry<T, TARGS> {
    getType(): Type<DodecahedronGeometry>;
    get type(): (string | 'DodecahedronGeometry') | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThDodecahedronGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThDodecahedronGeometry<any, any>, "th-dodecahedronGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThDotScreenPass<T extends DotScreenPass = DotScreenPass, TARGS = [center?: Vector2, angle?: number, scale?: number]> extends ThPass<T, TARGS> {
    getType(): Type<DotScreenPass>;
    set uniforms(map: {
        [name: string]: {
            value: any;
        };
    });
    get uniforms(): {
        [name: string]: {
            value: any;
        };
    } | undefined;
    set material(value: ShaderMaterial);
    get material(): ShaderMaterial | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThDotScreenPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThDotScreenPass<any, any>, "th-dotScreenPass", never, { "uniforms": { "alias": "uniforms"; "required": false; }; "material": { "alias": "material"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThDragControls<T extends DragControls = DragControls, TARGS = [
    objects: Object3D$1[],
    camera: Camera$1,
    domElement?: HTMLElement | SVGElement | null
]> extends ThControlBase<DragControlsEventMap, T, TARGS> {
    getType(): Type<DragControls>;
    set objects(value: Object3D$1[]);
    get objects(): Object3D$1[] | undefined;
    set recursive(value: boolean);
    get recursive(): boolean | undefined;
    set transformGroup(value: boolean);
    get transformGroup(): boolean | undefined;
    set rotateSpeed(value: number);
    get rotateSpeed(): number | undefined;
    set raycaster(value: Raycaster | [origin: Vector3$1, direction: Vector3$1]);
    get raycaster(): Raycaster | undefined;
    set mouseButtons(value: {
        LEFT?: MOUSE | null | undefined;
        MIDDLE?: MOUSE | null | undefined;
        RIGHT?: MOUSE | null | undefined;
    });
    get mouseButtons(): {
        LEFT?: MOUSE | null | undefined;
        MIDDLE?: MOUSE | null | undefined;
        RIGHT?: MOUSE | null | undefined;
    } | undefined;
    set touches(value: {
        ONE?: TOUCH | null | undefined;
    });
    get touches(): {
        ONE?: TOUCH | null | undefined;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThDragControls<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThDragControls<any, any>, "th-dragControls", never, { "objects": { "alias": "objects"; "required": false; }; "recursive": { "alias": "recursive"; "required": false; }; "transformGroup": { "alias": "transformGroup"; "required": false; }; "rotateSpeed": { "alias": "rotateSpeed"; "required": false; }; "raycaster": { "alias": "raycaster"; "required": false; }; "mouseButtons": { "alias": "mouseButtons"; "required": false; }; "touches": { "alias": "touches"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThEdgesGeometry<TBufferGeometry extends BufferGeometry = BufferGeometry, T extends EdgesGeometry<TBufferGeometry> = EdgesGeometry<TBufferGeometry>, TARGS = [geometry?: TBufferGeometry | null, thresholdAngle?: number]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<EdgesGeometry<TBufferGeometry>>;
    get type(): (string | 'EdgesGeometry') | undefined;
    get parameters(): {
        readonly geometry: TBufferGeometry | null;
        readonly thresholdAngle: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThEdgesGeometry<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThEdgesGeometry<any, any, any>, "th-edgesGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThExternalTexture<T extends ExternalTexture = ExternalTexture, TARGS = /* sourceTexture? */ WebGLTexture | GPUTexture | null> extends ThTexture<null, T, TARGS> {
    getType(): Type<ExternalTexture>;
    set sourceTexture(value: WebGLTexture | GPUTexture | null);
    get sourceTexture(): (WebGLTexture | GPUTexture | null) | undefined;
    get isExternalTexture(): true | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThExternalTexture<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThExternalTexture<any, any>, "th-externalTexture", never, { "sourceTexture": { "alias": "sourceTexture"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThExtrudeGeometry<T extends ExtrudeGeometry = ExtrudeGeometry, TARGS = [shapes?: Shape | Shape[], options?: ExtrudeGeometryOptions]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<ExtrudeGeometry>;
    get type(): (string | 'ExtrudeGeometry') | undefined;
    get parameters(): {
        readonly shapes: Shape | Shape[];
        readonly options: ExtrudeGeometryOptions;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThExtrudeGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThExtrudeGeometry<any, any>, "th-extrudeGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThFilmPass<T extends FilmPass = FilmPass, TARGS = [intensity?: number, grayscale?: boolean]> extends ThPass<T, TARGS> {
    getType(): Type<FilmPass>;
    set uniforms(map: {
        [name: string]: {
            value: any;
        };
    });
    get uniforms(): {
        [name: string]: {
            value: any;
        };
    } | undefined;
    set material(value: ShaderMaterial);
    get material(): ShaderMaterial | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThFilmPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThFilmPass<any, any>, "th-filmPass", never, { "uniforms": { "alias": "uniforms"; "required": false; }; "material": { "alias": "material"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThFirstPersonControls<T extends FirstPersonControls = FirstPersonControls, TARGS = [object: Camera, domElement?: HTMLElement | SVGElement]> extends ThControlBase<{}, T, TARGS> {
    getType(): Type<FirstPersonControls>;
    set movementSpeed(value: number);
    get movementSpeed(): number | undefined;
    set lookSpeed(value: number);
    get lookSpeed(): number | undefined;
    set lookVertical(value: boolean);
    get lookVertical(): boolean | undefined;
    set autoForward(value: boolean);
    get autoForward(): boolean | undefined;
    set activeLook(value: boolean);
    get activeLook(): boolean | undefined;
    set heightSpeed(value: boolean);
    get heightSpeed(): boolean | undefined;
    set heightCoef(value: number);
    get heightCoef(): number | undefined;
    set heightMin(value: number);
    get heightMin(): number | undefined;
    set heightMax(value: number);
    get heightMax(): number | undefined;
    set constrainVertical(value: boolean);
    get constrainVertical(): boolean | undefined;
    set verticalMin(value: number);
    get verticalMin(): number | undefined;
    set verticalMax(value: number);
    get verticalMax(): number | undefined;
    set mouseDragOn(value: boolean);
    get mouseDragOn(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThFirstPersonControls<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThFirstPersonControls<any, any>, "th-firstPersonControls", never, { "movementSpeed": { "alias": "movementSpeed"; "required": false; }; "lookSpeed": { "alias": "lookSpeed"; "required": false; }; "lookVertical": { "alias": "lookVertical"; "required": false; }; "autoForward": { "alias": "autoForward"; "required": false; }; "activeLook": { "alias": "activeLook"; "required": false; }; "heightSpeed": { "alias": "heightSpeed"; "required": false; }; "heightCoef": { "alias": "heightCoef"; "required": false; }; "heightMin": { "alias": "heightMin"; "required": false; }; "heightMax": { "alias": "heightMax"; "required": false; }; "constrainVertical": { "alias": "constrainVertical"; "required": false; }; "verticalMin": { "alias": "verticalMin"; "required": false; }; "verticalMax": { "alias": "verticalMax"; "required": false; }; "mouseDragOn": { "alias": "mouseDragOn"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThFlyControls<T extends FlyControls = FlyControls, TARGS = [object: Camera, domElement?: HTMLElement | SVGElement | null]> extends ThControlBase<FlyControlsEventMap, T, TARGS> {
    getType(): Type<FlyControls>;
    set movementSpeed(value: number);
    get movementSpeed(): number | undefined;
    set rollSpeed(value: number);
    get rollSpeed(): number | undefined;
    set dragToLook(value: boolean);
    get dragToLook(): boolean | undefined;
    set autoForward(value: boolean);
    get autoForward(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThFlyControls<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThFlyControls<any, any>, "th-flyControls", never, { "movementSpeed": { "alias": "movementSpeed"; "required": false; }; "rollSpeed": { "alias": "rollSpeed"; "required": false; }; "dragToLook": { "alias": "dragToLook"; "required": false; }; "autoForward": { "alias": "autoForward"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThFramebufferTexture<T extends FramebufferTexture = FramebufferTexture, TARGS = [width: number, height: number]> extends ThTexture<FramebufferTextureImageData, T, TARGS> {
    getType(): Type<FramebufferTexture>;
    get isFramebufferTexture(): true | undefined;
    set magFilter(value: MagnificationTextureFilter);
    get magFilter(): MagnificationTextureFilter | undefined;
    set minFilter(value: MinificationTextureFilter);
    get minFilter(): MinificationTextureFilter | undefined;
    set generateMipmaps(value: boolean);
    get generateMipmaps(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThFramebufferTexture<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThFramebufferTexture<any, any>, "th-framebufferTexture", never, { "magFilter": { "alias": "magFilter"; "required": false; }; "minFilter": { "alias": "minFilter"; "required": false; }; "generateMipmaps": { "alias": "generateMipmaps"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThGlitchPass<T extends GlitchPass = GlitchPass, TARGS = number> extends ThPass<T, TARGS> {
    getType(): Type<GlitchPass>;
    set uniforms(map: {
        [name: string]: {
            value: any;
        };
    });
    get uniforms(): {
        [name: string]: {
            value: any;
        };
    } | undefined;
    set material(value: ShaderMaterial);
    get material(): ShaderMaterial | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    set goWild(value: boolean);
    get goWild(): boolean | undefined;
    set curF(value: number);
    get curF(): number | undefined;
    set randX(value: number);
    get randX(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThGlitchPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThGlitchPass<any, any>, "th-glitchPass", never, { "uniforms": { "alias": "uniforms"; "required": false; }; "material": { "alias": "material"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; "goWild": { "alias": "goWild"; "required": false; }; "curF": { "alias": "curF"; "required": false; }; "randX": { "alias": "randX"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThGridHelper<T extends GridHelper = GridHelper, TARGS = [
    size?: number,
    divisions?: number,
    color1?: ColorRepresentation$1,
    color2?: ColorRepresentation$1
]> extends ThLineSegments<BufferGeometry, LineBasicMaterial, Object3DEventMap, T, TARGS> {
    getType(): Type<GridHelper>;
    get type(): (string | 'GridHelper') | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThGridHelper<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThGridHelper<any, any>, "th-gridHelper", never, {}, {}, never, ["*"], true, never>;
}

declare class ThGroup<TEventMap extends Object3DEventMap$1 = Object3DEventMap$1, T extends Group<TEventMap> = Group<TEventMap>, TARGS = []> extends ThObject3D<TEventMap, T, TARGS> {
    getType(): Type<Group<TEventMap>>;
    get isGroup(): true | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThGroup<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThGroup<any, any, any>, "th-group", never, {}, {}, never, ["*"], true, never>;
}

declare class ThHalftonePass<T extends HalftonePass = HalftonePass, TARGS = HalftonePassParameters> extends ThPass<T, TARGS> {
    getType(): Type<HalftonePass>;
    set uniforms(map: {
        [name: string]: {
            value: any;
        };
    });
    get uniforms(): {
        [name: string]: {
            value: any;
        };
    } | undefined;
    set material(value: ShaderMaterial);
    get material(): ShaderMaterial | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThHalftonePass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThHalftonePass<any, any>, "th-halftonePass", never, { "uniforms": { "alias": "uniforms"; "required": false; }; "material": { "alias": "material"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThHemisphereLight<T extends HemisphereLight = HemisphereLight, TARGS = [
    skyColor?: ColorRepresentation,
    groundColor?: ColorRepresentation,
    intensity?: number
]> extends ThLight<undefined, T, TARGS> {
    getType(): Type<HemisphereLight>;
    get isHemisphereLight(): true | undefined;
    get type(): (string | 'HemisphereLight') | undefined;
    set position(value: Vector3 | [x: number, y: number, z: number]);
    get position(): Vector3 | undefined;
    set color(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get color(): Color | undefined;
    set groundColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get groundColor(): Color | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThHemisphereLight<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThHemisphereLight<any, any>, "th-hemisphereLight", never, { "position": { "alias": "position"; "required": false; }; "color": { "alias": "color"; "required": false; }; "groundColor": { "alias": "groundColor"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThHemisphereLightHelper<T extends HemisphereLightHelper = HemisphereLightHelper, TARGS = [light: HemisphereLight$1, size: number, color?: ColorRepresentation$1]> extends ThObject3D<Object3DEventMap, T, TARGS> {
    getType(): Type<HemisphereLightHelper>;
    get type(): (string | 'HemisphereLightHelper') | undefined;
    set light(value: HemisphereLight$1);
    get light(): HemisphereLight$1 | undefined;
    set matrix(value: Matrix4$1 | [
        n11: number,
        n12: number,
        n13: number,
        n14: number,
        n21: number,
        n22: number,
        n23: number,
        n24: number,
        n31: number,
        n32: number,
        n33: number,
        n34: number,
        n41: number,
        n42: number,
        n43: number,
        n44: number
    ]);
    get matrix(): Matrix4$1 | undefined;
    set matrixAutoUpdate(value: boolean);
    get matrixAutoUpdate(): boolean | undefined;
    set material(value: MeshBasicMaterial);
    get material(): MeshBasicMaterial | undefined;
    set color(value: ColorRepresentation$1 | undefined);
    get color(): (ColorRepresentation$1 | undefined) | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThHemisphereLightHelper<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThHemisphereLightHelper<any, any>, "th-hemisphereLightHelper", never, { "light": { "alias": "light"; "required": false; }; "matrix": { "alias": "matrix"; "required": false; }; "matrixAutoUpdate": { "alias": "matrixAutoUpdate"; "required": false; }; "material": { "alias": "material"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThIcosahedronGeometry<T extends IcosahedronGeometry = IcosahedronGeometry, TARGS = [radius?: number, detail?: number]> extends ThPolyhedronGeometry<T, TARGS> {
    getType(): Type<IcosahedronGeometry>;
    get type(): (string | 'IcosahedronGeometry') | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThIcosahedronGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThIcosahedronGeometry<any, any>, "th-icosahedronGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThInstancedBufferGeometry<T extends InstancedBufferGeometry = InstancedBufferGeometry, TARGS = []> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<InstancedBufferGeometry>;
    set type(value: string);
    get type(): string | undefined;
    get isInstancedBufferGeometry(): true | undefined;
    set instanceCount(value: number);
    get instanceCount(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThInstancedBufferGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThInstancedBufferGeometry<any, any>, "th-instancedBufferGeometry", never, { "type": { "alias": "type"; "required": false; }; "instanceCount": { "alias": "instanceCount"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThInstancedMesh<TGeometry extends BufferGeometry = BufferGeometry, TMaterial extends Material | Material[] = Material | Material[], TEventMap extends InstancedMeshEventMap = InstancedMeshEventMap, T extends InstancedMesh<TGeometry, TMaterial, TEventMap> = InstancedMesh<TGeometry, TMaterial, TEventMap>, TARGS = [
    geometry: TGeometry | undefined,
    material: TMaterial | undefined,
    count: number
]> extends ThMesh<TGeometry, TMaterial, TEventMap, T, TARGS> {
    getType(): Type<InstancedMesh<TGeometry, TMaterial, TEventMap>>;
    get isInstancedMesh(): true | undefined;
    set boundingBox(value: Box3 | null | [min: Vector3$1, max: Vector3$1]);
    get boundingBox(): (Box3 | null) | undefined;
    set boundingSphere(value: Sphere | null | [center: Vector3$1, radius: number]);
    get boundingSphere(): (Sphere | null) | undefined;
    set count(value: number);
    get count(): number | undefined;
    set instanceColor(value: InstancedBufferAttribute | null | [value: ArrayLike<number> | ArrayBufferView, offset?: number]);
    get instanceColor(): (InstancedBufferAttribute | null) | undefined;
    set instanceMatrix(value: InstancedBufferAttribute | [value: ArrayLike<number> | ArrayBufferView, offset?: number]);
    get instanceMatrix(): InstancedBufferAttribute | undefined;
    set morphTexture(value: DataTexture$1 | null);
    get morphTexture(): (DataTexture$1 | null) | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThInstancedMesh<any, any, any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThInstancedMesh<any, any, any, any, any>, "th-instancedMesh", never, { "boundingBox": { "alias": "boundingBox"; "required": false; }; "boundingSphere": { "alias": "boundingSphere"; "required": false; }; "count": { "alias": "count"; "required": false; }; "instanceColor": { "alias": "instanceColor"; "required": false; }; "instanceMatrix": { "alias": "instanceMatrix"; "required": false; }; "morphTexture": { "alias": "morphTexture"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThLatheGeometry<T extends LatheGeometry = LatheGeometry, TARGS = [
    points?: Vector2$1[],
    segments?: number,
    phiStart?: number,
    phiLength?: number
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<LatheGeometry>;
    get type(): (string | 'LatheGeometry') | undefined;
    get parameters(): {
        readonly points: Vector2$1[];
        readonly segments: number;
        readonly phiStart: number;
        readonly phiLength: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThLatheGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThLatheGeometry<any, any>, "th-latheGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThLightProbe<T extends LightProbe = LightProbe, TARGS = [sh?: SphericalHarmonics3, intensity?: number]> extends ThLight<LightShadow$1 | undefined, T, TARGS> {
    getType(): Type<LightProbe>;
    get isLightProbe(): true | undefined;
    set sh(value: SphericalHarmonics3 | [coefficients: Vector3$1[]]);
    get sh(): SphericalHarmonics3 | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThLightProbe<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThLightProbe<any, any>, "th-lightProbe", never, { "sh": { "alias": "sh"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThMaterialBase<T extends Material$1, ARGS> extends ThWrapperBase<T, ARGS> {
    protected parent: ThObject3D<any, three.Object3D<any>, []>;
    addToParent(): void;
    removeFromParent(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMaterialBase<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMaterialBase<any, any>, "th-abs-material", never, {}, {}, never, never, true, never>;
}

declare class ThMaterial<T extends Material$1 = Material$1, TARGS = []> extends ThMaterialBase<T, TARGS> {
    parent: ThObject3D<three.Object3DEventMap, three.Object3D<three.Object3DEventMap>, []>;
    getType(): Type<Material$1>;
    get isMaterial(): boolean | undefined;
    get uuid(): string | undefined;
    set type(value: string);
    get type(): string | undefined;
    get version(): number | undefined;
    set defines(value: Record<string, unknown> | undefined);
    get defines(): (Record<string, unknown> | undefined) | undefined;
    set needsUpdate(value: boolean);
    set name(value: string);
    get name(): string | undefined;
    set blending(value: Blending);
    get blending(): Blending | undefined;
    set side(value: Side);
    get side(): Side | undefined;
    set vertexColors(value: boolean);
    get vertexColors(): boolean | undefined;
    set opacity(value: number);
    get opacity(): number | undefined;
    set transparent(value: boolean);
    get transparent(): boolean | undefined;
    set alphaHash(value: boolean);
    get alphaHash(): boolean | undefined;
    set blendSrc(value: BlendingSrcFactor);
    get blendSrc(): BlendingSrcFactor | undefined;
    set blendDst(value: BlendingDstFactor);
    get blendDst(): BlendingDstFactor | undefined;
    set blendEquation(value: BlendingEquation);
    get blendEquation(): BlendingEquation | undefined;
    set blendSrcAlpha(value: BlendingSrcFactor | null);
    get blendSrcAlpha(): (BlendingSrcFactor | null) | undefined;
    set blendDstAlpha(value: BlendingDstFactor | null);
    get blendDstAlpha(): (BlendingDstFactor | null) | undefined;
    set blendEquationAlpha(value: BlendingEquation | null);
    get blendEquationAlpha(): (BlendingEquation | null) | undefined;
    set blendColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get blendColor(): Color | undefined;
    set blendAlpha(value: number);
    get blendAlpha(): number | undefined;
    set depthFunc(value: DepthModes);
    get depthFunc(): DepthModes | undefined;
    set depthTest(value: boolean);
    get depthTest(): boolean | undefined;
    set depthWrite(value: boolean);
    get depthWrite(): boolean | undefined;
    set stencilWriteMask(value: number);
    get stencilWriteMask(): number | undefined;
    set stencilFunc(value: StencilFunc);
    get stencilFunc(): StencilFunc | undefined;
    set stencilRef(value: number);
    get stencilRef(): number | undefined;
    set stencilFuncMask(value: number);
    get stencilFuncMask(): number | undefined;
    set stencilFail(value: StencilOp);
    get stencilFail(): StencilOp | undefined;
    set stencilZFail(value: StencilOp);
    get stencilZFail(): StencilOp | undefined;
    set stencilZPass(value: StencilOp);
    get stencilZPass(): StencilOp | undefined;
    set stencilWrite(value: boolean);
    get stencilWrite(): boolean | undefined;
    set clippingPlanes(value: Array<Plane> | null);
    get clippingPlanes(): (Array<Plane> | null) | undefined;
    set clipIntersection(value: boolean);
    get clipIntersection(): boolean | undefined;
    set clipShadows(value: boolean);
    get clipShadows(): boolean | undefined;
    set shadowSide(value: Side | null);
    get shadowSide(): (Side | null) | undefined;
    set colorWrite(value: boolean);
    get colorWrite(): boolean | undefined;
    set precision(value: ('highp' | 'mediump' | 'lowp') | null);
    get precision(): (('highp' | 'mediump' | 'lowp') | null) | undefined;
    set polygonOffset(value: boolean);
    get polygonOffset(): boolean | undefined;
    set polygonOffsetFactor(value: number);
    get polygonOffsetFactor(): number | undefined;
    set polygonOffsetUnits(value: number);
    get polygonOffsetUnits(): number | undefined;
    set dithering(value: boolean);
    get dithering(): boolean | undefined;
    set alphaToCoverage(value: boolean);
    get alphaToCoverage(): boolean | undefined;
    set premultipliedAlpha(value: boolean);
    get premultipliedAlpha(): boolean | undefined;
    set forceSinglePass(value: boolean);
    get forceSinglePass(): boolean | undefined;
    set allowOverride(value: boolean);
    get allowOverride(): boolean | undefined;
    set visible(value: boolean);
    get visible(): boolean | undefined;
    set toneMapped(value: boolean);
    get toneMapped(): boolean | undefined;
    set userData(value: Record<string, any>);
    get userData(): Record<string, any> | undefined;
    set alphaTest(value: number);
    get alphaTest(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMaterial<any, any>, "th-material", never, { "type": { "alias": "type"; "required": false; }; "defines": { "alias": "defines"; "required": false; }; "needsUpdate": { "alias": "needsUpdate"; "required": false; }; "name": { "alias": "name"; "required": false; }; "blending": { "alias": "blending"; "required": false; }; "side": { "alias": "side"; "required": false; }; "vertexColors": { "alias": "vertexColors"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "transparent": { "alias": "transparent"; "required": false; }; "alphaHash": { "alias": "alphaHash"; "required": false; }; "blendSrc": { "alias": "blendSrc"; "required": false; }; "blendDst": { "alias": "blendDst"; "required": false; }; "blendEquation": { "alias": "blendEquation"; "required": false; }; "blendSrcAlpha": { "alias": "blendSrcAlpha"; "required": false; }; "blendDstAlpha": { "alias": "blendDstAlpha"; "required": false; }; "blendEquationAlpha": { "alias": "blendEquationAlpha"; "required": false; }; "blendColor": { "alias": "blendColor"; "required": false; }; "blendAlpha": { "alias": "blendAlpha"; "required": false; }; "depthFunc": { "alias": "depthFunc"; "required": false; }; "depthTest": { "alias": "depthTest"; "required": false; }; "depthWrite": { "alias": "depthWrite"; "required": false; }; "stencilWriteMask": { "alias": "stencilWriteMask"; "required": false; }; "stencilFunc": { "alias": "stencilFunc"; "required": false; }; "stencilRef": { "alias": "stencilRef"; "required": false; }; "stencilFuncMask": { "alias": "stencilFuncMask"; "required": false; }; "stencilFail": { "alias": "stencilFail"; "required": false; }; "stencilZFail": { "alias": "stencilZFail"; "required": false; }; "stencilZPass": { "alias": "stencilZPass"; "required": false; }; "stencilWrite": { "alias": "stencilWrite"; "required": false; }; "clippingPlanes": { "alias": "clippingPlanes"; "required": false; }; "clipIntersection": { "alias": "clipIntersection"; "required": false; }; "clipShadows": { "alias": "clipShadows"; "required": false; }; "shadowSide": { "alias": "shadowSide"; "required": false; }; "colorWrite": { "alias": "colorWrite"; "required": false; }; "precision": { "alias": "precision"; "required": false; }; "polygonOffset": { "alias": "polygonOffset"; "required": false; }; "polygonOffsetFactor": { "alias": "polygonOffsetFactor"; "required": false; }; "polygonOffsetUnits": { "alias": "polygonOffsetUnits"; "required": false; }; "dithering": { "alias": "dithering"; "required": false; }; "alphaToCoverage": { "alias": "alphaToCoverage"; "required": false; }; "premultipliedAlpha": { "alias": "premultipliedAlpha"; "required": false; }; "forceSinglePass": { "alias": "forceSinglePass"; "required": false; }; "allowOverride": { "alias": "allowOverride"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "toneMapped": { "alias": "toneMapped"; "required": false; }; "userData": { "alias": "userData"; "required": false; }; "alphaTest": { "alias": "alphaTest"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThLineBasicMaterial<T extends LineBasicMaterial$1 = LineBasicMaterial$1, TARGS = LineBasicMaterialParameters> extends ThMaterial<T, TARGS> {
    getType(): Type<LineBasicMaterial$1>;
    get isLineBasicMaterial(): boolean | undefined;
    set color(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get color(): Color | undefined;
    set map(value: Texture | null);
    get map(): (Texture | null) | undefined;
    set linewidth(value: number);
    get linewidth(): number | undefined;
    set linecap(value: 'butt' | 'round' | 'square');
    get linecap(): ('butt' | 'round' | 'square') | undefined;
    set linejoin(value: 'round' | 'bevel' | 'miter');
    get linejoin(): ('round' | 'bevel' | 'miter') | undefined;
    set fog(value: boolean);
    get fog(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThLineBasicMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThLineBasicMaterial<any, any>, "th-lineBasicMaterial", never, { "color": { "alias": "color"; "required": false; }; "map": { "alias": "map"; "required": false; }; "linewidth": { "alias": "linewidth"; "required": false; }; "linecap": { "alias": "linecap"; "required": false; }; "linejoin": { "alias": "linejoin"; "required": false; }; "fog": { "alias": "fog"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThLineDashedMaterial<T extends LineDashedMaterial = LineDashedMaterial, TARGS = LineDashedMaterialParameters> extends ThLineBasicMaterial<T, TARGS> {
    getType(): Type<LineDashedMaterial>;
    get isLineDashedMaterial(): boolean | undefined;
    set scale(value: number);
    get scale(): number | undefined;
    set dashSize(value: number);
    get dashSize(): number | undefined;
    set gapSize(value: number);
    get gapSize(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThLineDashedMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThLineDashedMaterial<any, any>, "th-lineDashedMaterial", never, { "scale": { "alias": "scale"; "required": false; }; "dashSize": { "alias": "dashSize"; "required": false; }; "gapSize": { "alias": "gapSize"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThLineLoop<TGeometry extends BufferGeometry = BufferGeometry, TMaterial extends Material | Material[] = Material | Material[], TEventMap extends Object3DEventMap$1 = Object3DEventMap$1, T extends LineLoop<TGeometry, TMaterial, TEventMap> = LineLoop<TGeometry, TMaterial, TEventMap>, TARGS = [geometry?: TGeometry, material?: TMaterial]> extends ThLine<TGeometry, TMaterial, TEventMap, T, TARGS> {
    getType(): Type<LineLoop<TGeometry, TMaterial, TEventMap>>;
    get isLineLoop(): true | undefined;
    get type(): (string | 'LineLoop') | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThLineLoop<any, any, any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThLineLoop<any, any, any, any, any>, "th-lineLoop", never, {}, {}, never, ["*"], true, never>;
}

declare class ThLOD<TEventMap extends Object3DEventMap$1 = Object3DEventMap$1, T extends LOD<TEventMap> = LOD<TEventMap>, TARGS = []> extends ThObject3D<TEventMap, T, TARGS> {
    getType(): Type<LOD<TEventMap>>;
    get isLOD(): true | undefined;
    get type(): (string | 'LOD') | undefined;
    get levels(): Array<{
        /** The Object3D to display at this level. */
        object: Object3D$1;
        /** The distance at which to display this level of detail. Expects a `Float`. */
        distance: number;
        /** Threshold used to avoid flickering at LOD boundaries, as a fraction of distance. Expects a `Float`. */
        hysteresis: number;
    }> | undefined;
    set autoUpdate(value: boolean);
    get autoUpdate(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThLOD<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThLOD<any, any, any>, "th-lOD", never, { "autoUpdate": { "alias": "autoUpdate"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThShaderPass<T extends ShaderPass = ShaderPass, TARGS = [shader: object, textureID?: string]> extends ThPass<T, TARGS> {
    getType(): Type<ShaderPass>;
    set textureID(value: string);
    get textureID(): string | undefined;
    set uniforms(map: {
        [name: string]: {
            value: any;
        };
    });
    get uniforms(): {
        [name: string]: {
            value: any;
        };
    } | undefined;
    set material(value: ShaderMaterial);
    get material(): ShaderMaterial | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThShaderPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThShaderPass<any, any>, "th-shaderPass", never, { "textureID": { "alias": "textureID"; "required": false; }; "uniforms": { "alias": "uniforms"; "required": false; }; "material": { "alias": "material"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThLUTPass<T extends LUTPass = LUTPass, TARGS = LUTPassParameters> extends ThShaderPass<T, TARGS> {
    getType(): Type<LUTPass>;
    set lut(value: DataTexture | Data3DTexture);
    get lut(): (DataTexture | Data3DTexture) | undefined;
    set intensity(value: number);
    get intensity(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThLUTPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThLUTPass<any, any>, "th-lUTPass", never, { "lut": { "alias": "lut"; "required": false; }; "intensity": { "alias": "intensity"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThOrbitControls<T extends OrbitControls = OrbitControls, TARGS = [object: Camera$1, domElement?: HTMLElement | SVGElement | null]> extends ThControlBase<OrbitControlsEventMap, T, TARGS> {
    getType(): Type<OrbitControls>;
    set target(value: Vector3 | [x: number, y: number, z: number]);
    get target(): Vector3 | undefined;
    set cursor(value: Vector3 | [x: number, y: number, z: number]);
    get cursor(): Vector3 | undefined;
    set minDistance(value: number);
    get minDistance(): number | undefined;
    set maxDistance(value: number);
    get maxDistance(): number | undefined;
    set minZoom(value: number);
    get minZoom(): number | undefined;
    set maxZoom(value: number);
    get maxZoom(): number | undefined;
    set minTargetRadius(value: number);
    get minTargetRadius(): number | undefined;
    set maxTargetRadius(value: number);
    get maxTargetRadius(): number | undefined;
    set minPolarAngle(value: number);
    get minPolarAngle(): number | undefined;
    set maxPolarAngle(value: number);
    get maxPolarAngle(): number | undefined;
    set minAzimuthAngle(value: number);
    get minAzimuthAngle(): number | undefined;
    set maxAzimuthAngle(value: number);
    get maxAzimuthAngle(): number | undefined;
    set enableDamping(value: boolean);
    get enableDamping(): boolean | undefined;
    set dampingFactor(value: number);
    get dampingFactor(): number | undefined;
    set enableZoom(value: boolean);
    get enableZoom(): boolean | undefined;
    set zoomSpeed(value: number);
    get zoomSpeed(): number | undefined;
    set enableRotate(value: boolean);
    get enableRotate(): boolean | undefined;
    set rotateSpeed(value: number);
    get rotateSpeed(): number | undefined;
    set keyRotateSpeed(value: number);
    get keyRotateSpeed(): number | undefined;
    set enablePan(value: boolean);
    get enablePan(): boolean | undefined;
    set panSpeed(value: number);
    get panSpeed(): number | undefined;
    set screenSpacePanning(value: boolean);
    get screenSpacePanning(): boolean | undefined;
    set keyPanSpeed(value: number);
    get keyPanSpeed(): number | undefined;
    set zoomToCursor(value: boolean);
    get zoomToCursor(): boolean | undefined;
    set autoRotate(value: boolean);
    get autoRotate(): boolean | undefined;
    set autoRotateSpeed(value: number);
    get autoRotateSpeed(): number | undefined;
    set keys(value: {
        LEFT: string;
        UP: string;
        RIGHT: string;
        BOTTOM: string;
    });
    get keys(): {
        LEFT: string;
        UP: string;
        RIGHT: string;
        BOTTOM: string;
    } | undefined;
    set mouseButtons(value: {
        LEFT?: MOUSE | null | undefined;
        MIDDLE?: MOUSE | null | undefined;
        RIGHT?: MOUSE | null | undefined;
    });
    get mouseButtons(): {
        LEFT?: MOUSE | null | undefined;
        MIDDLE?: MOUSE | null | undefined;
        RIGHT?: MOUSE | null | undefined;
    } | undefined;
    set touches(value: {
        ONE?: TOUCH | null | undefined;
        TWO?: TOUCH | null | undefined;
    });
    get touches(): {
        ONE?: TOUCH | null | undefined;
        TWO?: TOUCH | null | undefined;
    } | undefined;
    set target0(value: Vector3 | [x: number, y: number, z: number]);
    get target0(): Vector3 | undefined;
    set position0(value: Vector3 | [x: number, y: number, z: number]);
    get position0(): Vector3 | undefined;
    set zoom0(value: number);
    get zoom0(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThOrbitControls<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThOrbitControls<any, any>, "th-orbitControls", never, { "target": { "alias": "target"; "required": false; }; "cursor": { "alias": "cursor"; "required": false; }; "minDistance": { "alias": "minDistance"; "required": false; }; "maxDistance": { "alias": "maxDistance"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "maxZoom": { "alias": "maxZoom"; "required": false; }; "minTargetRadius": { "alias": "minTargetRadius"; "required": false; }; "maxTargetRadius": { "alias": "maxTargetRadius"; "required": false; }; "minPolarAngle": { "alias": "minPolarAngle"; "required": false; }; "maxPolarAngle": { "alias": "maxPolarAngle"; "required": false; }; "minAzimuthAngle": { "alias": "minAzimuthAngle"; "required": false; }; "maxAzimuthAngle": { "alias": "maxAzimuthAngle"; "required": false; }; "enableDamping": { "alias": "enableDamping"; "required": false; }; "dampingFactor": { "alias": "dampingFactor"; "required": false; }; "enableZoom": { "alias": "enableZoom"; "required": false; }; "zoomSpeed": { "alias": "zoomSpeed"; "required": false; }; "enableRotate": { "alias": "enableRotate"; "required": false; }; "rotateSpeed": { "alias": "rotateSpeed"; "required": false; }; "keyRotateSpeed": { "alias": "keyRotateSpeed"; "required": false; }; "enablePan": { "alias": "enablePan"; "required": false; }; "panSpeed": { "alias": "panSpeed"; "required": false; }; "screenSpacePanning": { "alias": "screenSpacePanning"; "required": false; }; "keyPanSpeed": { "alias": "keyPanSpeed"; "required": false; }; "zoomToCursor": { "alias": "zoomToCursor"; "required": false; }; "autoRotate": { "alias": "autoRotate"; "required": false; }; "autoRotateSpeed": { "alias": "autoRotateSpeed"; "required": false; }; "keys": { "alias": "keys"; "required": false; }; "mouseButtons": { "alias": "mouseButtons"; "required": false; }; "touches": { "alias": "touches"; "required": false; }; "target0": { "alias": "target0"; "required": false; }; "position0": { "alias": "position0"; "required": false; }; "zoom0": { "alias": "zoom0"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThMapControls<T extends MapControls = MapControls, TARGS = [object: Camera, domElement?: HTMLElement]> extends ThOrbitControls<T, TARGS> {
    getType(): Type<MapControls>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMapControls<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMapControls<any, any>, "th-mapControls", never, {}, {}, never, ["*"], true, never>;
}

declare class ThMaskPass<T extends MaskPass = MaskPass, TARGS = [scene: Scene, camera: Camera]> extends ThPass<T, TARGS> {
    getType(): Type<MaskPass>;
    set scene(value: Scene);
    get scene(): Scene | undefined;
    set camera(value: Camera);
    get camera(): Camera | undefined;
    set inverse(value: boolean);
    get inverse(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMaskPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMaskPass<any, any>, "th-maskPass", never, { "scene": { "alias": "scene"; "required": false; }; "camera": { "alias": "camera"; "required": false; }; "inverse": { "alias": "inverse"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThMeshBasicMaterial<T extends MeshBasicMaterial$1 = MeshBasicMaterial$1, TARGS = MeshBasicMaterialParameters> extends ThMaterial<T, TARGS> {
    getType(): Type<MeshBasicMaterial$1>;
    get isMeshBasicMaterial(): boolean | undefined;
    set color(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get color(): Color | undefined;
    set map(value: Texture | null);
    get map(): (Texture | null) | undefined;
    set lightMap(value: Texture | null);
    get lightMap(): (Texture | null) | undefined;
    set lightMapIntensity(value: number);
    get lightMapIntensity(): number | undefined;
    set aoMap(value: Texture | null);
    get aoMap(): (Texture | null) | undefined;
    set aoMapIntensity(value: number);
    get aoMapIntensity(): number | undefined;
    set specularMap(value: Texture | null);
    get specularMap(): (Texture | null) | undefined;
    set alphaMap(value: Texture | null);
    get alphaMap(): (Texture | null) | undefined;
    set envMap(value: Texture | null);
    get envMap(): (Texture | null) | undefined;
    set envMapRotation(value: Euler$1 | [x: number, y: number, z: number, order?: EulerOrder]);
    get envMapRotation(): Euler$1 | undefined;
    set combine(value: Combine);
    get combine(): Combine | undefined;
    set reflectivity(value: number);
    get reflectivity(): number | undefined;
    set refractionRatio(value: number);
    get refractionRatio(): number | undefined;
    set wireframe(value: boolean);
    get wireframe(): boolean | undefined;
    set wireframeLinewidth(value: number);
    get wireframeLinewidth(): number | undefined;
    set wireframeLinecap(value: 'round' | 'bevel' | 'miter');
    get wireframeLinecap(): ('round' | 'bevel' | 'miter') | undefined;
    set wireframeLinejoin(value: 'round' | 'bevel' | 'miter');
    get wireframeLinejoin(): ('round' | 'bevel' | 'miter') | undefined;
    set fog(value: boolean);
    get fog(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMeshBasicMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMeshBasicMaterial<any, any>, "th-meshBasicMaterial", never, { "color": { "alias": "color"; "required": false; }; "map": { "alias": "map"; "required": false; }; "lightMap": { "alias": "lightMap"; "required": false; }; "lightMapIntensity": { "alias": "lightMapIntensity"; "required": false; }; "aoMap": { "alias": "aoMap"; "required": false; }; "aoMapIntensity": { "alias": "aoMapIntensity"; "required": false; }; "specularMap": { "alias": "specularMap"; "required": false; }; "alphaMap": { "alias": "alphaMap"; "required": false; }; "envMap": { "alias": "envMap"; "required": false; }; "envMapRotation": { "alias": "envMapRotation"; "required": false; }; "combine": { "alias": "combine"; "required": false; }; "reflectivity": { "alias": "reflectivity"; "required": false; }; "refractionRatio": { "alias": "refractionRatio"; "required": false; }; "wireframe": { "alias": "wireframe"; "required": false; }; "wireframeLinewidth": { "alias": "wireframeLinewidth"; "required": false; }; "wireframeLinecap": { "alias": "wireframeLinecap"; "required": false; }; "wireframeLinejoin": { "alias": "wireframeLinejoin"; "required": false; }; "fog": { "alias": "fog"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThMeshDepthMaterial<T extends MeshDepthMaterial = MeshDepthMaterial, TARGS = MeshDepthMaterialParameters> extends ThMaterial<T, TARGS> {
    getType(): Type<MeshDepthMaterial>;
    get isMeshDepthMaterial(): boolean | undefined;
    set depthPacking(value: DepthPackingStrategies);
    get depthPacking(): DepthPackingStrategies | undefined;
    set map(value: Texture | null);
    get map(): (Texture | null) | undefined;
    set alphaMap(value: Texture | null);
    get alphaMap(): (Texture | null) | undefined;
    set displacementMap(value: Texture | null);
    get displacementMap(): (Texture | null) | undefined;
    set displacementScale(value: number);
    get displacementScale(): number | undefined;
    set displacementBias(value: number);
    get displacementBias(): number | undefined;
    set wireframe(value: boolean);
    get wireframe(): boolean | undefined;
    set wireframeLinewidth(value: number);
    get wireframeLinewidth(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMeshDepthMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMeshDepthMaterial<any, any>, "th-meshDepthMaterial", never, { "depthPacking": { "alias": "depthPacking"; "required": false; }; "map": { "alias": "map"; "required": false; }; "alphaMap": { "alias": "alphaMap"; "required": false; }; "displacementMap": { "alias": "displacementMap"; "required": false; }; "displacementScale": { "alias": "displacementScale"; "required": false; }; "displacementBias": { "alias": "displacementBias"; "required": false; }; "wireframe": { "alias": "wireframe"; "required": false; }; "wireframeLinewidth": { "alias": "wireframeLinewidth"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThMeshDistanceMaterial<T extends MeshDistanceMaterial = MeshDistanceMaterial, TARGS = MeshDistanceMaterialParameters> extends ThMaterial<T, TARGS> {
    getType(): Type<MeshDistanceMaterial>;
    get isMeshDistanceMaterial(): boolean | undefined;
    set map(value: Texture | null);
    get map(): (Texture | null) | undefined;
    set alphaMap(value: Texture | null);
    get alphaMap(): (Texture | null) | undefined;
    set displacementMap(value: Texture | null);
    get displacementMap(): (Texture | null) | undefined;
    set displacementScale(value: number);
    get displacementScale(): number | undefined;
    set displacementBias(value: number);
    get displacementBias(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMeshDistanceMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMeshDistanceMaterial<any, any>, "th-meshDistanceMaterial", never, { "map": { "alias": "map"; "required": false; }; "alphaMap": { "alias": "alphaMap"; "required": false; }; "displacementMap": { "alias": "displacementMap"; "required": false; }; "displacementScale": { "alias": "displacementScale"; "required": false; }; "displacementBias": { "alias": "displacementBias"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThMeshLambertMaterial<T extends MeshLambertMaterial = MeshLambertMaterial, TARGS = MeshLambertMaterialParameters> extends ThMaterial<T, TARGS> {
    getType(): Type<MeshLambertMaterial>;
    get isMeshLambertMaterial(): boolean | undefined;
    set color(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get color(): Color | undefined;
    set map(value: Texture | null);
    get map(): (Texture | null) | undefined;
    set lightMap(value: Texture | null);
    get lightMap(): (Texture | null) | undefined;
    set lightMapIntensity(value: number);
    get lightMapIntensity(): number | undefined;
    set aoMap(value: Texture | null);
    get aoMap(): (Texture | null) | undefined;
    set aoMapIntensity(value: number);
    get aoMapIntensity(): number | undefined;
    set emissive(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get emissive(): Color | undefined;
    set emissiveIntensity(value: number);
    get emissiveIntensity(): number | undefined;
    set emissiveMap(value: Texture | null);
    get emissiveMap(): (Texture | null) | undefined;
    set bumpMap(value: Texture | null);
    get bumpMap(): (Texture | null) | undefined;
    set bumpScale(value: number);
    get bumpScale(): number | undefined;
    set normalMap(value: Texture | null);
    get normalMap(): (Texture | null) | undefined;
    set normalMapType(value: NormalMapTypes);
    get normalMapType(): NormalMapTypes | undefined;
    set normalScale(value: Vector2 | [x: number, y: number]);
    get normalScale(): Vector2 | undefined;
    set displacementMap(value: Texture | null);
    get displacementMap(): (Texture | null) | undefined;
    set displacementScale(value: number);
    get displacementScale(): number | undefined;
    set displacementBias(value: number);
    get displacementBias(): number | undefined;
    set specularMap(value: Texture | null);
    get specularMap(): (Texture | null) | undefined;
    set alphaMap(value: Texture | null);
    get alphaMap(): (Texture | null) | undefined;
    set envMap(value: Texture | null);
    get envMap(): (Texture | null) | undefined;
    set envMapRotation(value: Euler$1 | [x: number, y: number, z: number, order?: EulerOrder]);
    get envMapRotation(): Euler$1 | undefined;
    set combine(value: Combine);
    get combine(): Combine | undefined;
    set reflectivity(value: number);
    get reflectivity(): number | undefined;
    set refractionRatio(value: number);
    get refractionRatio(): number | undefined;
    set wireframe(value: boolean);
    get wireframe(): boolean | undefined;
    set wireframeLinewidth(value: number);
    get wireframeLinewidth(): number | undefined;
    set wireframeLinecap(value: 'round' | 'bevel' | 'miter');
    get wireframeLinecap(): ('round' | 'bevel' | 'miter') | undefined;
    set wireframeLinejoin(value: 'round' | 'bevel' | 'miter');
    get wireframeLinejoin(): ('round' | 'bevel' | 'miter') | undefined;
    set flatShading(value: boolean);
    get flatShading(): boolean | undefined;
    set fog(value: boolean);
    get fog(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMeshLambertMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMeshLambertMaterial<any, any>, "th-meshLambertMaterial", never, { "color": { "alias": "color"; "required": false; }; "map": { "alias": "map"; "required": false; }; "lightMap": { "alias": "lightMap"; "required": false; }; "lightMapIntensity": { "alias": "lightMapIntensity"; "required": false; }; "aoMap": { "alias": "aoMap"; "required": false; }; "aoMapIntensity": { "alias": "aoMapIntensity"; "required": false; }; "emissive": { "alias": "emissive"; "required": false; }; "emissiveIntensity": { "alias": "emissiveIntensity"; "required": false; }; "emissiveMap": { "alias": "emissiveMap"; "required": false; }; "bumpMap": { "alias": "bumpMap"; "required": false; }; "bumpScale": { "alias": "bumpScale"; "required": false; }; "normalMap": { "alias": "normalMap"; "required": false; }; "normalMapType": { "alias": "normalMapType"; "required": false; }; "normalScale": { "alias": "normalScale"; "required": false; }; "displacementMap": { "alias": "displacementMap"; "required": false; }; "displacementScale": { "alias": "displacementScale"; "required": false; }; "displacementBias": { "alias": "displacementBias"; "required": false; }; "specularMap": { "alias": "specularMap"; "required": false; }; "alphaMap": { "alias": "alphaMap"; "required": false; }; "envMap": { "alias": "envMap"; "required": false; }; "envMapRotation": { "alias": "envMapRotation"; "required": false; }; "combine": { "alias": "combine"; "required": false; }; "reflectivity": { "alias": "reflectivity"; "required": false; }; "refractionRatio": { "alias": "refractionRatio"; "required": false; }; "wireframe": { "alias": "wireframe"; "required": false; }; "wireframeLinewidth": { "alias": "wireframeLinewidth"; "required": false; }; "wireframeLinecap": { "alias": "wireframeLinecap"; "required": false; }; "wireframeLinejoin": { "alias": "wireframeLinejoin"; "required": false; }; "flatShading": { "alias": "flatShading"; "required": false; }; "fog": { "alias": "fog"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThMeshMatcapMaterial<T extends MeshMatcapMaterial = MeshMatcapMaterial, TARGS = MeshMatcapMaterialParameters> extends ThMaterial<T, TARGS> {
    getType(): Type<MeshMatcapMaterial>;
    get isMeshMatcapMaterial(): boolean | undefined;
    set color(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get color(): Color | undefined;
    set matcap(value: Texture | null);
    get matcap(): (Texture | null) | undefined;
    set map(value: Texture | null);
    get map(): (Texture | null) | undefined;
    set bumpMap(value: Texture | null);
    get bumpMap(): (Texture | null) | undefined;
    set bumpScale(value: number);
    get bumpScale(): number | undefined;
    set normalMap(value: Texture | null);
    get normalMap(): (Texture | null) | undefined;
    set normalMapType(value: NormalMapTypes);
    get normalMapType(): NormalMapTypes | undefined;
    set normalScale(value: Vector2 | [x: number, y: number]);
    get normalScale(): Vector2 | undefined;
    set displacementMap(value: Texture | null);
    get displacementMap(): (Texture | null) | undefined;
    set displacementScale(value: number);
    get displacementScale(): number | undefined;
    set displacementBias(value: number);
    get displacementBias(): number | undefined;
    set alphaMap(value: Texture | null);
    get alphaMap(): (Texture | null) | undefined;
    set wireframe(value: boolean);
    get wireframe(): boolean | undefined;
    set wireframeLinewidth(value: number);
    get wireframeLinewidth(): number | undefined;
    set flatShading(value: boolean);
    get flatShading(): boolean | undefined;
    set fog(value: boolean);
    get fog(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMeshMatcapMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMeshMatcapMaterial<any, any>, "th-meshMatcapMaterial", never, { "color": { "alias": "color"; "required": false; }; "matcap": { "alias": "matcap"; "required": false; }; "map": { "alias": "map"; "required": false; }; "bumpMap": { "alias": "bumpMap"; "required": false; }; "bumpScale": { "alias": "bumpScale"; "required": false; }; "normalMap": { "alias": "normalMap"; "required": false; }; "normalMapType": { "alias": "normalMapType"; "required": false; }; "normalScale": { "alias": "normalScale"; "required": false; }; "displacementMap": { "alias": "displacementMap"; "required": false; }; "displacementScale": { "alias": "displacementScale"; "required": false; }; "displacementBias": { "alias": "displacementBias"; "required": false; }; "alphaMap": { "alias": "alphaMap"; "required": false; }; "wireframe": { "alias": "wireframe"; "required": false; }; "wireframeLinewidth": { "alias": "wireframeLinewidth"; "required": false; }; "flatShading": { "alias": "flatShading"; "required": false; }; "fog": { "alias": "fog"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThMeshNormalMaterial<T extends MeshNormalMaterial = MeshNormalMaterial, TARGS = MeshNormalMaterialParameters> extends ThMaterial<T, TARGS> {
    getType(): Type<MeshNormalMaterial>;
    get isMeshNormalMaterial(): boolean | undefined;
    set bumpMap(value: Texture | null);
    get bumpMap(): (Texture | null) | undefined;
    set bumpScale(value: number);
    get bumpScale(): number | undefined;
    set normalMap(value: Texture | null);
    get normalMap(): (Texture | null) | undefined;
    set normalMapType(value: NormalMapTypes);
    get normalMapType(): NormalMapTypes | undefined;
    set normalScale(value: Vector2 | [x: number, y: number]);
    get normalScale(): Vector2 | undefined;
    set displacementMap(value: Texture | null);
    get displacementMap(): (Texture | null) | undefined;
    set displacementScale(value: number);
    get displacementScale(): number | undefined;
    set displacementBias(value: number);
    get displacementBias(): number | undefined;
    set wireframe(value: boolean);
    get wireframe(): boolean | undefined;
    set wireframeLinewidth(value: number);
    get wireframeLinewidth(): number | undefined;
    set flatShading(value: boolean);
    get flatShading(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMeshNormalMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMeshNormalMaterial<any, any>, "th-meshNormalMaterial", never, { "bumpMap": { "alias": "bumpMap"; "required": false; }; "bumpScale": { "alias": "bumpScale"; "required": false; }; "normalMap": { "alias": "normalMap"; "required": false; }; "normalMapType": { "alias": "normalMapType"; "required": false; }; "normalScale": { "alias": "normalScale"; "required": false; }; "displacementMap": { "alias": "displacementMap"; "required": false; }; "displacementScale": { "alias": "displacementScale"; "required": false; }; "displacementBias": { "alias": "displacementBias"; "required": false; }; "wireframe": { "alias": "wireframe"; "required": false; }; "wireframeLinewidth": { "alias": "wireframeLinewidth"; "required": false; }; "flatShading": { "alias": "flatShading"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThMeshPhongMaterial<T extends MeshPhongMaterial = MeshPhongMaterial, TARGS = MeshPhongMaterialParameters> extends ThMaterial<T, TARGS> {
    getType(): Type<MeshPhongMaterial>;
    get isMeshPhongMaterial(): boolean | undefined;
    set color(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get color(): Color | undefined;
    set specular(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get specular(): Color | undefined;
    set shininess(value: number);
    get shininess(): number | undefined;
    set map(value: Texture | null);
    get map(): (Texture | null) | undefined;
    set lightMap(value: Texture | null);
    get lightMap(): (Texture | null) | undefined;
    set lightMapIntensity(value: number);
    get lightMapIntensity(): number | undefined;
    set aoMap(value: Texture | null);
    get aoMap(): (Texture | null) | undefined;
    set aoMapIntensity(value: number);
    get aoMapIntensity(): number | undefined;
    set emissive(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get emissive(): Color | undefined;
    set emissiveIntensity(value: number);
    get emissiveIntensity(): number | undefined;
    set emissiveMap(value: Texture | null);
    get emissiveMap(): (Texture | null) | undefined;
    set bumpMap(value: Texture | null);
    get bumpMap(): (Texture | null) | undefined;
    set bumpScale(value: number);
    get bumpScale(): number | undefined;
    set normalMap(value: Texture | null);
    get normalMap(): (Texture | null) | undefined;
    set normalMapType(value: NormalMapTypes);
    get normalMapType(): NormalMapTypes | undefined;
    set normalScale(value: Vector2 | [x: number, y: number]);
    get normalScale(): Vector2 | undefined;
    set displacementMap(value: Texture | null);
    get displacementMap(): (Texture | null) | undefined;
    set displacementScale(value: number);
    get displacementScale(): number | undefined;
    set displacementBias(value: number);
    get displacementBias(): number | undefined;
    set specularMap(value: Texture | null);
    get specularMap(): (Texture | null) | undefined;
    set alphaMap(value: Texture | null);
    get alphaMap(): (Texture | null) | undefined;
    set envMap(value: Texture | null);
    get envMap(): (Texture | null) | undefined;
    set envMapRotation(value: Euler$1 | [x: number, y: number, z: number, order?: EulerOrder]);
    get envMapRotation(): Euler$1 | undefined;
    set combine(value: Combine);
    get combine(): Combine | undefined;
    set reflectivity(value: number);
    get reflectivity(): number | undefined;
    set refractionRatio(value: number);
    get refractionRatio(): number | undefined;
    set wireframe(value: boolean);
    get wireframe(): boolean | undefined;
    set wireframeLinewidth(value: number);
    get wireframeLinewidth(): number | undefined;
    set wireframeLinecap(value: 'round' | 'bevel' | 'miter');
    get wireframeLinecap(): ('round' | 'bevel' | 'miter') | undefined;
    set wireframeLinejoin(value: 'round' | 'bevel' | 'miter');
    get wireframeLinejoin(): ('round' | 'bevel' | 'miter') | undefined;
    set flatShading(value: boolean);
    get flatShading(): boolean | undefined;
    set fog(value: boolean);
    get fog(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMeshPhongMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMeshPhongMaterial<any, any>, "th-meshPhongMaterial", never, { "color": { "alias": "color"; "required": false; }; "specular": { "alias": "specular"; "required": false; }; "shininess": { "alias": "shininess"; "required": false; }; "map": { "alias": "map"; "required": false; }; "lightMap": { "alias": "lightMap"; "required": false; }; "lightMapIntensity": { "alias": "lightMapIntensity"; "required": false; }; "aoMap": { "alias": "aoMap"; "required": false; }; "aoMapIntensity": { "alias": "aoMapIntensity"; "required": false; }; "emissive": { "alias": "emissive"; "required": false; }; "emissiveIntensity": { "alias": "emissiveIntensity"; "required": false; }; "emissiveMap": { "alias": "emissiveMap"; "required": false; }; "bumpMap": { "alias": "bumpMap"; "required": false; }; "bumpScale": { "alias": "bumpScale"; "required": false; }; "normalMap": { "alias": "normalMap"; "required": false; }; "normalMapType": { "alias": "normalMapType"; "required": false; }; "normalScale": { "alias": "normalScale"; "required": false; }; "displacementMap": { "alias": "displacementMap"; "required": false; }; "displacementScale": { "alias": "displacementScale"; "required": false; }; "displacementBias": { "alias": "displacementBias"; "required": false; }; "specularMap": { "alias": "specularMap"; "required": false; }; "alphaMap": { "alias": "alphaMap"; "required": false; }; "envMap": { "alias": "envMap"; "required": false; }; "envMapRotation": { "alias": "envMapRotation"; "required": false; }; "combine": { "alias": "combine"; "required": false; }; "reflectivity": { "alias": "reflectivity"; "required": false; }; "refractionRatio": { "alias": "refractionRatio"; "required": false; }; "wireframe": { "alias": "wireframe"; "required": false; }; "wireframeLinewidth": { "alias": "wireframeLinewidth"; "required": false; }; "wireframeLinecap": { "alias": "wireframeLinecap"; "required": false; }; "wireframeLinejoin": { "alias": "wireframeLinejoin"; "required": false; }; "flatShading": { "alias": "flatShading"; "required": false; }; "fog": { "alias": "fog"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThMeshStandardMaterial<T extends MeshStandardMaterial = MeshStandardMaterial, TARGS = MeshStandardMaterialParameters> extends ThMaterial<T, TARGS> {
    getType(): Type<MeshStandardMaterial>;
    get isMeshStandardMaterial(): boolean | undefined;
    set color(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get color(): Color | undefined;
    set roughness(value: number);
    get roughness(): number | undefined;
    set metalness(value: number);
    get metalness(): number | undefined;
    set map(value: Texture | null);
    get map(): (Texture | null) | undefined;
    set lightMap(value: Texture | null);
    get lightMap(): (Texture | null) | undefined;
    set lightMapIntensity(value: number);
    get lightMapIntensity(): number | undefined;
    set aoMap(value: Texture | null);
    get aoMap(): (Texture | null) | undefined;
    set aoMapIntensity(value: number);
    get aoMapIntensity(): number | undefined;
    set emissive(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get emissive(): Color | undefined;
    set emissiveIntensity(value: number);
    get emissiveIntensity(): number | undefined;
    set emissiveMap(value: Texture | null);
    get emissiveMap(): (Texture | null) | undefined;
    set bumpMap(value: Texture | null);
    get bumpMap(): (Texture | null) | undefined;
    set bumpScale(value: number);
    get bumpScale(): number | undefined;
    set normalMap(value: Texture | null);
    get normalMap(): (Texture | null) | undefined;
    set normalMapType(value: NormalMapTypes);
    get normalMapType(): NormalMapTypes | undefined;
    set normalScale(value: Vector2 | [x: number, y: number]);
    get normalScale(): Vector2 | undefined;
    set displacementMap(value: Texture | null);
    get displacementMap(): (Texture | null) | undefined;
    set displacementScale(value: number);
    get displacementScale(): number | undefined;
    set displacementBias(value: number);
    get displacementBias(): number | undefined;
    set roughnessMap(value: Texture | null);
    get roughnessMap(): (Texture | null) | undefined;
    set metalnessMap(value: Texture | null);
    get metalnessMap(): (Texture | null) | undefined;
    set alphaMap(value: Texture | null);
    get alphaMap(): (Texture | null) | undefined;
    set envMap(value: Texture | null);
    get envMap(): (Texture | null) | undefined;
    set envMapRotation(value: Euler$1 | [x: number, y: number, z: number, order?: EulerOrder]);
    get envMapRotation(): Euler$1 | undefined;
    set envMapIntensity(value: number);
    get envMapIntensity(): number | undefined;
    set wireframe(value: boolean);
    get wireframe(): boolean | undefined;
    set wireframeLinewidth(value: number);
    get wireframeLinewidth(): number | undefined;
    set wireframeLinecap(value: 'round' | 'bevel' | 'miter');
    get wireframeLinecap(): ('round' | 'bevel' | 'miter') | undefined;
    set wireframeLinejoin(value: 'round' | 'bevel' | 'miter');
    get wireframeLinejoin(): ('round' | 'bevel' | 'miter') | undefined;
    set flatShading(value: boolean);
    get flatShading(): boolean | undefined;
    set fog(value: boolean);
    get fog(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMeshStandardMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMeshStandardMaterial<any, any>, "th-meshStandardMaterial", never, { "color": { "alias": "color"; "required": false; }; "roughness": { "alias": "roughness"; "required": false; }; "metalness": { "alias": "metalness"; "required": false; }; "map": { "alias": "map"; "required": false; }; "lightMap": { "alias": "lightMap"; "required": false; }; "lightMapIntensity": { "alias": "lightMapIntensity"; "required": false; }; "aoMap": { "alias": "aoMap"; "required": false; }; "aoMapIntensity": { "alias": "aoMapIntensity"; "required": false; }; "emissive": { "alias": "emissive"; "required": false; }; "emissiveIntensity": { "alias": "emissiveIntensity"; "required": false; }; "emissiveMap": { "alias": "emissiveMap"; "required": false; }; "bumpMap": { "alias": "bumpMap"; "required": false; }; "bumpScale": { "alias": "bumpScale"; "required": false; }; "normalMap": { "alias": "normalMap"; "required": false; }; "normalMapType": { "alias": "normalMapType"; "required": false; }; "normalScale": { "alias": "normalScale"; "required": false; }; "displacementMap": { "alias": "displacementMap"; "required": false; }; "displacementScale": { "alias": "displacementScale"; "required": false; }; "displacementBias": { "alias": "displacementBias"; "required": false; }; "roughnessMap": { "alias": "roughnessMap"; "required": false; }; "metalnessMap": { "alias": "metalnessMap"; "required": false; }; "alphaMap": { "alias": "alphaMap"; "required": false; }; "envMap": { "alias": "envMap"; "required": false; }; "envMapRotation": { "alias": "envMapRotation"; "required": false; }; "envMapIntensity": { "alias": "envMapIntensity"; "required": false; }; "wireframe": { "alias": "wireframe"; "required": false; }; "wireframeLinewidth": { "alias": "wireframeLinewidth"; "required": false; }; "wireframeLinecap": { "alias": "wireframeLinecap"; "required": false; }; "wireframeLinejoin": { "alias": "wireframeLinejoin"; "required": false; }; "flatShading": { "alias": "flatShading"; "required": false; }; "fog": { "alias": "fog"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThMeshPhysicalMaterial<T extends MeshPhysicalMaterial = MeshPhysicalMaterial, TARGS = MeshPhysicalMaterialParameters> extends ThMeshStandardMaterial<T, TARGS> {
    getType(): Type<MeshPhysicalMaterial>;
    get isMeshPhysicalMaterial(): boolean | undefined;
    set anisotropyRotation(value: number);
    get anisotropyRotation(): number | undefined;
    set anisotropyMap(value: Texture | null);
    get anisotropyMap(): (Texture | null) | undefined;
    set clearcoatMap(value: Texture | null);
    get clearcoatMap(): (Texture | null) | undefined;
    set clearcoatRoughness(value: number);
    get clearcoatRoughness(): number | undefined;
    set clearcoatRoughnessMap(value: Texture | null);
    get clearcoatRoughnessMap(): (Texture | null) | undefined;
    set clearcoatNormalScale(value: Vector2 | [x: number, y: number]);
    get clearcoatNormalScale(): Vector2 | undefined;
    set clearcoatNormalMap(value: Texture | null);
    get clearcoatNormalMap(): (Texture | null) | undefined;
    set ior(value: number);
    get ior(): number | undefined;
    get reflectivity(): number | undefined;
    set reflectivity(value: number);
    set iridescenceMap(value: Texture | null);
    get iridescenceMap(): (Texture | null) | undefined;
    set iridescenceIOR(value: number);
    get iridescenceIOR(): number | undefined;
    set iridescenceThicknessRange(value: [number, number]);
    get iridescenceThicknessRange(): [number, number] | undefined;
    set iridescenceThicknessMap(value: Texture | null);
    get iridescenceThicknessMap(): (Texture | null) | undefined;
    set sheenColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get sheenColor(): Color | undefined;
    set sheenColorMap(value: Texture | null);
    get sheenColorMap(): (Texture | null) | undefined;
    set sheenRoughness(value: number);
    get sheenRoughness(): number | undefined;
    set sheenRoughnessMap(value: Texture | null);
    get sheenRoughnessMap(): (Texture | null) | undefined;
    set transmissionMap(value: Texture | null);
    get transmissionMap(): (Texture | null) | undefined;
    set thickness(value: number);
    get thickness(): number | undefined;
    set thicknessMap(value: Texture | null);
    get thicknessMap(): (Texture | null) | undefined;
    set attenuationDistance(value: number);
    get attenuationDistance(): number | undefined;
    set attenuationColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get attenuationColor(): Color | undefined;
    set specularIntensity(value: number);
    get specularIntensity(): number | undefined;
    set specularIntensityMap(value: Texture | null);
    get specularIntensityMap(): (Texture | null) | undefined;
    set specularColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get specularColor(): Color | undefined;
    set specularColorMap(value: Texture | null);
    get specularColorMap(): (Texture | null) | undefined;
    set anisotropy(value: number);
    get anisotropy(): number | undefined;
    set clearcoat(value: number);
    get clearcoat(): number | undefined;
    set iridescence(value: number);
    get iridescence(): number | undefined;
    set dispersion(value: number);
    get dispersion(): number | undefined;
    set sheen(value: number);
    get sheen(): number | undefined;
    set transmission(value: number);
    get transmission(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMeshPhysicalMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMeshPhysicalMaterial<any, any>, "th-meshPhysicalMaterial", never, { "anisotropyRotation": { "alias": "anisotropyRotation"; "required": false; }; "anisotropyMap": { "alias": "anisotropyMap"; "required": false; }; "clearcoatMap": { "alias": "clearcoatMap"; "required": false; }; "clearcoatRoughness": { "alias": "clearcoatRoughness"; "required": false; }; "clearcoatRoughnessMap": { "alias": "clearcoatRoughnessMap"; "required": false; }; "clearcoatNormalScale": { "alias": "clearcoatNormalScale"; "required": false; }; "clearcoatNormalMap": { "alias": "clearcoatNormalMap"; "required": false; }; "ior": { "alias": "ior"; "required": false; }; "reflectivity": { "alias": "reflectivity"; "required": false; }; "iridescenceMap": { "alias": "iridescenceMap"; "required": false; }; "iridescenceIOR": { "alias": "iridescenceIOR"; "required": false; }; "iridescenceThicknessRange": { "alias": "iridescenceThicknessRange"; "required": false; }; "iridescenceThicknessMap": { "alias": "iridescenceThicknessMap"; "required": false; }; "sheenColor": { "alias": "sheenColor"; "required": false; }; "sheenColorMap": { "alias": "sheenColorMap"; "required": false; }; "sheenRoughness": { "alias": "sheenRoughness"; "required": false; }; "sheenRoughnessMap": { "alias": "sheenRoughnessMap"; "required": false; }; "transmissionMap": { "alias": "transmissionMap"; "required": false; }; "thickness": { "alias": "thickness"; "required": false; }; "thicknessMap": { "alias": "thicknessMap"; "required": false; }; "attenuationDistance": { "alias": "attenuationDistance"; "required": false; }; "attenuationColor": { "alias": "attenuationColor"; "required": false; }; "specularIntensity": { "alias": "specularIntensity"; "required": false; }; "specularIntensityMap": { "alias": "specularIntensityMap"; "required": false; }; "specularColor": { "alias": "specularColor"; "required": false; }; "specularColorMap": { "alias": "specularColorMap"; "required": false; }; "anisotropy": { "alias": "anisotropy"; "required": false; }; "clearcoat": { "alias": "clearcoat"; "required": false; }; "iridescence": { "alias": "iridescence"; "required": false; }; "dispersion": { "alias": "dispersion"; "required": false; }; "sheen": { "alias": "sheen"; "required": false; }; "transmission": { "alias": "transmission"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThMeshToonMaterial<T extends MeshToonMaterial = MeshToonMaterial, TARGS = MeshToonMaterialParameters> extends ThMaterial<T, TARGS> {
    getType(): Type<MeshToonMaterial>;
    get isMeshToonMaterial(): boolean | undefined;
    set color(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get color(): Color | undefined;
    set map(value: Texture | null);
    get map(): (Texture | null) | undefined;
    set gradientMap(value: Texture | null);
    get gradientMap(): (Texture | null) | undefined;
    set lightMap(value: Texture | null);
    get lightMap(): (Texture | null) | undefined;
    set lightMapIntensity(value: number);
    get lightMapIntensity(): number | undefined;
    set aoMap(value: Texture | null);
    get aoMap(): (Texture | null) | undefined;
    set aoMapIntensity(value: number);
    get aoMapIntensity(): number | undefined;
    set emissive(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get emissive(): Color | undefined;
    set emissiveIntensity(value: number);
    get emissiveIntensity(): number | undefined;
    set emissiveMap(value: Texture | null);
    get emissiveMap(): (Texture | null) | undefined;
    set bumpMap(value: Texture | null);
    get bumpMap(): (Texture | null) | undefined;
    set bumpScale(value: number);
    get bumpScale(): number | undefined;
    set normalMap(value: Texture | null);
    get normalMap(): (Texture | null) | undefined;
    set normalMapType(value: NormalMapTypes);
    get normalMapType(): NormalMapTypes | undefined;
    set normalScale(value: Vector2 | [x: number, y: number]);
    get normalScale(): Vector2 | undefined;
    set displacementMap(value: Texture | null);
    get displacementMap(): (Texture | null) | undefined;
    set displacementScale(value: number);
    get displacementScale(): number | undefined;
    set displacementBias(value: number);
    get displacementBias(): number | undefined;
    set alphaMap(value: Texture | null);
    get alphaMap(): (Texture | null) | undefined;
    set wireframe(value: boolean);
    get wireframe(): boolean | undefined;
    set wireframeLinewidth(value: number);
    get wireframeLinewidth(): number | undefined;
    set wireframeLinecap(value: 'round' | 'bevel' | 'miter');
    get wireframeLinecap(): ('round' | 'bevel' | 'miter') | undefined;
    set wireframeLinejoin(value: 'round' | 'bevel' | 'miter');
    get wireframeLinejoin(): ('round' | 'bevel' | 'miter') | undefined;
    set fog(value: boolean);
    get fog(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThMeshToonMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThMeshToonMaterial<any, any>, "th-meshToonMaterial", never, { "color": { "alias": "color"; "required": false; }; "map": { "alias": "map"; "required": false; }; "gradientMap": { "alias": "gradientMap"; "required": false; }; "lightMap": { "alias": "lightMap"; "required": false; }; "lightMapIntensity": { "alias": "lightMapIntensity"; "required": false; }; "aoMap": { "alias": "aoMap"; "required": false; }; "aoMapIntensity": { "alias": "aoMapIntensity"; "required": false; }; "emissive": { "alias": "emissive"; "required": false; }; "emissiveIntensity": { "alias": "emissiveIntensity"; "required": false; }; "emissiveMap": { "alias": "emissiveMap"; "required": false; }; "bumpMap": { "alias": "bumpMap"; "required": false; }; "bumpScale": { "alias": "bumpScale"; "required": false; }; "normalMap": { "alias": "normalMap"; "required": false; }; "normalMapType": { "alias": "normalMapType"; "required": false; }; "normalScale": { "alias": "normalScale"; "required": false; }; "displacementMap": { "alias": "displacementMap"; "required": false; }; "displacementScale": { "alias": "displacementScale"; "required": false; }; "displacementBias": { "alias": "displacementBias"; "required": false; }; "alphaMap": { "alias": "alphaMap"; "required": false; }; "wireframe": { "alias": "wireframe"; "required": false; }; "wireframeLinewidth": { "alias": "wireframeLinewidth"; "required": false; }; "wireframeLinecap": { "alias": "wireframeLinecap"; "required": false; }; "wireframeLinejoin": { "alias": "wireframeLinejoin"; "required": false; }; "fog": { "alias": "fog"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThOctahedronGeometry<T extends OctahedronGeometry = OctahedronGeometry, TARGS = [radius?: number, detail?: number]> extends ThPolyhedronGeometry<T, TARGS> {
    getType(): Type<OctahedronGeometry>;
    get type(): (string | 'OctahedronGeometry') | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThOctahedronGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThOctahedronGeometry<any, any>, "th-octahedronGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThOrthographicCamera<T extends OrthographicCamera = OrthographicCamera, TARGS = [
    left?: number,
    right?: number,
    top?: number,
    bottom?: number,
    near?: number,
    far?: number
]> extends ThCamera<T, TARGS> {
    getType(): Type<OrthographicCamera>;
    get isOrthographicCamera(): true | undefined;
    get type(): (string | 'OrthographicCamera') | undefined;
    set zoom(value: number);
    get zoom(): number | undefined;
    set view(value: null | {
        enabled: boolean;
        fullWidth: number;
        fullHeight: number;
        offsetX: number;
        offsetY: number;
        width: number;
        height: number;
    });
    get view(): (null | {
        enabled: boolean;
        fullWidth: number;
        fullHeight: number;
        offsetX: number;
        offsetY: number;
        width: number;
        height: number;
    }) | undefined;
    set left(value: number);
    get left(): number | undefined;
    set right(value: number);
    get right(): number | undefined;
    set top(value: number);
    get top(): number | undefined;
    set bottom(value: number);
    get bottom(): number | undefined;
    set near(value: number);
    get near(): number | undefined;
    set far(value: number);
    get far(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThOrthographicCamera<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThOrthographicCamera<any, any>, "th-orthographicCamera", never, { "zoom": { "alias": "zoom"; "required": false; }; "view": { "alias": "view"; "required": false; }; "left": { "alias": "left"; "required": false; }; "right": { "alias": "right"; "required": false; }; "top": { "alias": "top"; "required": false; }; "bottom": { "alias": "bottom"; "required": false; }; "near": { "alias": "near"; "required": false; }; "far": { "alias": "far"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThOutlinePass<T extends OutlinePass = OutlinePass, TARGS = [
    resolution: Vector2,
    scene: Scene,
    camera: Camera,
    selectedObjects?: Object3D[]
]> extends ThPass<T, TARGS> {
    getType(): Type<OutlinePass>;
    set renderScene(value: Scene);
    get renderScene(): Scene | undefined;
    set renderCamera(value: Camera);
    get renderCamera(): Camera | undefined;
    set selectedObjects(value: Object3D[]);
    get selectedObjects(): Object3D[] | undefined;
    set visibleEdgeColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get visibleEdgeColor(): Color | undefined;
    set hiddenEdgeColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get hiddenEdgeColor(): Color | undefined;
    set edgeGlow(value: number);
    get edgeGlow(): number | undefined;
    set usePatternTexture(value: boolean);
    get usePatternTexture(): boolean | undefined;
    set edgeThickness(value: number);
    get edgeThickness(): number | undefined;
    set edgeStrength(value: number);
    get edgeStrength(): number | undefined;
    set downSampleRatio(value: number);
    get downSampleRatio(): number | undefined;
    set pulsePeriod(value: number);
    get pulsePeriod(): number | undefined;
    set resolution(value: Vector2 | [x: number, y: number]);
    get resolution(): Vector2 | undefined;
    set patternTexture(value: Texture$1);
    get patternTexture(): Texture$1 | undefined;
    set maskBufferMaterial(value: MeshBasicMaterial$1);
    get maskBufferMaterial(): MeshBasicMaterial$1 | undefined;
    set renderTargetMaskBuffer(value: WebGLRenderTarget);
    get renderTargetMaskBuffer(): WebGLRenderTarget | undefined;
    set depthMaterial(value: MeshDepthMaterial);
    get depthMaterial(): MeshDepthMaterial | undefined;
    set prepareMaskMaterial(value: ShaderMaterial);
    get prepareMaskMaterial(): ShaderMaterial | undefined;
    set renderTargetDepthBuffer(value: WebGLRenderTarget);
    get renderTargetDepthBuffer(): WebGLRenderTarget | undefined;
    set renderTargetMaskDownSampleBuffer(value: WebGLRenderTarget);
    get renderTargetMaskDownSampleBuffer(): WebGLRenderTarget | undefined;
    set renderTargetBlurBuffer1(value: WebGLRenderTarget);
    get renderTargetBlurBuffer1(): WebGLRenderTarget | undefined;
    set renderTargetBlurBuffer2(value: WebGLRenderTarget);
    get renderTargetBlurBuffer2(): WebGLRenderTarget | undefined;
    set edgeDetectionMaterial(value: ShaderMaterial);
    get edgeDetectionMaterial(): ShaderMaterial | undefined;
    set renderTargetEdgeBuffer1(value: WebGLRenderTarget);
    get renderTargetEdgeBuffer1(): WebGLRenderTarget | undefined;
    set renderTargetEdgeBuffer2(value: WebGLRenderTarget);
    get renderTargetEdgeBuffer2(): WebGLRenderTarget | undefined;
    set separableBlurMaterial1(value: ShaderMaterial);
    get separableBlurMaterial1(): ShaderMaterial | undefined;
    set separableBlurMaterial2(value: ShaderMaterial);
    get separableBlurMaterial2(): ShaderMaterial | undefined;
    set overlayMaterial(value: ShaderMaterial);
    get overlayMaterial(): ShaderMaterial | undefined;
    set copyUniforms(value: object);
    get copyUniforms(): object | undefined;
    set materialCopy(value: ShaderMaterial);
    get materialCopy(): ShaderMaterial | undefined;
    set oldClearColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get oldClearColor(): Color | undefined;
    set oldClearAlpha(value: number);
    get oldClearAlpha(): number | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    set tempPulseColor1(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get tempPulseColor1(): Color | undefined;
    set tempPulseColor2(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get tempPulseColor2(): Color | undefined;
    set textureMatrix(value: Matrix4$1 | [
        n11: number,
        n12: number,
        n13: number,
        n14: number,
        n21: number,
        n22: number,
        n23: number,
        n24: number,
        n31: number,
        n32: number,
        n33: number,
        n34: number,
        n41: number,
        n42: number,
        n43: number,
        n44: number
    ]);
    get textureMatrix(): Matrix4$1 | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThOutlinePass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThOutlinePass<any, any>, "th-outlinePass", never, { "renderScene": { "alias": "renderScene"; "required": false; }; "renderCamera": { "alias": "renderCamera"; "required": false; }; "selectedObjects": { "alias": "selectedObjects"; "required": false; }; "visibleEdgeColor": { "alias": "visibleEdgeColor"; "required": false; }; "hiddenEdgeColor": { "alias": "hiddenEdgeColor"; "required": false; }; "edgeGlow": { "alias": "edgeGlow"; "required": false; }; "usePatternTexture": { "alias": "usePatternTexture"; "required": false; }; "edgeThickness": { "alias": "edgeThickness"; "required": false; }; "edgeStrength": { "alias": "edgeStrength"; "required": false; }; "downSampleRatio": { "alias": "downSampleRatio"; "required": false; }; "pulsePeriod": { "alias": "pulsePeriod"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "patternTexture": { "alias": "patternTexture"; "required": false; }; "maskBufferMaterial": { "alias": "maskBufferMaterial"; "required": false; }; "renderTargetMaskBuffer": { "alias": "renderTargetMaskBuffer"; "required": false; }; "depthMaterial": { "alias": "depthMaterial"; "required": false; }; "prepareMaskMaterial": { "alias": "prepareMaskMaterial"; "required": false; }; "renderTargetDepthBuffer": { "alias": "renderTargetDepthBuffer"; "required": false; }; "renderTargetMaskDownSampleBuffer": { "alias": "renderTargetMaskDownSampleBuffer"; "required": false; }; "renderTargetBlurBuffer1": { "alias": "renderTargetBlurBuffer1"; "required": false; }; "renderTargetBlurBuffer2": { "alias": "renderTargetBlurBuffer2"; "required": false; }; "edgeDetectionMaterial": { "alias": "edgeDetectionMaterial"; "required": false; }; "renderTargetEdgeBuffer1": { "alias": "renderTargetEdgeBuffer1"; "required": false; }; "renderTargetEdgeBuffer2": { "alias": "renderTargetEdgeBuffer2"; "required": false; }; "separableBlurMaterial1": { "alias": "separableBlurMaterial1"; "required": false; }; "separableBlurMaterial2": { "alias": "separableBlurMaterial2"; "required": false; }; "overlayMaterial": { "alias": "overlayMaterial"; "required": false; }; "copyUniforms": { "alias": "copyUniforms"; "required": false; }; "materialCopy": { "alias": "materialCopy"; "required": false; }; "oldClearColor": { "alias": "oldClearColor"; "required": false; }; "oldClearAlpha": { "alias": "oldClearAlpha"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; "tempPulseColor1": { "alias": "tempPulseColor1"; "required": false; }; "tempPulseColor2": { "alias": "tempPulseColor2"; "required": false; }; "textureMatrix": { "alias": "textureMatrix"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThOutputPass<T extends OutputPass = OutputPass, TARGS = []> extends ThPass<T, TARGS> {
    getType(): Type<OutputPass>;
    get isOutputPass(): true | undefined;
    set uniforms(map: {
        [name: string]: {
            value: any;
        };
    });
    get uniforms(): {
        [name: string]: {
            value: any;
        };
    } | undefined;
    set material(value: RawShaderMaterial);
    get material(): RawShaderMaterial | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThOutputPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThOutputPass<any, any>, "th-outputPass", never, { "uniforms": { "alias": "uniforms"; "required": false; }; "material": { "alias": "material"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThParametricGeometry<T extends ParametricGeometry = ParametricGeometry, TARGS = [
    func?: (u: number, v: number, target: Vector3) => void,
    slices?: number,
    stacks?: number
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<ParametricGeometry>;
    set type(value: string);
    get type(): string | undefined;
    set parameters(value: {
        func: (u: number, v: number, dest: Vector3) => void;
        slices: number;
        stacks: number;
    });
    get parameters(): {
        func: (u: number, v: number, dest: Vector3) => void;
        slices: number;
        stacks: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThParametricGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThParametricGeometry<any, any>, "th-parametricGeometry", never, { "type": { "alias": "type"; "required": false; }; "parameters": { "alias": "parameters"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThPlaneGeometry<T extends PlaneGeometry = PlaneGeometry, TARGS = [
    width?: number,
    height?: number,
    widthSegments?: number,
    heightSegments?: number
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<PlaneGeometry>;
    get type(): (string | 'PlaneGeometry') | undefined;
    get parameters(): {
        readonly width: number;
        readonly height: number;
        readonly widthSegments: number;
        readonly heightSegments: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPlaneGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThPlaneGeometry<any, any>, "th-planeGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThPlaneHelper<T extends PlaneHelper = PlaneHelper, TARGS = [plane: Plane$1, size?: number, hex?: number]> extends ThLineSegments<BufferGeometry$1, Material$1 | Material$1[], Object3DEventMap, T, TARGS> {
    getType(): Type<PlaneHelper>;
    get type(): (string | 'PlaneHelper') | undefined;
    set plane(value: Plane$1 | [normal: Vector3$1, constant: number]);
    get plane(): Plane$1 | undefined;
    set size(value: number);
    get size(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPlaneHelper<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThPlaneHelper<any, any>, "th-planeHelper", never, { "plane": { "alias": "plane"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThPointerLockControls<T extends PointerLockControls = PointerLockControls, TARGS = [camera: Camera, domElement?: HTMLElement | SVGElement | null]> extends ThControlBase<PointerLockControlsEventMap, T, TARGS> {
    getType(): Type<PointerLockControls>;
    set isLocked(value: boolean);
    get isLocked(): boolean | undefined;
    set minPolarAngle(value: number);
    get minPolarAngle(): number | undefined;
    set maxPolarAngle(value: number);
    get maxPolarAngle(): number | undefined;
    set pointerSpeed(value: number);
    get pointerSpeed(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPointerLockControls<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThPointerLockControls<any, any>, "th-pointerLockControls", never, { "isLocked": { "alias": "isLocked"; "required": false; }; "minPolarAngle": { "alias": "minPolarAngle"; "required": false; }; "maxPolarAngle": { "alias": "maxPolarAngle"; "required": false; }; "pointerSpeed": { "alias": "pointerSpeed"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThPointLight<T extends PointLight = PointLight, TARGS = [
    color?: ColorRepresentation$1,
    intensity?: number,
    distance?: number,
    decay?: number
]> extends ThLight<PointLightShadow, T, TARGS> {
    getType(): Type<PointLight>;
    get isPointLight(): true | undefined;
    set type(value: string);
    get type(): string | undefined;
    set intensity(value: number);
    get intensity(): number | undefined;
    set distance(value: number);
    get distance(): number | undefined;
    set castShadow(value: boolean);
    get castShadow(): boolean | undefined;
    set decay(value: number);
    get decay(): number | undefined;
    set shadow(value: PointLightShadow);
    get shadow(): PointLightShadow | undefined;
    set power(value: number);
    get power(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPointLight<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThPointLight<any, any>, "th-pointLight", never, { "type": { "alias": "type"; "required": false; }; "intensity": { "alias": "intensity"; "required": false; }; "distance": { "alias": "distance"; "required": false; }; "castShadow": { "alias": "castShadow"; "required": false; }; "decay": { "alias": "decay"; "required": false; }; "shadow": { "alias": "shadow"; "required": false; }; "power": { "alias": "power"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThPointLightHelper<T extends PointLightHelper = PointLightHelper, TARGS = [light: PointLight$1, sphereSize?: number, color?: ColorRepresentation$1]> extends ThObject3D<Object3DEventMap, T, TARGS> {
    getType(): Type<PointLightHelper>;
    get type(): (string | 'PointLightHelper') | undefined;
    set light(value: PointLight$1);
    get light(): PointLight$1 | undefined;
    set matrix(value: Matrix4$1 | [
        n11: number,
        n12: number,
        n13: number,
        n14: number,
        n21: number,
        n22: number,
        n23: number,
        n24: number,
        n31: number,
        n32: number,
        n33: number,
        n34: number,
        n41: number,
        n42: number,
        n43: number,
        n44: number
    ]);
    get matrix(): Matrix4$1 | undefined;
    set color(value: ColorRepresentation$1 | undefined);
    get color(): (ColorRepresentation$1 | undefined) | undefined;
    set matrixAutoUpdate(value: boolean);
    get matrixAutoUpdate(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPointLightHelper<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThPointLightHelper<any, any>, "th-pointLightHelper", never, { "light": { "alias": "light"; "required": false; }; "matrix": { "alias": "matrix"; "required": false; }; "color": { "alias": "color"; "required": false; }; "matrixAutoUpdate": { "alias": "matrixAutoUpdate"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThPoints<TGeometry extends BufferGeometry<NormalOrGLBufferAttributes$1> = BufferGeometry, TMaterial extends Material | Material[] = Material | Material[], TEventMap extends Object3DEventMap$1 = Object3DEventMap$1, T extends Points<TGeometry, TMaterial, TEventMap> = Points<TGeometry, TMaterial, TEventMap>, TARGS = [geometry?: TGeometry, material?: TMaterial]> extends ThObject3D<TEventMap, T, TARGS> {
    getType(): Type<Points<TGeometry, TMaterial, TEventMap>>;
    get isPoints(): true | undefined;
    get type(): (string | 'Points') | undefined;
    set morphTargetInfluences(value: number[] | undefined);
    get morphTargetInfluences(): (number[] | undefined) | undefined;
    set morphTargetDictionary(value: {
        [key: string]: number;
    } | undefined);
    get morphTargetDictionary(): ({
        [key: string]: number;
    } | undefined) | undefined;
    set geometry(value: TGeometry);
    get geometry(): TGeometry | undefined;
    set material(value: TMaterial);
    get material(): TMaterial | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPoints<any, any, any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThPoints<any, any, any, any, any>, "th-points", never, { "morphTargetInfluences": { "alias": "morphTargetInfluences"; "required": false; }; "morphTargetDictionary": { "alias": "morphTargetDictionary"; "required": false; }; "geometry": { "alias": "geometry"; "required": false; }; "material": { "alias": "material"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThPointsMaterial<T extends PointsMaterial = PointsMaterial, TARGS = PointsMaterialParameters> extends ThMaterial<T, TARGS> {
    getType(): Type<PointsMaterial>;
    get isPointsMaterial(): boolean | undefined;
    set color(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get color(): Color | undefined;
    set map(value: Texture | null);
    get map(): (Texture | null) | undefined;
    set alphaMap(value: Texture | null);
    get alphaMap(): (Texture | null) | undefined;
    set size(value: number);
    get size(): number | undefined;
    set sizeAttenuation(value: boolean);
    get sizeAttenuation(): boolean | undefined;
    set fog(value: boolean);
    get fog(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPointsMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThPointsMaterial<any, any>, "th-pointsMaterial", never, { "color": { "alias": "color"; "required": false; }; "map": { "alias": "map"; "required": false; }; "alphaMap": { "alias": "alphaMap"; "required": false; }; "size": { "alias": "size"; "required": false; }; "sizeAttenuation": { "alias": "sizeAttenuation"; "required": false; }; "fog": { "alias": "fog"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThPolarGridHelper<T extends PolarGridHelper = PolarGridHelper, TARGS = [
    radius?: number,
    radials?: number,
    circles?: number,
    divisions?: number,
    color1?: ColorRepresentation$1,
    color2?: ColorRepresentation$1
]> extends ThLineSegments<BufferGeometry$1, Material$1 | Material$1[], Object3DEventMap, T, TARGS> {
    getType(): Type<PolarGridHelper>;
    get type(): (string | 'PolarGridHelper') | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPolarGridHelper<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThPolarGridHelper<any, any>, "th-polarGridHelper", never, {}, {}, never, ["*"], true, never>;
}

declare class ThPositionalAudio<T extends PositionalAudio = PositionalAudio, TARGS = AudioListener> extends ThAudio<PannerNode, T, TARGS> {
    getType(): Type<PositionalAudio>;
    set panner(value: PannerNode);
    get panner(): PannerNode | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPositionalAudio<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThPositionalAudio<any, any>, "th-positionalAudio", never, { "panner": { "alias": "panner"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThShaderMaterial<T extends ShaderMaterial = ShaderMaterial, TARGS = ShaderMaterialParameters> extends ThMaterial<T, TARGS> {
    getType(): Type<ShaderMaterial>;
    get isShaderMaterial(): boolean | undefined;
    set defines(value: Record<string, unknown>);
    get defines(): Record<string, unknown> | undefined;
    set uniforms(value: {
        [uniform: string]: IUniform;
    });
    get uniforms(): {
        [uniform: string]: IUniform;
    } | undefined;
    set uniformsGroups(value: Array<UniformsGroup>);
    get uniformsGroups(): Array<UniformsGroup> | undefined;
    set vertexShader(value: string);
    get vertexShader(): string | undefined;
    set fragmentShader(value: string);
    get fragmentShader(): string | undefined;
    set linewidth(value: number);
    get linewidth(): number | undefined;
    set wireframe(value: boolean);
    get wireframe(): boolean | undefined;
    set wireframeLinewidth(value: number);
    get wireframeLinewidth(): number | undefined;
    set fog(value: boolean);
    get fog(): boolean | undefined;
    set lights(value: boolean);
    get lights(): boolean | undefined;
    set clipping(value: boolean);
    get clipping(): boolean | undefined;
    set extensions(value: {
        clipCullDistance: boolean;
        multiDraw: boolean;
    });
    get extensions(): {
        clipCullDistance: boolean;
        multiDraw: boolean;
    } | undefined;
    set defaultAttributeValues(value: {
        color: [number, number, number];
        uv: [number, number];
        uv1: [number, number];
    });
    get defaultAttributeValues(): {
        color: [number, number, number];
        uv: [number, number];
        uv1: [number, number];
    } | undefined;
    set index0AttributeName(value: string | undefined);
    get index0AttributeName(): (string | undefined) | undefined;
    set uniformsNeedUpdate(value: boolean);
    get uniformsNeedUpdate(): boolean | undefined;
    set glslVersion(value: GLSLVersion | null);
    get glslVersion(): (GLSLVersion | null) | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThShaderMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThShaderMaterial<any, any>, "th-shaderMaterial", never, { "defines": { "alias": "defines"; "required": false; }; "uniforms": { "alias": "uniforms"; "required": false; }; "uniformsGroups": { "alias": "uniformsGroups"; "required": false; }; "vertexShader": { "alias": "vertexShader"; "required": false; }; "fragmentShader": { "alias": "fragmentShader"; "required": false; }; "linewidth": { "alias": "linewidth"; "required": false; }; "wireframe": { "alias": "wireframe"; "required": false; }; "wireframeLinewidth": { "alias": "wireframeLinewidth"; "required": false; }; "fog": { "alias": "fog"; "required": false; }; "lights": { "alias": "lights"; "required": false; }; "clipping": { "alias": "clipping"; "required": false; }; "extensions": { "alias": "extensions"; "required": false; }; "defaultAttributeValues": { "alias": "defaultAttributeValues"; "required": false; }; "index0AttributeName": { "alias": "index0AttributeName"; "required": false; }; "uniformsNeedUpdate": { "alias": "uniformsNeedUpdate"; "required": false; }; "glslVersion": { "alias": "glslVersion"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThRawShaderMaterial<T extends RawShaderMaterial = RawShaderMaterial, TARGS = ShaderMaterialParameters> extends ThShaderMaterial<T, TARGS> {
    getType(): Type<RawShaderMaterial>;
    get isRawShaderMaterial(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThRawShaderMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThRawShaderMaterial<any, any>, "th-rawShaderMaterial", never, {}, {}, never, ["*"], true, never>;
}

declare class ThRectAreaLight<T extends RectAreaLight = RectAreaLight, TARGS = [
    color?: ColorRepresentation$1,
    intensity?: number,
    width?: number,
    height?: number
]> extends ThLight<undefined, T, TARGS> {
    getType(): Type<RectAreaLight>;
    get isRectAreaLight(): true | undefined;
    get type(): (string | 'RectAreaLight') | undefined;
    set width(value: number);
    get width(): number | undefined;
    set height(value: number);
    get height(): number | undefined;
    set intensity(value: number);
    get intensity(): number | undefined;
    set power(value: number);
    get power(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThRectAreaLight<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThRectAreaLight<any, any>, "th-rectAreaLight", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "intensity": { "alias": "intensity"; "required": false; }; "power": { "alias": "power"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThRingGeometry<T extends RingGeometry = RingGeometry, TARGS = [
    innerRadius?: number,
    outerRadius?: number,
    thetaSegments?: number,
    phiSegments?: number,
    thetaStart?: number,
    thetaLength?: number
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<RingGeometry>;
    get type(): (string | 'RingGeometry') | undefined;
    get parameters(): {
        readonly innerRadius: number;
        readonly outerRadius: number;
        readonly thetaSegments: number;
        readonly phiSegments: number;
        readonly thetaStart: number;
        readonly thetaLength: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThRingGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThRingGeometry<any, any>, "th-ringGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThRoundedBoxGeometry<T extends RoundedBoxGeometry = RoundedBoxGeometry, TARGS = [
    width?: number,
    height?: number,
    depth?: number,
    segments?: number,
    radius?: number
]> extends ThBoxGeometry<T, TARGS> {
    getType(): Type<RoundedBoxGeometry>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThRoundedBoxGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThRoundedBoxGeometry<any, any>, "th-roundedBoxGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThSAOPass<T extends SAOPass = SAOPass, TARGS = [scene: Scene, camera: Camera, resolution?: Vector2]> extends ThPass<T, TARGS> {
    getType(): Type<SAOPass>;
    set scene(value: Scene);
    get scene(): Scene | undefined;
    set camera(value: Camera);
    get camera(): Camera | undefined;
    set originalClearColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get originalClearColor(): Color | undefined;
    set oldClearColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get oldClearColor(): Color | undefined;
    set oldClearAlpha(value: number);
    get oldClearAlpha(): number | undefined;
    set resolution(value: Vector2 | [x: number, y: number]);
    get resolution(): Vector2 | undefined;
    set saoRenderTarget(value: WebGLRenderTarget);
    get saoRenderTarget(): WebGLRenderTarget | undefined;
    set blurIntermediateRenderTarget(value: WebGLRenderTarget);
    get blurIntermediateRenderTarget(): WebGLRenderTarget | undefined;
    set normalRenderTarget(value: WebGLRenderTarget);
    get normalRenderTarget(): WebGLRenderTarget | undefined;
    set normalMaterial(value: MeshNormalMaterial);
    get normalMaterial(): MeshNormalMaterial | undefined;
    set saoMaterial(value: ShaderMaterial);
    get saoMaterial(): ShaderMaterial | undefined;
    set vBlurMaterial(value: ShaderMaterial);
    get vBlurMaterial(): ShaderMaterial | undefined;
    set hBlurMaterial(value: ShaderMaterial);
    get hBlurMaterial(): ShaderMaterial | undefined;
    set materialCopy(value: ShaderMaterial);
    get materialCopy(): ShaderMaterial | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    set params(value: SAOPassParams);
    get params(): SAOPassParams | undefined;
    static readonly OUTPUT: typeof three_examples_jsm_postprocessing_SAOPass_js.OUTPUT;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThSAOPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThSAOPass<any, any>, "th-sAOPass", never, { "scene": { "alias": "scene"; "required": false; }; "camera": { "alias": "camera"; "required": false; }; "originalClearColor": { "alias": "originalClearColor"; "required": false; }; "oldClearColor": { "alias": "oldClearColor"; "required": false; }; "oldClearAlpha": { "alias": "oldClearAlpha"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "saoRenderTarget": { "alias": "saoRenderTarget"; "required": false; }; "blurIntermediateRenderTarget": { "alias": "blurIntermediateRenderTarget"; "required": false; }; "normalRenderTarget": { "alias": "normalRenderTarget"; "required": false; }; "normalMaterial": { "alias": "normalMaterial"; "required": false; }; "saoMaterial": { "alias": "saoMaterial"; "required": false; }; "vBlurMaterial": { "alias": "vBlurMaterial"; "required": false; }; "hBlurMaterial": { "alias": "hBlurMaterial"; "required": false; }; "materialCopy": { "alias": "materialCopy"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; "params": { "alias": "params"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThSavePass<T extends SavePass = SavePass, TARGS = WebGLRenderTarget> extends ThPass<T, TARGS> {
    getType(): Type<SavePass>;
    set textureID(value: string);
    get textureID(): string | undefined;
    set renderTarget(value: WebGLRenderTarget);
    get renderTarget(): WebGLRenderTarget | undefined;
    set uniforms(map: {
        [name: string]: {
            value: any;
        };
    });
    get uniforms(): {
        [name: string]: {
            value: any;
        };
    } | undefined;
    set material(value: ShaderMaterial);
    get material(): ShaderMaterial | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThSavePass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThSavePass<any, any>, "th-savePass", never, { "textureID": { "alias": "textureID"; "required": false; }; "renderTarget": { "alias": "renderTarget"; "required": false; }; "uniforms": { "alias": "uniforms"; "required": false; }; "material": { "alias": "material"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThShadowMaterial<T extends ShadowMaterial = ShadowMaterial, TARGS = ShadowMaterialParameters> extends ThMaterial<T, TARGS> {
    getType(): Type<ShadowMaterial>;
    get isShadowMaterial(): boolean | undefined;
    set color(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get color(): Color | undefined;
    set fog(value: boolean);
    get fog(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThShadowMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThShadowMaterial<any, any>, "th-shadowMaterial", never, { "color": { "alias": "color"; "required": false; }; "fog": { "alias": "fog"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThShapeGeometry<T extends ShapeGeometry = ShapeGeometry, TARGS = [shapes?: Shape | Shape[], curveSegments?: number]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<ShapeGeometry>;
    get type(): (string | 'ShapeGeometry') | undefined;
    get parameters(): {
        readonly shapes: Shape | Shape[];
        readonly curveSegments: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThShapeGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThShapeGeometry<any, any>, "th-shapeGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThSkeletonHelper<T extends SkeletonHelper = SkeletonHelper, TARGS = /* object */ SkinnedMesh | Object3D$1> extends ThLineSegments<BufferGeometry$1, Material$1 | Material$1[], Object3DEventMap, T, TARGS> {
    getType(): Type<SkeletonHelper>;
    get type(): (string | 'SkeletonHelper') | undefined;
    set root(value: SkinnedMesh | Object3D$1);
    get root(): (SkinnedMesh | Object3D$1) | undefined;
    set bones(value: Bone$1[]);
    get bones(): Bone$1[] | undefined;
    set matrixAutoUpdate(value: boolean);
    get matrixAutoUpdate(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThSkeletonHelper<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThSkeletonHelper<any, any>, "th-skeletonHelper", never, { "root": { "alias": "root"; "required": false; }; "bones": { "alias": "bones"; "required": false; }; "matrixAutoUpdate": { "alias": "matrixAutoUpdate"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThSkinnedMesh<TGeometry extends BufferGeometry = BufferGeometry, TMaterial extends Material | Material[] = Material | Material[], TEventMap extends Object3DEventMap$1 = Object3DEventMap$1, T extends SkinnedMesh$1<TGeometry, TMaterial, TEventMap> = SkinnedMesh$1<TGeometry, TMaterial, TEventMap>, TARGS = [
    geometry?: TGeometry,
    material?: TMaterial,
    useVertexTexture?: boolean
]> extends ThMesh<TGeometry, TMaterial, TEventMap, T, TARGS> {
    getType(): Type<SkinnedMesh$1<TGeometry, TMaterial, TEventMap>>;
    get isSkinnedMesh(): true | undefined;
    get type(): (string | 'SkinnedMesh') | undefined;
    set bindMode(value: BindMode);
    get bindMode(): BindMode | undefined;
    set bindMatrix(value: Matrix4$1 | [
        n11: number,
        n12: number,
        n13: number,
        n14: number,
        n21: number,
        n22: number,
        n23: number,
        n24: number,
        n31: number,
        n32: number,
        n33: number,
        n34: number,
        n41: number,
        n42: number,
        n43: number,
        n44: number
    ]);
    get bindMatrix(): Matrix4$1 | undefined;
    set bindMatrixInverse(value: Matrix4$1 | [
        n11: number,
        n12: number,
        n13: number,
        n14: number,
        n21: number,
        n22: number,
        n23: number,
        n24: number,
        n31: number,
        n32: number,
        n33: number,
        n34: number,
        n41: number,
        n42: number,
        n43: number,
        n44: number
    ]);
    get bindMatrixInverse(): Matrix4$1 | undefined;
    set boundingBox(value: Box3 | [min: Vector3$1, max: Vector3$1]);
    get boundingBox(): Box3 | undefined;
    set boundingSphere(value: Sphere | [center: Vector3$1, radius: number]);
    get boundingSphere(): Sphere | undefined;
    set skeleton(value: Skeleton);
    get skeleton(): Skeleton | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThSkinnedMesh<any, any, any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThSkinnedMesh<any, any, any, any, any>, "th-skinnedMesh", never, { "bindMode": { "alias": "bindMode"; "required": false; }; "bindMatrix": { "alias": "bindMatrix"; "required": false; }; "bindMatrixInverse": { "alias": "bindMatrixInverse"; "required": false; }; "boundingBox": { "alias": "boundingBox"; "required": false; }; "boundingSphere": { "alias": "boundingSphere"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThSMAAPass<T extends SMAAPass = SMAAPass, TARGS = []> extends ThPass<T, TARGS> {
    getType(): Type<SMAAPass>;
    set edgesRT(value: WebGLRenderTarget);
    get edgesRT(): WebGLRenderTarget | undefined;
    set weightsRT(value: WebGLRenderTarget);
    get weightsRT(): WebGLRenderTarget | undefined;
    set areaTexture(value: Texture$1);
    get areaTexture(): Texture$1 | undefined;
    set searchTexture(value: Texture$1);
    get searchTexture(): Texture$1 | undefined;
    set uniformsEdges(value: object);
    get uniformsEdges(): object | undefined;
    set materialEdges(value: ShaderMaterial);
    get materialEdges(): ShaderMaterial | undefined;
    set uniformsWeights(value: object);
    get uniformsWeights(): object | undefined;
    set materialWeights(value: ShaderMaterial);
    get materialWeights(): ShaderMaterial | undefined;
    set uniformsBlend(value: object);
    get uniformsBlend(): object | undefined;
    set materialBlend(value: ShaderMaterial);
    get materialBlend(): ShaderMaterial | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThSMAAPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThSMAAPass<any, any>, "th-sMAAPass", never, { "edgesRT": { "alias": "edgesRT"; "required": false; }; "weightsRT": { "alias": "weightsRT"; "required": false; }; "areaTexture": { "alias": "areaTexture"; "required": false; }; "searchTexture": { "alias": "searchTexture"; "required": false; }; "uniformsEdges": { "alias": "uniformsEdges"; "required": false; }; "materialEdges": { "alias": "materialEdges"; "required": false; }; "uniformsWeights": { "alias": "uniformsWeights"; "required": false; }; "materialWeights": { "alias": "materialWeights"; "required": false; }; "uniformsBlend": { "alias": "uniformsBlend"; "required": false; }; "materialBlend": { "alias": "materialBlend"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThSphereGeometry<T extends SphereGeometry = SphereGeometry, TARGS = [
    radius?: number,
    widthSegments?: number,
    heightSegments?: number,
    phiStart?: number,
    phiLength?: number,
    thetaStart?: number,
    thetaLength?: number
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<SphereGeometry>;
    get type(): (string | 'SphereGeometry') | undefined;
    get parameters(): {
        readonly radius: number;
        readonly widthSegments: number;
        readonly heightSegments: number;
        readonly phiStart: number;
        readonly phiLength: number;
        readonly thetaStart: number;
        readonly thetaLength: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThSphereGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThSphereGeometry<any, any>, "th-sphereGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThSpotLight<T extends SpotLight = SpotLight, TARGS = [
    color?: ColorRepresentation$1,
    intensity?: number,
    distance?: number,
    angle?: number,
    penumbra?: number,
    decay?: number
]> extends ThLight<SpotLightShadow, T, TARGS> {
    getType(): Type<SpotLight>;
    get isSpotLight(): true | undefined;
    get type(): (string | 'SpotLight') | undefined;
    set position(value: Vector3 | [x: number, y: number, z: number]);
    get position(): Vector3 | undefined;
    set target(value: Object3D$1);
    get target(): Object3D$1 | undefined;
    set castShadow(value: boolean);
    get castShadow(): boolean | undefined;
    set intensity(value: number);
    get intensity(): number | undefined;
    set distance(value: number);
    get distance(): number | undefined;
    set angle(value: number);
    get angle(): number | undefined;
    set decay(value: number);
    get decay(): number | undefined;
    set shadow(value: SpotLightShadow);
    get shadow(): SpotLightShadow | undefined;
    set power(value: number);
    get power(): number | undefined;
    set penumbra(value: number);
    get penumbra(): number | undefined;
    set map(value: Texture | null);
    get map(): (Texture | null) | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThSpotLight<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThSpotLight<any, any>, "th-spotLight", never, { "position": { "alias": "position"; "required": false; }; "target": { "alias": "target"; "required": false; }; "castShadow": { "alias": "castShadow"; "required": false; }; "intensity": { "alias": "intensity"; "required": false; }; "distance": { "alias": "distance"; "required": false; }; "angle": { "alias": "angle"; "required": false; }; "decay": { "alias": "decay"; "required": false; }; "shadow": { "alias": "shadow"; "required": false; }; "power": { "alias": "power"; "required": false; }; "penumbra": { "alias": "penumbra"; "required": false; }; "map": { "alias": "map"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThSpotLightHelper<T extends SpotLightHelper = SpotLightHelper, TARGS = [light: Light$1, color?: ColorRepresentation$1]> extends ThObject3D<Object3DEventMap, T, TARGS> {
    getType(): Type<SpotLightHelper>;
    get type(): (string | 'SpotLightHelper') | undefined;
    set cone(value: LineSegments$1);
    get cone(): LineSegments$1 | undefined;
    set light(value: Light$1);
    get light(): Light$1 | undefined;
    set matrix(value: Matrix4$1 | [
        n11: number,
        n12: number,
        n13: number,
        n14: number,
        n21: number,
        n22: number,
        n23: number,
        n24: number,
        n31: number,
        n32: number,
        n33: number,
        n34: number,
        n41: number,
        n42: number,
        n43: number,
        n44: number
    ]);
    get matrix(): Matrix4$1 | undefined;
    set color(value: ColorRepresentation$1 | undefined);
    get color(): (ColorRepresentation$1 | undefined) | undefined;
    set matrixAutoUpdate(value: boolean);
    get matrixAutoUpdate(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThSpotLightHelper<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThSpotLightHelper<any, any>, "th-spotLightHelper", never, { "cone": { "alias": "cone"; "required": false; }; "light": { "alias": "light"; "required": false; }; "matrix": { "alias": "matrix"; "required": false; }; "color": { "alias": "color"; "required": false; }; "matrixAutoUpdate": { "alias": "matrixAutoUpdate"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThSprite<TEventMap extends Object3DEventMap$1 = Object3DEventMap$1, T extends Sprite<TEventMap> = Sprite<TEventMap>, TARGS = SpriteMaterial> extends ThObject3D<TEventMap, T, TARGS> {
    getType(): Type<Sprite<TEventMap>>;
    get isSprite(): true | undefined;
    get type(): (string | 'Sprite') | undefined;
    set castShadow(value: false);
    get castShadow(): false | undefined;
    set geometry(value: BufferGeometry);
    get geometry(): BufferGeometry | undefined;
    set material(value: SpriteMaterial);
    get material(): SpriteMaterial | undefined;
    set center(value: Vector2 | [x: number, y: number]);
    get center(): Vector2 | undefined;
    set count(value: number);
    get count(): number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThSprite<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThSprite<any, any, any>, "th-sprite", never, { "castShadow": { "alias": "castShadow"; "required": false; }; "geometry": { "alias": "geometry"; "required": false; }; "material": { "alias": "material"; "required": false; }; "center": { "alias": "center"; "required": false; }; "count": { "alias": "count"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThSpriteMaterial<T extends SpriteMaterial$1 = SpriteMaterial$1, TARGS = SpriteMaterialParameters> extends ThMaterial<T, TARGS> {
    getType(): Type<SpriteMaterial$1>;
    get isSpriteMaterial(): boolean | undefined;
    set color(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get color(): Color | undefined;
    set map(value: Texture | null);
    get map(): (Texture | null) | undefined;
    set alphaMap(value: Texture | null);
    get alphaMap(): (Texture | null) | undefined;
    set rotation(value: number);
    get rotation(): number | undefined;
    set sizeAttenuation(value: boolean);
    get sizeAttenuation(): boolean | undefined;
    set fog(value: boolean);
    get fog(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThSpriteMaterial<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThSpriteMaterial<any, any>, "th-spriteMaterial", never, { "color": { "alias": "color"; "required": false; }; "map": { "alias": "map"; "required": false; }; "alphaMap": { "alias": "alphaMap"; "required": false; }; "rotation": { "alias": "rotation"; "required": false; }; "sizeAttenuation": { "alias": "sizeAttenuation"; "required": false; }; "fog": { "alias": "fog"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThSSAARenderPass<T extends SSAARenderPass = SSAARenderPass, TARGS = [
    scene: Scene,
    camera: Camera,
    clearColor?: ColorRepresentation,
    clearAlpha?: number
]> extends ThPass<T, TARGS> {
    getType(): Type<SSAARenderPass>;
    set scene(value: Scene);
    get scene(): Scene | undefined;
    set camera(value: Camera);
    get camera(): Camera | undefined;
    set sampleLevel(value: number);
    get sampleLevel(): number | undefined;
    set unbiased(value: boolean);
    get unbiased(): boolean | undefined;
    set stencilBuffer(value: boolean);
    get stencilBuffer(): boolean | undefined;
    set clearColor(value: ColorRepresentation);
    get clearColor(): ColorRepresentation | undefined;
    set clearAlpha(value: number);
    get clearAlpha(): number | undefined;
    set copyUniforms(value: object);
    get copyUniforms(): object | undefined;
    set copyMaterial(value: ShaderMaterial);
    get copyMaterial(): ShaderMaterial | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    set sampleRenderTarget(value: WebGLRenderTarget | undefined);
    get sampleRenderTarget(): (WebGLRenderTarget | undefined) | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThSSAARenderPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThSSAARenderPass<any, any>, "th-sSAARenderPass", never, { "scene": { "alias": "scene"; "required": false; }; "camera": { "alias": "camera"; "required": false; }; "sampleLevel": { "alias": "sampleLevel"; "required": false; }; "unbiased": { "alias": "unbiased"; "required": false; }; "stencilBuffer": { "alias": "stencilBuffer"; "required": false; }; "clearColor": { "alias": "clearColor"; "required": false; }; "clearAlpha": { "alias": "clearAlpha"; "required": false; }; "copyUniforms": { "alias": "copyUniforms"; "required": false; }; "copyMaterial": { "alias": "copyMaterial"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; "sampleRenderTarget": { "alias": "sampleRenderTarget"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThSSAOPass<T extends SSAOPass = SSAOPass, TARGS = [
    scene: Scene,
    camera: Camera,
    width?: number,
    height?: number,
    kernelSize?: number
]> extends ThPass<T, TARGS> {
    getType(): Type<SSAOPass>;
    set scene(value: Scene);
    get scene(): Scene | undefined;
    set camera(value: Camera);
    get camera(): Camera | undefined;
    set width(value: number);
    get width(): number | undefined;
    set height(value: number);
    get height(): number | undefined;
    set clear(value: boolean);
    get clear(): boolean | undefined;
    set kernelRadius(value: number);
    get kernelRadius(): number | undefined;
    set kernel(value: Vector3$1[]);
    get kernel(): Vector3$1[] | undefined;
    set noiseTexture(value: DataTexture);
    get noiseTexture(): DataTexture | undefined;
    set output(value: SSAOPassOUTPUT);
    get output(): SSAOPassOUTPUT | undefined;
    set minDistance(value: number);
    get minDistance(): number | undefined;
    set maxDistance(value: number);
    get maxDistance(): number | undefined;
    set normalRenderTarget(value: WebGLRenderTarget);
    get normalRenderTarget(): WebGLRenderTarget | undefined;
    set ssaoRenderTarget(value: WebGLRenderTarget);
    get ssaoRenderTarget(): WebGLRenderTarget | undefined;
    set blurRenderTarget(value: WebGLRenderTarget);
    get blurRenderTarget(): WebGLRenderTarget | undefined;
    set ssaoMaterial(value: ShaderMaterial);
    get ssaoMaterial(): ShaderMaterial | undefined;
    set normalMaterial(value: MeshNormalMaterial);
    get normalMaterial(): MeshNormalMaterial | undefined;
    set blurMaterial(value: ShaderMaterial);
    get blurMaterial(): ShaderMaterial | undefined;
    set depthRenderMaterial(value: ShaderMaterial);
    get depthRenderMaterial(): ShaderMaterial | undefined;
    set copyMaterial(value: ShaderMaterial);
    get copyMaterial(): ShaderMaterial | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    set originalClearColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get originalClearColor(): Color | undefined;
    static readonly OUTPUT: typeof SSAOPassOUTPUT;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThSSAOPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThSSAOPass<any, any>, "th-sSAOPass", never, { "scene": { "alias": "scene"; "required": false; }; "camera": { "alias": "camera"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "clear": { "alias": "clear"; "required": false; }; "kernelRadius": { "alias": "kernelRadius"; "required": false; }; "kernel": { "alias": "kernel"; "required": false; }; "noiseTexture": { "alias": "noiseTexture"; "required": false; }; "output": { "alias": "output"; "required": false; }; "minDistance": { "alias": "minDistance"; "required": false; }; "maxDistance": { "alias": "maxDistance"; "required": false; }; "normalRenderTarget": { "alias": "normalRenderTarget"; "required": false; }; "ssaoRenderTarget": { "alias": "ssaoRenderTarget"; "required": false; }; "blurRenderTarget": { "alias": "blurRenderTarget"; "required": false; }; "ssaoMaterial": { "alias": "ssaoMaterial"; "required": false; }; "normalMaterial": { "alias": "normalMaterial"; "required": false; }; "blurMaterial": { "alias": "blurMaterial"; "required": false; }; "depthRenderMaterial": { "alias": "depthRenderMaterial"; "required": false; }; "copyMaterial": { "alias": "copyMaterial"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; "originalClearColor": { "alias": "originalClearColor"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThSSRPass<T extends SSRPass = SSRPass, TARGS = SSRPassParams> extends ThPass<T, TARGS> {
    getType(): Type<SSRPass>;
    set width(value: number);
    get width(): number | undefined;
    set height(value: number);
    get height(): number | undefined;
    set clear(value: boolean);
    get clear(): boolean | undefined;
    set renderer(value: WebGLRenderer);
    get renderer(): WebGLRenderer | undefined;
    set scene(value: Scene);
    get scene(): Scene | undefined;
    set camera(value: Camera);
    get camera(): Camera | undefined;
    set groundReflector(value: ReflectorForSSRPass | null);
    get groundReflector(): (ReflectorForSSRPass | null) | undefined;
    set opacity(value: number);
    get opacity(): number | undefined;
    set output(value: number);
    get output(): number | undefined;
    set maxDistance(value: number);
    get maxDistance(): number | undefined;
    set thickness(value: number);
    get thickness(): number | undefined;
    set tempColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get tempColor(): Color | undefined;
    get selects(): (Mesh$1[] | null) | undefined;
    set selects(value: Mesh$1[] | null);
    set selective(value: boolean);
    get selective(): boolean | undefined;
    get bouncing(): boolean | undefined;
    set bouncing(value: boolean);
    set blur(value: boolean);
    get blur(): boolean | undefined;
    get distanceAttenuation(): boolean | undefined;
    set distanceAttenuation(value: boolean);
    get fresnel(): boolean | undefined;
    set fresnel(value: boolean);
    get infiniteThick(): boolean | undefined;
    set infiniteThick(value: boolean);
    set beautyRenderTarget(value: WebGLRenderTarget);
    get beautyRenderTarget(): WebGLRenderTarget | undefined;
    set prevRenderTarget(value: WebGLRenderTarget);
    get prevRenderTarget(): WebGLRenderTarget | undefined;
    set normalRenderTarget(value: WebGLRenderTarget);
    get normalRenderTarget(): WebGLRenderTarget | undefined;
    set metalnessRenderTarget(value: WebGLRenderTarget);
    get metalnessRenderTarget(): WebGLRenderTarget | undefined;
    set ssrRenderTarget(value: WebGLRenderTarget);
    get ssrRenderTarget(): WebGLRenderTarget | undefined;
    set blurRenderTarget(value: WebGLRenderTarget);
    get blurRenderTarget(): WebGLRenderTarget | undefined;
    set blurRenderTarget2(value: WebGLRenderTarget);
    get blurRenderTarget2(): WebGLRenderTarget | undefined;
    set ssrMaterial(value: ShaderMaterial);
    get ssrMaterial(): ShaderMaterial | undefined;
    set normalMaterial(value: MeshNormalMaterial);
    get normalMaterial(): MeshNormalMaterial | undefined;
    set metalnessOnMaterial(value: MeshBasicMaterial$1);
    get metalnessOnMaterial(): MeshBasicMaterial$1 | undefined;
    set metalnessOffMaterial(value: MeshBasicMaterial$1);
    get metalnessOffMaterial(): MeshBasicMaterial$1 | undefined;
    set blurMaterial(value: ShaderMaterial);
    get blurMaterial(): ShaderMaterial | undefined;
    set blurMaterial2(value: ShaderMaterial);
    get blurMaterial2(): ShaderMaterial | undefined;
    set depthRenderMaterial(value: ShaderMaterial);
    get depthRenderMaterial(): ShaderMaterial | undefined;
    set copyMaterial(value: ShaderMaterial);
    get copyMaterial(): ShaderMaterial | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    set originalClearColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get originalClearColor(): Color | undefined;
    static readonly OUTPUT: {
        Default: 0;
        SSR: 1;
        Beauty: 3;
        Depth: 4;
        Normal: 5;
        Metalness: 7;
    };
    get resolutionScale(): number | undefined;
    set resolutionScale(value: number);
    static ɵfac: i0.ɵɵFactoryDeclaration<ThSSRPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThSSRPass<any, any>, "th-sSRPass", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "clear": { "alias": "clear"; "required": false; }; "renderer": { "alias": "renderer"; "required": false; }; "scene": { "alias": "scene"; "required": false; }; "camera": { "alias": "camera"; "required": false; }; "groundReflector": { "alias": "groundReflector"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "output": { "alias": "output"; "required": false; }; "maxDistance": { "alias": "maxDistance"; "required": false; }; "thickness": { "alias": "thickness"; "required": false; }; "tempColor": { "alias": "tempColor"; "required": false; }; "selects": { "alias": "selects"; "required": false; }; "selective": { "alias": "selective"; "required": false; }; "bouncing": { "alias": "bouncing"; "required": false; }; "blur": { "alias": "blur"; "required": false; }; "distanceAttenuation": { "alias": "distanceAttenuation"; "required": false; }; "fresnel": { "alias": "fresnel"; "required": false; }; "infiniteThick": { "alias": "infiniteThick"; "required": false; }; "beautyRenderTarget": { "alias": "beautyRenderTarget"; "required": false; }; "prevRenderTarget": { "alias": "prevRenderTarget"; "required": false; }; "normalRenderTarget": { "alias": "normalRenderTarget"; "required": false; }; "metalnessRenderTarget": { "alias": "metalnessRenderTarget"; "required": false; }; "ssrRenderTarget": { "alias": "ssrRenderTarget"; "required": false; }; "blurRenderTarget": { "alias": "blurRenderTarget"; "required": false; }; "blurRenderTarget2": { "alias": "blurRenderTarget2"; "required": false; }; "ssrMaterial": { "alias": "ssrMaterial"; "required": false; }; "normalMaterial": { "alias": "normalMaterial"; "required": false; }; "metalnessOnMaterial": { "alias": "metalnessOnMaterial"; "required": false; }; "metalnessOffMaterial": { "alias": "metalnessOffMaterial"; "required": false; }; "blurMaterial": { "alias": "blurMaterial"; "required": false; }; "blurMaterial2": { "alias": "blurMaterial2"; "required": false; }; "depthRenderMaterial": { "alias": "depthRenderMaterial"; "required": false; }; "copyMaterial": { "alias": "copyMaterial"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; "originalClearColor": { "alias": "originalClearColor"; "required": false; }; "resolutionScale": { "alias": "resolutionScale"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThStereoCamera<T extends StereoCamera = StereoCamera, TARGS = []> extends ThCamera<T, TARGS> {
    getType(): Type<StereoCamera>;
    set type(value: 'StereoCamera');
    get type(): 'StereoCamera' | undefined;
    set aspect(value: number);
    get aspect(): number | undefined;
    set eyeSep(value: number);
    get eyeSep(): number | undefined;
    set cameraL(value: PerspectiveCamera$1);
    get cameraL(): PerspectiveCamera$1 | undefined;
    set cameraR(value: PerspectiveCamera$1);
    get cameraR(): PerspectiveCamera$1 | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThStereoCamera<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThStereoCamera<any, any>, "th-stereoCamera", never, { "type": { "alias": "type"; "required": false; }; "aspect": { "alias": "aspect"; "required": false; }; "eyeSep": { "alias": "eyeSep"; "required": false; }; "cameraL": { "alias": "cameraL"; "required": false; }; "cameraR": { "alias": "cameraR"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThTAARenderPass<T extends TAARenderPass = TAARenderPass, TARGS = [
    scene: Scene,
    camera: Camera,
    clearColor?: ColorRepresentation,
    clearAlpha?: number
]> extends ThSSAARenderPass<T, TARGS> {
    getType(): Type<TAARenderPass>;
    set accumulate(value: boolean);
    get accumulate(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTAARenderPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThTAARenderPass<any, any>, "th-tAARenderPass", never, { "accumulate": { "alias": "accumulate"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThTeapotGeometry<T extends TeapotGeometry = TeapotGeometry, TARGS = [
    size?: number,
    segments?: number,
    bottom?: boolean,
    lid?: boolean,
    body?: boolean,
    fitLid?: boolean,
    blinn?: boolean
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<TeapotGeometry>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTeapotGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThTeapotGeometry<any, any>, "th-teapotGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThTetrahedronGeometry<T extends TetrahedronGeometry = TetrahedronGeometry, TARGS = [radius?: number, detail?: number]> extends ThPolyhedronGeometry<T, TARGS> {
    getType(): Type<TetrahedronGeometry>;
    get type(): (string | 'TetrahedronGeometry') | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTetrahedronGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThTetrahedronGeometry<any, any>, "th-tetrahedronGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThTextGeometry<T extends TextGeometry = TextGeometry, TARGS = [text: string, parameters?: TextGeometryParameters]> extends ThExtrudeGeometry<T, TARGS> {
    getType(): Type<TextGeometry>;
    get type(): (string | 'TextGeometry') | undefined;
    get parameters(): {
        readonly shapes: Shape$1 | Shape$1[];
        readonly options: TextGeometryParameters;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTextGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThTextGeometry<any, any>, "th-textGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThTexturePass<T extends TexturePass = TexturePass, TARGS = [map?: Texture$1, opacity?: number]> extends ThPass<T, TARGS> {
    getType(): Type<TexturePass>;
    set map(value: Texture$1 | undefined);
    get map(): (Texture$1 | undefined) | undefined;
    set opacity(value: number);
    get opacity(): number | undefined;
    set uniforms(map: {
        [name: string]: {
            value: any;
        };
    });
    get uniforms(): {
        [name: string]: {
            value: any;
        };
    } | undefined;
    set material(value: ShaderMaterial);
    get material(): ShaderMaterial | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTexturePass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThTexturePass<any, any>, "th-texturePass", never, { "map": { "alias": "map"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "uniforms": { "alias": "uniforms"; "required": false; }; "material": { "alias": "material"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThTorusGeometry<T extends TorusGeometry = TorusGeometry, TARGS = [
    radius?: number,
    tube?: number,
    radialSegments?: number,
    tubularSegments?: number,
    arc?: number
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<TorusGeometry>;
    get type(): (string | 'TorusGeometry') | undefined;
    get parameters(): {
        readonly radius: number;
        readonly tube: number;
        readonly radialSegments: number;
        readonly tubularSegments: number;
        readonly arc: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTorusGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThTorusGeometry<any, any>, "th-torusGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThTorusKnotGeometry<T extends TorusKnotGeometry = TorusKnotGeometry, TARGS = [
    radius?: number,
    tube?: number,
    tubularSegments?: number,
    radialSegments?: number,
    p?: number,
    q?: number
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<TorusKnotGeometry>;
    get type(): (string | 'TorusKnotGeometry') | undefined;
    get parameters(): {
        readonly radius: number;
        readonly tube: number;
        readonly tubularSegments: number;
        readonly radialSegments: number;
        readonly p: number;
        readonly q: number;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTorusKnotGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThTorusKnotGeometry<any, any>, "th-torusKnotGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare class ThTrackballControls<T extends TrackballControls = TrackballControls, TARGS = [camera: Camera$1, domElement?: HTMLElement | SVGElement | null]> extends ThControlBase<TrackballControlsEventMap, T, TARGS> {
    getType(): Type<TrackballControls>;
    set screen(value: {
        left: number;
        top: number;
        width: number;
        height: number;
    });
    get screen(): {
        left: number;
        top: number;
        width: number;
        height: number;
    } | undefined;
    set rotateSpeed(value: number);
    get rotateSpeed(): number | undefined;
    set zoomSpeed(value: number);
    get zoomSpeed(): number | undefined;
    set panSpeed(value: number);
    get panSpeed(): number | undefined;
    set noRotate(value: boolean);
    get noRotate(): boolean | undefined;
    set noZoom(value: boolean);
    get noZoom(): boolean | undefined;
    set noPan(value: boolean);
    get noPan(): boolean | undefined;
    set staticMoving(value: boolean);
    get staticMoving(): boolean | undefined;
    set dynamicDampingFactor(value: number);
    get dynamicDampingFactor(): number | undefined;
    set minDistance(value: number);
    get minDistance(): number | undefined;
    set maxDistance(value: number);
    get maxDistance(): number | undefined;
    set minZoom(value: number);
    get minZoom(): number | undefined;
    set maxZoom(value: number);
    get maxZoom(): number | undefined;
    set keys(value: [string, string, string]);
    get keys(): [string, string, string] | undefined;
    set mouseButtons(value: {
        LEFT?: MOUSE | null | undefined;
        MIDDLE?: MOUSE | null | undefined;
        RIGHT?: MOUSE | null | undefined;
    });
    get mouseButtons(): {
        LEFT?: MOUSE | null | undefined;
        MIDDLE?: MOUSE | null | undefined;
        RIGHT?: MOUSE | null | undefined;
    } | undefined;
    set target(value: Vector3 | [x: number, y: number, z: number]);
    get target(): Vector3 | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTrackballControls<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThTrackballControls<any, any>, "th-trackballControls", never, { "screen": { "alias": "screen"; "required": false; }; "rotateSpeed": { "alias": "rotateSpeed"; "required": false; }; "zoomSpeed": { "alias": "zoomSpeed"; "required": false; }; "panSpeed": { "alias": "panSpeed"; "required": false; }; "noRotate": { "alias": "noRotate"; "required": false; }; "noZoom": { "alias": "noZoom"; "required": false; }; "noPan": { "alias": "noPan"; "required": false; }; "staticMoving": { "alias": "staticMoving"; "required": false; }; "dynamicDampingFactor": { "alias": "dynamicDampingFactor"; "required": false; }; "minDistance": { "alias": "minDistance"; "required": false; }; "maxDistance": { "alias": "maxDistance"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "maxZoom": { "alias": "maxZoom"; "required": false; }; "keys": { "alias": "keys"; "required": false; }; "mouseButtons": { "alias": "mouseButtons"; "required": false; }; "target": { "alias": "target"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThTubeGeometry<T extends TubeGeometry = TubeGeometry, TARGS = [
    path?: Curve<Vector3$1>,
    tubularSegments?: number,
    radius?: number,
    radialSegments?: number,
    closed?: boolean
]> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<TubeGeometry>;
    get type(): (string | 'TubeGeometry') | undefined;
    get parameters(): {
        readonly path: Curve<Vector3$1>;
        readonly tubularSegments: number;
        readonly radius: number;
        readonly radialSegments: number;
        readonly closed: boolean;
    } | undefined;
    set tangents(value: Vector3$1[]);
    get tangents(): Vector3$1[] | undefined;
    set normals(value: Vector3$1[]);
    get normals(): Vector3$1[] | undefined;
    set binormals(value: Vector3$1[]);
    get binormals(): Vector3$1[] | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTubeGeometry<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThTubeGeometry<any, any>, "th-tubeGeometry", never, { "tangents": { "alias": "tangents"; "required": false; }; "normals": { "alias": "normals"; "required": false; }; "binormals": { "alias": "binormals"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThUnrealBloomPass<T extends UnrealBloomPass = UnrealBloomPass, TARGS = [
    resolution: Vector2,
    strength: number,
    radius: number,
    threshold: number
]> extends ThPass<T, TARGS> {
    getType(): Type<UnrealBloomPass>;
    set resolution(value: Vector2 | [x: number, y: number]);
    get resolution(): Vector2 | undefined;
    set strength(value: number);
    get strength(): number | undefined;
    set radius(value: number);
    get radius(): number | undefined;
    set threshold(value: number);
    get threshold(): number | undefined;
    set clearColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get clearColor(): Color | undefined;
    set renderTargetsHorizontal(value: WebGLRenderTarget[]);
    get renderTargetsHorizontal(): WebGLRenderTarget[] | undefined;
    set renderTargetsVertical(value: WebGLRenderTarget[]);
    get renderTargetsVertical(): WebGLRenderTarget[] | undefined;
    set nMips(value: number);
    get nMips(): number | undefined;
    set renderTargetBright(value: WebGLRenderTarget);
    get renderTargetBright(): WebGLRenderTarget | undefined;
    set highPassUniforms(value: object);
    get highPassUniforms(): object | undefined;
    set materialHighPassFilter(value: ShaderMaterial);
    get materialHighPassFilter(): ShaderMaterial | undefined;
    set separableBlurMaterials(value: ShaderMaterial[]);
    get separableBlurMaterials(): ShaderMaterial[] | undefined;
    set compositeMaterial(value: ShaderMaterial);
    get compositeMaterial(): ShaderMaterial | undefined;
    set bloomTintColors(value: Vector3$1[]);
    get bloomTintColors(): Vector3$1[] | undefined;
    set copyUniforms(value: object);
    get copyUniforms(): object | undefined;
    set blendMaterial(value: ShaderMaterial);
    get blendMaterial(): ShaderMaterial | undefined;
    set oldClearColor(value: Color | [
        ...args: [color: ColorRepresentation] | [r: number, g: number, b: number]
    ]);
    get oldClearColor(): Color | undefined;
    set oldClearAlpha(value: number);
    get oldClearAlpha(): number | undefined;
    set basic(value: MeshBasicMaterial$1);
    get basic(): MeshBasicMaterial$1 | undefined;
    set fsQuad(value: FullScreenQuad);
    get fsQuad(): FullScreenQuad | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThUnrealBloomPass<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThUnrealBloomPass<any, any>, "th-unrealBloomPass", never, { "resolution": { "alias": "resolution"; "required": false; }; "strength": { "alias": "strength"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "threshold": { "alias": "threshold"; "required": false; }; "clearColor": { "alias": "clearColor"; "required": false; }; "renderTargetsHorizontal": { "alias": "renderTargetsHorizontal"; "required": false; }; "renderTargetsVertical": { "alias": "renderTargetsVertical"; "required": false; }; "nMips": { "alias": "nMips"; "required": false; }; "renderTargetBright": { "alias": "renderTargetBright"; "required": false; }; "highPassUniforms": { "alias": "highPassUniforms"; "required": false; }; "materialHighPassFilter": { "alias": "materialHighPassFilter"; "required": false; }; "separableBlurMaterials": { "alias": "separableBlurMaterials"; "required": false; }; "compositeMaterial": { "alias": "compositeMaterial"; "required": false; }; "bloomTintColors": { "alias": "bloomTintColors"; "required": false; }; "copyUniforms": { "alias": "copyUniforms"; "required": false; }; "blendMaterial": { "alias": "blendMaterial"; "required": false; }; "oldClearColor": { "alias": "oldClearColor"; "required": false; }; "oldClearAlpha": { "alias": "oldClearAlpha"; "required": false; }; "basic": { "alias": "basic"; "required": false; }; "fsQuad": { "alias": "fsQuad"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThVideoTexture<TVideo = HTMLVideoElement, T extends VideoTexture<TVideo> = VideoTexture<TVideo>, TARGS = [
    video: TVideo,
    mapping?: Mapping,
    wrapS?: Wrapping,
    wrapT?: Wrapping,
    magFilter?: MagnificationTextureFilter,
    minFilter?: MinificationTextureFilter,
    format?: PixelFormat,
    type?: TextureDataType,
    anisotropy?: number
]> extends ThTexture<TVideo, T, TARGS> {
    getType(): Type<VideoTexture<TVideo>>;
    get isVideoTexture(): true | undefined;
    set magFilter(value: MagnificationTextureFilter);
    get magFilter(): MagnificationTextureFilter | undefined;
    set minFilter(value: MinificationTextureFilter);
    get minFilter(): MinificationTextureFilter | undefined;
    set generateMipmaps(value: boolean);
    get generateMipmaps(): boolean | undefined;
    set needsUpdate(value: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<ThVideoTexture<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThVideoTexture<any, any, any>, "th-videoTexture", never, { "magFilter": { "alias": "magFilter"; "required": false; }; "minFilter": { "alias": "minFilter"; "required": false; }; "generateMipmaps": { "alias": "generateMipmaps"; "required": false; }; "needsUpdate": { "alias": "needsUpdate"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ThVideoFrameTexture<T extends VideoFrameTexture = VideoFrameTexture, TARGS = [
    mapping?: Mapping,
    wrapS?: Wrapping,
    wrapT?: Wrapping,
    magFilter?: MagnificationTextureFilter,
    minFilter?: MinificationTextureFilter,
    format?: PixelFormat,
    type?: TextureDataType,
    anisotropy?: number
]> extends ThVideoTexture<VideoFrame | {}, T, TARGS> {
    getType(): Type<VideoFrameTexture>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThVideoFrameTexture<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThVideoFrameTexture<any, any>, "th-videoFrameTexture", never, {}, {}, never, ["*"], true, never>;
}

declare class ThWireframeGeometry<TBufferGeometry extends BufferGeometry = BufferGeometry, T extends WireframeGeometry<TBufferGeometry> = WireframeGeometry<TBufferGeometry>, TARGS = TBufferGeometry> extends ThBufferGeometry<NormalBufferAttributes, BufferGeometryEventMap, T, TARGS> {
    getType(): Type<WireframeGeometry<TBufferGeometry>>;
    get type(): (string | 'WireframeGeometry') | undefined;
    get parameters(): {
        readonly geometry: TBufferGeometry;
    } | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThWireframeGeometry<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThWireframeGeometry<any, any, any>, "th-wireframeGeometry", never, {}, {}, never, ["*"], true, never>;
}

declare const enum RaycasterEvent {
    mouseEnter = "mouseEnter",
    mouseExit = "mouseExit",
    click = "click",
    pointerDown = "pointerDown",
    pointerUp = "pointerUp"
}
interface RaycasterEventMap {
    mouseEnter: {
        component: ThObject3D<three.Object3DEventMap & RaycasterEventMap>;
    };
    mouseExit: {
        component: ThObject3D<three.Object3DEventMap & RaycasterEventMap>;
    };
    click: {
        component: ThObject3D<three.Object3DEventMap & RaycasterEventMap>;
    };
    pointerDown: {
        component: ThObject3D<three.Object3DEventMap & RaycasterEventMap>;
    };
    pointerUp: {
        component: ThObject3D<three.Object3DEventMap & RaycasterEventMap>;
    };
}
declare class RaycasterService implements OnDestroy {
    private canvas?;
    private raycaster;
    private selected;
    private enabled;
    private camera?;
    private groups;
    private paused;
    private maxClickDistance;
    private static instanceCnt;
    /**
     * targets of the pointer down event
     */
    private pointerDownEvent?;
    readonly nid: number;
    constructor();
    ngOnDestroy(): void;
    private subscribe;
    private unsubscribe;
    enable(): void;
    disable(): void;
    pause(): void;
    resume(): void;
    get isEnabled(): boolean;
    init(camera: ThCamera, canvas: HTMLElement): void;
    addEventTarget(target: RaycasterEventDirective): void;
    removeEventTarget(target: RaycasterEventDirective): void;
    private onPointerMove;
    private onPointerDown;
    private onPointerUp;
    private isReady;
    private calcPointerDownUpDinstance;
    private getFirstIntersectedGroup;
    static ɵfac: i0.ɵɵFactoryDeclaration<RaycasterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RaycasterService>;
}

declare class ThCanvas extends ThView implements OnInit, AfterViewInit, AfterContentChecked {
    protected engServ: ThEngineService;
    protected raycaster: RaycasterService;
    protected animationLoop: ThAnimationLoopService;
    readonly elementRef: ElementRef<HTMLElement>;
    readonly isDevMode: typeof isDevMode;
    private static instanceCnt;
    readonly nid: number;
    /**
     * if true does not use the ThCanvas as view
     * this is esepcially usefull if you have multiple views
     * and want to iterate over all of them with *ngFor
     * use statically (before ngOnInit is triggered)
     */
    disableDefaultView: boolean;
    get obj(): this;
    set views(viewList: QueryList<ThView>);
    get rendererCanvas(): HTMLCanvasElement | undefined;
    constructor();
    ngAfterContentChecked(): void;
    ngAfterViewInit(): void;
    ngOnInit(): void;
    protected setViews(viewList?: QueryList<ThView>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCanvas, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThCanvas, "th-canvas", never, { "disableDefaultView": { "alias": "disableDefaultView"; "required": false; }; }, {}, ["views"], ["*"], true, never>;
}

declare abstract class ThLoader<TData = unknown, TUrl extends string | string[] = string> {
    abstract readonly clazz: Type<Loader<TData, TUrl>>;
    protected crossOrigin?: string;
    protected withCredentials?: boolean;
    setCrossOrigin(cors: string): void;
    setWithCredentials(credentials: boolean): void;
    createLoaderInstance(): Loader<TData, TUrl>;
}

declare abstract class ThCallbackLoaderService<TData = unknown, TUrl extends string | string[] = string> extends ThLoader<TData, TUrl> {
    load(...args: Parameters<Loader<TData, TUrl>['load']>): ReturnType<Loader<TData, TUrl>['load']>;
}
declare abstract class ThCallbackLoaderBasePipe<TData = unknown, TUrl extends string | string[] = string> implements PipeTransform {
    protected abstract service: ThCallbackLoaderService<TData, TUrl>;
    transform(...args: Parameters<Loader<TData, TUrl>['load']>): void;
}
declare abstract class ThCallbackLoaderBaseDirective<TData = unknown, TUrl extends string | string[] = string> implements OnInit {
    /**
     * Derived directive should inject the host object.
     */
    protected abstract host: {
        objRef: any;
    };
    /**
     * Derived directive should inject the (derived) service.
     */
    protected abstract service: ThCallbackLoaderService<TData, TUrl>;
    protected zone: NgZone;
    private initialized;
    private _url?;
    protected onLoaded$?: EventEmitter<ReturnType<Loader<TData, TUrl>['load']>>;
    protected onProgress$?: EventEmitter<ProgressEvent>;
    set url(url: TUrl | undefined);
    get url(): TUrl | undefined;
    get onLoaded(): EventEmitter<void>;
    get onProgress(): EventEmitter<ProgressEvent<EventTarget>>;
    ngOnInit(): void;
    protected load(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCallbackLoaderBaseDirective<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThCallbackLoaderBaseDirective<any, any>, never, never, { "url": { "alias": "url"; "required": false; }; }, { "onLoaded": "onLoaded"; "onProgress": "onProgress"; }, never, never, true, never>;
}

interface DRACODecoderConfig {
    type: 'js' | 'wasm';
}
declare class DRACOLoaderService extends ThCallbackLoaderService<BufferGeometry$1> {
    readonly clazz: typeof DRACOLoader;
    protected decoderPath: string;
    protected decoderConfig?: DRACODecoderConfig;
    protected workerLimit?: number;
    protected reuseInstance: boolean;
    protected instance?: DRACOLoader;
    setDecoderPath(path: string): void;
    setDecoderConfig(config: DRACODecoderConfig): void;
    setWorkerLimit(limit: number): void;
    setReuseInstance(reuse: boolean): void;
    createLoaderInstance(): DRACOLoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<DRACOLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DRACOLoaderService>;
}

interface LazyObject3DProxy<TEventMap extends Object3DEventMap = Object3DEventMap> extends Object3D<TEventMap> {
    readonly __isProxy?: boolean;
    objRef?: Object3D;
    applyToObject3D(real: Object3D): void;
}
declare function createLazyObject3DProxy<TEventMap extends Object3DEventMap = Object3DEventMap>(target?: Object3D<TEventMap>): LazyObject3DProxy<TEventMap>;
declare function isLazyObject3dProxy(object: Object3D | LazyObject3DProxy): object is LazyObject3DProxy;

type Awaited<T> = T extends PromiseLike<infer U> ? U : T;
declare abstract class ThAsyncLoaderService<TData = unknown, TUrl extends string | string[] = string> extends ThLoader<TData, TUrl> {
    load(...args: Parameters<Loader<TData, TUrl>['loadAsync']>): ReturnType<Loader<TData, TUrl>['loadAsync']>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThAsyncLoaderService<any, any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ThAsyncLoaderService<any, any>>;
}
declare abstract class ThAsyncLoaderBasePipe<TData = unknown, TUrl extends string | string[] = string> implements PipeTransform {
    protected abstract service: ThAsyncLoaderService<TData, TUrl>;
    private animationLoop;
    constructor();
    transform(...args: Parameters<Loader<TData, TUrl>['loadAsync']>): Promise<TData>;
}
declare abstract class ThAsyncLoaderBaseDirective<TData = unknown, TUrl extends string | string[] = string> implements OnInit {
    /**
     * injector function to get the host object reference.
     *
     * Override this method in dervied classes if you want to inject other host element types (e.g. ThBufferGeometry, etc.), default is ThOBject3D.
     * always implement as a function not as a fat arrow function, else it will not be available in the constructor.
     */
    protected injectHost(): {
        objRef: any;
    };
    /**
     * Derived directive should inject the (derived) service.
     */
    protected abstract service: ThAsyncLoaderService<TData, TUrl>;
    protected abstract getRefFromResponse(response: Awaited<ReturnType<Loader<TData, TUrl>['loadAsync']>>): any;
    protected zone: NgZone;
    protected animationLoop: ThAnimationLoopService;
    protected _host: {
        objRef: any;
    };
    protected initialized: boolean;
    protected _url?: Parameters<Loader<TData, TUrl>['loadAsync']>[0];
    protected onLoaded$?: EventEmitter<Awaited<ReturnType<Loader<TData, TUrl>['loadAsync']>>>;
    protected onProgress$?: EventEmitter<ProgressEvent>;
    protected proxy: LazyObject3DProxy;
    set url(url: Parameters<Loader<TData, TUrl>['loadAsync']>[0] | undefined);
    get url(): Parameters<Loader<TData, TUrl>["loadAsync"]>[0] | undefined;
    get onLoaded(): EventEmitter<TData>;
    get onProgress(): EventEmitter<ProgressEvent<EventTarget>>;
    constructor();
    ngOnInit(): void;
    protected load(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThAsyncLoaderBaseDirective<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThAsyncLoaderBaseDirective<any, any>, never, never, { "url": { "alias": "url"; "required": false; }; }, { "onLoaded": "onLoaded"; "onProgress": "onProgress"; }, never, never, true, never>;
}

/**
 * use this function to provide a MeshoptDecoder implementation to the GLTFLoaderService
 * @param decoder
 * @returns
 */
declare function provideMeshoptDecoder(decoder: typeof MeshoptDecoder): {
    provide: InjectionToken<{
        supported: boolean;
        ready: Promise<void>;
        decodeVertexBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, filter?: string) => void;
        decodeIndexBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array) => void;
        decodeIndexSequence: (target: Uint8Array, count: number, size: number, source: Uint8Array) => void;
        decodeGltfBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, mode: string, filter?: string) => void;
        useWorkers: (count: number) => void;
        decodeGltfBufferAsync: (count: number, size: number, source: Uint8Array, mode: string, filter?: string) => Promise<Uint8Array>;
    }>;
    useValue: {
        supported: boolean;
        ready: Promise<void>;
        decodeVertexBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, filter?: string) => void;
        decodeIndexBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array) => void;
        decodeIndexSequence: (target: Uint8Array, count: number, size: number, source: Uint8Array) => void;
        decodeGltfBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, mode: string, filter?: string) => void;
        useWorkers: (count: number) => void;
        decodeGltfBufferAsync: (count: number, size: number, source: Uint8Array, mode: string, filter?: string) => Promise<Uint8Array>;
    };
};
declare class GLTFLoaderService extends ThAsyncLoaderService<GLTF> {
    protected dracoLoaderService: DRACOLoaderService;
    protected meshoptDecoder: {
        supported: boolean;
        ready: Promise<void>;
        decodeVertexBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, filter?: string) => void;
        decodeIndexBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array) => void;
        decodeIndexSequence: (target: Uint8Array, count: number, size: number, source: Uint8Array) => void;
        decodeGltfBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, mode: string, filter?: string) => void;
        useWorkers: (count: number) => void;
        decodeGltfBufferAsync: (count: number, size: number, source: Uint8Array, mode: string, filter?: string) => Promise<Uint8Array>;
    } | null;
    clazz: typeof GLTFLoader;
    createLoaderInstance(): GLTFLoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<GLTFLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GLTFLoaderService>;
}
declare class ThGLTFLoaderPipe extends ThAsyncLoaderBasePipe<GLTF> implements PipeTransform {
    protected service: GLTFLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThGLTFLoaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThGLTFLoaderPipe, "loadGLTF", true>;
}
declare class ThGLTFLoaderDirective extends ThAsyncLoaderBaseDirective<GLTF> {
    protected service: GLTFLoaderService;
    protected getRefFromResponse(response: GLTF): three.Group<three.Object3DEventMap>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThGLTFLoaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThGLTFLoaderDirective, "[loadGLTF]", never, {}, {}, never, never, true, never>;
}

declare class OBJLoaderService extends ThAsyncLoaderService<Group> {
    clazz: typeof OBJLoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<OBJLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OBJLoaderService>;
}
declare class ThObjLoaderPipe extends ThAsyncLoaderBasePipe<Group> implements PipeTransform {
    protected service: OBJLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThObjLoaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThObjLoaderPipe, "loadObj", true>;
}
declare class ThObjLoaderDirective extends ThAsyncLoaderBaseDirective<Group> {
    protected service: OBJLoaderService;
    protected getRefFromResponse(response: Group): Group<three.Object3DEventMap>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThObjLoaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThObjLoaderDirective, "[loadObj]", never, {}, {}, never, never, true, never>;
}

declare class FBXLoaderService extends ThAsyncLoaderService<Group> {
    clazz: typeof FBXLoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<FBXLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FBXLoaderService>;
}
declare class ThFBXLoaderPipe extends ThAsyncLoaderBasePipe<Group> implements PipeTransform {
    protected service: FBXLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThFBXLoaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThFBXLoaderPipe, "loadFBX", true>;
}
declare class ThFBXLoaderDirective extends ThAsyncLoaderBaseDirective<Group> {
    protected service: FBXLoaderService;
    protected getRefFromResponse(response: Group): Group<three.Object3DEventMap>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThFBXLoaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThFBXLoaderDirective, "[loadFBX]", never, {}, {}, never, never, true, never>;
}

declare class PLYLoaderService extends ThAsyncLoaderService<BufferGeometry$1> {
    clazz: typeof PLYLoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<PLYLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PLYLoaderService>;
}
declare class ThPLYLoaderPipe extends ThAsyncLoaderBasePipe<BufferGeometry$1> implements PipeTransform {
    protected service: PLYLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPLYLoaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThPLYLoaderPipe, "loadPLY", true>;
}
declare class ThPLYLoaderDirective extends ThAsyncLoaderBaseDirective<BufferGeometry$1> {
    protected injectHost(): ThBufferGeometry<three.NormalOrGLBufferAttributes, three.BufferGeometryEventMap, BufferGeometry$1<three.NormalOrGLBufferAttributes, three.BufferGeometryEventMap>, unknown>;
    protected service: PLYLoaderService;
    protected getRefFromResponse(response: BufferGeometry$1): BufferGeometry$1<three.NormalBufferAttributes, three.BufferGeometryEventMap>;
    protected load(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPLYLoaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThPLYLoaderDirective, "[loadPLY]", never, {}, {}, never, never, true, never>;
}

/**
 * constructs a color of it's constructor parameters
 */
declare class ColorPipe implements PipeTransform {
    transform(args: ColorRepresentation | [r: number, g: number, b: number]): Color;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ColorPipe, "color", true>;
}

/**
 * transform arrays to vectors
 */
declare class Vector2Pipe implements PipeTransform {
    transform(args: ConstructorParameters<typeof Vector2>): Vector2;
    static ɵfac: i0.ɵɵFactoryDeclaration<Vector2Pipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<Vector2Pipe, "vector2", true>;
}
declare class Vector3Pipe implements PipeTransform {
    transform(args: ConstructorParameters<typeof Vector3>): Vector3;
    static ɵfac: i0.ɵɵFactoryDeclaration<Vector3Pipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<Vector3Pipe, "vector3", true>;
}
declare class Vector4Pipe implements PipeTransform {
    transform(args: ConstructorParameters<typeof Vector4>): Vector4;
    static ɵfac: i0.ɵɵFactoryDeclaration<Vector4Pipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<Vector4Pipe, "vector4", true>;
}

/**
 * create a clone of any "cloneable" three.js class (or from it's ngx-three warpper)
 */
declare class ClonePipe implements PipeTransform {
    transform<T extends {
        clone(): T;
    }>(value?: ThWrapperBase<T, any> | T | null): T | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClonePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ClonePipe, "clone", true>;
}

declare class FogPipe implements PipeTransform {
    transform(args: ConstructorParameters<typeof Fog$1>): Fog$1;
    static ɵfac: i0.ɵɵFactoryDeclaration<FogPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FogPipe, "fog", true>;
}

declare class BindPipe implements PipeTransform {
    transform(methodToBind: (...anyArgs: unknown[]) => unknown, instance: unknown): (...anyArgs: unknown[]) => unknown;
    static ɵfac: i0.ɵɵFactoryDeclaration<BindPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<BindPipe, "bind", true>;
}

/**
 * creates a plane from a normal vector3 and a constant:
 * https://threejs.org/docs/#api/en/math/Plane
 */
declare class PlanePipe implements PipeTransform {
    transform(normal: [number, number?, number?], constant?: number): Plane$1;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlanePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PlanePipe, "plane", true>;
}

declare class StatsDirective implements OnInit, OnDestroy {
    private engineService;
    private canvas;
    private stats;
    private renderSubscription?;
    constructor();
    ngOnDestroy(): void;
    ngOnInit(): void;
    set thStats(enabled: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<StatsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StatsDirective, "[thStats]", never, { "thStats": { "alias": "thStats"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ThRenderDirective {
    private engineService;
    private animationLoopService;
    get beforeRender(): rxjs.Observable<ngx_three.RenderState>;
    get onResize(): rxjs.Observable<{
        width: number;
        height: number;
    }>;
    set renderOnDemand(onDemand: boolean);
    get renderOnDemand(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThRenderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThRenderDirective, "[beforeRender], [onResize], [renderOnDemand]", never, { "renderOnDemand": { "alias": "renderOnDemand"; "required": false; }; }, { "beforeRender": "beforeRender"; "onResize": "onResize"; }, never, never, true, never>;
}

declare class TextureLoaderService extends ThCallbackLoaderService<Texture$1> {
    clazz: typeof TextureLoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<TextureLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TextureLoaderService>;
}
declare class ThTextureLoaderPipe extends ThCallbackLoaderBasePipe<Texture$1> implements PipeTransform {
    protected service: TextureLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTextureLoaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThTextureLoaderPipe, "loadTexture", true>;
}
declare class ThTextureLoaderDirective extends ThCallbackLoaderBaseDirective<Texture$1> {
    protected host: ThTexture<Texture$1<unknown>, Texture$1<Texture$1<unknown>>, [image?: Texture$1<unknown> | undefined, mapping?: three.Mapping | undefined, wrapS?: three.Wrapping | undefined, wrapT?: three.Wrapping | undefined, magFilter?: three.MagnificationTextureFilter | undefined, minFilter?: three.MinificationTextureFilter | undefined, format?: three.PixelFormat | undefined, type?: three.TextureDataType | undefined, anisotropy?: number | undefined, colorSpace?: three.ColorSpace | undefined] | [image: Texture$1<unknown>, mapping: three.Mapping, wrapS: three.Wrapping, wrapT: three.Wrapping, magFilter: three.MagnificationTextureFilter, minFilter: three.MinificationTextureFilter, format: three.PixelFormat, type: three.TextureDataType, anisotropy: number]>;
    protected service: TextureLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTextureLoaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThTextureLoaderDirective, "[loadTexture]", never, {}, {}, never, never, true, never>;
}

declare class CubeTextureLoaderService extends ThCallbackLoaderService<CubeTexture$1, string[]> {
    clazz: typeof CubeTextureLoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<CubeTextureLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CubeTextureLoaderService>;
}
declare class ThCubeTextureLoaderPipe extends ThCallbackLoaderBasePipe<CubeTexture$1, string[]> implements PipeTransform {
    protected service: CubeTextureLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCubeTextureLoaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThCubeTextureLoaderPipe, "loadCubeTexture", true>;
}
declare class ThCubeTextureLoaderDirective extends ThCallbackLoaderBaseDirective<CubeTexture$1, string[]> {
    protected host: ThTexture<Texture$1<unknown>, Texture$1<Texture$1<unknown>>, [image?: Texture$1<unknown> | undefined, mapping?: three.Mapping | undefined, wrapS?: three.Wrapping | undefined, wrapT?: three.Wrapping | undefined, magFilter?: three.MagnificationTextureFilter | undefined, minFilter?: three.MinificationTextureFilter | undefined, format?: three.PixelFormat | undefined, type?: three.TextureDataType | undefined, anisotropy?: number | undefined, colorSpace?: three.ColorSpace | undefined] | [image: Texture$1<unknown>, mapping: three.Mapping, wrapS: three.Wrapping, wrapT: three.Wrapping, magFilter: three.MagnificationTextureFilter, minFilter: three.MinificationTextureFilter, format: three.PixelFormat, type: three.TextureDataType, anisotropy: number]>;
    protected service: CubeTextureLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThCubeTextureLoaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThCubeTextureLoaderDirective, "[loadCubeTexture]", never, {}, {}, never, never, true, never>;
}

declare class DDSLoaderService extends ThCallbackLoaderService<CompressedTexture> {
    clazz: typeof DDSLoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<DDSLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DDSLoaderService>;
}
declare class ThDDSLoaderPipe extends ThCallbackLoaderBasePipe<CompressedTexture> implements PipeTransform {
    protected service: DDSLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThDDSLoaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThDDSLoaderPipe, "loadDDSTexture", true>;
}
declare class ThDDSLoaderDirective extends ThCallbackLoaderBaseDirective<CompressedTexture> {
    protected host: ThCompressedTexture<unknown, CompressedTexture<unknown>, unknown>;
    protected service: DDSLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThDDSLoaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThDDSLoaderDirective, "[loadDDSTexture]", never, {}, {}, never, never, true, never>;
}

declare class KTXLoaderService extends ThCallbackLoaderService<CompressedTexture> {
    clazz: typeof KTXLoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<KTXLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<KTXLoaderService>;
}
declare class ThKTXLoaderPipe extends ThCallbackLoaderBasePipe<CompressedTexture> implements PipeTransform {
    protected service: KTXLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThKTXLoaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThKTXLoaderPipe, "loadKTXTexture", true>;
}
declare class ThKTXLoaderDirective extends ThCallbackLoaderBaseDirective<CompressedTexture> {
    protected host: ThCompressedTexture<unknown, CompressedTexture<unknown>, unknown>;
    protected service: KTXLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThKTXLoaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThKTXLoaderDirective, "[loadKTXTexture]", never, {}, {}, never, never, true, never>;
}

declare class KTX2LoaderService extends ThCallbackLoaderService<CompressedTexture> {
    readonly clazz: typeof KTX2Loader;
    protected transcoderPath: string;
    setDecoderPath(path: string): void;
    createLoaderInstance(): KTX2Loader;
    static ɵfac: i0.ɵɵFactoryDeclaration<KTX2LoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<KTX2LoaderService>;
}
declare class ThKTX2LoaderPipe extends ThCallbackLoaderBasePipe<CompressedTexture> implements PipeTransform {
    protected service: KTX2LoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThKTX2LoaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThKTX2LoaderPipe, "loadKTX2Texture", true>;
}
declare class ThKTX2LoaderDirective extends ThCallbackLoaderBaseDirective<CompressedTexture> {
    protected host: ThTexture<unknown, three.Texture<unknown>, unknown>;
    protected service: KTX2LoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThKTX2LoaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThKTX2LoaderDirective, "[loadKTX2Texture]", never, {}, {}, never, never, true, never>;
}

declare class PVRLoaderService extends ThCallbackLoaderService<CompressedTexture> {
    clazz: typeof PVRLoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<PVRLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PVRLoaderService>;
}
declare class ThPVRLoaderPipe extends ThCallbackLoaderBasePipe<CompressedTexture> implements PipeTransform {
    protected service: PVRLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPVRLoaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThPVRLoaderPipe, "loadPVRTexture", true>;
}
declare class ThPVRLoaderDirective extends ThCallbackLoaderBaseDirective<CompressedTexture> {
    protected host: ThCompressedTexture<unknown, CompressedTexture<unknown>, unknown>;
    protected service: PVRLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThPVRLoaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThPVRLoaderDirective, "[loadPVRTexture]", never, {}, {}, never, never, true, never>;
}

declare class EXRLoaderService extends ThCallbackLoaderService<DataTexture> {
    clazz: typeof EXRLoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<EXRLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EXRLoaderService>;
}
declare class ThEXRLoaderPipe extends ThCallbackLoaderBasePipe<DataTexture> implements PipeTransform {
    protected service: EXRLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThEXRLoaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThEXRLoaderPipe, "loadEXRTexture", true>;
}
declare class ThEXRLoaderDirective extends ThCallbackLoaderBaseDirective<DataTexture> {
    protected host: ThDataTexture<DataTexture, unknown>;
    protected service: EXRLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThEXRLoaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThEXRLoaderDirective, "[loadEXRTexture]", never, {}, {}, never, never, true, never>;
}

declare class RGBELoaderService extends ThCallbackLoaderService<DataTexture> {
    clazz: typeof RGBELoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<RGBELoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RGBELoaderService>;
}
declare class ThRGBELoaderPipe extends ThCallbackLoaderBasePipe<DataTexture> implements PipeTransform {
    protected service: RGBELoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThRGBELoaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThRGBELoaderPipe, "loadRGBETexture", true>;
}
declare class ThRGBELoaderDirective extends ThCallbackLoaderBaseDirective<DataTexture> {
    protected host: ThDataTexture<DataTexture, unknown>;
    protected service: RGBELoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThRGBELoaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThRGBELoaderDirective, "[loadRGBETexture]", never, {}, {}, never, never, true, never>;
}

declare class TGALoaderService extends ThCallbackLoaderService<DataTexture> {
    clazz: typeof TGALoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<TGALoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TGALoaderService>;
}
declare class ThTGALoaderPipe extends ThCallbackLoaderBasePipe<DataTexture> implements PipeTransform {
    protected service: TGALoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTGALoaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThTGALoaderPipe, "loadTGATexture", true>;
}
declare class ThTGALoaderDirective extends ThCallbackLoaderBaseDirective<DataTexture> {
    protected host: ThDataTexture<DataTexture, unknown>;
    protected service: TGALoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThTGALoaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThTGALoaderDirective, "[loadTGATexture]", never, {}, {}, never, never, true, never>;
}

declare class UltraHDRLoaderService extends ThCallbackLoaderService<DataTexture> {
    clazz: typeof UltraHDRLoader;
    static ɵfac: i0.ɵɵFactoryDeclaration<UltraHDRLoaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UltraHDRLoaderService>;
}
declare class ThUltraHDRLoaderPipe extends ThCallbackLoaderBasePipe<DataTexture> implements PipeTransform {
    protected service: UltraHDRLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThUltraHDRLoaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ThUltraHDRLoaderPipe, "loadUltraHDRTexture", true>;
}
declare class ThUltraHDRLoaderDirective extends ThCallbackLoaderBaseDirective<DataTexture> {
    protected host: ThDataTexture<DataTexture, unknown>;
    protected service: UltraHDRLoaderService;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThUltraHDRLoaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThUltraHDRLoaderDirective, "[loadUltraHDRTexture]", never, {}, {}, never, never, true, never>;
}

declare class RefByIdDirective implements OnDestroy {
    private host;
    private parent;
    protected subscription?: Subscription;
    protected parentObj?: Object3D;
    protected id?: string;
    constructor();
    set refById(id: string | undefined);
    applyRef(): void;
    protected findById(parentObj: Object3D, id: string): Object3D | undefined;
    protected setRef(host: ThObject3D, ref: Object3D): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RefByIdDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RefByIdDirective, "[refById]", never, { "refById": { "alias": "refById"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LODLevelDirective implements OnInit, OnChanges, OnDestroy {
    lod: ThLOD<three.Object3DEventMap, three.LOD<three.Object3DEventMap>, unknown>;
    target: ThObject3D<three.Object3DEventMap, three.Object3D<three.Object3DEventMap>, unknown>;
    lodLevel?: {
        distance?: number;
        hysteresis?: number;
    };
    ngOnInit(): void;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    setLevel(): void;
    removeLevel(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LODLevelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LODLevelDirective, "[lodLevel]", never, { "lodLevel": { "alias": "lodLevel"; "required": false; }; }, {}, never, never, true, never>;
}

type MarkFunctionProperties<Component> = {
    [Key in keyof Component]: Component[Key] extends Function ? never : Key;
};
type ExcludeFunctionPropertyNames<T> = MarkFunctionProperties<T>[keyof T];
type ExcludeFunctions<T> = Pick<T, ExcludeFunctionPropertyNames<T>>;
type NgChanges<Component, Props = ExcludeFunctions<Component>> = {
    [Key in keyof Props]?: {
        previousValue: Props[Key];
        currentValue: Props[Key];
        firstChange: boolean;
        isFirstChange(): boolean;
    };
};

/**
 * The following code is ported from pmndrs/drei and adapted to work with Angular and ngx-three
 * Many thanks to pmndrs/drei at its contributors!
 */

declare function defaultCalculatePosition(el: Object3D, camera: Camera, size: {
    width: number;
    height: number;
}): number[];
type CalculatePosition = typeof defaultCalculatePosition;
type PointerEventsProperties = 'auto' | 'none' | 'visiblePainted' | 'visibleFill' | 'visibleStroke' | 'visible' | 'painted' | 'fill' | 'stroke' | 'all' | 'inherit';
/**
 * A port of the pmndrs/drei Html component
 *
 * Add Html content to any three.js object3d node
 */
declare class HtmlComponent extends ThGroup implements OnInit, OnDestroy, OnChanges, AfterViewInit {
    private view;
    protected readonly DoubleSide: 2;
    protected readonly FRAGMENT_SHADER = "\nvoid main() {\n  gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);\n}\n";
    protected readonly VERTEX_SHADER = "\n/*\n  This shader is from the THREE's SpriteMaterial.\n  We need to turn the backing plane into a Sprite\n  (make it always face the camera) if \"transfrom\" \n  is false. \n*/\n#include <common>\nvoid main() {\n  vec2 center = vec2(0., 1.);\n  float rotation = 0.0;\n  \n  // This is somewhat arbitrary, but it seems to work well\n  // Need to figure out how to derive this dynamically if it even matters\n  float size = 0.03;\n  vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n  vec2 scale;\n  scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n  scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n  bool isPerspective = isPerspectiveMatrix( projectionMatrix );\n  if ( isPerspective ) scale *= - mvPosition.z;\n  vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale * size;\n  vec2 rotatedPosition;\n  rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n  rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n  mvPosition.xy += rotatedPosition;\n  gl_Position = projectionMatrix * mvPosition;\n}\n";
    prepend: boolean;
    center: boolean;
    fullscreen: boolean;
    eps: number;
    portal?: HTMLElement;
    distanceFactor?: number;
    sprite: boolean;
    transform: boolean;
    zIndexRange: [number, number];
    style?: Partial<CSSStyleDeclaration>;
    className?: string;
    occlude?: Object3D[] | ThObject3D[] | boolean;
    onOcclude: EventEmitter<boolean>;
    /**
     * Override default positioning function. [ignored in transform mode]
     */
    calculatePosition: CalculatePosition;
    as: string;
    wrapperClass?: string;
    pointerEvents: PointerEventsProperties;
    protected transformInnerStyles: {
        position: string;
        pointerEvents: PointerEventsProperties;
    };
    protected styles: Record<string, any> | null;
    private oldZoom;
    private oldPosition;
    private notOccluded;
    private transformOuterRef?;
    private transformInnerRef?;
    private el?;
    private target?;
    private frameSubscription?;
    private raycaster;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    protected onResize(): void;
    ngOnChanges(changes: NgChanges<HtmlComponent>): void;
    private appendElement;
    onFrame(): void;
    ngOnDestroy(): void;
    private computeStyles;
    private computeInnerStyles;
    private getSize;
    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HtmlComponent, "th-html", never, { "prepend": { "alias": "prepend"; "required": false; }; "center": { "alias": "center"; "required": false; }; "fullscreen": { "alias": "fullscreen"; "required": false; }; "portal": { "alias": "portal"; "required": false; }; "distanceFactor": { "alias": "distanceFactor"; "required": false; }; "sprite": { "alias": "sprite"; "required": false; }; "transform": { "alias": "transform"; "required": false; }; "zIndexRange": { "alias": "zIndexRange"; "required": false; }; "style": { "alias": "style"; "required": false; }; "className": { "alias": "className"; "required": false; }; "occlude": { "alias": "occlude"; "required": false; }; "calculatePosition": { "alias": "calculatePosition"; "required": false; }; "as": { "alias": "as"; "required": false; }; "wrapperClass": { "alias": "wrapperClass"; "required": false; }; "pointerEvents": { "alias": "pointerEvents"; "required": false; }; }, { "onOcclude": "onOcclude"; }, never, ["*"], true, never>;
}
declare const VERTEX_SHADER = "\n/*\n  This shader is from the THREE's SpriteMaterial.\n  We need to turn the backing plane into a Sprite\n  (make it always face the camera) if \"transfrom\" \n  is false. \n*/\n#include <common>\nvoid main() {\n  vec2 center = vec2(0., 1.);\n  float rotation = 0.0;\n  \n  // This is somewhat arbitrary, but it seems to work well\n  // Need to figure out how to derive this dynamically if it even matters\n  float size = 0.03;\n  vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n  vec2 scale;\n  scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n  scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n  bool isPerspective = isPerspectiveMatrix( projectionMatrix );\n  if ( isPerspective ) scale *= - mvPosition.z;\n  vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale * size;\n  vec2 rotatedPosition;\n  rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n  rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n  mvPosition.xy += rotatedPosition;\n  gl_Position = projectionMatrix * mvPosition;\n}\n";
declare const FRAGMENT_SHADER = "\nvoid main() {\n  gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);\n}\n";

declare class NgxThreeGeneratedModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxThreeGeneratedModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxThreeGeneratedModule, never, [typeof ThTransformControlsGen, typeof ThTransformControls, typeof ThArcballControls, typeof ThDragControls, typeof ThFirstPersonControls, typeof ThFlyControls, typeof ThOrbitControls, typeof ThMapControls, typeof ThPointerLockControls, typeof ThTrackballControls, typeof ThAudio, typeof ThAudioListener, typeof ThPositionalAudio, typeof ThArrayCamera, typeof ThCamera, typeof ThCubeCamera, typeof ThOrthographicCamera, typeof ThPerspectiveCamera, typeof ThStereoCamera, typeof ThObject3D, typeof ThArrowHelper, typeof ThAxesHelper, typeof ThBox3Helper, typeof ThBoxHelper, typeof ThCameraHelper, typeof ThDirectionalLightHelper, typeof ThGridHelper, typeof ThHemisphereLightHelper, typeof ThPlaneHelper, typeof ThPointLightHelper, typeof ThPolarGridHelper, typeof ThSkeletonHelper, typeof ThSpotLightHelper, typeof ThAmbientLight, typeof ThDirectionalLight, typeof ThHemisphereLight, typeof ThLightProbe, typeof ThPointLight, typeof ThRectAreaLight, typeof ThSpotLight, typeof ThBatchedMesh, typeof ThBone, typeof ThGroup, typeof ThInstancedMesh, typeof ThLine, typeof ThLineLoop, typeof ThLineSegments, typeof ThLOD, typeof ThMesh, typeof ThPoints, typeof ThSkinnedMesh, typeof ThSprite, typeof ThScene, typeof ThCSS3DObjectGen, typeof ThCSS3DObject, typeof ThCSS2DObjectGen, typeof ThCSS2DObject, typeof ThLineBasicMaterial, typeof ThLineDashedMaterial, typeof ThMaterial, typeof ThMeshBasicMaterial, typeof ThMeshDepthMaterial, typeof ThMeshDistanceMaterial, typeof ThMeshLambertMaterial, typeof ThMeshMatcapMaterial, typeof ThMeshNormalMaterial, typeof ThMeshPhongMaterial, typeof ThMeshPhysicalMaterial, typeof ThMeshStandardMaterial, typeof ThMeshToonMaterial, typeof ThPointsMaterial, typeof ThRawShaderMaterial, typeof ThShaderMaterial, typeof ThShadowMaterial, typeof ThSpriteMaterial, typeof ThBufferGeometry, typeof ThInstancedBufferGeometry, typeof ThBoxGeometry, typeof ThCapsuleGeometry, typeof ThCircleGeometry, typeof ThConeGeometry, typeof ThCylinderGeometry, typeof ThDodecahedronGeometry, typeof ThEdgesGeometry, typeof ThExtrudeGeometry, typeof ThIcosahedronGeometry, typeof ThLatheGeometry, typeof ThOctahedronGeometry, typeof ThPlaneGeometry, typeof ThPolyhedronGeometry, typeof ThRingGeometry, typeof ThShapeGeometry, typeof ThSphereGeometry, typeof ThTetrahedronGeometry, typeof ThTorusGeometry, typeof ThTorusKnotGeometry, typeof ThTubeGeometry, typeof ThWireframeGeometry, typeof ThBoxLineGeometry, typeof ThConvexGeometry, typeof ThDecalGeometry, typeof ThParametricGeometry, typeof ThRoundedBoxGeometry, typeof ThTeapotGeometry, typeof ThTextGeometry, typeof ThPass, typeof ThEffectComposerGen, typeof ThEffectComposer, typeof ThAfterimagePass, typeof ThBloomPass, typeof ThBokehPass, typeof ThClearPass, typeof ThCubeTexturePass, typeof ThDotScreenPass, typeof ThFilmPass, typeof ThGlitchPass, typeof ThHalftonePass, typeof ThLUTPass, typeof ThMaskPass, typeof ThClearMaskPass, typeof ThOutlinePass, typeof ThOutputPass, typeof ThRenderPassGen, typeof ThRenderPass, typeof ThSAOPass, typeof ThSMAAPass, typeof ThSSAARenderPass, typeof ThSSAOPass, typeof ThSSRPass, typeof ThSavePass, typeof ThShaderPass, typeof ThTAARenderPass, typeof ThTexturePass, typeof ThUnrealBloomPass, typeof ThCanvasTexture, typeof ThCompressedArrayTexture, typeof ThCompressedCubeTexture, typeof ThCompressedTexture, typeof ThCubeTexture, typeof ThData3DTexture, typeof ThDataArrayTexture, typeof ThDataTexture, typeof ThDepthTexture, typeof ThExternalTexture, typeof ThFramebufferTexture, typeof ThTexture, typeof ThVideoFrameTexture, typeof ThVideoTexture], [typeof ThTransformControlsGen, typeof ThTransformControls, typeof ThArcballControls, typeof ThDragControls, typeof ThFirstPersonControls, typeof ThFlyControls, typeof ThOrbitControls, typeof ThMapControls, typeof ThPointerLockControls, typeof ThTrackballControls, typeof ThAudio, typeof ThAudioListener, typeof ThPositionalAudio, typeof ThArrayCamera, typeof ThCamera, typeof ThCubeCamera, typeof ThOrthographicCamera, typeof ThPerspectiveCamera, typeof ThStereoCamera, typeof ThObject3D, typeof ThArrowHelper, typeof ThAxesHelper, typeof ThBox3Helper, typeof ThBoxHelper, typeof ThCameraHelper, typeof ThDirectionalLightHelper, typeof ThGridHelper, typeof ThHemisphereLightHelper, typeof ThPlaneHelper, typeof ThPointLightHelper, typeof ThPolarGridHelper, typeof ThSkeletonHelper, typeof ThSpotLightHelper, typeof ThAmbientLight, typeof ThDirectionalLight, typeof ThHemisphereLight, typeof ThLightProbe, typeof ThPointLight, typeof ThRectAreaLight, typeof ThSpotLight, typeof ThBatchedMesh, typeof ThBone, typeof ThGroup, typeof ThInstancedMesh, typeof ThLine, typeof ThLineLoop, typeof ThLineSegments, typeof ThLOD, typeof ThMesh, typeof ThPoints, typeof ThSkinnedMesh, typeof ThSprite, typeof ThScene, typeof ThCSS3DObjectGen, typeof ThCSS3DObject, typeof ThCSS2DObjectGen, typeof ThCSS2DObject, typeof ThLineBasicMaterial, typeof ThLineDashedMaterial, typeof ThMaterial, typeof ThMeshBasicMaterial, typeof ThMeshDepthMaterial, typeof ThMeshDistanceMaterial, typeof ThMeshLambertMaterial, typeof ThMeshMatcapMaterial, typeof ThMeshNormalMaterial, typeof ThMeshPhongMaterial, typeof ThMeshPhysicalMaterial, typeof ThMeshStandardMaterial, typeof ThMeshToonMaterial, typeof ThPointsMaterial, typeof ThRawShaderMaterial, typeof ThShaderMaterial, typeof ThShadowMaterial, typeof ThSpriteMaterial, typeof ThBufferGeometry, typeof ThInstancedBufferGeometry, typeof ThBoxGeometry, typeof ThCapsuleGeometry, typeof ThCircleGeometry, typeof ThConeGeometry, typeof ThCylinderGeometry, typeof ThDodecahedronGeometry, typeof ThEdgesGeometry, typeof ThExtrudeGeometry, typeof ThIcosahedronGeometry, typeof ThLatheGeometry, typeof ThOctahedronGeometry, typeof ThPlaneGeometry, typeof ThPolyhedronGeometry, typeof ThRingGeometry, typeof ThShapeGeometry, typeof ThSphereGeometry, typeof ThTetrahedronGeometry, typeof ThTorusGeometry, typeof ThTorusKnotGeometry, typeof ThTubeGeometry, typeof ThWireframeGeometry, typeof ThBoxLineGeometry, typeof ThConvexGeometry, typeof ThDecalGeometry, typeof ThParametricGeometry, typeof ThRoundedBoxGeometry, typeof ThTeapotGeometry, typeof ThTextGeometry, typeof ThPass, typeof ThEffectComposerGen, typeof ThEffectComposer, typeof ThAfterimagePass, typeof ThBloomPass, typeof ThBokehPass, typeof ThClearPass, typeof ThCubeTexturePass, typeof ThDotScreenPass, typeof ThFilmPass, typeof ThGlitchPass, typeof ThHalftonePass, typeof ThLUTPass, typeof ThMaskPass, typeof ThClearMaskPass, typeof ThOutlinePass, typeof ThOutputPass, typeof ThRenderPassGen, typeof ThRenderPass, typeof ThSAOPass, typeof ThSMAAPass, typeof ThSSAARenderPass, typeof ThSSAOPass, typeof ThSSRPass, typeof ThSavePass, typeof ThShaderPass, typeof ThTAARenderPass, typeof ThTexturePass, typeof ThUnrealBloomPass, typeof ThCanvasTexture, typeof ThCompressedArrayTexture, typeof ThCompressedCubeTexture, typeof ThCompressedTexture, typeof ThCubeTexture, typeof ThData3DTexture, typeof ThDataArrayTexture, typeof ThDataTexture, typeof ThDepthTexture, typeof ThExternalTexture, typeof ThFramebufferTexture, typeof ThTexture, typeof ThVideoFrameTexture, typeof ThVideoTexture]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgxThreeGeneratedModule>;
}

declare class NgxThreeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxThreeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxThreeModule, never, [typeof ThCanvas, typeof ThView, typeof ThObjectBase, typeof ThMaterialBase, typeof ThWrapperBase, typeof ThGLTFLoaderDirective, typeof ThGLTFLoaderPipe, typeof ThObjLoaderPipe, typeof ThObjLoaderDirective, typeof ThFBXLoaderDirective, typeof ThFBXLoaderPipe, typeof ThPLYLoaderDirective, typeof ThPLYLoaderPipe, typeof RaycasterEventDirective, typeof ColorPipe, typeof Vector2Pipe, typeof Vector3Pipe, typeof Vector4Pipe, typeof ClonePipe, typeof FogPipe, typeof BindPipe, typeof PlanePipe, typeof StatsDirective, typeof ThRenderDirective, typeof ThTextureLoaderDirective, typeof ThTextureLoaderPipe, typeof ThCubeTextureLoaderDirective, typeof ThCubeTextureLoaderPipe, typeof ThDDSLoaderDirective, typeof ThDDSLoaderPipe, typeof ThKTXLoaderDirective, typeof ThKTXLoaderPipe, typeof ThKTX2LoaderDirective, typeof ThKTX2LoaderPipe, typeof ThPVRLoaderDirective, typeof ThPVRLoaderPipe, typeof ThEXRLoaderDirective, typeof ThEXRLoaderPipe, typeof ThRGBELoaderDirective, typeof ThRGBELoaderPipe, typeof ThTGALoaderDirective, typeof ThTGALoaderPipe, typeof ThUltraHDRLoaderDirective, typeof ThUltraHDRLoaderPipe, typeof RefByIdDirective, typeof RendererProviderDirective, typeof LODLevelDirective, typeof HtmlComponent, typeof NgxThreeGeneratedModule, typeof i34.CommonModule], [typeof NgxThreeGeneratedModule, typeof ThCanvas, typeof ThView, typeof ThGLTFLoaderDirective, typeof ThGLTFLoaderPipe, typeof ThObjLoaderDirective, typeof ThObjLoaderPipe, typeof ThFBXLoaderDirective, typeof ThFBXLoaderPipe, typeof ThPLYLoaderDirective, typeof ThPLYLoaderPipe, typeof RaycasterEventDirective, typeof ColorPipe, typeof Vector2Pipe, typeof Vector3Pipe, typeof Vector4Pipe, typeof ClonePipe, typeof FogPipe, typeof BindPipe, typeof PlanePipe, typeof ThRenderDirective, typeof StatsDirective, typeof ThTextureLoaderDirective, typeof ThTextureLoaderPipe, typeof ThCubeTextureLoaderDirective, typeof ThCubeTextureLoaderPipe, typeof ThDDSLoaderDirective, typeof ThDDSLoaderPipe, typeof ThKTXLoaderDirective, typeof ThKTXLoaderPipe, typeof ThKTX2LoaderDirective, typeof ThKTX2LoaderPipe, typeof ThPVRLoaderDirective, typeof ThPVRLoaderPipe, typeof ThEXRLoaderDirective, typeof ThEXRLoaderPipe, typeof ThRGBELoaderDirective, typeof ThRGBELoaderPipe, typeof ThTGALoaderDirective, typeof ThTGALoaderPipe, typeof ThUltraHDRLoaderDirective, typeof ThUltraHDRLoaderPipe, typeof RefByIdDirective, typeof RendererProviderDirective, typeof LODLevelDirective, typeof HtmlComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgxThreeModule>;
}

declare function createThProviderArray(cls: InstanceType<any>, baseCls: InstanceType<any>): void;
/**
 * usage:
 *
 * @Component({
 *  providers: createObj3DProviderArray(forwardRef(() => TheComponent)))
 * })
 * export class TheComponent {
 * ...
 * }
 * @param type the Object3D derived Class to be provided
 */
declare function createObj3DProviderArray(type: Type<any>): {
    provide: typeof ThObject3D;
    useExisting: Type<any>;
}[];
declare function createCameraProviderArray(type: Type<any>): ({
    provide: typeof ThObject3D;
    useExisting: Type<any>;
} | {
    provide: typeof ThCamera;
    useExisting: Type<any>;
})[];

interface BakedMesh {
    geometry: BufferGeometry$1;
    material: Material$1;
}
declare function bakeSceneMeshes(source: Object3D): BakedMesh[];
declare function buildInstancedScene(source: Object3D, instanceCount: number): Object3D;
declare function applyInstanceMatrices(instancedScene: Object3D, matrices: Matrix4$1[]): void;
declare function updateInstanceMatrix(instancedScene: Object3D, instanceIndex: number, matrix: Matrix4$1): void;
declare function readInstanceMatrices(instancedScene: Object3D): Matrix4$1[][];

export { BindPipe, CSS2D_RENDERER, CSS3D_RENDERER, ClonePipe, ColorPipe, CubeTextureLoaderService, DDSLoaderService, DRACOLoaderService, EXRLoaderService, FBXLoaderService, FRAGMENT_SHADER, FogPipe, GLTFLoaderService, HOST_ELEMENT, HtmlComponent, KTX2LoaderService, KTXLoaderService, LODLevelDirective, NgxThreeGeneratedModule, NgxThreeModule, OBJLoaderService, PLYLoaderService, PVRLoaderService, PlanePipe, RENDERER_PROVIDERS, RGBELoaderService, RaycasterEventDirective, RefByIdDirective, RendererProviderDirective, StatsDirective, TGALoaderService, TextureLoaderService, ThAfterimagePass, ThAmbientLight, ThAnimationLoopService, ThArcballControls, ThArrayCamera, ThArrowHelper, ThAsyncLoaderBaseDirective, ThAsyncLoaderBasePipe, ThAsyncLoaderService, ThAudio, ThAudioListener, ThAxesHelper, ThBatchedMesh, ThBloomPass, ThBokehPass, ThBone, ThBox3Helper, ThBoxGeometry, ThBoxHelper, ThBoxLineGeometry, ThBufferGeometry, ThCSS2DObject, ThCSS2DObjectGen, ThCSS3DObject, ThCSS3DObjectGen, ThCallbackLoaderBaseDirective, ThCallbackLoaderBasePipe, ThCallbackLoaderService, ThCamera, ThCameraHelper, ThCanvas, ThCanvasTexture, ThCapsuleGeometry, ThCircleGeometry, ThClearMaskPass, ThClearPass, ThCompressedArrayTexture, ThCompressedCubeTexture, ThCompressedTexture, ThConeGeometry, ThConvexGeometry, ThCubeCamera, ThCubeTexture, ThCubeTextureLoaderDirective, ThCubeTextureLoaderPipe, ThCubeTexturePass, ThCylinderGeometry, ThDDSLoaderDirective, ThDDSLoaderPipe, ThData3DTexture, ThDataArrayTexture, ThDataTexture, ThDecalGeometry, ThDepthTexture, ThDirectionalLight, ThDirectionalLightHelper, ThDodecahedronGeometry, ThDotScreenPass, ThDragControls, ThEXRLoaderDirective, ThEXRLoaderPipe, ThEdgesGeometry, ThEffectComposer, ThEffectComposerGen, ThEngineService, ThExternalTexture, ThExtrudeGeometry, ThFBXLoaderDirective, ThFBXLoaderPipe, ThFilmPass, ThFirstPersonControls, ThFlyControls, ThFramebufferTexture, ThGLTFLoaderDirective, ThGLTFLoaderPipe, ThGlitchPass, ThGridHelper, ThGroup, ThHalftonePass, ThHemisphereLight, ThHemisphereLightHelper, ThIcosahedronGeometry, ThInstancedBufferGeometry, ThInstancedMesh, ThKTX2LoaderDirective, ThKTX2LoaderPipe, ThKTXLoaderDirective, ThKTXLoaderPipe, ThLOD, ThLUTPass, ThLatheGeometry, ThLight, ThLightProbe, ThLine, ThLineBasicMaterial, ThLineDashedMaterial, ThLineLoop, ThLineSegments, ThMapControls, ThMaskPass, ThMaterial, ThMesh, ThMeshBasicMaterial, ThMeshDepthMaterial, ThMeshDistanceMaterial, ThMeshLambertMaterial, ThMeshMatcapMaterial, ThMeshNormalMaterial, ThMeshPhongMaterial, ThMeshPhysicalMaterial, ThMeshStandardMaterial, ThMeshToonMaterial, ThObjLoaderDirective, ThObjLoaderPipe, ThObject3D, ThOctahedronGeometry, ThOrbitControls, ThOrthographicCamera, ThOutlinePass, ThOutputPass, ThPLYLoaderDirective, ThPLYLoaderPipe, ThPVRLoaderDirective, ThPVRLoaderPipe, ThParametricGeometry, ThPass, ThPerspectiveCamera, ThPlaneGeometry, ThPlaneHelper, ThPointLight, ThPointLightHelper, ThPointerLockControls, ThPoints, ThPointsMaterial, ThPolarGridHelper, ThPolyhedronGeometry, ThPositionalAudio, ThRGBELoaderDirective, ThRGBELoaderPipe, ThRawShaderMaterial, ThRectAreaLight, ThRenderDirective, ThRenderPass, ThRenderPassGen, ThRingGeometry, ThRoundedBoxGeometry, ThSAOPass, ThSMAAPass, ThSSAARenderPass, ThSSAOPass, ThSSRPass, ThSavePass, ThScene, ThShaderMaterial, ThShaderPass, ThShadowMaterial, ThShapeGeometry, ThSkeletonHelper, ThSkinnedMesh, ThSphereGeometry, ThSpotLight, ThSpotLightHelper, ThSprite, ThSpriteMaterial, ThStereoCamera, ThTAARenderPass, ThTGALoaderDirective, ThTGALoaderPipe, ThTeapotGeometry, ThTetrahedronGeometry, ThTextGeometry, ThTexture, ThTextureLoaderDirective, ThTextureLoaderPipe, ThTexturePass, ThTorusGeometry, ThTorusKnotGeometry, ThTrackballControls, ThTransformControls, ThTransformControlsGen, ThTubeGeometry, ThUltraHDRLoaderDirective, ThUltraHDRLoaderPipe, ThUnrealBloomPass, ThVideoFrameTexture, ThVideoTexture, ThView, ThWireframeGeometry, UltraHDRLoaderService, VERTEX_SHADER, Vector2Pipe, Vector3Pipe, Vector4Pipe, WEBGL_RENDERER, applyInstanceMatrices, bakeSceneMeshes, buildInstancedScene, createCameraProviderArray, createLazyObject3DProxy, createObj3DProviderArray, createThProviderArray, isLazyObject3dProxy, provideCSS2dRenderer, provideCSS3dRenderer, provideMeshoptDecoder, provideWebGLRenderer, provideWebGPURenderer, readInstanceMatrices, updateInstanceMatrix };
export type { BakedMesh, CalculatePosition, DRACODecoderConfig, LazyObject3DProxy, RaycasterEmitEvent, RenderState, Renderer, ThRendererParameters };