@navaramap/engine-worker 0.2.1 → 0.3.0

package/navara_wasm_worker.js

@@ -145,10 +145,25 @@ export class BillboardMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Whether faces seen from behind are culled. Default is false, so a
-     * quad frozen in its anchor's frame (`rotateWithCamera: false`) stays
-     * visible from behind. Turn it on to hide a flat quad's parts that wrap
-     * over the horizon, which face away from the camera.
+     * Part of the quad placed at the anchor point: `"center"` (default),
+     * `"left"`, `"right"`, `"top"`, `"bottom"`, `"top-left"`, `"top-right"`,
+     * `"bottom-left"` or `"bottom-right"`, as MapLibre's `icon-anchor`.
+     * @returns {string | undefined}
+     */
+    get anchor() {
+        const ret = wasm.__wbg_get_billboardmaterial_anchor(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Whether faces seen from behind are culled. Default is false. Only a
+     * flat quad has a back the camera can see: turn it on to hide the parts
+     * of a large one that wrap over the horizon, which face away from the
+     * camera.
      * @returns {boolean | undefined}
      */
     get backfaceCulling() {
@@ -156,9 +171,12 @@ export class BillboardMaterial {
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
     /**
-     * Whether the sprite stands up (`"upright"`, the default) or lies on the
-     * globe surface around its anchor (`"flat"`). Pair with
-     * `rotateWithCamera`.
+     * Plane the sprite lies in: the screen (`"upright"`, never foreshortened)
+     * or the globe surface around its anchor (`"flat"`), as MapLibre's
+     * `icon-pitch-alignment` `viewport` and `map`. Pair with
+     * `rotateWithCamera`. Left unset, it is `"flat"` when `rotateWithCamera`
+     * resolves to `false` and `"upright"` otherwise, as MapLibre resolves
+     * `auto`.
      * @returns {string | undefined}
      */
     get billboardFacing() {
@@ -170,15 +188,6 @@ export class BillboardMaterial {
         }
         return v1;
     }
-    /**
-     * anchor point of the sprite, range is (-0.5, -0.5) to (0.5, 0.5).
-     * Default is (0.0, 0.0) which means the center of the sprite.
-     * @returns {Vec2 | undefined}
-     */
-    get center() {
-        const ret = wasm.__wbg_get_billboardmaterial_center(this.__wbg_ptr);
-        return ret === 0 ? undefined : Vec2.__wrap(ret);
-    }
     /**
      * @returns {boolean | undefined}
      */
@@ -193,6 +202,21 @@ export class BillboardMaterial {
         const ret = wasm.__wbg_get_billboardmaterial_color(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Extra space around the collision box, in screen pixels: one to four
+     * values, expanded like CSS padding (top, right, bottom, left). Only
+     * meaningful when `declutter` is enabled. Defaults to `[2]`.
+     * @returns {Float32Array | undefined}
+     */
+    get declutterPadding() {
+        const ret = wasm.__wbg_get_billboardmaterial_declutterPadding(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
     /**
      * Placement priority for decluttering; higher wins. Only meaningful when
      * `declutter` is enabled. Defaults to `0.0`.
@@ -202,6 +226,17 @@ export class BillboardMaterial {
         const ret = wasm.__wbg_get_billboardmaterial_declutterPriority(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Coarse placement order for decluttering, compared before
+     * `declutterPriority`: every label with a higher rank is placed before any
+     * label with a lower one, whatever their priorities. Only meaningful when
+     * `declutter` is enabled. Defaults to `0.0`.
+     * @returns {number | undefined}
+     */
+    get declutterRank() {
+        const ret = wasm.__wbg_get_billboardmaterial_declutterRank(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * Participate in screen-space decluttering: when labels/sprites overlap
      * on screen, lower-priority ones are hidden. Defaults to `true`; set to
@@ -250,8 +285,9 @@ export class BillboardMaterial {
     }
     /**
      * Source geometry types this appearance consumes: `"point"`, `"line"`,
-     * `"polygon"`. Defaults to `["point"]`; adding `"line"`/`"polygon"` also
-     * emits a billboard per line-string / polygon-ring vertex.
+     * `"polygon"`. Defaults to `["point"]`; adding `"line"` also emits a
+     * billboard per line string, at its first vertex, and `"polygon"` one per
+     * polygon.
      * @returns {string[] | undefined}
      */
     get geometryTypes() {
@@ -270,6 +306,16 @@ export class BillboardMaterial {
         const ret = wasm.__wbg_get_billboardmaterial_height(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Leave this label's box out of the collision grid, so symbols placed
+     * after it may overlap it. Only meaningful when `declutter` is enabled.
+     * Defaults to `false`.
+     * @returns {boolean | undefined}
+     */
+    get ignorePlacement() {
+        const ret = wasm.__wbg_get_billboardmaterial_ignorePlacement(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
     /**
      * Avoid overlapping with the globe surface.
      * @returns {boolean | undefined}
@@ -278,6 +324,16 @@ export class BillboardMaterial {
         const ret = wasm.__wbg_get_billboardmaterial_offsetDepth(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
+    /**
+     * Shift from the anchor point, x right and y down, in the unit of `size`
+     * (meters when `sizeInMeters`, pixels otherwise). Lies in the quad's own
+     * plane, so it turns with `rotation`. Defaults to `(0, 0)`.
+     * @returns {Vec2 | undefined}
+     */
+    get offset() {
+        const ret = wasm.__wbg_get_billboardmaterial_offset(this.__wbg_ptr);
+        return ret === 0 ? undefined : Vec2.__wrap(ret);
+    }
     /**
      * @returns {number | undefined}
      */
@@ -286,9 +342,56 @@ export class BillboardMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Whether the sprite turns to follow the camera. `true` (the default)
-     * keeps it facing the viewer. `false` freezes it in the anchor's local
-     * east-north-up frame, so moving the camera never reorients it.
+     * Whether the label may be drawn over symbols placed before it:
+     * `"never"` (the default) hides it on any collision, `"always"` never
+     * does, `"cooperative"` hides it only when it collides with a `"never"`
+     * symbol. Only meaningful when `declutter` is enabled.
+     * @returns {string | undefined}
+     */
+    get overlap() {
+        const ret = wasm.__wbg_get_billboardmaterial_overlap(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * How anchors are derived from line and polygon geometry: `"point"` (the
+     * default) puts one per line string, at its first vertex, and one per
+     * polygon, `"line"` repeats them along the line every `spacing`,
+     * `"line-center"` places a single one at the line's midpoint. Polygon
+     * rings are walked like lines. Requires `geometryTypes` to include
+     * `"line"` or `"polygon"`.
+     * @returns {string | undefined}
+     */
+    get placement() {
+        const ret = wasm.__wbg_get_billboardmaterial_placement(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Add the line's tangent bearing at the anchor to `rotation`, so the
+     * sprite turns with the line it sits on. Defaults to `true`.
+     * @returns {boolean | undefined}
+     */
+    get rotateToLine() {
+        const ret = wasm.__wbg_get_billboardmaterial_rotateToLine(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * Whether the sprite turns with the camera or with the map, as MapLibre's
+     * `icon-rotation-alignment` `viewport` and `map`. `true` keeps it reading left to right
+     * (a screen-aligned billboard, or a flat quad yawed to the camera).
+     * `false` aligns it with the map: upright, it stays on screen but turns
+     * with the camera heading so its x-axis points east; flat, it lies
+     * north-up. Left unset, it is `true` for `placement: "point"` and `false`
+     * along a line, as MapLibre resolves `auto`.
      * @returns {boolean | undefined}
      */
     get rotateWithCamera() {
@@ -297,7 +400,7 @@ export class BillboardMaterial {
     }
     /**
      * Rotation of the sprite within its own plane, about its anchor point,
-     * in degrees, clockwise seen from the front. `center` decides where
+     * in degrees, clockwise seen from the front. `anchor` decides where
      * inside the sprite the pivot sits. Defaults to `0.0`.
      * @returns {number | undefined}
      */
@@ -320,6 +423,17 @@ export class BillboardMaterial {
         const ret = wasm.__wbg_get_billboardmaterial_sizeInMeters(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
+    /**
+     * Whether `size` scales the image's own pixel height instead of being the
+     * quad's height, like MapLibre's `icon-size`: `1` draws the image at its
+     * natural size. `offset` keeps the unit `sizeInMeters` gives it. Default
+     * is false.
+     * @returns {boolean | undefined}
+     */
+    get sizeRelativeToImage() {
+        const ret = wasm.__wbg_get_billboardmaterial_sizeRelativeToImage(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
     /**
      * size in pixels/meters (units are determined by `sizeInMeters`).
      * @returns {number | undefined}
@@ -328,6 +442,59 @@ export class BillboardMaterial {
         const ret = wasm.__wbg_get_billboardmaterial_size(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Distance between repeated anchors along a line, in screen pixels, for
+     * `vector-tile` and `geojson` sources alike. Resolved per anchor as the
+     * camera moves: anchors thin out as it pulls back and fill in as it
+     * closes, never moving, so the gap on screen stays between one and two
+     * times `spacing` across a pitched view. As MapLibre does with
+     * `symbol-spacing`, a sprite wider than three quarters of the spacing
+     * spreads its repeats to its width plus a quarter of the spacing, and a
+     * vector tile places anchors only inside its own bounds. Only used by
+     * `placement: "line"`. Defaults to `250.0`.
+     * @returns {number | undefined}
+     */
+    get spacing() {
+        const ret = wasm.__wbg_get_billboardmaterial_spacing(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * Whether this may show while its partner at the same anchor (the
+     * layer's label for a billboard, its billboard for a label) is hidden.
+     * With `false` on both, the two are placed together: both show or
+     * neither does. Only meaningful when `declutter` is enabled. Defaults to
+     * `true`.
+     * @returns {boolean | undefined}
+     */
+    get standalone() {
+        const ret = wasm.__wbg_get_billboardmaterial_standalone(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * Frame `translate` is measured in: `"map"` (default) turns it with the
+     * camera heading so +x points east and +y south; `"viewport"` keeps it on
+     * the screen axes. MapLibre's `icon-translate-anchor`.
+     * @returns {string | undefined}
+     */
+    get translateAnchor() {
+        const ret = wasm.__wbg_get_billboardmaterial_translateAnchor(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Screen-pixel shift of the drawn quad, x right and y down, applied after
+     * projection so it stays the same number of pixels at any distance, as
+     * MapLibre's `icon-translate`. Defaults to `(0, 0)`.
+     * @returns {Vec2 | undefined}
+     */
+    get translate() {
+        const ret = wasm.__wbg_get_billboardmaterial_translate(this.__wbg_ptr);
+        return ret === 0 ? undefined : Vec2.__wrap(ret);
+    }
     /**
      * @returns {boolean | undefined}
      */
@@ -354,19 +521,33 @@ export class BillboardMaterial {
         wasm.__wbg_set_billboardmaterial_alphaTest(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
     /**
-     * Whether faces seen from behind are culled. Default is false, so a
-     * quad frozen in its anchor's frame (`rotateWithCamera: false`) stays
-     * visible from behind. Turn it on to hide a flat quad's parts that wrap
-     * over the horizon, which face away from the camera.
+     * Part of the quad placed at the anchor point: `"center"` (default),
+     * `"left"`, `"right"`, `"top"`, `"bottom"`, `"top-left"`, `"top-right"`,
+     * `"bottom-left"` or `"bottom-right"`, as MapLibre's `icon-anchor`.
+     * @param {string | null} [arg0]
+     */
+    set anchor(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_billboardmaterial_anchor(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Whether faces seen from behind are culled. Default is false. Only a
+     * flat quad has a back the camera can see: turn it on to hide the parts
+     * of a large one that wrap over the horizon, which face away from the
+     * camera.
      * @param {boolean | null} [arg0]
      */
     set backfaceCulling(arg0) {
         wasm.__wbg_set_billboardmaterial_backfaceCulling(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
     /**
-     * Whether the sprite stands up (`"upright"`, the default) or lies on the
-     * globe surface around its anchor (`"flat"`). Pair with
-     * `rotateWithCamera`.
+     * Plane the sprite lies in: the screen (`"upright"`, never foreshortened)
+     * or the globe surface around its anchor (`"flat"`), as MapLibre's
+     * `icon-pitch-alignment` `viewport` and `map`. Pair with
+     * `rotateWithCamera`. Left unset, it is `"flat"` when `rotateWithCamera`
+     * resolves to `false` and `"upright"` otherwise, as MapLibre resolves
+     * `auto`.
      * @param {string | null} [arg0]
      */
     set billboardFacing(arg0) {
@@ -374,19 +555,6 @@ export class BillboardMaterial {
         var len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_billboardmaterial_billboardFacing(this.__wbg_ptr, ptr0, len0);
     }
-    /**
-     * anchor point of the sprite, range is (-0.5, -0.5) to (0.5, 0.5).
-     * Default is (0.0, 0.0) which means the center of the sprite.
-     * @param {Vec2 | null} [arg0]
-     */
-    set center(arg0) {
-        let ptr0 = 0;
-        if (!isLikeNone(arg0)) {
-            _assertClass(arg0, Vec2);
-            ptr0 = arg0.__destroy_into_raw();
-        }
-        wasm.__wbg_set_billboardmaterial_center(this.__wbg_ptr, ptr0);
-    }
     /**
      * @param {boolean | null} [arg0]
      */
@@ -399,6 +567,17 @@ export class BillboardMaterial {
     set color(arg0) {
         wasm.__wbg_set_billboardmaterial_color(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >>> 0);
     }
+    /**
+     * Extra space around the collision box, in screen pixels: one to four
+     * values, expanded like CSS padding (top, right, bottom, left). Only
+     * meaningful when `declutter` is enabled. Defaults to `[2]`.
+     * @param {Float32Array | null} [arg0]
+     */
+    set declutterPadding(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passArrayF32ToWasm0(arg0, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_billboardmaterial_declutterPadding(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * Placement priority for decluttering; higher wins. Only meaningful when
      * `declutter` is enabled. Defaults to `0.0`.
@@ -407,6 +586,16 @@ export class BillboardMaterial {
     set declutterPriority(arg0) {
         wasm.__wbg_set_billboardmaterial_declutterPriority(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Coarse placement order for decluttering, compared before
+     * `declutterPriority`: every label with a higher rank is placed before any
+     * label with a lower one, whatever their priorities. Only meaningful when
+     * `declutter` is enabled. Defaults to `0.0`.
+     * @param {number | null} [arg0]
+     */
+    set declutterRank(arg0) {
+        wasm.__wbg_set_billboardmaterial_declutterRank(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
     /**
      * Participate in screen-space decluttering: when labels/sprites overlap
      * on screen, lower-priority ones are hidden. Defaults to `true`; set to
@@ -447,8 +636,9 @@ export class BillboardMaterial {
     }
     /**
      * Source geometry types this appearance consumes: `"point"`, `"line"`,
-     * `"polygon"`. Defaults to `["point"]`; adding `"line"`/`"polygon"` also
-     * emits a billboard per line-string / polygon-ring vertex.
+     * `"polygon"`. Defaults to `["point"]`; adding `"line"` also emits a
+     * billboard per line string, at its first vertex, and `"polygon"` one per
+     * polygon.
      * @param {string[] | null} [arg0]
      */
     set geometryTypes(arg0) {
@@ -462,6 +652,15 @@ export class BillboardMaterial {
     set height(arg0) {
         wasm.__wbg_set_billboardmaterial_height(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Leave this label's box out of the collision grid, so symbols placed
+     * after it may overlap it. Only meaningful when `declutter` is enabled.
+     * Defaults to `false`.
+     * @param {boolean | null} [arg0]
+     */
+    set ignorePlacement(arg0) {
+        wasm.__wbg_set_billboardmaterial_ignorePlacement(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
     /**
      * Avoid overlapping with the globe surface.
      * @param {boolean | null} [arg0]
@@ -469,6 +668,20 @@ export class BillboardMaterial {
     set offsetDepth(arg0) {
         wasm.__wbg_set_billboardmaterial_offsetDepth(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
+    /**
+     * Shift from the anchor point, x right and y down, in the unit of `size`
+     * (meters when `sizeInMeters`, pixels otherwise). Lies in the quad's own
+     * plane, so it turns with `rotation`. Defaults to `(0, 0)`.
+     * @param {Vec2 | null} [arg0]
+     */
+    set offset(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Vec2);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_billboardmaterial_offset(this.__wbg_ptr, ptr0);
+    }
     /**
      * @param {number | null} [arg0]
      */
@@ -476,9 +689,47 @@ export class BillboardMaterial {
         wasm.__wbg_set_billboardmaterial_opacity(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
     /**
-     * Whether the sprite turns to follow the camera. `true` (the default)
-     * keeps it facing the viewer. `false` freezes it in the anchor's local
-     * east-north-up frame, so moving the camera never reorients it.
+     * Whether the label may be drawn over symbols placed before it:
+     * `"never"` (the default) hides it on any collision, `"always"` never
+     * does, `"cooperative"` hides it only when it collides with a `"never"`
+     * symbol. Only meaningful when `declutter` is enabled.
+     * @param {string | null} [arg0]
+     */
+    set overlap(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_billboardmaterial_overlap(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * How anchors are derived from line and polygon geometry: `"point"` (the
+     * default) puts one per line string, at its first vertex, and one per
+     * polygon, `"line"` repeats them along the line every `spacing`,
+     * `"line-center"` places a single one at the line's midpoint. Polygon
+     * rings are walked like lines. Requires `geometryTypes` to include
+     * `"line"` or `"polygon"`.
+     * @param {string | null} [arg0]
+     */
+    set placement(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_billboardmaterial_placement(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Add the line's tangent bearing at the anchor to `rotation`, so the
+     * sprite turns with the line it sits on. Defaults to `true`.
+     * @param {boolean | null} [arg0]
+     */
+    set rotateToLine(arg0) {
+        wasm.__wbg_set_billboardmaterial_rotateToLine(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
+    /**
+     * Whether the sprite turns with the camera or with the map, as MapLibre's
+     * `icon-rotation-alignment` `viewport` and `map`. `true` keeps it reading left to right
+     * (a screen-aligned billboard, or a flat quad yawed to the camera).
+     * `false` aligns it with the map: upright, it stays on screen but turns
+     * with the camera heading so its x-axis points east; flat, it lies
+     * north-up. Left unset, it is `true` for `placement: "point"` and `false`
+     * along a line, as MapLibre resolves `auto`.
      * @param {boolean | null} [arg0]
      */
     set rotateWithCamera(arg0) {
@@ -486,7 +737,7 @@ export class BillboardMaterial {
     }
     /**
      * Rotation of the sprite within its own plane, about its anchor point,
-     * in degrees, clockwise seen from the front. `center` decides where
+     * in degrees, clockwise seen from the front. `anchor` decides where
      * inside the sprite the pivot sits. Defaults to `0.0`.
      * @param {number | null} [arg0]
      */
@@ -506,6 +757,16 @@ export class BillboardMaterial {
     set sizeInMeters(arg0) {
         wasm.__wbg_set_billboardmaterial_sizeInMeters(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
+    /**
+     * Whether `size` scales the image's own pixel height instead of being the
+     * quad's height, like MapLibre's `icon-size`: `1` draws the image at its
+     * natural size. `offset` keeps the unit `sizeInMeters` gives it. Default
+     * is false.
+     * @param {boolean | null} [arg0]
+     */
+    set sizeRelativeToImage(arg0) {
+        wasm.__wbg_set_billboardmaterial_sizeRelativeToImage(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
     /**
      * size in pixels/meters (units are determined by `sizeInMeters`).
      * @param {number | null} [arg0]
@@ -513,6 +774,57 @@ export class BillboardMaterial {
     set size(arg0) {
         wasm.__wbg_set_billboardmaterial_size(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Distance between repeated anchors along a line, in screen pixels, for
+     * `vector-tile` and `geojson` sources alike. Resolved per anchor as the
+     * camera moves: anchors thin out as it pulls back and fill in as it
+     * closes, never moving, so the gap on screen stays between one and two
+     * times `spacing` across a pitched view. As MapLibre does with
+     * `symbol-spacing`, a sprite wider than three quarters of the spacing
+     * spreads its repeats to its width plus a quarter of the spacing, and a
+     * vector tile places anchors only inside its own bounds. Only used by
+     * `placement: "line"`. Defaults to `250.0`.
+     * @param {number | null} [arg0]
+     */
+    set spacing(arg0) {
+        wasm.__wbg_set_billboardmaterial_spacing(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
+    /**
+     * Whether this may show while its partner at the same anchor (the
+     * layer's label for a billboard, its billboard for a label) is hidden.
+     * With `false` on both, the two are placed together: both show or
+     * neither does. Only meaningful when `declutter` is enabled. Defaults to
+     * `true`.
+     * @param {boolean | null} [arg0]
+     */
+    set standalone(arg0) {
+        wasm.__wbg_set_billboardmaterial_standalone(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
+    /**
+     * Frame `translate` is measured in: `"map"` (default) turns it with the
+     * camera heading so +x points east and +y south; `"viewport"` keeps it on
+     * the screen axes. MapLibre's `icon-translate-anchor`.
+     * @param {string | null} [arg0]
+     */
+    set translateAnchor(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_billboardmaterial_translateAnchor(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Screen-pixel shift of the drawn quad, x right and y down, applied after
+     * projection so it stays the same number of pixels at any distance, as
+     * MapLibre's `icon-translate`. Defaults to `(0, 0)`.
+     * @param {Vec2 | null} [arg0]
+     */
+    set translate(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Vec2);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_billboardmaterial_translate(this.__wbg_ptr, ptr0);
+    }
     /**
      * @param {boolean | null} [arg0]
      */
@@ -1226,6 +1538,7 @@ export class CompiledExpression {
      * * `properties_json` - Feature properties as JSON object
      * * `zoom` - Current zoom level
      * * `geometry_type` - Optional geometry type string (e.g., "Point", "Polygon")
+     * * `elevation` - Optional terrain elevation in meters for `["elevation"]`
      *
      * # Returns
      * Evaluated value as JsValue. Supported types:
@@ -1238,12 +1551,13 @@ export class CompiledExpression {
      * @param {any} properties_json
      * @param {number} zoom
      * @param {string | null} [geometry_type]
+     * @param {number | null} [elevation]
      * @returns {any}
      */
-    evaluate(properties_json, zoom, geometry_type) {
+    evaluate(properties_json, zoom, geometry_type, elevation) {
         var ptr0 = isLikeNone(geometry_type) ? 0 : passStringToWasm0(geometry_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.compiledexpression_evaluate(this.__wbg_ptr, properties_json, zoom, ptr0, len0);
+        const ret = wasm.compiledexpression_evaluate(this.__wbg_ptr, properties_json, zoom, ptr0, len0, !isLikeNone(elevation), isLikeNone(elevation) ? 0 : elevation);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -1681,15 +1995,15 @@ export class ConstructedPolylineGeometry {
     /**
      * @returns {Float32Array | undefined}
      */
-    end_normal_and_texture_coordinate_normalization_x() {
-        const ret = wasm.constructedpolylinegeometry_end_normal_and_texture_coordinate_normalization_x(this.__wbg_ptr);
+    end_normal_and_segment_length() {
+        const ret = wasm.constructedpolylinegeometry_end_normal_and_segment_length(this.__wbg_ptr);
         return ret;
     }
     /**
      * @returns {number | undefined}
      */
-    end_normal_and_texture_coordinate_normalization_x_size() {
-        const ret = wasm.constructedpolylinegeometry_end_normal_and_texture_coordinate_normalization_x_size(this.__wbg_ptr);
+    end_normal_and_segment_length_size() {
+        const ret = wasm.constructedpolylinegeometry_end_normal_and_segment_length_size(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret;
     }
     /**
@@ -1720,6 +2034,20 @@ export class ConstructedPolylineGeometry {
         const ret = wasm.constructedpolylinegeometry_indices(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @returns {Float32Array | undefined}
+     */
+    line_distance_and_ends() {
+        const ret = wasm.constructedpolylinegeometry_line_distance_and_ends(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Float32Array | undefined}
+     */
+    line_segments() {
+        const ret = wasm.constructedpolylinegeometry_line_segments(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {Float32Array}
      */
@@ -1765,15 +2093,15 @@ export class ConstructedPolylineGeometry {
     /**
      * @returns {Float32Array}
      */
-    right_normal_and_texture_coordinate_normalization_y() {
-        const ret = wasm.constructedpolylinegeometry_right_normal_and_texture_coordinate_normalization_y(this.__wbg_ptr);
+    right_normal_and_line_length() {
+        const ret = wasm.constructedpolylinegeometry_right_normal_and_line_length(this.__wbg_ptr);
         return ret;
     }
     /**
      * @returns {number}
      */
-    right_normal_and_texture_coordinate_normalization_y_size() {
-        const ret = wasm.constructedpolylinegeometry_right_normal_and_texture_coordinate_normalization_y_size(this.__wbg_ptr);
+    right_normal_and_line_length_size() {
+        const ret = wasm.constructedpolylinegeometry_right_normal_and_line_length_size(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -1814,15 +2142,15 @@ export class ConstructedPolylineGeometry {
     /**
      * @returns {Float32Array | undefined}
      */
-    start_normals() {
-        const ret = wasm.constructedpolylinegeometry_start_normals(this.__wbg_ptr);
+    start_normal_and_length_high() {
+        const ret = wasm.constructedpolylinegeometry_start_normal_and_length_high(this.__wbg_ptr);
         return ret;
     }
     /**
      * @returns {number | undefined}
      */
-    start_normals_size() {
-        const ret = wasm.constructedpolylinegeometry_start_normals_size(this.__wbg_ptr);
+    start_normal_and_length_high_size() {
+        const ret = wasm.constructedpolylinegeometry_start_normal_and_length_high_size(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret;
     }
     /**
@@ -2077,6 +2405,52 @@ export class ElevationHeatmapMaterial {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_elevationheatmapmaterial_free(ptr, 0);
     }
+    /**
+     * Color map lookup table for this layer's elevation heatmap rendering.
+     * Flattened RGBA array: [r0,g0,b0,a0, r1,g1,b1,a1, ...], evenly spaced over
+     * [minHeight, maxHeight]. When None, the elevation renders as grayscale.
+     * Managed on the web side (ColorMapAtlas); Rust only hashes it to detect
+     * changes.
+     * @returns {Float32Array | undefined}
+     */
+    get colorMap() {
+        const ret = wasm.__wbg_get_elevationheatmapmaterial_colorMap(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
+    /**
+     * Optional ascending stop elevations in meters, one per colorMap entry.
+     * When set, colorMap entry i is placed at elevation colorStops[i] instead
+     * of being evenly spaced over [minHeight, maxHeight].
+     * Managed on the web side (ColorMapAtlas); Rust only hashes it to detect
+     * changes.
+     * @returns {Float32Array | undefined}
+     */
+    get colorStops() {
+        const ret = wasm.__wbg_get_elevationheatmapmaterial_colorStops(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get filter() {
+        const ret = wasm.__wbg_get_elevationheatmapmaterial_filter(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
     /**
      * @returns {number | undefined}
      */
@@ -2105,6 +2479,40 @@ export class ElevationHeatmapMaterial {
         const ret = wasm.__wbg_get_elevationheatmapmaterial_minHeight(this.__wbg_ptr);
         return ret[0] === 0 ? undefined : ret[1];
     }
+    /**
+     * Color map lookup table for this layer's elevation heatmap rendering.
+     * Flattened RGBA array: [r0,g0,b0,a0, r1,g1,b1,a1, ...], evenly spaced over
+     * [minHeight, maxHeight]. When None, the elevation renders as grayscale.
+     * Managed on the web side (ColorMapAtlas); Rust only hashes it to detect
+     * changes.
+     * @param {Float32Array | null} [arg0]
+     */
+    set colorMap(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passArrayF32ToWasm0(arg0, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_elevationheatmapmaterial_colorMap(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Optional ascending stop elevations in meters, one per colorMap entry.
+     * When set, colorMap entry i is placed at elevation colorStops[i] instead
+     * of being evenly spaced over [minHeight, maxHeight].
+     * Managed on the web side (ColorMapAtlas); Rust only hashes it to detect
+     * changes.
+     * @param {Float32Array | null} [arg0]
+     */
+    set colorStops(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passArrayF32ToWasm0(arg0, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_elevationheatmapmaterial_colorStops(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string | null} [arg0]
+     */
+    set filter(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_elevationheatmapmaterial_filter(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * @param {number | null} [arg0]
      */
@@ -2512,6 +2920,13 @@ export class Geometry {
         const ret = wasm.geometry_transferNormals(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @returns {Float32Array | undefined}
+     */
+    transferSkirtHeights() {
+        const ret = wasm.geometry_transferSkirtHeights(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {Uint32Array | undefined}
      */
@@ -2582,17 +2997,6 @@ export class Globe {
         const ret = wasm.__wbg_get_globe_color(this.__wbg_ptr);
         return ret >>> 0;
     }
-    /**
-     * Color map lookup table for elevation heatmap rendering.
-     * Flattened RGB array: [r0,g0,b0, r1,g1,b1, ...].
-     * @returns {Float32Array}
-     */
-    get elevationColormap() {
-        const ret = wasm.__wbg_get_globe_elevationColormap(this.__wbg_ptr);
-        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
     /**
      * Whether to hide underground geometry. Disabling this value might cause unexpected behavior when using effect.
      * @returns {boolean}
@@ -2671,12 +3075,9 @@ export class Globe {
      * @param {boolean} transparent
      * @param {number} opacity
      * @param {boolean} wireframe
-     * @param {Float32Array} elevation_colormap
      */
-    constructor(max_sse, segments, color, hide_underground, use_normal, transparent, opacity, wireframe, elevation_colormap) {
-        const ptr0 = passArrayF32ToWasm0(elevation_colormap, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.globe_new(max_sse, segments, color, hide_underground, use_normal, transparent, opacity, wireframe, ptr0, len0);
+    constructor(max_sse, segments, color, hide_underground, use_normal, transparent, opacity, wireframe) {
+        const ret = wasm.globe_new(max_sse, segments, color, hide_underground, use_normal, transparent, opacity, wireframe);
         this.__wbg_ptr = ret;
         GlobeFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -2688,16 +3089,6 @@ export class Globe {
     set color(arg0) {
         wasm.__wbg_set_globe_color(this.__wbg_ptr, arg0);
     }
-    /**
-     * Color map lookup table for elevation heatmap rendering.
-     * Flattened RGB array: [r0,g0,b0, r1,g1,b1, ...].
-     * @param {Float32Array} arg0
-     */
-    set elevationColormap(arg0) {
-        const ptr0 = passArrayF32ToWasm0(arg0, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_globe_elevationColormap(this.__wbg_ptr, ptr0, len0);
-    }
     /**
      * Whether to hide underground geometry. Disabling this value might cause unexpected behavior when using effect.
      * @param {boolean} arg0
@@ -2973,19 +3364,12 @@ export class ModelMaterial {
     /**
      * @returns {boolean | undefined}
      */
-    get applyWaterNormal() {
-        const ret = wasm.__wbg_get_modelmaterial_applyWaterNormal(this.__wbg_ptr);
+    get castShadow() {
+        const ret = wasm.__wbg_get_modelmaterial_castShadow(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
     /**
-     * @returns {boolean | undefined}
-     */
-    get castShadow() {
-        const ret = wasm.__wbg_get_modelmaterial_castShadow(this.__wbg_ptr);
-        return ret === 0xFFFFFF ? undefined : ret !== 0;
-    }
-    /**
-     * @returns {number | undefined}
+     * @returns {number | undefined}
      */
     get color() {
         const ret = wasm.__wbg_get_modelmaterial_color(this.__wbg_ptr);
@@ -3037,6 +3421,15 @@ export class ModelMaterial {
         const ret = wasm.__wbg_get_modelmaterial_emissiveIntensity(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Speed in m/s of the current carrying the water's waves
+     * along `waveDirection`. Default: 0.
+     * @returns {number | undefined}
+     */
+    get flowSpeed() {
+        const ret = wasm.__wbg_get_modelmaterial_flowSpeed(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * @returns {number | undefined}
      */
@@ -3124,6 +3517,7 @@ export class ModelMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
+     * Phong shininess of the non-water `specular` highlight.
      * @returns {number | undefined}
      */
     get shininess() {
@@ -3167,6 +3561,7 @@ export class ModelMaterial {
     }
     /**
      * Enabling this value allows using `shininess` and `specular_strength`.
+     * Has no effect on water.
      * @returns {boolean | undefined}
      */
     get specular() {
@@ -3194,28 +3589,54 @@ export class ModelMaterial {
         return v1;
     }
     /**
-     * Scale water normal. Decreasing this value will make the water surface rough.
+     * Extent of the water body, which bounds how far the wind blows over it
+     * and so how large its waves grow: `"ocean"` (the default; open sea),
+     * `"large"` (a bay or a large lake, about 20 km), `"medium"` (a lake or a
+     * wide river, about 2 km) or `"small"` (a river or a pond, about 200 m).
+     * @returns {string | undefined}
+     */
+    get waterScale() {
+        const ret = wasm.__wbg_get_modelmaterial_waterScale(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Apply a water material on the polygon. It might slow down the loading of the mesh.
+     * @returns {boolean | undefined}
+     */
+    get water() {
+        const ret = wasm.__wbg_get_modelmaterial_water(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * Where the water's waves travel, in degrees clockwise from north.
+     * Default: 0.
      * @returns {number | undefined}
      */
-    get waterScaleNormal() {
-        const ret = wasm.__wbg_get_modelmaterial_waterScaleNormal(this.__wbg_ptr);
+    get waveDirection() {
+        const ret = wasm.__wbg_get_modelmaterial_waveDirection(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Water wave speed.
+     * Scales the water's wave slopes; 0 is a flat mirror.
      * @returns {number | undefined}
      */
-    get waterSpeed() {
-        const ret = wasm.__wbg_get_modelmaterial_waterSpeed(this.__wbg_ptr);
+    get waveExaggeration() {
+        const ret = wasm.__wbg_get_modelmaterial_waveExaggeration(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Apply a water material on the polygon. It might slow down the loading of the mesh.
-     * @returns {boolean | undefined}
+     * Sets the size, steepness and speed of the water's waves: about 1 is a
+     * calm ripple, 5 moderate and 20 a storm. Default: 5.
+     * @returns {number | undefined}
      */
-    get water() {
-        const ret = wasm.__wbg_get_modelmaterial_water(this.__wbg_ptr);
-        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    get waveStrength() {
+        const ret = wasm.__wbg_get_modelmaterial_waveStrength(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
      * @param {ModelInternalMaterial | null} [arg0]
@@ -3242,12 +3663,6 @@ export class ModelMaterial {
     set animationSpeed(arg0) {
         wasm.__wbg_set_modelmaterial_animationSpeed(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
-    /**
-     * @param {boolean | null} [arg0]
-     */
-    set applyWaterNormal(arg0) {
-        wasm.__wbg_set_modelmaterial_applyWaterNormal(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
-    }
     /**
      * @param {boolean | null} [arg0]
      */
@@ -3298,6 +3713,14 @@ export class ModelMaterial {
     set emissiveIntensity(arg0) {
         wasm.__wbg_set_modelmaterial_emissiveIntensity(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Speed in m/s of the current carrying the water's waves
+     * along `waveDirection`. Default: 0.
+     * @param {number | null} [arg0]
+     */
+    set flowSpeed(arg0) {
+        wasm.__wbg_set_modelmaterial_flowSpeed(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
     /**
      * @param {number | null} [arg0]
      */
@@ -3374,6 +3797,7 @@ export class ModelMaterial {
         wasm.__wbg_set_modelmaterial_roughness(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
     /**
+     * Phong shininess of the non-water `specular` highlight.
      * @param {number | null} [arg0]
      */
     set shininess(arg0) {
@@ -3411,6 +3835,7 @@ export class ModelMaterial {
     }
     /**
      * Enabling this value allows using `shininess` and `specular_strength`.
+     * Has no effect on water.
      * @param {boolean | null} [arg0]
      */
     set specular(arg0) {
@@ -3432,25 +3857,46 @@ export class ModelMaterial {
         wasm.__wbg_set_modelmaterial_url(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * Scale water normal. Decreasing this value will make the water surface rough.
+     * Extent of the water body, which bounds how far the wind blows over it
+     * and so how large its waves grow: `"ocean"` (the default; open sea),
+     * `"large"` (a bay or a large lake, about 20 km), `"medium"` (a lake or a
+     * wide river, about 2 km) or `"small"` (a river or a pond, about 200 m).
+     * @param {string | null} [arg0]
+     */
+    set waterScale(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_modelmaterial_waterScale(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Apply a water material on the polygon. It might slow down the loading of the mesh.
+     * @param {boolean | null} [arg0]
+     */
+    set water(arg0) {
+        wasm.__wbg_set_modelmaterial_water(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
+    /**
+     * Where the water's waves travel, in degrees clockwise from north.
+     * Default: 0.
      * @param {number | null} [arg0]
      */
-    set waterScaleNormal(arg0) {
-        wasm.__wbg_set_modelmaterial_waterScaleNormal(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    set waveDirection(arg0) {
+        wasm.__wbg_set_modelmaterial_waveDirection(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
     /**
-     * Water wave speed.
+     * Scales the water's wave slopes; 0 is a flat mirror.
      * @param {number | null} [arg0]
      */
-    set waterSpeed(arg0) {
-        wasm.__wbg_set_modelmaterial_waterSpeed(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    set waveExaggeration(arg0) {
+        wasm.__wbg_set_modelmaterial_waveExaggeration(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
     /**
-     * Apply a water material on the polygon. It might slow down the loading of the mesh.
-     * @param {boolean | null} [arg0]
+     * Sets the size, steepness and speed of the water's waves: about 1 is a
+     * calm ripple, 5 moderate and 20 a storm. Default: 5.
+     * @param {number | null} [arg0]
      */
-    set water(arg0) {
-        wasm.__wbg_set_modelmaterial_water(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    set waveStrength(arg0) {
+        wasm.__wbg_set_modelmaterial_waveStrength(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
 }
 if (Symbol.dispose) ModelMaterial.prototype[Symbol.dispose] = ModelMaterial.prototype.free;
@@ -3576,25 +4022,31 @@ export class PointMaterial {
         wasm.__wbg_pointmaterial_free(ptr, 0);
     }
     /**
-     * Whether faces seen from behind are culled. Default is false, so a
-     * quad frozen in its anchor's frame (`rotateWithCamera: false`) stays
-     * visible from behind. Turn it on to hide a flat quad's parts that wrap
-     * over the horizon, which face away from the camera.
+     * Part of the quad placed at the anchor point: `"center"` (default),
+     * `"left"`, `"right"`, `"top"`, `"bottom"`, `"top-left"`, `"top-right"`,
+     * `"bottom-left"` or `"bottom-right"`, as MapLibre's `icon-anchor`.
+     * @returns {string | undefined}
+     */
+    get anchor() {
+        const ret = wasm.__wbg_get_pointmaterial_anchor(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Whether faces seen from behind are culled. Default is false. Only a
+     * flat quad has a back the camera can see: turn it on to hide the parts
+     * of a large one that wrap over the horizon, which face away from the
+     * camera.
      * @returns {boolean | undefined}
      */
     get backfaceCulling() {
         const ret = wasm.__wbg_get_pointmaterial_backfaceCulling(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
-    /**
-     * anchor point of the sprite, range is (-0.5, -0.5) to (0.5, 0.5).
-     * Default is (0.0, 0.0) which means the center of the sprite.
-     * @returns {Vec2 | undefined}
-     */
-    get center() {
-        const ret = wasm.__wbg_get_pointmaterial_center(this.__wbg_ptr);
-        return ret === 0 ? undefined : Vec2.__wrap(ret);
-    }
     /**
      * @returns {boolean | undefined}
      */
@@ -3609,6 +4061,21 @@ export class PointMaterial {
         const ret = wasm.__wbg_get_pointmaterial_color(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Extra space around the collision box, in screen pixels: one to four
+     * values, expanded like CSS padding (top, right, bottom, left). Only
+     * meaningful when `declutter` is enabled. Defaults to `[2]`.
+     * @returns {Float32Array | undefined}
+     */
+    get declutterPadding() {
+        const ret = wasm.__wbg_get_pointmaterial_declutterPadding(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
     /**
      * Placement priority for decluttering; higher wins. Only meaningful when
      * `declutter` is enabled. Defaults to `0.0`.
@@ -3618,6 +4085,17 @@ export class PointMaterial {
         const ret = wasm.__wbg_get_pointmaterial_declutterPriority(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Coarse placement order for decluttering, compared before
+     * `declutterPriority`: every label with a higher rank is placed before any
+     * label with a lower one, whatever their priorities. Only meaningful when
+     * `declutter` is enabled. Defaults to `0.0`.
+     * @returns {number | undefined}
+     */
+    get declutterRank() {
+        const ret = wasm.__wbg_get_pointmaterial_declutterRank(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * Participate in screen-space decluttering: when labels/sprites overlap
      * on screen, lower-priority ones are hidden. Defaults to `true`; set to
@@ -3686,6 +4164,16 @@ export class PointMaterial {
         const ret = wasm.__wbg_get_pointmaterial_height(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Leave this label's box out of the collision grid, so symbols placed
+     * after it may overlap it. Only meaningful when `declutter` is enabled.
+     * Defaults to `false`.
+     * @returns {boolean | undefined}
+     */
+    get ignorePlacement() {
+        const ret = wasm.__wbg_get_pointmaterial_ignorePlacement(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
     /**
      * Avoid overlapping with the globe surface.
      * @returns {boolean | undefined}
@@ -3694,6 +4182,16 @@ export class PointMaterial {
         const ret = wasm.__wbg_get_pointmaterial_offsetDepth(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
+    /**
+     * Shift from the anchor point, x right and y down, in the unit of `size`
+     * (meters when `sizeInMeters`, pixels otherwise). Lies in the quad's own
+     * plane, so it turns with `rotation`. Defaults to `(0, 0)`.
+     * @returns {Vec2 | undefined}
+     */
+    get offset() {
+        const ret = wasm.__wbg_get_pointmaterial_offset(this.__wbg_ptr);
+        return ret === 0 ? undefined : Vec2.__wrap(ret);
+    }
     /**
      * @returns {number | undefined}
      */
@@ -3702,9 +4200,45 @@ export class PointMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Whether the point stands up (`"upright"`, the default) or lies on the
-     * globe surface around its anchor (`"flat"`). Pair with
-     * `rotateWithCamera`.
+     * Whether the label may be drawn over symbols placed before it:
+     * `"never"` (the default) hides it on any collision, `"always"` never
+     * does, `"cooperative"` hides it only when it collides with a `"never"`
+     * symbol. Only meaningful when `declutter` is enabled.
+     * @returns {string | undefined}
+     */
+    get overlap() {
+        const ret = wasm.__wbg_get_pointmaterial_overlap(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * How anchors are derived from line and polygon geometry: `"point"` (the
+     * default) puts one at every line and polygon-ring vertex, `"line"`
+     * repeats them along the line every `spacing`, `"line-center"` places a
+     * single one at the line's midpoint. Polygon rings are walked like lines. Requires `geometryTypes`
+     * to include `"line"` or `"polygon"`.
+     * @returns {string | undefined}
+     */
+    get placement() {
+        const ret = wasm.__wbg_get_pointmaterial_placement(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Plane the point lies in: the screen (`"upright"`, never foreshortened)
+     * or the globe surface around its anchor (`"flat"`), as MapLibre's
+     * `icon-pitch-alignment` `viewport` and `map`. Pair with
+     * `rotateWithCamera`. Left unset, it is `"flat"` when `rotateWithCamera`
+     * resolves to `false` and `"upright"` otherwise, as MapLibre resolves
+     * `auto`.
      * @returns {string | undefined}
      */
     get pointFacing() {
@@ -3717,9 +4251,22 @@ export class PointMaterial {
         return v1;
     }
     /**
-     * Whether the point turns to follow the camera. `true` (the default)
-     * keeps it facing the viewer. `false` freezes it in the anchor's local
-     * east-north-up frame, so moving the camera never reorients it.
+     * Add the line's tangent bearing at the anchor to `rotation`, so the
+     * sprite turns with the line it sits on. Defaults to `true`.
+     * @returns {boolean | undefined}
+     */
+    get rotateToLine() {
+        const ret = wasm.__wbg_get_pointmaterial_rotateToLine(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * Whether the point turns with the camera or with the map, as MapLibre's
+     * `icon-rotation-alignment` `viewport` and `map`. `true` keeps it reading left to right
+     * (a screen-aligned billboard, or a flat quad yawed to the camera).
+     * `false` aligns it with the map: upright, it stays on screen but turns
+     * with the camera heading so its x-axis points east; flat, it lies
+     * north-up. Left unset, it is `true` for `placement: "point"` and `false`
+     * along a line, as MapLibre resolves `auto`.
      * @returns {boolean | undefined}
      */
     get rotateWithCamera() {
@@ -3728,7 +4275,7 @@ export class PointMaterial {
     }
     /**
      * Rotation of the point within its own plane, about its anchor point, in
-     * degrees, clockwise seen from the front. `center` decides where inside
+     * degrees, clockwise seen from the front. `anchor` decides where inside
      * the quad the pivot sits. Defaults to `0.0`.
      * @returns {number | undefined}
      */
@@ -3759,6 +4306,47 @@ export class PointMaterial {
         const ret = wasm.__wbg_get_pointmaterial_size(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Distance between repeated anchors along a line, in screen pixels, for
+     * `vector-tile` and `geojson` sources alike. Resolved per anchor as the
+     * camera moves: anchors thin out as it pulls back and fill in as it
+     * closes, never moving, so the gap on screen stays between one and two
+     * times `spacing` across a pitched view. As MapLibre does with
+     * `symbol-spacing`, a sprite wider than three quarters of the spacing
+     * spreads its repeats to its width plus a quarter of the spacing, and a
+     * vector tile places anchors only inside its own bounds. Only used by
+     * `placement: "line"`. Defaults to `250.0`.
+     * @returns {number | undefined}
+     */
+    get spacing() {
+        const ret = wasm.__wbg_get_pointmaterial_spacing(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * Frame `translate` is measured in: `"map"` (default) turns it with the
+     * camera heading so +x points east and +y south; `"viewport"` keeps it on
+     * the screen axes. MapLibre's `icon-translate-anchor`.
+     * @returns {string | undefined}
+     */
+    get translateAnchor() {
+        const ret = wasm.__wbg_get_pointmaterial_translateAnchor(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Screen-pixel shift of the drawn quad, x right and y down, applied after
+     * projection so it stays the same number of pixels at any distance, as
+     * MapLibre's `icon-translate`. Defaults to `(0, 0)`.
+     * @returns {Vec2 | undefined}
+     */
+    get translate() {
+        const ret = wasm.__wbg_get_pointmaterial_translate(this.__wbg_ptr);
+        return ret === 0 ? undefined : Vec2.__wrap(ret);
+    }
     /**
      * @returns {boolean | undefined}
      */
@@ -3767,27 +4355,25 @@ export class PointMaterial {
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
     /**
-     * Whether faces seen from behind are culled. Default is false, so a
-     * quad frozen in its anchor's frame (`rotateWithCamera: false`) stays
-     * visible from behind. Turn it on to hide a flat quad's parts that wrap
-     * over the horizon, which face away from the camera.
-     * @param {boolean | null} [arg0]
+     * Part of the quad placed at the anchor point: `"center"` (default),
+     * `"left"`, `"right"`, `"top"`, `"bottom"`, `"top-left"`, `"top-right"`,
+     * `"bottom-left"` or `"bottom-right"`, as MapLibre's `icon-anchor`.
+     * @param {string | null} [arg0]
      */
-    set backfaceCulling(arg0) {
-        wasm.__wbg_set_pointmaterial_backfaceCulling(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    set anchor(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_pointmaterial_anchor(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * anchor point of the sprite, range is (-0.5, -0.5) to (0.5, 0.5).
-     * Default is (0.0, 0.0) which means the center of the sprite.
-     * @param {Vec2 | null} [arg0]
+     * Whether faces seen from behind are culled. Default is false. Only a
+     * flat quad has a back the camera can see: turn it on to hide the parts
+     * of a large one that wrap over the horizon, which face away from the
+     * camera.
+     * @param {boolean | null} [arg0]
      */
-    set center(arg0) {
-        let ptr0 = 0;
-        if (!isLikeNone(arg0)) {
-            _assertClass(arg0, Vec2);
-            ptr0 = arg0.__destroy_into_raw();
-        }
-        wasm.__wbg_set_pointmaterial_center(this.__wbg_ptr, ptr0);
+    set backfaceCulling(arg0) {
+        wasm.__wbg_set_pointmaterial_backfaceCulling(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
     /**
      * @param {boolean | null} [arg0]
@@ -3801,6 +4387,17 @@ export class PointMaterial {
     set color(arg0) {
         wasm.__wbg_set_pointmaterial_color(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >>> 0);
     }
+    /**
+     * Extra space around the collision box, in screen pixels: one to four
+     * values, expanded like CSS padding (top, right, bottom, left). Only
+     * meaningful when `declutter` is enabled. Defaults to `[2]`.
+     * @param {Float32Array | null} [arg0]
+     */
+    set declutterPadding(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passArrayF32ToWasm0(arg0, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_pointmaterial_declutterPadding(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * Placement priority for decluttering; higher wins. Only meaningful when
      * `declutter` is enabled. Defaults to `0.0`.
@@ -3809,6 +4406,16 @@ export class PointMaterial {
     set declutterPriority(arg0) {
         wasm.__wbg_set_pointmaterial_declutterPriority(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Coarse placement order for decluttering, compared before
+     * `declutterPriority`: every label with a higher rank is placed before any
+     * label with a lower one, whatever their priorities. Only meaningful when
+     * `declutter` is enabled. Defaults to `0.0`.
+     * @param {number | null} [arg0]
+     */
+    set declutterRank(arg0) {
+        wasm.__wbg_set_pointmaterial_declutterRank(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
     /**
      * Participate in screen-space decluttering: when labels/sprites overlap
      * on screen, lower-priority ones are hidden. Defaults to `true`; set to
@@ -3864,6 +4471,15 @@ export class PointMaterial {
     set height(arg0) {
         wasm.__wbg_set_pointmaterial_height(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Leave this label's box out of the collision grid, so symbols placed
+     * after it may overlap it. Only meaningful when `declutter` is enabled.
+     * Defaults to `false`.
+     * @param {boolean | null} [arg0]
+     */
+    set ignorePlacement(arg0) {
+        wasm.__wbg_set_pointmaterial_ignorePlacement(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
     /**
      * Avoid overlapping with the globe surface.
      * @param {boolean | null} [arg0]
@@ -3871,6 +4487,20 @@ export class PointMaterial {
     set offsetDepth(arg0) {
         wasm.__wbg_set_pointmaterial_offsetDepth(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
+    /**
+     * Shift from the anchor point, x right and y down, in the unit of `size`
+     * (meters when `sizeInMeters`, pixels otherwise). Lies in the quad's own
+     * plane, so it turns with `rotation`. Defaults to `(0, 0)`.
+     * @param {Vec2 | null} [arg0]
+     */
+    set offset(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Vec2);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_pointmaterial_offset(this.__wbg_ptr, ptr0);
+    }
     /**
      * @param {number | null} [arg0]
      */
@@ -3878,9 +4508,37 @@ export class PointMaterial {
         wasm.__wbg_set_pointmaterial_opacity(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
     /**
-     * Whether the point stands up (`"upright"`, the default) or lies on the
-     * globe surface around its anchor (`"flat"`). Pair with
-     * `rotateWithCamera`.
+     * Whether the label may be drawn over symbols placed before it:
+     * `"never"` (the default) hides it on any collision, `"always"` never
+     * does, `"cooperative"` hides it only when it collides with a `"never"`
+     * symbol. Only meaningful when `declutter` is enabled.
+     * @param {string | null} [arg0]
+     */
+    set overlap(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_pointmaterial_overlap(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * How anchors are derived from line and polygon geometry: `"point"` (the
+     * default) puts one at every line and polygon-ring vertex, `"line"`
+     * repeats them along the line every `spacing`, `"line-center"` places a
+     * single one at the line's midpoint. Polygon rings are walked like lines. Requires `geometryTypes`
+     * to include `"line"` or `"polygon"`.
+     * @param {string | null} [arg0]
+     */
+    set placement(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_pointmaterial_placement(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Plane the point lies in: the screen (`"upright"`, never foreshortened)
+     * or the globe surface around its anchor (`"flat"`), as MapLibre's
+     * `icon-pitch-alignment` `viewport` and `map`. Pair with
+     * `rotateWithCamera`. Left unset, it is `"flat"` when `rotateWithCamera`
+     * resolves to `false` and `"upright"` otherwise, as MapLibre resolves
+     * `auto`.
      * @param {string | null} [arg0]
      */
     set pointFacing(arg0) {
@@ -3889,9 +4547,21 @@ export class PointMaterial {
         wasm.__wbg_set_pointmaterial_pointFacing(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * Whether the point turns to follow the camera. `true` (the default)
-     * keeps it facing the viewer. `false` freezes it in the anchor's local
-     * east-north-up frame, so moving the camera never reorients it.
+     * Add the line's tangent bearing at the anchor to `rotation`, so the
+     * sprite turns with the line it sits on. Defaults to `true`.
+     * @param {boolean | null} [arg0]
+     */
+    set rotateToLine(arg0) {
+        wasm.__wbg_set_pointmaterial_rotateToLine(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
+    /**
+     * Whether the point turns with the camera or with the map, as MapLibre's
+     * `icon-rotation-alignment` `viewport` and `map`. `true` keeps it reading left to right
+     * (a screen-aligned billboard, or a flat quad yawed to the camera).
+     * `false` aligns it with the map: upright, it stays on screen but turns
+     * with the camera heading so its x-axis points east; flat, it lies
+     * north-up. Left unset, it is `true` for `placement: "point"` and `false`
+     * along a line, as MapLibre resolves `auto`.
      * @param {boolean | null} [arg0]
      */
     set rotateWithCamera(arg0) {
@@ -3899,7 +4569,7 @@ export class PointMaterial {
     }
     /**
      * Rotation of the point within its own plane, about its anchor point, in
-     * degrees, clockwise seen from the front. `center` decides where inside
+     * degrees, clockwise seen from the front. `anchor` decides where inside
      * the quad the pivot sits. Defaults to `0.0`.
      * @param {number | null} [arg0]
      */
@@ -3926,6 +4596,46 @@ export class PointMaterial {
     set size(arg0) {
         wasm.__wbg_set_pointmaterial_size(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Distance between repeated anchors along a line, in screen pixels, for
+     * `vector-tile` and `geojson` sources alike. Resolved per anchor as the
+     * camera moves: anchors thin out as it pulls back and fill in as it
+     * closes, never moving, so the gap on screen stays between one and two
+     * times `spacing` across a pitched view. As MapLibre does with
+     * `symbol-spacing`, a sprite wider than three quarters of the spacing
+     * spreads its repeats to its width plus a quarter of the spacing, and a
+     * vector tile places anchors only inside its own bounds. Only used by
+     * `placement: "line"`. Defaults to `250.0`.
+     * @param {number | null} [arg0]
+     */
+    set spacing(arg0) {
+        wasm.__wbg_set_pointmaterial_spacing(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
+    /**
+     * Frame `translate` is measured in: `"map"` (default) turns it with the
+     * camera heading so +x points east and +y south; `"viewport"` keeps it on
+     * the screen axes. MapLibre's `icon-translate-anchor`.
+     * @param {string | null} [arg0]
+     */
+    set translateAnchor(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_pointmaterial_translateAnchor(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Screen-pixel shift of the drawn quad, x right and y down, applied after
+     * projection so it stays the same number of pixels at any distance, as
+     * MapLibre's `icon-translate`. Defaults to `(0, 0)`.
+     * @param {Vec2 | null} [arg0]
+     */
+    set translate(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Vec2);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_pointmaterial_translate(this.__wbg_ptr, ptr0);
+    }
     /**
      * @param {boolean | null} [arg0]
      */
@@ -4221,13 +4931,6 @@ export class PolygonMaterial {
         const ret = wasm.__wbg_get_polygonmaterial___internal__(this.__wbg_ptr);
         return ret === 0 ? undefined : PolygonInternalMaterial.__wrap(ret);
     }
-    /**
-     * @returns {boolean | undefined}
-     */
-    get applyWaterNormal() {
-        const ret = wasm.__wbg_get_polygonmaterial_applyWaterNormal(this.__wbg_ptr);
-        return ret === 0xFFFFFF ? undefined : ret !== 0;
-    }
     /**
      * @returns {boolean | undefined}
      */
@@ -4249,6 +4952,14 @@ export class PolygonMaterial {
         const ret = wasm.__wbg_get_polygonmaterial_color(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Write depth before blending so a transparent layer blends only its nearest surface.
+     * @returns {boolean | undefined}
+     */
+    get depthPrePass() {
+        const ret = wasm.__wbg_get_polygonmaterial_depthPrePass(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
     /**
      * IDs of selective effects to apply (e.g., "bloom", "outline")
      * @returns {string[] | undefined}
@@ -4285,6 +4996,15 @@ export class PolygonMaterial {
         const ret = wasm.__wbg_get_polygonmaterial_extrudedHeight(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Speed in m/s of the current carrying the water's waves
+     * along `waveDirection`. Default: 0.
+     * @returns {number | undefined}
+     */
+    get flowSpeed() {
+        const ret = wasm.__wbg_get_polygonmaterial_flowSpeed(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * @returns {number | undefined}
      */
@@ -4382,6 +5102,15 @@ export class PolygonMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
+     * Shade the extruded sides with the surface normal instead of their own.
+     * @returns {boolean | undefined}
+     */
+    get shadeSidesAsSurface() {
+        const ret = wasm.__wbg_get_polygonmaterial_shadeSidesAsSurface(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * Phong shininess of the non-water `specular` highlight.
      * @returns {number | undefined}
      */
     get shininess() {
@@ -4404,6 +5133,7 @@ export class PolygonMaterial {
     }
     /**
      * Enabling this value allows using `shininess` and `specular_strength`.
+     * Has no effect on water.
      * @returns {boolean | undefined}
      */
     get specular() {
@@ -4440,28 +5170,54 @@ export class PolygonMaterial {
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
     /**
-     * Scale water normal. Decreasing this value will make the water surface rough.
-     * @returns {number | undefined}
+     * Extent of the water body, which bounds how far the wind blows over it
+     * and so how large its waves grow: `"ocean"` (the default; open sea),
+     * `"large"` (a bay or a large lake, about 20 km), `"medium"` (a lake or a
+     * wide river, about 2 km) or `"small"` (a river or a pond, about 200 m).
+     * @returns {string | undefined}
      */
-    get waterScaleNormal() {
-        const ret = wasm.__wbg_get_polygonmaterial_waterScaleNormal(this.__wbg_ptr);
-        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    get waterScale() {
+        const ret = wasm.__wbg_get_polygonmaterial_waterScale(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
     }
     /**
-     * Water wave speed.
-     * @returns {number | undefined}
+     * Apply a water material on the polygon. It might slow down the loading of the mesh.
+     * @returns {boolean | undefined}
      */
-    get waterSpeed() {
-        const ret = wasm.__wbg_get_polygonmaterial_waterSpeed(this.__wbg_ptr);
+    get water() {
+        const ret = wasm.__wbg_get_polygonmaterial_water(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * Where the water's waves travel, in degrees clockwise from north.
+     * Default: 0.
+     * @returns {number | undefined}
+     */
+    get waveDirection() {
+        const ret = wasm.__wbg_get_polygonmaterial_waveDirection(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Apply a water material on the polygon. It might slow down the loading of the mesh.
-     * @returns {boolean | undefined}
+     * Scales the water's wave slopes; 0 is a flat mirror.
+     * @returns {number | undefined}
      */
-    get water() {
-        const ret = wasm.__wbg_get_polygonmaterial_water(this.__wbg_ptr);
-        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    get waveExaggeration() {
+        const ret = wasm.__wbg_get_polygonmaterial_waveExaggeration(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * Sets the size, steepness and speed of the water's waves: about 1 is a
+     * calm ripple, 5 moderate and 20 a storm. Default: 5.
+     * @returns {number | undefined}
+     */
+    get waveStrength() {
+        const ret = wasm.__wbg_get_polygonmaterial_waveStrength(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
      * @returns {boolean | undefined}
@@ -4506,12 +5262,6 @@ export class PolygonMaterial {
         }
         wasm.__wbg_set_polygonmaterial___internal__(this.__wbg_ptr, ptr0);
     }
-    /**
-     * @param {boolean | null} [arg0]
-     */
-    set applyWaterNormal(arg0) {
-        wasm.__wbg_set_polygonmaterial_applyWaterNormal(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
-    }
     /**
      * @param {boolean | null} [arg0]
      */
@@ -4530,6 +5280,13 @@ export class PolygonMaterial {
     set color(arg0) {
         wasm.__wbg_set_polygonmaterial_color(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >>> 0);
     }
+    /**
+     * Write depth before blending so a transparent layer blends only its nearest surface.
+     * @param {boolean | null} [arg0]
+     */
+    set depthPrePass(arg0) {
+        wasm.__wbg_set_polygonmaterial_depthPrePass(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
     /**
      * IDs of selective effects to apply (e.g., "bloom", "outline")
      * @param {string[] | null} [arg0]
@@ -4559,6 +5316,14 @@ export class PolygonMaterial {
     set extrudedHeight(arg0) {
         wasm.__wbg_set_polygonmaterial_extrudedHeight(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Speed in m/s of the current carrying the water's waves
+     * along `waveDirection`. Default: 0.
+     * @param {number | null} [arg0]
+     */
+    set flowSpeed(arg0) {
+        wasm.__wbg_set_polygonmaterial_flowSpeed(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
     /**
      * @param {number | null} [arg0]
      */
@@ -4644,6 +5409,14 @@ export class PolygonMaterial {
         wasm.__wbg_set_polygonmaterial_roughness(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
     /**
+     * Shade the extruded sides with the surface normal instead of their own.
+     * @param {boolean | null} [arg0]
+     */
+    set shadeSidesAsSurface(arg0) {
+        wasm.__wbg_set_polygonmaterial_shadeSidesAsSurface(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
+    /**
+     * Phong shininess of the non-water `specular` highlight.
      * @param {number | null} [arg0]
      */
     set shininess(arg0) {
@@ -4663,6 +5436,7 @@ export class PolygonMaterial {
     }
     /**
      * Enabling this value allows using `shininess` and `specular_strength`.
+     * Has no effect on water.
      * @param {boolean | null} [arg0]
      */
     set specular(arg0) {
@@ -4695,25 +5469,46 @@ export class PolygonMaterial {
         wasm.__wbg_set_polygonmaterial_transparent(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
     /**
-     * Scale water normal. Decreasing this value will make the water surface rough.
+     * Extent of the water body, which bounds how far the wind blows over it
+     * and so how large its waves grow: `"ocean"` (the default; open sea),
+     * `"large"` (a bay or a large lake, about 20 km), `"medium"` (a lake or a
+     * wide river, about 2 km) or `"small"` (a river or a pond, about 200 m).
+     * @param {string | null} [arg0]
+     */
+    set waterScale(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_polygonmaterial_waterScale(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Apply a water material on the polygon. It might slow down the loading of the mesh.
+     * @param {boolean | null} [arg0]
+     */
+    set water(arg0) {
+        wasm.__wbg_set_polygonmaterial_water(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
+    /**
+     * Where the water's waves travel, in degrees clockwise from north.
+     * Default: 0.
      * @param {number | null} [arg0]
      */
-    set waterScaleNormal(arg0) {
-        wasm.__wbg_set_polygonmaterial_waterScaleNormal(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    set waveDirection(arg0) {
+        wasm.__wbg_set_polygonmaterial_waveDirection(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
     /**
-     * Water wave speed.
+     * Scales the water's wave slopes; 0 is a flat mirror.
      * @param {number | null} [arg0]
      */
-    set waterSpeed(arg0) {
-        wasm.__wbg_set_polygonmaterial_waterSpeed(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    set waveExaggeration(arg0) {
+        wasm.__wbg_set_polygonmaterial_waveExaggeration(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
     /**
-     * Apply a water material on the polygon. It might slow down the loading of the mesh.
-     * @param {boolean | null} [arg0]
+     * Sets the size, steepness and speed of the water's waves: about 1 is a
+     * calm ripple, 5 moderate and 20 a storm. Default: 5.
+     * @param {number | null} [arg0]
      */
-    set water(arg0) {
-        wasm.__wbg_set_polygonmaterial_water(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    set waveStrength(arg0) {
+        wasm.__wbg_set_polygonmaterial_waveStrength(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
     /**
      * @param {boolean | null} [arg0]
@@ -4794,15 +5589,15 @@ export class PolylineGeometry {
     /**
      * @returns {Float32Array | undefined}
      */
-    end_normal_and_texture_coordinate_normalization_x() {
-        const ret = wasm.polylinegeometry_end_normal_and_texture_coordinate_normalization_x(this.__wbg_ptr);
+    end_normal_and_segment_length() {
+        const ret = wasm.polylinegeometry_end_normal_and_segment_length(this.__wbg_ptr);
         return ret;
     }
     /**
      * @returns {number | undefined}
      */
-    end_normal_and_texture_coordinate_normalization_x_size() {
-        const ret = wasm.polylinegeometry_end_normal_and_texture_coordinate_normalization_x_size(this.__wbg_ptr);
+    end_normal_and_segment_length_size() {
+        const ret = wasm.polylinegeometry_end_normal_and_segment_length_size(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret;
     }
     /**
@@ -4826,6 +5621,20 @@ export class PolylineGeometry {
         const ret = wasm.polylinegeometry_indices(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @returns {Float32Array | undefined}
+     */
+    line_distance_and_ends() {
+        const ret = wasm.polylinegeometry_line_distance_and_ends(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Float32Array | undefined}
+     */
+    line_segments() {
+        const ret = wasm.polylinegeometry_line_segments(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {Float32Array}
      */
@@ -4871,15 +5680,15 @@ export class PolylineGeometry {
     /**
      * @returns {Float32Array}
      */
-    right_normal_and_texture_coordinate_normalization_y() {
-        const ret = wasm.polylinegeometry_right_normal_and_texture_coordinate_normalization_y(this.__wbg_ptr);
+    right_normal_and_line_length() {
+        const ret = wasm.polylinegeometry_right_normal_and_line_length(this.__wbg_ptr);
         return ret;
     }
     /**
      * @returns {number}
      */
-    right_normal_and_texture_coordinate_normalization_y_size() {
-        const ret = wasm.polylinegeometry_right_normal_and_texture_coordinate_normalization_y_size(this.__wbg_ptr);
+    right_normal_and_line_length_size() {
+        const ret = wasm.polylinegeometry_right_normal_and_line_length_size(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -4920,15 +5729,15 @@ export class PolylineGeometry {
     /**
      * @returns {Float32Array | undefined}
      */
-    start_normals() {
-        const ret = wasm.polylinegeometry_start_normals(this.__wbg_ptr);
+    start_normal_and_length_high() {
+        const ret = wasm.polylinegeometry_start_normal_and_length_high(this.__wbg_ptr);
         return ret;
     }
     /**
      * @returns {number | undefined}
      */
-    start_normals_size() {
-        const ret = wasm.polylinegeometry_start_normals_size(this.__wbg_ptr);
+    start_normal_and_length_high_size() {
+        const ret = wasm.polylinegeometry_start_normal_and_length_high_size(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret;
     }
     /**
@@ -5011,15 +5820,15 @@ export class PolylineGeometryAttributes {
     /**
      * @returns {Float32Array | undefined}
      */
-    transfer_end_normal_and_texture_coordinate_normalization_x() {
-        const ret = wasm.polylinegeometryattributes_transfer_end_normal_and_texture_coordinate_normalization_x(this.__wbg_ptr);
+    transfer_end_normal_and_segment_length() {
+        const ret = wasm.polylinegeometryattributes_transfer_end_normal_and_segment_length(this.__wbg_ptr);
         return ret;
     }
     /**
      * @returns {number | undefined}
      */
-    transfer_end_normal_and_texture_coordinate_normalization_x_size() {
-        const ret = wasm.polylinegeometryattributes_transfer_end_normal_and_texture_coordinate_normalization_x_size(this.__wbg_ptr);
+    transfer_end_normal_and_segment_length_size() {
+        const ret = wasm.polylinegeometryattributes_transfer_end_normal_and_segment_length_size(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret;
     }
     /**
@@ -5036,6 +5845,20 @@ export class PolylineGeometryAttributes {
         const ret = wasm.polylinegeometryattributes_transfer_forward_offset_size(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret;
     }
+    /**
+     * @returns {Float32Array | undefined}
+     */
+    transfer_line_distance_and_ends() {
+        const ret = wasm.polylinegeometryattributes_transfer_line_distance_and_ends(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Float32Array | undefined}
+     */
+    transfer_line_segments() {
+        const ret = wasm.polylinegeometryattributes_transfer_line_segments(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {Float32Array}
      */
@@ -5081,15 +5904,15 @@ export class PolylineGeometryAttributes {
     /**
      * @returns {Float32Array}
      */
-    transfer_right_normal_and_texture_coordinate_normalization_y() {
-        const ret = wasm.polylinegeometryattributes_transfer_right_normal_and_texture_coordinate_normalization_y(this.__wbg_ptr);
+    transfer_right_normal_and_line_length() {
+        const ret = wasm.polylinegeometryattributes_transfer_right_normal_and_line_length(this.__wbg_ptr);
         return ret;
     }
     /**
      * @returns {number}
      */
-    transfer_right_normal_and_texture_coordinate_normalization_y_size() {
-        const ret = wasm.polylinegeometryattributes_transfer_right_normal_and_texture_coordinate_normalization_y_size(this.__wbg_ptr);
+    transfer_right_normal_and_line_length_size() {
+        const ret = wasm.polylinegeometryattributes_transfer_right_normal_and_line_length_size(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -5130,15 +5953,15 @@ export class PolylineGeometryAttributes {
     /**
      * @returns {Float32Array | undefined}
      */
-    transfer_start_normals() {
-        const ret = wasm.polylinegeometryattributes_transfer_start_normals(this.__wbg_ptr);
+    transfer_start_normal_and_length_high() {
+        const ret = wasm.polylinegeometryattributes_transfer_start_normal_and_length_high(this.__wbg_ptr);
         return ret;
     }
     /**
      * @returns {number | undefined}
      */
-    transfer_start_normals_size() {
-        const ret = wasm.polylinegeometryattributes_transfer_start_normals_size(this.__wbg_ptr);
+    transfer_start_normal_and_length_high_size() {
+        const ret = wasm.polylinegeometryattributes_transfer_start_normal_and_length_high_size(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret;
     }
     /**
@@ -5206,6 +6029,23 @@ export class PolylineMaterial {
         const ret = wasm.__wbg_get_polylinematerial___internal__(this.__wbg_ptr);
         return ret === 0 ? undefined : PolylineInternalMaterial.__wrap(ret);
     }
+    /**
+     * Shape of the ends of the line and of its dashes: `"butt"` (the
+     * default), `"round"` or `"square"`. `"round"` adds a half circle one
+     * half line width in radius beyond both ends of the line and of every
+     * dash, so a zero-length dash becomes a dot. `"square"` extends the ends
+     * of the line by half a line width and leaves the dashes' ends square.
+     * @returns {string | undefined}
+     */
+    get cap() {
+        const ret = wasm.__wbg_get_polylinematerial_cap(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
     /**
      * @returns {boolean | undefined}
      */
@@ -5227,6 +6067,22 @@ export class PolylineMaterial {
         const ret = wasm.__wbg_get_polylinematerial_color(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Alternating dash and gap lengths, in multiples of the line width,
+     * repeated along the line. The pattern's period is the sum of the
+     * entries, so an odd-length array ends in a dash that runs into the first
+     * one. An empty array draws a solid line, which is the default.
+     * @returns {Float32Array | undefined}
+     */
+    get dashArray() {
+        const ret = wasm.__wbg_get_polylinematerial_dashArray(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
     /**
      * Enable writing to depth buffer
      * @returns {boolean | undefined}
@@ -5390,6 +6246,19 @@ export class PolylineMaterial {
         }
         wasm.__wbg_set_polylinematerial___internal__(this.__wbg_ptr, ptr0);
     }
+    /**
+     * Shape of the ends of the line and of its dashes: `"butt"` (the
+     * default), `"round"` or `"square"`. `"round"` adds a half circle one
+     * half line width in radius beyond both ends of the line and of every
+     * dash, so a zero-length dash becomes a dot. `"square"` extends the ends
+     * of the line by half a line width and leaves the dashes' ends square.
+     * @param {string | null} [arg0]
+     */
+    set cap(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_polylinematerial_cap(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * @param {boolean | null} [arg0]
      */
@@ -5408,6 +6277,18 @@ export class PolylineMaterial {
     set color(arg0) {
         wasm.__wbg_set_polylinematerial_color(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >>> 0);
     }
+    /**
+     * Alternating dash and gap lengths, in multiples of the line width,
+     * repeated along the line. The pattern's period is the sum of the
+     * entries, so an odd-length array ends in a dash that runs into the first
+     * one. An empty array draws a solid line, which is the default.
+     * @param {Float32Array | null} [arg0]
+     */
+    set dashArray(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passArrayF32ToWasm0(arg0, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_polylinematerial_dashArray(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * Enable writing to depth buffer
      * @param {boolean | null} [arg0]
@@ -5609,6 +6490,17 @@ export class RasterTileInternalMaterial {
         const ret = wasm.__wbg_get_rastertileinternalmaterial_castShadow(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
+    /**
+     * Per-slot layer IDs used to look up each layer's colorMap atlas row; an
+     * empty string for slots without an elevation heatmap.
+     * @returns {string[]}
+     */
+    get colorMapLayerIds() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_colorMapLayerIds(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * @returns {Uint32Array}
      */
@@ -5619,73 +6511,115 @@ export class RasterTileInternalMaterial {
         return v1;
     }
     /**
-     * @returns {number}
+     * @returns {Float64Array}
      */
-    get elevationBScaler() {
-        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationBScaler(this.__wbg_ptr);
-        return ret;
+    get elevationBScalers() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationBScalers(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * @returns {number}
+     * @returns {Float64Array}
      */
-    get elevationBoundary() {
-        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationBoundary(this.__wbg_ptr);
-        return ret;
+    get elevationBoundaries() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationBoundaries(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * @returns {number}
+     * @returns {Float64Array}
      */
-    get elevationEpsilon() {
-        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationEpsilon(this.__wbg_ptr);
-        return ret;
+    get elevationEpsilons() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationEpsilons(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * @returns {number}
+     * @returns {Float64Array}
      */
-    get elevationGScaler() {
-        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationGScaler(this.__wbg_ptr);
-        return ret;
+    get elevationGScalers() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationGScalers(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * @returns {number}
+     * Per-layer filter modes: "linear" or "nearest"
+     * @returns {string[]}
      */
-    get elevationMaxHeight() {
-        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationMaxHeight(this.__wbg_ptr);
-        return ret;
+    get elevationHeatmapFilters() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationHeatmapFilters(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
-     * @returns {number}
+     * Per-layer maximum heights for elevation normalization
+     * @returns {Float64Array}
      */
-    get elevationMaxOffset() {
-        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationMaxOffset(this.__wbg_ptr);
-        return ret;
+    get elevationMaxHeights() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationMaxHeights(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * @returns {number}
+     * @returns {Float64Array}
      */
-    get elevationMinHeight() {
-        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationMinHeight(this.__wbg_ptr);
-        return ret;
+    get elevationMaxOffsets() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationMaxOffsets(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * @returns {number}
+     * Per-layer minimum heights for elevation normalization
+     * @returns {Float64Array}
      */
-    get elevationMinOffset() {
-        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationMinOffset(this.__wbg_ptr);
-        return ret;
+    get elevationMinHeights() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationMinHeights(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * @returns {number}
+     * @returns {Float64Array}
      */
-    get elevationOffset() {
-        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationOffset(this.__wbg_ptr);
-        return ret;
+    get elevationMinOffsets() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationMinOffsets(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
+     * @returns {Float64Array}
+     */
+    get elevationOffsets() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationOffsets(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Per-layer DEM decoder parameters
+     * @returns {Float64Array}
+     */
+    get elevationRScalers() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationRScalers(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Speed in m/s of the current carrying the waves on the watermask's water
+     * along `waveDirection`.
      * @returns {number}
      */
-    get elevationRScaler() {
-        const ret = wasm.__wbg_get_rastertileinternalmaterial_elevationRScaler(this.__wbg_ptr);
+    get flowSpeed() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_flowSpeed(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -5789,18 +6723,24 @@ export class RasterTileInternalMaterial {
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
     /**
-     * @returns {number}
+     * Per-layer logarithmic boundaries
+     * @returns {Float64Array}
      */
-    get logBoundary() {
-        const ret = wasm.__wbg_get_rastertileinternalmaterial_logBoundary(this.__wbg_ptr);
-        return ret;
+    get logBoundaries() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_logBoundaries(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * @returns {boolean}
+     * Per-layer logarithmic scaling flags
+     * @returns {Uint8Array}
      */
-    get logarithmic() {
-        const ret = wasm.__wbg_get_rastertileinternalmaterial_logarithmic(this.__wbg_ptr);
-        return ret !== 0;
+    get logarithmics() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_logarithmics(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
     }
     /**
      * @returns {Float32Array}
@@ -5843,6 +6783,41 @@ export class RasterTileInternalMaterial {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * Body color of the watermask's water from the terrain layer; `None`
+     * keeps the imagery or globe color.
+     * @returns {number | undefined}
+     */
+    get waterMaskColor() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_waterMaskColor(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * Where the waves on the watermask's water travel, in degrees clockwise
+     * from north.
+     * @returns {number}
+     */
+    get waveDirection() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_waveDirection(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Scales the wave slopes on the watermask's water; 0 is a flat mirror.
+     * @returns {number}
+     */
+    get waveExaggeration() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_waveExaggeration(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Sets the size, slope and speed of the waves on the watermask's water, in
+     * m/s.
+     * @returns {number}
+     */
+    get waveStrength() {
+        const ret = wasm.__wbg_get_rastertileinternalmaterial_waveStrength(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {any[]}
      */
@@ -5870,6 +6845,16 @@ export class RasterTileInternalMaterial {
     set castShadow(arg0) {
         wasm.__wbg_set_rastertileinternalmaterial_castShadow(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
+    /**
+     * Per-slot layer IDs used to look up each layer's colorMap atlas row; an
+     * empty string for slots without an elevation heatmap.
+     * @param {string[]} arg0
+     */
+    set colorMapLayerIds(arg0) {
+        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_colorMapLayerIds(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * @param {Uint32Array} arg0
      */
@@ -5879,64 +6864,104 @@ export class RasterTileInternalMaterial {
         wasm.__wbg_set_rastertileinternalmaterial_colors(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * @param {Float64Array} arg0
      */
-    set elevationBScaler(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationBScaler(this.__wbg_ptr, arg0);
+    set elevationBScalers(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationBScalers(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * @param {Float64Array} arg0
      */
-    set elevationBoundary(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationBoundary(this.__wbg_ptr, arg0);
+    set elevationBoundaries(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationBoundaries(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * @param {Float64Array} arg0
      */
-    set elevationEpsilon(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationEpsilon(this.__wbg_ptr, arg0);
+    set elevationEpsilons(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationEpsilons(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * @param {Float64Array} arg0
      */
-    set elevationGScaler(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationGScaler(this.__wbg_ptr, arg0);
+    set elevationGScalers(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationGScalers(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * Per-layer filter modes: "linear" or "nearest"
+     * @param {string[]} arg0
      */
-    set elevationMaxHeight(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationMaxHeight(this.__wbg_ptr, arg0);
+    set elevationHeatmapFilters(arg0) {
+        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationHeatmapFilters(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * Per-layer maximum heights for elevation normalization
+     * @param {Float64Array} arg0
      */
-    set elevationMaxOffset(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationMaxOffset(this.__wbg_ptr, arg0);
+    set elevationMaxHeights(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationMaxHeights(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * @param {Float64Array} arg0
      */
-    set elevationMinHeight(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationMinHeight(this.__wbg_ptr, arg0);
+    set elevationMaxOffsets(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationMaxOffsets(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * Per-layer minimum heights for elevation normalization
+     * @param {Float64Array} arg0
      */
-    set elevationMinOffset(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationMinOffset(this.__wbg_ptr, arg0);
+    set elevationMinHeights(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationMinHeights(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * @param {Float64Array} arg0
      */
-    set elevationOffset(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationOffset(this.__wbg_ptr, arg0);
+    set elevationMinOffsets(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationMinOffsets(this.__wbg_ptr, ptr0, len0);
     }
     /**
+     * @param {Float64Array} arg0
+     */
+    set elevationOffsets(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationOffsets(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Per-layer DEM decoder parameters
+     * @param {Float64Array} arg0
+     */
+    set elevationRScalers(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationRScalers(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Speed in m/s of the current carrying the waves on the watermask's water
+     * along `waveDirection`.
      * @param {number} arg0
      */
-    set elevationRScaler(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationRScaler(this.__wbg_ptr, arg0);
+    set flowSpeed(arg0) {
+        wasm.__wbg_set_rastertileinternalmaterial_flowSpeed(this.__wbg_ptr, arg0);
     }
     /**
      * @param {number} arg0
@@ -6026,16 +7051,22 @@ export class RasterTileInternalMaterial {
         wasm.__wbg_set_rastertileinternalmaterial_lit(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
     /**
-     * @param {number} arg0
+     * Per-layer logarithmic boundaries
+     * @param {Float64Array} arg0
      */
-    set logBoundary(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_logBoundary(this.__wbg_ptr, arg0);
+    set logBoundaries(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_logBoundaries(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {boolean} arg0
+     * Per-layer logarithmic scaling flags
+     * @param {Uint8Array} arg0
      */
-    set logarithmic(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_logarithmic(this.__wbg_ptr, arg0);
+    set logarithmics(arg0) {
+        const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_logarithmics(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @param {Float32Array} arg0
@@ -6073,6 +7104,37 @@ export class RasterTileInternalMaterial {
         const len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_rastertileinternalmaterial_terrainLatRange(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * Body color of the watermask's water from the terrain layer; `None`
+     * keeps the imagery or globe color.
+     * @param {number | null} [arg0]
+     */
+    set waterMaskColor(arg0) {
+        wasm.__wbg_set_rastertileinternalmaterial_waterMaskColor(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >>> 0);
+    }
+    /**
+     * Where the waves on the watermask's water travel, in degrees clockwise
+     * from north.
+     * @param {number} arg0
+     */
+    set waveDirection(arg0) {
+        wasm.__wbg_set_rastertileinternalmaterial_waveDirection(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Scales the wave slopes on the watermask's water; 0 is a flat mirror.
+     * @param {number} arg0
+     */
+    set waveExaggeration(arg0) {
+        wasm.__wbg_set_rastertileinternalmaterial_waveExaggeration(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Sets the size, slope and speed of the waves on the watermask's water, in
+     * m/s.
+     * @param {number} arg0
+     */
+    set waveStrength(arg0) {
+        wasm.__wbg_set_rastertileinternalmaterial_waveStrength(this.__wbg_ptr, arg0);
+    }
 }
 if (Symbol.dispose) RasterTileInternalMaterial.prototype[Symbol.dispose] = RasterTileInternalMaterial.prototype.free;
 
@@ -6244,6 +7306,13 @@ export class ReturnedConstructedTerrainMesh {
         const ret = wasm.returnedconstructedterrainmesh_transferNormals(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @returns {Float32Array | undefined}
+     */
+    transferSkirtHeights() {
+        const ret = wasm.returnedconstructedterrainmesh_transferSkirtHeights(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {Uint32Array | undefined}
      */
@@ -6343,6 +7412,36 @@ export class TerrainMaterial {
         const ret = wasm.__wbg_get_terrainmaterial_castShadow(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
+    /**
+     * Height in meters that stays in place while the terrain is exaggerated:
+     * a terrain height `h` is rendered at
+     * `(h - exaggerationRelativeHeight) * exaggeration + exaggerationRelativeHeight`.
+     * Default: 0.
+     * @returns {number | undefined}
+     */
+    get exaggerationRelativeHeight() {
+        const ret = wasm.__wbg_get_terrainmaterial_exaggerationRelativeHeight(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * Vertical exaggeration of the terrain. Terrain heights are scaled by this
+     * factor around `exaggerationRelativeHeight`. A negative value is treated
+     * as 0, which flattens the terrain. Default: 1.
+     * @returns {number | undefined}
+     */
+    get exaggeration() {
+        const ret = wasm.__wbg_get_terrainmaterial_exaggeration(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * Speed in m/s of the current carrying the waves on the watermask's water
+     * along `waveDirection`. Default: 0.
+     * @returns {number | undefined}
+     */
+    get flowSpeed() {
+        const ret = wasm.__wbg_get_terrainmaterial_flowSpeed(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * Applies the lighting equation to the color output. When `false` the
      * material outputs plain albedo (for deferred lighting) while normals and
@@ -6392,12 +7491,66 @@ export class TerrainMaterial {
         const ret = wasm.__wbg_get_terrainmaterial_skirt(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
+    /**
+     * Where the waves on the watermask's water travel, in degrees clockwise
+     * from north. Default: 0.
+     * @returns {number | undefined}
+     */
+    get waveDirection() {
+        const ret = wasm.__wbg_get_terrainmaterial_waveDirection(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * Scales the wave slopes on the watermask's water, keeping their size and
+     * speed; 0 is a flat mirror. Default: 1.
+     * @returns {number | undefined}
+     */
+    get waveExaggeration() {
+        const ret = wasm.__wbg_get_terrainmaterial_waveExaggeration(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * Sets the size, steepness and speed of the waves on the watermask's water:
+     * about 1 is a calm ripple, 5 moderate and 20 a storm. Default: 5.
+     * @returns {number | undefined}
+     */
+    get waveStrength() {
+        const ret = wasm.__wbg_get_terrainmaterial_waveStrength(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * @param {boolean | null} [arg0]
      */
     set castShadow(arg0) {
         wasm.__wbg_set_terrainmaterial_castShadow(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
+    /**
+     * Height in meters that stays in place while the terrain is exaggerated:
+     * a terrain height `h` is rendered at
+     * `(h - exaggerationRelativeHeight) * exaggeration + exaggerationRelativeHeight`.
+     * Default: 0.
+     * @param {number | null} [arg0]
+     */
+    set exaggerationRelativeHeight(arg0) {
+        wasm.__wbg_set_terrainmaterial_exaggerationRelativeHeight(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? 0 : arg0);
+    }
+    /**
+     * Vertical exaggeration of the terrain. Terrain heights are scaled by this
+     * factor around `exaggerationRelativeHeight`. A negative value is treated
+     * as 0, which flattens the terrain. Default: 1.
+     * @param {number | null} [arg0]
+     */
+    set exaggeration(arg0) {
+        wasm.__wbg_set_terrainmaterial_exaggeration(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? 0 : arg0);
+    }
+    /**
+     * Speed in m/s of the current carrying the waves on the watermask's water
+     * along `waveDirection`. Default: 0.
+     * @param {number | null} [arg0]
+     */
+    set flowSpeed(arg0) {
+        wasm.__wbg_set_terrainmaterial_flowSpeed(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
     /**
      * Applies the lighting equation to the color output. When `false` the
      * material outputs plain albedo (for deferred lighting) while normals and
@@ -6441,6 +7594,47 @@ export class TerrainMaterial {
     set skirt(arg0) {
         wasm.__wbg_set_terrainmaterial_skirt(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
+    /**
+     * Where the waves on the watermask's water travel, in degrees clockwise
+     * from north. Default: 0.
+     * @param {number | null} [arg0]
+     */
+    set waveDirection(arg0) {
+        wasm.__wbg_set_terrainmaterial_waveDirection(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
+    /**
+     * Scales the wave slopes on the watermask's water, keeping their size and
+     * speed; 0 is a flat mirror. Default: 1.
+     * @param {number | null} [arg0]
+     */
+    set waveExaggeration(arg0) {
+        wasm.__wbg_set_terrainmaterial_waveExaggeration(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
+    /**
+     * Sets the size, steepness and speed of the waves on the watermask's water:
+     * about 1 is a calm ripple, 5 moderate and 20 a storm. Default: 5.
+     * @param {number | null} [arg0]
+     */
+    set waveStrength(arg0) {
+        wasm.__wbg_set_terrainmaterial_waveStrength(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
+    /**
+     * @param {number | null} [color]
+     */
+    set waterMaskColor(color) {
+        wasm.terrainmaterial_set_waterMaskColor(this.__wbg_ptr, isLikeNone(color) ? Number.MAX_SAFE_INTEGER : (color) >>> 0);
+    }
+    /**
+     * Body color of the water the source's watermask marks. The water shows
+     * this color under its reflections instead of the imagery or globe color
+     * beneath it. Requires `requestWaterMask` on a quantized-mesh source.
+     * An update with `undefined` uses that imagery or globe color.
+     * @returns {number | undefined}
+     */
+    get waterMaskColor() {
+        const ret = wasm.terrainmaterial_waterMaskColor(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
 }
 if (Symbol.dispose) TerrainMaterial.prototype[Symbol.dispose] = TerrainMaterial.prototype.free;
 
@@ -6456,10 +7650,27 @@ export class TextMaterial {
         wasm.__wbg_textmaterial_free(ptr, 0);
     }
     /**
-     * Whether faces seen from behind are culled. Default is false, so a
-     * quad frozen in its anchor's frame (`rotateWithCamera: false`) stays
-     * visible from behind. Turn it on to hide a flat quad's parts that wrap
-     * over the horizon, which face away from the camera.
+     * Part of the text block placed at the anchor point: `"center"`
+     * (default), `"left"`, `"right"`, `"top"`, `"bottom"`, `"top-left"`,
+     * `"top-right"`, `"bottom-left"` or `"bottom-right"`, as MapLibre's
+     * `text-anchor`. The block is as wide as its widest line and one line
+     * height tall per line.
+     * @returns {string | undefined}
+     */
+    get anchor() {
+        const ret = wasm.__wbg_get_textmaterial_anchor(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Whether faces seen from behind are culled. Default is false. Only a
+     * flat quad has a back the camera can see: turn it on to hide the parts
+     * of a large one that wrap over the horizon, which face away from the
+     * camera.
      * @returns {boolean | undefined}
      */
     get backfaceCulling() {
@@ -6487,13 +7698,6 @@ export class TextMaterial {
         const ret = wasm.__wbg_get_textmaterial_borderWidth(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
-    /**
-     * @returns {Vec2 | undefined}
-     */
-    get center() {
-        const ret = wasm.__wbg_get_textmaterial_center(this.__wbg_ptr);
-        return ret === 0 ? undefined : Vec2.__wrap(ret);
-    }
     /**
      * @returns {boolean | undefined}
      */
@@ -6508,6 +7712,21 @@ export class TextMaterial {
         const ret = wasm.__wbg_get_textmaterial_color(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Extra space around the collision box, in screen pixels: one to four
+     * values, expanded like CSS padding (top, right, bottom, left). Only
+     * meaningful when `declutter` is enabled. Defaults to `[2]`.
+     * @returns {Float32Array | undefined}
+     */
+    get declutterPadding() {
+        const ret = wasm.__wbg_get_textmaterial_declutterPadding(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
     /**
      * Placement priority for decluttering; higher wins. Only meaningful when
      * `declutter` is enabled. Defaults to `0.0`.
@@ -6517,6 +7736,17 @@ export class TextMaterial {
         const ret = wasm.__wbg_get_textmaterial_declutterPriority(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Coarse placement order for decluttering, compared before
+     * `declutterPriority`: every label with a higher rank is placed before any
+     * label with a lower one, whatever their priorities. Only meaningful when
+     * `declutter` is enabled. Defaults to `0.0`.
+     * @returns {number | undefined}
+     */
+    get declutterRank() {
+        const ret = wasm.__wbg_get_textmaterial_declutterRank(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * Participate in screen-space decluttering: when labels/sprites overlap
      * on screen, lower-priority ones are hidden. Defaults to `true`; set to
@@ -6590,8 +7820,9 @@ export class TextMaterial {
     }
     /**
      * Source geometry types this appearance consumes: `"point"`, `"line"`,
-     * `"polygon"`. Defaults to `["point"]`; adding `"line"`/`"polygon"` also
-     * emits a label per line-string / polygon-ring vertex.
+     * `"polygon"`. Defaults to `["point"]`; adding `"line"` also emits a
+     * label per line string, at its first vertex, and `"polygon"` one per
+     * polygon.
      * @returns {string[] | undefined}
      */
     get geometryTypes() {
@@ -6611,15 +7842,34 @@ export class TextMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Enable high-quality glyph rendering. When `true`, text uses an MTSDF
-     * atlas (sharper corners at large sizes, dramatically slower
-     * rasterization). When `false` or omitted, the default single-channel SDF
-     * atlas is used (fast). Mirrors `navara_material::TextMaterial::high_quality`
-     * on the Rust side.
+     * Enable high-quality glyph rendering. When `true`, text uses an MTSDF
+     * atlas (sharper corners at large sizes, dramatically slower
+     * rasterization). When `false` or omitted, the default single-channel SDF
+     * atlas is used (fast). Mirrors `navara_material::TextMaterial::high_quality`
+     * on the Rust side.
+     * @returns {boolean | undefined}
+     */
+    get highQuality() {
+        const ret = wasm.__wbg_get_textmaterial_highQuality(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * Leave this label's box out of the collision grid, so symbols placed
+     * after it may overlap it. Only meaningful when `declutter` is enabled.
+     * Defaults to `false`.
+     * @returns {boolean | undefined}
+     */
+    get ignorePlacement() {
+        const ret = wasm.__wbg_get_textmaterial_ignorePlacement(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * Flip a label that would otherwise read right-to-left, so names stay
+     * legible whichever way the underlying line runs. Defaults to `true`.
      * @returns {boolean | undefined}
      */
-    get highQuality() {
-        const ret = wasm.__wbg_get_textmaterial_highQuality(this.__wbg_ptr);
+    get keepUpright() {
+        const ret = wasm.__wbg_get_textmaterial_keepUpright(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
     /**
@@ -6636,14 +7886,47 @@ export class TextMaterial {
         return v1;
     }
     /**
-     * Line height as a multiplier of the font's natural line height
-     * (ascender − descender + line gap). Defaults to `1.0`.
+     * Extra space between characters, in ems (multiples of `size`). Not
+     * added after the last character; ignored for Arabic-script text.
+     * Negative values tighten. Defaults to `0.0`.
+     * @returns {number | undefined}
+     */
+    get letterSpacing() {
+        const ret = wasm.__wbg_get_textmaterial_letterSpacing(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * Distance between the baselines of a multi-line label, in ems
+     * (multiples of `size`). Defaults to the font's natural line height
+     * (ascender − descender + line gap).
      * @returns {number | undefined}
      */
     get lineHeight() {
         const ret = wasm.__wbg_get_textmaterial_lineHeight(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Offset perpendicular to the line, in the same units as the font size:
+     * pixels when `sizeInMeters` is false, metres when it is true. Positive is
+     * to the left of the direction of travel, which puts the name above the
+     * line. Defaults to `0.0`.
+     * @returns {number | undefined}
+     */
+    get lineOffset() {
+        const ret = wasm.__wbg_get_textmaterial_lineOffset(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * Largest turn, in degrees, the line may make under a label within a
+     * window of about one and a half ems before the label is dropped as
+     * unreadable. The window slides along the label, so a long gentle curve
+     * is accepted however far it turns in total. Defaults to `45.0`.
+     * @returns {number | undefined}
+     */
+    get maxAngle() {
+        const ret = wasm.__wbg_get_textmaterial_maxAngle(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * Maximum line width in ems (multiples of `size`) before text wraps at
      * word boundaries. `0.0` (the default) disables wrapping; explicit `\n`
@@ -6662,6 +7945,16 @@ export class TextMaterial {
         const ret = wasm.__wbg_get_textmaterial_offsetDepth(this.__wbg_ptr);
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
+    /**
+     * Shift from the anchor point, x right and y down, in ems (multiples of
+     * `size`), as MapLibre's `text-offset`. Lies in the label's own plane, so
+     * it turns with `rotation`. Defaults to `(0, 0)`.
+     * @returns {Vec2 | undefined}
+     */
+    get offset() {
+        const ret = wasm.__wbg_get_textmaterial_offset(this.__wbg_ptr);
+        return ret === 0 ? undefined : Vec2.__wrap(ret);
+    }
     /**
      * Opacity of the text
      * @returns {number | undefined}
@@ -6671,7 +7964,15 @@ export class TextMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Outline blur radius in CSS pixels. Defaults to `0.0`.
+     * Width over which the outline's outer edge fades out, centered on that
+     * edge, in the unit of `outlineWidth`. Defaults to `0.0`.
+     * @returns {number | undefined}
+     */
+    get outlineBlur() {
+        const ret = wasm.__wbg_get_textmaterial_outlineBlur(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
      * @returns {number | undefined}
      */
     get outlineColor() {
@@ -6687,7 +7988,9 @@ export class TextMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Outline thickness measured in CSS pixels. Defaults to `0.0`.
+     * Outline thickness in 1/64 em: pixels of text drawn 64 pixels tall, so
+     * the outline keeps its proportion to the glyphs at any size. Defaults
+     * to `0.0`.
      * @returns {number | undefined}
      */
     get outlineWidth() {
@@ -6695,11 +7998,49 @@ export class TextMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * Whether the label turns to follow the camera. `true` (the default)
-     * keeps it facing the viewer. `false` freezes it in the anchor's local
-     * east-north-up frame, so moving the camera never reorients it: with
-     * `textFacing: "upright"` it becomes a signboard standing on the
-     * surface, with `"flat"` a north-up label painted on it.
+     * Whether the label may be drawn over symbols placed before it:
+     * `"never"` (the default) hides it on any collision, `"always"` never
+     * does, `"cooperative"` hides it only when it collides with a `"never"`
+     * symbol. Only meaningful when `declutter` is enabled.
+     * @returns {string | undefined}
+     */
+    get overlap() {
+        const ret = wasm.__wbg_get_textmaterial_overlap(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * How anchors are derived from line and polygon geometry: `"point"` (the
+     * default) puts a label per line string, at its first vertex, and one
+     * per polygon, `"line"` repeats labels along the line every `spacing`
+     * with the glyphs bending to follow it, `"line-center"` places a single
+     * label at the line's midpoint. Polygon rings are walked like lines.
+     * Requires `geometryTypes` to include `"line"` or `"polygon"`.
+     * @returns {string | undefined}
+     */
+    get placement() {
+        const ret = wasm.__wbg_get_textmaterial_placement(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Whether the label turns with the camera or with the map, as MapLibre's
+     * `text-rotation-alignment` `viewport` and `map`. `true` keeps it reading
+     * left to right (a screen-aligned billboard, or a flat label yawed to the
+     * camera). `false` aligns it with the map: upright, it stays on screen but
+     * turns with the camera heading so its x-axis points east; flat, it lies
+     * north-up. Along a line, `false` makes the label follow the line, and
+     * `true` draws it straight at its anchor unless `spreadGlyphs` is set.
+     * Left unset, it is `true` for `placement: "point"` and `false` along a
+     * line, as MapLibre resolves `auto`.
      * @returns {boolean | undefined}
      */
     get rotateWithCamera() {
@@ -6711,8 +8052,10 @@ export class TextMaterial {
      * degrees, clockwise seen from the front. Applied on top of whatever
      * orientation `textFacing` and `rotateWithCamera` resolve to: it spins a
      * billboard on screen and turns a surface label like a compass bearing.
-     * `center` decides where inside the text the pivot sits. Defaults to
-     * `0.0`.
+     * `anchor` decides where inside the text the pivot sits. Along a line
+     * each glyph spins about its own point on the line, as MapLibre's
+     * `text-rotate` does, except for a straight label (`rotateWithCamera`
+     * without `spreadGlyphs`), which turns as a whole. Defaults to `0.0`.
      * @returns {number | undefined}
      */
     get rotation() {
@@ -6742,9 +8085,52 @@ export class TextMaterial {
         const ret = wasm.__wbg_get_textmaterial_size(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * Distance between repeated labels along a line, in screen pixels, for
+     * `vector-tile` and `geojson` sources alike. Resolved per label as the
+     * camera moves: labels thin out as it pulls back and fill in as it
+     * closes, never moving, so the gap on screen stays between one and two
+     * times `spacing` across a pitched view. As MapLibre does with
+     * `symbol-spacing`, a label longer than three quarters of the spacing
+     * spreads its repeats to its own length plus a quarter of the spacing, a
+     * label within half the spacing of an earlier one with the same text is
+     * dropped, and a vector tile places labels only inside its own bounds.
+     * Defaults to `250.0`.
+     * @returns {number | undefined}
+     */
+    get spacing() {
+        const ret = wasm.__wbg_get_textmaterial_spacing(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * Place each glyph of an along-line label on its own instead of each
+     * word. With `rotateWithCamera: false` each glyph turns with the line
+     * under it (MapLibre's `symbol-placement: "line"`); with `true`, each
+     * glyph turns to the camera like a point label and is spaced on the
+     * screen (MapLibre's `viewport-glyph`). Can be overridden per feature
+     * from a feature evaluator. Defaults to `false`.
+     * @returns {boolean | undefined}
+     */
+    get spreadGlyphs() {
+        const ret = wasm.__wbg_get_textmaterial_spreadGlyphs(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * Whether this may show while its partner at the same anchor (the
+     * layer's label for a billboard, its billboard for a label) is hidden.
+     * With `false` on both, the two are placed together: both show or
+     * neither does. Only meaningful when `declutter` is enabled. Defaults to
+     * `true`.
+     * @returns {boolean | undefined}
+     */
+    get standalone() {
+        const ret = wasm.__wbg_get_textmaterial_standalone(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
     /**
      * Horizontal alignment of lines within a multi-line block:
-     * `"left"`, `"center"` (default), or `"right"`.
+     * `"left"`, `"center"` (default), `"right"`, or `"auto"`, which aligns
+     * towards the horizontal side of `anchor` (MapLibre's `text-justify`).
      * @returns {string | undefined}
      */
     get textAlign() {
@@ -6757,9 +8143,13 @@ export class TextMaterial {
         return v1;
     }
     /**
-     * Whether the label stands up (`"upright"`, the default) or lies on the
-     * globe surface around its anchor (`"flat"`), following its curvature so
-     * it reads as painted on the surface. Pair with `rotateWithCamera`.
+     * Plane the label lies in: the screen (`"upright"`, never foreshortened)
+     * or the globe surface around its anchor (`"flat"`), following its
+     * curvature so it reads as painted on the surface. MapLibre's
+     * `text-pitch-alignment` `viewport` and `map`. Pair with
+     * `rotateWithCamera`. Left unset, it is `"flat"` when `rotateWithCamera`
+     * resolves to `false` and `"upright"` otherwise, as MapLibre resolves
+     * `auto`.
      * @returns {string | undefined}
      */
     get textFacing() {
@@ -6783,6 +8173,31 @@ export class TextMaterial {
         }
         return v1;
     }
+    /**
+     * Frame `translate` is measured in: `"map"` (default) turns it with the
+     * camera heading so +x points east and +y south; `"viewport"` keeps it on
+     * the screen axes. MapLibre's `text-translate-anchor`.
+     * @returns {string | undefined}
+     */
+    get translateAnchor() {
+        const ret = wasm.__wbg_get_textmaterial_translateAnchor(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Screen-pixel shift of the drawn label, x right and y down, applied after
+     * projection so it stays the same number of pixels at any distance, as
+     * MapLibre's `text-translate`. Defaults to `(0, 0)`.
+     * @returns {Vec2 | undefined}
+     */
+    get translate() {
+        const ret = wasm.__wbg_get_textmaterial_translate(this.__wbg_ptr);
+        return ret === 0 ? undefined : Vec2.__wrap(ret);
+    }
     /**
      * Enable transparency and alpha blending
      * @returns {boolean | undefined}
@@ -6792,10 +8207,40 @@ export class TextMaterial {
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
     /**
-     * Whether faces seen from behind are culled. Default is false, so a
-     * quad frozen in its anchor's frame (`rotateWithCamera: false`) stays
-     * visible from behind. Turn it on to hide a flat quad's parts that wrap
-     * over the horizon, which face away from the camera.
+     * Placements the declutter pass tries in order, keeping the first whose
+     * box is free, as MapLibre's `text-variable-anchor-offset`. The one in
+     * use is tried first, so a label only moves when it must. Overrides
+     * `anchor` and `offset` when not empty, except along a line. Without
+     * declutter the first is used.
+     * @returns {VariableAnchor[] | undefined}
+     */
+    get variableAnchors() {
+        const ret = wasm.__wbg_get_textmaterial_variableAnchors(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
+    /**
+     * Part of the text block placed at the anchor point: `"center"`
+     * (default), `"left"`, `"right"`, `"top"`, `"bottom"`, `"top-left"`,
+     * `"top-right"`, `"bottom-left"` or `"bottom-right"`, as MapLibre's
+     * `text-anchor`. The block is as wide as its widest line and one line
+     * height tall per line.
+     * @param {string | null} [arg0]
+     */
+    set anchor(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_textmaterial_anchor(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Whether faces seen from behind are culled. Default is false. Only a
+     * flat quad has a back the camera can see: turn it on to hide the parts
+     * of a large one that wrap over the horizon, which face away from the
+     * camera.
      * @param {boolean | null} [arg0]
      */
     set backfaceCulling(arg0) {
@@ -6819,17 +8264,6 @@ export class TextMaterial {
     set borderWidth(arg0) {
         wasm.__wbg_set_textmaterial_borderWidth(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
-    /**
-     * @param {Vec2 | null} [arg0]
-     */
-    set center(arg0) {
-        let ptr0 = 0;
-        if (!isLikeNone(arg0)) {
-            _assertClass(arg0, Vec2);
-            ptr0 = arg0.__destroy_into_raw();
-        }
-        wasm.__wbg_set_textmaterial_center(this.__wbg_ptr, ptr0);
-    }
     /**
      * @param {boolean | null} [arg0]
      */
@@ -6842,6 +8276,17 @@ export class TextMaterial {
     set color(arg0) {
         wasm.__wbg_set_textmaterial_color(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >>> 0);
     }
+    /**
+     * Extra space around the collision box, in screen pixels: one to four
+     * values, expanded like CSS padding (top, right, bottom, left). Only
+     * meaningful when `declutter` is enabled. Defaults to `[2]`.
+     * @param {Float32Array | null} [arg0]
+     */
+    set declutterPadding(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passArrayF32ToWasm0(arg0, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_textmaterial_declutterPadding(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * Placement priority for decluttering; higher wins. Only meaningful when
      * `declutter` is enabled. Defaults to `0.0`.
@@ -6850,6 +8295,16 @@ export class TextMaterial {
     set declutterPriority(arg0) {
         wasm.__wbg_set_textmaterial_declutterPriority(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Coarse placement order for decluttering, compared before
+     * `declutterPriority`: every label with a higher rank is placed before any
+     * label with a lower one, whatever their priorities. Only meaningful when
+     * `declutter` is enabled. Defaults to `0.0`.
+     * @param {number | null} [arg0]
+     */
+    set declutterRank(arg0) {
+        wasm.__wbg_set_textmaterial_declutterRank(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
     /**
      * Participate in screen-space decluttering: when labels/sprites overlap
      * on screen, lower-priority ones are hidden. Defaults to `true`; set to
@@ -6911,8 +8366,9 @@ export class TextMaterial {
     }
     /**
      * Source geometry types this appearance consumes: `"point"`, `"line"`,
-     * `"polygon"`. Defaults to `["point"]`; adding `"line"`/`"polygon"` also
-     * emits a label per line-string / polygon-ring vertex.
+     * `"polygon"`. Defaults to `["point"]`; adding `"line"` also emits a
+     * label per line string, at its first vertex, and `"polygon"` one per
+     * polygon.
      * @param {string[] | null} [arg0]
      */
     set geometryTypes(arg0) {
@@ -6937,6 +8393,23 @@ export class TextMaterial {
     set highQuality(arg0) {
         wasm.__wbg_set_textmaterial_highQuality(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
+    /**
+     * Leave this label's box out of the collision grid, so symbols placed
+     * after it may overlap it. Only meaningful when `declutter` is enabled.
+     * Defaults to `false`.
+     * @param {boolean | null} [arg0]
+     */
+    set ignorePlacement(arg0) {
+        wasm.__wbg_set_textmaterial_ignorePlacement(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
+    /**
+     * Flip a label that would otherwise read right-to-left, so names stay
+     * legible whichever way the underlying line runs. Defaults to `true`.
+     * @param {boolean | null} [arg0]
+     */
+    set keepUpright(arg0) {
+        wasm.__wbg_set_textmaterial_keepUpright(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
     /**
      * Language code for text shaping (e.g., "en", "ja", "ar"). Used for proper text rendering.
      * @param {string | null} [arg0]
@@ -6947,13 +8420,43 @@ export class TextMaterial {
         wasm.__wbg_set_textmaterial_lang(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * Line height as a multiplier of the font's natural line height
-     * (ascender − descender + line gap). Defaults to `1.0`.
+     * Extra space between characters, in ems (multiples of `size`). Not
+     * added after the last character; ignored for Arabic-script text.
+     * Negative values tighten. Defaults to `0.0`.
+     * @param {number | null} [arg0]
+     */
+    set letterSpacing(arg0) {
+        wasm.__wbg_set_textmaterial_letterSpacing(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
+    /**
+     * Distance between the baselines of a multi-line label, in ems
+     * (multiples of `size`). Defaults to the font's natural line height
+     * (ascender − descender + line gap).
      * @param {number | null} [arg0]
      */
     set lineHeight(arg0) {
         wasm.__wbg_set_textmaterial_lineHeight(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Offset perpendicular to the line, in the same units as the font size:
+     * pixels when `sizeInMeters` is false, metres when it is true. Positive is
+     * to the left of the direction of travel, which puts the name above the
+     * line. Defaults to `0.0`.
+     * @param {number | null} [arg0]
+     */
+    set lineOffset(arg0) {
+        wasm.__wbg_set_textmaterial_lineOffset(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
+    /**
+     * Largest turn, in degrees, the line may make under a label within a
+     * window of about one and a half ems before the label is dropped as
+     * unreadable. The window slides along the label, so a long gentle curve
+     * is accepted however far it turns in total. Defaults to `45.0`.
+     * @param {number | null} [arg0]
+     */
+    set maxAngle(arg0) {
+        wasm.__wbg_set_textmaterial_maxAngle(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
     /**
      * Maximum line width in ems (multiples of `size`) before text wraps at
      * word boundaries. `0.0` (the default) disables wrapping; explicit `\n`
@@ -6970,6 +8473,20 @@ export class TextMaterial {
     set offsetDepth(arg0) {
         wasm.__wbg_set_textmaterial_offsetDepth(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
+    /**
+     * Shift from the anchor point, x right and y down, in ems (multiples of
+     * `size`), as MapLibre's `text-offset`. Lies in the label's own plane, so
+     * it turns with `rotation`. Defaults to `(0, 0)`.
+     * @param {Vec2 | null} [arg0]
+     */
+    set offset(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Vec2);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_textmaterial_offset(this.__wbg_ptr, ptr0);
+    }
     /**
      * Opacity of the text
      * @param {number | null} [arg0]
@@ -6978,7 +8495,14 @@ export class TextMaterial {
         wasm.__wbg_set_textmaterial_opacity(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
     /**
-     * Outline blur radius in CSS pixels. Defaults to `0.0`.
+     * Width over which the outline's outer edge fades out, centered on that
+     * edge, in the unit of `outlineWidth`. Defaults to `0.0`.
+     * @param {number | null} [arg0]
+     */
+    set outlineBlur(arg0) {
+        wasm.__wbg_set_textmaterial_outlineBlur(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
+    /**
      * @param {number | null} [arg0]
      */
     set outlineColor(arg0) {
@@ -6992,18 +8516,50 @@ export class TextMaterial {
         wasm.__wbg_set_textmaterial_outlineOpacity(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
     /**
-     * Outline thickness measured in CSS pixels. Defaults to `0.0`.
+     * Outline thickness in 1/64 em: pixels of text drawn 64 pixels tall, so
+     * the outline keeps its proportion to the glyphs at any size. Defaults
+     * to `0.0`.
      * @param {number | null} [arg0]
      */
     set outlineWidth(arg0) {
         wasm.__wbg_set_textmaterial_outlineWidth(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
     /**
-     * Whether the label turns to follow the camera. `true` (the default)
-     * keeps it facing the viewer. `false` freezes it in the anchor's local
-     * east-north-up frame, so moving the camera never reorients it: with
-     * `textFacing: "upright"` it becomes a signboard standing on the
-     * surface, with `"flat"` a north-up label painted on it.
+     * Whether the label may be drawn over symbols placed before it:
+     * `"never"` (the default) hides it on any collision, `"always"` never
+     * does, `"cooperative"` hides it only when it collides with a `"never"`
+     * symbol. Only meaningful when `declutter` is enabled.
+     * @param {string | null} [arg0]
+     */
+    set overlap(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_textmaterial_overlap(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * How anchors are derived from line and polygon geometry: `"point"` (the
+     * default) puts a label per line string, at its first vertex, and one
+     * per polygon, `"line"` repeats labels along the line every `spacing`
+     * with the glyphs bending to follow it, `"line-center"` places a single
+     * label at the line's midpoint. Polygon rings are walked like lines.
+     * Requires `geometryTypes` to include `"line"` or `"polygon"`.
+     * @param {string | null} [arg0]
+     */
+    set placement(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_textmaterial_placement(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Whether the label turns with the camera or with the map, as MapLibre's
+     * `text-rotation-alignment` `viewport` and `map`. `true` keeps it reading
+     * left to right (a screen-aligned billboard, or a flat label yawed to the
+     * camera). `false` aligns it with the map: upright, it stays on screen but
+     * turns with the camera heading so its x-axis points east; flat, it lies
+     * north-up. Along a line, `false` makes the label follow the line, and
+     * `true` draws it straight at its anchor unless `spreadGlyphs` is set.
+     * Left unset, it is `true` for `placement: "point"` and `false` along a
+     * line, as MapLibre resolves `auto`.
      * @param {boolean | null} [arg0]
      */
     set rotateWithCamera(arg0) {
@@ -7014,8 +8570,10 @@ export class TextMaterial {
      * degrees, clockwise seen from the front. Applied on top of whatever
      * orientation `textFacing` and `rotateWithCamera` resolve to: it spins a
      * billboard on screen and turns a surface label like a compass bearing.
-     * `center` decides where inside the text the pivot sits. Defaults to
-     * `0.0`.
+     * `anchor` decides where inside the text the pivot sits. Along a line
+     * each glyph spins about its own point on the line, as MapLibre's
+     * `text-rotate` does, except for a straight label (`rotateWithCamera`
+     * without `spreadGlyphs`), which turns as a whole. Defaults to `0.0`.
      * @param {number | null} [arg0]
      */
     set rotation(arg0) {
@@ -7041,9 +8599,49 @@ export class TextMaterial {
     set size(arg0) {
         wasm.__wbg_set_textmaterial_size(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Distance between repeated labels along a line, in screen pixels, for
+     * `vector-tile` and `geojson` sources alike. Resolved per label as the
+     * camera moves: labels thin out as it pulls back and fill in as it
+     * closes, never moving, so the gap on screen stays between one and two
+     * times `spacing` across a pitched view. As MapLibre does with
+     * `symbol-spacing`, a label longer than three quarters of the spacing
+     * spreads its repeats to its own length plus a quarter of the spacing, a
+     * label within half the spacing of an earlier one with the same text is
+     * dropped, and a vector tile places labels only inside its own bounds.
+     * Defaults to `250.0`.
+     * @param {number | null} [arg0]
+     */
+    set spacing(arg0) {
+        wasm.__wbg_set_textmaterial_spacing(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
+    /**
+     * Place each glyph of an along-line label on its own instead of each
+     * word. With `rotateWithCamera: false` each glyph turns with the line
+     * under it (MapLibre's `symbol-placement: "line"`); with `true`, each
+     * glyph turns to the camera like a point label and is spaced on the
+     * screen (MapLibre's `viewport-glyph`). Can be overridden per feature
+     * from a feature evaluator. Defaults to `false`.
+     * @param {boolean | null} [arg0]
+     */
+    set spreadGlyphs(arg0) {
+        wasm.__wbg_set_textmaterial_spreadGlyphs(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
+    /**
+     * Whether this may show while its partner at the same anchor (the
+     * layer's label for a billboard, its billboard for a label) is hidden.
+     * With `false` on both, the two are placed together: both show or
+     * neither does. Only meaningful when `declutter` is enabled. Defaults to
+     * `true`.
+     * @param {boolean | null} [arg0]
+     */
+    set standalone(arg0) {
+        wasm.__wbg_set_textmaterial_standalone(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
     /**
      * Horizontal alignment of lines within a multi-line block:
-     * `"left"`, `"center"` (default), or `"right"`.
+     * `"left"`, `"center"` (default), `"right"`, or `"auto"`, which aligns
+     * towards the horizontal side of `anchor` (MapLibre's `text-justify`).
      * @param {string | null} [arg0]
      */
     set textAlign(arg0) {
@@ -7052,9 +8650,13 @@ export class TextMaterial {
         wasm.__wbg_set_textmaterial_textAlign(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * Whether the label stands up (`"upright"`, the default) or lies on the
-     * globe surface around its anchor (`"flat"`), following its curvature so
-     * it reads as painted on the surface. Pair with `rotateWithCamera`.
+     * Plane the label lies in: the screen (`"upright"`, never foreshortened)
+     * or the globe surface around its anchor (`"flat"`), following its
+     * curvature so it reads as painted on the surface. MapLibre's
+     * `text-pitch-alignment` `viewport` and `map`. Pair with
+     * `rotateWithCamera`. Left unset, it is `"flat"` when `rotateWithCamera`
+     * resolves to `false` and `"upright"` otherwise, as MapLibre resolves
+     * `auto`.
      * @param {string | null} [arg0]
      */
     set textFacing(arg0) {
@@ -7070,6 +8672,31 @@ export class TextMaterial {
         var len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_textmaterial_text(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * Frame `translate` is measured in: `"map"` (default) turns it with the
+     * camera heading so +x points east and +y south; `"viewport"` keeps it on
+     * the screen axes. MapLibre's `text-translate-anchor`.
+     * @param {string | null} [arg0]
+     */
+    set translateAnchor(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_textmaterial_translateAnchor(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Screen-pixel shift of the drawn label, x right and y down, applied after
+     * projection so it stays the same number of pixels at any distance, as
+     * MapLibre's `text-translate`. Defaults to `(0, 0)`.
+     * @param {Vec2 | null} [arg0]
+     */
+    set translate(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Vec2);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_textmaterial_translate(this.__wbg_ptr, ptr0);
+    }
     /**
      * Enable transparency and alpha blending
      * @param {boolean | null} [arg0]
@@ -7077,6 +8704,19 @@ export class TextMaterial {
     set transparent(arg0) {
         wasm.__wbg_set_textmaterial_transparent(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
+    /**
+     * Placements the declutter pass tries in order, keeping the first whose
+     * box is free, as MapLibre's `text-variable-anchor-offset`. The one in
+     * use is tried first, so a label only moves when it must. Overrides
+     * `anchor` and `offset` when not empty, except along a line. Without
+     * declutter the first is used.
+     * @param {VariableAnchor[] | null} [arg0]
+     */
+    set variableAnchors(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_textmaterial_variableAnchors(this.__wbg_ptr, ptr0, len0);
+    }
 }
 if (Symbol.dispose) TextMaterial.prototype[Symbol.dispose] = TextMaterial.prototype.free;
 
@@ -8095,6 +9735,83 @@ export class UpsamplableTerrainGeometry {
 }
 if (Symbol.dispose) UpsamplableTerrainGeometry.prototype[Symbol.dispose] = UpsamplableTerrainGeometry.prototype.free;
 
+/**
+ * One placement a label may take, as an entry of MapLibre's
+ * `text-variable-anchor-offset`.
+ */
+export class VariableAnchor {
+    static __wrap(ptr) {
+        const obj = Object.create(VariableAnchor.prototype);
+        obj.__wbg_ptr = ptr;
+        VariableAnchorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof VariableAnchor)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VariableAnchorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_variableanchor_free(ptr, 0);
+    }
+    /**
+     * Part of the text block placed at the anchor point, as `anchor`.
+     * @returns {string}
+     */
+    get anchor() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_variableanchor_anchor(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Shift from the anchor point, x right and y down, in ems. Defaults to
+     * `(0, 0)`.
+     * @returns {Vec2 | undefined}
+     */
+    get offset() {
+        const ret = wasm.__wbg_get_variableanchor_offset(this.__wbg_ptr);
+        return ret === 0 ? undefined : Vec2.__wrap(ret);
+    }
+    /**
+     * Part of the text block placed at the anchor point, as `anchor`.
+     * @param {string} arg0
+     */
+    set anchor(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_variableanchor_anchor(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Shift from the anchor point, x right and y down, in ems. Defaults to
+     * `(0, 0)`.
+     * @param {Vec2 | null} [arg0]
+     */
+    set offset(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Vec2);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_variableanchor_offset(this.__wbg_ptr, ptr0);
+    }
+}
+if (Symbol.dispose) VariableAnchor.prototype[Symbol.dispose] = VariableAnchor.prototype.free;
+
 export class Vec2 {
     static __wrap(ptr) {
         const obj = Object.create(Vec2.prototype);
@@ -8767,6 +10484,14 @@ function __wbg_get_imports() {
             const ret = arg0.value;
             return ret;
         },
+        __wbg_variableanchor_new: function(arg0) {
+            const ret = VariableAnchor.__wrap(arg0);
+            return ret;
+        },
+        __wbg_variableanchor_unwrap: function(arg0) {
+            const ret = VariableAnchor.__unwrap(arg0);
+            return ret;
+        },
         __wbindgen_cast_0000000000000001: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
@@ -8983,6 +10708,9 @@ const UintAttributeFinalization = (typeof FinalizationRegistry === 'undefined')
 const UpsamplableTerrainGeometryFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_upsamplableterraingeometry_free(ptr, 1));
+const VariableAnchorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_variableanchor_free(ptr, 1));
 const Vec2Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_vec2_free(ptr, 1));