@quick-threejs/reactive 0.1.15 → 0.1.17

package/dist/main.worker-WTRf-uyZ.d.ts

@@ -0,0 +1,726 @@
+import * as _quick_threejs_utils from '@quick-threejs/utils';
+import { ProxyReceiver, ExposedWorkerThreadModule, Methods, WorkerThreadResolution, WorkerThreadModule as WorkerThreadModule$1 } from '@quick-threejs/utils';
+import * as rxjs from 'rxjs';
+import { Subject, Observable } from 'rxjs';
+import * as three from 'three';
+import { Texture, CubeTextureLoader, VideoTexture, LoadingManager, ImageBitmapLoader, AudioLoader, Clock, Scene, Camera, PerspectiveCamera, Quaternion, Vector3, Euler, CameraHelper, AxesHelper, GridHelper, WebGLRenderer, Vector2Like } from 'three';
+import * as three_examples_jsm_Addons from 'three/examples/jsm/Addons';
+import { GLTF, DRACOLoader, GLTFLoader, OrbitControls } from 'three/examples/jsm/Addons';
+import * as three_examples_jsm_libs_lil_gui_module_min from 'three/examples/jsm/libs/lil-gui.module.min';
+import * as threads_dist_types_master from 'threads/dist/types/master';
+import * as threads from 'threads';
+import GUI from 'three/examples/jsm/libs/lil-gui.module.min.js';
+import Stats from 'stats.js';
+import { WorkerThreadModule, ExposedWorkerThreadModule as ExposedWorkerThreadModule$1 } from '@quick-threejs/utils/dist/types/worker.type';
+
+interface OffscreenCanvasWithStyle extends OffscreenCanvas {
+    style: Partial<CSSStyleDeclaration> & {
+        width: CSSStyleDeclaration["width"];
+        height: CSSStyleDeclaration["height"];
+    };
+}
+
+declare class AppComponent {
+    readonly proxyReceiver: ProxyReceiver<Record<string, unknown>>;
+    initialized: boolean;
+    canvas?: OffscreenCanvasWithStyle;
+}
+
+declare const KEYBOARD_EVENT_CODES: string[];
+declare const PROXY_EVENT_LISTENERS: readonly ["contextmenu", "resize", "mousedown", "mousemove", "mouseup", "pointerdown", "pointermove", "pointercancel", "pointerup", "touchstart", "touchmove", "touchend", "wheel", "keydown"];
+
+/** @description  */
+type ProxyEventListenerKeys = (typeof PROXY_EVENT_LISTENERS)[number];
+type ProxyEventHandlersImplementation = {
+    [x in ProxyEventListenerKeys]: (event: any) => void;
+};
+type ProxyEventSubjectsImplementation = {
+    [x in `${ProxyEventListenerKeys}$$`]: Subject<any>;
+};
+type ProxyEventObservablesImplementation = {
+    [x in `${ProxyEventListenerKeys}$`]: Observable<any>;
+};
+
+declare class ProxyEventSubjectsModel implements ProxyEventSubjectsImplementation {
+    contextmenu$$: Subject<MouseEvent & ProxyEvent>;
+    resize$$: Subject<UIEvent & ProxyEvent>;
+    mousedown$$: Subject<PointerEvent & ProxyEvent>;
+    mousemove$$: Subject<PointerEvent & ProxyEvent>;
+    mouseup$$: Subject<PointerEvent & ProxyEvent>;
+    pointerdown$$: Subject<PointerEvent & ProxyEvent>;
+    pointermove$$: Subject<PointerEvent & ProxyEvent>;
+    pointercancel$$: Subject<PointerEvent & ProxyEvent>;
+    pointerup$$: Subject<PointerEvent & ProxyEvent>;
+    touchstart$$: Subject<TouchEvent & ProxyEvent>;
+    touchmove$$: Subject<TouchEvent & ProxyEvent>;
+    touchend$$: Subject<TouchEvent & ProxyEvent>;
+    wheel$$: Subject<WheelEvent & ProxyEvent>;
+    keydown$$: Subject<KeyboardEvent & ProxyEvent>;
+}
+
+declare class ProxyEventObservablesModel extends ProxyEventSubjectsModel implements ProxyEventObservablesImplementation {
+    contextmenu$: Observable<MouseEvent & ProxyEvent>;
+    resize$: Observable<UIEvent & ProxyEvent>;
+    mousedown$: Observable<PointerEvent & ProxyEvent>;
+    mousemove$: Observable<PointerEvent & ProxyEvent>;
+    mouseup$: Observable<PointerEvent & ProxyEvent>;
+    pointerdown$: Observable<PointerEvent & ProxyEvent>;
+    pointermove$: Observable<PointerEvent & ProxyEvent>;
+    pointercancel$: Observable<PointerEvent & ProxyEvent>;
+    pointerup$: Observable<PointerEvent & ProxyEvent>;
+    touchstart$: Observable<TouchEvent & ProxyEvent>;
+    touchmove$: Observable<TouchEvent & ProxyEvent>;
+    touchend$: Observable<TouchEvent & ProxyEvent>;
+    wheel$: Observable<WheelEvent & ProxyEvent>;
+    keydown$: Observable<KeyboardEvent & ProxyEvent>;
+}
+
+declare class ProxyEventHandlersModel extends ProxyEventObservablesModel implements ProxyEventHandlersImplementation {
+    contextmenu: (e: MouseEvent & ProxyEvent) => void;
+    resize: (e: UIEvent & ProxyEvent) => void;
+    mousedown: (e: PointerEvent & ProxyEvent) => void;
+    mousemove: (e: PointerEvent & ProxyEvent) => void;
+    mouseup: (e: PointerEvent & ProxyEvent) => void;
+    pointerdown: (e: PointerEvent & ProxyEvent) => void;
+    pointermove: (e: PointerEvent & ProxyEvent) => void;
+    pointercancel: (e: PointerEvent & ProxyEvent) => void;
+    pointerup: (e: PointerEvent & ProxyEvent) => void;
+    touchstart: (e: TouchEvent & ProxyEvent) => void;
+    touchmove: (e: TouchEvent & ProxyEvent) => void;
+    touchend: (e: TouchEvent & ProxyEvent) => void;
+    wheel: (e: WheelEvent & ProxyEvent) => void;
+    keydown: (e: KeyboardEvent & ProxyEvent) => void;
+}
+
+declare enum RegisterLifecycleState {
+    INITIALIZED = 0,
+    DISPOSED = 1
+}
+declare enum AppLifecycleState {
+    INITIALIZED = 0,
+    STEP_STARTED = 1,
+    STEP_ENDED = 2,
+    DISPOSED = 3
+}
+
+declare class AppController extends ProxyEventHandlersModel {
+    private readonly component;
+    readonly lifecycle$$: Subject<AppLifecycleState>;
+    readonly lifecycle$: Observable<AppLifecycleState>;
+    constructor(component: AppComponent);
+}
+
+declare enum DefaultCameraType {
+    PERSPECTIVE = 0,
+    ORTHOGRAPHIC = 1
+}
+
+/** @description `launchApp` initialization properties. */
+declare class LaunchAppProps {
+    /**
+     * @description Handler triggered when the app is ready.
+     */
+    onReady?: (app: AppModule) => unknown;
+}
+
+declare const launchApp: (props?: LaunchAppProps) => AppModule;
+type ExposedAppModule = ExposedWorkerThreadModule<Methods<AppModule>>;
+
+declare class RegisterComponent {
+    readonly workerPool: _quick_threejs_utils.WorkerPool;
+    canvas: HTMLCanvasElement;
+    worker: WorkerThreadResolution<ExposedAppModule>["worker"];
+    thread: WorkerThreadResolution<ExposedAppModule>["thread"];
+    gui?: GUI;
+    stats?: Stats;
+    init(app: WorkerThreadResolution<ExposedAppModule>): void;
+}
+
+declare class RegisterController extends ProxyEventHandlersModel {
+    private readonly component;
+    private canvas;
+    readonly lifecycle$$: Subject<RegisterLifecycleState>;
+    readonly lifecycle$: rxjs.Observable<RegisterLifecycleState>;
+    constructor(component: RegisterComponent);
+    init(canvas: HTMLCanvasElement): void;
+    preventDefaultHandler(e: Event): {
+        type: string;
+    };
+    getScreenSizes(): {
+        width: number;
+        height: number;
+        windowWidth: number;
+        windowHeight: number;
+    };
+    uiEventHandler(e: UIEvent): {
+        type: string;
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+        windowWidth: number;
+        windowHeight: number;
+    };
+    mouseEventHandler(e: PointerEvent): {
+        button: number;
+        clientX: number;
+        clientY: number;
+        ctrlKey: boolean;
+        metaKey: boolean;
+        pageX: number;
+        pageY: number;
+        shiftKey: boolean;
+        pointerType: string;
+        type?: string;
+        width: number;
+        height: number;
+        windowWidth: number;
+        windowHeight: number;
+    };
+    touchEventHandler(e: TouchEvent): {
+        type: string;
+        touches: {
+            pageX: number;
+            pageY: number;
+        }[];
+        width: number;
+        height: number;
+        windowWidth: number;
+        windowHeight: number;
+    };
+    wheelEventHandler(e: WheelEvent): {
+        deltaX: number;
+        deltaY: number;
+        type?: string;
+        width: number;
+        height: number;
+        windowWidth: number;
+        windowHeight: number;
+    };
+    keyEventHandler(e: KeyboardEvent): {
+        ctrlKey: boolean;
+        metaKey: boolean;
+        shiftKey: boolean;
+        keyCode: number;
+        type?: string;
+        width: number;
+        height: number;
+        windowWidth: number;
+        windowHeight: number;
+    } | undefined;
+}
+
+type LoadedResourceItem = GLTF | Texture | CubeTextureLoader | VideoTexture | AudioBuffer;
+interface Resource {
+    name: string;
+    type: "cubeTexture" | "texture" | "gltfModel" | "video" | "audio";
+    path: string | string[];
+}
+interface ProgressedResource {
+    file?: LoadedResourceItem;
+    resource: Resource;
+    loaded: number;
+    toLoad: number;
+}
+
+declare class LoaderController {
+    readonly lifecycle$$: Subject<unknown>;
+    readonly progress$$: Subject<ProgressedResource>;
+    readonly progress$: rxjs.Observable<ProgressedResource>;
+    readonly lifecycle$: rxjs.Observable<unknown>;
+    readonly progressCompleted$: rxjs.Observable<ProgressedResource>;
+}
+
+declare class LoaderComponent {
+    readonly loadingManager: LoadingManager;
+    readonly loaders: {
+        dracoLoader?: DRACOLoader;
+        gltfLoader?: GLTFLoader;
+        textureLoader?: ImageBitmapLoader;
+        cubeTextureLoader?: CubeTextureLoader;
+        audioLoader?: AudioLoader;
+        videoLoader?: LoaderComponent["videoLoader"];
+    };
+    resources: Resource[];
+    items: {
+        [name: Resource["name"]]: LoadedResourceItem;
+    };
+    toLoad: number;
+    loaded: number;
+    private get videoLoader();
+    private _setLoaders;
+    setResources(resources: Resource[]): void;
+    init(resources?: Resource[]): void;
+}
+
+/**
+ * @description Module representation.
+ *
+ * @important Each module should `implement` this interface.
+ */
+interface Module {
+    /**
+     * @description Module initializer method.
+     *
+     * Can be used for direct initialization (when constructing `quick-three`) or manual (later in the code).
+     */
+    init(...props: any[]): void;
+    /**
+     * @description Module disposal.
+     *
+     * Used to terminate the Module execution and free memory.
+     */
+    dispose(): void;
+}
+
+declare class LoaderModule implements Module, WorkerThreadModule {
+    private readonly controller;
+    private readonly component;
+    constructor(controller: LoaderController, component: LoaderComponent);
+    private _handleLoadedResource;
+    setDracoLoader(dracoDecoderPath: string, linkWithGltfLoader?: boolean): void;
+    load(): void;
+    items(): {
+        [name: string]: LoadedResourceItem;
+    };
+    loaders(): {
+        dracoLoader?: DRACOLoader;
+        gltfLoader?: three_examples_jsm_Addons.GLTFLoader;
+        textureLoader?: three.ImageBitmapLoader;
+        cubeTextureLoader?: three.CubeTextureLoader;
+        audioLoader?: three.AudioLoader;
+        videoLoader?: LoaderComponent["videoLoader"];
+    };
+    resources(): Resource[];
+    loaded(): number;
+    toLoad(): number;
+    init(resources?: Resource[]): void;
+    dispose(): void;
+    lifecycle$(): rxjs.Observable<unknown>;
+    progress$(): rxjs.Observable<ProgressedResource>;
+    progressCompleted$(): rxjs.Observable<ProgressedResource>;
+}
+declare const loaderModule: LoaderModule;
+
+type ExposedLoaderModule = ExposedWorkerThreadModule$1<LoaderModule>;
+
+declare class RegisterProxyEventHandlersModel {
+    contextmenu$?: () => Observable<Event>;
+    resize$?: () => Observable<Event>;
+    mousedown$?: () => Observable<Event>;
+    mousemove$?: () => Observable<Event>;
+    mouseup$?: () => Observable<Event>;
+    pointerdown$?: () => Observable<Event>;
+    pointermove$?: () => Observable<Event>;
+    pointercancel$?: () => Observable<Event>;
+    pointerup$?: () => Observable<Event>;
+    touchstart$?: () => Observable<Event>;
+    touchmove$?: () => Observable<Event>;
+    touchend$?: () => Observable<Event>;
+    wheel$?: () => Observable<Event>;
+    keydown$?: () => Observable<Event>;
+}
+
+declare class RegisterModule extends RegisterProxyEventHandlersModel implements Module {
+    private readonly component;
+    private readonly controller;
+    private readonly registerProps;
+    constructor(component: RegisterComponent, controller: RegisterController, registerProps: RegisterPropsModel);
+    private _initCanvas;
+    private _initComponent;
+    private _initController;
+    private _initWorkerThread;
+    private _initProxyEvents;
+    init(): Promise<void>;
+    loadResources(props: {
+        resources: Resource[];
+        disposeOnComplete?: boolean;
+        onMainThread?: boolean;
+        immediateLoad?: boolean;
+        onProgress?: (resource: ProgressedResource) => unknown;
+        onProgressComplete?: (resource: ProgressedResource) => unknown;
+    }): Promise<{
+        load: LoaderModule["load"];
+        items: ReturnType<LoaderModule["items"]>;
+        loaders: ReturnType<LoaderModule["loaders"]>;
+        toLoad: ReturnType<LoaderModule["toLoad"]>;
+        loaded: ReturnType<LoaderModule["loaded"]>;
+        resources: ReturnType<LoaderModule["resources"]>;
+        worker?: threads.Worker;
+        thread?: threads.ModuleThread<ExposedLoaderModule> | undefined;
+    }>;
+    workerPool(): _quick_threejs_utils.WorkerPool;
+    canvas(): HTMLCanvasElement;
+    worker(): threads_dist_types_master.Worker | undefined;
+    thread(): threads.ModuleThread<ExposedAppModule> | undefined;
+    gui(): three_examples_jsm_libs_lil_gui_module_min.default | undefined;
+    dispose(): void;
+    lifecycle$(): rxjs.Observable<RegisterLifecycleState>;
+}
+
+/** @description Quick-three register properties. */
+declare class RegisterPropsModel {
+    /**
+     * @description The app worker logic location.
+     *
+     * @required
+     */
+    location: string;
+    /**
+     * @description App `canvas` element reference.
+     *
+     * @default undefined
+     */
+    canvas?: HTMLCanvasElement;
+    /**
+     * @description Set the `canvas` view in fullscreen and auto-resize it.
+     *
+     * @default true
+     */
+    fullScreen?: boolean;
+    /**
+     * Default used camera.
+     *
+     * @see {@link DefaultCameraType}
+     *
+     * @default DefaultCameraType.PERSPECTIVE
+     */
+    defaultCamera?: DefaultCameraType;
+    /**
+     * @description Start timer update on launch.
+     *
+     * @default true
+     */
+    startTimer?: boolean;
+    /**
+     * Enable the debug mode
+     *
+     * @default undefined
+     */
+    enableDebug?: boolean;
+    /**
+     * Define the {@link THREE.AxesHelper} sizes.
+     *
+     * @remark __Deactivated if the value is `0` or `undefined`__
+     * @remark __This property depends on {@link RegisterPropsModel.enableDebug}__
+     *
+     * @default undefined
+     */
+    axesSizes?: number;
+    /**
+     * Define the {@link THREE.GridHelper} sizes.
+     *
+     * @remark __Deactivated if the value is `0` or `undefined`__
+     * @remark __This property depends on {@link RegisterPropsModel.enableDebug}__
+     *
+     * @default undefined
+     */
+    gridSizes?: number;
+    /**
+     * Display a mini perfective camera at the top right corner of the screen.
+     *
+     * @remark __This property depends on {@link RegisterPropsModel.enableDebug}__
+     *
+     * @default false
+     */
+    withMiniCamera?: boolean;
+    /**
+     * @description Handler called when the app is ready.
+     *
+     * @default undefined
+     */
+    onReady?: (register: RegisterModule) => unknown;
+}
+
+interface CoreModuleMessageEventData extends Omit<RegisterPropsModel, "canvas" | "location"> {
+    /**
+     * The canvas element based on.
+     *
+     * @defaultValue `undefined`
+     */
+    canvas?: OffscreenCanvas;
+}
+interface CoreModuleMessageEvent extends MessageEvent<CoreModuleMessageEventData> {
+}
+
+interface StepPayload {
+    delta: number;
+    deltaRatio: number;
+}
+interface ProxyEvent {
+    width: number;
+    height: number;
+    windowWidth: number;
+    windowHeight: number;
+}
+
+declare class AppProxyEventHandlersModel {
+    contextmenu$?: () => Observable<MouseEvent & ProxyEvent>;
+    resize$?: () => Observable<UIEvent & ProxyEvent>;
+    mousedown$?: () => Observable<PointerEvent & ProxyEvent>;
+    mousemove$?: () => Observable<PointerEvent & ProxyEvent>;
+    mouseup$?: () => Observable<PointerEvent & ProxyEvent>;
+    pointerdown$?: () => Observable<PointerEvent & ProxyEvent>;
+    pointermove$?: () => Observable<PointerEvent & ProxyEvent>;
+    pointercancel$?: () => Observable<PointerEvent & ProxyEvent>;
+    pointerup$?: () => Observable<PointerEvent & ProxyEvent>;
+    touchstart$?: () => Observable<TouchEvent & ProxyEvent>;
+    touchmove$?: () => Observable<TouchEvent & ProxyEvent>;
+    touchend$?: () => Observable<TouchEvent & ProxyEvent>;
+    wheel$?: () => Observable<WheelEvent & ProxyEvent>;
+    keydown$?: () => Observable<KeyboardEvent & ProxyEvent>;
+    contextmenu: (e: MouseEvent & ProxyEvent) => void;
+    resize: (e: UIEvent & ProxyEvent) => void;
+    mousedown: (e: PointerEvent & ProxyEvent) => void;
+    mousemove: (e: PointerEvent & ProxyEvent) => void;
+    mouseup: (e: PointerEvent & ProxyEvent) => void;
+    pointerdown: (e: PointerEvent & ProxyEvent) => void;
+    pointermove: (e: PointerEvent & ProxyEvent) => void;
+    pointercancel: (e: PointerEvent & ProxyEvent) => void;
+    pointerup: (e: PointerEvent & ProxyEvent) => void;
+    touchstart: (e: TouchEvent & ProxyEvent) => void;
+    touchmove: (e: TouchEvent & ProxyEvent) => void;
+    touchend: (e: TouchEvent & ProxyEvent) => void;
+    wheel: (e: WheelEvent & ProxyEvent) => void;
+    keydown: (e: KeyboardEvent & ProxyEvent) => void;
+}
+
+declare class TimerComponent {
+    readonly clock: Clock;
+    readonly frame: number;
+    delta: number;
+    deltaRatio: number;
+    enabled: boolean;
+}
+
+declare class WorldComponent {
+    scene: Scene;
+    enabled: boolean;
+}
+
+declare class SizesComponent {
+    width: number;
+    height: number;
+    aspect: number;
+    pixelRatio: number;
+    frustrum: number;
+    enabled: boolean;
+    init(canvas: OffscreenCanvasWithStyle, enabled?: boolean): void;
+}
+
+declare class CameraComponent {
+    private readonly sizesComponent;
+    instance?: Camera;
+    miniCamera?: PerspectiveCamera;
+    enabled: boolean;
+    constructor(sizesComponent: SizesComponent);
+    set aspectRatio(ratio: number);
+    set quaternion(quaternion: Quaternion);
+    set position(position: Vector3);
+    set rotation(rotation: Euler);
+    initDefaultCamera(cameraType?: DefaultCameraType): void;
+    setMiniCamera(): void;
+    removeCamera(): void;
+    removeMiniCamera(): void;
+}
+
+declare class DebugComponent {
+    private readonly appComponent;
+    private readonly cameraComponent;
+    private readonly worldComponent;
+    enabled: boolean;
+    cameraControls?: OrbitControls;
+    miniCameraControls?: OrbitControls;
+    cameraHelper?: CameraHelper;
+    axesHelper?: AxesHelper;
+    gridHelper?: GridHelper;
+    constructor(appComponent: AppComponent, cameraComponent: CameraComponent, worldComponent: WorldComponent);
+    private _setCameraOrbitControl;
+    private _setMiniCameraOrbitControls;
+    private _setCameraHelper;
+    private _setAxesHelper;
+    private _setGridHelper;
+    init(props?: {
+        axesSizes?: number;
+        gridSizes?: number;
+    }): void;
+    update(): void;
+    dispose(): void;
+}
+
+declare class RendererComponent {
+    private readonly worldComponent;
+    private readonly cameraComponent;
+    private readonly sizesComponent;
+    private readonly debugComponent;
+    static readonly RENDERER_PIXEL_RATIO: number;
+    enabled: boolean;
+    instance?: WebGLRenderer;
+    constructor(worldComponent: WorldComponent, cameraComponent: CameraComponent, sizesComponent: SizesComponent, debugComponent: DebugComponent);
+    init(canvas: OffscreenCanvasWithStyle): void;
+    setSize(width: number, height: number): void;
+    render(): void;
+}
+
+declare class TimerController {
+    private readonly component;
+    private readonly appController;
+    readonly step$$: Subject<StepPayload>;
+    readonly enable$$: Subject<boolean>;
+    readonly step$: rxjs.Observable<StepPayload>;
+    readonly enable$: rxjs.Observable<boolean>;
+    constructor(component: TimerComponent, appController: AppController);
+    step(): void;
+}
+
+declare class TimerModule implements Module {
+    private readonly component;
+    private readonly controller;
+    private readonly rendererComponent;
+    constructor(component: TimerComponent, controller: TimerController, rendererComponent: RendererComponent);
+    init(startTimer?: boolean): void;
+    clock(): three.Clock;
+    frame(): number;
+    delta(value?: number): number;
+    deltaRatio(value?: number): number;
+    enabled(value?: boolean): boolean;
+    dispose(): void;
+    enabled$(): rxjs.Observable<boolean>;
+    step$(): rxjs.Observable<StepPayload>;
+}
+
+declare class CameraController {
+    private readonly component;
+    private readonly timerController;
+    readonly enable$$: Subject<boolean>;
+    readonly enable$: Observable<boolean>;
+    readonly step$: Observable<StepPayload>;
+    constructor(component: CameraComponent, timerController: TimerController);
+}
+
+declare class CameraModule implements Module {
+    private readonly component;
+    private readonly sizesComponent;
+    private readonly controller;
+    constructor(component: CameraComponent, sizesComponent: SizesComponent, controller: CameraController);
+    init(withMiniCamera?: boolean): void;
+    dispose(): void;
+    aspectRatio(value?: number): number;
+    enabled(value?: boolean): boolean;
+    instance(value?: Camera): Camera | undefined;
+    miniCamera(value?: PerspectiveCamera): PerspectiveCamera | undefined;
+    position(value?: Vector3): Vector3;
+    quaternion(value?: Quaternion): Quaternion;
+    enabled$(): rxjs.Observable<boolean>;
+}
+
+declare class SizesController {
+    private readonly appController;
+    private readonly component;
+    readonly enable$$: Subject<boolean>;
+    readonly enable$: Observable<boolean>;
+    readonly resize$: Observable<UIEvent & ProxyEvent>;
+    constructor(appController: AppController, component: SizesComponent);
+}
+
+declare class RendererController {
+    private readonly rendererComponent;
+    private readonly timerController;
+    private readonly sizesController;
+    readonly enable$$: Subject<boolean>;
+    readonly enable$: Observable<boolean>;
+    readonly step$: Observable<StepPayload>;
+    readonly resize$: Observable<UIEvent & ProxyEvent>;
+    constructor(rendererComponent: RendererComponent, timerController: TimerController, sizesController: SizesController);
+}
+
+declare class RendererModule implements Module {
+    private readonly component;
+    private readonly controller;
+    constructor(component: RendererComponent, controller: RendererController);
+    init(canvas: OffscreenCanvasWithStyle): void;
+    dispose(): void;
+    enabled(value?: boolean): boolean;
+    instance(): three.WebGLRenderer | undefined;
+    setSize(value: Vector2Like): void;
+    render(): void;
+    enabled$(): rxjs.Observable<boolean>;
+}
+
+declare class SizesModule implements Module {
+    private readonly component;
+    private readonly controller;
+    constructor(component: SizesComponent, controller: SizesController);
+    init(canvas: OffscreenCanvasWithStyle): void;
+    dispose(): void;
+    aspect(value?: number): number;
+    enabled(value?: boolean): boolean;
+    frustrum(value?: number): number;
+    height(value?: number): number;
+    pixelRatio(value?: number): number;
+    width(value?: number): number;
+    enabled$(): rxjs.Observable<boolean>;
+    resize$(): rxjs.Observable<UIEvent & ProxyEvent>;
+}
+
+declare class WorldController {
+    readonly enable$$: Subject<boolean>;
+    readonly enable$: rxjs.Observable<boolean>;
+}
+
+declare class WorldModule implements Module {
+    private readonly component;
+    private readonly controller;
+    constructor(component: WorldComponent, controller: WorldController);
+    init(): void;
+    dispose(): void;
+    scene(value?: Scene): Scene;
+    enabled(value?: boolean): boolean;
+    get enable$(): rxjs.Observable<boolean>;
+}
+
+declare class DebugController {
+    private readonly timerController;
+    readonly enable$$: Subject<boolean>;
+    readonly enable$: rxjs.Observable<boolean>;
+    readonly step$: TimerController["step$"];
+    constructor(timerController: TimerController);
+}
+
+declare class DebugModule implements Module {
+    readonly component: DebugComponent;
+    readonly controller: DebugController;
+    constructor(component: DebugComponent, controller: DebugController);
+    init(props?: Parameters<DebugComponent["init"]>[0]): void;
+    dispose(): void;
+    axesHelper(): three.AxesHelper | undefined;
+    cameraControls(): three_examples_jsm_Addons.OrbitControls | undefined;
+    cameraHelper(): three.CameraHelper | undefined;
+    enabled(value?: boolean): boolean;
+    gridHelper(): three.GridHelper | undefined;
+    miniCameraControls(): three_examples_jsm_Addons.OrbitControls | undefined;
+    enabled$(): rxjs.Observable<boolean>;
+}
+
+declare class AppModule extends AppProxyEventHandlersModel implements Module, WorkerThreadModule$1 {
+    private readonly controller;
+    private readonly component;
+    readonly timer: TimerModule;
+    readonly sizes: SizesModule;
+    readonly camera: CameraModule;
+    readonly world: WorldModule;
+    readonly renderer: RendererModule;
+    readonly debug: DebugModule;
+    constructor(controller: AppController, component: AppComponent, timer: TimerModule, sizes: SizesModule, camera: CameraModule, world: WorldModule, renderer: RendererModule, debug: DebugModule);
+    private _initProxyEvents;
+    private _onMessage;
+    init(props: CoreModuleMessageEventData): void;
+    get canvas(): OffscreenCanvasWithStyle | undefined;
+    get initialized(): boolean;
+    isInitialized(): boolean;
+    dispose(): void;
+    lifecycle$(): Observable<AppLifecycleState>;
+}
+declare const appModule: AppModule;
+
+export { AppModule as A, type CoreModuleMessageEventData as C, DefaultCameraType as D, type ExposedAppModule as E, KEYBOARD_EVENT_CODES as K, LoaderModule as L, type Module as M, type OffscreenCanvasWithStyle as O, PROXY_EVENT_LISTENERS as P, RegisterPropsModel as R, type StepPayload as S, RegisterModule as a, appModule as b, RegisterLifecycleState as c, AppLifecycleState as d, type CoreModuleMessageEvent as e, type ProxyEvent as f, type LoadedResourceItem as g, type Resource as h, type ProgressedResource as i, AppProxyEventHandlersModel as j, LaunchAppProps as k, loaderModule as l, ProxyEventHandlersModel as m, ProxyEventObservablesModel as n, ProxyEventSubjectsModel as o, RegisterProxyEventHandlersModel as p, type ProxyEventListenerKeys as q, type ProxyEventHandlersImplementation as r, type ProxyEventSubjectsImplementation as s, type ProxyEventObservablesImplementation as t, launchApp as u };