@navaramap/engine 0.2.1 → 0.3.0

package/navara_wasm.js

@@ -163,10 +163,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() {
@@ -174,9 +189,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() {
@@ -188,15 +206,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}
      */
@@ -211,6 +220,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`.
@@ -220,6 +244,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
@@ -268,8 +303,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() {
@@ -288,6 +324,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}
@@ -296,6 +342,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}
      */
@@ -304,9 +360,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() {
@@ -315,7 +418,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}
      */
@@ -338,6 +441,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}
@@ -346,6 +460,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}
      */
@@ -372,19 +539,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) {
@@ -392,19 +573,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]
      */
@@ -417,6 +585,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`.
@@ -425,6 +604,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
@@ -465,8 +654,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) {
@@ -480,6 +670,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]
@@ -487,6 +686,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]
      */
@@ -494,9 +707,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) {
@@ -504,7 +755,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]
      */
@@ -524,6 +775,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]
@@ -531,6 +792,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]
      */
@@ -1365,6 +1677,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:
@@ -1377,12 +1690,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]);
         }
@@ -2387,15 +2701,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;
     }
     /**
@@ -2426,6 +2740,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}
      */
@@ -2471,15 +2799,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;
     }
     /**
@@ -2520,15 +2848,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;
     }
     /**
@@ -2787,18 +3115,6 @@ export class Core {
         const ret = wasm.core_getGlobeColor(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
-    /**
-     * @returns {Float32Array | undefined}
-     */
-    getGlobeElevationColormap() {
-        const ret = wasm.core_getGlobeElevationColormap(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 {boolean | undefined}
      */
@@ -2913,6 +3229,21 @@ export class Core {
         const ret = wasm.core_getTerrainDemBytes(this.__wbg_ptr, handle);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * `[scale, relativeHeight]` of the surface rendered from `source_id`,
+     * `[1, 0]` when the exaggerated terrain layer does not render it.
+     * Used by `view.sampleTerrainMostDetailed` to return rendered heights.
+     * @param {string} source_id
+     * @returns {Float64Array}
+     */
+    getTerrainExaggerationForSource(source_id) {
+        const ptr0 = passStringToWasm0(source_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.core_getTerrainExaggerationForSource(this.__wbg_ptr, ptr0, len0);
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
     /**
      * @param {bigint} handle
      * @returns {TransferableTile | undefined}
@@ -2956,10 +3287,16 @@ export class Core {
         return v1;
     }
     /**
+     * Get the current zoom level of the camera.
+     *
+     * # Arguments
+     * * `tile_size_px` - Optional tile size for zoom calculation. Defaults to 256.
+     *                    Use 512 for MapLibre-compatible zoom values.
+     * @param {number | null} [tile_size_px]
      * @returns {number | undefined}
      */
-    getZoomLevel() {
-        const ret = wasm.core_getZoomLevel(this.__wbg_ptr);
+    getZoomLevel(tile_size_px) {
+        const ret = wasm.core_getZoomLevel(this.__wbg_ptr, !isLikeNone(tile_size_px), isLikeNone(tile_size_px) ? 0 : tile_size_px);
         return ret[0] === 0 ? undefined : ret[1];
     }
     /**
@@ -3346,14 +3683,6 @@ export class Core {
     setGlobeColor(value) {
         wasm.core_setGlobeColor(this.__wbg_ptr, value);
     }
-    /**
-     * @param {Float32Array} value
-     */
-    setGlobeElevationColormap(value) {
-        const ptr0 = passArrayF32ToWasm0(value, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.core_setGlobeElevationColormap(this.__wbg_ptr, ptr0, len0);
-    }
     /**
      * @param {boolean} value
      */
@@ -3415,6 +3744,14 @@ export class Core {
     setMaxPendingRequests(value) {
         wasm.core_setMaxPendingRequests(this.__wbg_ptr, value);
     }
+    /**
+     * Caps the number of delegated worker tasks in flight across all task
+     * kinds (terrain mesh, MVT parse, polygon / polyline build, ...).
+     * @param {number} value
+     */
+    setMaxWorkerTasks(value) {
+        wasm.core_setMaxWorkerTasks(this.__wbg_ptr, value);
+    }
     /**
      * Overrides GPU cost estimates that only the JS side knows precisely
      * (the composite atlas size depends on device options).
@@ -3440,14 +3777,33 @@ export class Core {
     setTileMeshPrepared(handle) {
         wasm.core_setTileMeshPrepared(this.__wbg_ptr, handle);
     }
+    /**
+     * Reports the worker-pool tasks in flight outside delegated tasks (image
+     * decodes, Draco, descriptor / plugin tasks, tasks cancelled mid-run);
+     * they take from the `setMaxWorkerTasks` cap.
+     * @param {number} value
+     */
+    setWorkerExternalLoad(value) {
+        wasm.core_setWorkerExternalLoad(this.__wbg_ptr, value);
+    }
+    /**
+     * Pauses or resumes worker intake: while paused, nothing that runs on
+     * the worker pool is handed out, model feature adds and image fetches
+     * included.
+     * @param {boolean} paused
+     */
+    setWorkerIntakePaused(paused) {
+        wasm.core_setWorkerIntakePaused(this.__wbg_ptr, paused);
+    }
     start() {
         wasm.core_start(this.__wbg_ptr);
     }
     /**
      * @param {bigint} bits
+     * @param {number} handle
      */
-    triggerDataRequesterFailed(bits) {
-        wasm.core_triggerDataRequesterFailed(this.__wbg_ptr, bits);
+    triggerDataRequesterFailed(bits, handle) {
+        wasm.core_triggerDataRequesterFailed(this.__wbg_ptr, bits, handle);
     }
     /**
      * @param {bigint} bits
@@ -3521,14 +3877,31 @@ export class Core {
         wasm.core_updateSource(this.__wbg_ptr, ptr0, len0, source);
     }
     /**
-     * Monotonic revision that changes only when the vector-tile resolution could have
-     * changed. The web renderer reads it once per frame and skips the per-terrain-tile
-     * `getVectorTileStates` calls while it is unchanged.
-     * @returns {number}
+     * Compute camera viewing distance required to achieve a target zoom level.
+     *
+     * This is the inverse of `getZoomLevel`. Given a Web Mercator zoom level
+     * and latitude, returns the camera-to-target viewing distance in meters
+     * that would produce that zoom level.
+     *
+     * Uses the current viewport height and camera FOV from the engine state.
+     *
+     * # Arguments
+     * * `zoom_level` - Target Web Mercator zoom level
+     * * `lat_deg` - Latitude in degrees (affects scale due to Web Mercator projection)
+     * * `tile_size_px` - Tile size for zoom calculation (defaults to 256)
+     * * `fov_rad` - Optional FOV override in radians
+     *
+     * # Returns
+     * Camera viewing distance to target in meters, or `undefined` if inputs are invalid
+     * @param {number} zoom_level
+     * @param {number} lat_deg
+     * @param {number | null} [tile_size_px]
+     * @param {number | null} [fov_rad]
+     * @returns {number | undefined}
      */
-    vectorRevision() {
-        const ret = wasm.core_vectorRevision(this.__wbg_ptr);
-        return ret >>> 0;
+    zoomLevelToCameraDistance(zoom_level, lat_deg, tile_size_px, fov_rad) {
+        const ret = wasm.core_zoomLevelToCameraDistance(this.__wbg_ptr, zoom_level, lat_deg, !isLikeNone(tile_size_px), isLikeNone(tile_size_px) ? 0 : tile_size_px, !isLikeNone(fov_rad), isLikeNone(fov_rad) ? 0 : fov_rad);
+        return ret[0] === 0 ? undefined : ret[1];
     }
     /**
      * @returns {string}
@@ -3634,10 +4007,10 @@ export class DataRequestEvent {
     }
     /**
      * Fetch urgency: 0 is the most urgent (see `Priority::rank`). The web
-     * side keeps its pending fetch queue sorted by this. Requests without an
-     * ECS `Priority` (tileset / PMTiles bootstrap reads, 3D Tiles content)
-     * rank as `Extreme`, matching the engine sender that dispatches them
-     * ahead of the prioritized ones.
+     * side starts every fetch right away and passes this on as the browser's
+     * fetch priority hint. Requests without an ECS `Priority` (tileset /
+     * PMTiles bootstrap reads, 3D Tiles content) rank as `Extreme`, matching
+     * the engine sender that dispatches them ahead of the prioritized ones.
      * @returns {number}
      */
     get priority() {
@@ -3737,10 +4110,10 @@ export class DataRequestEvent {
     }
     /**
      * Fetch urgency: 0 is the most urgent (see `Priority::rank`). The web
-     * side keeps its pending fetch queue sorted by this. Requests without an
-     * ECS `Priority` (tileset / PMTiles bootstrap reads, 3D Tiles content)
-     * rank as `Extreme`, matching the engine sender that dispatches them
-     * ahead of the prioritized ones.
+     * side starts every fetch right away and passes this on as the browser's
+     * fetch priority hint. Requests without an ECS `Priority` (tileset /
+     * PMTiles bootstrap reads, 3D Tiles content) rank as `Extreme`, matching
+     * the engine sender that dispatches them ahead of the prioritized ones.
      * @param {number} arg0
      */
     set priority(arg0) {
@@ -4561,18 +4934,64 @@ export class ElevationHeatmapMaterial {
         wasm.__wbg_elevationheatmapmaterial_free(ptr, 0);
     }
     /**
-     * @returns {number | undefined}
+     * 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 logBoundary() {
-        const ret = wasm.__wbg_get_elevationheatmapmaterial_logBoundary(this.__wbg_ptr);
-        return ret[0] === 0 ? undefined : ret[1];
+    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;
     }
     /**
-     * @returns {boolean | undefined}
+     * 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 logarithmic() {
-        const ret = wasm.__wbg_get_elevationheatmapmaterial_logarithmic(this.__wbg_ptr);
-        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    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}
+     */
+    get logBoundary() {
+        const ret = wasm.__wbg_get_elevationheatmapmaterial_logBoundary(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @returns {boolean | undefined}
+     */
+    get logarithmic() {
+        const ret = wasm.__wbg_get_elevationheatmapmaterial_logarithmic(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
     /**
      * @returns {number | undefined}
@@ -4588,6 +5007,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]
      */
@@ -5003,6 +5456,13 @@ export class Events {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * @returns {TerrainExaggerationUpdatedEvent | undefined}
+     */
+    take_terrain_exaggeration_updated() {
+        const ret = wasm.events_take_terrain_exaggeration_updated(this.__wbg_ptr);
+        return ret === 0 ? undefined : TerrainExaggerationUpdatedEvent.__wrap(ret);
+    }
     /**
      * @returns {EntityEvent[]}
      */
@@ -5039,6 +5499,15 @@ export class Events {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * @returns {BigUint64Array}
+     */
+    take_vector_drape_changed() {
+        const ret = wasm.events_take_vector_drape_changed(this.__wbg_ptr);
+        var v1 = getArrayU64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
     /**
      * @returns {WorkerTaskDelegatedEvent[]}
      */
@@ -5356,6 +5825,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}
      */
@@ -5432,17 +5908,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}
@@ -5521,12 +5986,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;
@@ -5538,16 +6000,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
@@ -6020,6 +6472,15 @@ export class Mesh {
         const ret = wasm.__wbg_get_mesh_fill_quadrants(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Per-vertex terrain height handle (meters, unexaggerated). `None` for a
+     * flat tile, whose vertices all sit at height 0.
+     * @returns {number | undefined}
+     */
+    get heights() {
+        const ret = wasm.__wbg_get_mesh_heights(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * @returns {number}
      */
@@ -6027,6 +6488,21 @@ export class Mesh {
         const ret = wasm.__wbg_get_mesh_indices(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @returns {number}
+     */
+    get max_height() {
+        const ret = wasm.__wbg_get_mesh_max_height(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Range of `heights` (both 0 for a flat tile).
+     * @returns {number}
+     */
+    get min_height() {
+        const ret = wasm.__wbg_get_mesh_min_height(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Per-vertex normals handle (terrain only).
      * @returns {number | undefined}
@@ -6042,6 +6518,14 @@ export class Mesh {
         const ret = wasm.__wbg_get_mesh_render_order(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Skirt per-vertex terrain height handle; set whenever `skirt_vertices` is.
+     * @returns {number | undefined}
+     */
+    get skirt_heights() {
+        const ret = wasm.__wbg_get_mesh_skirt_heights(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * Skirt indices handle.
      * @returns {number | undefined}
@@ -6117,12 +6601,33 @@ export class Mesh {
     set fill_quadrants(arg0) {
         wasm.__wbg_set_mesh_fill_quadrants(this.__wbg_ptr, arg0);
     }
+    /**
+     * Per-vertex terrain height handle (meters, unexaggerated). `None` for a
+     * flat tile, whose vertices all sit at height 0.
+     * @param {number | null} [arg0]
+     */
+    set heights(arg0) {
+        wasm.__wbg_set_mesh_heights(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >> 0);
+    }
     /**
      * @param {number} arg0
      */
     set indices(arg0) {
         wasm.__wbg_set_mesh_indices(this.__wbg_ptr, arg0);
     }
+    /**
+     * @param {number} arg0
+     */
+    set max_height(arg0) {
+        wasm.__wbg_set_mesh_max_height(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Range of `heights` (both 0 for a flat tile).
+     * @param {number} arg0
+     */
+    set min_height(arg0) {
+        wasm.__wbg_set_mesh_min_height(this.__wbg_ptr, arg0);
+    }
     /**
      * Per-vertex normals handle (terrain only).
      * @param {number | null} [arg0]
@@ -6136,6 +6641,13 @@ export class Mesh {
     set render_order(arg0) {
         wasm.__wbg_set_mesh_render_order(this.__wbg_ptr, arg0);
     }
+    /**
+     * Skirt per-vertex terrain height handle; set whenever `skirt_vertices` is.
+     * @param {number | null} [arg0]
+     */
+    set skirt_heights(arg0) {
+        wasm.__wbg_set_mesh_skirt_heights(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >> 0);
+    }
     /**
      * Skirt indices handle.
      * @param {number | null} [arg0]
@@ -6598,13 +7110,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}
      */
@@ -6665,6 +7170,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}
      */
@@ -6752,6 +7266,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() {
@@ -6795,6 +7310,7 @@ export class ModelMaterial {
     }
     /**
      * Enabling this value allows using `shininess` and `specular_strength`.
+     * Has no effect on water.
      * @returns {boolean | undefined}
      */
     get specular() {
@@ -6822,28 +7338,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]
@@ -6870,12 +7412,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]
      */
@@ -6926,6 +7462,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]
      */
@@ -7002,6 +7546,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) {
@@ -7039,6 +7584,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) {
@@ -7060,25 +7606,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;
@@ -7674,25 +8241,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}
      */
@@ -7707,6 +8280,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`.
@@ -7716,6 +8304,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
@@ -7784,6 +8383,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}
@@ -7792,6 +8401,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}
      */
@@ -7800,9 +8419,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() {
@@ -7815,9 +8470,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() {
@@ -7826,7 +8494,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}
      */
@@ -7858,34 +8526,73 @@ export class PointMaterial {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * @returns {boolean | undefined}
-     */
-    get transparent() {
-        const ret = wasm.__wbg_get_pointmaterial_transparent(this.__wbg_ptr);
-        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]
+     * 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}
      */
-    set backfaceCulling(arg0) {
-        wasm.__wbg_set_pointmaterial_backfaceCulling(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    get spacing() {
+        const ret = wasm.__wbg_get_pointmaterial_spacing(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
-     * 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]
+     * 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}
      */
-    set center(arg0) {
-        let ptr0 = 0;
-        if (!isLikeNone(arg0)) {
-            _assertClass(arg0, Vec2);
-            ptr0 = arg0.__destroy_into_raw();
+    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);
         }
-        wasm.__wbg_set_pointmaterial_center(this.__wbg_ptr, ptr0);
+        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}
+     */
+    get transparent() {
+        const ret = wasm.__wbg_get_pointmaterial_transparent(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * 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_pointmaterial_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_pointmaterial_backfaceCulling(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
     }
     /**
      * @param {boolean | null} [arg0]
@@ -7899,6 +8606,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`.
@@ -7907,6 +8625,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
@@ -7962,6 +8690,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]
@@ -7969,6 +8706,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]
      */
@@ -7976,9 +8727,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) {
@@ -7987,9 +8766,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) {
@@ -7997,7 +8788,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]
      */
@@ -8024,6 +8815,46 @@ export class PointMaterial {
     set size(arg0) {
         wasm.__wbg_set_pointmaterial_size(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
     }
+    /**
+     * Distance between repeated anchors along a line, in screen pixels, for
+     * `vector-tile` and `geojson` sources alike. Resolved per anchor as the
+     * camera moves: anchors thin out as it pulls back and fill in as it
+     * closes, never moving, so the gap on screen stays between one and two
+     * times `spacing` across a pitched view. As MapLibre does with
+     * `symbol-spacing`, a sprite wider than three quarters of the spacing
+     * spreads its repeats to its width plus a quarter of the spacing, and a
+     * vector tile places anchors only inside its own bounds. Only used by
+     * `placement: "line"`. Defaults to `250.0`.
+     * @param {number | null} [arg0]
+     */
+    set spacing(arg0) {
+        wasm.__wbg_set_pointmaterial_spacing(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : Math.fround(arg0));
+    }
+    /**
+     * Frame `translate` is measured in: `"map"` (default) turns it with the
+     * camera heading so +x points east and +y south; `"viewport"` keeps it on
+     * the screen axes. MapLibre's `icon-translate-anchor`.
+     * @param {string | null} [arg0]
+     */
+    set translateAnchor(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_pointmaterial_translateAnchor(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Screen-pixel shift of the drawn quad, x right and y down, applied after
+     * projection so it stays the same number of pixels at any distance, as
+     * MapLibre's `icon-translate`. Defaults to `(0, 0)`.
+     * @param {Vec2 | null} [arg0]
+     */
+    set translate(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Vec2);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_pointmaterial_translate(this.__wbg_ptr, ptr0);
+    }
     /**
      * @param {boolean | null} [arg0]
      */
@@ -8416,13 +9247,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}
      */
@@ -8444,6 +9268,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}
@@ -8480,6 +9312,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}
      */
@@ -8577,6 +9418,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() {
@@ -8599,6 +9449,7 @@ export class PolygonMaterial {
     }
     /**
      * Enabling this value allows using `shininess` and `specular_strength`.
+     * Has no effect on water.
      * @returns {boolean | undefined}
      */
     get specular() {
@@ -8635,28 +9486,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}
@@ -8701,12 +9578,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]
      */
@@ -8725,6 +9596,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]
@@ -8754,6 +9632,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]
      */
@@ -8839,6 +9725,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) {
@@ -8858,6 +9752,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) {
@@ -8890,25 +9785,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]
@@ -8978,6 +9894,14 @@ export class PolygonMesh {
         const ret = wasm.__wbg_get_polygonmesh_outline_geometry(this.__wbg_ptr);
         return ret === 0 ? undefined : TransferablePolygonOutlineGeometry.__wrap(ret);
     }
+    /**
+     * Whether the polygon should be rendered as a texturized draped feature
+     * @returns {boolean}
+     */
+    get should_be_texturized() {
+        const ret = wasm.__wbg_get_polygonmesh_should_be_texturized(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * @returns {Transform}
      */
@@ -9035,6 +9959,13 @@ export class PolygonMesh {
         }
         wasm.__wbg_set_polygonmesh_outline_geometry(this.__wbg_ptr, ptr0);
     }
+    /**
+     * Whether the polygon should be rendered as a texturized draped feature
+     * @param {boolean} arg0
+     */
+    set should_be_texturized(arg0) {
+        wasm.__wbg_set_polygonmesh_should_be_texturized(this.__wbg_ptr, arg0);
+    }
     /**
      * @param {Transform} arg0
      */
@@ -9116,15 +10047,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;
     }
     /**
@@ -9148,6 +10079,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}
      */
@@ -9193,15 +10138,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;
     }
     /**
@@ -9242,15 +10187,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;
     }
     /**
@@ -9333,15 +10278,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;
     }
     /**
@@ -9358,6 +10303,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}
      */
@@ -9403,15 +10362,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;
     }
     /**
@@ -9452,15 +10411,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;
     }
     /**
@@ -9534,6 +10493,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}
      */
@@ -9555,6 +10531,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}
@@ -9718,6 +10710,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]
      */
@@ -9736,6 +10741,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]
@@ -10476,6 +11493,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}
      */
@@ -10486,73 +11514,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;
     }
     /**
@@ -10656,18 +11726,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}
@@ -10710,6 +11786,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[]}
      */
@@ -10737,6 +11848,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
      */
@@ -10746,64 +11867,104 @@ export class RasterTileInternalMaterial {
         wasm.__wbg_set_rastertileinternalmaterial_colors(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * @param {Float64Array} arg0
      */
-    set elevationBScaler(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationBScaler(this.__wbg_ptr, arg0);
+    set elevationBScalers(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationBScalers(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * @param {Float64Array} arg0
      */
-    set elevationBoundary(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationBoundary(this.__wbg_ptr, arg0);
+    set elevationBoundaries(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationBoundaries(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * @param {Float64Array} arg0
      */
-    set elevationEpsilon(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationEpsilon(this.__wbg_ptr, arg0);
+    set elevationEpsilons(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationEpsilons(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * @param {Float64Array} arg0
      */
-    set elevationGScaler(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationGScaler(this.__wbg_ptr, arg0);
+    set elevationGScalers(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationGScalers(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * Per-layer filter modes: "linear" or "nearest"
+     * @param {string[]} arg0
      */
-    set elevationMaxHeight(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationMaxHeight(this.__wbg_ptr, arg0);
+    set elevationHeatmapFilters(arg0) {
+        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationHeatmapFilters(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * Per-layer maximum heights for elevation normalization
+     * @param {Float64Array} arg0
      */
-    set elevationMaxOffset(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationMaxOffset(this.__wbg_ptr, arg0);
+    set elevationMaxHeights(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationMaxHeights(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * @param {Float64Array} arg0
      */
-    set elevationMinHeight(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationMinHeight(this.__wbg_ptr, arg0);
+    set elevationMaxOffsets(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationMaxOffsets(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * Per-layer minimum heights for elevation normalization
+     * @param {Float64Array} arg0
      */
-    set elevationMinOffset(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationMinOffset(this.__wbg_ptr, arg0);
+    set elevationMinHeights(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationMinHeights(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} arg0
+     * @param {Float64Array} arg0
      */
-    set elevationOffset(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationOffset(this.__wbg_ptr, arg0);
+    set elevationMinOffsets(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationMinOffsets(this.__wbg_ptr, ptr0, len0);
     }
     /**
+     * @param {Float64Array} arg0
+     */
+    set elevationOffsets(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationOffsets(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Per-layer DEM decoder parameters
+     * @param {Float64Array} arg0
+     */
+    set elevationRScalers(arg0) {
+        const ptr0 = passArrayF64ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_rastertileinternalmaterial_elevationRScalers(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Speed in m/s of the current carrying the waves on the watermask's water
+     * along `waveDirection`.
      * @param {number} arg0
      */
-    set elevationRScaler(arg0) {
-        wasm.__wbg_set_rastertileinternalmaterial_elevationRScaler(this.__wbg_ptr, arg0);
+    set flowSpeed(arg0) {
+        wasm.__wbg_set_rastertileinternalmaterial_flowSpeed(this.__wbg_ptr, arg0);
     }
     /**
      * @param {number} arg0
@@ -10893,16 +12054,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
@@ -10940,6 +12107,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;
 
@@ -11807,6 +13005,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}
      */
@@ -12172,6 +13377,73 @@ export class SourceDescription {
 }
 if (Symbol.dispose) SourceDescription.prototype[Symbol.dispose] = SourceDescription.prototype.free;
 
+/**
+ * The terrain exaggeration in effect from this frame on (`h' = (h -
+ * relative_height) * scale + relative_height`), emitted when it changes.
+ */
+export class TerrainExaggerationUpdatedEvent {
+    static __wrap(ptr) {
+        const obj = Object.create(TerrainExaggerationUpdatedEvent.prototype);
+        obj.__wbg_ptr = ptr;
+        TerrainExaggerationUpdatedEventFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TerrainExaggerationUpdatedEventFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_terrainexaggerationupdatedevent_free(ptr, 0);
+    }
+    /**
+     * Height (never positive) the ellipsoid is shrunk by for horizon culling
+     * so that terrain sunk below it stays visible.
+     * @returns {number}
+     */
+    get horizon_minimum_height() {
+        const ret = wasm.__wbg_get_terrainexaggerationupdatedevent_horizon_minimum_height(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get relative_height() {
+        const ret = wasm.__wbg_get_terrainexaggerationupdatedevent_relative_height(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get scale() {
+        const ret = wasm.__wbg_get_terrainexaggerationupdatedevent_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Height (never positive) the ellipsoid is shrunk by for horizon culling
+     * so that terrain sunk below it stays visible.
+     * @param {number} arg0
+     */
+    set horizon_minimum_height(arg0) {
+        wasm.__wbg_set_terrainexaggerationupdatedevent_horizon_minimum_height(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set relative_height(arg0) {
+        wasm.__wbg_set_terrainexaggerationupdatedevent_relative_height(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set scale(arg0) {
+        wasm.__wbg_set_terrainexaggerationupdatedevent_scale(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) TerrainExaggerationUpdatedEvent.prototype[Symbol.dispose] = TerrainExaggerationUpdatedEvent.prototype.free;
+
 export class TerrainHeightRangeUpdatedEvent {
     static __wrap(ptr) {
         const obj = Object.create(TerrainHeightRangeUpdatedEvent.prototype);
@@ -12348,6 +13620,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
@@ -12397,12 +13699,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
@@ -12446,6 +13802,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;
 
@@ -12552,10 +13949,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() {
@@ -12583,13 +13997,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}
      */
@@ -12604,6 +14011,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`.
@@ -12613,6 +14035,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
@@ -12686,8 +14119,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() {
@@ -12718,6 +14152,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}
@@ -12732,14 +14185,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`
@@ -12758,6 +14244,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}
@@ -12767,7 +14263,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() {
@@ -12783,7 +14287,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() {
@@ -12791,11 +14297,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() {
@@ -12807,8 +14351,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() {
@@ -12838,9 +14384,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() {
@@ -12853,9 +14442,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() {
@@ -12879,6 +14472,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}
@@ -12888,10 +14506,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) {
@@ -12915,17 +14563,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]
      */
@@ -12938,6 +14575,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`.
@@ -12946,6 +14594,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
@@ -13007,8 +14665,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) {
@@ -13033,6 +14692,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]
@@ -13043,13 +14719,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`
@@ -13066,6 +14772,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]
@@ -13074,7 +14794,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) {
@@ -13088,18 +14815,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) {
@@ -13110,8 +14869,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) {
@@ -13137,9 +14898,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) {
@@ -13148,9 +14949,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) {
@@ -13166,6 +14971,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]
@@ -13173,6 +15003,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;
 
@@ -13774,6 +15617,13 @@ export class TransferableGeometry {
         const ret = wasm.__wbg_get_transferablegeometry_normals(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * @returns {number | undefined}
+     */
+    get skirt_heights() {
+        const ret = wasm.__wbg_get_transferablegeometry_skirt_heights(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * @returns {number | undefined}
      */
@@ -13828,6 +15678,12 @@ export class TransferableGeometry {
     set normals(arg0) {
         wasm.__wbg_set_transferablegeometry_normals(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >> 0);
     }
+    /**
+     * @param {number | null} [arg0]
+     */
+    set skirt_heights(arg0) {
+        wasm.__wbg_set_transferablegeometry_skirt_heights(this.__wbg_ptr, isLikeNone(arg0) ? Number.MAX_SAFE_INTEGER : (arg0) >> 0);
+    }
     /**
      * @param {number | null} [arg0]
      */
@@ -14111,6 +15967,33 @@ export class TransferablePointGeometry {
         const ret = wasm.__wbg_get_transferablepointgeometry_batch_index(this.__wbg_ptr);
         return TransferableUintAttribute.__wrap(ret);
     }
+    /**
+     * Per-anchor tangent bearing in degrees clockwise from north, present only
+     * when the anchors were placed along a line.
+     * @returns {TransferableFloatAttribute | undefined}
+     */
+    get bearings() {
+        const ret = wasm.__wbg_get_transferablepointgeometry_bearings(this.__wbg_ptr);
+        return ret === 0 ? undefined : TransferableFloatAttribute.__wrap(ret);
+    }
+    /**
+     * Per-anchor metres between adjacent path samples, then metres of real
+     * line either side of the anchor.
+     * @returns {TransferableFloatAttribute | undefined}
+     */
+    get path_meta() {
+        const ret = wasm.__wbg_get_transferablepointgeometry_path_meta(this.__wbg_ptr);
+        return ret === 0 ? undefined : TransferableFloatAttribute.__wrap(ret);
+    }
+    /**
+     * Per-anchor east/north samples of the line, for bending glyphs along it.
+     * `size` is the stride: two floats per sample.
+     * @returns {TransferableFloatAttribute | undefined}
+     */
+    get path_samples() {
+        const ret = wasm.__wbg_get_transferablepointgeometry_path_samples(this.__wbg_ptr);
+        return ret === 0 ? undefined : TransferableFloatAttribute.__wrap(ret);
+    }
     /**
      * @returns {TransferableFloatAttribute | undefined}
      */
@@ -14132,6 +16015,15 @@ export class TransferablePointGeometry {
         const ret = wasm.__wbg_get_transferablepointgeometry_position(this.__wbg_ptr);
         return ret === 0 ? undefined : TransferableFloatAttribute.__wrap(ret);
     }
+    /**
+     * Per-anchor `(min, max]` ground metres per screen pixel over which it is
+     * shown; `size` is the stride. Present exactly when `bearings` is.
+     * @returns {TransferableFloatAttribute | undefined}
+     */
+    get scale_bands() {
+        const ret = wasm.__wbg_get_transferablepointgeometry_scale_bands(this.__wbg_ptr);
+        return ret === 0 ? undefined : TransferableFloatAttribute.__wrap(ret);
+    }
     /**
      * @param {TransferableFloatAttribute} arg0
      */
@@ -14148,6 +16040,45 @@ export class TransferablePointGeometry {
         var ptr0 = arg0.__destroy_into_raw();
         wasm.__wbg_set_transferablepointgeometry_batch_index(this.__wbg_ptr, ptr0);
     }
+    /**
+     * Per-anchor tangent bearing in degrees clockwise from north, present only
+     * when the anchors were placed along a line.
+     * @param {TransferableFloatAttribute | null} [arg0]
+     */
+    set bearings(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, TransferableFloatAttribute);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_transferablepointgeometry_bearings(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * Per-anchor metres between adjacent path samples, then metres of real
+     * line either side of the anchor.
+     * @param {TransferableFloatAttribute | null} [arg0]
+     */
+    set path_meta(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, TransferableFloatAttribute);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_transferablepointgeometry_path_meta(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * Per-anchor east/north samples of the line, for bending glyphs along it.
+     * `size` is the stride: two floats per sample.
+     * @param {TransferableFloatAttribute | null} [arg0]
+     */
+    set path_samples(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, TransferableFloatAttribute);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_transferablepointgeometry_path_samples(this.__wbg_ptr, ptr0);
+    }
     /**
      * @param {TransferableFloatAttribute | null} [arg0]
      */
@@ -14181,6 +16112,19 @@ export class TransferablePointGeometry {
         }
         wasm.__wbg_set_transferablepointgeometry_position(this.__wbg_ptr, ptr0);
     }
+    /**
+     * Per-anchor `(min, max]` ground metres per screen pixel over which it is
+     * shown; `size` is the stride. Present exactly when `bearings` is.
+     * @param {TransferableFloatAttribute | null} [arg0]
+     */
+    set scale_bands(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, TransferableFloatAttribute);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_transferablepointgeometry_scale_bands(this.__wbg_ptr, ptr0);
+    }
 }
 if (Symbol.dispose) TransferablePointGeometry.prototype[Symbol.dispose] = TransferablePointGeometry.prototype.free;
 
@@ -14906,8 +16850,8 @@ export class TransferablePolylineGeometry {
     /**
      * @returns {TransferableFloatAttribute | undefined}
      */
-    get end_normal_and_texture_coordinate_normalization_x() {
-        const ret = wasm.__wbg_get_transferablepolylinegeometry_end_normal_and_texture_coordinate_normalization_x(this.__wbg_ptr);
+    get end_normal_and_segment_length() {
+        const ret = wasm.__wbg_get_transferablepolylinegeometry_end_normal_and_segment_length(this.__wbg_ptr);
         return ret === 0 ? undefined : TransferableFloatAttribute.__wrap(ret);
     }
     /**
@@ -14924,6 +16868,20 @@ export class TransferablePolylineGeometry {
         const ret = wasm.__wbg_get_transferablepolylinegeometry_indices(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @returns {TransferableFloatAttribute | undefined}
+     */
+    get line_distance_and_ends() {
+        const ret = wasm.__wbg_get_transferablepolylinegeometry_line_distance_and_ends(this.__wbg_ptr);
+        return ret === 0 ? undefined : TransferableFloatAttribute.__wrap(ret);
+    }
+    /**
+     * @returns {TransferableFloatAttribute | undefined}
+     */
+    get line_segments() {
+        const ret = wasm.__wbg_get_transferablepolylinegeometry_line_segments(this.__wbg_ptr);
+        return ret === 0 ? undefined : TransferableFloatAttribute.__wrap(ret);
+    }
     /**
      * @returns {TransferableFloatAttribute | undefined}
      */
@@ -14948,8 +16906,8 @@ export class TransferablePolylineGeometry {
     /**
      * @returns {TransferableFloatAttribute}
      */
-    get right_normal_and_texture_coordinate_normalization_y() {
-        const ret = wasm.__wbg_get_transferablepolylinegeometry_right_normal_and_texture_coordinate_normalization_y(this.__wbg_ptr);
+    get right_normal_and_line_length() {
+        const ret = wasm.__wbg_get_transferablepolylinegeometry_right_normal_and_line_length(this.__wbg_ptr);
         return TransferableFloatAttribute.__wrap(ret);
     }
     /**
@@ -14969,8 +16927,8 @@ export class TransferablePolylineGeometry {
     /**
      * @returns {TransferableFloatAttribute | undefined}
      */
-    get start_normals() {
-        const ret = wasm.__wbg_get_transferablepolylinegeometry_start_normals(this.__wbg_ptr);
+    get start_normal_and_length_high() {
+        const ret = wasm.__wbg_get_transferablepolylinegeometry_start_normal_and_length_high(this.__wbg_ptr);
         return ret === 0 ? undefined : TransferableFloatAttribute.__wrap(ret);
     }
     /**
@@ -15027,13 +16985,13 @@ export class TransferablePolylineGeometry {
     /**
      * @param {TransferableFloatAttribute | null} [arg0]
      */
-    set end_normal_and_texture_coordinate_normalization_x(arg0) {
+    set end_normal_and_segment_length(arg0) {
         let ptr0 = 0;
         if (!isLikeNone(arg0)) {
             _assertClass(arg0, TransferableFloatAttribute);
             ptr0 = arg0.__destroy_into_raw();
         }
-        wasm.__wbg_set_transferablepolylinegeometry_end_normal_and_texture_coordinate_normalization_x(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_transferablepolylinegeometry_end_normal_and_segment_length(this.__wbg_ptr, ptr0);
     }
     /**
      * @param {TransferableFloatAttribute | null} [arg0]
@@ -15052,6 +17010,28 @@ export class TransferablePolylineGeometry {
     set indices(arg0) {
         wasm.__wbg_set_transferablepolylinegeometry_indices(this.__wbg_ptr, arg0);
     }
+    /**
+     * @param {TransferableFloatAttribute | null} [arg0]
+     */
+    set line_distance_and_ends(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, TransferableFloatAttribute);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_transferablepolylinegeometry_line_distance_and_ends(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @param {TransferableFloatAttribute | null} [arg0]
+     */
+    set line_segments(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, TransferableFloatAttribute);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_transferablepolylinegeometry_line_segments(this.__wbg_ptr, ptr0);
+    }
     /**
      * @param {TransferableFloatAttribute | null} [arg0]
      */
@@ -15085,10 +17065,10 @@ export class TransferablePolylineGeometry {
     /**
      * @param {TransferableFloatAttribute} arg0
      */
-    set right_normal_and_texture_coordinate_normalization_y(arg0) {
+    set right_normal_and_line_length(arg0) {
         _assertClass(arg0, TransferableFloatAttribute);
         var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_transferablepolylinegeometry_right_normal_and_texture_coordinate_normalization_y(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_transferablepolylinegeometry_right_normal_and_line_length(this.__wbg_ptr, ptr0);
     }
     /**
      * @param {TransferableFloatAttribute | null} [arg0]
@@ -15115,13 +17095,13 @@ export class TransferablePolylineGeometry {
     /**
      * @param {TransferableFloatAttribute | null} [arg0]
      */
-    set start_normals(arg0) {
+    set start_normal_and_length_high(arg0) {
         let ptr0 = 0;
         if (!isLikeNone(arg0)) {
             _assertClass(arg0, TransferableFloatAttribute);
             ptr0 = arg0.__destroy_into_raw();
         }
-        wasm.__wbg_set_transferablepolylinegeometry_start_normals(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_transferablepolylinegeometry_start_normal_and_length_high(this.__wbg_ptr, ptr0);
     }
     /**
      * @param {TransferableFloatAttribute | null} [arg0]
@@ -15144,14 +17124,16 @@ export class TransferablePolylineGeometry {
      * @param {TransferableFloatAttribute | null | undefined} forward_offset
      * @param {TransferableFloatAttribute | null | undefined} end_high
      * @param {TransferableFloatAttribute | null | undefined} end_low
-     * @param {TransferableFloatAttribute | null | undefined} start_normals
-     * @param {TransferableFloatAttribute | null | undefined} end_normal_and_texture_coordinate_normalization_x
-     * @param {TransferableFloatAttribute} right_normal_and_texture_coordinate_normalization_y
+     * @param {TransferableFloatAttribute | null | undefined} start_normal_and_length_high
+     * @param {TransferableFloatAttribute | null | undefined} end_normal_and_segment_length
+     * @param {TransferableFloatAttribute} right_normal_and_line_length
      * @param {TransferableFloatAttribute | null | undefined} batch_ids
      * @param {TransferableUintAttribute | null | undefined} batch_index
      * @param {number} indices
+     * @param {TransferableFloatAttribute | null} [line_segments]
+     * @param {TransferableFloatAttribute | null} [line_distance_and_ends]
      */
-    constructor(position, position_high, position_low, start, start_high, start_low, forward_offset, end_high, end_low, start_normals, end_normal_and_texture_coordinate_normalization_x, right_normal_and_texture_coordinate_normalization_y, batch_ids, batch_index, indices) {
+    constructor(position, position_high, position_low, start, start_high, start_low, forward_offset, end_high, end_low, start_normal_and_length_high, end_normal_and_segment_length, right_normal_and_line_length, batch_ids, batch_index, indices, line_segments, line_distance_and_ends) {
         _assertClass(position, TransferableFloatAttribute);
         var ptr0 = position.__destroy_into_raw();
         let ptr1 = 0;
@@ -15195,17 +17177,17 @@ export class TransferablePolylineGeometry {
             ptr8 = end_low.__destroy_into_raw();
         }
         let ptr9 = 0;
-        if (!isLikeNone(start_normals)) {
-            _assertClass(start_normals, TransferableFloatAttribute);
-            ptr9 = start_normals.__destroy_into_raw();
+        if (!isLikeNone(start_normal_and_length_high)) {
+            _assertClass(start_normal_and_length_high, TransferableFloatAttribute);
+            ptr9 = start_normal_and_length_high.__destroy_into_raw();
         }
         let ptr10 = 0;
-        if (!isLikeNone(end_normal_and_texture_coordinate_normalization_x)) {
-            _assertClass(end_normal_and_texture_coordinate_normalization_x, TransferableFloatAttribute);
-            ptr10 = end_normal_and_texture_coordinate_normalization_x.__destroy_into_raw();
+        if (!isLikeNone(end_normal_and_segment_length)) {
+            _assertClass(end_normal_and_segment_length, TransferableFloatAttribute);
+            ptr10 = end_normal_and_segment_length.__destroy_into_raw();
         }
-        _assertClass(right_normal_and_texture_coordinate_normalization_y, TransferableFloatAttribute);
-        var ptr11 = right_normal_and_texture_coordinate_normalization_y.__destroy_into_raw();
+        _assertClass(right_normal_and_line_length, TransferableFloatAttribute);
+        var ptr11 = right_normal_and_line_length.__destroy_into_raw();
         let ptr12 = 0;
         if (!isLikeNone(batch_ids)) {
             _assertClass(batch_ids, TransferableFloatAttribute);
@@ -15216,7 +17198,17 @@ export class TransferablePolylineGeometry {
             _assertClass(batch_index, TransferableUintAttribute);
             ptr13 = batch_index.__destroy_into_raw();
         }
-        const ret = wasm.transferablepolylinegeometry_new(ptr0, ptr1, ptr2, ptr3, ptr4, ptr5, ptr6, ptr7, ptr8, ptr9, ptr10, ptr11, ptr12, ptr13, indices);
+        let ptr14 = 0;
+        if (!isLikeNone(line_segments)) {
+            _assertClass(line_segments, TransferableFloatAttribute);
+            ptr14 = line_segments.__destroy_into_raw();
+        }
+        let ptr15 = 0;
+        if (!isLikeNone(line_distance_and_ends)) {
+            _assertClass(line_distance_and_ends, TransferableFloatAttribute);
+            ptr15 = line_distance_and_ends.__destroy_into_raw();
+        }
+        const ret = wasm.transferablepolylinegeometry_new(ptr0, ptr1, ptr2, ptr3, ptr4, ptr5, ptr6, ptr7, ptr8, ptr9, ptr10, ptr11, ptr12, ptr13, indices, ptr14, ptr15);
         this.__wbg_ptr = ret;
         TransferablePolylineGeometryFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -15965,6 +17957,83 @@ export class UpsampleTerrainMeshResult {
 }
 if (Symbol.dispose) UpsampleTerrainMeshResult.prototype[Symbol.dispose] = UpsampleTerrainMeshResult.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);
@@ -16653,8 +18722,8 @@ export class WorkerTaskDelegatedEvent {
     }
     /**
      * Dispatch urgency: 0 is the most urgent (see `Priority::rank`). The
-     * platform keeps its pending stack sorted by this so a terrain mesh task
-     * overtakes older, less urgent work waiting for a worker.
+     * engine already emits a frame's tasks in this order and bounds how many
+     * are in flight, so the platform starts them as they come.
      * @returns {number}
      */
     get priority() {
@@ -16688,8 +18757,8 @@ export class WorkerTaskDelegatedEvent {
     }
     /**
      * Dispatch urgency: 0 is the most urgent (see `Priority::rank`). The
-     * platform keeps its pending stack sorted by this so a terrain mesh task
-     * overtakes older, less urgent work waiting for a worker.
+     * engine already emits a frame's tasks in this order and bounds how many
+     * are in flight, so the platform starts them as they come.
      * @param {number} arg0
      */
     set priority(arg0) {
@@ -16706,6 +18775,23 @@ export class WorkerTaskDelegatedEvent {
 }
 if (Symbol.dispose) WorkerTaskDelegatedEvent.prototype[Symbol.dispose] = WorkerTaskDelegatedEvent.prototype.free;
 
+/**
+ * Height of the rendered terrain surface for an unexaggerated terrain height:
+ * `(height - relativeHeight) * scale + relativeHeight`, with a negative
+ * `scale` clamped to 0.
+ *
+ * Exported so the web side (tile bounds, `sampleTerrainMostDetailed`) maps
+ * heights with the same function the engine's bounds and height queries use.
+ * @param {number} height
+ * @param {number} scale
+ * @param {number} relative_height
+ * @returns {number}
+ */
+export function exaggerateTerrainHeight(height, scale, relative_height) {
+    const ret = wasm.exaggerateTerrainHeight(height, scale, relative_height);
+    return ret;
+}
+
 /**
  * @returns {string}
  */
@@ -17128,6 +19214,14 @@ function __wbg_get_imports() {
             const ret = arg0.value;
             return ret;
         },
+        __wbg_variableanchor_new: function(arg0) {
+            const ret = VariableAnchor.__wrap(arg0);
+            return ret;
+        },
+        __wbg_variableanchor_unwrap: function(arg0) {
+            const ret = VariableAnchor.__unwrap(arg0);
+            return ret;
+        },
         __wbg_vectortilestate_new: function(arg0) {
             const ret = VectorTileState.__wrap(arg0);
             return ret;
@@ -17439,6 +19533,9 @@ const SourceDataFinalization = (typeof FinalizationRegistry === 'undefined')
 const SourceDescriptionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sourcedescription_free(ptr, 1));
+const TerrainExaggerationUpdatedEventFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_terrainexaggerationupdatedevent_free(ptr, 1));
 const TerrainHeightRangeUpdatedEventFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_terrainheightrangeupdatedevent_free(ptr, 1));
@@ -17538,6 +19635,9 @@ const UpsampleTerrainMeshParametersFinalization = (typeof FinalizationRegistry =
 const UpsampleTerrainMeshResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_upsampleterrainmeshresult_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));
@@ -17671,11 +19771,24 @@ function getArrayU32FromWasm0(ptr, len) {
     return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
 
+function getArrayU64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getBigUint64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+let cachedBigUint64ArrayMemory0 = null;
+function getBigUint64ArrayMemory0() {
+    if (cachedBigUint64ArrayMemory0 === null || cachedBigUint64ArrayMemory0.byteLength === 0) {
+        cachedBigUint64ArrayMemory0 = new BigUint64Array(wasm.memory.buffer);
+    }
+    return cachedBigUint64ArrayMemory0;
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -17856,6 +19969,7 @@ function __wbg_finalize_init(instance, module) {
     wasmInstance = instance;
     wasm = instance.exports;
     wasmModule = module;
+    cachedBigUint64ArrayMemory0 = null;
     cachedDataViewMemory0 = null;
     cachedFloat32ArrayMemory0 = null;
     cachedFloat64ArrayMemory0 = null;