ohzi-core 12.2.0 → 12.3.0

package/types/CameraManager.d.ts

@@ -1,13 +1,14 @@
-import { Camera } from "three";
-
-export { camera_manager as CameraManager };
-declare const camera_manager: CameraManager;
-declare class CameraManager {
-    init(): void;
-    _current: Camera;
-    _spectator: Camera;
-    set current(arg: any);
-    get current(): any;
-    set spectator(arg: any);
-    get spectator(): any;
-}
+export { camera_manager as CameraManager };
+declare const camera_manager: CameraManager;
+declare class CameraManager {
+    init(): void;
+    _current: PerspectiveCamera;
+    _spectator: PerspectiveCamera;
+    set current(arg: PerspectiveCamera);
+    /** @type {PerspectiveCamera} */
+    get current(): PerspectiveCamera;
+    set spectator(arg: PerspectiveCamera);
+    /** @type {PerspectiveCamera} */
+    get spectator(): PerspectiveCamera;
+}
+import { PerspectiveCamera } from "./PerspectiveCamera";

package/types/Capabilities.d.ts

@@ -1,8 +1,8 @@
-export { capabilities as Capabilities };
-declare const capabilities: Capabilities;
-declare class Capabilities {
-    init(): void;
-    max_anisotropy: number;
-    vertex_texture_sampler_available: boolean;
-    fp_textures_available: boolean;
-}
+export { capabilities as Capabilities };
+declare const capabilities: Capabilities;
+declare class Capabilities {
+    init(): void;
+    max_anisotropy: number;
+    vertex_texture_sampler_available: boolean;
+    fp_textures_available: boolean;
+}

package/types/CustomBezierCurve.d.ts

@@ -1,7 +1,19 @@
-export class CustomBezierCurve {
-    constructor(points: any);
-    original_points: any[];
-    tmp_points: any[];
-    build(point_amount: any): any[];
-    get_point_at(t: any): any;
-}
+export class CustomBezierCurve {
+    /**
+     * @param {Vector3[]} points
+     */
+    constructor(points: Vector3[]);
+    original_points: Vector3[];
+    tmp_points: Vector3[];
+    /**
+     * @param {number} point_amount
+     * @returns {Vector3[]}
+     */
+    build(point_amount: number): Vector3[];
+    /**
+     * @param {number} t
+     * @returns {Vector3}
+     */
+    get_point_at(t: number): Vector3;
+}
+import { Vector3 } from "three/src/math/Vector3";

package/types/Debug.d.ts

@@ -1,37 +1,198 @@
-export { debug as Debug };
-declare const debug: Debug;
-declare class Debug {
-    init(): void;
-    Vector3_one: any;
-    Vector3_zero: any;
-    canvas_renderer: any;
-    display_texture_meshes: any[];
-    ctx: any;
-    scene: any;
-    camera: PerspectiveCamera;
-    draw_arrow(origin: any, dir: any, color?: number): Arrow;
-    draw_axis(): AxisHelper;
-    set_debug_RT(RT: any): void;
-    rt_debug: any;
-    draw_rectangle(position_2d: any, width: any, height: any, color: any): void;
-    clear(): void;
-    draw_line_2D(from: any, to: any, color: any): void;
-    draw_line(points: any, color?: number): any;
-    draw_cube(pos: any, size: any, color: any): Cube;
-    draw_oriented_cube(from: any, to: any, height?: number, color?: string, depth?: number): Cube;
-    draw_plane(width: any, height: any, color: any): any;
-    draw_empty_cube(pos: any, size: any, color: any): any;
-    draw_sphere(pos: any, size: any, color: any): Sphere;
-    draw_point_array(input_points: any, open?: boolean, color?: number): any;
-    draw_sphere_helper(sphere: any, color: any): any;
-    draw_math_sphere(sphere: any): void;
-    draw_bounding_box(bb: any): void;
-    draw_curve(curve: any, options: any): void;
-    draw_texture(tex: any, w: any, h: any): any;
-    render(graphics: any): void;
-}
-import { PerspectiveCamera } from "./PerspectiveCamera";
-import { Arrow } from "./primitives/Arrow";
-import { AxisHelper } from "./components/AxisHelper";
-import { Cube } from "./primitives/Cube";
-import { Sphere } from "./primitives/Sphere";
+export { debug as Debug };
+declare const debug: Debug;
+declare class Debug {
+    init(): void;
+    Vector3_one: Vector3;
+    Vector3_zero: Vector3;
+    canvas_renderer: any;
+    /** @type { Mesh<PlaneGeometry, ScreenSpaceTextureMaterial>[] } */
+    display_texture_meshes: Mesh<PlaneGeometry, ScreenSpaceTextureMaterial>[];
+    ctx: any;
+    scene: Scene;
+    camera: PerspectiveCamera;
+    /**
+     * @param {Vector3} origin
+     * @param {Vector3} dir
+     * @param {number | string} color
+     * @returns {Arrow}
+     */
+    draw_arrow(origin: Vector3, dir: Vector3, color?: number | string): Arrow;
+    draw_axis(): AxisHelper;
+    /**
+     * @param {RenderTarget} RT
+     */
+    set_debug_RT(RT: RenderTarget): void;
+    rt_debug: RenderTarget<Texture>;
+    /**
+     * @param {Vector2 | Vector3} position_2d
+     * @param {number} width
+     * @param {number} height
+     * @param {number | string} color
+     */
+    draw_rectangle(position_2d: Vector2 | Vector3, width: number, height: number, color: number | string): void;
+    clear(): void;
+    /**
+     * @param {Vector3 | Vector2} from
+     * @param {Vector3 | Vector2} to
+     * @param {number | string} color
+     */
+    draw_line_2D(from: Vector3 | Vector2, to: Vector3 | Vector2, color: number | string): void;
+    /**
+     * @param {Vector3[]} points
+     * @param {number | string} color
+     * @returns {Line}
+     */
+    draw_line(points: Vector3[], color?: number | string): Line;
+    /**
+     * @param {Vector3} pos
+     * @param {number} size
+     * @param {number | string} color
+     * @returns {Cube}
+     */
+    draw_cube(pos: Vector3, size: number, color: number | string): Cube;
+    /**
+     * @param {Vector3} from
+     * @param {Vector3} to
+     * @param {number} height
+     * @param {number | string} color
+     * @param {number} depth
+     * @returns {Cube}
+     */
+    draw_oriented_cube(from: Vector3, to: Vector3, height?: number, color?: number | string, depth?: number): Cube;
+    /**
+     *
+     * @param {number} [width]
+     * @param {number} [height]
+     * @param {number | string} [color]
+     * @returns
+     */
+    draw_plane(width?: number, height?: number, color?: number | string): Mesh<PlaneGeometry, ShaderMaterial, import("three").Object3DEventMap>;
+    /**
+     * @param {Vector3} pos
+     * @param {number} size
+     * @param {number | string} color
+     * @returns {Box3Helper}
+     */
+    draw_empty_cube(pos: Vector3, size: number, color: number | string): Box3Helper;
+    /**
+     * @param {Vector3} pos
+     * @param {number} size
+     * @param {number | string} color
+     * @returns {Sphere}
+     */
+    draw_sphere(pos: Vector3, size: number, color: number | string): Sphere;
+    /**
+     *
+     * @param {Vector3[]} input_points
+     * @param {boolean} open
+     * @param {number | string} color
+     * @returns {Line}
+     */
+    draw_point_array(input_points: Vector3[], open?: boolean, color?: number | string): Line;
+    /**
+     * @param {Sphere} sphere
+     * @param {number | string} color
+     * @returns {Mesh}
+     */
+    draw_sphere_helper(sphere: Sphere, color: number | string): Mesh;
+    /**
+     * @param {Sphere} sphere
+     */
+    draw_math_sphere(sphere: Sphere): void;
+    /**
+     * @param {Box3} bb
+     */
+    draw_bounding_box(bb: Box3): void;
+    /**
+     * @param {Vector3[]} curve
+     * @param {object} options
+     * @param {number} options.offset
+     */
+    draw_curve(curve: Vector3[], options: {
+        offset: number;
+    }): void;
+    /**
+     * @param {Texture} tex
+     * @param {number} w
+     * @param {number} h
+     * @returns {Mesh}
+     */
+    draw_texture(tex: Texture, w: number, h: number): Mesh;
+    /**
+     * @param {Graphics} graphics
+     */
+    render(graphics: {
+        init({ canvas, core_attributes, context_attributes, threejs_attributes, dpr }: {
+            canvas: HTMLCanvasElement;
+            core_attributes: Record<string, any>;
+            context_attributes: Record<string, any>;
+            threejs_attributes: Record<string, any>;
+            dpr: number;
+        }): void;
+        _renderer: WebGLRenderer;
+        blitter: import("./render_utilities/Blitter").Blitter;
+        canvas: HTMLCanvasElement;
+        no_render: import("./render_mode/BaseRender").BaseRender;
+        current_render_mode: import("./render_mode/BaseRender").BaseRender;
+        generateDepthNormalTexture: boolean;
+        depth_and_normals_renderer: import("./render_utilities/DepthAndNormalsRenderer").DepthAndNormalsRenderer;
+        is_webgl2: boolean;
+        canvas_context: RenderingContext;
+        context_attributes: {
+            alpha: boolean;
+            antialias: boolean;
+            depth: boolean;
+            desynchronized: boolean;
+            failIfMajorPerformanceCaveat: boolean;
+            powerPreference: string;
+            premultipliedAlpha: boolean;
+            preserveDrawingBuffer: boolean;
+            stencil: boolean;
+        };
+        core_attributes: {
+            force_webgl2: boolean;
+            xr_enabled: boolean;
+        };
+        threejs_attributes: Record<string, any>;
+        readonly dom_element: HTMLCanvasElement;
+        readonly depth_normals_RT: import("three").WebGLRenderTarget<Texture>;
+        set_state(new_state: import("./render_mode/BaseRender").BaseRender): void;
+        update(): void;
+        __update_current_camera(): void;
+        render(scene?: Scene, camera?: PerspectiveCamera | import("./OrthographicCamera").OrthographicCamera, RT?: import("three").WebGLRenderTarget<Texture>, override_mat?: import("three").Material): void;
+        compile(scene: Scene, camera: PerspectiveCamera, RT: import("three").WebGLRenderTarget<Texture>, override_mat: import("three").Material): void;
+        compile_async(scene: Scene, camera: PerspectiveCamera, RT: import("three").WebGLRenderTarget<Texture>, override_mat: import("three").Material, target_scene: Scene): Promise<import("three").Object3D<import("three").Object3DEventMap>>;
+        render_scene(scene: Scene | import("./BaseApplication").BaseApplication | {
+            render: () => void;
+        }): void;
+        __apply_override_material(scene: Scene, mat: import("three").Material): void;
+        readback_RT(RT: import("three").WebGLRenderTarget<Texture>, buffer: import("three").TypedArray): void;
+        clear(RT: import("three").WebGLRenderTarget<Texture>, camera: PerspectiveCamera, clear_depth: boolean, clear_stencil: boolean): void;
+        on_resize(entries: ResizeObserverEntry[], dpr: number): void;
+        material_pass(mat: import("three").Material, dst: import("three").WebGLRenderTarget<Texture>): void;
+        blit(src_RT: import("three").WebGLRenderTarget<Texture>, dst_RT: import("three").WebGLRenderTarget<Texture>, mat: import("three").Material): void;
+        blit_clear_with_material(dst_RT: import("three").WebGLRenderTarget<Texture>, mat: import("three").Material): void;
+        take_screenshot(blob_callback: BlobCallback, width?: number, height?: number): void;
+        download_screenshot(blob: Blob): void;
+        dispose(): void;
+        is_floating_point_texture_available(): boolean;
+    }): void;
+}
+import { Vector3 } from "three/src/math/Vector3";
+import { Mesh } from "three/src/objects/Mesh";
+import { PlaneGeometry } from "three/src/geometries/PlaneGeometry";
+import { ScreenSpaceTextureMaterial } from "./materials/ScreenSpaceTextureMaterial";
+import { Scene } from "three/src/scenes/Scene";
+import { PerspectiveCamera } from "./PerspectiveCamera";
+import { Arrow } from "./primitives/Arrow";
+import { AxisHelper } from "./components/AxisHelper";
+import { RenderTarget } from "three/src/core/RenderTarget";
+import { Texture } from "three/src/textures/Texture";
+import { Vector2 } from "three/src/math/Vector2";
+import { Line } from "three/src/objects/Line";
+import { Cube } from "./primitives/Cube";
+import { ShaderMaterial } from "three/src/materials/ShaderMaterial";
+import { Box3Helper } from "three/src/helpers/Box3Helper";
+import { Sphere } from "./primitives/Sphere";
+import { Box3 } from "three/src/math/Box3";
+import { WebGLRenderer } from "three/src/renderers/WebGLRenderer";

package/types/Graphics.d.ts

@@ -1,61 +1,143 @@
-export { graphics as Graphics };
-declare const graphics: Graphics;
-declare class Graphics {
-    init({ canvas, core_attributes, context_attributes, threejs_attributes, dpr }: {
-        canvas: any;
-        core_attributes: any;
-        context_attributes: any;
-        threejs_attributes: any;
-        dpr: any;
-    }): void;
-    _renderer: any;
-    blitter: Blitter;
-    canvas: any;
-    no_render: BaseRender;
-    current_render_mode: any;
-    generateDepthNormalTexture: boolean;
-    depth_and_normals_renderer: DepthAndNormalsRenderer;
-    is_webgl2: boolean;
-    canvas_context: any;
-    context_attributes: {
-        alpha: boolean;
-        antialias: boolean;
-        depth: boolean;
-        desynchronized: boolean;
-        failIfMajorPerformanceCaveat: boolean;
-        powerPreference: string;
-        premultipliedAlpha: boolean;
-        preserveDrawingBuffer: boolean;
-        stencil: boolean;
-    };
-    core_attributes: {
-        force_webgl2: boolean;
-        xr_enabled: boolean;
-    };
-    threejs_attributes: {
-        logarithmicDepthBuffer: boolean;
-    };
-    get dom_element(): any;
-    get depth_normals_RT(): any;
-    set_state(new_state: any): void;
-    update(): void;
-    __update_current_camera(): void;
-    render(scene: any, camera: any, RT: any, override_mat: any): void;
-    compile(scene: any, camera: any, RT: any, override_mat: any): void;
-    compile_async(scene: any, camera: any, RT: any, override_mat: any, target_scene: any): Promise<any>;
-    render_scene(scene: any): void;
-    __apply_override_material(scene: any, mat: any): void;
-    readback_RT(RT: any, buffer: any): void;
-    clear(RT: any, camera: any, clear_depth: any, clear_stencil: any): void;
-    on_resize(entries: any, dpr: any): void;
-    material_pass(mat: any, dst: any): void;
-    blit(src_RT: any, dst_RT: any, mat: any): void;
-    blit_clear_with_material(dst_RT: any, mat: any): void;
-    take_screenshot(blob_callback: any, width?: any, height?: any): void;
-    download_screenshot(blob: any): void;
-    dispose(): void;
-    is_floating_point_texture_available(): boolean;
-}
-import { Blitter } from "./render_utilities/Blitter";
-import { BaseRender } from "./render_mode/BaseRender";
-import { DepthAndNormalsRenderer } from "./render_utilities/DepthAndNormalsRenderer";
+export { graphics as Graphics };
+declare const graphics: Graphics;
+declare class Graphics {
+    /**
+     * @param {Object} options
+     * @param {HTMLCanvasElement} options.canvas
+     * @param {Record<string, any>} options.core_attributes
+     * @param {Record<string, any>} options.context_attributes
+     * @param {Record<string, any>} options.threejs_attributes
+     * @param {number} options.dpr
+     */
+    init({ canvas, core_attributes, context_attributes, threejs_attributes, dpr }: {
+        canvas: HTMLCanvasElement;
+        core_attributes: Record<string, any>;
+        context_attributes: Record<string, any>;
+        threejs_attributes: Record<string, any>;
+        dpr: number;
+    }): void;
+    _renderer: WebGLRenderer;
+    blitter: Blitter;
+    canvas: HTMLCanvasElement;
+    no_render: BaseRender;
+    current_render_mode: BaseRender;
+    generateDepthNormalTexture: boolean;
+    depth_and_normals_renderer: DepthAndNormalsRenderer;
+    is_webgl2: boolean;
+    canvas_context: RenderingContext;
+    context_attributes: {
+        alpha: boolean;
+        antialias: boolean;
+        depth: boolean;
+        desynchronized: boolean;
+        failIfMajorPerformanceCaveat: boolean;
+        powerPreference: string;
+        premultipliedAlpha: boolean;
+        preserveDrawingBuffer: boolean;
+        stencil: boolean;
+    };
+    core_attributes: {
+        force_webgl2: boolean;
+        xr_enabled: boolean;
+    };
+    /** @type {Record<string, any>} */
+    threejs_attributes: Record<string, any>;
+    get dom_element(): HTMLCanvasElement;
+    get depth_normals_RT(): WebGLRenderTarget<import("three").Texture>;
+    /**
+     * @param {BaseRender} new_state
+     */
+    set_state(new_state: BaseRender): void;
+    update(): void;
+    __update_current_camera(): void;
+    /**
+     * @param {Scene} [scene]
+     * @param {PerspectiveCamera | OrthographicCamera} [camera]
+     * @param {WebGLRenderTarget} [RT]
+     * @param {Material} [override_mat]
+     */
+    render(scene?: Scene, camera?: PerspectiveCamera | OrthographicCamera, RT?: WebGLRenderTarget, override_mat?: Material): void;
+    /**
+     * @param {Scene} scene
+     * @param {PerspectiveCamera} camera
+     * @param {WebGLRenderTarget} RT
+     * @param {Material} override_mat
+     */
+    compile(scene: Scene, camera: PerspectiveCamera, RT: WebGLRenderTarget, override_mat: Material): void;
+    /**
+     * @param {Scene} scene
+     * @param {PerspectiveCamera} camera
+     * @param {WebGLRenderTarget} RT
+     * @param {Material} override_mat
+     * @param {Scene} target_scene
+     * @returns {Promise<Object3D>}
+     */
+    compile_async(scene: Scene, camera: PerspectiveCamera, RT: WebGLRenderTarget, override_mat: Material, target_scene: Scene): Promise<Object3D>;
+    /**
+     * @param {BaseApplication | Scene | {render:()=>void}} scene
+     */
+    render_scene(scene: BaseApplication | Scene | {
+        render: () => void;
+    }): void;
+    /**
+     * @param {Scene} scene
+     * @param {Material} mat
+     */
+    __apply_override_material(scene: Scene, mat: Material): void;
+    /**
+     * @param {WebGLRenderTarget} RT
+     * @param {import('three').TypedArray} buffer
+     */
+    readback_RT(RT: WebGLRenderTarget, buffer: import('three').TypedArray): void;
+    /**
+     * @param {WebGLRenderTarget} RT
+     * @param {PerspectiveCamera} camera
+     * @param {boolean} clear_depth
+     * @param {boolean} clear_stencil
+     */
+    clear(RT: WebGLRenderTarget, camera: PerspectiveCamera, clear_depth: boolean, clear_stencil: boolean): void;
+    /**
+     * @param {ResizeObserverEntry[]} entries
+     * @param {number} dpr
+     */
+    on_resize(entries: ResizeObserverEntry[], dpr: number): void;
+    /**
+     * @param {Material} mat
+     * @param {WebGLRenderTarget} dst
+     */
+    material_pass(mat: Material, dst: WebGLRenderTarget): void;
+    /**
+     * @param {WebGLRenderTarget} src_RT
+     * @param {WebGLRenderTarget} dst_RT
+     * @param {Material} mat
+     */
+    blit(src_RT: WebGLRenderTarget, dst_RT: WebGLRenderTarget, mat: Material): void;
+    /**
+     * @param {WebGLRenderTarget} dst_RT
+     * @param {Material} mat
+     */
+    blit_clear_with_material(dst_RT: WebGLRenderTarget, mat: Material): void;
+    /**
+     * @param {BlobCallback} blob_callback
+     * @param {number} width
+     * @param {number} height
+     */
+    take_screenshot(blob_callback: BlobCallback, width?: number, height?: number): void;
+    /**
+     * @param {Blob} blob
+     */
+    download_screenshot(blob: Blob): void;
+    dispose(): void;
+    is_floating_point_texture_available(): boolean;
+}
+import { WebGLRenderer } from "three/src/renderers/WebGLRenderer";
+import { Blitter } from "./render_utilities/Blitter";
+import { BaseRender } from "./render_mode/BaseRender";
+import { DepthAndNormalsRenderer } from "./render_utilities/DepthAndNormalsRenderer";
+import { WebGLRenderTarget } from "three/src/renderers/WebGLRenderTarget";
+import { Scene } from "three/src/scenes/Scene";
+import { PerspectiveCamera } from "./PerspectiveCamera";
+import { OrthographicCamera } from "./OrthographicCamera";
+import { Material } from "three/src/materials/Material";
+import { Object3D } from "three/src/core/Object3D";
+import { BaseApplication } from "./BaseApplication";

package/types/Initializer.d.ts

@@ -1,6 +1,10 @@
-export { initializer as Initializer };
-declare const initializer: Initializer;
-declare class Initializer {
-    init(input: any): void;
-    dispose(render_loop: any): void;
-}
+export { initializer as Initializer };
+declare const initializer: Initializer;
+declare class Initializer {
+    init(input: any): void;
+    /**
+     * @param {RenderLoop} render_loop
+     */
+    dispose(render_loop: RenderLoop): void;
+}
+import { RenderLoop } from "./index";

package/types/KeyboardInput.d.ts

@@ -1,20 +1,65 @@
-export class KeyboardInput {
-    init(container: any): void;
-    ctrlz_pressed: boolean;
-    ctrlz_fired: boolean;
-    keys: {};
-    keys_keys: any[] | string[];
-    container: any;
-    on_key_down(e: any): void;
-    on_key_up(e: any): void;
-    clear(): void;
-    release_key(key_name: any): void;
-    release_keys(): void;
-    press_key(key_name: any): void;
-    is_key_pressed(key_name: any): any;
-    is_key_down(key_name: any): any;
-    is_key_released(key_name: any): any;
-    register_key(key: any): void;
-    unregister_key(key_name: any): void;
-    dispose(): void;
-}
+export class KeyboardInput {
+    /**
+     * @param {HTMLElement} container
+     */
+    init(container: HTMLElement): void;
+    ctrlz_pressed: boolean;
+    ctrlz_fired: boolean;
+    /**
+     * @type {{[key:string]:{key_name: string, pressed: boolean, down: boolean, fired: boolean, released: boolean}}}
+     */
+    keys: {
+        [key: string]: {
+            key_name: string;
+            pressed: boolean;
+            down: boolean;
+            fired: boolean;
+            released: boolean;
+        };
+    };
+    /** @type {string[]} */
+    keys_keys: string[];
+    container: HTMLElement;
+    /**
+     * @param {KeyboardEvent} e
+     */
+    on_key_down(e: KeyboardEvent): void;
+    /**
+     * @param {KeyboardEvent} e
+     */
+    on_key_up(e: KeyboardEvent): void;
+    clear(): void;
+    /**
+     * @param {string} key_name
+     */
+    release_key(key_name: string): void;
+    release_keys(): void;
+    /**
+     * @param {string} key_name
+     */
+    press_key(key_name: string): void;
+    /**
+     * @param {string} key_name
+     * @returns {boolean}
+     */
+    is_key_pressed(key_name: string): boolean;
+    /**
+     * @param {string} key_name
+     * @returns {boolean}
+     */
+    is_key_down(key_name: string): boolean;
+    /**
+     * @param {string} key_name
+     * @returns {boolean}
+     */
+    is_key_released(key_name: string): boolean;
+    /**
+     * @param {string} key
+     */
+    register_key(key: string): void;
+    /**
+     * @param {string} key_name
+     */
+    unregister_key(key_name: string): void;
+    dispose(): void;
+}

package/types/OS.d.ts

@@ -1,20 +1,20 @@
-export { os as OS };
-declare const os: OS;
-declare class OS {
-    init(): void;
-    operating_systems: {
-        ANDROID: string;
-        IOS: string;
-        LINUX: string;
-        MAC: string;
-        WINDOWS: string;
-    };
-    is_mobile: boolean;
-    is_ipad: boolean;
-    is_ios: boolean;
-    is_android: boolean;
-    is_linux: boolean;
-    is_mac: boolean;
-    is_windows: boolean;
-    get_os(): string;
-}
+export { os as OS };
+declare const os: OS;
+declare class OS {
+    init(): void;
+    operating_systems: {
+        ANDROID: string;
+        IOS: string;
+        LINUX: string;
+        MAC: string;
+        WINDOWS: string;
+    };
+    is_mobile: boolean;
+    is_ipad: boolean;
+    is_ios: boolean;
+    is_android: boolean;
+    is_linux: boolean;
+    is_mac: boolean;
+    is_windows: boolean;
+    get_os(): string;
+}