@defold-typescript/types 0.19.4 → 0.20.0

package/generated/render.d.ts

@@ -3,15 +3,7 @@ import type { Hash, Matrix4, Opaque, Url, Vector4 } from "../src/core-types";
 
 declare global {
   /**
-   * Rendering functions, messages and constants. The "render" namespace is
-   * accessible only from render scripts.
-   *
-   * The rendering API was originally built on top of OpenGL ES 2.0, and it uses a subset of the
-   * OpenGL computer graphics rendering API for rendering 2D and 3D computer
-   * graphics. Our current target is OpenGLES 3.0 with fallbacks to 2.0 on some platforms.
-   *
-   * [icon:attention] It is possible to create materials and write shaders that
-   * require features not in OpenGL ES 2.0, but those will not work cross platform.
+   * Rendering API documentation
    */
   namespace render {
     type constant_buffer = Opaque<"constant_buffer">;
@@ -658,6 +650,17 @@ declare global {
      * ```
      */
     function render_target(name: string, parameters: Record<string | number, unknown>): Opaque<"render_target">;
+    /**
+     * Sets the blend equation with separate equations for the color and alpha channels.
+     *
+     * @param equation_color - color blend equation
+     * @param equation_alpha - alpha blend equation
+     * @example
+     * ```ts
+     * render.set_blend_equation_separate(graphics.BLEND_EQUATION_ADD, graphics.BLEND_EQUATION_REVERSE_SUBTRACT);
+     * ```
+     */
+    function set_blend_equation_separate(equation_color: number, equation_alpha: number): void;
     /**
      * Specifies the arithmetic used when computing pixel values that are written to the frame
      * buffer. In RGBA mode, pixels can be drawn using a function that blends the source RGBA
@@ -745,6 +748,19 @@ declare global {
      * ```
      */
     function set_blend_func(source_factor: number, destination_factor: number): void;
+    /**
+     * Sets the blend function with separate blend factors for the color and alpha channels.
+     *
+     * @param source_factor_color - source color blend factor
+     * @param destination_factor_color - destination color blend factor
+     * @param source_factor_alpha - source alpha blend factor
+     * @param destination_factor_alpha - destination alpha blend factor
+     * @example
+     * ```ts
+     * 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;
     /**
      * 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

package/generated/resource.d.ts

@@ -255,7 +255,7 @@ declare global {
      * -
      *
      * `transfer_ownership`
-     * boolean optional flag to determine wether or not the resource should take over ownership of the buffer object (default true)
+     * boolean optional flag to determine whether or not the resource should take over ownership of the buffer object (default true)
      * @returns Returns the buffer resource path
      * @example
      * ```ts
@@ -1224,7 +1224,7 @@ declare global {
      * -
      *
      * `transfer_ownership`
-     * boolean optional flag to determine wether or not the resource should take over ownership of the buffer object (default false)
+     * boolean optional flag to determine whether or not the resource should take over ownership of the buffer object (default false)
      * @example
      * ```ts
      * // How to set the data from a buffer

package/generated/sprite.d.ts

@@ -3,7 +3,7 @@ import type { Hash, Url, Vector3, Vector4 } from "../src/core-types";
 
 declare global {
   /**
-   * Functions, messages and properties used to manipulate sprite components.
+   * Sprite API documentation
    */
   namespace sprite {
     /**
@@ -53,6 +53,20 @@ declare global {
      * ```
      */
     function play_flipbook(url: string | Hash | Url, id: string | Hash, complete_function?: (self: unknown, message_id: unknown, message: unknown, sender: unknown) => void, play_properties?: { offset?: number; playback_rate?: number }): void;
+    /**
+     * Resets a shader constant for a sprite component.
+     * The constant must be defined in the material assigned to the sprite.
+     * Resetting a constant through this function implies that the value defined in the material will be used.
+     * Which sprite to reset a constant for is identified by the URL.
+     *
+     * @param url - the sprite that should have a constant reset
+     * @param constant - name of the constant
+     * @example
+     * ```ts
+     * sprite.reset_constant("#sprite", "tint");
+     * ```
+     */
+    function reset_constant(url: string | Hash | Url, constant: string | Hash): void;
     /**
      * Sets horizontal flipping of the provided sprite's animations.
      * The sprite is identified by its URL.

package/generated/tilemap.d.ts

@@ -110,6 +110,20 @@ declare global {
      * ```
      */
     function get_tiles(url: string | Hash | Url, layer: string | Hash): LuaMap<number, LuaMap<number, number>>;
+    /**
+     * Resets a shader constant for a tile map component.
+     * The constant must be defined in the material assigned to the tile map.
+     * Resetting a constant through this function implies that the value defined in the material will be used.
+     * Which tile map to reset a constant for is identified by the URL.
+     *
+     * @param url - the tile map that should have a constant reset
+     * @param constant - name of the constant
+     * @example
+     * ```ts
+     * tilemap.reset_constant("#tilemap", "tint");
+     * ```
+     */
+    function reset_constant(url: string | Hash | Url, constant: string | Hash): void;
     /**
      * Replace a tile in a tile map with a new tile.
      * The coordinates of the tiles are indexed so that the "first" tile just

package/generated/versions/defold-1.12.4/b2d.d.ts

@@ -0,0 +1,27 @@
+/** @noSelfInFile */
+import type { Hash, Opaque, Url } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for interacting with Box2D.
+   */
+  namespace b2d {
+    type b2Body = Opaque<"b2Body">;
+    type b2World = Opaque<"b2World">;
+    /**
+     * Get the Box2D body from a collision object
+     *
+     * @param url - the url to the game object collision component
+     * @returns the body if successful. Otherwise `nil`.
+     */
+    function get_body(url: string | Hash | Url): Opaque<"b2Body">;
+    /**
+     * Get the Box2D world from the current collection
+     *
+     * @returns the world if successful. Otherwise `nil`.
+     */
+    function get_world(): Opaque<"b2World">;
+  }
+}
+
+export {};

package/generated/versions/defold-1.12.4/b2d_body.d.ts

@@ -0,0 +1,348 @@
+/** @noSelfInFile */
+import type { Opaque, Vector3 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for interacting with Box2D bodies.
+   */
+  namespace b2d.body {
+    type b2Body = Opaque<"b2Body">;
+    type b2World = Opaque<"b2World">;
+    /**
+     * Dynamic body
+     */
+    const B2_DYNAMIC_BODY: number & { readonly __brand: "b2d.body.B2_DYNAMIC_BODY" };
+    /**
+     * Kinematic body
+     */
+    const B2_KINEMATIC_BODY: number & { readonly __brand: "b2d.body.B2_KINEMATIC_BODY" };
+    /**
+     * Static (immovable) body
+     */
+    const B2_STATIC_BODY: number & { readonly __brand: "b2d.body.B2_STATIC_BODY" };
+    /**
+     * Apply an angular impulse.
+     *
+     * @param body - body
+     * @param impulse - impulse the angular impulse in units of kg*m*m/s
+     */
+    function apply_angular_impulse(body: Opaque<"b2Body">, impulse: number): void;
+    /**
+     * Apply a force at a world point. If the force is not
+     * applied at the center of mass, it will generate a torque and
+     * affect the angular velocity. This wakes up the body.
+     *
+     * @param body - body
+     * @param force - the world force vector, usually in Newtons (N).
+     * @param point - the world position of the point of application.
+     */
+    function apply_force(body: Opaque<"b2Body">, force: Vector3, point: Vector3): void;
+    /**
+     * Apply a force to the center of mass. This wakes up the body.
+     *
+     * @param body - body
+     * @param force - the world force vector, usually in Newtons (N).
+     */
+    function apply_force_to_center(body: Opaque<"b2Body">, force: Vector3): void;
+    /**
+     * Apply an impulse at a point. This immediately modifies the velocity.
+     * It also modifies the angular velocity if the point of application
+     * is not at the center of mass. This wakes up the body.
+     *
+     * @param body - body
+     * @param impulse - the world impulse vector, usually in N-seconds or kg-m/s.
+     * @param point - the world position of the point of application.
+     */
+    function apply_linear_impulse(body: Opaque<"b2Body">, impulse: Vector3, point: Vector3): void;
+    /**
+     * Apply a torque. This affects the angular velocity
+     * without affecting the linear velocity of the center of mass.
+     * This wakes up the body.
+     *
+     * @param body - body
+     * @param torque - torque about the z-axis (out of the screen), usually in N-m.
+     */
+    function apply_torque(body: Opaque<"b2Body">, torque: number): void;
+    /**
+     * You can disable sleeping on this body. If you disable sleeping, the body will be woken.
+     *
+     * @param body - body
+     * @param enable - if false, the body will never sleep, and consume more CPU
+     */
+    function enable_sleep(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Get the angle in radians.
+     *
+     * @param body - body
+     * @returns the current world rotation angle in radians.
+     */
+    function get_angle(body: Opaque<"b2Body">): number;
+    /**
+     * Get the angular damping of the body.
+     *
+     * @param body - body
+     * @returns the damping
+     */
+    function get_angular_damping(body: Opaque<"b2Body">): number;
+    /**
+     * Get the angular velocity.
+     *
+     * @param body - body
+     * @returns the angular velocity in radians/second.
+     */
+    function get_angular_velocity(body: Opaque<"b2Body">): number;
+    /**
+     * Get the gravity scale of the body.
+     *
+     * @param body - body
+     * @returns the scale
+     */
+    function get_gravity_scale(body: Opaque<"b2Body">): number;
+    /**
+     * Get the linear damping of the body.
+     *
+     * @param body - body
+     * @returns the damping
+     */
+    function get_linear_damping(body: Opaque<"b2Body">): number;
+    /**
+     * Get the linear velocity of the center of mass.
+     *
+     * @param body - body
+     * @returns the linear velocity of the center of mass.
+     */
+    function get_linear_velocity(body: Opaque<"b2Body">): Vector3;
+    /**
+     * Get the world velocity of a local point.
+     *
+     * @param body - body
+     * @param local_point - a point in local coordinates.
+     * @returns the world velocity of a point.
+     */
+    function get_linear_velocity_from_local_point(body: Opaque<"b2Body">, local_point: Vector3): Vector3;
+    /**
+     * Get the world linear velocity of a world point attached to this body.
+     *
+     * @param body - body
+     * @param world_point - a point in world coordinates.
+     * @returns the world velocity of a point.
+     */
+    function get_linear_velocity_from_world_point(body: Opaque<"b2Body">, world_point: Vector3): Vector3;
+    /**
+     * Get the local position of the center of mass.
+     *
+     * @param body - body
+     * @returns Get the local position of the center of mass.
+     */
+    function get_local_center_of_mass(body: Opaque<"b2Body">): Vector3;
+    /**
+     * Gets a local point relative to the body's origin given a world point.
+     *
+     * @param body - body
+     * @param world_point - a point in world coordinates.
+     * @returns the corresponding local point relative to the body's origin.
+     */
+    function get_local_point(body: Opaque<"b2Body">, world_point: Vector3): Vector3;
+    /**
+     * Gets a local vector given a world vector.
+     *
+     * @param body - body
+     * @param world_vector - a vector in world coordinates.
+     * @returns the corresponding local vector.
+     */
+    function get_local_vector(body: Opaque<"b2Body">, world_vector: Vector3): Vector3;
+    /**
+     * Get the total mass of the body.
+     *
+     * @param body - body
+     * @returns the mass, usually in kilograms (kg).
+     */
+    function get_mass(body: Opaque<"b2Body">): number;
+    /**
+     * Get the world body origin position.
+     *
+     * @param body - body
+     * @returns the world position of the body's origin.
+     */
+    function get_position(body: Opaque<"b2Body">): Vector3;
+    /**
+     * Get the rotational inertia of the body about the local origin.
+     *
+     * @param body - body
+     * @returns the rotational inertia, usually in kg-m^2.
+     */
+    function get_rotational_inertia(body: Opaque<"b2Body">): number;
+    /**
+     * Get the type of this body.
+     *
+     * @param body - body
+     * @returns the body type
+     */
+    function get_type(body: Opaque<"b2Body">): (number & { readonly __brand: "b2d.body.B2_DYNAMIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_KINEMATIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_STATIC_BODY" });
+    /**
+     * Get the parent world of this body.
+     *
+     * @param body - body
+     */
+    function get_world(body: Opaque<"b2Body">): Opaque<"b2World">;
+    /**
+     * Get the world position of the center of mass.
+     *
+     * @param body - body
+     * @returns Get the world position of the center of mass.
+     */
+    function get_world_center_of_mass(body: Opaque<"b2Body">): Vector3;
+    /**
+     * Get the world coordinates of a point given the local coordinates.
+     *
+     * @param body - body
+     * @param local_vector - localPoint a point on the body measured relative the the body's origin.
+     * @returns the same point expressed in world coordinates.
+     */
+    function get_world_point(body: Opaque<"b2Body">, local_vector: Vector3): Vector3;
+    /**
+     * Get the world coordinates of a vector given the local coordinates.
+     *
+     * @param body - body
+     * @param local_vector - a vector fixed in the body.
+     * @returns the same vector expressed in world coordinates.
+     */
+    function get_world_vector(body: Opaque<"b2Body">, local_vector: Vector3): Vector3;
+    /**
+     * Get the active state of the body.
+     *
+     * @param body - body
+     * @returns is the body active
+     */
+    function is_active(body: Opaque<"b2Body">): boolean;
+    /**
+     * Get the sleeping state of this body.
+     *
+     * @param body - body
+     * @returns true if the body is awake, false if it's sleeping.
+     */
+    function is_awake(body: Opaque<"b2Body">): boolean;
+    /**
+     * Is this body in bullet mode
+     *
+     * @param body - body
+     * @returns true if the body is in bullet mode
+     */
+    function is_bullet(body: Opaque<"b2Body">): boolean;
+    /**
+     * Does this body have fixed rotation?
+     *
+     * @param body - body
+     * @returns is the rotation fixed
+     */
+    function is_fixed_rotation(body: Opaque<"b2Body">): boolean;
+    /**
+     * Is this body allowed to sleep
+     *
+     * @param body - body
+     * @returns true if the body is allowed to sleep
+     */
+    function is_sleeping_enabled(body: Opaque<"b2Body">): boolean;
+    /**
+     * This resets the mass properties to the sum of the mass properties of the fixtures.
+     * This normally does not need to be called unless you called SetMassData to override
+     *
+     * @param body - body
+     */
+    function reset_mass_data(body: Opaque<"b2Body">): void;
+    /**
+     * Set the active state of the body. An inactive body is not
+     * simulated and cannot be collided with or woken up.
+     * If you pass a flag of true, all fixtures will be added to the
+     * broad-phase.
+     * If you pass a flag of false, all fixtures will be removed from
+     * the broad-phase and all contacts will be destroyed.
+     * Fixtures and joints are otherwise unaffected. You may continue
+     * to create/destroy fixtures and joints on inactive bodies.
+     * Fixtures on an inactive body are implicitly inactive and will
+     * not participate in collisions, ray-casts, or queries.
+     * Joints connected to an inactive body are implicitly inactive.
+     * An inactive body is still owned by a b2World object and remains
+     * in the body list.
+     *
+     * @param body - body
+     * @param enable - true if the body should be active
+     */
+    function set_active(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Set the angular damping of the body.
+     *
+     * @param body - body
+     * @param damping - the damping
+     */
+    function set_angular_damping(body: Opaque<"b2Body">, damping: number): void;
+    /**
+     * Set the angular velocity.
+     *
+     * @param body - body
+     * @param omega - the new angular velocity in radians/second.
+     */
+    function set_angular_velocity(body: Opaque<"b2Body">, omega: number): void;
+    /**
+     * Set the sleep state of the body. A sleeping body has very low CPU cost.
+     *
+     * @param body - body
+     * @param enable - flag set to false to put body to sleep, true to wake it.
+     */
+    function set_awake(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Should this body be treated like a bullet for continuous collision detection?
+     *
+     * @param body - body
+     * @param enable - if true, the body will be in bullet mode
+     */
+    function set_bullet(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Set this body to have fixed rotation. This causes the mass to be reset.
+     *
+     * @param body - body
+     * @param enable - true if the rotation should be fixed
+     */
+    function set_fixed_rotation(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Set the gravity scale of the body.
+     *
+     * @param body - body
+     * @param scale - the scale
+     */
+    function set_gravity_scale(body: Opaque<"b2Body">, scale: number): void;
+    /**
+     * Set the linear damping of the body.
+     *
+     * @param body - body
+     * @param damping - the damping
+     */
+    function set_linear_damping(body: Opaque<"b2Body">, damping: number): void;
+    /**
+     * Set the linear velocity of the center of mass.
+     *
+     * @param body - body
+     * @param velocity - the new linear velocity of the center of mass.
+     */
+    function set_linear_velocity(body: Opaque<"b2Body">, velocity: Vector3): void;
+    /**
+     * Set the position of the body's origin and rotation.
+     * This breaks any contacts and wakes the other bodies.
+     * Manipulating a body's transform may cause non-physical behavior.
+     *
+     * @param body - body
+     * @param position - the world position of the body's local origin.
+     * @param angle - the world position of the body's local origin.
+     */
+    function set_transform(body: Opaque<"b2Body">, position: Vector3, angle: number): void;
+    /**
+     * Set the type of this body. This may alter the mass and velocity.
+     *
+     * @param body - body
+     * @param type - the body type
+     */
+    function set_type(body: Opaque<"b2Body">, type: (number & { readonly __brand: "b2d.body.B2_DYNAMIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_KINEMATIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_STATIC_BODY" })): void;
+  }
+}
+
+export {};

package/generated/versions/defold-1.12.4/buffer.d.ts

@@ -0,0 +1,176 @@
+/** @noSelfInFile */
+import type { Hash, Opaque } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for manipulating buffers and streams
+   */
+  namespace buffer {
+    /**
+     * Float, single precision, 4 bytes
+     */
+    const VALUE_TYPE_FLOAT32: number & { readonly __brand: "buffer.VALUE_TYPE_FLOAT32" };
+    /**
+     * Signed integer, 2 bytes
+     */
+    const VALUE_TYPE_INT16: number & { readonly __brand: "buffer.VALUE_TYPE_INT16" };
+    /**
+     * Signed integer, 4 bytes
+     */
+    const VALUE_TYPE_INT32: number & { readonly __brand: "buffer.VALUE_TYPE_INT32" };
+    /**
+     * Signed integer, 8 bytes
+     */
+    const VALUE_TYPE_INT64: number & { readonly __brand: "buffer.VALUE_TYPE_INT64" };
+    /**
+     * Signed integer, 1 byte
+     */
+    const VALUE_TYPE_INT8: number & { readonly __brand: "buffer.VALUE_TYPE_INT8" };
+    /**
+     * Unsigned integer, 2 bytes
+     */
+    const VALUE_TYPE_UINT16: number & { readonly __brand: "buffer.VALUE_TYPE_UINT16" };
+    /**
+     * Unsigned integer, 4 bytes
+     */
+    const VALUE_TYPE_UINT32: number & { readonly __brand: "buffer.VALUE_TYPE_UINT32" };
+    /**
+     * Unsigned integer, 8 bytes
+     */
+    const VALUE_TYPE_UINT64: number & { readonly __brand: "buffer.VALUE_TYPE_UINT64" };
+    /**
+     * Unsigned integer, 1 byte
+     */
+    const VALUE_TYPE_UINT8: number & { readonly __brand: "buffer.VALUE_TYPE_UINT8" };
+    /**
+     * Copy all data streams from one buffer to another, element wise.
+     * Each of the source streams must have a matching stream in the
+     * destination buffer. The streams must match in both type and size.
+     * The source and destination buffer can be the same.
+     *
+     * @param dst - the destination buffer
+     * @param dstoffset - the offset to start copying data to
+     * @param src - the source data buffer
+     * @param srcoffset - the offset to start copying data from
+     * @param count - the number of elements to copy
+     * @example
+     * ```ts
+     * // How to copy elements (e.g. vertices) from one buffer to another
+     * // copy entire buffer
+     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, 0, srcbuffer.length);
+     *
+     * // copy last 10 elements to the front of another buffer
+     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, srcbuffer.length - 10, 10);
+     * ```
+     */
+    function copy_buffer(dst: Opaque<"buffer">, dstoffset: number, src: Opaque<"buffer">, srcoffset: number, count: number): void;
+    /**
+     * Copy a specified amount of data from one stream to another.
+     * The value type and size must match between source and destination streams.
+     * The source and destination streams can be the same.
+     *
+     * @param dst - the destination stream
+     * @param dstoffset - the offset to start copying data to (measured in value type)
+     * @param src - the source data stream
+     * @param srcoffset - the offset to start copying data from (measured in value type)
+     * @param count - the number of values to copy (measured in value type)
+     * @example
+     * ```ts
+     * // How to update a texture of a sprite:
+     * // copy entire stream
+     * const srcstream = buffer.get_stream(srcbuffer, hash("xyz"));
+     * const dststream = buffer.get_stream(dstbuffer, hash("xyz"));
+     * buffer.copy_stream(dststream, 0, srcstream, 0, srcstream.length);
+     * ```
+     */
+    function copy_stream(dst: Opaque<"bufferstream"> & { [index: number]: number }, dstoffset: number, src: Opaque<"bufferstream"> & { [index: number]: number }, srcoffset: number, count: number): void;
+    /**
+     * Create a new data buffer containing a specified set of streams. A data buffer
+     * can contain one or more streams with typed data. This is useful for managing
+     * compound data, for instance a vertex buffer could contain separate streams for
+     * vertex position, color, normal etc.
+     *
+     * @param element_count - The number of elements the buffer should hold
+     * @param declaration - A table where each entry (table) describes a stream
+     *
+     * - hash | string `name`: The name of the stream
+     *
+     * - constant `type`: The data type of the stream
+     *
+     * - number `count`: The number of values each element should hold
+     * @returns the new buffer
+     * @example
+     * ```ts
+     * // How to create and initialize a buffer
+     * export default defineScript({
+     *   init(self) {
+     *     const size = 128;
+     *     self.image = buffer.create(size * size, [{ name: hash("rgb"), type: buffer.VALUE_TYPE_UINT8, count: 3 }]);
+     *     self.imagestream = buffer.get_stream(self.image, hash("rgb"));
+     *
+     *     for (let y = 0; y < self.height; y++) {
+     *       for (let x = 0; x < self.width; x++) {
+     *         const index = y * self.width * 3 + x * 3;
+     *         self.imagestream[index + 0] = self.r;
+     *         self.imagestream[index + 1] = self.g;
+     *         self.imagestream[index + 2] = self.b;
+     *       }
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function create(element_count: number, declaration: { name?: Hash | string; type?: Opaque<"constant">; count?: number }): Opaque<"buffer">;
+    /**
+     * Get a copy of all the bytes from a specified stream as a Lua string.
+     *
+     * @param buffer - the source buffer
+     * @param stream_name - the name of the stream
+     * @returns the buffer data as a Lua string
+     */
+    function get_bytes(buffer: Opaque<"buffer">, stream_name: Hash): string;
+    /**
+     * Get a named metadata entry from a buffer along with its type.
+     *
+     * @param buf - the buffer to get the metadata from
+     * @param metadata_name - name of the metadata entry
+     * @example
+     * ```ts
+     * // How to get a metadata entry from a buffer
+     * // retrieve a metadata entry named "somefloats" and its numeric type
+     * const [values, type] = buffer.get_metadata(buf, hash("somefloats"));
+     * if (values) print(`${values.length} values in 'somefloats'`);
+     * ```
+     */
+    function get_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string): LuaMultiReturn<[number[] | unknown, Opaque<"constant"> | unknown]>;
+    /**
+     * Get a specified stream from a buffer.
+     *
+     * @param buffer - the buffer to get the stream from
+     * @param stream_name - the stream name
+     * @returns the data stream
+     */
+    function get_stream(buffer: Opaque<"buffer">, stream_name: Hash | string): Opaque<"bufferstream"> & { [index: number]: number };
+    /**
+     * Creates or updates a metadata array entry on a buffer.
+     * The value type and count given when updating the entry should match those used when first creating it.
+     *
+     * @param buf - the buffer to set the metadata on
+     * @param metadata_name - name of the metadata entry
+     * @param values - actual metadata, an array of numeric values
+     * @param value_type - type of values when stored
+     * @example
+     * ```ts
+     * // How to set a metadata entry on a buffer
+     * // create a new metadata entry with three floats
+     * buffer.set_metadata(buf, hash("somefloats"), [1.5, 3.2, 7.9], buffer.VALUE_TYPE_FLOAT32);
+     * // ...
+     * // update to a new set of values
+     * buffer.set_metadata(buf, hash("somefloats"), [-2.5, 10.0, 32.2], buffer.VALUE_TYPE_FLOAT32);
+     * ```
+     */
+    function set_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string, values: number[], value_type: Opaque<"constant">): void;
+  }
+}
+
+export {};