@navaramap/engine-api 0.2.0 → 0.3.0

package/navara_wasm_api.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]
      */
@@ -1220,6 +1532,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:
@@ -1232,12 +1545,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]);
         }
@@ -1675,15 +1989,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;
     }
     /**
@@ -1714,6 +2028,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}
      */
@@ -1759,15 +2087,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;
     }
     /**
@@ -1808,15 +2136,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;
     }
     /**
@@ -2071,6 +2399,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}
      */
@@ -2099,6 +2473,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
@@ -2865,10 +3256,89 @@ export class LLE {
 }
 if (Symbol.dispose) LLE.prototype[Symbol.dispose] = LLE.prototype.free;
 
-export class ModelInternalMaterial {
-    static __wrap(ptr) {
-        const obj = Object.create(ModelInternalMaterial.prototype);
-        obj.__wbg_ptr = ptr;
+export class LineDashAtlas {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LineDashAtlasFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_linedashatlas_free(ptr, 0);
+    }
+    /**
+     * The rows as RGBA float texels, `rowTexels` wide and `rowCapacity`
+     * high. A view into WASM memory: copy it before the next allocation.
+     * @returns {Float32Array}
+     */
+    get data() {
+        const ret = wasm.linedashatlas_data(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Changes whenever a row is written into `data`.
+     * @returns {number}
+     */
+    get dataVersion() {
+        const ret = wasm.linedashatlas_dataVersion(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    constructor() {
+        const ret = wasm.linedashatlas_new();
+        this.__wbg_ptr = ret;
+        LineDashAtlasFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Returns the row holding the pattern of `dash_array` drawn with `cap`
+     * (`"butt" | "round" | "square"`), adding it on first use, and holds it
+     * until `release`. A solid line with butt ends, and a pattern the atlas
+     * cannot hold, are row `0`; the latter warns once per reason. An unknown
+     * cap warns once and draws as `"butt"`.
+     * @param {Float32Array | null | undefined} dash_array
+     * @param {string} cap
+     * @returns {number}
+     */
+    register(dash_array, cap) {
+        var ptr0 = isLikeNone(dash_array) ? 0 : passArrayF32ToWasm0(dash_array, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(cap, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.linedashatlas_register(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret >>> 0;
+    }
+    /**
+     * Ends one `register` of `row`; the last one frees the row for another
+     * pattern. A row nobody holds is left as is and warns once.
+     * @param {number} row
+     */
+    release(row) {
+        wasm.linedashatlas_release(this.__wbg_ptr, row);
+    }
+    /**
+     * Rows `data` holds; it grows when a row is added past it.
+     * @returns {number}
+     */
+    get rowCapacity() {
+        const ret = wasm.linedashatlas_rowCapacity(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * RGBA texels per row.
+     * @returns {number}
+     */
+    get rowTexels() {
+        const ret = wasm.linedashatlas_rowTexels(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) LineDashAtlas.prototype[Symbol.dispose] = LineDashAtlas.prototype.free;
+
+export class ModelInternalMaterial {
+    static __wrap(ptr) {
+        const obj = Object.create(ModelInternalMaterial.prototype);
+        obj.__wbg_ptr = ptr;
         ModelInternalMaterialFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
@@ -2970,13 +3440,6 @@ export class ModelMaterial {
         const ret = wasm.__wbg_get_modelmaterial_animationSpeed(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
-    /**
-     * @returns {boolean | undefined}
-     */
-    get applyWaterNormal() {
-        const ret = wasm.__wbg_get_modelmaterial_applyWaterNormal(this.__wbg_ptr);
-        return ret === 0xFFFFFF ? undefined : ret !== 0;
-    }
     /**
      * @returns {boolean | undefined}
      */
@@ -3037,6 +3500,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 +3596,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 +3640,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 +3668,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 +3742,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 +3792,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 +3876,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 +3914,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 +3936,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;
@@ -3582,25 +4107,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}
      */
@@ -3615,6 +4146,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`.
@@ -3624,6 +4170,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
@@ -3692,6 +4249,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}
@@ -3700,6 +4267,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}
      */
@@ -3708,9 +4285,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() {
@@ -3723,9 +4336,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() {
@@ -3734,7 +4360,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}
      */
@@ -3765,6 +4391,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}
      */
@@ -3773,27 +4440,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]
@@ -3807,6 +4472,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`.
@@ -3815,6 +4491,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
@@ -3870,6 +4556,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]
@@ -3877,6 +4572,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]
      */
@@ -3884,9 +4593,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) {
@@ -3895,9 +4632,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) {
@@ -3905,7 +4654,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]
      */
@@ -3933,12 +4682,52 @@ export class PointMaterial {
         wasm.__wbg_set_pointmaterial_size(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
     /**
-     * @param {boolean | null} [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 transparent(arg0) {
-        wasm.__wbg_set_pointmaterial_transparent(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    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]
+     */
+    set transparent(arg0) {
+        wasm.__wbg_set_pointmaterial_transparent(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
+}
 if (Symbol.dispose) PointMaterial.prototype[Symbol.dispose] = PointMaterial.prototype.free;
 
 export class PolygonGeometry {
@@ -4227,13 +5016,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}
      */
@@ -4255,6 +5037,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}
@@ -4291,6 +5081,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}
      */
@@ -4388,6 +5187,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() {
@@ -4410,6 +5218,7 @@ export class PolygonMaterial {
     }
     /**
      * Enabling this value allows using `shininess` and `specular_strength`.
+     * Has no effect on water.
      * @returns {boolean | undefined}
      */
     get specular() {
@@ -4446,28 +5255,54 @@ export class PolygonMaterial {
         return ret === 0xFFFFFF ? undefined : ret !== 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).
+     * @returns {string | undefined}
+     */
+    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;
+    }
+    /**
+     * 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_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 waterScaleNormal() {
-        const ret = wasm.__wbg_get_polygonmaterial_waterScaleNormal(this.__wbg_ptr);
+    get waveDirection() {
+        const ret = wasm.__wbg_get_polygonmaterial_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_polygonmaterial_waterSpeed(this.__wbg_ptr);
+    get waveExaggeration() {
+        const ret = wasm.__wbg_get_polygonmaterial_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_polygonmaterial_water(this.__wbg_ptr);
-        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    get waveStrength() {
+        const ret = wasm.__wbg_get_polygonmaterial_waveStrength(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
      * @returns {boolean | undefined}
@@ -4512,12 +5347,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]
      */
@@ -4536,6 +5365,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]
@@ -4565,6 +5401,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]
      */
@@ -4650,6 +5494,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) {
@@ -4669,6 +5521,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) {
@@ -4701,25 +5554,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]
@@ -4800,15 +5674,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;
     }
     /**
@@ -4832,6 +5706,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}
      */
@@ -4877,15 +5765,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;
     }
     /**
@@ -4926,15 +5814,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;
     }
     /**
@@ -5017,15 +5905,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;
     }
     /**
@@ -5042,6 +5930,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}
      */
@@ -5087,15 +5989,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;
     }
     /**
@@ -5136,15 +6038,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;
     }
     /**
@@ -5212,6 +6114,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}
      */
@@ -5233,6 +6152,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}
@@ -5396,6 +6331,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]
      */
@@ -5414,6 +6362,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]
@@ -5615,6 +6575,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}
      */
@@ -5625,73 +6596,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;
     }
     /**
@@ -5795,18 +6808,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}
@@ -5849,6 +6868,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[]}
      */
@@ -5876,6 +6930,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
      */
@@ -5885,64 +6949,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 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 elevationOffset(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationOffset(this.__wbg_ptr, 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
@@ -6032,16 +7136,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
@@ -6079,6 +7189,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;
 
@@ -6250,6 +7391,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}
      */
@@ -6349,6 +7497,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
@@ -6398,12 +7576,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
@@ -6447,6 +7679,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;
 
@@ -6462,10 +7735,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() {
@@ -6493,13 +7783,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}
      */
@@ -6514,6 +7797,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`.
@@ -6523,6 +7821,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
@@ -6596,8 +7905,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() {
@@ -6628,6 +7938,25 @@ export class TextMaterial {
         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 keepUpright() {
+        const ret = wasm.__wbg_get_textmaterial_keepUpright(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
     /**
      * Language code for text shaping (e.g., "en", "ja", "ar"). Used for proper text rendering.
      * @returns {string | undefined}
@@ -6642,14 +7971,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`
@@ -6668,6 +8030,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}
@@ -6677,7 +8049,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() {
@@ -6693,7 +8073,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() {
@@ -6701,11 +8083,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() {
@@ -6717,8 +8137,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() {
@@ -6748,9 +8170,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() {
@@ -6763,9 +8228,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() {
@@ -6789,6 +8258,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}
@@ -6798,10 +8292,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) {
@@ -6825,17 +8349,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]
      */
@@ -6848,6 +8361,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`.
@@ -6856,6 +8380,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
@@ -6917,8 +8451,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) {
@@ -6943,6 +8478,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]
@@ -6953,13 +8505,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`
@@ -6976,6 +8558,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]
@@ -6984,7 +8580,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) {
@@ -6998,18 +8601,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) {
@@ -7020,8 +8655,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) {
@@ -7047,9 +8684,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) {
@@ -7058,9 +8735,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) {
@@ -7076,6 +8757,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]
@@ -7083,6 +8789,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;
 
@@ -7897,6 +9616,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);
@@ -8186,17 +9982,20 @@ export function buildPolylineGeometry(coordinates, geocentric, ring, material) {
 
 /**
  * Run one placement pass. Returns a `hidden` flag (0 or 1) per candidate, in the
- * same order as the input slice.
+ * same order as the input slice. Of a group of variable-anchor rows, at most
+ * one is shown: the first that fits.
  *
  * `candidates` is a packed `f64` slice of `n * CANDIDATE_STRIDE` values (see the
  * module docs); `view` and `proj` are column-major 4×4 matrices (16 values each).
- * `padding_px` pads every box; `hysteresis_px` is the collision-test shrink
- * applied only to currently-shown labels.
+ * `horizon_min_height` is the renderer's `nvrHorizonMinHeight`, which the
+ * horizon test shrinks the ellipsoid by. `hysteresis_px` is the
+ * collision-test shrink applied only to currently-shown labels.
  *
  * The result is *hidden-by-default*: only a label that claimed space inside the
  * tracked area (viewport + grid margin) comes back shown. Off-screen and
  * GPU-culled labels stay hidden so they cannot fade in unseen and then pan into
- * view at full opacity.
+ * view at full opacity. An [`Overlap::Always`] label is the exception: it can
+ * never lose, so it is always shown and has no fade-in to wait for.
  * @param {Float64Array} candidates
  * @param {Float64Array} view
  * @param {Float64Array} proj
@@ -8207,18 +10006,18 @@ export function buildPolylineGeometry(coordinates, geocentric, ring, material) {
  * @param {number} width_px
  * @param {number} height_px
  * @param {number} fov_rad
- * @param {number} padding_px
+ * @param {number} horizon_min_height
  * @param {number} hysteresis_px
  * @returns {Uint8Array}
  */
-export function declutterPlace(candidates, view, proj, camera_x, camera_y, camera_z, near, width_px, height_px, fov_rad, padding_px, hysteresis_px) {
+export function declutterPlace(candidates, view, proj, camera_x, camera_y, camera_z, near, width_px, height_px, fov_rad, horizon_min_height, hysteresis_px) {
     const ptr0 = passArrayF64ToWasm0(candidates, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArrayF64ToWasm0(view, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
     const ptr2 = passArrayF64ToWasm0(proj, wasm.__wbindgen_malloc);
     const len2 = WASM_VECTOR_LEN;
-    const ret = wasm.declutterPlace(ptr0, len0, ptr1, len1, ptr2, len2, camera_x, camera_y, camera_z, near, width_px, height_px, fov_rad, padding_px, hysteresis_px);
+    const ret = wasm.declutterPlace(ptr0, len0, ptr1, len1, ptr2, len2, camera_x, camera_y, camera_z, near, width_px, height_px, fov_rad, horizon_min_height, hysteresis_px);
     var v4 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v4;
@@ -8386,6 +10185,96 @@ export function getWGS84SemiMinorAxis() {
     return ret;
 }
 
+/**
+ * Place along-line anchors for meshes that lay no label along the line — a
+ * sprite is one quad at its anchor: whether each one's level is the one on
+ * screen, and the box its quad covers there for the declutter pass.
+ *
+ * The level is chosen by the quad's extent *along its line*, measured in the
+ * quad's own frame as MapLibre measures an icon: its local +y is turned
+ * `rotation` from north and the line runs at `bearing`, so a quad turned to
+ * follow its line is measured by its height, whatever its image's aspect.
+ *
+ * The box mirrors `nvr_quadBasis`, so a quad turned by its line, its style or
+ * its facing claims the space it is drawn over rather than its unrotated
+ * rectangle.
+ *
+ * `anchors` is packed [`LINE_ANCHOR_STRIDE`] values per anchor. Returns
+ * [`LINE_ANCHOR_RESULT_STRIDE`] values per anchor, in input order.
+ * @param {Float64Array} anchors
+ * @param {Float64Array} view
+ * @param {number} height_px
+ * @param {number} fov_rad
+ * @param {number} spacing_px
+ * @returns {Float64Array}
+ */
+export function lineAnchorPlace(anchors, view, height_px, fov_rad, spacing_px) {
+    const ptr0 = passArrayF64ToWasm0(anchors, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(view, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.lineAnchorPlace(ptr0, len0, ptr1, len1, height_px, fov_rad, spacing_px);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * Whether a label is short enough to sit on its line, using nothing but the
+ * anchor, the label's width and the line's extent.
+ *
+ * Returns one byte per label: `1` fits, `0` does not. See the module docs for
+ * why this is worth a phase of its own.
+ * @param {Float64Array} labels
+ * @param {Float64Array} view
+ * @param {number} height_px
+ * @param {number} fov_rad
+ * @param {number} spacing_px
+ * @returns {Uint8Array}
+ */
+export function lineLabelFit(labels, view, height_px, fov_rad, spacing_px) {
+    const ptr0 = passArrayF64ToWasm0(labels, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(view, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.lineLabelFit(ptr0, len0, ptr1, len1, height_px, fov_rad, spacing_px);
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * Place text labels along their lines.
+ *
+ * `labels` is a packed `f64` slice of `n * LINE_LABEL_STRIDE` values (see the
+ * module docs); `paths` holds each label's samples as `2 * samples` `f32`
+ * values, east then north metres relative to its anchor. `view` is a
+ * column-major 4x4 matrix.
+ *
+ * Returns [`LINE_LABEL_RESULT_STRIDE`] values per label, in input order; see
+ * the module docs for the layout. `spacing_px` is the layer's `spacing`.
+ * @param {Float64Array} labels
+ * @param {Float32Array} paths
+ * @param {number} samples_per_label
+ * @param {Float64Array} view
+ * @param {number} height_px
+ * @param {number} fov_rad
+ * @param {number} spacing_px
+ * @returns {Float64Array}
+ */
+export function lineLabelPlace(labels, paths, samples_per_label, view, height_px, fov_rad, spacing_px) {
+    const ptr0 = passArrayF64ToWasm0(labels, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(paths, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(view, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.lineLabelPlace(ptr0, len0, ptr1, len1, samples_per_label, ptr2, len2, height_px, fov_rad, spacing_px);
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v4;
+}
+
 /**
  * @param {Vec3} origin
  * @returns {Float64Array}
@@ -8856,8 +10745,8 @@ function __wbg_get_imports() {
             const ret = LLE.__wrap(arg0);
             return ret;
         },
-        __wbg_log_12e4fe682663fedd: function(arg0, arg1) {
-            console.log(getStringFromWasm0(arg0, arg1));
+        __wbg_log_e6372b4fbfc9f81e: function(arg0) {
+            console.log(arg0);
         },
         __wbg_new_078f4f4b1eaabdec: function(arg0) {
             const ret = new Float32Array(arg0);
@@ -8887,6 +10776,10 @@ function __wbg_get_imports() {
             const ret = new Uint32Array(arg0, arg1 >>> 0, arg2 >>> 0);
             return ret;
         },
+        __wbg_new_with_byte_offset_and_length_1aca16330a3ebb0a: function(arg0, arg1, arg2) {
+            const ret = new Float32Array(arg0, arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        },
         __wbg_new_with_byte_offset_and_length_8a19fd6506a908ea: function(arg0, arg1, arg2) {
             const ret = new Float64Array(arg0, arg1 >>> 0, arg2 >>> 0);
             return ret;
@@ -8944,6 +10837,17 @@ 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;
+        },
+        __wbg_warn_917d7f727ab78481: function(arg0) {
+            console.warn(arg0);
+        },
         __wbindgen_cast_0000000000000001: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
@@ -9058,6 +10962,9 @@ const HillshadeMaterialFinalization = (typeof FinalizationRegistry === 'undefine
 const LLEFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_lle_free(ptr, 1));
+const LineDashAtlasFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_linedashatlas_free(ptr, 1));
 const ModelInternalMaterialFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_modelinternalmaterial_free(ptr, 1));
@@ -9151,6 +11058,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));