@defold-typescript/types 0.51.0 → 0.53.0

package/generated/versions/defold-1.13.0/http.d.ts

@@ -1,5 +1,5 @@
 /** @noSelfInFile */
-import type { Hash } from "../../../src/core-types";
+import type { Hash, Url } from "../../../src/core-types";
 
 declare global {
   /**
@@ -72,7 +72,7 @@ declare global {
      * });
      * ```
      */
-    function request(url: string, method: string, callback: (self: unknown, id: Hash, response: { status: number; url: string; response?: string; headers?: LuaMap<string, string>; path?: string; error?: string; bytes_sent?: number; bytes_received?: number; bytes_total?: number; range_start?: number; range_end?: number; document_size?: number }) => void, headers?: LuaMap<string, string> | Record<string, string>, post_data?: string, options?: { timeout?: number; path?: string; ignore_cache?: boolean; chunked_transfer?: boolean; report_progress?: boolean }): void;
+    function request(url: string, method: string, callback: (self: unknown, id: Hash, response: { status: number; url: string; response?: string; headers?: LuaMap<string, string>; path?: string; error?: string; bytes_sent?: number; bytes_received?: number; bytes_total?: number; range_start?: number; range_end?: number; document_size?: number }, sender: Url) => void, headers?: LuaMap<string, string> | Record<string, string>, post_data?: string, options?: { timeout?: number; path?: string; ignore_cache?: boolean; chunked_transfer?: boolean; report_progress?: boolean }): void;
   }
 }
 

package/generated/versions/defold-1.13.0/image.d.ts

@@ -77,7 +77,87 @@ declare global {
      * });
      * ```
      */
-    function load(buffer: string, options?: { premultiply_alpha?: boolean; flip_vertically?: boolean }): { width: number; height: number; type: Opaque<"constant">; buffer: string } | undefined;
+    function load(buffer: string): { width: number; height: number; type: Opaque<"constant">; buffer: string } | undefined;
+    /**
+     * Load image (PNG or JPEG) from buffer.
+     *
+     * @param buffer - image data buffer
+     * @param options - An optional table containing parameters for loading the image. Supported entries:
+     *
+     * `premultiply_alpha`
+     * boolean True if alpha should be premultiplied into the color components. Defaults to `false`.
+     * `flip_vertically`
+     * boolean True if the image contents should be flipped vertically. Defaults to `false`.
+     * @returns object or `nil` if loading fails. The object is a table with the following fields:
+     *
+     * - number `width`: image width
+     * - number `height`: image height
+     * - constant `type`: image type
+     *   - `image.TYPE_RGB`
+     *   - `image.TYPE_RGBA`
+     *   - `image.TYPE_LUMINANCE`
+     *   - `image.TYPE_LUMINANCE_ALPHA`
+     * - string `buffer`: the raw image data
+     * @example
+     * ```ts
+     * // How to load an image from an URL and create a GUI texture from it:
+     * const imgurl = "http://www.site.com/image.png";
+     * http.request(imgurl, "GET", (self, id, response) => {
+     *   const img = response.response !== undefined ? image.load(response.response) : undefined;
+     *   if (img !== undefined) {
+     *     const tx = gui.new_texture("image_node", img.width, img.height, img.type, img.buffer);
+     *   }
+     * });
+     * ```
+     */
+    function load(buffer: string, options: { premultiply_alpha?: boolean; flip_vertically?: boolean }): { width: number; height: number; type: Opaque<"constant">; buffer: string } | undefined;
+    /**
+     * Load image (PNG or JPEG) from a string buffer.
+     *
+     * @param buffer - image data buffer
+     * @param options - An optional table containing parameters for loading the image. Supported entries:
+     *
+     * `premultiply_alpha`
+     * boolean True if alpha should be premultiplied into the color components. Defaults to `false`.
+     * `flip_vertically`
+     * boolean True if the image contents should be flipped vertically. Defaults to `false`.
+     * @returns object or `nil` if loading fails. The object is a table with the following fields:
+     *
+     * - number `width`: image width
+     * - number `height`: image height
+     * - constant `type`: image type
+     *   - `image.TYPE_RGB`
+     *   - `image.TYPE_RGBA`
+     *   - `image.TYPE_LUMINANCE`
+     *   - `image.TYPE_LUMINANCE_ALPHA`
+     * - buffer `buffer`: the script buffer that holds the decompressed image data. See buffer.create how to use the buffer.
+     * @example
+     * ```ts
+     * // Load an image from an URL as a buffer and create a texture resource from it:
+     * const imgurl = "http://www.site.com/image.png";
+     * http.request(imgurl, "GET", (self, id, response) => {
+     *   const img =
+     *     response.response !== undefined
+     *       ? image.load_buffer(response.response, { flip_vertically: true })
+     *       : undefined;
+     *   // the engine registers a texture format only when the driver supports it
+     *   const format = graphics.TEXTURE_FORMAT_RGBA;
+     *   if (img !== undefined && format !== undefined) {
+     *     const tparams = {
+     *       width: img.width,
+     *       height: img.height,
+     *       type: graphics.TEXTURE_TYPE_2D,
+     *       format,
+     *     };
+     *
+     *     const my_texture_id = resource.create_texture("/my_custom_texture.texturec", tparams, img.buffer);
+     *     // Apply the texture to a model
+     *     go.set("/go1#model", "texture0", my_texture_id);
+     *   }
+     * });
+     * ```
+     */
+    function load_buffer(buffer: string): { width: number; height: number; type: Opaque<"constant">; buffer: Opaque<"buffer"> & { length: LuaLengthMethod<number> } } | undefined;
     /**
      * Load image (PNG or JPEG) from a string buffer.
      *
@@ -124,7 +204,7 @@ declare global {
      * });
      * ```
      */
-    function load_buffer(buffer: string, options?: { premultiply_alpha?: boolean; flip_vertically?: boolean }): { width: number; height: number; type: Opaque<"constant">; buffer: Opaque<"buffer"> } | undefined;
+    function load_buffer(buffer: string, options: { premultiply_alpha?: boolean; flip_vertically?: boolean }): { width: number; height: number; type: Opaque<"constant">; buffer: Opaque<"buffer"> & { length: LuaLengthMethod<number> } } | undefined;
   }
 }
 

package/generated/versions/defold-1.13.0/index.d.ts

@@ -52,6 +52,7 @@ import "../../../src/scene-addresses";
 import "../../../src/go-overloads";
 import "../../../src/component-properties";
 import "../../../src/render-overloads";
+import "../../../src/gui-overloads";
 import "../../../src/vmath-overloads";
 import "../../../src/sys-overloads";
 

package/generated/versions/defold-1.13.0/label.d.ts

@@ -39,7 +39,7 @@ declare global {
      * ```
      */
     function set_text(url: string | Hash | Url, text: string | number): void;
-    interface properties {
+    interface Properties {
       /**
        * The color of the label. The type of the property is vector4.
        */

package/generated/versions/defold-1.13.0/liveupdate.d.ts

@@ -38,6 +38,10 @@ declare global {
      * Memory wasn't allocated
      */
     const LIVEUPDATE_MEM_ERROR: number & { readonly __brand: "liveupdate.LIVEUPDATE_MEM_ERROR" };
+    /**
+     * Live update is not initialized. `liveupdate.add_mount` and `liveupdate.remove_mount` return it while live update is disabled.
+     */
+    const LIVEUPDATE_NOT_INITIALIZED: number & { readonly __brand: "liveupdate.LIVEUPDATE_NOT_INITIALIZED" };
     /**
      * LIVEUPDATE_OK
      */

package/generated/versions/defold-1.13.0/material.d.ts

@@ -217,6 +217,8 @@ declare global {
      * - `graphics.TEXTURE_USAGE_FLAG_STORAGE`
      * - `graphics.TEXTURE_USAGE_FLAG_INPUT`
      * - `graphics.TEXTURE_USAGE_FLAG_COLOR`
+     *
+     * Keyed by sampler slot from 1; a slot with no texture has no entry, so iterate with `for (const [slot, info] of textures)`.
      * @example
      * ```ts
      * // Get the textures from a material specified as a resource property
@@ -231,7 +233,7 @@ declare global {
      * });
      * ```
      */
-    function get_textures(path: Hash | string): { path: Hash; handle: Hash; width: number; height: number; depth: number; mipmaps: number; type: number; flags: number }[];
+    function get_textures(path: Hash | string): LuaMap<number, { path: Hash; handle: Hash; width: number; height: number; depth: number; mipmaps: number; type: number; flags: number }>;
     /**
      * Returns a table of all the vertex attributes in the material. This function will return all the vertex attributes
      * that are used in the vertex shader of the material.

package/generated/versions/defold-1.13.0/model.d.ts

@@ -174,7 +174,7 @@ declare global {
      * });
      * ```
      */
-    function play_anim(url: string | Hash | Url, anim_id: string | Hash, playback: go.Playback, play_properties?: { blend_duration?: number; offset?: number; playback_rate?: number }, complete_function?: (self: unknown, message_id: Hash, message: BuiltinMessages["model_animation_done"]) => void): void;
+    function play_anim(url: string | Hash | Url, anim_id: string | Hash, playback: Exclude<go.Playback, typeof go.PLAYBACK_NONE>, play_properties?: { blend_duration?: number; offset?: number; playback_rate?: number }, complete_function?: (self: unknown, message_id: Hash, message: BuiltinMessages["model_animation_done"]) => void): void;
     /**
      * Resets a shader constant for a model component.
      * The constant must be defined in the material assigned to the model.
@@ -224,7 +224,7 @@ declare global {
      * ```
      */
     function set_mesh_enabled(url: string | Hash | Url, mesh_id: string | Hash, enabled: boolean): void;
-    interface properties {
+    interface Properties {
       /**
        * The current animation set on the component. The type of the property is hash.
        */
@@ -239,37 +239,69 @@ declare global {
        */
       playback_rate: number;
       /**
-       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
        */
       texture0: Hash;
       /**
-       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
        */
       texture1: Hash;
       /**
-       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
        */
       texture2: Hash;
       /**
-       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
        */
       texture3: Hash;
       /**
-       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
        */
       texture4: Hash;
       /**
-       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
        */
       texture5: Hash;
       /**
-       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
        */
       texture6: Hash;
       /**
-       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
        */
       texture7: Hash;
+      /**
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
+       */
+      texture8: Hash;
+      /**
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
+       */
+      texture9: Hash;
+      /**
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
+       */
+      texture10: Hash;
+      /**
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
+       */
+      texture11: Hash;
+      /**
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
+       */
+      texture12: Hash;
+      /**
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
+       */
+      texture13: Hash;
+      /**
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
+       */
+      texture14: Hash;
+      /**
+       * The texture hash id of the model, read and written on the texture unit the key's number names (`texture3` is unit 3).
+       */
+      texture15: Hash;
     }
   }
 }

package/generated/versions/defold-1.13.0/particlefx.d.ts

@@ -134,8 +134,29 @@ declare global {
      * });
      * ```
      */
-    function stop(url: string | Hash | Url, options?: { clear?: boolean }): void;
-    interface properties {
+    function stop(url: string | Hash | Url): void;
+    /**
+     * Stops a particle FX component from playing.
+     * Stopping a particle FX does not remove already spawned particles.
+     * Which particle FX to stop is identified by the URL.
+     *
+     * @param url - the particle fx that should stop playing
+     * @param options - Options when stopping the particle fx. Supported options:
+     *
+     * - boolean `clear`: instantly clear spawned particles
+     * @example
+     * ```ts
+     * // How to stop a particle fx when a game object is deleted and immediately also
+     * // clear any spawned particles:
+     * export default defineScript({
+     *   final(self) {
+     *     particlefx.stop("#particlefx", { clear: true });
+     *   },
+     * });
+     * ```
+     */
+    function stop(url: string | Hash | Url, options: { clear?: boolean }): void;
+    interface Properties {
       /**
        * The animation used during rendering by an emitter in a particle FX component.
        * The property type is a hash and refers to a valid animation in an atlas or a tile source resource.

package/generated/versions/defold-1.13.0/physics.d.ts

@@ -269,7 +269,51 @@ declare global {
      * });
      * ```
      */
-    function raycast_async(from: Vector3, to: Vector3, groups: Hash[], request_id?: number): void;
+    function raycast_async(from: Vector3, to: Vector3, groups: Hash[]): void;
+    /**
+     * Ray casts are used to test for intersections against collision objects in the physics world.
+     * Collision objects of types kinematic, dynamic and static are tested against. Trigger objects
+     * do not intersect with ray casts.
+     * Which collision objects to hit is filtered by their collision groups and can be configured
+     * through `groups`.
+     * The actual ray cast will be performed during the physics-update.
+     *
+     * - If an object is hit, the result will be reported via a ray_cast_response message.
+     * - If there is no object hit, the result will be reported via a ray_cast_missed message.
+     *
+     * NOTE: Ray casts will ignore collision objects that contain the starting point of the ray. This is a limitation in Box2D.
+     *
+     * @param from - the world position of the start of the ray
+     * @param to - the world position of the end of the ray
+     * @param groups - a lua table containing the hashed groups for which to test collisions against
+     * @param request_id - a number in range [0,255]. It will be sent back in the response for identification, 0 by default
+     * @example
+     * ```ts
+     * // How to perform a ray cast asynchronously:
+     * export default defineScript({
+     *   init() {
+     *     return { my_groups: [hash("my_group1"), hash("my_group2")] };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // request ray cast
+     *     const my_start = go.get_world_position();
+     *     const my_end = vmath.vector3(my_start.x, my_start.y - 100, my_start.z);
+     *     physics.raycast_async(my_start, my_end, self.my_groups);
+     *   },
+     *
+     *   on_message(self, message_id, message, sender) {
+     *     // check for the response
+     *     if (message_id === hash("ray_cast_response")) {
+     *       // act on the hit
+     *     } else if (message_id === hash("ray_cast_missed")) {
+     *       // act on the miss
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function raycast_async(from: Vector3, to: Vector3, groups: Hash[], request_id: number): void;
     /**
      * Only one physics world event listener can be set at a time.
      *
@@ -526,7 +570,7 @@ declare global {
      * ```
      */
     function wakeup(url: string | Hash | Url): void;
-    interface properties {
+    interface Properties {
       /**
        * The angular damping value for the collision object. Setting this value alters the damping of
        * angular motion of the object (rotation). Valid values are between 0 (no damping) and 1 (full damping).

package/generated/versions/defold-1.13.0/render.d.ts

@@ -6,10 +6,11 @@ declare global {
    * Rendering API documentation
    */
   namespace render {
-    type constant_buffer = Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | ConstantArray<Vector4> | ConstantArray<Matrix4> };
-    type render_target = Opaque<"render_target">;
-    type texture = Opaque<"texture">;
+    type ConstantBuffer = Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | ConstantArray<Vector4> | ConstantArray<Matrix4> };
+    type RenderTarget = Opaque<"render_target">;
+    type Texture = Opaque<"texture">;
     type ClearBufferKey = typeof graphics.BUFFER_TYPE_COLOR0_BIT | typeof graphics.BUFFER_TYPE_DEPTH_BIT | typeof graphics.BUFFER_TYPE_STENCIL_BIT;
+    type RenderTargetTextureType = typeof graphics.TEXTURE_TYPE_2D | typeof graphics.TEXTURE_TYPE_CUBE_MAP;
     type RenderTargetParams = Record<string | number, unknown>;
     /**
      * The rendering context was lost. Rendering is paused and all graphics resources become invalid. Passed to the `render.set_listener` callback.
@@ -177,7 +178,7 @@ declare global {
      * });
      * ```
      */
-    function disable_state(state: graphics.State): void;
+    function disable_state(state: Exclude<graphics.State, typeof graphics.STATE_ALPHA_TEST_SUPPORTED | typeof graphics.STATE_SCISSOR_TEST>): void;
     /**
      * Disables a texture that has previourly been enabled.
      *
@@ -212,7 +213,7 @@ declare global {
      * });
      * ```
      */
-    function disable_texture(binding: Opaque<"texture"> | string | Hash | number): void;
+    function disable_texture(binding: string | Hash | number): void;
     /**
      * Dispatches the currently enabled compute program. The dispatch call takes three arguments x,y,z which constitutes
      * the 'global working group' of the compute dispatch. Together with the 'local working group' specified in the compute shader
@@ -325,7 +326,69 @@ declare global {
      * }
      * ```
      */
-    function draw(predicate: Opaque<"render_predicate">, options?: { frustum?: Matrix4; frustum_planes?: number; constants?: Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | ConstantArray<Vector4> | ConstantArray<Matrix4> }; sort_order?: number }): void;
+    function draw(predicate: Opaque<"render_predicate">): void;
+    /**
+     * Draws all objects that match a specified predicate. An optional constant buffer can be
+     * provided to override the default constants. If no constants buffer is provided, a default
+     * system constants buffer is used containing constants as defined in materials and set through
+     * go.set (or particlefx.set_constant) on visual components.
+     *
+     * @param predicate - predicate to draw for
+     * @param options - optional table with properties:
+     *
+     * `frustum`
+     * matrix4 A frustum matrix used to cull renderable items. (E.g. `local frustum = proj * view`). default=nil
+     * `frustum_planes`
+     * int Determines which sides of the frustum will be used. Default is render.FRUSTUM_PLANES_SIDES.
+     *
+     * - render.FRUSTUM_PLANES_SIDES : The left, right, top and bottom sides of the frustum.
+     * - render.FRUSTUM_PLANES_ALL : All 6 sides of the frustum.
+     *
+     * `constants`
+     * constant_buffer optional constants to use while rendering
+     * `sort_order`
+     * int How to sort draw order for world-ordered entries. Default uses the renderer's preferred world sorting (back-to-front).
+     * @example
+     * ```ts
+     * export default defineRenderScript({
+     *   init() {
+     *     // define a predicate matching anything with material tag "my_tag"
+     *     return { my_pred: render.predicate([hash("my_tag")]) };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // draw everything in the my_pred predicate
+     *     render.draw(self.my_pred);
+     *   },
+     * });
+     * ```
+     * @example
+     * Draw predicate with constants:
+     * ```ts
+     * function draw_tinted(self: { my_pred: Opaque<"render_predicate"> }) {
+     *   const constants = render.constant_buffer();
+     *   constants.tint = vmath.vector4(1, 1, 1, 1);
+     *   render.draw(self.my_pred, { constants });
+     * }
+     * ```
+     * @example
+     * Draw with predicate and frustum culling (without near+far planes):
+     * ```ts
+     * function draw_culled(self: { my_pred: Opaque<"render_predicate">; proj: Matrix4; view: Matrix4 }) {
+     *   const frustum = self.proj.mul(self.view);
+     *   render.draw(self.my_pred, { frustum });
+     * }
+     * ```
+     * @example
+     * Draw with predicate and frustum culling (with near+far planes):
+     * ```ts
+     * function draw_culled(self: { my_pred: Opaque<"render_predicate">; proj: Matrix4; view: Matrix4 }) {
+     *   const frustum = self.proj.mul(self.view);
+     *   render.draw(self.my_pred, { frustum, frustum_planes: render.FRUSTUM_PLANES_ALL });
+     * }
+     * ```
+     */
+    function draw(predicate: Opaque<"render_predicate">, options: { frustum?: Matrix4; frustum_planes?: number; constants?: Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | ConstantArray<Vector4> | ConstantArray<Matrix4> }; sort_order?: number }): void;
     /**
      * Draws all 3d debug graphics such as lines drawn with "draw_line" messages and physics visualization.
      *
@@ -400,7 +463,7 @@ declare global {
      * });
      * ```
      */
-    function enable_state(state: graphics.State): void;
+    function enable_state(state: Exclude<graphics.State, typeof graphics.STATE_ALPHA_TEST_SUPPORTED | typeof graphics.STATE_SCISSOR_TEST>): void;
     /**
      * Sets the specified texture handle for a render target attachment or a regular texture
      * that should be used for rendering. The texture can be bound to either a texture unit
@@ -762,7 +825,7 @@ declare global {
      * render.set_blend_func_separate(graphics.BLEND_FACTOR_SRC_ALPHA, graphics.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, graphics.BLEND_FACTOR_ONE, graphics.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA);
      * ```
      */
-    function set_blend_func_separate(source_factor_color: number, destination_factor_color: number, source_factor_alpha: number, destination_factor_alpha: number): void;
+    function set_blend_func_separate(source_factor_color: graphics.BlendFactor, destination_factor_color: graphics.BlendFactor, source_factor_alpha: graphics.BlendFactor, destination_factor_alpha: graphics.BlendFactor): void;
     /**
      * Sets the current render camera to be used for rendering. If a render camera
      * has been set by the render script, the renderer will be using its projection and view matrix
@@ -1043,7 +1106,82 @@ declare global {
      * });
      * ```
      */
-    function set_render_target(render_target?: Opaque<"render_target"> | string | Hash | typeof render.RENDER_TARGET_DEFAULT, options?: { transient?: graphics.BufferType[] }): void;
+    function set_render_target(render_target?: Opaque<"render_target"> | string | Hash | typeof render.RENDER_TARGET_DEFAULT): void;
+    /**
+     * Sets a render target. Subsequent draw operations will be to the
+     * render target until it is replaced by a subsequent call to set_render_target.
+     * This function supports render targets created by a render script, or a render target resource.
+     *
+     * @param render_target - render target to set. render.RENDER_TARGET_DEFAULT to set the default render target
+     * @param options - optional table with behaviour parameters
+     *
+     * `transient`
+     * table Transient frame buffer types are only valid while the render target is active, i.e becomes undefined when a new target is set by a subsequent call to set_render_target.
+     * Default is all non-transient. Be aware that some hardware uses a combined depth stencil buffer and when this is the case both are considered non-transient if exclusively selected!
+     * A buffer type defined that doesn't exist in the render target is silently ignored.
+     *
+     * - `graphics.BUFFER_TYPE_COLOR0_BIT`
+     * - `graphics.BUFFER_TYPE_DEPTH_BIT`
+     * - `graphics.BUFFER_TYPE_STENCIL_BIT`
+     * @example
+     * How to set a render target and draw to it and then switch back to the default render target
+     * The render target defines the depth/stencil buffers as transient, when set_render_target is called the next time the buffers may be invalidated and allow for optimisations depending on driver support
+     * ```ts
+     * // How to set a render target and draw to it and then switch back to the default render target
+     * // The render target defines the depth/stencil buffers as transient, when set_render_target is called the next time the buffers may be invalidated and allow for optimisations depending on driver support
+     * export default defineRenderScript({
+     *   init() {
+     *     // the engine registers a texture format only when the driver supports it
+     *     const format = graphics.TEXTURE_FORMAT_RGBA;
+     *     if (format === undefined) return undefined;
+     *     const color_params = {
+     *       format,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *     };
+     *     return {
+     *       my_render_target: render.render_target({ [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params }),
+     *       my_pred: render.predicate([hash("my_tag")]),
+     *     };
+     *   },
+     *
+     *   update(self, dt) {
+     *     if (self === undefined) return;
+     *     // set render target so all drawing is done to it
+     *     render.set_render_target(self.my_render_target, {
+     *       transient: [graphics.BUFFER_TYPE_DEPTH_BIT, graphics.BUFFER_TYPE_STENCIL_BIT],
+     *     });
+     *
+     *     // draw a predicate to the render target
+     *     render.draw(self.my_pred);
+     *
+     *     // set default render target. This also invalidates the depth and stencil buffers of the current target (self.my_render_target)
+     *     //  which can be an optimisation on some hardware
+     *     render.set_render_target(render.RENDER_TARGET_DEFAULT);
+     *   },
+     * });
+     * ```
+     * @example
+     * ```ts
+     * export default defineRenderScript({
+     *   init() {
+     *     return { my_pred: render.predicate([hash("my_tag")]) };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // set render target by a render target resource identifier
+     *     render.set_render_target("my_rt_resource");
+     *
+     *     // draw a predicate to the render target
+     *     render.draw(self.my_pred);
+     *
+     *     // reset the render target to the default backbuffer
+     *     render.set_render_target(render.RENDER_TARGET_DEFAULT);
+     *   },
+     * });
+     * ```
+     */
+    function set_render_target(render_target: Opaque<"render_target"> | string | Hash | typeof render.RENDER_TARGET_DEFAULT | undefined, options: { transient?: graphics.BufferType[] }): void;
     /**
      * Sets the render target size for a render target created from
      * either a render script, or from a render target resource.