@defold-typescript/types 0.51.0 → 0.52.0

package/generated/render-script-modules/sound.d.ts

@@ -0,0 +1,227 @@
+/** @noSelfInFile */
+import type { Hash } from "../../src/core-types";
+
+declare global {
+  /**
+   * Functions and messages for controlling sound components and
+   * mixer groups.
+   */
+  namespace sound {
+    /**
+     * Data passed to the completion callback of sound.play. The callback's
+     * `message_id` indicates whether playback finished or was stopped manually.
+     */
+    interface play_completion {
+      /**
+       * The sequential play identifier for the playback.
+       */
+      play_id: number;
+    }
+    /**
+     * Sound playback properties
+     */
+    interface play_properties {
+      /**
+       * Delay in seconds before playback starts. The default is 0.
+       */
+      delay?: number;
+      /**
+       * Gain from 0 to 1. The default is 1; this combines with the group and master gains.
+       */
+      gain?: number;
+      /**
+       * Pan from -1 to 1. The default is 0; this is added to the component pan.
+       */
+      pan?: number;
+      /**
+       * Playback speed from 0 to 50. The default is 1; this is multiplied by the component speed.
+       */
+      speed?: number;
+      /**
+       * Playback offset in seconds. Mutually exclusive with `start_frame`.
+       */
+      start_time?: number;
+      /**
+       * Playback offset in frames or samples. Takes precedence over `start_time`.
+       */
+      start_frame?: number;
+    }
+    /**
+     * Sound stop properties
+     */
+    interface stop_properties {
+      /**
+       * Sequential playback identifier returned by sound.play.
+       */
+      play_id?: number;
+    }
+    /**
+     * Get mixer group gain
+     *
+     * @param group - group name
+     * @returns gain in [0 1] range ([-60dB.. 0dB])
+     * @example
+     * ```ts
+     * // Get the mixer group gain for the "soundfx" and convert to dB:
+     * const gain = sound.get_group_gain("soundfx");
+     * const gain_db = 60 * gain;
+     * ```
+     */
+    function get_group_gain(group: string | Hash): number;
+    /**
+     * Get a mixer group name as a string.
+     * This function is to be used for debugging and
+     * development tooling only. The function does a reverse hash lookup, which does not
+     * return a proper string value when the game is built in release mode.
+     *
+     * @param group - group name
+     * @returns group name
+     * @example
+     * ```ts
+     * // Get the mixer group string names so we can show them as labels on a dev mixer overlay:
+     * const groups = sound.get_groups();
+     * for (const group of groups) {
+     *   const name = sound.get_group_name(group);
+     *   msg.post("/mixer_overlay#gui", "set_mixer_label", { group: group, label: name });
+     * }
+     * ```
+     */
+    function get_group_name(group: Hash): string;
+    /**
+     * Get a table of all mixer group names (hashes).
+     *
+     * @returns table of mixer group names
+     * @example
+     * ```ts
+     * // Get the mixer groups, set all gains to 0 except for "master" and "soundfx"
+     * // where gain is set to 1:
+     * const groups = sound.get_groups();
+     * for (const group of groups) {
+     *   if (group === hash("master") || group === hash("soundfx")) {
+     *     sound.set_group_gain(group, 1);
+     *   } else {
+     *     sound.set_group_gain(group, 0);
+     *   }
+     * }
+     * ```
+     */
+    function get_groups(): Hash[];
+    /**
+     * Get peak value from mixer group.
+     * Note that gain is in linear scale, between 0 and 1.
+     * To get the dB value from the gain, use the formula `20 * log(gain)`.
+     * Inversely, to find the linear value from a dB value, use the formula
+     * `10db/20`.
+     * Also note that the returned value might be an approximation and in particular
+     * the effective window might be larger than specified.
+     *
+     * @param group - group name
+     * @param window - window length in seconds
+     * @example
+     * ```ts
+     * // Get the peak gain from the "master" group and convert to dB for displaying:
+     * const [left_p, right_p] = sound.get_peak("master", 0.1);
+     * const left_p_db = 20 * Math.log(left_p);
+     * const right_p_db = 20 * Math.log(right_p);
+     * ```
+     */
+    function get_peak(group: string | Hash, window: number): LuaMultiReturn<[number, number]>;
+    /**
+     * Get RMS (Root Mean Square) value from mixer group. This value is the
+     * square root of the mean (average) value of the squared function of
+     * the instantaneous values.
+     * For instance: for a sinewave signal with a peak gain of -1.94 dB (0.8 linear),
+     * the RMS is `0.8 × 1/sqrt(2)` which is about 0.566.
+     * Note the returned value might be an approximation and in particular
+     * the effective window might be larger than specified.
+     *
+     * @param group - group name
+     * @param window - window length in seconds
+     * @example
+     * ```ts
+     * // Get the RMS from the "master" group where a mono -1.94 dB sinewave is playing:
+     * const [rms] = sound.get_rms("master", 0.1); // throw away right channel.
+     * print(rms); // => 0.56555819511414
+     * ```
+     */
+    function get_rms(group: string | Hash, window: number): LuaMultiReturn<[number, number]>;
+    /**
+     * Checks if background music is playing, e.g. from iTunes.
+     * On non mobile platforms,
+     * this function always return `false`.
+     * On Android you can only get a correct reading
+     * of this state if your game is not playing any sounds itself. This is a limitation
+     * in the Android SDK. If your game is playing any sounds, *even with a gain of zero*, this
+     * function will return `false`.
+     * The best time to call this function is:
+     *
+     * - In the `init` function of your main collection script before any sounds are triggered
+     * - In a window listener callback when the window.WINDOW_EVENT_FOCUS_GAINED event is received
+     *
+     * Both those times will give you a correct reading of the state even when your application is
+     * swapped out and in while playing sounds and it works equally well on Android and iOS.
+     *
+     * @returns `true` if music is playing, otherwise `false`.
+     * @example
+     * ```ts
+     * // If music is playing, mute "master":
+     * if (sound.is_music_playing()) {
+     *   // mute "master"
+     *   sound.set_group_gain("master", 0);
+     * }
+     * ```
+     */
+    function is_music_playing(): boolean;
+    /**
+     * Checks if a phone call is active. If there is an active phone call all
+     * other sounds will be muted until the phone call is finished.
+     * On non mobile platforms,
+     * this function always return `false`.
+     *
+     * @returns `true` if there is an active phone call, `false` otherwise.
+     * @example
+     * ```ts
+     * // Test if a phone call is on-going:
+     * if (sound.is_phone_call_active()) {
+     *   // do something sensible.
+     * }
+     * ```
+     */
+    function is_phone_call_active(): boolean;
+    /**
+     * Set mixer group gain
+     *
+     * @param group - group name
+     * @param gain - gain in range [0..1] mapped to [0 .. -60dB]
+     * @example
+     * ```ts
+     * // Set mixer group gain on the "soundfx" group to 50% (-30dB):
+     * sound.set_group_gain("soundfx", 0.5);
+     * ```
+     */
+    function set_group_gain(group: string | Hash, gain: number): void;
+    interface properties {
+      /**
+       * The gain on the sound-component. Note that gain is in linear scale,
+       * between 0 and 1.
+       */
+      gain: number;
+      /**
+       * The pan on the sound-component. The valid range is from -1.0 to 1.0,
+       * representing -45 degrees left, to +45 degrees right.
+       */
+      pan: number;
+      /**
+       * The sound data used when playing the sound. The type of the property is hash.
+       */
+      sound: Hash;
+      /**
+       * The speed on the sound-component where 1.0 is normal speed, 0.5 is half
+       * speed and 2.0 is double speed. Valid range is 0.0 to 50.0.
+       */
+      speed: number;
+    }
+  }
+}
+
+export {};

package/generated/render-script-modules/sprite.d.ts

@@ -0,0 +1,68 @@
+/** @noSelfInFile */
+import type { Hash, Vector3, Vector4 } from "../../src/core-types";
+
+declare global {
+  /**
+   * Sprite API documentation
+   */
+  namespace sprite {
+    /**
+     * Sprite flipbook playback properties
+     */
+    interface play_properties {
+      /**
+       * Normalized initial animation cursor.
+       */
+      offset?: number;
+      /**
+       * Positive animation playback rate.
+       */
+      playback_rate?: number;
+    }
+    interface properties {
+      /**
+       * READ ONLY The current animation id. An animation that plays currently for the sprite. The type of the property is hash.
+       */
+      readonly animation: Hash;
+      /**
+       * The normalized animation cursor. The type of the property is number.
+       */
+      cursor: number;
+      /**
+       * READ ONLY The frame count of the currently playing animation.
+       */
+      readonly frame_count: number;
+      /**
+       * The image used when rendering the sprite. The type of the property is hash.
+       */
+      image: Hash;
+      /**
+       * The material used when rendering the sprite. The type of the property is hash.
+       */
+      material: Hash;
+      /**
+       * The animation playback rate. A multiplier to the animation playback rate. The type of the property is number.
+       * The playback_rate is a non-negative number, a negative value will be clamped to 0.
+       */
+      playback_rate: number;
+      /**
+       * The non-uniform scale of the sprite. The type of the property is vector3.
+       */
+      scale: Vector3;
+      /**
+       * The size of the sprite, not allowing for any additional scaling that may be applied.
+       * The type of the property is vector3. It is not possible to set the size if the size mode
+       * of the sprite is set to auto.
+       */
+      size: Vector3;
+      /**
+       * The slice values of the sprite. The type of the property is a vector4 that corresponds to
+       * the left, top, right, bottom values of the sprite in the editor.
+       * It is not possible to set the slice property if the size mode of the sprite is set to auto.
+       */
+      slice: Vector4;
+    }
+  }
+}
+
+export {};

package/generated/render-script-modules/tilemap.d.ts

@@ -0,0 +1,43 @@
+/** @noSelfInFile */
+import type { Hash } from "../../src/core-types";
+
+declare global {
+  /**
+   * Functions and messages used to manipulate tile map components.
+   */
+  namespace tilemap {
+    type TRANSFORM = typeof tilemap.H_FLIP | typeof tilemap.ROTATE_180 | typeof tilemap.ROTATE_270 | typeof tilemap.ROTATE_90 | typeof tilemap.V_FLIP;
+    /**
+     * flip tile horizontally
+     */
+    const H_FLIP: number & { readonly __brand: "tilemap.H_FLIP" };
+    /**
+     * rotate tile 180 degrees clockwise
+     */
+    const ROTATE_180: number & { readonly __brand: "tilemap.ROTATE_180" };
+    /**
+     * rotate tile 270 degrees clockwise
+     */
+    const ROTATE_270: number & { readonly __brand: "tilemap.ROTATE_270" };
+    /**
+     * rotate tile 90 degrees clockwise
+     */
+    const ROTATE_90: number & { readonly __brand: "tilemap.ROTATE_90" };
+    /**
+     * flip tile vertically
+     */
+    const V_FLIP: number & { readonly __brand: "tilemap.V_FLIP" };
+    interface properties {
+      /**
+       * The material used when rendering the tile map. The type of the property is hash.
+       */
+      material: Hash;
+      /**
+       * The tile source used when rendering the tile map. The type of the property is hash.
+       */
+      tile_source: Hash;
+    }
+  }
+}
+
+export {};

package/generated/render.d.ts

@@ -59,7 +59,7 @@ declare global {
        */
       sort_order?: render.SORT;
     }
-    type render_predicate = number;
+    type render_predicate = Opaque<"render_predicate">;
     type render_target = Opaque<"render_target">;
     /**
      * Render-target attachment parameters
@@ -102,7 +102,7 @@ declare global {
        */
       flags?: render.RENDER_TARGET_FLAG | number;
     }
-    type render_target_params = { type?: graphics.TEXTURE_TYPE; sample_count?: number } & { [key: number]: render.render_target_buffer_params };
+    type render_target_params = { type?: render.RenderTargetTextureType; sample_count?: number } & { [key: number]: render.render_target_buffer_params };
     /**
      * Render-target activation options
      */
@@ -118,6 +118,7 @@ declare global {
     }
     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 = render.render_target_params;
     type CONTEXT_EVENT = typeof render.CONTEXT_EVENT_CONTEXT_LOST | typeof render.CONTEXT_EVENT_CONTEXT_RESTORED;
     type FRUSTUM_PLANES = typeof render.FRUSTUM_PLANES_ALL | typeof render.FRUSTUM_PLANES_SIDES;
@@ -295,7 +296,7 @@ declare global {
      * });
      * ```
      */
-    function disable_state(state: graphics.STATE): void;
+    function disable_state(state: graphics.State): void;
     /**
      * Disables a texture that has previourly been enabled.
      *
@@ -330,7 +331,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
@@ -427,7 +428,56 @@ declare global {
      * }
      * ```
      */
-    function draw(predicate: Opaque<"render_predicate">, options?: render.draw_options): 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 draw options
+     * @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: render.draw_options): void;
     /**
      * Draws all 3d debug graphics such as lines drawn with "draw_line" messages and physics visualization.
      *
@@ -494,7 +544,7 @@ declare global {
      * });
      * ```
      */
-    function enable_state(state: graphics.STATE): void;
+    function enable_state(state: graphics.State): 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
@@ -791,7 +841,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
@@ -1047,7 +1097,83 @@ declare global {
      * });
      * ```
      */
-    function set_render_target(render_target?: Opaque<"render_target"> | string | Hash | typeof render.RENDER_TARGET_DEFAULT, options?: render.set_render_target_options): 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. Omit it, pass `nil`, or use render.RENDER_TARGET_DEFAULT to set the default render target
+     * @param options - optional render-target activation options
+     *
+     * `face`
+     * number Cubemap face selected for rendering. This option is valid only for cubemap render targets and defaults to `graphics.CUBEMAP_FACE_POSITIVE_X`.
+     *
+     * - `graphics.CUBEMAP_FACE_POSITIVE_X`
+     * - `graphics.CUBEMAP_FACE_NEGATIVE_X`
+     * - `graphics.CUBEMAP_FACE_POSITIVE_Y`
+     * - `graphics.CUBEMAP_FACE_NEGATIVE_Y`
+     * - `graphics.CUBEMAP_FACE_POSITIVE_Z`
+     * - `graphics.CUBEMAP_FACE_NEGATIVE_Z`
+     * @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: render.set_render_target_options): void;
     /**
      * Sets the render target size for a render target created from
      * either a render script, or from a render target resource.

package/generated/resource.d.ts

@@ -130,7 +130,7 @@ declare global {
       /**
        * Buffer to bind to the resource.
        */
-      buffer: Opaque<"buffer">;
+      buffer: Opaque<"buffer"> & { length: LuaLengthMethod<number> };
       /**
        * Whether the resource takes ownership of the buffer. The default is true.
        */
@@ -708,7 +708,7 @@ declare global {
      * });
      * ```
      */
-    function create_sound_data(path: string, options: resource.sound_data_options): Hash;
+    function create_sound_data(path: string, options: resource.sound_data_options & ({ partial?: false } | ({ partial: true } & Required<Pick<resource.sound_data_options, "filesize">>))): Hash;
     /**
      * Creates a new texture resource that can be used in the same way as any texture created during build time.
      * The path used for creating the texture must be unique, trying to create a resource at a path that is already
@@ -836,7 +836,7 @@ declare global {
      * }
      * ```
      */
-    function create_texture(path: string, table: resource.texture_creation_params, buffer?: Opaque<"buffer">): Hash;
+    function create_texture(path: string, table: resource.texture_creation_params, buffer?: Opaque<"buffer"> & { length: LuaLengthMethod<number> }): Hash;
     /**
      * Creates a new texture resource that can be used in the same way as any texture created during build time.
      * The path used for creating the texture must be unique, trying to create a resource at a path that is already
@@ -955,7 +955,7 @@ declare global {
      * });
      * ```
      */
-    function create_texture_async(path: string, table: resource.texture_creation_params, buffer: Opaque<"buffer"> | undefined, callback: (self: unknown, request_id: number, result: resource.texture_creation_result) => void): LuaMultiReturn<[Hash, number]>;
+    function create_texture_async(path: string, table: resource.texture_creation_params, buffer: Opaque<"buffer"> & { length: LuaLengthMethod<number> } | undefined, callback: (self: unknown, request_id: number, result: resource.texture_creation_result) => void): LuaMultiReturn<[Hash, number]>;
     /**
      * Constructor-like function with two purposes:
      *
@@ -1024,7 +1024,7 @@ declare global {
      * });
      * ```
      */
-    function get_buffer(path: Hash | string): Opaque<"buffer">;
+    function get_buffer(path: Hash | string): Opaque<"buffer"> & { length: LuaLengthMethod<number> };
     /**
      * Gets render target info from a render target resource path or a render target handle
      *
@@ -1080,7 +1080,28 @@ declare global {
      * });
      * ```
      */
-    function get_text_metrics(url: Hash | string, text: string, options?: resource.text_metrics_options): resource.text_metrics;
+    function get_text_metrics(url: Hash | string, text: string): resource.text_metrics;
+    /**
+     * Gets the text metrics from a font. Rich text markup is measured using its
+     * visible text and font sizes. If markup cannot be parsed, the text is measured literally.
+     * Inline sprites reserve their specified dimensions, or one em by default.
+     *
+     * @param url - the font to get the (unscaled) metrics from
+     * @param text - text to measure
+     * @param options - optional text-metric options
+     * @returns measured text metrics
+     * @example
+     * ```ts
+     * export default defineScript({
+     *   init() {
+     *     const font = go.get<label.properties>()("#label", "font");
+     *     const metrics = resource.get_text_metrics(font, "The quick brown fox\n jumps over the lazy dog");
+     *     pprint(metrics);
+     *   },
+     * });
+     * ```
+     */
+    function get_text_metrics(url: Hash | string, text: string, options: resource.text_metrics_options): resource.text_metrics;
     /**
      * Gets texture info from a texture resource path or a texture handle
      *
@@ -1155,7 +1176,7 @@ declare global {
      * // custom_resources = resources/,assets/level_data.json
      * ```
      */
-    function load(path: string): Opaque<"buffer">;
+    function load(path: string): Opaque<"buffer"> & { length: LuaLengthMethod<number> };
     /**
      * Constructor-like function with two purposes:
      *
@@ -1242,7 +1263,7 @@ declare global {
      * resource.set(go.get<sprite.properties>()("#sprite", "texture0"), buffer);
      * ```
      */
-    function set(path: string | Hash, buffer: Opaque<"buffer">): void;
+    function set(path: string | Hash, buffer: Opaque<"buffer"> & { length: LuaLengthMethod<number> }): void;
     /**
      * Sets the data for a specific atlas resource. Setting new atlas data is specified by passing in
      * a texture path for the backing texture of the atlas, a list of geometries and a list of animations
@@ -1371,7 +1392,7 @@ declare global {
      * });
      * ```
      */
-    function set_buffer(path: Hash | string, buffer: Opaque<"buffer">, table?: resource.buffer_update_options): void;
+    function set_buffer(path: Hash | string, buffer: Opaque<"buffer"> & { length: LuaLengthMethod<number> }, table?: resource.buffer_update_options): void;
     /**
      * Update internal sound resource (wavc/oggc/opusc) with new data
      *
@@ -1571,7 +1592,7 @@ declare global {
      * }
      * ```
      */
-    function set_texture(path: Hash | string, table: resource.texture_update_params, buffer: Opaque<"buffer">): void;
+    function set_texture(path: Hash | string, table: resource.texture_update_params, buffer: Opaque<"buffer"> & { length: LuaLengthMethod<number> }): void;
     /**
      * Constructor-like function with two purposes:
      *