/// <reference types="bitecs" />
import { BufferGeometry, Material, Mesh, Object3D, Scene, Bone, PerspectiveCamera, Group, InstancedMesh, Line, LineLoop, LineSegments, PointLight, Points, SkinnedMesh, SpotLight, OrthographicCamera, BoxGeometry, CircleGeometry, ConeGeometry, CylinderGeometry, DodecahedronGeometry, EdgesGeometry, ExtrudeGeometry, IcosahedronGeometry, LatheGeometry, OctahedronGeometry, PlaneGeometry, PolyhedronGeometry, RingGeometry, ShapeGeometry, SphereGeometry, TetrahedronGeometry, TorusGeometry, TorusKnotGeometry, TubeGeometry, WireframeGeometry, LineBasicMaterial, LineDashedMaterial, MeshBasicMaterial, MeshDepthMaterial, MeshDistanceMaterial, MeshLambertMaterial, MeshMatcapMaterial, MeshNormalMaterial, MeshPhongMaterial, MeshPhysicalMaterial, MeshStandardMaterial, MeshToonMaterial, PointsMaterial, RawShaderMaterial, ShaderMaterial, ShadowMaterial, SpriteMaterial, CanvasTexture, CompressedTexture, CubeTexture, DataTexture, DataTexture2DArray, DataTexture3D, DepthTexture, Texture, VideoTexture, Audio, PositionalAudio, AudioListener } from "three";
import { Constructor, IObject3DEntity, IObject3DStaticProps } from "./proxy/Object3DEntityMixin";
import { World } from "./World";
declare type Override<T, O> = Omit<T, keyof O> & O;
declare type ITextureProps = {
    eid: number;
    store: typeof TextureComponent;
};
export declare type ITextureEntity<T extends Texture = Texture> = Override<T, ITextureProps>;
export declare const TextureComponent: import("./ECS").MapComponent<ITextureEntity<Texture>>;
export declare const TextureEntityMixin: <T extends Texture, R extends ITextureEntity<T>>(Base: new (...args: any[]) => T) => new (...args: any[]) => R;
declare const TextureEntity_base: new (...args: any[]) => ITextureEntity<Texture>;
export declare class TextureEntity extends TextureEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof Texture>);
}
export declare const CanvasTextureComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const CanvasTextureEntity_base: new (...args: any[]) => ITextureEntity<CanvasTexture>;
export declare class CanvasTextureEntity extends CanvasTextureEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof CanvasTexture>);
}
export declare const CompressedTextureComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const CompressedTextureEntity_base: new (...args: any[]) => ITextureEntity<CompressedTexture>;
export declare class CompressedTextureEntity extends CompressedTextureEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof CompressedTexture>);
}
export declare const CubeTextureComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const CubeTextureEntity_base: new (...args: any[]) => ITextureEntity<CubeTexture>;
export declare class CubeTextureEntity extends CubeTextureEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof CubeTexture>);
}
export declare const DataTextureComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const DataTextureEntity_base: new (...args: any[]) => ITextureEntity<DataTexture>;
export declare class DataTextureEntity extends DataTextureEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof DataTexture>);
}
export declare const DataTexture2DArrayComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const DataTexture2DArrayEntity_base: new (...args: any[]) => ITextureEntity<DataTexture2DArray>;
export declare class DataTexture2DArrayEntity extends DataTexture2DArrayEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof DataTexture2DArray>);
}
export declare const DataTexture3DComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const DataTexture3DEntity_base: new (...args: any[]) => ITextureEntity<DataTexture3D>;
export declare class DataTexture3DEntity extends DataTexture3DEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof DataTexture3D>);
}
export declare const DepthTextureComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const DepthTextureEntity_base: new (...args: any[]) => ITextureEntity<DepthTexture>;
export declare class DepthTextureEntity extends DepthTextureEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof DepthTexture>);
}
export declare const VideoTextureComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const VideoTextureEntity_base: new (...args: any[]) => ITextureEntity<VideoTexture>;
export declare class VideoTextureEntity extends VideoTextureEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof VideoTexture>);
}
export declare const GeometryComponent: import("./ECS").MapComponent<IGeometryEntity<BufferGeometry>>;
declare type IGeometryProps = {
    eid: number;
    store: typeof GeometryComponent;
};
export declare type IGeometryEntity<T extends BufferGeometry = BufferGeometry> = Override<T, IGeometryProps>;
export declare const GeometryEntityMixin: <T extends BufferGeometry, R extends IGeometryEntity<T>>(Base: new (...args: any[]) => T) => new (...args: any[]) => R;
export declare const BoxGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const BoxGeometryEntity_base: new (...args: any[]) => IGeometryEntity<BoxGeometry>;
export declare class BoxGeometryEntity extends BoxGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof BoxGeometry>);
}
export declare const CircleGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const CircleGeometryEntity_base: new (...args: any[]) => IGeometryEntity<CircleGeometry>;
export declare class CircleGeometryEntity extends CircleGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof CircleGeometry>);
}
export declare const ConeGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const ConeGeometryEntity_base: new (...args: any[]) => IGeometryEntity<ConeGeometry>;
export declare class ConeGeometryEntity extends ConeGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof ConeGeometry>);
}
export declare const CylinderGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const CylinderGeometryEntity_base: new (...args: any[]) => IGeometryEntity<CylinderGeometry>;
export declare class CylinderGeometryEntity extends CylinderGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof CylinderGeometry>);
}
export declare const DodecahedronGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const DodecahedronGeometryEntity_base: new (...args: any[]) => IGeometryEntity<DodecahedronGeometry>;
export declare class DodecahedronGeometryEntity extends DodecahedronGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof DodecahedronGeometry>);
}
export declare const EdgesGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const EdgesGeometryEntity_base: new (...args: any[]) => IGeometryEntity<EdgesGeometry<any>>;
export declare class EdgesGeometryEntity extends EdgesGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof EdgesGeometry>);
}
export declare const ExtrudeGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const ExtrudeGeometryEntity_base: new (...args: any[]) => IGeometryEntity<ExtrudeGeometry>;
export declare class ExtrudeGeometryEntity extends ExtrudeGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof ExtrudeGeometry>);
}
export declare const IcosahedronGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const IcosahedronGeometryEntity_base: new (...args: any[]) => IGeometryEntity<IcosahedronGeometry>;
export declare class IcosahedronGeometryEntity extends IcosahedronGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof IcosahedronGeometry>);
}
export declare const LatheGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const LatheGeometryEntity_base: new (...args: any[]) => IGeometryEntity<LatheGeometry>;
export declare class LatheGeometryEntity extends LatheGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof LatheGeometry>);
}
export declare const OctahedronGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const OctahedronGeometryEntity_base: new (...args: any[]) => IGeometryEntity<OctahedronGeometry>;
export declare class OctahedronGeometryEntity extends OctahedronGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof OctahedronGeometry>);
}
export declare const PlaneGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const PlaneGeometryEntity_base: new (...args: any[]) => IGeometryEntity<PlaneGeometry>;
export declare class PlaneGeometryEntity extends PlaneGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof BoxGeometry>);
}
export declare const PolyhedronGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const PolyhedronGeometryEntity_base: new (...args: any[]) => IGeometryEntity<PolyhedronGeometry>;
export declare class PolyhedronGeometryEntity extends PolyhedronGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof PolyhedronGeometry>);
}
export declare const RingGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const RingGeometryEntity_base: new (...args: any[]) => IGeometryEntity<RingGeometry>;
export declare class RingGeometryEntity extends RingGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof RingGeometry>);
}
export declare const ShapeGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const ShapeGeometryEntity_base: new (...args: any[]) => IGeometryEntity<ShapeGeometry>;
export declare class ShapeGeometryEntity extends ShapeGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof BoxGeometry>);
}
export declare const SphereGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const SphereGeometryEntity_base: new (...args: any[]) => IGeometryEntity<SphereGeometry>;
export declare class SphereGeometryEntity extends SphereGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof SphereGeometry>);
}
export declare const TetrahedronGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const TetrahedronGeometryEntity_base: new (...args: any[]) => IGeometryEntity<TetrahedronGeometry>;
export declare class TetrahedronGeometryEntity extends TetrahedronGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof TetrahedronGeometry>);
}
export declare const TorusGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const TorusGeometryEntity_base: new (...args: any[]) => IGeometryEntity<TorusGeometry>;
export declare class TorusGeometryEntity extends TorusGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof TorusGeometry>);
}
export declare const TorusKnotGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const TorusKnotGeometryEntity_base: new (...args: any[]) => IGeometryEntity<TorusKnotGeometry>;
export declare class TorusKnotGeometryEntity extends TorusKnotGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof TorusKnotGeometry>);
}
export declare const TubeGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const TubeGeometryEntity_base: new (...args: any[]) => IGeometryEntity<TubeGeometry>;
export declare class TubeGeometryEntity extends TubeGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof TubeGeometry>);
}
export declare const WireframeGeometryComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const WireframeGeometryEntity_base: new (...args: any[]) => IGeometryEntity<WireframeGeometry<any>>;
export declare class WireframeGeometryEntity extends WireframeGeometryEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof WireframeGeometry>);
}
export declare const MaterialComponent: import("./ECS").MapComponent<IMaterialEntity<Material, {}>>;
declare type IMaterialProps = {
    eid: number;
    store: typeof MaterialComponent;
    textureStore: typeof TextureComponent;
};
export declare type IMaterialEntity<T extends Material = Material, O extends object = {}> = Override<T, IMaterialProps & O>;
export declare const MaterialEntityMixin: <T extends Material, O extends object = {}, R extends IMaterialEntity<T, O> = IMaterialEntity<T, O>>(Base: new (...args: any[]) => T) => new (...args: any[]) => R;
export declare const LineBasicMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const LineBasicMaterialEntity_base: new (...args: any[]) => IMaterialEntity<LineBasicMaterial, {}>;
export declare class LineBasicMaterialEntity extends LineBasicMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof LineBasicMaterial>);
}
export declare const LineDashedMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const LineDashedMaterialEntity_base: new (...args: any[]) => IMaterialEntity<LineDashedMaterial, {}>;
export declare class LineDashedMaterialEntity extends LineDashedMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof LineDashedMaterial>);
}
export declare const MeshBasicMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const MeshBasicMaterialEntity_base: new (...args: any[]) => IMaterialEntity<MeshBasicMaterial, {}>;
export declare class MeshBasicMaterialEntity extends MeshBasicMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof MeshBasicMaterial>);
}
export declare const MeshDepthMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const MeshDepthMaterialEntity_base: new (...args: any[]) => IMaterialEntity<MeshDepthMaterial, {}>;
export declare class MeshDepthMaterialEntity extends MeshDepthMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof MeshDepthMaterial>);
}
export declare const MeshDistanceMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const MeshDistanceMaterialEntity_base: new (...args: any[]) => IMaterialEntity<MeshDistanceMaterial, {}>;
export declare class MeshDistanceMaterialEntity extends MeshDistanceMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof MeshDistanceMaterial>);
}
export declare const MeshLambertMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const MeshLambertMaterialEntity_base: new (...args: any[]) => IMaterialEntity<MeshLambertMaterial, {}>;
export declare class MeshLambertMaterialEntity extends MeshLambertMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof MeshLambertMaterial>);
}
export declare const MeshMatcapMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const MeshMatcapMaterialEntity_base: new (...args: any[]) => IMaterialEntity<MeshMatcapMaterial, {}>;
export declare class MeshMatcapMaterialEntity extends MeshMatcapMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof MeshMatcapMaterial>);
}
export declare const MeshNormalMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const MeshNormalMaterialEntity_base: new (...args: any[]) => IMaterialEntity<MeshNormalMaterial, {}>;
export declare class MeshNormalMaterialEntity extends MeshNormalMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof MeshNormalMaterial>);
}
export declare const MeshPhongMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const MeshPhongMaterialEntity_base: new (...args: any[]) => IMaterialEntity<MeshPhongMaterial, {}>;
export declare class MeshPhongMaterialEntity extends MeshPhongMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof MeshPhongMaterial>);
}
export declare const MeshPhysicalMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const MeshPhysicalMaterialEntity_base: new (...args: any[]) => IMaterialEntity<MeshPhysicalMaterial, {}>;
export declare class MeshPhysicalMaterialEntity extends MeshPhysicalMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof MeshPhysicalMaterial>);
}
export declare const MeshStandardMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const MeshStandardMaterialEntity_base: new (...args: any[]) => IMaterialEntity<MeshStandardMaterial, {}>;
export declare class MeshStandardMaterialEntity extends MeshStandardMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof MeshStandardMaterial>);
}
export declare const MeshToonMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const MeshToonMaterialEntity_base: new (...args: any[]) => IMaterialEntity<MeshToonMaterial, {}>;
export declare class MeshToonMaterialEntity extends MeshToonMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof MeshToonMaterial>);
}
export declare const PointsMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const PointsMaterialEntity_base: new (...args: any[]) => IMaterialEntity<PointsMaterial, {}>;
export declare class PointsMaterialEntity extends PointsMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof PointsMaterial>);
}
export declare const RawShaderMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const RawShaderMaterialEntity_base: new (...args: any[]) => IMaterialEntity<RawShaderMaterial, {}>;
export declare class RawShaderMaterialEntity extends RawShaderMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof RawShaderMaterial>);
}
export declare const ShaderMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const ShaderMaterialEntity_base: new (...args: any[]) => IMaterialEntity<ShaderMaterial, {}>;
export declare class ShaderMaterialEntity extends ShaderMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof ShaderMaterial>);
}
export declare const ShadowMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const ShadowMaterialEntity_base: new (...args: any[]) => IMaterialEntity<ShadowMaterial, {}>;
export declare class ShadowMaterialEntity extends ShadowMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof ShadowMaterial>);
}
export declare const SpriteMaterialComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const SpriteMaterialEntity_base: new (...args: any[]) => IMaterialEntity<SpriteMaterial, {}>;
export declare class SpriteMaterialEntity extends SpriteMaterialEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof SpriteMaterial>);
}
/**
 * Base Object3D Types:
 * Scene
 *
 * GLTFLoader Object3D Types:
 * Bone
 * Group
 * Line
 * LineLoop
 * LineSegments
 * Mesh
 * Object3D
 * OrthographicCamera
 * PerspectiveCamera
 * PointLight
 * Points
 * SkinnedMesh
 * SpotLight
 *
 * three-omi Object3D Types:
 * Audio
 * PositionalAudio
 * AudioListener
 *
 * Additional Object3D Types:
 * LOD?
 */
export declare const SceneComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const SceneEntity_base: Constructor<IObject3DEntity<Scene, {}>, IObject3DStaticProps>;
export declare class SceneEntity extends SceneEntity_base {
    constructor(world: World);
}
declare const Object3DEntity_base: Constructor<IObject3DEntity<Object3D<import("three").Event>, {}>, IObject3DStaticProps>;
export declare class Object3DEntity extends Object3DEntity_base {
    constructor(world: World);
}
export declare const MeshBaseComponent: import("bitecs").ComponentType<{
    geometryEid: "eid";
    materialEid: "eid";
}>;
interface IMeshBaseEntityProps {
    meshBaseStore: typeof MeshBaseComponent;
    geometryStore: typeof GeometryComponent;
    materialStore: typeof MaterialComponent;
    geometry: IGeometryEntity;
    material: IMaterialEntity;
}
export declare const MeshBaseEntityMixin: <T extends Object3D<import("three").Event>, O extends object = {}, R extends IObject3DEntity<T, O> = IObject3DEntity<T, O>, S extends IObject3DStaticProps = IObject3DStaticProps>(Base: new (...args: any[]) => T) => Constructor<R, S>;
export declare const MeshComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const MeshEntity_base: Constructor<IObject3DEntity<Mesh<BufferGeometry, Material | Material[]>, IMeshBaseEntityProps>, IObject3DStaticProps>;
export declare class MeshEntity extends MeshEntity_base {
    constructor(world: World, geometry: IGeometryEntity, material: IMaterialEntity);
}
export declare const SkinnedMeshComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const SkinnedMeshEntity_base: Constructor<IObject3DEntity<SkinnedMesh<any, any>, {}>, IObject3DStaticProps>;
export declare class SkinnedMeshEntity extends SkinnedMeshEntity_base {
    constructor(world: World, geometry: IGeometryEntity, material: IMaterialEntity);
}
export declare const InstancedMeshImposterComponent: import("bitecs").ComponentType<{
    instancedMeshEid: "eid";
    instancedMeshIndex: "ui32";
    needsUpdate: "ui8";
    autoUpdate: "ui8";
}>;
declare const InstancedMeshImposterEntity_base: Constructor<IObject3DEntity<Mesh<any, any>, {}>, IObject3DStaticProps>;
export declare class InstancedMeshImposterEntity extends InstancedMeshImposterEntity_base {
    constructor(world: World, instancedMesh: InstancedMeshEntity);
}
export declare const InstancedMeshComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const InstancedMeshEntity_base: Constructor<IObject3DEntity<InstancedMesh<any, any>, {}>, IObject3DStaticProps>;
export declare class InstancedMeshEntity extends InstancedMeshEntity_base {
    constructor(world: World, geometry: IGeometryEntity, material: IMaterialEntity, size: number, count?: number);
    addInstance(): void;
}
export declare const BoneComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const BoneEntity_base: Constructor<IObject3DEntity<Bone, {}>, IObject3DStaticProps>;
export declare class BoneEntity extends BoneEntity_base {
    constructor(world: World);
}
export declare const CameraComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
export declare const OrthographicCameraComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const OrthographicCameraEntity_base: Constructor<IObject3DEntity<OrthographicCamera, {}>, IObject3DStaticProps>;
export declare class OrthographicCameraEntity extends OrthographicCameraEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof OrthographicCamera>);
}
export declare const PerspectiveCameraComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const PerspectiveCameraEntity_base: Constructor<IObject3DEntity<PerspectiveCamera, {}>, IObject3DStaticProps>;
export declare class PerspectiveCameraEntity extends PerspectiveCameraEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof OrthographicCamera>);
}
export declare const GroupComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const GroupEntity_base: Constructor<IObject3DEntity<Group, {}>, IObject3DStaticProps>;
export declare class GroupEntity extends GroupEntity_base {
    constructor(world: World);
}
export declare const LineComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const LineEntity_base: Constructor<IObject3DEntity<Line<any, any>, {}>, IObject3DStaticProps>;
export declare class LineEntity extends LineEntity_base {
    constructor(world: World, geometry: IGeometryEntity, material: IMaterialEntity);
}
export declare const LineLoopComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const LineLoopEntity_base: Constructor<IObject3DEntity<LineLoop<any, any>, {}>, IObject3DStaticProps>;
export declare class LineLoopEntity extends LineLoopEntity_base {
    constructor(world: World, geometry: IGeometryEntity, material: IMaterialEntity);
}
export declare const LineSegmentsComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const LineSegmentsEntity_base: Constructor<IObject3DEntity<LineSegments<any, any>, {}>, IObject3DStaticProps>;
export declare class LineSegmentsEntity extends LineSegmentsEntity_base {
    constructor(world: World, geometry: IGeometryEntity, material: IMaterialEntity);
}
export declare const PointLightComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const PointLightEntity_base: Constructor<IObject3DEntity<PointLight, {}>, IObject3DStaticProps>;
export declare class PointLightEntity extends PointLightEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof PointLight>);
}
export declare const PointsComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const PointsEntity_base: Constructor<IObject3DEntity<Points<any, any>, {}>, IObject3DStaticProps>;
export declare class PointsEntity extends PointsEntity_base {
    constructor(world: World, geometry: IGeometryEntity, material: IMaterialEntity);
}
export declare const SpotLightComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const SpotLightEntity_base: Constructor<IObject3DEntity<SpotLight, {}>, IObject3DStaticProps>;
export declare class SpotLightEntity extends SpotLightEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof SpotLight>);
}
export declare const AudioComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const AudioEntity_base: Constructor<IObject3DEntity<Audio<GainNode>, {}>, IObject3DStaticProps>;
export declare class AudioEntity extends AudioEntity_base {
    constructor(world: World, listener: AudioListenerEntity);
}
export declare const PositionalAudioComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const PositionalAudioEntity_base: Constructor<IObject3DEntity<PositionalAudio, {}>, IObject3DStaticProps>;
export declare class PositionalAudioEntity extends PositionalAudioEntity_base {
    constructor(world: World, listener: AudioListenerEntity);
}
export declare const AudioListenerComponent: import("bitecs").ComponentType<import("bitecs").ISchema>;
declare const AudioListenerEntity_base: Constructor<IObject3DEntity<AudioListener, {}>, IObject3DStaticProps>;
export declare class AudioListenerEntity extends AudioListenerEntity_base {
    constructor(world: World, ...args: ConstructorParameters<typeof AudioListener>);
}
export {};