ohzi-core 13.0.0 → 13.0.2

package/types/data_textures/RGBFloatDataTexture.d.ts

@@ -1,4 +1,5 @@
-export class RGBFloatDataTexture extends CustomDataTexture {
-    constructor(width: any, height: any);
+import { CustomDataTexture } from './CustomDataTexture';
+declare class RGBFloatDataTexture extends CustomDataTexture {
+    constructor(width: number, height: number);
 }
-import { CustomDataTexture } from "./CustomDataTexture";
+export { RGBFloatDataTexture };

package/types/gpu_particles/GPUParticleSystem.d.ts

@@ -1,22 +1,19 @@
-export class GPUParticleSystem extends Object3D<import("three").Object3DEventMap> {
+import type { InstancedBufferAttribute, Mesh, Points, Scene } from "three";
+import { Object3D } from "three";
+
+export class GPUParticleSystem extends Object3D {
     constructor(particle_count: any, material: any);
     attributes: any[];
-    mesh: Mesh<InstancedBufferGeometry, any, import("three").Object3DEventMap>;
-    attribute_writter_mesh: Points<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>;
+    mesh: Mesh;
+    attribute_writter_mesh: Points;
     attribute_writter_scene: Scene;
+
     add_texture_attribute(buffer_attribute: any): void;
     add_update_attribute_array(name: any, array: any, item_size: any): void;
     add_attribute_array(name: any, array: any, item_size: any): void;
     update(): void;
     dispose(): void;
-    build_point_mesh(instance_count: number, material: any): Mesh<InstancedBufferGeometry, any, import("three").Object3DEventMap>;
-    build_attribute_writter_mesh(particle_count: any): Points<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>;
+    build_point_mesh(instance_count: number, material: any): Mesh;
+    build_attribute_writter_mesh(particle_count: any): Points;
     build_uv_storage_attribute(particle_count: any): InstancedBufferAttribute;
 }
-import { Object3D } from "three/src/core/Object3D";
-import { InstancedBufferGeometry } from "three/src/core/InstancedBufferGeometry";
-import { Mesh } from "three/src/objects/Mesh";
-import { BufferGeometry } from "three/src/core/BufferGeometry";
-import { Points } from "three/src/objects/Points";
-import { Scene } from "three/src/scenes/Scene";
-import { InstancedBufferAttribute } from "three/src/core/InstancedBufferAttribute";

package/types/gpu_particles/ParticleAttribute.d.ts

@@ -1,3 +1,5 @@
+import type { RenderTarget, Texture } from "three";
+
 export class ParticleAttribute {
     static calculate_resolution(particle_count: any): {
         width: number;
@@ -10,10 +12,9 @@ export class ParticleAttribute {
     update_material: any;
     init_from_geometry(geometry: any): void;
     init_from_attribute(particle_attribute: any): void;
-    build_RT(particle_count: any): WebGLRenderTarget<import("three").Texture>;
+    build_RT(particle_count: any): RenderTarget<Texture>;
     swap_RT(): void;
     update(attribute_writter_scene: any): void;
-    store_geometry_attribute_in_RT(attribute: any, RT: any, storage_material: any, attribute_writter_scene: any): void;
-    get_texture(): any;
+    store_geometry_attribute_in_RT(attribute: any, RT: RenderTarget<Texture>, storage_material: any, attribute_writter_scene: any): void;
+    get_texture(): Texture;
 }
-import { WebGLRenderTarget } from "three/src/renderers/WebGLRenderTarget";

package/types/html_utilities/CSSAnimator.d.ts

@@ -1,3 +1,6 @@
+import type { EasingFunctions } from "../utilities/EasingFunctions";
+import type { Idle } from "./css_animator_states/Idle";
+
 export class CSSAnimator {
     constructor({ element, css_property, from, to, duration, value_prefix, value_suffix, easing_function, finished_callback }: {
         element: any;
@@ -27,5 +30,3 @@ export class CSSAnimator {
     get is_animating(): boolean;
     set_current_state(state: any): void;
 }
-import { EasingFunctions } from "../utilities/EasingFunctions";
-import { Idle } from "./css_animator_states/Idle";

package/types/loaders/AsyncAbstractLoader.d.ts

@@ -1,24 +1,15 @@
+import type { ResourceContainer } from "../../src/loaders/assets_loader/ResourceContainer";
+
 export class AsyncAbstractLoader {
     static create_worker(): Worker;
-    /**
-     * @param {string} name
-     * @param {any[]} assets
-     * @param {Worker} worker
-     */
     constructor(name: string, assets: any[], worker: Worker);
-    resource_container: {
-        init(): void;
-        resources: Record<string, import("../ResourceContainer").Resource>;
-        resources_by_url: Record<string, any>;
-        set_resource(name: string, url: string, resource: import("../ResourceContainer").Resource): void;
-        get_resource(name: string): import("../ResourceContainer").Resource;
-        get(name: string): import("../ResourceContainer").Resource;
-    };
+    resource_container: ResourceContainer;
     assets: any[];
     name: string;
     worker: Worker;
     bound_on_message: any;
     assets_loaders: any[];
+    
     load(): void;
     is_loaded(): boolean;
     get_progress(): number;
@@ -26,16 +17,7 @@ export class AsyncAbstractLoader {
     __get_total_bytes(): number;
     get_assets_names(): any[];
     __setup_worker(): void;
-    /**
-     * @param {MessageEvent} e
-     */
     on_message(e: MessageEvent): void;
-    /**
-     * @param {any} resources
-     */
     __on_assets_loaded(resources: any): void;
-    /**
-     * @returns {any[]}
-     */
     __setup_loaders(): any[];
 }

package/types/loaders/assets_loader/AssetLoader.d.ts

@@ -1,4 +1,6 @@
-export class AssetLoader extends AbstractLoader {
-    constructor(resource_id: any, url: any, size: any);
-}
-import { AbstractLoader } from "../../resource_loader/AbstractLoader";
+import { AbstractLoader } from '../../resource_loader/AbstractLoader';
+import type { ResourceContainer } from './ResourceContainer';
+export declare class AssetLoader extends AbstractLoader {
+    constructor(resource_id: string, url: string, size: number);
+    on_preloaded_finished(resource_container: ResourceContainer, response: Response): void;
+}

package/types/loaders/assets_loader/AsyncAssetsLoaderWorker.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/types/loaders/assets_loader/ResourceBatch.d.ts

@@ -1,14 +1,16 @@
-export class ResourceBatch {
-    constructor(batch_name: any, resource_container: any);
-    resource_loaders: any[];
-    batch_name: any;
-    resource_container: any;
-    add_loader(loader: any): void;
-    load(): void;
-    get loading_finished(): boolean;
-    get has_errors(): boolean;
-    print_errors(): void;
-    get_progress(): number;
-    get_loaded_bytes(): number;
-    get_total_bytes(): number;
-}
+import type { ResourceContainer } from "./ResourceContainer";
+declare class ResourceBatch {
+    resource_loaders: Array<any>;
+    batch_name: string;
+    resource_container: ResourceContainer;
+    constructor(batch_name: string, resource_container: ResourceContainer);
+    add_loader(loader: any): void;
+    load(): void;
+    get loading_finished(): boolean;
+    get has_errors(): boolean;
+    print_errors(): void;
+    get_progress(): number;
+    get_loaded_bytes(): number;
+    get_total_bytes(): number;
+}
+export { ResourceBatch };

package/types/loaders/assets_loader/ResourceLoaderChecker.d.ts

@@ -1,8 +1,9 @@
-export class ResourceLoaderChecker {
-    constructor(batch: any);
-    batch: any;
-    on_resources_loaded: any;
-    timeout: number;
-    setup(on_resources_loaded: any, timeout?: number): void;
-    check(): void;
-}
+declare class ResourceLoaderChecker {
+    batch: any;
+    on_resources_loaded: (() => void) | undefined;
+    timeout: number;
+    constructor(batch: any);
+    setup(on_resources_loaded: () => void, timeout?: number): void;
+    check(): void;
+}
+export { ResourceLoaderChecker };

package/types/materials/BaseShaderMaterial.d.ts

@@ -1,4 +1,4 @@
+import { ShaderMaterial } from "three";
 export class BaseShaderMaterial extends ShaderMaterial {
     constructor(vert: any, frag: any, uniforms: any);
 }
-import { ShaderMaterial } from "three/src/materials/ShaderMaterial";

package/types/materials/BlitMaterial.d.ts

@@ -1,4 +1,4 @@
+import { ShaderMaterial } from "three";
 export class BlitMaterial extends ShaderMaterial {
     constructor(frag_shader: any, vert_shader: any, defines: any);
 }
-import { ShaderMaterial } from "three/src/materials/ShaderMaterial";

package/types/materials/BloomComposeMaterial.d.ts

@@ -1,4 +1,5 @@
-export class BloomComposeMaterial extends BlitMaterial {
-    constructor(alpha_blending: any);
-}
-import { BlitMaterial } from "./BlitMaterial";
+import { BlitMaterial } from './BlitMaterial';
+declare class BloomComposeMaterial extends BlitMaterial {
+    constructor(alpha_blending?: boolean);
+}
+export { BloomComposeMaterial };

package/types/materials/DeferredRendererComposeMaterial.d.ts

@@ -1,7 +1,10 @@
-export class DeferredRendererComposeMaterial extends BlitMaterial {
-    constructor();
-    set_normal_depth_rt(rt: any): void;
-    set_albedo_rt(tex: any): void;
-    set_proj_matrix(mat4: any): void;
-}
-import { BlitMaterial } from "../materials/BlitMaterial";
+import { BlitMaterial } from '../materials/BlitMaterial';
+import type { RenderTarget, Texture } from 'three';
+import { Matrix4 } from 'three';
+declare class DeferredRendererComposeMaterial extends BlitMaterial {
+    constructor();
+    set_normal_depth_rt(rt: RenderTarget): void;
+    set_albedo_rt(tex: Texture): void;
+    set_proj_matrix(mat4: Matrix4): void;
+}
+export { DeferredRendererComposeMaterial };

package/types/materials/DepthNormalMaterial.d.ts

@@ -1,6 +1,6 @@
+import { ShaderMaterial } from "three";
 export class DepthNormalMaterial extends ShaderMaterial {
     constructor();
     set far_plane(arg: any);
     get far_plane(): any;
 }
-import { ShaderMaterial } from "three/src/materials/ShaderMaterial";

package/types/materials/FXAAMaterial.d.ts

@@ -1,3 +1,5 @@
-export class FXAAMaterial {
-    constructor(upsample: any);
-}
+import { BlitMaterial } from './BlitMaterial';
+declare class FXAAMaterial extends BlitMaterial {
+    constructor();
+}
+export { FXAAMaterial };

package/types/materials/MedianFilterMaterial.d.ts

@@ -1,7 +1,8 @@
+import type { Vector2 } from "three";
+import { BlitMaterial } from "../materials/BlitMaterial";
+
 export class MedianFilterMaterial extends BlitMaterial {
     constructor();
     set_texture(tex: any): void;
     get_size(tex: any): Vector2;
 }
-import { BlitMaterial } from "../materials/BlitMaterial";
-import { Vector2 } from "three/src/math/Vector2";

package/types/materials/SDFScreenTextMaterial.d.ts

@@ -1,7 +1,8 @@
-export class SDFScreenTextMaterial extends BaseShaderMaterial {
-    constructor(texture: any);
-    side: 2;
-    set_atlas_size(size: any): void;
-}
-import { BaseShaderMaterial } from "./BaseShaderMaterial";
-
+import { BaseShaderMaterial } from './BaseShaderMaterial';
+import type { Texture } from 'three';
+import { Vector2 } from 'three';
+declare class SDFScreenTextMaterial extends BaseShaderMaterial {
+    constructor(texture: Texture);
+    set_atlas_size(size: Vector2): void;
+}
+export { SDFScreenTextMaterial };

package/types/materials/SSAOMaterial.d.ts

@@ -1,8 +1,7 @@
+import type { DataTexture, Vector3 } from "three";
+import { BlitMaterial } from "../materials/BlitMaterial";
 export class SSAOMaterial extends BlitMaterial {
     constructor();
     __get_sample_kernel(): Vector3[];
     __get_rotation_kernel(): DataTexture;
 }
-import { BlitMaterial } from "../materials/BlitMaterial";
-import { Vector3 } from "three/src/math/Vector3";
-import { DataTexture } from "three/src/textures/DataTexture";

package/types/materials/ScreenSpaceTextureMaterial.d.ts

@@ -1,7 +1,9 @@
-export class ScreenSpaceTextureMaterial extends BaseShaderMaterial {
-    constructor(x: any, y: any, w: any, h: any);
-    set_position(x: any, y: any): void;
-    set_texture(tex: any, w: any, h: any): void;
-    set_screen_size(w: any, h: any): void;
-}
-import { BaseShaderMaterial } from "./BaseShaderMaterial";
+import type { Texture } from 'three';
+import { BaseShaderMaterial } from './BaseShaderMaterial';
+declare class ScreenSpaceTextureMaterial extends BaseShaderMaterial {
+    constructor();
+    set_position(x: number, y: number): void;
+    set_texture(tex: Texture, w: number, h: number): void;
+    set_screen_size(w: number, h: number): void;
+}
+export { ScreenSpaceTextureMaterial };

package/types/materials/UnrealBlurMaterial.d.ts

@@ -1,4 +1,5 @@
-export class UnrealBlurMaterial extends BlitMaterial {
-    constructor(kernel_radius: any);
-}
-import { BlitMaterial } from "../materials/BlitMaterial";
+import { BlitMaterial } from '../materials/BlitMaterial';
+declare class UnrealBlurMaterial extends BlitMaterial {
+    constructor(kernel_radius: number);
+}
+export { UnrealBlurMaterial };

package/types/materials/UnrealComposeMaterial.d.ts

@@ -1,4 +1,5 @@
-export class UnrealComposeMaterial extends BlitMaterial {
-    constructor(nMips: any);
-}
-import { BlitMaterial } from "../materials/BlitMaterial";
+import { BlitMaterial } from '../materials/BlitMaterial';
+declare class UnrealComposeMaterial extends BlitMaterial {
+    constructor(nMips: number);
+}
+export { UnrealComposeMaterial };

package/types/materials/ViewPositionMaterial.d.ts

@@ -1,4 +1,5 @@
-export class ViewPositionMaterial extends ShaderMaterial {
-    constructor();
-}
-import { ShaderMaterial } from "three/src/materials/ShaderMaterial";
+import { ShaderMaterial } from 'three';
+declare class ViewPositionMaterial extends ShaderMaterial {
+    constructor();
+}
+export { ViewPositionMaterial };

package/types/materials/deferred/DeferredPointLightMaterial.d.ts

@@ -1,9 +1,10 @@
-export class DeferredPointLightMaterial extends BaseShaderMaterial {
-    constructor(intensity?: number);
-    blending: 2;
-    side: 1;
-    set_inverse_proj_matrix(mat4: any): void;
-    set_normal_depth_rt(rt: any): void;
-    set_albedo_rt(rt: any): void;
-}
-import { BaseShaderMaterial } from "../../materials/BaseShaderMaterial";
+import { BaseShaderMaterial } from '../../materials/BaseShaderMaterial';
+import type { RenderTarget } from 'three';
+import { Matrix4 } from 'three';
+declare class DeferredPointLightMaterial extends BaseShaderMaterial {
+    constructor(intensity?: number);
+    set_inverse_proj_matrix(mat4: Matrix4): void;
+    set_normal_depth_rt(rt: RenderTarget): void;
+    set_albedo_rt(rt: RenderTarget): void;
+}
+export { DeferredPointLightMaterial };

package/types/materials/gpu_particles/AttributeUpdateMaterial.d.ts

@@ -1,7 +1,8 @@
-export class AttributeUpdateMaterial extends BlitMaterial {
-    constructor(custom_frag: any);
-    multiplier: number;
-    update(): void;
-    set_multiplier(val: any): void;
-}
-import { BlitMaterial } from "../../materials/BlitMaterial";
+import { BlitMaterial } from '../../materials/BlitMaterial';
+declare class AttributeUpdateMaterial extends BlitMaterial {
+    multiplier: number;
+    constructor(custom_frag?: string);
+    update(): void;
+    set_multiplier(val: number): void;
+}
+export { AttributeUpdateMaterial };

package/types/materials/gpu_particles/BasicParticleMaterial.d.ts

@@ -1,4 +1,5 @@
-export class BasicParticleMaterial extends ShaderMaterial {
-    constructor();
-}
-import { ShaderMaterial } from "three/src/materials/ShaderMaterial";
+import { ShaderMaterial } from 'three';
+declare class BasicParticleMaterial extends ShaderMaterial {
+    constructor();
+}
+export { BasicParticleMaterial };

package/types/materials/gpu_particles/PositionStorageMaterial.d.ts

@@ -1,3 +1,5 @@
-export class PositionStorageMaterial extends ParticleStorageMaterial {
-}
-import { ParticleStorageMaterial } from "../../materials/gpu_particles/ParticleStorageMaterial";
+import { ParticleStorageMaterial } from '../../materials/gpu_particles/ParticleStorageMaterial';
+declare class PositionStorageMaterial extends ParticleStorageMaterial {
+    constructor();
+}
+export { PositionStorageMaterial };

package/types/primitives/Arrow.d.ts

@@ -1,15 +1,12 @@
-export class Arrow extends Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> {
-    /**
-     * @param {string | number} [color]
-     * @param {number} [length]
-     * @param {Vector3} [dir]
-     */
+import type { Vector3 } from "three";
+import { Mesh } from "three";
+
+export class Arrow extends Mesh {
     constructor(color?: string | number, length?: number, dir?: Vector3);
     _dir: Vector3;
+
     set dir(arg: Vector3);
     get dir(): Vector3;
     set length(arg: number);
     get length(): number;
 }
-import { Mesh } from "three/src/objects/Mesh";
-import { Vector3 } from "three/src/math/Vector3";

package/types/primitives/Cube.d.ts

@@ -1,10 +1,5 @@
-export class Cube extends Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> {
-    /**
-     * @param {Vector3} [size]
-     * @param {Vector3} [segments]
-     * @param {number | string} [color]
-     */
+import type { Vector3 } from "three";
+import { Mesh } from "three";
+export class Cube extends Mesh {
     constructor(size?: Vector3, segments?: Vector3, color?: number | string);
 }
-import { Mesh } from "three/src/objects/Mesh";
-import { Vector3 } from "three/src/math/Vector3";

package/types/primitives/HorizontalPlane.d.ts

@@ -1,11 +1,5 @@
-export class HorizontalPlane extends Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, Material | Material[], import("three").Object3DEventMap> {
-    /**
-     * @param {number} [width]
-     * @param {number} [height]
-     * @param {number | string} [color]
-     * @param {Material} [material]
-     */
+import type { Material } from "three";
+import { Mesh } from "three";
+export class HorizontalPlane extends Mesh {
     constructor(width?: number, height?: number, color?: number | string, material?: Material);
 }
-import { Material } from "three/src/materials/Material";
-import { Mesh } from "three/src/objects/Mesh";

package/types/primitives/Sphere.d.ts

@@ -1,11 +1,9 @@
-export class Sphere extends Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> {
-    /**
-     * @param {number} radius
-     * @param {number | string} color
-     */
+import type { Vector3 } from "three";
+import { Mesh } from "three";
+export class Sphere extends Mesh {
     constructor(radius: number, color: number | string);
+
     radius: number;
     color: string | number;
-    center: import("three").Vector3;
+    center: Vector3;
 }
-import { Mesh } from "three/src/objects/Mesh";

package/types/primitives/VerticalPlane.d.ts

@@ -1,11 +1,5 @@
-export class VerticalPlane extends Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, Material | Material[], import("three").Object3DEventMap> {
-    /**
-     * @param {number} [width]
-     * @param {number} [height]
-     * @param {number | string} [color]
-     * @param {Material} [material]
-     */
+import type { Material } from "three";
+import { Mesh } from "three";
+export class VerticalPlane extends Mesh {
     constructor(width?: number, height?: number, color?: number | string, material?: Material);
 }
-import { Material } from "three/src/materials/Material";
-import { Mesh } from "three/src/objects/Mesh";

package/types/raycast/GroupRaycaster.d.ts

@@ -1,15 +1,20 @@
-export class GroupRaycaster {
-    constructor(raycastee_group: any, raycast_resolver: any, camera: any, input: any);
-    camera: any;
-    raycast_resolver: any;
-    raycastee_group: any;
-    input: any;
-    raycaster: Raycaster;
-    current_state: IdleState;
-    current_intersections: import("three").Intersection<import("three").Object3D<import("three").Object3DEventMap>>[];
-    set_raycastee_group(raycastee_group: any): void;
-    update(): void;
-    set_state(new_state: any): void;
-}
-import { Raycaster } from "three/src/core/Raycaster";
-import { IdleState } from "./states/IdleState";
+import type { Input } from '../components/Input';
+import { RaycastResolver } from './RaycastResolver';
+import { IdleState } from './states/IdleState';
+import type { Camera, Intersection, Object3D } from 'three';
+import { Raycaster } from 'three';
+import type { BaseState } from './states/BaseState';
+declare class GroupRaycaster {
+    camera: Camera;
+    current_intersections: Intersection[];
+    current_state: IdleState;
+    input: Input;
+    raycast_resolver: RaycastResolver;
+    raycastee_group: Object3D[];
+    raycaster: Raycaster;
+    constructor(raycastee_group: Object3D[], raycast_resolver: RaycastResolver, camera: Camera, input: Input);
+    set_raycastee_group(raycastee_group: Object3D[]): void;
+    update(): void;
+    set_state(new_state: BaseState): void;
+}
+export { GroupRaycaster };

package/types/raycast/PlaneDragResolver.d.ts

@@ -1,16 +1,21 @@
-export class PlaneDragResolver extends PlaneRaycastResolver {
-    constructor(input: any);
-    _drag_started: boolean;
-    _plane_raycaster: PlaneRaycaster;
-    input: any;
-    on_drag_start(contact_point: any): void;
-    on_drag_move(contact_point: any): void;
-    on_drag_end(): void;
-    on_update(): void;
-    on_drag_button_pressed(): any;
-    on_drag_button_released(): any;
-    get drag_started(): boolean;
-    update(reference_position: any, plane_normal: any): void;
-}
-import { PlaneRaycastResolver } from "./PlaneRaycastResolver";
-import { PlaneRaycaster } from "./PlaneRaycaster";
+import type { Vector3 } from 'three';
+import type { Input } from '../components/Input';
+import { PlaneRaycaster } from './PlaneRaycaster';
+import { PlaneRaycastResolver } from './PlaneRaycastResolver';
+declare class PlaneDragResolver extends PlaneRaycastResolver {
+    _drag_started: boolean;
+    _plane_raycaster: PlaneRaycaster;
+    input: Input;
+    constructor(input: Input);
+    on_drag_start(contact_point: any): void;
+    on_drag_move(contact_point: any): void;
+    on_drag_end(): void;
+    on_update(): void;
+    on_drag_button_pressed(): boolean;
+    on_drag_button_released(): boolean;
+    on_hover(intersection_point: Vector3): void;
+    get drag_started(): boolean;
+    on_exit(): void;
+    update(reference_position: any, plane_normal: any): void;
+}
+export { PlaneDragResolver };

package/types/raycast/PlaneRaycastResolver.d.ts

@@ -1,5 +1,8 @@
-export class PlaneRaycastResolver {
-    on_enter(intersected_point: any): void;
-    on_hover(intersected_point: any): void;
-    on_exit(): void;
-}
+import type { Vector3 } from "three";
+declare class PlaneRaycastResolver {
+    constructor();
+    on_enter(intersected_point: Vector3): void;
+    on_hover(intersected_point: Vector3): void;
+    on_exit(): void;
+}
+export { PlaneRaycastResolver };

package/types/raycast/PlaneRaycaster.d.ts

@@ -1,9 +1,10 @@
-export class PlaneRaycaster {
-    constructor(raycast_resolver: any);
-    raycast_resolver: any;
-    raycaster: Raycaster;
-    current_intersected_point: Vector3;
-    update(reference_position: any, plane_normal: any): void;
-}
-import { Raycaster } from "three/src/core/Raycaster";
-import { Vector3 } from "three/src/math/Vector3";
+import { Raycaster, Vector3 } from 'three';
+import type { RaycastResolver } from './RaycastResolver';
+declare class PlaneRaycaster {
+    current_intersected_point: Vector3;
+    raycast_resolver: RaycastResolver;
+    raycaster: Raycaster;
+    constructor(raycast_resolver: RaycastResolver);
+    update(reference_position: any, plane_normal: any): void;
+}
+export { PlaneRaycaster };

package/types/raycast/RaycastResolver.d.ts

@@ -1,5 +1,8 @@
-export class RaycastResolver {
-    on_enter(intersected_object: any): void;
-    on_hover(intersected_object: any): void;
-    on_exit(): void;
-}
+import type { Vector3 } from "three";
+declare class RaycastResolver {
+    constructor();
+    on_enter(intersected_point: Vector3): void;
+    on_hover(intersected_point: Vector3): void;
+    on_exit(): void;
+}
+export { RaycastResolver };