@defold-typescript/library-types 0.22.0 → 0.24.0

package/generated/event.d.ts

@@ -0,0 +1,318 @@
+/** @noResolution */
+declare module 'event.event' {
+	type promise_state = "pending" | "resolved" | "rejected";
+	/**
+	 * Array of next items:
+	 * [1] callback,
+	 * [2] callback_context,
+	 * [3] script_context
+	 * [4] remaining: nil=infinite, number=fires left, 0=pending delete.
+	 * [5] subscribed_event: event when callback is event with context.
+	 */
+	interface event_callback_data {
+	}
+	/**
+	 * A logger object for event module should match the following interface
+	 */
+	interface event_logger {
+		trace: (logger: event_logger, message: string, data: unknown | undefined) => void;
+		debug: (logger: event_logger, message: string, data: unknown | undefined) => void;
+		info: (logger: event_logger, message: string, data: unknown | undefined) => void;
+		warn: (logger: event_logger, message: string, data: unknown | undefined) => void;
+		error: (logger: event_logger, message: string, data: unknown | undefined) => void;
+	}
+	/**
+	 * The Event module, used to create and manage events. Allows to subscribe to events and trigger them.
+	 */
+	interface event {
+		/**
+		 * Subscribe a callback to the event or other event. The callback will be invoked whenever the event is triggered.
+		 * The callback_context parameter is optional and will be passed as the first parameter to the callback function.
+		 * If the callback with context is already subscribed, the warning will be logged.
+		 * local function callback(self)
+		 * print("clicked!")
+		 * end
+		 * on_click_event:subscribe(callback, self)
+		 *
+		 * -- Subscribe an event to another event
+		 * event_1 = event.create(callback)
+		 * event_2 = event.create()
+		 * event_2:subscribe(event_1) -- Now event2 will trigger event1
+		 */
+		subscribe(callback: ((...args: any[]) => unknown) | event, callback_context?: unknown | undefined): boolean;
+		/**
+		 * Subscribe a callback for a single trigger. After the first trigger the callback is automatically unsubscribed.
+		 * on_click_event:subscribe_once(function(self) print("one-time click!") end, self)
+		 */
+		subscribe_once(callback: ((...args: any[]) => unknown) | event, callback_context?: unknown | undefined): boolean;
+		/**
+		 * Remove a previously subscribed callback from the event.
+		 * The callback_context should be the same as the one used when subscribing the callback.
+		 * If there is no callback_context provided, all callbacks with the same function will be unsubscribed.
+		 * on_click_event:unsubscribe(callback, self)
+		 */
+		unsubscribe(callback: ((...args: any[]) => unknown) | event, callback_context?: unknown | undefined): boolean;
+		/**
+		 * Determine if a specific callback is currently subscribed to the event.
+		 * The callback_context should be the same as the one used when subscribing the callback.
+		 * local is_subscribed = on_click_event:is_subscribed(callback, self)
+		 */
+		is_subscribed(callback: ((...args: any[]) => unknown) | event, callback_context?: unknown | undefined): LuaMultiReturn<[boolean, number | undefined]>;
+		/**
+		 * Trigger the event, causing all subscribed callbacks to be executed.
+		 * Any parameters passed to trigger will be forwarded to the callbacks.
+		 * The return value of the last executed callback is returned.
+		 * The event:trigger(...) can be called as event(...).
+		 * on_click_event:trigger("arg1", "arg2")
+		 *
+		 * -- The event can be triggered as a function
+		 * on_click_event("arg1", "arg2")
+		 */
+		trigger(...args: unknown[]): unknown;
+		/**
+		 * Check if the event has no subscribed callbacks.
+		 * local is_empty = on_click_event:is_empty()
+		 */
+		is_empty(): boolean;
+		/**
+		 * Remove all callbacks subscribed to the event, effectively resetting it.
+		 * on_click_event:clear()
+		 */
+		clear(): void;
+		/**
+		 * Trigger the event. All subscribed callbacks will be called in the order they were subscribed.
+		 */
+		(vararg: unknown): unknown | undefined;
+	}
+	/**
+	 * Global events module that allows creation and management of global events that can be triggered from anywhere in your game.
+	 * This is particularly useful for events that need to be handled by multiple scripts or systems.
+	 */
+	interface events {
+	}
+	interface promise_cancelled_context {
+		is_cancelled: boolean;
+		on_cancel: event;
+	}
+	/**
+	 * The Promise module, used to create and manage promises.
+	 * A promise represents a single asynchronous operation that will either resolve with a value or reject with a reason.
+	 */
+	interface promise {
+		state: promise_state;
+		value: unknown;
+		cancellation: promise_cancelled_context;
+		/**
+		 * Attach resolve and reject handlers to the promise.
+		 * Returns a new promise that will be resolved or rejected based on the handlers' return values.
+		 * load_data():next(function(data) return process(data) end):next(display):catch(show_error)
+		 */
+		next(on_resolved?: ((...args: any[]) => unknown) | promise | event | undefined, on_rejected?: ((...args: any[]) => unknown) | promise | event | undefined, context?: unknown | undefined): promise;
+		/**
+		 * Attach a rejection handler to the promise. Equivalent to next(nil, on_rejected).
+		 * load_data():catch(function(err) print("Failed:", err) end)
+		 */
+		"catch"(on_rejected: ((...args: any[]) => unknown) | event, context?: unknown | undefined): promise;
+		/**
+		 * Attach a handler that is called regardless of whether the promise is resolved or rejected.
+		 * The handler is called with the resolved value or rejection reason.
+		 * When context is provided, it is passed as the first argument.
+		 * The handler return value is ignored.
+		 * load_data():finally(function() hide_loading_spinner() end)
+		 */
+		"finally"(on_finally: ((...args: any[]) => unknown) | event, context?: unknown | undefined): promise;
+		/**
+		 * Check if the promise is in pending state.
+		 */
+		is_pending(): boolean;
+		/**
+		 * Check if the promise is in resolved state.
+		 */
+		is_resolved(): boolean;
+		/**
+		 * Check if the promise is in rejected state.
+		 */
+		is_rejected(): boolean;
+		/**
+		 * Check if the promise is finished (either resolved or rejected).
+		 */
+		is_finished(): boolean;
+		/**
+		 * Check if the shared cancel_context was cancelled.
+		 */
+		is_cancelled(): boolean;
+		/**
+		 * Resolve the promise.
+		 * my_promise:resolve(result)
+		 */
+		resolve(value: unknown): void;
+		/**
+		 * Reject the promise.
+		 * my_promise:reject("failed")
+		 */
+		reject(reason: unknown): void;
+		/**
+		 * Cancel the promise chain. Triggers cleanup and rejects if still pending.
+		 * my_promise:cancel()
+		 */
+		cancel(): void;
+		/**
+		 * Append a task to this promise's internal sequence without reassigning.
+		 * The task may return a value or a promise. If `task` is a promise, the pipeline waits for it
+		 * to finish and adopts its result. The incoming value is not forwarded into `task`
+		 * (same as `append(function() return task end)`).
+		 * Returns self for chaining.
+		 * Almost similar to `promise = promise:next(task)`, but without reassigning the promise.
+		 * pipeline:append(step1)
+		 * pipeline:append(step2)
+		 * pipeline:append(step3)
+		 * local last = pipeline:tail()
+		 * print("Is going to check status of", last:is_pending())
+		 */
+		append(task: ((value: unknown) => unknown) | promise): promise;
+		/**
+		 * Get the current tail promise representing all appended work.
+		 * local last = pipeline:tail()
+		 * last:next(on_complete)
+		 */
+		tail(): promise;
+		/**
+		 * Reset the internal sequence to an already resolved promise.
+		 * pipeline:reset()
+		 * pipeline:append(new_step)
+		 */
+		reset(): promise;
+		/**
+		 * Reject pending child promises when a settled promise is cancelled.
+		 */
+		_reject_cancel_children(): void;
+		/**
+		 * Call the promise to resolve it with value
+		 */
+		(value: unknown): undefined;
+	}
+	interface queue_event_data {
+		data: unknown;
+		on_handle: event;
+	}
+	/**
+	 * The Queue module, used to create and manage FIFO event queues. Allows to push events to a queue and subscribe handlers to process them.
+	 * Events are stored in the queue until they are handled by subscribers, following first-in-first-out (FIFO) order.
+	 */
+	interface queue {
+		/**
+		 * Push a new event to the queue. The event will exist until it's handled by a subscriber.
+		 * If there are already subscribers for this queue instance, they will be called immediately.
+		 * If multiple subscribers handle the event, all subscribers will still be called. The on_handle callback
+		 * will be called for each subscriber that handles the event.
+		 * my_queue:push(save_data)
+		 * my_queue:push(save_data, function() print("saved!") end)
+		 */
+		push(data: unknown, on_handle?: ((...args: any[]) => unknown) | event | undefined, context?: unknown | undefined): void;
+		/**
+		 * Subscribe a handler to this queue instance. When an event is pushed to this queue,
+		 * the handler will be called. If there are already events in the queue, they will be processed immediately.
+		 * Return a non-nil value from the handler to mark the event as handled and remove it from the queue.
+		 * local function on_save(self, data)
+		 * do_save(data)
+		 * return true
+		 * end
+		 * my_queue:subscribe(on_save, self)
+		 */
+		subscribe(handler: ((...args: any[]) => unknown) | event, context?: unknown | undefined): boolean;
+		/**
+		 * Subscribe a handler until it handles one event. The handler is invoked for each event in the queue until it returns non-nil (handles an event)
+		 * then it is automatically unsubscribed and will not be invoked again, even if more events remain in the queue.
+		 * my_queue:subscribe_once(function(self, data) return process(data) end, self)
+		 */
+		subscribe_once(handler: ((...args: any[]) => unknown) | event, context?: unknown | undefined): boolean;
+		/**
+		 * Unsubscribe a handler from this queue instance.
+		 * my_queue:unsubscribe(on_save, self)
+		 */
+		unsubscribe(handler: ((...args: any[]) => unknown) | event, context?: unknown | undefined): boolean;
+		/**
+		 * Check if a handler is subscribed to this queue instance.
+		 * local ok = my_queue:is_subscribed(on_save, self)
+		 */
+		is_subscribed(handler: ((...args: any[]) => unknown) | event, context?: unknown | undefined): LuaMultiReturn<[boolean, number | undefined]>;
+		/**
+		 * Process all events in this queue immediately. Subscribers will not be called in this function.
+		 * Events can be handled and removed in event handler callback. If event is handled, it will be removed from the queue.
+		 * my_queue:process(function(self, data) return handle(data) end, self)
+		 */
+		process(event_handler: ((...args: any[]) => unknown) | event, context?: unknown | undefined): void;
+		/**
+		 * Process exactly one queued event with a specific handler (subscribers will NOT be called).
+		 * If the handler returns non-nil the event will be removed from the queue.
+		 * local handled = my_queue:process_next(function(data) return handle(data) end)
+		 */
+		process_next(event_handler?: ((...args: any[]) => unknown) | event | undefined, context?: unknown | undefined): boolean;
+		/**
+		 * Get all pending events in this queue.
+		 * for _, event_data in ipairs(my_queue:get_events()) do
+		 * print(event_data.data)
+		 * end
+		 */
+		get_events(): queue_event_data[];
+		/**
+		 * Clear all pending events in this queue.
+		 * my_queue:clear_events()
+		 */
+		clear_events(): void;
+		/**
+		 * Clear all subscribers from this queue instance.
+		 * my_queue:clear_subscribers()
+		 */
+		clear_subscribers(): void;
+		/**
+		 * Check if this queue has no pending events.
+		 * if my_queue:is_empty() then
+		 * return
+		 * end
+		 */
+		is_empty(): boolean;
+		/**
+		 * Check if this queue instance has no subscribed handlers.
+		 * if my_queue:has_subscribers() then
+		 * my_queue:push(data)
+		 * end
+		 */
+		has_subscribers(): boolean;
+		/**
+		 * Remove all events and handlers from this queue instance, effectively resetting it.
+		 * my_queue:clear()
+		 */
+		clear(): void;
+	}
+	/**
+	 * Global queues module that allows creation and management of global FIFO event queues that can be accessed from anywhere in your game.
+	 * This is particularly useful for events that need to be handled by multiple scripts or systems using a queue-based approach.
+	 */
+	interface queues {
+	}
+	/**
+	 * Generate a new event instance. This instance can then be used to subscribe to and trigger events.
+	 * The callback function will be called when the event is triggered. The callback_context parameter is optional
+	 * and will be passed as the first parameter to the callback function. Usually, it is used to pass the self instance.
+	 * local e = event.create()
+	 * local e = event.create(function(self) print("ok") end, self)
+	 */
+	export function create(this: void, callback?: ((...args: any[]) => unknown) | event | undefined, callback_context?: unknown | undefined): event;
+	/**
+	 * Check if the table is an event instance.
+	 * if event.is_event(my_value) then
+	 * my_value:trigger()
+	 * end
+	 */
+	export function is_event(this: void, value: unknown): boolean;
+	/**
+	 * Customize the logging mechanism used by Event module. You can use **Defold Log** library or provide a custom logger.
+	 * By default, the module uses the `pprint` logger for errors.
+	 */
+	export function set_logger(this: void, logger_instance?: event_logger | LuaTable | undefined): void;
+	/**
+	 * Set the mode of the event module.
+	 */
+	export function set_mode(this: void, mode: "pcall"): void;
+}

package/generated/{gooey.gooey.d.ts → gooey.d.ts}

@@ -135,6 +135,38 @@ declare module 'gooey.gooey' {
 		total_width: number;
 	};
 
+	/** What `create_theme` hands back: the helpers it installs, over any component
+	 * carrying a node. `is_enabled` and `set_enabled` return nothing when it does not. */
+	type Theme = {
+		is_enabled: (component: { node?: Opaque<"node"> }) => boolean | undefined;
+		set_enabled: (component: { node?: Opaque<"node"> }, enabled: boolean) => void;
+		acquire_input: () => void;
+		release_input: () => void;
+		group: (
+			group_id: Hash | string,
+			action_id: Hash,
+			action: table,
+			group_fn: () => void,
+		) => table;
+	};
+
+	/**
+	 * Check if a node is enabled. This is done by not only looking at the state of the
+	 * node itself but also it's ancestors all the way up the hierarchy.
+	 */
+	export function is_enabled(node: Opaque<"node">): boolean;
+
+	/** Convenience function to acquire input focus */
+	export function acquire_input(): void;
+
+	/** Convenience function to release input focus */
+	export function release_input(): void;
+
+	export function create_theme(): Theme;
+
+	/** Mask text by replacing every character with a mask character */
+	export function mask_text(text: string, mask: string): string;
+
 	export function button(
 		node_id: Hash | string,
 		action_id: Hash,
@@ -151,6 +183,15 @@ declare module 'gooey.gooey' {
 		refresh_fn?: (checkbox: CheckboxState) => void,
 	): CheckboxState;
 
+	/** Wraps the `gooey.radio` calls of one group; `fn` receives the group's id and the
+	 * input it was called with, not a radio state (`README.md:265`). */
+	export function radiogroup(
+		group_id: Hash | string,
+		action_id: Hash,
+		action: table,
+		fn: (group_id: Hash | string, action_id: Hash, action: table) => void,
+	): table;
+
 	export function radio(
 		node_id: Hash | string,
 		group: string,
@@ -169,12 +210,10 @@ declare module 'gooey.gooey' {
 		config: { horizontal?: boolean } | undefined,
 		fn: (list: ListState) => void,
 		refresh_fn?: (list: ListState) => void,
-		is_horizontal?: boolean,
 	): ListState;
 
 	export function dynamic_list(
 		list_id: string,
-		root_id: string,
 		stencil_id: Hash | string,
 		item_id: Hash | string,
 		data: table,
@@ -183,12 +222,10 @@ declare module 'gooey.gooey' {
 		config: { horizontal?: boolean; carousel?: boolean } | undefined,
 		fn: (list: ListState) => void,
 		refresh_fn?: (list: ListState) => void,
-		is_horizontal?: boolean,
 	): ListState;
 
 	export function horizontal_dynamic_list(
 		list_id: string,
-		root_id: string,
 		stencil_id: Hash | string,
 		item_id: Hash | string,
 		data: table,
@@ -201,7 +238,6 @@ declare module 'gooey.gooey' {
 
 	export function vertical_dynamic_list(
 		list_id: string,
-		root_id: string,
 		stencil_id: Hash | string,
 		item_id: Hash | string,
 		data: table,
@@ -239,6 +275,17 @@ declare module 'gooey.gooey' {
 		bounds_id: Hash | string,
 		action_id: Hash,
 		action: table,
+		config: table | undefined,
+		fn: (scrollbar: ScrollbarState) => void,
+		refresh_fn?: (scrollbar: ScrollbarState) => void,
+	): ScrollbarState;
+
+	export function horizontal_scrollbar(
+		handle_id: Hash | string,
+		bounds_id: Hash | string,
+		action_id: Hash,
+		action: table,
+		config: table | undefined,
 		fn: (scrollbar: ScrollbarState) => void,
 		refresh_fn?: (scrollbar: ScrollbarState) => void,
 	): ScrollbarState;
@@ -257,5 +304,13 @@ declare module 'gooey.gooey' {
 		refresh_fn?: (input: InputState) => void,
 	): InputState;
 
-	export function group(group_id: string, fn: () => void): table;
+	export function group(
+		group_id: Hash | string,
+		action_id: Hash,
+		action: table,
+		group_fn: () => void,
+	): table;
+
+	/** Move a group's focus to the component at `index`, refreshing it. */
+	export function set_focus(group: table, index: number): void;
 }

package/generated/immutable.d.ts

@@ -0,0 +1,13 @@
+/** @noResolution */
+declare module 'immutable.immutable' {
+	interface Immutable {
+	}
+	/**
+	 * Checks if a given table `table_to_check` is immutable
+	 */
+	export function is_immutable(this: void, table_to_check: LuaTable | Immutable): boolean;
+	/**
+	 * Makes a given table immutable, including nested tables
+	 */
+	export function make(this: void, original_table: LuaTable | Immutable): Immutable;
+}

package/generated/in.onscreen.d.ts

@@ -32,6 +32,11 @@ declare module 'in.onscreen' {
 		on_input: (action_id: Hash, action: {}) => boolean;
 	};
 
+	/**
+	 * Create an instance of the onscreen controls.
+	 * @param config Optional settings. `touch` is the action id bound to single touch.
+	 * @returns The instance the register and input functions operate on.
+	 */
 	function create(config?: { touch: Hash }): OnscreenInstance;
 
 	export function reset(instance?: OnscreenInstance): void;

package/generated/in.textbox.d.ts

@@ -18,6 +18,10 @@ declare module 'in.textbox' {
 	): Opaque<"node">;
 	export function unregister(node_or_string?: Opaque<"node"> | string): void;
 	export function effect(node: Opaque<"node">, scale: { x: number; y: number }): void;
+	/**
+	 * Get a registered textbox's text, or set it first when `text` is given.
+	 * Returns the text the box holds after the call.
+	 */
 	export function text(
 		node_or_string: Opaque<"node"> | string,
 		text?: string,

package/generated/lang.d.ts

@@ -0,0 +1,101 @@
+/** @noResolution */
+declare module 'lang.lang' {
+	interface lang_logger {
+		trace: (_: unknown, msg: string, data: unknown) => void;
+		debug: (_: unknown, msg: string, data: unknown) => void;
+		info: (_: unknown, msg: string, data: unknown) => void;
+		warn: (_: unknown, msg: string, data: unknown) => void;
+		error: (_: unknown, msg: string, data: unknown) => void;
+	}
+	interface lang_registry {
+	}
+	interface lang {
+		state: lang_state;
+		on_lang_changed: (...args: any[]) => unknown;
+	}
+	interface lang_state {
+		lang: string;
+	}
+	interface lang_data {
+		path?: string | LuaTable | undefined;
+		id: string;
+		loader?: ((...args: any[]) => unknown) | undefined;
+	}
+	/**
+	 * Global callback after language is loaded and translations are ready.
+	 * Called by `set_lang`, `set_next_lang`, and `load_langs`. Set once at startup to refresh UI.
+	 */
+	export function on_lang_changed(this: void): void;
+	/**
+	 * Call this to initialize lang module
+	 */
+	export function init(this: void, available_langs: lang_data[], lang_on_start?: string | undefined): void;
+	/**
+	 * Load additional locale pack and refresh current language
+	 */
+	export function load_langs(this: void, pack_id: string, langs: lang_data[], on_lang_changed?: ((...args: any[]) => unknown) | undefined): void;
+	/**
+	 * Set current language
+	 */
+	export function set_lang(this: void, lang_id: string, on_lang_changed?: ((...args: any[]) => unknown) | undefined): void;
+	/**
+	 * Set next language from lang list and return it's code
+	 */
+	export function set_next_lang(this: void, on_lang_changed?: ((...args: any[]) => unknown) | undefined): string;
+	/**
+	 * Get next language from lang list and return it's code
+	 */
+	export function get_next_lang(this: void): string;
+	/**
+	 * Get current language
+	 */
+	export function get_lang(this: void): string;
+	/**
+	 * Return list of available languages
+	 */
+	export function get_langs(this: void): string[];
+	/**
+	 * Get translation for text id
+	 */
+	export function txt(this: void, text_id: string): string;
+	/**
+	 * Get translation for text id with params
+	 */
+	export function txp(this: void, text_id: string, ...args: (string | number)[]): string;
+	/**
+	 * Get random translation for text id, split by \n symbol
+	 */
+	export function txr(this: void, text_id: string): string;
+	/**
+	 * Check is translation with text_id exist
+	 */
+	export function is_exist(this: void, text_id: string): boolean;
+	/**
+	 * Set logger for lang module. Pass nil to use empty logger
+	 */
+	export function set_logger(this: void, logger_instance?: lang_logger | LuaTable | undefined): void;
+	/**
+	 * Reset module lang state
+	 */
+	export function reset_state(this: void): void;
+	/**
+	 * Get lang module state
+	 */
+	export function get_state(this: void): lang_state;
+	/**
+	 * Set lang module state
+	 */
+	export function set_state(this: void, state: lang_state): void;
+	/**
+	 * Get default language
+	 */
+	export function get_default_lang(this: void): string;
+	/**
+	 * Get current lang table { key = "value" }
+	 */
+	export function get_lang_table(this: void): LuaTable<string, string>;
+	/**
+	 * Check if language is available
+	 */
+	export function is_lang_available(this: void, lang_id: string): boolean;
+}

package/generated/log.d.ts

@@ -0,0 +1,36 @@
+/** @noResolution */
+declare module 'log.log' {
+	type logger = log;
+	interface log {
+		name: string;
+		level: string;
+		/**
+		 * Log message with TRACE level
+		 */
+		trace(message: string, data: unknown): void;
+		/**
+		 * Log message with DEBUG level
+		 */
+		debug(message: string, data: unknown): void;
+		/**
+		 * Log message with INFO level
+		 */
+		info(message: string, data: unknown): void;
+		/**
+		 * Log message with WARN level
+		 */
+		warn(message: string, data: unknown): void;
+		/**
+		 * Log message with ERROR level
+		 */
+		error(message: string, data: unknown): void;
+	}
+	/**
+	 * Return the new logger instance
+	 */
+	export function get_logger(this: void, logger_name?: string | undefined, force_logger_level_in_debug?: string | undefined): logger;
+	/**
+	 * Return the basename of the current file
+	 */
+	export function get_default_logger_name(this: void, debuginfo: debug.FunctionInfo): string;
+}

package/generated/metrics.fps.d.ts

@@ -12,5 +12,23 @@ declare module 'metrics.fps' {
     draw: () => void;
   }
 
-  export function create(samples?: number, format?: string, position?: string, color?: string): Metrics;
+  /** Where `draw()` places the text, and the default `create()` uses when given no position. */
+  export const POSITION: Vector3;
+
+  /** The `string.format` pattern the FPS reading is rendered through. */
+  export const FORMAT: string;
+
+  /** The colour `draw()` renders the text in, and the default `create()` uses when given no colour. */
+  export const COLOR: Vector4;
+
+  export function create(samples?: number, format?: string, position?: Vector3, color?: Vector4): Metrics;
+
+  /** Call this once per frame. Once enough samples have been collected it is possible to call fps() to get the current FPS. */
+  export function update(): void;
+
+  /** Get the current FPS, based on collected samples. */
+  export function fps(): number;
+
+  /** Draw fps count text using `draw_debug_text`. */
+  export function draw(): void;
 }

package/generated/metrics.mem.d.ts

@@ -12,5 +12,23 @@ declare module 'metrics.mem' {
     draw: () => void;
   }
 
-  export function create(format?: string, position?: string, color?: string): Metrics;
+  /** Where `draw()` places the text, and the default `create()` uses when given no position. */
+  export const POSITION: Vector3;
+
+  /** The `string.format` pattern the memory reading is rendered through. */
+  export const FORMAT: string;
+
+  /** The colour `draw()` renders the text in, and the default `create()` uses when given no colour. */
+  export const COLOR: Vector4;
+
+  export function create(format?: string, position?: Vector3, color?: Vector4): Metrics;
+
+  /** Call this to get a new memory usage reading. */
+  export function update(): void;
+
+  /** Get the current memory usage, in kilobytes. */
+  export function mem(): number;
+
+  /** Draw memory usage text using `draw_debug_text`. */
+  export function draw(): void;
 }