@defold-typescript/library-types 0.23.0 → 0.24.0

package/generated/orthographic.camera.d.ts

@@ -6,14 +6,14 @@
  */
 declare module 'orthographic.camera' {
 	/**
-	 * Follow a game object.
+	 * Follow one or more game objects. When following multiple objects the camera will follow the center point between the objects.
 	 * @param camera_id undefined for the first camera
-	 * @param target Game object to follow
+	 * @param targets Game object(s) to follow
 	 * @param options Options
 	 */
 	export function follow(
 		camera_id: Hash | Url | undefined,
-		target: Hash | Url,
+		targets: Hash | Url | (Hash | Url)[],
 		options?: {
 			/**
 			 *  Lerp from current position to target position with lerp as t.
@@ -54,6 +54,24 @@ declare module 'orthographic.camera' {
 		zoom: number,
 	): void;
 
+	/**
+	 * Get if the camera is configured to use automatic zoom level.
+	 * @param camera_id undefined for the first camera
+	 */
+	export function get_automatic_zoom(
+		camera_id: Hash | Url | undefined,
+	): boolean;
+
+	/**
+	 * Set if the camera should use automatic zoom level.
+	 * @param camera_id undefined for the first camera
+	 * @param enabled True if automatic zoom should be enabled
+	 */
+	export function set_automatic_zoom(
+		camera_id: Hash | Url | undefined,
+		enabled: boolean,
+	): void;
+
 	/**
 	 * Shake the camera.
 	 * @param camera_id undefined for the first camera
@@ -133,12 +151,6 @@ declare module 'orthographic.camera' {
 		camera_id: Hash | Url | undefined,
 	): Matrix4;
 
-	/**
-	 * Get the current projection id of the camera.
-	 * @param camera_id undefined for the first camera
-	 */
-	export function get_projection_id(camera_id: Hash | Url | undefined): Hash;
-
 	/**
 	 * Apply a recoil effect to the camera. The recoil will decay using linear interpolation.
 	 * @param camera_id
@@ -214,18 +226,13 @@ declare module 'orthographic.camera' {
 	): Vector4;
 
 	/**
-	 * Translate world coordinates to screen coordinates, based on the view and projection of the camera, optionally taking into account an adjust mode. This is useful when manually culling game objects and you need to determine if a world coordinate will be visible or not. It can also be used to position gui nodes on top of game objects.
+	 * Translate world coordinates to screen coordinates, based on the view and projection of the camera. This is useful when manually culling game objects and you need to determine if a world coordinate will be visible or not. It can also be used to position gui nodes on top of game objects.
 	 * @param camera_id undefined for the first camera
 	 * @param world World coordinates to convert
-	 * @param adjust_mode One of gui.ADJUST_FIT, gui.ADJUST_ZOOM and gui.ADJUST_STRETCH, or undefined to not take into account the adjust mode.
 	 */
 	export function world_to_screen(
 		camera_id: Hash | Url | undefined,
 		world: Vector3,
-		adjust_mode?:
-			| typeof gui.ADJUST_FIT
-			| typeof gui.ADJUST_STRETCH
-			| typeof gui.ADJUST_ZOOM,
 	): Vector3;
 
 	/**
@@ -252,26 +259,6 @@ declare module 'orthographic.camera' {
 		world: Vector3,
 	): Vector3;
 
-	/**
-	 * Add a custom projector that can be used by cameras in your project (see configuration above).
-	 * @param projector_id  Id of the projector. Used as a value in the projection field of the camera script.
-	 * @param projector_fn The function to call when a projection matrix is needed for the camera. The function will receive the id, near_z and far_z values of the camera.
-	 */
-	export function add_projector(
-		projector_id: Hash,
-		projector_fn: (id: Hash, near_z: number, far_z: number) => void,
-	): void;
-
-	/**
-	 * Set a specific projector for a camera. This must be either one of the predefined projectors (see above) or a custom projector added using `camera.add_projector()`.
-	 * @param camera_id undefined for the first camera
-	 * @param projector_id  Id of the projector.
-	 */
-	export function use_projector(
-		camera_id: Hash | Url | undefined,
-		projector_id: Hash,
-	): void;
-
 	/**
 	 * Set window scaling factor (basically retina or no retina screen). There is no built-in way to detect if Defold is running on a retina or non retina screen. This information combined with the High DPI setting in game.project can be used to ensure that the zoom behaves the same way regardless of screen type and High DPI setting. You can use an extension such as DefOS to get the window scaling factor.
 	 * @param scaling_factor Current window scaling factor
@@ -288,8 +275,6 @@ declare module 'orthographic.camera' {
 	export const SHAKE_VERTICAL: Hash;
 	export const SHAKE_HORIZONTAL: Hash;
 
-	export const ORTHOGRAPHIC_RENDER_SCRIPT_USED: boolean;
-
 	export const MSG_DISABLE: Hash;
 	export const MSG_UNFOLLOW: Hash;
 	export const MSG_FOLLOW: Hash;
@@ -302,7 +287,8 @@ declare module 'orthographic.camera' {
 	export const MSG_BOUNDS: Hash;
 	export const MSG_UPDATE_CAMERA: Hash;
 	export const MSG_ZOOM_TO: Hash;
-	export const MSG_USE_PROJECTION: Hash;
+	/** Posted to a camera to turn automatic zoom on or off. */
+	export const MSG_SET_AUTOMATIC_ZOOM: Hash;
 	export const MSG_VIEWPORT: Hash;
 	export const MSG_ENABLE: Hash;
 }

package/generated/orthographic.d.ts

@@ -0,0 +1,155 @@
+/** @noSelfInFile */
+/** @noResolution */
+declare module 'orthographic.camera' {
+  /**
+   * (synthesized)
+   * Defold `orthographic` API namespace.
+   */
+  export namespace orthographic {
+    /**
+     * Limits the camera position to within the specified rectangle.
+     *
+     * @param camera_id - nil for the first camera
+     * @param left - Left edge of the camera bounds
+     * @param top - Top edge of camera bounds
+     * @param right - Right edge of camera bounds
+     * @param bottom - Bottom edge of camera bounds
+     */
+    function bounds(camera_id: Hash | Url | undefined, left: number, top: number, right: number, bottom: number): void;
+    /**
+     * If following a game object this will add a deadzone around the camera position where the camera position will not update. If the target moves to the edge of the deadzone the camera will start to follow until the target returns within the bounds of the deadzone.
+     *
+     * @param camera_id - nil for the first camera
+     * @param left - Number of pixels to the left of the camera
+     * @param top - Number of pixels above the camera
+     * @param right - Number of pixels to the right of the camera
+     * @param bottom - Number of pixels below the camera
+     */
+    function deadzone(camera_id: Hash | Url | undefined, left: number, top: number, right: number, bottom: number): void;
+    /**
+     * Follow one or more game objects. When following multiple objects the camera will follow the center point between the objects.
+     *
+     * @param camera_id - nil for the first camera
+     * @param targets - Game object(s) to follow
+     * @param options - Options (see below)
+     */
+    function follow(camera_id: Hash | Url | undefined, targets: Hash | Url | Record<string | number, unknown>, options?: Record<string | number, unknown>): void;
+    /**
+     * Change the camera follow offset.
+     *
+     * @param camera_id - nil for the first camera
+     * @param offset - Camera offset from target position.
+     */
+    function follow_offset(camera_id: Hash | Url | undefined, offset: Vector3): void;
+    /**
+     * Get if the camera is configured to use automatic zoom level.
+     *
+     * @returns True if automatic zoom is enabled
+     */
+    function get_automatic_zoom(): boolean;
+    /**
+     * Get the display size, as specified in game.project.
+     */
+    function get_display_size(): LuaMultiReturn<[number, number]>;
+    /**
+     * Get the current offset of the camera (caused by shake or recoil)
+     *
+     * @param camera_id - nil for the first camera
+     * @returns The current offset of the camera
+     */
+    function get_offset(camera_id?: Hash | Url): Vector3;
+    /**
+     * Get the current projection of the camera.
+     *
+     * @param camera_id - nil for the first camera
+     * @returns The current projection
+     */
+    function get_projection(camera_id?: Hash | Url): Matrix4;
+    /**
+     * Get the current view of the camera.
+     *
+     * @param camera_id - nil for the first camera
+     * @returns The current view
+     */
+    function get_view(camera_id?: Hash | Url): Matrix4;
+    /**
+     * Get the current viewport of the camera.
+     *
+     * @param camera_id - nil for the first camera
+     */
+    function get_viewport(camera_id?: Hash | Url): LuaMultiReturn<[number, number, number, number]>;
+    /**
+     * Get the current window size. The default values will be the ones specified in game.project.
+     */
+    function get_window_size(): LuaMultiReturn<[number, number]>;
+    /**
+     * Get the current zoom level of the camera.
+     *
+     * @param camera_id - nil for the first camera
+     * @returns The current zoom of the camera
+     */
+    function get_zoom(camera_id?: Hash | Url): number;
+    /**
+     * Apply a recoil effect to the camera. The recoil will decay using linear interpolation.
+     *
+     * @param offset - Offset to apply to the camera. Defaults to 0.05
+     * @param duration - Duration of the recoil, in seconds. Defaults to 0.5
+     */
+    function recoil(camera_id: Hash | Url, offset: Vector3, duration?: number): void;
+    /**
+     * Translate screen coordinates to world coordinates, based on the view and projection of the camera.
+     *
+     * @param camera_id - nil for the first camera
+     * @param screen - Screen coordinates to convert
+     * @returns World coordinates
+     */
+    function screen_to_world(camera_id: Hash | Url | undefined, screen: Vector3): Vector3;
+    /**
+     * Translate screen boundaries (corners) to world coordinates, based on the view and projection of the camera.
+     *
+     * @param camera_id - nil for the first camera
+     * @returns Screen bounds (x = left, y = top, z = right, w = bottom)
+     */
+    function screen_to_world_bounds(camera_id?: Hash | Url): Vector4;
+    /**
+     * Set if the camera should use automatic zoom level.
+     *
+     * @param enabled - True if automatic zoom should be enabled
+     */
+    function set_automatic_zoom(enabled: boolean): void;
+    /**
+     * Change the zoom level of the camera.
+     *
+     * @param camera_id - nil for the first camera
+     * @param zoom - The new zoom level of the camera
+     */
+    function set_zoom(camera_id: Hash | Url | undefined, zoom: number): void;
+    /**
+     * Shake the camera.
+     *
+     * @param intensity - Intensity of the shake, in percent of screen. Defaults to 0.05
+     * @param duration - Duration of the shake, in seconds. Defaults to 0.5
+     * @param direction - Direction of the shake. Possible values: `both`, `horizontal`, `vertical`. Defaults to `both`.
+     * @param cb - Function to call when the shake has finished. Optional.
+     */
+    function shake(camera_id: Hash | Url, intensity?: number, duration?: number, direction?: Hash, cb?: (...args: unknown[]) => unknown): void;
+    /**
+     * Stop shaking the camera.
+     */
+    function stop_shaking(camera_id: Hash | Url): void;
+    /**
+     * Stop following a game object.
+     *
+     * @param camera_id - nil for the first camera
+     */
+    function unfollow(camera_id?: Hash | Url): void;
+    /**
+     * Translate world coordinates to screen coordinates, based on the view and projection of the camera. This is useful when manually culling game objects and you need to determine if a world coordinate will be visible or not. It can also be used to position gui nodes on top of game objects.
+     *
+     * @param camera_id - nil for the first camera
+     * @param world - World coordinates to convert
+     * @returns Screen coordinates
+     */
+    function world_to_screen(camera_id: Hash | Url | undefined, world: Vector3): Vector3;
+  }
+}

package/generated/panthera.d.ts

@@ -0,0 +1,170 @@
+/** @noResolution */
+declare module 'panthera.panthera' {
+	interface panthera_animation {
+		adapter: panthera_adapter;
+		speed: number;
+		current_time: number;
+		nodes: LuaTable;
+		childs?: panthera_animation[] | undefined;
+		get_node: (node_id: string) => Opaque<"node">;
+		animation_id?: string | undefined;
+		previous_animation_id?: string | undefined;
+		animation_path: string;
+		animation_keys_index: number;
+		events?: LuaTable | undefined;
+		timer_id?: number | undefined;
+	}
+	interface panthera_options {
+		is_loop?: boolean | undefined;
+		is_skip_init?: boolean | undefined;
+		is_detached?: boolean | undefined;
+		speed?: number | undefined;
+		easing?: string | Opaque<"constant"> | undefined;
+		callback?: ((animation_id: string) => undefined) | undefined;
+		callback_event?: ((event_id: string, node: Opaque<"node"> | undefined, string_value: string, number_value: number) => undefined) | undefined;
+	}
+	interface panthera_options_tweener {
+		speed?: number | undefined;
+		is_loop?: boolean | undefined;
+		easing?: string | Opaque<"constant"> | undefined;
+		callback?: ((animation_id: string) => undefined) | undefined;
+		callback_event?: ((event_id: string, node: Opaque<"node"> | undefined, string_value: string, number_value: number) => undefined) | undefined;
+		is_reverse?: boolean | undefined;
+		from?: number | undefined;
+		to?: number | undefined;
+	}
+	interface panthera {
+		SPEED: number;
+	}
+	interface panthera_adapter {
+		get_node: (node_id: string) => Opaque<"node">;
+		get_easing: (easing_id: string) => Hash;
+		tween_animation_key: (node: Opaque<"node">, property_id: string, easing: Hash | number[], duration: number, end_value: number) => undefined;
+		trigger_animation_key: (node: Opaque<"node">, property_id: string, value: unknown) => undefined;
+		event_animation_key: (node: Opaque<"node">, key: panthera_animation_data_animation_key) => undefined;
+		set_node_property: (node: Opaque<"node">, property_id: string, value: number | string) => boolean;
+		stop_tween: (node: Opaque<"node">, property_id: string) => undefined;
+		is_node_valid: (node: Opaque<"node">) => boolean;
+	}
+	interface panthera_logger {
+		trace: (logger: panthera_logger, message: string, data: unknown | undefined) => void;
+		debug: (logger: panthera_logger, message: string, data: unknown | undefined) => void;
+		info: (logger: panthera_logger, message: string, data: unknown | undefined) => void;
+		warn: (logger: panthera_logger, message: string, data: unknown | undefined) => void;
+		error: (logger: panthera_logger, message: string, data: unknown | undefined) => void;
+	}
+	interface panthera_animation_data_node {
+	}
+	interface panthera_animation_data_metadata {
+		gui_path: string;
+		fps: number;
+		settings: LuaTable;
+		gizmo_steps: LuaTable;
+		template_animation_paths: LuaTable<string, string>;
+	}
+	interface panthera_animation_data_animation {
+		duration: number;
+		animation_id: string;
+		initial_state: string;
+		animation_keys: panthera_animation_data_animation_key[];
+	}
+	interface panthera_animation_data {
+		name: string;
+		nodes: panthera_animation_data_node[];
+		animations: panthera_animation_data_animation[];
+		metadata: panthera_animation_data_metadata;
+		group_animation_keys: LuaTable<string, LuaTable<string, LuaTable<string, panthera_animation_data_animation_key[]>>>;
+		animations_dict: LuaTable<string, panthera_animation_data_animation>;
+	}
+	interface panthera_animation_project_file {
+		data: panthera_animation_data;
+		format: string;
+		version: string;
+		type: string;
+	}
+	interface panthera_animation_data_animation_key {
+		key_type: number;
+		node_id: string;
+		property_id: string;
+		start_time: number;
+		duration: number;
+		start_value: number;
+		end_value: number;
+		easing: string;
+		easing_custom?: number[] | Vector | undefined;
+		start_data: string;
+		data: string;
+		event_id: string;
+		is_editor_only: boolean;
+	}
+	/**
+	 * Customize the logging mechanism used by Panthera Runtime. You can use Defold Log library or provide a custom logger.
+	 */
+	export function set_logger(this: void, logger_instance?: panthera_logger | LuaTable | undefined): void;
+	/**
+	 * Load and create a game object animation state from a Lua table or JSON file.
+	 */
+	export function create_go(this: void, animation_or_path: string | LuaTable, collection_name?: string | undefined, objects?: LuaTable<string | Hash, string | Hash> | undefined): panthera_animation;
+	/**
+	 * Load and create a GUI animation state from a Lua table or JSON file.
+	 */
+	export function create_gui(this: void, animation_or_path: string | LuaTable, template?: string | undefined, nodes?: LuaTable<string | Hash, Opaque<"node">> | undefined): panthera_animation;
+	/**
+	 * Load an animation from a Lua table or JSON file and create an animation state using a specified adapter.
+	 */
+	export function create(this: void, animation_or_path: string | LuaTable, adapter: panthera_adapter, get_node: (node_id: string) => Opaque<"node">): panthera_animation;
+	/**
+	 * Clone an existing animation state object, enabling multiple instances of the same animation to play simultaneously or independently.
+	 */
+	export function clone_state(this: void, animation_state: panthera_animation): panthera_animation;
+	/**
+	 * Play an animation with specified ID and options.
+	 */
+	export function play(this: void, animation_state: panthera_animation, animation_id: string, options?: panthera_options | undefined): void;
+	/**
+	 * Play animation with easing support using tweener. Allows for non-linear animation playback with custom easing functions.
+	 */
+	export function play_tweener(this: void, animation_state: panthera_animation, animation_id: string, options?: panthera_options_tweener | undefined): void;
+	/**
+	 * Play animation as a child of the current animation state, allowing multiple animations to run independently and simultaneously.
+	 *
+	 * This creates a detached animation that runs in parallel with the main animation state without affecting it.
+	 * The child animation will be automatically cleaned up when it completes.
+	 */
+	export function play_detached(this: void, animation_state: panthera_animation, animation_id: string, options?: panthera_options | undefined): void;
+	/**
+	 * Set the current time of an animation. This function stops any currently playing animation.
+	 */
+	export function set_time(this: void, animation_state: panthera_animation, animation_id: string, time: number, event_callback?: ((event_id: string, node: Opaque<"node"> | undefined, string_value: string, number_value: number) => void) | undefined): boolean;
+	/**
+	 * Retrieve the current playback time in seconds of an animation. If the animation is not playing, the function returns 0.
+	 */
+	export function get_time(this: void, animation_state: panthera_animation): number;
+	/**
+	 * Stop a currently playing animation. The animation will be stopped at current time.
+	 */
+	export function stop(this: void, animation_state: panthera_animation): boolean;
+	/**
+	 * Retrieve the total duration of a specific animation.
+	 */
+	export function get_duration(this: void, animation_state: panthera_animation, animation_id: string): number;
+	/**
+	 * Check if an animation is currently playing.
+	 */
+	export function is_playing(this: void, animation_state: panthera_animation): boolean;
+	/**
+	 * Get the ID of the last animation that was started.
+	 */
+	export function get_latest_animation_id(this: void, animation_state: panthera_animation): string | undefined;
+	/**
+	 * Return a list of animation IDs from the created animation state.
+	 */
+	export function get_animations(this: void, animation_state: panthera_animation): string[];
+	/**
+	 * Reload animations from JSON files, useful for development and debugging.
+	 *
+	 * The animations loaded from Lua tables will not be reloaded.
+	 * Animation will be reloaded only at desktop.
+	 */
+	export function reload_animation(this: void, animation_path?: string | undefined): void;
+}

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

@@ -31,4 +31,7 @@ declare module 'persist.persist' {
 	 * Returns an `object`, or `undefined` if the file does not exist.
 	 */
 	export function load(file_name: string): {} | undefined;
+
+	/** Checks if a file exists. */
+	export function exists(file_name: string): boolean;
 }

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

@@ -67,6 +67,15 @@ declare module 'platypus.platypus' {
 	export const DOUBLE_JUMP: Hash;
 	export const WALL_SLIDE: Hash;
 
+	/** Value for `collisions.separation` selecting raycast separation. */
+	export const SEPARATION_RAYS: Hash;
+	/**
+	 * Value for `collisions.separation` selecting shape separation. Platypus warns
+	 * at runtime that this mode is no longer supported and only raycast separation
+	 * is; the constant still exists.
+	 */
+	export const SEPARATION_SHAPES: Hash;
+
 	type Direction = number;
 	export const DIR_UP: Direction;
 	export const DIR_LEFT: Direction;

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

@@ -9,6 +9,39 @@
 declare module 'rendy.rendy' {
 	type CameraId = Hash | string;
 
+	/**
+	 * Every camera except the GUI camera, keyed by camera id. Exposed only because the
+	 * rendy.render_script file needs write-access to it; reach for `set` and `get`
+	 * rather than accessing or manipulating it directly.
+	 */
+	const cameras: LuaMap<CameraId, unknown>;
+
+	/**
+	 * Initial width of the window, specified in the game.project file. Exposed only
+	 * because the rendy.render_script file needs write-access to it; it is unset until
+	 * that script has run.
+	 */
+	const display_width: number;
+
+	/**
+	 * Initial height of the window, specified in the game.project file. Exposed only
+	 * because the rendy.render_script file needs write-access to it; it is unset until
+	 * that script has run.
+	 */
+	const display_height: number;
+
+	/**
+	 * Current width of the window. Exposed only because the rendy.render_script file
+	 * needs write-access to it; it is unset until that script has run.
+	 */
+	const window_width: number;
+
+	/**
+	 * Current height of the window. Exposed only because the rendy.render_script file
+	 * needs write-access to it; it is unset until that script has run.
+	 */
+	const window_height: number;
+
 	/**
 	 * Creates a camera. This function is called automatically by the rendy.go game object.
 	 * @param camera_id - The identifier for the camera.
@@ -29,86 +62,6 @@ declare module 'rendy.rendy' {
 	 */
 	function set(camera_id: CameraId, property: Hash | string, value: any): void;
 
-	/**
-	 * Animates a camera property. This function replaces the standard go.animate().
-	 * @param camera_id - The identifier for the camera.
-	 * @param property - The property to be animated.
-	 * @param playback - The playback mode of the animation.
-	 * @param to - The target value of the animation.
-	 * @param easing - The easing function for the animation.
-	 * @param duration - The duration of the animation.
-	 * @param delay - Optional delay before starting the animation.
-	 * @param complete_function - Optional function to be called when the animation is complete.
-	 */
-	function animate(
-		camera_id: CameraId,
-		property: Hash | string,
-		playback:
-			| typeof go.PLAYBACK_LOOP_BACKWARD
-			| typeof go.PLAYBACK_LOOP_FORWARD
-			| typeof go.PLAYBACK_LOOP_PINGPONG
-			| typeof go.PLAYBACK_ONCE_BACKWARD
-			| typeof go.PLAYBACK_ONCE_FORWARD
-			| typeof go.PLAYBACK_ONCE_PINGPONG,
-		to: Quaternion | Vector3 | Vector4 | number,
-		easing:
-			| Vector3
-			| typeof go.EASING_INBACK
-			| typeof go.EASING_INBOUNCE
-			| typeof go.EASING_INCIRC
-			| typeof go.EASING_INCUBIC
-			| typeof go.EASING_INELASTIC
-			| typeof go.EASING_INEXPO
-			| typeof go.EASING_INOUTBACK
-			| typeof go.EASING_INOUTBOUNCE
-			| typeof go.EASING_INOUTCIRC
-			| typeof go.EASING_INOUTCUBIC
-			| typeof go.EASING_INOUTELASTIC
-			| typeof go.EASING_INOUTEXPO
-			| typeof go.EASING_INOUTQUAD
-			| typeof go.EASING_INOUTQUART
-			| typeof go.EASING_INOUTQUINT
-			| typeof go.EASING_INOUTSINE
-			| typeof go.EASING_INQUAD
-			| typeof go.EASING_INQUART
-			| typeof go.EASING_INQUINT
-			| typeof go.EASING_INSINE
-			| typeof go.EASING_LINEAR
-			| typeof go.EASING_OUTBACK
-			| typeof go.EASING_OUTBOUNCE
-			| typeof go.EASING_OUTCIRC
-			| typeof go.EASING_OUTCUBIC
-			| typeof go.EASING_OUTELASTIC
-			| typeof go.EASING_OUTEXPO
-			| typeof go.EASING_OUTINBACK
-			| typeof go.EASING_OUTINBOUNCE
-			| typeof go.EASING_OUTINCIRC
-			| typeof go.EASING_OUTINCUBIC
-			| typeof go.EASING_OUTINELASTIC
-			| typeof go.EASING_OUTINEXPO
-			| typeof go.EASING_OUTINQUAD
-			| typeof go.EASING_OUTINQUART
-			| typeof go.EASING_OUTINQUINT
-			| typeof go.EASING_OUTINSINE
-			| typeof go.EASING_OUTQUAD
-			| typeof go.EASING_OUTQUART
-			| typeof go.EASING_OUTQUINT
-			| typeof go.EASING_OUTSINE,
-		duration: number,
-		delay?: number,
-		complete_function?: (this: any, url: Url, property: Hash) => void,
-	): void;
-
-	/**
-	 * Cancels a camera property animation. This function replaces the standard go.cancel_animations().
-	 * @param camera_id - The identifier for the camera.
-	 * @param property - The property of the animation to be cancelled.
-	 */
-	function cancel_animations(
-		camera_id: CameraId,
-		property: Hash | string,
-	): void;
-
 	/**
 	 * Gets a camera property. This function is equivalent to the standard go.get().
 	 * @param camera_id - The identifier for the camera.

package/generated/richtext.color.d.ts

@@ -6,6 +6,21 @@
 declare module 'richtext.color' {
 	export function add(name: string, color: number | string): void;
 
+	/**
+	 * Resolves a color by name, hex string or comma-separated decimal string.
+	 */
+	export function parse(c: string): Vector4 | undefined;
+
+	/**
+	 * Parses a `#rrggbb` or `#rrggbbaa` hex string, with or without the leading `#`.
+	 */
+	export function parse_hex(hex: string): Vector4 | undefined;
+
+	/**
+	 * Parses a comma-separated `r,g,b,a` string of decimal components.
+	 */
+	export function parse_decimal(dec: string): Vector4 | undefined;
+
 	export const COLORS: {
 		aqua: Vector4;
 		black: Vector4;

package/generated/saver.saver.d.ts

@@ -41,6 +41,8 @@ declare module 'saver.saver' {
 	}
 	/**
 	 * Persist data between game sessions
+	 *
+	 * @deprecated
 	 */
 	interface saver_storage_state {
 		storage: LuaTable<string, saver_storage_value>;

package/generated/saver.storage.d.ts

@@ -41,6 +41,8 @@ declare module 'saver.storage' {
 	}
 	/**
 	 * Persist data between game sessions
+	 *
+	 * @deprecated
 	 */
 	interface saver_storage_state {
 		storage: LuaTable<string, saver_storage_value>;