@defold-typescript/types 0.1.0

package/generated/gui.d.ts

@@ -0,0 +1,245 @@
+/** @noSelfInFile */
+import type { Hash, Opaque, Quaternion, Url, Vector, Vector3, Vector4 } from "../src/core-types";
+
+declare global {
+  namespace gui {
+    const ADJUST_FIT: number & { readonly __brand: "gui.ADJUST_FIT" };
+    const ADJUST_STRETCH: number & { readonly __brand: "gui.ADJUST_STRETCH" };
+    const ADJUST_ZOOM: number & { readonly __brand: "gui.ADJUST_ZOOM" };
+    const ANCHOR_BOTTOM: number & { readonly __brand: "gui.ANCHOR_BOTTOM" };
+    const ANCHOR_LEFT: number & { readonly __brand: "gui.ANCHOR_LEFT" };
+    const ANCHOR_NONE: number & { readonly __brand: "gui.ANCHOR_NONE" };
+    const ANCHOR_RIGHT: number & { readonly __brand: "gui.ANCHOR_RIGHT" };
+    const ANCHOR_TOP: number & { readonly __brand: "gui.ANCHOR_TOP" };
+    const BLEND_ADD: number & { readonly __brand: "gui.BLEND_ADD" };
+    const BLEND_ADD_ALPHA: number & { readonly __brand: "gui.BLEND_ADD_ALPHA" };
+    const BLEND_ALPHA: number & { readonly __brand: "gui.BLEND_ALPHA" };
+    const BLEND_MULT: number & { readonly __brand: "gui.BLEND_MULT" };
+    const BLEND_SCREEN: number & { readonly __brand: "gui.BLEND_SCREEN" };
+    const CLIPPING_MODE_NONE: number & { readonly __brand: "gui.CLIPPING_MODE_NONE" };
+    const CLIPPING_MODE_STENCIL: number & { readonly __brand: "gui.CLIPPING_MODE_STENCIL" };
+    const EASING_INBACK: number & { readonly __brand: "gui.EASING_INBACK" };
+    const EASING_INBOUNCE: number & { readonly __brand: "gui.EASING_INBOUNCE" };
+    const EASING_INCIRC: number & { readonly __brand: "gui.EASING_INCIRC" };
+    const EASING_INCUBIC: number & { readonly __brand: "gui.EASING_INCUBIC" };
+    const EASING_INELASTIC: number & { readonly __brand: "gui.EASING_INELASTIC" };
+    const EASING_INEXPO: number & { readonly __brand: "gui.EASING_INEXPO" };
+    const EASING_INOUTBACK: number & { readonly __brand: "gui.EASING_INOUTBACK" };
+    const EASING_INOUTBOUNCE: number & { readonly __brand: "gui.EASING_INOUTBOUNCE" };
+    const EASING_INOUTCIRC: number & { readonly __brand: "gui.EASING_INOUTCIRC" };
+    const EASING_INOUTCUBIC: number & { readonly __brand: "gui.EASING_INOUTCUBIC" };
+    const EASING_INOUTELASTIC: number & { readonly __brand: "gui.EASING_INOUTELASTIC" };
+    const EASING_INOUTEXPO: number & { readonly __brand: "gui.EASING_INOUTEXPO" };
+    const EASING_INOUTQUAD: number & { readonly __brand: "gui.EASING_INOUTQUAD" };
+    const EASING_INOUTQUART: number & { readonly __brand: "gui.EASING_INOUTQUART" };
+    const EASING_INOUTQUINT: number & { readonly __brand: "gui.EASING_INOUTQUINT" };
+    const EASING_INOUTSINE: number & { readonly __brand: "gui.EASING_INOUTSINE" };
+    const EASING_INQUAD: number & { readonly __brand: "gui.EASING_INQUAD" };
+    const EASING_INQUART: number & { readonly __brand: "gui.EASING_INQUART" };
+    const EASING_INQUINT: number & { readonly __brand: "gui.EASING_INQUINT" };
+    const EASING_INSINE: number & { readonly __brand: "gui.EASING_INSINE" };
+    const EASING_LINEAR: number & { readonly __brand: "gui.EASING_LINEAR" };
+    const EASING_OUTBACK: number & { readonly __brand: "gui.EASING_OUTBACK" };
+    const EASING_OUTBOUNCE: number & { readonly __brand: "gui.EASING_OUTBOUNCE" };
+    const EASING_OUTCIRC: number & { readonly __brand: "gui.EASING_OUTCIRC" };
+    const EASING_OUTCUBIC: number & { readonly __brand: "gui.EASING_OUTCUBIC" };
+    const EASING_OUTELASTIC: number & { readonly __brand: "gui.EASING_OUTELASTIC" };
+    const EASING_OUTEXPO: number & { readonly __brand: "gui.EASING_OUTEXPO" };
+    const EASING_OUTINBACK: number & { readonly __brand: "gui.EASING_OUTINBACK" };
+    const EASING_OUTINBOUNCE: number & { readonly __brand: "gui.EASING_OUTINBOUNCE" };
+    const EASING_OUTINCIRC: number & { readonly __brand: "gui.EASING_OUTINCIRC" };
+    const EASING_OUTINCUBIC: number & { readonly __brand: "gui.EASING_OUTINCUBIC" };
+    const EASING_OUTINELASTIC: number & { readonly __brand: "gui.EASING_OUTINELASTIC" };
+    const EASING_OUTINEXPO: number & { readonly __brand: "gui.EASING_OUTINEXPO" };
+    const EASING_OUTINQUAD: number & { readonly __brand: "gui.EASING_OUTINQUAD" };
+    const EASING_OUTINQUART: number & { readonly __brand: "gui.EASING_OUTINQUART" };
+    const EASING_OUTINQUINT: number & { readonly __brand: "gui.EASING_OUTINQUINT" };
+    const EASING_OUTINSINE: number & { readonly __brand: "gui.EASING_OUTINSINE" };
+    const EASING_OUTQUAD: number & { readonly __brand: "gui.EASING_OUTQUAD" };
+    const EASING_OUTQUART: number & { readonly __brand: "gui.EASING_OUTQUART" };
+    const EASING_OUTQUINT: number & { readonly __brand: "gui.EASING_OUTQUINT" };
+    const EASING_OUTSINE: number & { readonly __brand: "gui.EASING_OUTSINE" };
+    const KEYBOARD_TYPE_DEFAULT: number & { readonly __brand: "gui.KEYBOARD_TYPE_DEFAULT" };
+    const KEYBOARD_TYPE_EMAIL: number & { readonly __brand: "gui.KEYBOARD_TYPE_EMAIL" };
+    const KEYBOARD_TYPE_NUMBER_PAD: number & { readonly __brand: "gui.KEYBOARD_TYPE_NUMBER_PAD" };
+    const KEYBOARD_TYPE_PASSWORD: number & { readonly __brand: "gui.KEYBOARD_TYPE_PASSWORD" };
+    const PIEBOUNDS_ELLIPSE: number & { readonly __brand: "gui.PIEBOUNDS_ELLIPSE" };
+    const PIEBOUNDS_RECTANGLE: number & { readonly __brand: "gui.PIEBOUNDS_RECTANGLE" };
+    const PIVOT_CENTER: number & { readonly __brand: "gui.PIVOT_CENTER" };
+    const PIVOT_E: number & { readonly __brand: "gui.PIVOT_E" };
+    const PIVOT_N: number & { readonly __brand: "gui.PIVOT_N" };
+    const PIVOT_NE: number & { readonly __brand: "gui.PIVOT_NE" };
+    const PIVOT_NW: number & { readonly __brand: "gui.PIVOT_NW" };
+    const PIVOT_S: number & { readonly __brand: "gui.PIVOT_S" };
+    const PIVOT_SE: number & { readonly __brand: "gui.PIVOT_SE" };
+    const PIVOT_SW: number & { readonly __brand: "gui.PIVOT_SW" };
+    const PIVOT_W: number & { readonly __brand: "gui.PIVOT_W" };
+    const PLAYBACK_LOOP_BACKWARD: number & { readonly __brand: "gui.PLAYBACK_LOOP_BACKWARD" };
+    const PLAYBACK_LOOP_FORWARD: number & { readonly __brand: "gui.PLAYBACK_LOOP_FORWARD" };
+    const PLAYBACK_LOOP_PINGPONG: number & { readonly __brand: "gui.PLAYBACK_LOOP_PINGPONG" };
+    const PLAYBACK_ONCE_BACKWARD: number & { readonly __brand: "gui.PLAYBACK_ONCE_BACKWARD" };
+    const PLAYBACK_ONCE_FORWARD: number & { readonly __brand: "gui.PLAYBACK_ONCE_FORWARD" };
+    const PLAYBACK_ONCE_PINGPONG: number & { readonly __brand: "gui.PLAYBACK_ONCE_PINGPONG" };
+    const PROP_COLOR: number & { readonly __brand: "gui.PROP_COLOR" };
+    const PROP_EULER: number & { readonly __brand: "gui.PROP_EULER" };
+    const PROP_FILL_ANGLE: number & { readonly __brand: "gui.PROP_FILL_ANGLE" };
+    const PROP_INNER_RADIUS: number & { readonly __brand: "gui.PROP_INNER_RADIUS" };
+    const PROP_LEADING: number & { readonly __brand: "gui.PROP_LEADING" };
+    const PROP_OUTLINE: number & { readonly __brand: "gui.PROP_OUTLINE" };
+    const PROP_POSITION: number & { readonly __brand: "gui.PROP_POSITION" };
+    const PROP_ROTATION: number & { readonly __brand: "gui.PROP_ROTATION" };
+    const PROP_SCALE: number & { readonly __brand: "gui.PROP_SCALE" };
+    const PROP_SHADOW: number & { readonly __brand: "gui.PROP_SHADOW" };
+    const PROP_SIZE: number & { readonly __brand: "gui.PROP_SIZE" };
+    const PROP_SLICE9: number & { readonly __brand: "gui.PROP_SLICE9" };
+    const PROP_TRACKING: number & { readonly __brand: "gui.PROP_TRACKING" };
+    const RESULT_DATA_ERROR: number & { readonly __brand: "gui.RESULT_DATA_ERROR" };
+    const RESULT_OUT_OF_RESOURCES: number & { readonly __brand: "gui.RESULT_OUT_OF_RESOURCES" };
+    const RESULT_TEXTURE_ALREADY_EXISTS: number & { readonly __brand: "gui.RESULT_TEXTURE_ALREADY_EXISTS" };
+    const SAFE_AREA_BOTH: number & { readonly __brand: "gui.SAFE_AREA_BOTH" };
+    const SAFE_AREA_LONG: number & { readonly __brand: "gui.SAFE_AREA_LONG" };
+    const SAFE_AREA_NONE: number & { readonly __brand: "gui.SAFE_AREA_NONE" };
+    const SAFE_AREA_SHORT: number & { readonly __brand: "gui.SAFE_AREA_SHORT" };
+    const SIZE_MODE_AUTO: number & { readonly __brand: "gui.SIZE_MODE_AUTO" };
+    const SIZE_MODE_MANUAL: number & { readonly __brand: "gui.SIZE_MODE_MANUAL" };
+    const TYPE_BOX: number & { readonly __brand: "gui.TYPE_BOX" };
+    const TYPE_CUSTOM: number & { readonly __brand: "gui.TYPE_CUSTOM" };
+    const TYPE_PARTICLEFX: number & { readonly __brand: "gui.TYPE_PARTICLEFX" };
+    const TYPE_PIE: number & { readonly __brand: "gui.TYPE_PIE" };
+    const TYPE_TEXT: number & { readonly __brand: "gui.TYPE_TEXT" };
+    function animate(node: Opaque<"node">, property: string | Opaque<"constant">, to: number | Vector3 | Vector4 | Quaternion, easing: Opaque<"constant"> | Vector, duration: number, delay?: number, complete_function?: (self: unknown, node: unknown) => void, playback?: Opaque<"constant">): void;
+    function cancel_animations(node: Opaque<"node">, property?: string | Opaque<"constant">): void;
+    function cancel_flipbook(node: Opaque<"node">): void;
+    function clone(node: Opaque<"node">): Opaque<"node">;
+    function clone_tree(node: Opaque<"node">): LuaMap<Hash, Opaque<"node">>;
+    function delete_node(node: Opaque<"node">): void;
+    function delete_texture(texture: string | Hash): void;
+    function final(self: Opaque<"userdata">): void;
+    function get(node: Opaque<"node">, property: string | Hash | Opaque<"constant">, options?: { index?: number }): void;
+    function get_adjust_mode(node: Opaque<"node">): Opaque<"constant">;
+    function get_alpha(node: Opaque<"node">): number;
+    function get_blend_mode(node: Opaque<"node">): Opaque<"constant">;
+    function get_clipping_inverted(node: Opaque<"node">): boolean;
+    function get_clipping_mode(node: Opaque<"node">): Opaque<"constant">;
+    function get_clipping_visible(node: Opaque<"node">): boolean;
+    function get_color(node: Opaque<"node">): Vector4;
+    function get_euler(node: Opaque<"node">): Vector3;
+    function get_fill_angle(node: Opaque<"node">): number;
+    function get_flipbook(node: Opaque<"node">): Hash;
+    function get_flipbook_cursor(node: Opaque<"node">): number;
+    function get_flipbook_playback_rate(node: Opaque<"node">): number;
+    function get_font(node: Opaque<"node">): Hash;
+    function get_font_resource(font_name: Hash | string): Hash;
+    function get_height(): number;
+    function get_id(node: Opaque<"node">): Hash;
+    function get_index(node: Opaque<"node">): number;
+    function get_inherit_alpha(node: Opaque<"node">): boolean;
+    function get_inner_radius(node: Opaque<"node">): number;
+    function get_layer(node: Opaque<"node">): Hash;
+    function get_layout(): Hash;
+    function get_layouts(): LuaMap<Hash, Vector3>;
+    function get_leading(node: Opaque<"node">): number;
+    function get_line_break(node: Opaque<"node">): boolean;
+    function get_material(node: Opaque<"node">): Hash;
+    function get_node(id: string | Hash): Opaque<"node">;
+    function get_outer_bounds(node: Opaque<"node">): Opaque<"constant">;
+    function get_outline(node: Opaque<"node">): Vector4;
+    function get_parent(node: Opaque<"node">): Opaque<"node"> | unknown;
+    function get_particlefx(node: Opaque<"node">): Hash;
+    function get_perimeter_vertices(node: Opaque<"node">): number;
+    function get_pivot(node: Opaque<"node">): Opaque<"constant">;
+    function get_position(node: Opaque<"node">): Vector3;
+    function get_rotation(node: Opaque<"node">): Quaternion;
+    function get_scale(node: Opaque<"node">): Vector3;
+    function get_screen_position(node: Opaque<"node">): Vector3;
+    function get_shadow(node: Opaque<"node">): Vector4;
+    function get_size(node: Opaque<"node">): Vector3;
+    function get_size_mode(node: Opaque<"node">): Opaque<"constant">;
+    function get_slice9(node: Opaque<"node">): Vector4;
+    function get_text(node: Opaque<"node">): string;
+    function get_texture(node: Opaque<"node">): Hash;
+    function get_tracking(node: Opaque<"node">): number;
+    function get_tree(node: Opaque<"node">): LuaMap<Hash, Opaque<"node">>;
+    function get_type(node: Opaque<"node">): LuaMultiReturn<[Opaque<"constant">, number | unknown]>;
+    function get_visible(node: Opaque<"node">): boolean;
+    function get_width(): number;
+    function get_xanchor(node: Opaque<"node">): Opaque<"constant">;
+    function get_yanchor(node: Opaque<"node">): Opaque<"constant">;
+    function hide_keyboard(): void;
+    function init(self: Opaque<"userdata">): void;
+    function is_enabled(node: Opaque<"node">, recursive?: boolean): boolean;
+    function move_above(node: Opaque<"node">, reference?: Opaque<"node">): void;
+    function move_below(node: Opaque<"node">, reference?: Opaque<"node">): void;
+    function new_box_node(pos: Vector3 | Vector4, size: Vector3): Opaque<"node">;
+    function new_particlefx_node(pos: Vector3 | Vector4, particlefx: Hash | string): Opaque<"node">;
+    function new_pie_node(pos: Vector3 | Vector4, size: Vector3): Opaque<"node">;
+    function new_text_node(pos: Vector3 | Vector4, text: string): Opaque<"node">;
+    function new_texture(texture_id: string | Hash, width: number, height: number, type: string | Opaque<"constant">, buffer: string, flip: boolean): LuaMultiReturn<[boolean, number]>;
+    function on_input(self: Opaque<"userdata">, action_id: Hash, action: Record<string | number, unknown>): boolean | unknown;
+    function on_message(self: Opaque<"userdata">, message_id: Hash, message: Record<string | number, unknown>): void;
+    function on_reload(self: Opaque<"userdata">): void;
+    function pick_node(node: Opaque<"node">, x: number, y: number): boolean;
+    function play_flipbook(node: Opaque<"node">, animation: string | Hash, complete_function?: (self: unknown, node: unknown) => void, play_properties?: { offset?: number; playback_rate?: number }): void;
+    function play_particlefx(node: Opaque<"node">, emitter_state_function?: (self: unknown, node: unknown, emitter: unknown, state: unknown) => void): void;
+    function reset_keyboard(): void;
+    function reset_material(node: Opaque<"node">): void;
+    function reset_nodes(): void;
+    function screen_to_local(node: Opaque<"node">, screen_position: Vector3): Vector3;
+    function set(node: Opaque<"node"> | Url, property: string | Hash | Opaque<"constant">, value: number | Vector4 | Vector3 | Quaternion, options?: { index?: number; key?: Hash }): void;
+    function set_adjust_mode(node: Opaque<"node">, adjust_mode: Opaque<"constant">): void;
+    function set_alpha(node: Opaque<"node">, alpha: number): void;
+    function set_blend_mode(node: Opaque<"node">, blend_mode: Opaque<"constant">): void;
+    function set_clipping_inverted(node: Opaque<"node">, inverted: boolean): void;
+    function set_clipping_mode(node: Opaque<"node">, clipping_mode: Opaque<"constant">): void;
+    function set_clipping_visible(node: Opaque<"node">, visible: boolean): void;
+    function set_color(node: Opaque<"node">, color: Vector3 | Vector4): void;
+    function set_enabled(node: Opaque<"node">, enabled: boolean): void;
+    function set_euler(node: Opaque<"node">, rotation: Vector3 | Vector4): void;
+    function set_fill_angle(node: Opaque<"node">, angle: number): void;
+    function set_flipbook_cursor(node: Opaque<"node">, cursor: number): void;
+    function set_flipbook_playback_rate(node: Opaque<"node">, playback_rate: number): void;
+    function set_font(node: Opaque<"node">, font: string | Hash): void;
+    function set_id(node: Opaque<"node">, id: string | Hash): void;
+    function set_inherit_alpha(node: Opaque<"node">, inherit_alpha: boolean): void;
+    function set_inner_radius(node: Opaque<"node">, radius: number): void;
+    function set_layer(node: Opaque<"node">, layer: string | Hash): void;
+    function set_layout(layout: string | Hash): boolean;
+    function set_leading(node: Opaque<"node">, leading: number): void;
+    function set_line_break(node: Opaque<"node">, line_break: boolean): void;
+    function set_material(node: Opaque<"node">, material: string | Hash): void;
+    function set_outer_bounds(node: Opaque<"node">, bounds_mode: Opaque<"constant">): void;
+    function set_outline(node: Opaque<"node">, color: Vector3 | Vector4): void;
+    function set_parent(node: Opaque<"node">, parent?: Opaque<"node">, keep_scene_transform?: boolean): void;
+    function set_particlefx(node: Opaque<"node">, particlefx: Hash | string): void;
+    function set_perimeter_vertices(node: Opaque<"node">, vertices: number): void;
+    function set_pivot(node: Opaque<"node">, pivot: Opaque<"constant">): void;
+    function set_position(node: Opaque<"node">, position: Vector3 | Vector4): void;
+    function set_render_order(order: number): void;
+    function set_rotation(node: Opaque<"node">, rotation: Quaternion | Vector4): void;
+    function set_safe_area_mode(mode: Opaque<"constant">): void;
+    function set_scale(node: Opaque<"node">, scale: Vector3 | Vector4): void;
+    function set_screen_position(node: Opaque<"node">, screen_position: Vector3): void;
+    function set_shadow(node: Opaque<"node">, color: Vector3 | Vector4): void;
+    function set_size(node: Opaque<"node">, size: Vector3 | Vector4): void;
+    function set_size_mode(node: Opaque<"node">, size_mode: Opaque<"constant">): void;
+    function set_slice9(node: Opaque<"node">, values: Vector4): void;
+    function set_text(node: Opaque<"node">, text: string | number): void;
+    function set_texture(node: Opaque<"node">, texture: string | Hash): void;
+    function set_texture_data(texture: string | Hash, width: number, height: number, type: string | Opaque<"constant">, buffer: string, flip: boolean): boolean;
+    function set_tracking(node: Opaque<"node">, tracking: number): void;
+    function set_visible(node: Opaque<"node">, visible: boolean): void;
+    function set_xanchor(node: Opaque<"node">, anchor: Opaque<"constant">): void;
+    function set_yanchor(node: Opaque<"node">, anchor: Opaque<"constant">): void;
+    function show_keyboard(type: Opaque<"constant">, autoclose: boolean): void;
+    function stop_particlefx(node: Opaque<"node">, options?: { clear?: boolean }): void;
+    function update(self: Opaque<"userdata">, dt: number): void;
+    interface properties {
+      fonts: Hash;
+      material: Hash;
+      materials: Hash;
+      textures: Hash;
+    }
+  }
+}
+
+export {};

package/generated/http.d.ts

@@ -0,0 +1,8 @@
+/** @noSelfInFile */
+declare global {
+  namespace http {
+    function request(url: string, method: string, callback: (self: unknown, id: unknown, response: unknown) => void, headers?: Record<string | number, unknown>, post_data?: string, options?: { timeout?: number; path?: string; ignore_cache?: boolean; chunked_transfer?: boolean; report_progress?: boolean }): void;
+  }
+}
+
+export {};

package/generated/iac.d.ts

@@ -0,0 +1,8 @@
+/** @noSelfInFile */
+declare global {
+  namespace iac {
+    function set_listener(payload: Record<string | number, unknown>, type: number): void;
+  }
+}
+
+export {};

package/generated/iap.d.ts

@@ -0,0 +1,16 @@
+/** @noSelfInFile */
+import type { Opaque } from "../src/core-types";
+
+declare global {
+  namespace iap {
+    function acknowledge(transaction: Record<string | number, unknown>): void;
+    function buy(id: string, options: Record<string | number, unknown>): void;
+    function finish(transaction: Record<string | number, unknown>): void;
+    function get_provider_id(): Opaque<"constant">;
+    function list(ids: string[], callback: (...args: unknown[]) => unknown): void;
+    function restore(): boolean;
+    function set_listener(listener: (...args: unknown[]) => unknown): void;
+  }
+}
+
+export {};

package/generated/image.d.ts

@@ -0,0 +1,16 @@
+/** @noSelfInFile */
+import type { Opaque } from "../src/core-types";
+
+declare global {
+  namespace image {
+    const TYPE_LUMINANCE: number & { readonly __brand: "image.TYPE_LUMINANCE" };
+    const TYPE_LUMINANCE_ALPHA: number & { readonly __brand: "image.TYPE_LUMINANCE_ALPHA" };
+    const TYPE_RGB: number & { readonly __brand: "image.TYPE_RGB" };
+    const TYPE_RGBA: number & { readonly __brand: "image.TYPE_RGBA" };
+    function get_astc_header(buffer: string): { width: number; height: number; depth: number; block_size_x: number; block_size_y: number; block_size_z: number } | unknown;
+    function load(buffer: string, options?: { premultiply_alpha?: boolean; flip_vertically?: boolean }): { width: number; height: number; type: Opaque<"constant">; buffer: string } | unknown;
+    function load_buffer(buffer: string, options?: { premultiply_alpha?: boolean; flip_vertically?: boolean }): { width: number; height: number; type: Opaque<"constant">; buffer: Opaque<"buffer"> } | unknown;
+  }
+}
+
+export {};

package/generated/json.d.ts

@@ -0,0 +1,11 @@
+/** @noSelfInFile */
+declare global {
+  namespace json {
+    const _null: unknown;
+    export function decode(json: string, options?: { decode_null_as_userdata?: boolean }): Record<string | number, unknown>;
+    export function encode(tbl: Record<string | number, unknown>, options?: { encode_empty_table_as_object?: string }): string;
+    export { _null as null };
+  }
+}
+
+export {};

package/generated/kinds/gui-script.d.ts

@@ -0,0 +1,39 @@
+import "../../src/go-overloads";
+import "../../src/msg-overloads";
+import "../b2d";
+import "../buffer";
+import "../builtin-messages";
+import "../camera";
+import "../collectionfactory";
+import "../collectionproxy";
+import "../crash";
+import "../factory";
+import "../go";
+import "../graphics";
+import "../http";
+import "../iac";
+import "../iap";
+import "../image";
+import "../json";
+import "../label";
+import "../liveupdate";
+import "../model";
+import "../msg";
+import "../particlefx";
+import "../physics";
+import "../profiler";
+import "../push";
+import "../resource";
+import "../socket";
+import "../sound";
+import "../sprite";
+import "../sys";
+import "../tilemap";
+import "../timer";
+import "../vmath";
+import "../webview";
+import "../window";
+import "../zlib";
+import "../gui";
+
+export {};

package/generated/kinds/render-script.d.ts

@@ -0,0 +1,39 @@
+import "../../src/go-overloads";
+import "../../src/msg-overloads";
+import "../b2d";
+import "../buffer";
+import "../builtin-messages";
+import "../camera";
+import "../collectionfactory";
+import "../collectionproxy";
+import "../crash";
+import "../factory";
+import "../go";
+import "../graphics";
+import "../http";
+import "../iac";
+import "../iap";
+import "../image";
+import "../json";
+import "../label";
+import "../liveupdate";
+import "../model";
+import "../msg";
+import "../particlefx";
+import "../physics";
+import "../profiler";
+import "../push";
+import "../resource";
+import "../socket";
+import "../sound";
+import "../sprite";
+import "../sys";
+import "../tilemap";
+import "../timer";
+import "../vmath";
+import "../webview";
+import "../window";
+import "../zlib";
+import "../render";
+
+export {};

package/generated/kinds/script.d.ts

@@ -0,0 +1,38 @@
+import "../../src/go-overloads";
+import "../../src/msg-overloads";
+import "../b2d";
+import "../buffer";
+import "../builtin-messages";
+import "../camera";
+import "../collectionfactory";
+import "../collectionproxy";
+import "../crash";
+import "../factory";
+import "../go";
+import "../graphics";
+import "../http";
+import "../iac";
+import "../iap";
+import "../image";
+import "../json";
+import "../label";
+import "../liveupdate";
+import "../model";
+import "../msg";
+import "../particlefx";
+import "../physics";
+import "../profiler";
+import "../push";
+import "../resource";
+import "../socket";
+import "../sound";
+import "../sprite";
+import "../sys";
+import "../tilemap";
+import "../timer";
+import "../vmath";
+import "../webview";
+import "../window";
+import "../zlib";
+
+export {};

package/generated/label.d.ts

@@ -0,0 +1,23 @@
+/** @noSelfInFile */
+import type { Hash, Url, Vector3, Vector4 } from "../src/core-types";
+
+declare global {
+  namespace label {
+    function get_text(url: string | Hash | Url): string;
+    function set_text(url: string | Hash | Url, text: string | number): void;
+    interface properties {
+      color: Vector4;
+      font: Hash;
+      leading: number;
+      line_break: boolean;
+      material: Hash;
+      outline: Vector4;
+      scale: number | Vector3;
+      shadow: Vector4;
+      size: Vector3;
+      tracking: number;
+    }
+  }
+}
+
+export {};

package/generated/liveupdate.d.ts

@@ -0,0 +1,23 @@
+/** @noSelfInFile */
+declare global {
+  namespace liveupdate {
+    const LIVEUPDATE_BUNDLED_RESOURCE_MISMATCH: number & { readonly __brand: "liveupdate.LIVEUPDATE_BUNDLED_RESOURCE_MISMATCH" };
+    const LIVEUPDATE_ENGINE_VERSION_MISMATCH: number & { readonly __brand: "liveupdate.LIVEUPDATE_ENGINE_VERSION_MISMATCH" };
+    const LIVEUPDATE_FORMAT_ERROR: number & { readonly __brand: "liveupdate.LIVEUPDATE_FORMAT_ERROR" };
+    const LIVEUPDATE_INVAL: number & { readonly __brand: "liveupdate.LIVEUPDATE_INVAL" };
+    const LIVEUPDATE_INVALID_HEADER: number & { readonly __brand: "liveupdate.LIVEUPDATE_INVALID_HEADER" };
+    const LIVEUPDATE_INVALID_RESOURCE: number & { readonly __brand: "liveupdate.LIVEUPDATE_INVALID_RESOURCE" };
+    const LIVEUPDATE_IO_ERROR: number & { readonly __brand: "liveupdate.LIVEUPDATE_IO_ERROR" };
+    const LIVEUPDATE_MEM_ERROR: number & { readonly __brand: "liveupdate.LIVEUPDATE_MEM_ERROR" };
+    const LIVEUPDATE_OK: number & { readonly __brand: "liveupdate.LIVEUPDATE_OK" };
+    const LIVEUPDATE_SCHEME_MISMATCH: number & { readonly __brand: "liveupdate.LIVEUPDATE_SCHEME_MISMATCH" };
+    const LIVEUPDATE_SIGNATURE_MISMATCH: number & { readonly __brand: "liveupdate.LIVEUPDATE_SIGNATURE_MISMATCH" };
+    const LIVEUPDATE_UNKNOWN: number & { readonly __brand: "liveupdate.LIVEUPDATE_UNKNOWN" };
+    const LIVEUPDATE_VERSION_MISMATCH: number & { readonly __brand: "liveupdate.LIVEUPDATE_VERSION_MISMATCH" };
+    function add_mount(name: string, uri: string, priority: number, callback: (...args: unknown[]) => unknown): number;
+    function get_mounts(): Record<string | number, unknown>;
+    function remove_mount(name: string): number;
+  }
+}
+
+export {};

package/generated/model.d.ts

@@ -0,0 +1,23 @@
+/** @noSelfInFile */
+import type { Hash, Opaque, Url } from "../src/core-types";
+
+declare global {
+  namespace model {
+    function cancel(url: string | Hash | Url): void;
+    function get_aabb(url: string | Hash | Url): Record<string | number, unknown>;
+    function get_go(url: string | Hash | Url, bone_id: string | Hash): Hash;
+    function get_mesh_aabb(url: string | Hash | Url): Record<string | number, unknown>;
+    function get_mesh_enabled(url: string | Hash | Url, mesh_id: string | Hash | Url): boolean;
+    function play_anim(url: string | Hash | Url, anim_id: string | Hash, playback: Opaque<"constant">, play_properties?: { blend_duration?: number; offset?: number; playback_rate?: number }, complete_function?: (self: unknown, message_id: unknown, message: unknown, sender: unknown) => void): void;
+    function set_mesh_enabled(url: string | Hash | Url, mesh_id: string | Hash | Url, enabled: boolean): void;
+    interface properties {
+      animation: Hash;
+      cursor: number;
+      material: Hash;
+      playback_rate: number;
+      textureN: Hash;
+    }
+  }
+}
+
+export {};

package/generated/msg.d.ts

@@ -0,0 +1,12 @@
+/** @noSelfInFile */
+import type { Hash, Url } from "../src/core-types";
+
+declare global {
+  namespace msg {
+    function url(): Url;
+    function url(urlstring: string): Url;
+    function url(socket?: string | Hash, path?: string | Hash, fragment?: string | Hash): Url;
+  }
+}
+
+export {};

package/generated/particlefx.d.ts

@@ -0,0 +1,22 @@
+/** @noSelfInFile */
+import type { Hash, Url, Vector4 } from "../src/core-types";
+
+declare global {
+  namespace particlefx {
+    const EMITTER_STATE_POSTSPAWN: number & { readonly __brand: "particlefx.EMITTER_STATE_POSTSPAWN" };
+    const EMITTER_STATE_PRESPAWN: number & { readonly __brand: "particlefx.EMITTER_STATE_PRESPAWN" };
+    const EMITTER_STATE_SLEEPING: number & { readonly __brand: "particlefx.EMITTER_STATE_SLEEPING" };
+    const EMITTER_STATE_SPAWNING: number & { readonly __brand: "particlefx.EMITTER_STATE_SPAWNING" };
+    function play(url: string | Hash | Url, emitter_state_function?: (self: unknown, id: unknown, emitter: unknown, state: unknown) => void): void;
+    function reset_constant(url: string | Hash | Url, emitter: string | Hash, constant: string | Hash): void;
+    function set_constant(url: string | Hash | Url, emitter: string | Hash, constant: string | Hash, value: Vector4): void;
+    function stop(url: string | Hash | Url, options?: { clear?: boolean }): void;
+    interface properties {
+      animation: Hash;
+      image: Hash;
+      material: Hash;
+    }
+  }
+}
+
+export {};

package/generated/physics.d.ts

@@ -0,0 +1,47 @@
+/** @noSelfInFile */
+import type { Hash, Url, Vector3 } from "../src/core-types";
+
+declare global {
+  namespace physics {
+    const JOINT_TYPE_FIXED: number & { readonly __brand: "physics.JOINT_TYPE_FIXED" };
+    const JOINT_TYPE_HINGE: number & { readonly __brand: "physics.JOINT_TYPE_HINGE" };
+    const JOINT_TYPE_SLIDER: number & { readonly __brand: "physics.JOINT_TYPE_SLIDER" };
+    const JOINT_TYPE_SPRING: number & { readonly __brand: "physics.JOINT_TYPE_SPRING" };
+    const JOINT_TYPE_WELD: number & { readonly __brand: "physics.JOINT_TYPE_WELD" };
+    const JOINT_TYPE_WHEEL: number & { readonly __brand: "physics.JOINT_TYPE_WHEEL" };
+    const SHAPE_TYPE_BOX: number & { readonly __brand: "physics.SHAPE_TYPE_BOX" };
+    const SHAPE_TYPE_CAPSULE: number & { readonly __brand: "physics.SHAPE_TYPE_CAPSULE" };
+    const SHAPE_TYPE_HULL: number & { readonly __brand: "physics.SHAPE_TYPE_HULL" };
+    const SHAPE_TYPE_SPHERE: number & { readonly __brand: "physics.SHAPE_TYPE_SPHERE" };
+    function create_joint(joint_type: number, collisionobject_a: string | Hash | Url, joint_id: string | Hash, position_a: Vector3, collisionobject_b: string | Hash | Url, position_b: Vector3, properties?: Record<string | number, unknown>): void;
+    function destroy_joint(collisionobject: string | Hash | Url, joint_id: string | Hash): void;
+    function get_gravity(): Vector3;
+    function get_group(url: string | Hash | Url): Hash;
+    function get_joint_properties(collisionobject: string | Hash | Url, joint_id: string | Hash): { collide_connected: boolean };
+    function get_joint_reaction_force(collisionobject: string | Hash | Url, joint_id: string | Hash): Vector3;
+    function get_joint_reaction_torque(collisionobject: string | Hash | Url, joint_id: string | Hash): number;
+    function get_maskbit(url: string | Hash | Url, group: string): boolean;
+    function get_shape(url: string | Hash | Url, shape: string | Hash): { type: number; diameter: number; dimensions: Vector3; diameter: number; height: number };
+    function raycast(from: Vector3, to: Vector3, groups: Record<string | number, unknown>, options?: { all?: boolean }): Record<string | number, unknown> | unknown;
+    function raycast_async(from: Vector3, to: Vector3, groups: Record<string | number, unknown>, request_id?: number): void;
+    function set_event_listener(callback?: (self: unknown, events: unknown) => void): void;
+    function set_gravity(gravity: Vector3): void;
+    function set_group(url: string | Hash | Url, group: string): void;
+    function set_hflip(url: string | Hash | Url, flip: boolean): void;
+    function set_joint_properties(collisionobject: string | Hash | Url, joint_id: string | Hash, properties: Record<string | number, unknown>): void;
+    function set_maskbit(url: string | Hash | Url, group: string, maskbit: boolean): void;
+    function set_shape(url: string | Hash | Url, shape: string | Hash, table: { type?: number; diameter?: number; dimensions?: Vector3; diameter?: number; height?: number }): void;
+    function set_vflip(url: string | Hash | Url, flip: boolean): void;
+    function update_mass(collisionobject: string | Hash | Url, mass: number): void;
+    function wakeup(url: string | Hash | Url): void;
+    interface properties {
+      angular_damping: number;
+      angular_velocity: Vector3;
+      linear_damping: number;
+      linear_velocity: Vector3;
+      mass: number;
+    }
+  }
+}
+
+export {};

package/generated/profiler.d.ts

@@ -0,0 +1,28 @@
+/** @noSelfInFile */
+import type { Opaque } from "../src/core-types";
+
+declare global {
+  namespace profiler {
+    const MODE_PAUSE: number & { readonly __brand: "profiler.MODE_PAUSE" };
+    const MODE_RECORD: number & { readonly __brand: "profiler.MODE_RECORD" };
+    const MODE_RUN: number & { readonly __brand: "profiler.MODE_RUN" };
+    const MODE_SHOW_PEAK_FRAME: number & { readonly __brand: "profiler.MODE_SHOW_PEAK_FRAME" };
+    const VIEW_MODE_FULL: number & { readonly __brand: "profiler.VIEW_MODE_FULL" };
+    const VIEW_MODE_MINIMIZED: number & { readonly __brand: "profiler.VIEW_MODE_MINIMIZED" };
+    function dump_frame(): void;
+    function enable(enabled: boolean): void;
+    function enable_ui(enabled: boolean): void;
+    function get_cpu_usage(): number;
+    function get_memory_usage(): number;
+    function log_text(text: string): void;
+    function recorded_frame_count(): number;
+    function scope_begin(name: string): void;
+    function scope_end(): void;
+    function set_ui_mode(mode: Opaque<"constant">): void;
+    function set_ui_view_mode(mode: Opaque<"constant">): void;
+    function set_ui_vsync_wait_visible(visible: boolean): void;
+    function view_recorded_frame(frame_index: Record<string | number, unknown>): void;
+  }
+}
+
+export {};

package/generated/push.d.ts

@@ -0,0 +1,15 @@
+/** @noSelfInFile */
+declare global {
+  namespace push {
+    function cancel(id: number): void;
+    function cancel_all_issued(): void;
+    function get_all_scheduled(): Record<string | number, unknown>;
+    function get_scheduled(id: number): Record<string | number, unknown>;
+    function register(notifications: Record<string | number, unknown>, callback: (...args: unknown[]) => unknown): void;
+    function schedule(time: number, title: string, alert: string, payload: string, notification_settings: Record<string | number, unknown>): LuaMultiReturn<[number, string]>;
+    function set_badge_count(count: number): void;
+    function set_listener(listener: (...args: unknown[]) => unknown): void;
+  }
+}
+
+export {};