@xweather/mapsgl 1.9.4 → 1.10.0

package/dist/mapsgl.d.ts

@@ -306,6 +306,10 @@ export declare const getPageLoadPromise: () => Promise<any>;
 
 export declare const getPixelRatio: (gl: any) => number;
 
+/**
+ * Extract `#define SHADER_NAME name` from GLSL source, if present.
+ * Returns an empty string when the define is missing so callers can supply their own label.
+ */
 export declare const getShaderName: (shader: string) => string;
 
 export declare const getShaderTypeName: (gl: any, type: number) => string;
@@ -894,6 +898,7 @@ export declare type WebGLContext = WebGLRenderingContext | WebGL2RenderingContex
 /// <reference types="leaflet" />
 /// <reference types="mapbox-gl" />
 /// <reference types="maplibre-gl" />
+/// <reference types="types/marchingsquares" />
 
 /**
  * An `Account` object is responsible for managing the client id and secret as well as permissions for an Xweather
@@ -1211,6 +1216,8 @@ export declare type AnyAuthenticator = Authenticator<any>;
 export declare type AnyMapController = MapController<any>;
 
 export declare type AnyTileCache = TileCache<any>;
+
+export declare type AnyTileRenderable = TileRenderable<any>;
 
 /**
  * An enumerated value representing an API endpoint action.
@@ -1565,7 +1572,7 @@ export declare class ApiResult {
      */
     headers(): Record<string, string> | undefined;
 }
-
+
 /**
  * An interface that describes an object that performs server authentication using a session token or
  * other means.
@@ -1612,6 +1619,11 @@ export declare interface BarLegendOptions {
          * The measurement units.
          */
         units: string;
+        /**
+         * When `true`, the legend always displays in its own {@link units}, ignoring the map's unit
+         * state for this {@link type}. See `weather-spec`'s `LegendMeasurementSpec` for the rationale.
+         */
+        fixed?: boolean;
         /**
          * A function that converts a value to another unit.
          */
@@ -1679,14 +1691,27 @@ export declare interface BarLegendOptions {
         allowOverlap: boolean;
     }>;
 }
-
+
 export declare type BBox = {
     minX: number;
     minY: number;
     maxX: number;
     maxY: number;
 };
+
+export declare interface Bindable {
+    bind(target?: GLenum): void;
+    unbind(target?: GLenum): void;
+}
 
+declare enum Blending {
+    None = 0,
+    Normal = 1,
+    Additive = 2,
+    Subtractive = 3,
+    Multiply = 4
+}
+
 export declare class Bounds {
     left: number;
     right: number;
@@ -1697,6 +1722,74 @@ export declare class Bounds {
     constructor(left: number, right: number, top: number, bottom: number);
 }
 
+/** Built-in slot identifiers (bottom → top order). */
+export declare const BuiltinSlot: {
+    /**
+     * Under-basemap band (default: below admin boundaries): raster/sample/heatmap
+     * plus polygon fills, stacked by {@link BuiltinStackRank}.
+     */
+    readonly underlay: "underlay";
+    /**
+     * Mid-map band: particles plus lines, circles, symbols, contours, and other
+     * non-fill marks. Ordered within the slot by {@link BuiltinStackRank}
+     * (particles below contour/line/symbol).
+     */
+    readonly inlay: "inlay";
+    readonly text: "text";
+    /**
+     * Topmost MapsGL band: day/night chrome, debug, and other always-on-top content.
+     * Symmetric with {@link BuiltinSlot.underlay}.
+     */
+    readonly overlay: "overlay";
+};
+
+export declare type BuiltinSlot = ObjectValue<typeof BuiltinSlot>;
+
+/**
+ * Built-in within-slot stack ranks (higher = above within the same slot).
+ * Used when no explicit `stackRank` / code override is provided.
+ *
+ * Global top → bottom (also safe if every layer shares one slot):
+ * overlay → text → symbol → circle → line → contour → particle →
+ * radar → satellite → fill → precip → default.
+ */
+export declare const BuiltinStackRank: {
+    readonly default: 0;
+    /**
+     * Precip / frozen-precip sample rasters (`precip-*`, `snow-*`, `sleet-*`, `ice-*`).
+     * Above generic samples, below polygon fills.
+     */
+    readonly precip: 50;
+    /** Polygon fills — above precip/generic samples, below satellite/radar. */
+    readonly fill: 100;
+    readonly satellite: 200;
+    readonly radar: 300;
+    readonly boundaries: 350;
+    /** Particle fields — above underlay products, below contour/line/symbol. */
+    readonly particle: 400;
+    readonly contour: 500;
+    readonly line: 600;
+    readonly circle: 700;
+    readonly symbol: 800;
+    readonly text: 900;
+    /** Day/night and similar chrome — topmost among built-in ranks. */
+    readonly overlay: 1000;
+};
+
+export declare interface CameraOpts {
+    fov?: number;
+    aspect?: number;
+    near?: number;
+    far?: number;
+    bounds?: ViewBounds;
+    zoom?: number;
+}
+
+declare enum CameraType {
+    orthographic = 0,
+    perspective = 1
+}
+
 /**
  * Circle style properties control how circles get rendered on a map. Use these properties in conjunction with `fill`
  * and `stroke` to define the style for a circle layer.
@@ -1708,6 +1801,47 @@ export declare interface CircleStyleSpec {
     radius: StyleValue<number>;
 }
 
+/**
+ * A utility class for creating and representing a color.
+ */
+export declare class Color {
+    /**
+     * Red channel as a normalized value between 0 and 1. Default is 0.
+     */
+    r: number;
+    /**
+     * Green channel value normalized between 0 and 1. Defautl value is 1.
+     */
+    g: number;
+    b: number;
+    a: number;
+    /**
+     * @param r - If arguments `g` and `b` are defined, then the red component of the color. Otherwise, it can be
+     * a single hexadecimal triplet, a CSS-style color string, a valid X11 color name or a single number applied to all
+     * color components.
+     * @param g - The green component of the color.
+     * @param b - The blue component of the color.
+     * @param a - The alpha component of the color.
+     */
+    constructor(r?: any, g?: number, b?: number, a?: number);
+    fromHex(hex: string | number): Color;
+    fromHSL(h: number, s: number | string, l: number | string, a?: number): Color;
+    fromHSV(h: number, s: number | string, v: number | string, a?: number): Color;
+    setRGB(r: number, g: number, b: number): Color;
+    setRGBA(r: number, g: number, b: number, a: number, normalized?: boolean): Color;
+    setAlpha(a: number): Color;
+    lighter(percent: number): Color;
+    darker(percent: number): Color;
+    equals(c: Color): boolean;
+    toHex(): string;
+    toHSL(): HSL;
+    toHSV(): HSV;
+    toObject(normalized?: boolean): RGB;
+    toArray(): number[];
+    toVector(): Vector4;
+    toString(): string;
+}
+
 export declare type ColorBand = typeof SupportedColorBands[number];
 
 /**
@@ -1895,7 +2029,7 @@ export declare interface ControlStore {
     dataInspector: DataInspectorControl;
 }
 
-export declare type ConversionMeasurement = Measurement | 'temperature-change';
+export declare type ConversionMeasurement = Measurement;
 
 declare const convert: (type: ConversionMeasurement | string, value: number, from: string, to: string) => number;
 
@@ -1915,7 +2049,7 @@ export declare type CoordinateBounds = {
 };
 
 export declare type CrossTileID = string;
-
+
 declare const CtoF: (c: number) => number;
 
 declare const CtoFUnit: (c: number) => number;
@@ -1923,10 +2057,19 @@ declare const CtoFUnit: (c: number) => number;
 export declare class DataDrivenStyleValue<T> extends StyleValue_2<T> {
 }
 
+/**
+ * Data-inspector evaluator. `fn` may return plain text or an HTML fragment string; rich markup
+ * should use the shared helpers in `control/inspector/markup.ts`. Display units come from the
+ * map controller's current `MapUnits` preference (second argument). Optional `EvaluatorContext`
+ * exposes layer paint for paint-driven colors (badges, etc.).
+ */
 export declare interface DataEvaluator {
     title: string | ((data: FeatureQueryResult) => string);
+    /**
+     * @deprecated Rows are no longer deduplicated by title. Kept for API compatibility.
+     */
     alwaysShow?: boolean;
-    fn: (data: FeatureQueryResult) => string;
+    fn: (data: FeatureQueryResult, units: MapUnits, context?: EvaluatorContext) => string;
 }
 
 export declare class DataInspector {
@@ -1944,6 +2087,7 @@ export declare class DataInspectorControl {
     private _position;
     private _coord;
     private _enabled;
+    private _boundUnitsChange;
     get isEnabled(): boolean;
     constructor(inspector: DataInspector, options?: Partial<DataInspectorControlOptions>);
     addTo(target: HTMLElement | string): void;
@@ -1961,15 +2105,28 @@ export declare class DataInspectorControl {
     _queryFeatures: (coord: Coordinate) => void;
     _queryFeaturesAsync: (coord: Coordinate) => Promise<void>;
     _setFeatures(coord: Coordinate, features: Record<string, FeatureQueryResult>): void;
+    private _bindUnitsChange;
+    private _unbindUnitsChange;
+    private _handleUnitsChange;
 }
 
 export declare interface DataInspectorControlOptions {
     event: 'click' | 'move';
     stream: boolean;
     showCoordinates: boolean;
+    /**
+     * Row layout mode:
+     * - `auto` — side-by-side title|value for compact one-liners (scalars, badge-only,
+     *   badge + inline value like radar); title above value for multi-line/block content
+     *   (alerts, multi-source stats, tropical stacks, progress, …)
+     * - `stacked` — title above value for every row
+     */
+    layout: DataInspectorLayout;
     tooltip: any;
 }
 
+export declare type DataInspectorLayout = 'auto' | 'stacked';
+
 /**
  * Determines the quality of the data when rendered.
  */
@@ -2085,10 +2242,21 @@ export declare const DataSourceType: {
     readonly geojson: "geojson";
     readonly encoded: "encoded";
     readonly debug: "debug";
+    /** A source that never fetches — used by source-less layers (coverage masks, debug). */
+    readonly noop: "noop";
 };
 
 export declare type DataSourceType = ObjectValue<typeof DataSourceType>;
-
+
+export declare interface DayNightOverlayOptions {
+    /**
+     * Overall opacity of the day/night overlay in the range `[0, 1]`.
+     * Multiplies with the twilight fill alpha so stacked bands still deepen toward night.
+     * Defaults to `1`.
+     */
+    opacity?: number;
+}
+
 declare const dbzToMMRate: (dbz: number, perSecond?: boolean) => number;
 
 declare const defaultUnits: Record<Exclude<UnitSystem, 'custom'>, MapUnits>;
@@ -2403,6 +2571,8 @@ export declare interface EncodedRasterDataset {
     dataMax: number;
     /**
      * The no data value for the dataset.
+     * For multi-band packs of the same id, only the primary band should define this; decode/skip
+     * key off that band while later bands use the full 0…255 range.
      */
     noData: number;
     /**
@@ -2460,6 +2630,29 @@ export declare interface EncodedSourceSpecification<Dataset extends EncodedRaste
      * @deprecated Use `transformerId` instead to reference a registered transformer by ID.
      */
     transformTileData?: (data: RGBAImage, datasets: Array<Dataset>) => void;
+    /**
+     * Number of pixels to dilate (extend) valid data outward past nodata boundaries when a tile is
+     * decoded. Defaults to `0` (disabled).
+     *
+     * Regional models are resampled into tiles with large nodata areas outside their coverage,
+     * producing a jagged data edge. Dilating the decoded tile a few pixels lets the renderer's
+     * normal nodata edge handling and a coverage {@link WebGLLayer.mask | mask} produce a clean
+     * edge. Uses the first dataset's `noData` value and `band`.
+     *
+     * Note: this mutates the decoded tile data, so value lookups just outside the original coverage
+     * will return the filled (extended) values rather than nodata.
+     */
+    edgeDilate?: number;
+    /**
+     * Whether to recompute {@link edgeDilate | edge dilation} when a neighbouring tile backfills this
+     * tile's edge padding. Defaults to `false`.
+     *
+     * Enabling this extends dilated data across tile seams that coincide with the model's coverage
+     * boundary, but it can make interior tile seams visible (which edge backfilling otherwise
+     * prevents) and introduce edge artifacts, so it is opt-in. Only affects the decode-time dilation
+     * along seams; the initial dilation is unaffected.
+     */
+    edgeDilateBackfill?: boolean;
 }
 
 /**
@@ -2508,10 +2701,77 @@ protected onLoadProgress(e: any): void;
 declare const equalUnits: (units1: MapUnits, units2: MapUnits) => boolean;
 
 /**
- * Mapbox-style expression: operator name followed by arguments.
- * Arguments may be literals or nested expressions (recursive).
+ * Euler angles describe a rotational transformation by rotating an object on its various axes in
+ * specified amounts per axis, and a specified axis order. Euler angles consist of three
+ * components: roll, pitch and yaw angles.
+ * @see https://en.wikipedia.org/wiki/Euler%27s_rotation_theorem
+ */
+export declare class Euler {
+
+get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get order(): number;
+    set order(value: number);
+    get roll(): number;
+    set roll(value: number);
+    get pitch(): number;
+    set pitch(value: number);
+    get yaw(): number;
+    set yaw(value: number);
+    get value(): vec4;
+    get elements(): number;
+    constructor(x?: number, y?: number, z?: number, order?: number);
+    fromArray(array: number[], offset?: number): Euler;
+    toArray(array?: number[], offset?: number): number[];
+    fromObject({ x, y, z, order }: {
+        x: number;
+        y: number;
+        z: number;
+        order: number;
+    }): Euler;
+    toObject(): {
+        x: number;
+        y: number;
+        z: number;
+        order: number;
+    };
+    fromRotationMatrix(m: Matrix4, order?: EulerOrder): Euler;
+    fromQuaternion(q: Quaternion): Euler;
+    toQuaternion(): Quaternion;
+    fromVector3(v: Vector3, order?: EulerOrder): Euler;
+    toVector3(): Vector3;
+    set(x: number, y: number, z: number, order?: EulerOrder): Euler;
+    clone(): Euler;
+    copy(e: Euler): Euler;
+    equals(e: Euler): boolean;
+
+}
+
+/**
+ * The order of the Euler angles.
+ */
+declare enum EulerOrder {
+    ZYX = 0,
+    YXZ = 1,
+    XZY = 2,
+    ZXY = 3,
+    YZX = 4,
+    XYZ = 5,
+    RollPitchYaw = 0
+}
+
+/**
+ * Optional context passed to data-inspector evaluators so they can resolve paint-driven
+ * colors (and similar layer state) without hardcoding layer-specific lookups.
  */
-export declare type Expression = [ExpressionOperator, ...ExpressionValue[]];
+export declare type EvaluatorContext = {
+    layerId?: string;
+    paint?: PaintStyle;
+};
 
 /**
  * Mapbox-style expression array, e.g. ['get', 'opacity'] or ['*', ['get', 'x'], 2].
@@ -2560,97 +2820,15 @@ export declare interface ExpressionOperation {
      */
     chunk: string;
 }
-
-/**
- * Supported expression operator names (first element of an expression array).
- * @see evaluateExpression
- */
-declare const ExpressionOperator: {
-    readonly literal: "literal";
-    readonly get: "get";
-    readonly has: "has";
-    readonly var: "var";
-    readonly properties: "properties";
-    readonly zoom: "zoom";
-    readonly coalesce: "coalesce";
-    readonly eq: "==";
-    readonly neq: "!=";
-    readonly lt: "<";
-    readonly lte: "<=";
-    readonly gt: ">";
-    readonly gte: ">=";
-    readonly not: "!";
-    readonly all: "all";
-    readonly any: "any";
-    readonly toNumber: "to-number";
-    readonly toString: "to-string";
-    readonly toDate: "to-date";
-    readonly toLocaleString: "to-locale-string";
-    readonly toUnit: "to-unit";
-    readonly toBoolean: "to-boolean";
-    readonly typeOf: "typeof";
-    readonly number: "number";
-    readonly string: "string";
-    readonly boolean: "boolean";
-    readonly object: "object";
-    readonly add: "+";
-    readonly subtract: "-";
-    readonly mod: "%";
-    readonly pow: "^";
-    readonly multiply: "*";
-    readonly divide: "/";
-    readonly abs: "abs";
-    readonly ceil: "ceil";
-    readonly floor: "floor";
-    readonly round: "round";
-    readonly min: "min";
-    readonly max: "max";
-    readonly sqrt: "sqrt";
-    readonly ln: "ln";
-    readonly ln2: "ln2";
-    readonly log2: "log2";
-    readonly log10: "log10";
-    readonly sin: "sin";
-    readonly cos: "cos";
-    readonly tan: "tan";
-    readonly asin: "asin";
-    readonly acos: "acos";
-    readonly atan: "atan";
-    readonly e: "e";
-    readonly pi: "pi";
-    readonly at: "at";
-    readonly in: "in";
-    readonly regex: "regex";
-    readonly indexOf: "index-of";
-    readonly length: "length";
-    readonly slice: "slice";
-    readonly concat: "concat";
-    readonly downcase: "downcase";
-    readonly upcase: "upcase";
-    readonly step: "step";
-    readonly interpolate: "interpolate";
-    readonly case: "case";
-    readonly match: "match";
-    readonly let: "let";
-    /**
-     * Active map timeline position as **Unix seconds** (from the map controller), not wall clock — use `now` for that.
-     */
-    readonly mapTime: "map-time";
-    /**
-     * @deprecated Prefer `map-time` — same semantics.
-     */
-    readonly time: "time";
-    readonly now: "now";
-};
-
-export declare type ExpressionOperator = ObjectValue<typeof ExpressionOperator>;
-
-/** Value that can appear as an expression or as an argument (literal or nested expression). */
-export declare type ExpressionValue = string | number | boolean | null | object | Expression;
 
 export declare type FeatureQueryResult = {
     value: number;
     angle?: number;
+    /**
+     * Optional discrete sample flag (e.g. radar `PTYPESMPL`: 1 = rain, 2 = snow, 3 = mix).
+     * Present when the queried layer encodes a categorical band alongside the scalar value.
+     */
+    flag?: number;
     unit?: string;
     features?: Array<FeatureData>;
     nodata: boolean;
@@ -2697,13 +2875,65 @@ export declare interface FillStyleSpec {
 }
 
 /**
- * Mapbox-style filter expression array. Evaluates to boolean (feature included when truthy).
- * Use with StyleExpression for evaluation. Supports decision expressions (==, !=, <, <=, >, >=,
- * all, any, !, in, regex, case, match, etc.) and property lookups (get, has).
- * @see StyleExpression
+ * Bottom-most (lowest in the style stack) admin boundary layer id from a Mapbox/MapLibre
+ * style `layers` array. Style order is bottom → top, so the first matching layer is returned.
+ * Used as the default ceiling for the MapsGL `underlay` slot when no explicit `beforeId` is set.
+ */
+export declare const findBottomMostAdminBoundaryLayerId: (layers: ReadonlyArray<StyleLayerRef> | null | undefined, excludeIds?: ReadonlySet<string>) => string | undefined;
+
+/**
+ * A set of font specifications and character metrics used for laying out text for rendering. This information is
+ * automatically generated using the `msdf-bmfont` tool from the `msdf-bmfont-xml` package from a TTF font file:
+ * https://github.com/soimy/msdf-bmfont-xml
  */
-export declare type FilterExpression = ExpressionValue;
+export declare type FontLayoutSpec = {
+    pages: Array<string>;
+    chars: Array<TextMetrics_2>;
+    info: {
+        face: string;
+        size: number;
+        bold: number;
+        italic: number;
+        charset: Array<string>;
+        unicode: number;
+        stretchH: number;
+        smooth: number;
+        aa: number;
+        padding: [number, number, number, number];
+        spacing: [number, number];
+        outline: number;
+    };
+    common: {
+        lineHeight: number;
+        base: number;
+        scaleW: number;
+        scaleH: number;
+        pages: number;
+        packed: number;
+        alphaChnl: number;
+        redChnl: number;
+        greenChnl: number;
+        blueChnl: number;
+    };
+    distanceField: {
+        fieldType: string;
+        distanceRange: number;
+    };
+    kernings: Array<{
+        first: number;
+        second: number;
+        amount: number;
+    }>;
+};
 
+export declare interface FramebufferTarget {
+    target?: GLuint;
+    buffer?: WebGLFramebuffer;
+    width?: number;
+    height?: number;
+    depth?: boolean;
+}
+
 declare const FtoC: (f: number) => number;
 
 declare const FtoCUnit: (f: number) => number;
@@ -2882,8 +3112,13 @@ export declare class GeoJSONSource extends VectorTileSource {
     /**
      * The GeoJSON data associated with the source, either provided statically or from a remote source.
      */
-    get data(): GeoJSONFeatureCollection;
+    get data(): GeoJSONFeatureCollection | undefined;
     private needsUpdate;
+    /**
+     * The last resolved remote data URL. When this changes between requests, cached tiles are
+     * expired so the worker reloads GeoJSON from the new URL.
+     */
+    private _lastDataUrl;
     /**
      * The revision number of the data.
      */
@@ -2911,6 +3146,15 @@ export declare class GeoJSONSource extends VectorTileSource {
     setData(value: GeoJSONFeatureCollection): void;
     expireAllTiles(): void;
     reload(): void;
+    /**
+     * Clears GeoJSON held by the worker so the next remote tile request refetches data
+     * (needed when the timeline range changes and `{startDate}`/`{endDate}` URLs update).
+     *
+     * Intentionally does not call `cancelAllRequests()` — aborting in-flight visible-tile
+     * tasks leaves their deferreds unresolved, so expired tiles stay blank until a later
+     * viewport change re-requests them.
+     */
+    private clearWorkerData;
     private updateWorkerData;
     private processWorkerUpdate;
     private beginDataUpdate;
@@ -2931,8 +3175,24 @@ export declare interface GeoJSONSourceSpecification extends SourceSpecification
      * The GeoJSON URL template string to use when requesting GeoJSON data.
      */
     url: string;
+    /**
+     * The minimum data zoom level at which the source is sliced into tiles, from `0` to `21`.
+     * Defaults to `0`.
+     */
+    minZoom?: number;
+    /**
+     * The maximum data zoom level at which the source is sliced into tiles, from `0` to `21`.
+     * Defaults to `21`. Clamp this low (e.g. `0`) for small, globally-continuous geometry so it is
+     * served as a single overscaled tile instead of many independently-updating tiles — this
+     * avoids inter-tile seams/tearing when the data updates rapidly.
+     */
+    maxZoom?: number;
     /**
      * Whether the GeoJSON data is dynamic, meaning it will be updated frequently. Default is `false`.
+     *
+     * Dynamic sources keep the last-good tiles rendered while new data re-slices (avoiding a blank
+     * flash), and the worker prefers a lightweight index for fast updates — automatically falling
+     * back to the full index for polygon data that the lightweight index cannot tile-fill.
      */
     dynamic?: boolean;
     /**
@@ -3185,11 +3445,23 @@ export declare type InterpolationMode = ObjectValue<typeof InterpolationMode>;
 
 declare const inToM: (ins: number) => number;
 
-declare const inToMM: (ins: number) => number;
-
-declare const inToMMRate: (ins: number) => number;
+/**
+ * Returns whether a style layer looks like an administrative boundary line.
+ * Matches Mapbox Streets (`admin-*-boundary*`, `source-layer: admin`) and common
+ * MapLibre/OpenMapTiles boundary layers (`boundary_*`, `source-layer: boundary`).
+ */
+export declare const isAdminBoundaryStyleLayer: (layer: StyleLayerRef | null | undefined) => boolean;
 
-declare const kmToM: (km: number) => number;
+/** Whether a style layer id is a MapsGL slot sentinel. */
+export declare const isSlotSentinelId: (id: string) => boolean;
+
+/**
+ * Whether a layer id / weather code should land in the `text` slot
+ * (`temperatures-text`, `conditions.temperature.text`, …).
+ */
+export declare const isTextSlotLayerKey: (key: string | undefined) => boolean;
+
+declare const kmToM: (km: number) => number;
 
 declare const kmToMi: (km: number) => number;
 
@@ -3443,6 +3715,10 @@ export declare interface LayerRenderer {
      * Called when the layer's mask state changes.
      */
     onMaskStateChange(): void;
+    /**
+     * Called when the layer's mask configuration (mask layers / mode / invert) changes.
+     */
+    onMaskLayerChange(): void;
     /**
      * Flags the renderer as dirty so that it is updated during the next render frame.
      */
@@ -3490,8 +3766,24 @@ export declare interface LayerSpecification {
      * Data source associated with the layer.
      * @remarks
      * This can be a string representing the ID of a data source, a data source instance or a source specification.
+     * Not required for source-less layers such as `coverageMask`.
      */
     source: string | SourceSpecification | DataSource;
+    /**
+     * The native coverage description for a `coverageMask` layer. Defines the model's grid and
+     * projection so the mask can be reprojected to the map and clipped to the coverage area.
+     */
+    coverage?: CoverageSpec;
+    /**
+     * Subdivisions per axis for a `coverageMask` mesh (default 64). Higher values follow the model's
+     * curved native boundary more closely at the cost of more vertices.
+     */
+    coverageSegments?: number;
+    /**
+     * Debug fill color (RGBA 0–1) for a `coverageMask` when rendered visibly. Ignored when the layer
+     * is used as a stencil mask.
+     */
+    coverageColor?: [number, number, number, number];
     /**
      * The layer's data to use from the data source, if applicable. This is only used for vector tile data sources
      * whose tiles are in the Mapbox Vector Tile (MVT) format.
@@ -3557,6 +3849,24 @@ export declare interface LayerSpecification {
      * loaded tile bounds. Default is `false`.
      */
     preloadLowQuality?: boolean;
+    /**
+     * MapsGL ordering slot id. Ignored unless layer slots are enabled on the
+     * controller (`slots: true` or a slots configuration object). When omitted
+     * and slots are enabled, the slot is chosen from the layer type
+     * (e.g. raster/sample/fill → `underlay`, particle/line → `inlay`).
+     * @see MapController.defineSlot
+     */
+    slot?: string;
+    /**
+     * Within-slot stack rank (higher paints above siblings in the same slot).
+     * When omitted, resolved from {@link stackKey} / weather code defaults (radar > satellite > other).
+     */
+    stackRank?: number;
+    /**
+     * Lookup key for default stack ranks (typically the weather layer code when the
+     * instance id differs). Used with {@link SlotRegistryOptions.stackRanks}.
+     */
+    stackKey?: string;
     /**
      * Render style configuration.
      * @see PaintStyleSpec
@@ -3598,6 +3908,16 @@ export declare type LayerTiming = {
      * beginning of the time range.
      */
     interleaved: boolean;
+    /**
+     * Number of neighboring time intervals before AND after the currently visible interval to preload once the
+     * visible interval has finished loading.
+     * @remarks
+     * Preloading neighboring intervals hides the network latency of stepping or scrubbing to an adjacent interval by
+     * fetching them ahead of time at a lower download priority, so the visible interval is never blocked waiting on
+     * non-visible data. A value of `0` disables preloading. The value is clamped to a maximum of `3`. Defaults to `0`.
+     * NOTE: Larger values increase network and memory usage since more interval data is retained at once.
+     */
+    preload: number;
     /**
      * The operation to perform on the data within the time series. Defaults to `none`.
      */
@@ -3695,7 +4015,18 @@ declare abstract class Legend extends EventDispatcher {
     options: Partial<LegendOptions>;
 
 private _rendered;
+    
     get measurement(): string | undefined;
+    /**
+     * The measurement's native units — the units the legend should always display in when
+     * {@link measurementFixed} is `true`.
+     */
+    get measurementUnits(): string | undefined;
+    /**
+     * When `true`, the legend ignores the map's unit state and always displays in its native
+     * {@link measurementUnits} (see `weather-spec`'s `LegendMeasurementSpec`).
+     */
+    get measurementFixed(): boolean;
     get size(): Size;
     get canvas(): HTMLCanvasElement;
     get layout(): LegendLayout;
@@ -3934,6 +4265,21 @@ export declare interface MapAdapterOptions {
      */
     account: Account;
     units?: Partial<MapUnits>;
+    /**
+     * Layer ordering slots. Opt-in — omitted or `false` keeps insertion/`beforeId`
+     * stacking from previous releases so existing integrations are unchanged.
+     *
+     * Pass `true` to enable built-in slots (underlay / inlay / text / overlay) with
+     * type-based stacking and default host pinning (Mapbox/MapLibre `underlay` below
+     * the bottom-most admin boundary). Pass a {@link SlotRegistryOptions} object to
+     * enable slots and customize definitions, type mapping, or stack ranks.
+     *
+     * Within a slot, {@link SlotRegistryOptions.stackRanks} control relative order
+     * (e.g. radar above satellite above other underlays). See {@link SlotRegistry}.
+     *
+     * @default undefined (disabled)
+     */
+    slots?: boolean | SlotRegistryOptions;
     /**
      * The {@link TimeAnimationOptions} containing configuration options for the map controller's timeline.
      */
@@ -3965,6 +4311,9 @@ export declare interface MapAdapterOptions {
     }>;
 }
 
+/** Mapbox Standard slot ids in paint order (bottom → top). */
+export declare const MAPBOX_STANDARD_SLOTS: readonly MapboxStandardSlot[];
+
 export declare type MapboxMap = mapboxgl.Map;
 
 /**
@@ -3975,6 +4324,7 @@ export declare class MapboxMapController extends MapController<MapboxMap> implem
 get container(): HTMLElement;
     get libraryInfo(): MapLibraryInfo;
     constructor(map: MapboxMap, opts: MapAdapterOptions);
+    initialize(): Promise<void>;
     getSize(): Size;
     setSize(size: NumericalOrStringSize): void;
     getCenter(): Coordinate;
@@ -3989,12 +4339,47 @@ get container(): HTMLElement;
     redraw(): void;
     moveLayer(id: string, beforeId?: string): void;
 
+/**
+     * Classic styles: prefer explicit slot.beforeId, else bottom-most admin boundary for `underlay`.
+     */
+    getSlotHostBeforeId(slotId: SlotId): string | undefined;
+    /**
+     * Host style layer id this MapsGL layer is pinned below.
+     */
+    getLayerHostBeforeId(layerId: string): string | undefined;
+
 getProjection(): ProjectionType;
     setProjection(projection: ProjectionType): void;
 
+/**
+     * Pin a MapsGL ordering slot into a Mapbox Standard style slot (`bottom` / `middle` / `top`),
+     * or clear the pin (`undefined` / `null`) to restore adapter defaults
+     * (`underlay` → `middle`, other built-ins → `top`).
+     * Repositions slot sentinels and reprojects layers in the slot.
+     */
+    setSlotMapboxSlot(slotId: SlotId, mapboxSlot?: MapboxStandardSlot | null): void;
+    /**
+     * Whether the current Mapbox style exposes Standard slots (`bottom` / `middle` / `top`).
+     */
+    usesMapboxStandardSlots(): boolean;
+    /**
+     * Mapbox Standard slot ids available on the current style.
+     * Empty when {@link usesMapboxStandardSlots} is false.
+     */
+    listMapboxStandardSlots(): MapboxStandardSlot[];
+    /**
+     * Resolve the Mapbox Standard slot a MapsGL slot maps into, if any.
+     * On Standard styles this is the explicit pin or an adapter default
+     * (`underlay` → `middle`, other built-ins → `top`).
+     */
+    getSlotMapboxSlot(slotId: SlotId): MapboxStandardSlot | undefined;
+
 dispose(all?: boolean): void;
 }
 
+/** Mapbox Standard Style native slot bands. */
+export declare type MapboxStandardSlot = 'bottom' | 'middle' | 'top';
+
 export declare class MapCamera {
     private _transform;
     private _orientation;
@@ -4045,6 +4430,11 @@ declare abstract class MapController<MapType> extends EventDispatcher {
      * The {@link WeatherLayerProvider} instance used for managing weather layer configurations and data.
      */
     readonly weatherProvider: WeatherLayerProvider;
+    /**
+     * Whether layer ordering slots are enabled for this controller.
+     * `true` when constructed with `slots: true` or a {@link SlotRegistryOptions} object.
+     */
+    readonly useLayerSlots: boolean;
 
 get needsViewportUpdate(): boolean;
     
@@ -4200,6 +4590,14 @@ get needsViewportUpdate(): boolean;
      * @param value - New value of the paint style property to set.
      */
     setPaintProperty(layerId: string, property: string, value: any): void;
+    /**
+     * Sets the stencil mask for the specified layer. Accepts the same mask configuration shape used when adding
+     * layers (`type: 'water' | 'land'`, `layers` by id, `mode`, and `invert`). Weather layer codes in
+     * `layers` are created as `::mask` instances when needed. Pass `null` or `undefined` to clear the mask.
+     * @param layerId - Map layer id or weather layer code for the target layer.
+     * @param mask - Mask configuration, a single mask layer id string, or `null`/`undefined` to clear.
+     */
+    setMask(layerId: string, mask?: LayerMaskConfiguration | LayerMaskSpecification | string | null): void;
     /**
      * Adds a legend control to the map in the specified DOM element.
      * @param target - The DOM element to add the legend control to.
@@ -4209,7 +4607,9 @@ get needsViewportUpdate(): boolean;
     addLegendControl(target: HTMLElement, options?: Partial<LegendControlOptions>): LegendControl;
     /**
      * Adds a data inspector control to the map.
-     * @param options - The configuration options for the data inspector control.
+     * @param options - Control options (`event`, `stream`, `showCoordinates`, `layout`, `tooltip`).
+     *   `layout`: `'auto'` (default) side-by-side for compact rows (scalars, badge, badge+value);
+     *   stack title above value for multi-line/block content; `'stacked'` always stacks.
      * @returns The newly added data inspector control instance.
      */
     addDataInspectorControl(options?: Partial<DataInspectorControlOptions>): DataInspectorControl;
@@ -4221,12 +4621,88 @@ get needsViewportUpdate(): boolean;
      * Removes the data inspector control from the map.
      */
     removeDataInspectorControl(): void;
-    addDayNightOverlay(): void;
+    /**
+     * Adds the day/night terminator overlay to the map, or updates it if already present.
+     * The overlay is always kept at the top of the MapsGL layer stack.
+     * @param options - Optional overlay settings such as {@link DayNightOverlayOptions.opacity}.
+     */
+    addDayNightOverlay(options?: DayNightOverlayOptions): void;
     removeDayNightOverlay(): void;
     /**
+     * Keep the day/night terminator above every other MapsGL layer. Weather layers added or
+     * reordered later would otherwise land on top of the overlay and hide the terminator.
+     *
+     * Updates the internal layer stack only, then asks the host map adapter to mirror that order.
+     * Avoid calling {@link moveLayer} here — Mapbox's override re-applies the original move after
+     * `super`, which would put content layers back above the overlay.
+     */
+    private bringDayNightOverlayToTop;
+    
+    /**
+     * Define or update a layer ordering slot. Custom slots are inserted below `overlay` by default.
+     * @param id - Slot identifier.
+     * @param definition - Optional host placement (`beforeId`).
+     */
+    defineSlot(id: SlotId, definition?: Omit<SlotDefinition, 'id'>): SlotDefinition;
+    /**
+     * Pin a MapsGL ordering slot below a host style layer (Mapbox/MapLibre `beforeId`),
+     * or clear the pin (`undefined` / `null`) to restore the slot's default host placement.
+     * Repositions the slot sentinel and reprojects layers currently in the slot.
+     */
+    setSlotBeforeId(slotId: SlotId, beforeId?: string | null): void;
+    /**
+     * Replace the bottom → top ordering of slots.
+     * @param ids - Slot identifiers in bottom-to-top order.
+     */
+    setSlotOrder(ids: SlotId[]): void;
+    /**
+     * Returns all slot definitions in bottom → top order.
+     */
+    listSlots(): SlotDefinition[];
+    /**
+     * Resolve the host style layer id a slot pins below, if any.
+     * Mapbox/MapLibre may return a runtime default (e.g. bottom-most admin boundary for `underlay`).
+     */
+    getSlotHostBeforeId(slotId: SlotId): string | undefined;
+    /**
+     * Host style layer id this MapsGL layer is pinned below (Mapbox/MapLibre `beforeId`).
+     * Undefined when the layer sits at the top of the host stack, or the host has no style layers.
+     */
+    getLayerHostBeforeId(_layerId: string): string | undefined;
+    /**
+     * Returns the slot id currently assigned to a MapsGL layer, if any.
+     * @param layerId - MapsGL layer identifier.
+     */
+    getSlot(layerId: string): SlotId | undefined;
+    /**
+     * Move a MapsGL layer into a different ordering slot, preserving its stack rank
+     * (or appending when ranks are equal / unset).
+     * @param layerId - MapsGL layer identifier.
+     * @param slotId - Target slot identifier.
+     */
+    moveLayerToSlot(layerId: string, slotId: SlotId): void;
+    /**
+     * Returns the within-slot stack rank for a layer (higher paints above siblings).
+     */
+    getStackRank(layerId: string): number | undefined;
+    /**
+     * Set the within-slot stack rank for a layer and re-insert it among siblings.
+     */
+    setStackRank(layerId: string, rank: number): void;
+    /**
+     * Override the default stack rank for a weather layer code / stack key.
+     * Applies to future inserts that resolve rank from that key.
+     */
+    setCodeStackRank(code: string, rank: number): void;
+
+/**
      * Returns whether the map currently contains a weather layer with the specified identifier.
      * @param id - Weather layer identifier to check for.
      * @returns `true` if the weather layer exists, otherwise `false`
+     * @remarks
+     * Layers that exist only as inactive hidden dependencies (e.g. a sample source auto-added for a
+     * {@link DataQueryTileLayer} text layer) are treated as not present until explicitly added via
+     * {@link MapController.addWeatherLayer}.
      */
     hasWeatherLayer(id: string): boolean;
     /**
@@ -4249,9 +4725,13 @@ get needsViewportUpdate(): boolean;
      * Adds a new weather layer to the map.
      * @param idOrConfig - One of the supported weather layer identifiers or a weather layer configuration object.
      * @param overrides - An object containing data and render style overrides for the weather layer.
-     * @param beforeId - The identifier of an existing map layer to insert the new layer before, which will result in
-     * the new layer appearing below the target layer. If not provided, then the new layer will be added to the end of
-     * the layer stack and above all other layers.
+     * When layer slots are enabled, may include `slot` to force a MapsGL ordering band
+     * (see {@link MapController.defineSlot}).
+     * @param beforeId - Optional insert-before id (MapsGL layer or Mapbox/MapLibre style layer).
+     * When layer slots are disabled (the default), omitted `beforeId` appends the layer above all
+     * other MapsGL layers. When slots are enabled (`slots: true` or a slots config object), omitted
+     * `beforeId` places the layer by type (raster/sample/fill → `underlay`; particle/line/circle/symbol
+     * → `inlay`; text → `text`) and within-slot `stackRank`.
      * @returns The newly added map layer or an array of layers if the weather layer identifier maps to multiple layers.
      */
     addWeatherLayer(idOrConfig: WeatherLayerConfiguration | string, overrides?: Partial<WeatherLayerOptions>, beforeId?: string): WebGLLayer | Array<WebGLLayer>;
@@ -4302,8 +4782,9 @@ get needsViewportUpdate(): boolean;
      * @param id - A unique identifier for the layer.
      * @param config - The configuration options for the layer.
      * @param beforeId - The identifier of an existing map layer to insert the new layer before, which will result in
-     * the new layer appearing below the target layer. If not provided, then the new layer will be added to the end of
-     * the layer stack and above all other layers.
+     * the new layer appearing below the target layer. If not provided, the new layer is added above all other
+     * MapsGL layers — or, when layer slots are enabled, according to its ordering slot (from layer type or
+     * `config.slot`).
      * @returns The newly added layer.
      */
     addLayer(id: string, config: Partial<LayerSpecification> | WebGLLayer, beforeId?: string): WebGLLayer;
@@ -4392,7 +4873,15 @@ get needsViewportUpdate(): boolean;
 protected getViewportState(): MapViewState;
 
 protected fadeSymbolsIfNeeded(): void;
-    
+
+/**
+     * Ensures a weather element's legend is registered when a legend control is present.
+     * Used both on initial add and when promoting a previously hidden query/dependency layer.
+     *
+     * `WeatherElement.addTo` assigns `legendId` from the legend config before the control
+     * exists, so presence of `legendId` does not mean the legend is already mounted.
+     */
+    private ensureWeatherLayerLegend;
     private setupLegendEvents;
 
 private _handleLayerLoadEvent;
@@ -4456,6 +4945,13 @@ export declare class MaplibreMapController extends MapboxMapController {
 
 getProjection(): ProjectionType;
     setProjection(projection: ProjectionType): void;
+    /**
+     * MapLibre has no Mapbox Standard slots. Inherited Mapbox Standard APIs are no-ops.
+     */
+    setSlotMapboxSlot(_slotId: SlotId, _mapboxSlot?: MapboxStandardSlot | null): void;
+    usesMapboxStandardSlots(): boolean;
+    listMapboxStandardSlots(): MapboxStandardSlot[];
+    getSlotMapboxSlot(_slotId: SlotId): MapboxStandardSlot | undefined;
 }
 
 /**
@@ -4778,6 +5274,11 @@ export declare type MapUnits = {
      * The current unit of measurement for ratio.
      */
     ratio: (typeof Units.ratio)[keyof typeof Units.ratio];
+    /**
+     * The current unit of measurement for index-based values (UVI, AQI, etc.).
+     * Index values have no unit conversion — they are always displayed as floored integers.
+     */
+    index: (typeof Units.index)[keyof typeof Units.index];
 };
 
 export declare interface MapViewState {
@@ -4816,15 +5317,134 @@ export declare interface MapViewState {
     projectionMatrix?: Matrix4;
 }
 
+/**
+ * Base class for all matrices.
+ */
+export declare class Matrix<T> {
+    /**
+     * The raw value of the matrix.
+     * @readonly
+     */
+    get value(): T;
+    /**
+     * Assigns the matrix values from an array.
+     * @param array - The array to assign the values from.
+     * @param offset - An optional offset to start assigning the values at.
+     */
+    fromArray(array: number[], offset?: number): Matrix<T>;
+    /**
+     * Returns the matrix as an array. If an array is provided, the values will be set to that array.
+     * @param array - An optional array to set the values to.
+     * @param offset - An optional offset to start setting the values at.
+     * @returns The array representation of the matrix.
+     */
+    toArray(array?: number[], offset?: number): number[];
+}
+
+/**
+ * Class representing a 3x3 matrix.
+ */
+export declare class Matrix3 extends Matrix<mat3> {
+    private _value;
+    get value(): mat3;
+    get elements(): number;
+    static get identity(): Matrix3;
+    static get zero(): Matrix3;
+    fromArray(array: number[], offset?: number): Matrix3;
+    toArray(array?: number[], offset?: number): number[];
+    clone(): Matrix3;
+    copy(m: Matrix3): Matrix3;
+    set(m00: number, m10: number, m20: number, m01: number, m11: number, m21: number, m02: number, m12: number, m22: number): Matrix3;
+    determinant(): number;
+    equals(m: Matrix3): boolean;
+    getNormalMatrix(m: Matrix4): void;
+    identity(): Matrix3;
+    invert(): Matrix3;
+    inverse(m: Matrix3): Matrix3;
+    rotate(radians: number): Matrix3;
+    scale(v: Vector2): Matrix3;
+    scaleScalar(s: number): Matrix3;
+    translate(v: Vector2): Matrix3;
+    transpose(): Matrix3;
+    multiply(m: Matrix3): Matrix3;
+    multiplyScalar(s: number): Matrix3;
+    toString(): string;
+}
+
+/**
+ * Class representing a 4x4 matrix.
+ */
+export declare class Matrix4 extends Matrix<mat4> {
+    private _value;
+    get value(): mat4;
+    get elements(): number;
+    get x(): number;
+    get y(): number;
+    get z(): number;
+    get w(): number;
+    static get identity(): Matrix4;
+    static get zero(): Matrix4;
+    fromArray(array: number[], offset?: number): Matrix4;
+    toArray(array?: number[], offset?: number): number[];
+    fromRotationX(radians: number): Matrix4;
+    fromRotationY(radians: number): Matrix4;
+    fromRotationZ(radians: number): Matrix4;
+    fromScale(v: Vector3): Matrix4;
+    fromTranslation(v: Vector3): Matrix4;
+    fromPerspective(fovy: number, aspect: number, near: number, far: number): Matrix4;
+    fromOrthogonal(left: number, right: number, top: number, bottom: number, near: number, far: number): Matrix4;
+    fromQuaternion(q: Quaternion): Matrix4;
+    clone(): Matrix4;
+    copy(m: Matrix4): Matrix4;
+    determinant(): number;
+    equals(m: Matrix4): boolean;
+    getColumn(col: number): Vector4;
+    setColumn(col: number, v: Vector4): Matrix4;
+    getRotation(q?: Quaternion): Quaternion;
+    getScale(v?: Vector3): Vector3;
+    getTranslation(v?: Vector3): Vector3;
+    identity(): Matrix4;
+    invert(): Matrix4;
+    inverse(m: Matrix4): Matrix4;
+    transpose(): Matrix4;
+    lookAt(eye: Vector3, center?: Vector3, up?: Vector3): Matrix4;
+    multiply(m1: Matrix4, m2?: Matrix4): Matrix4;
+    multiplyScalar(s: number): Matrix4;
+    premultiply(m: Matrix4): Matrix4;
+    rotateX(radians: number): Matrix4;
+    rotateY(radians: number): Matrix4;
+    rotateZ(radians: number): Matrix4;
+    scale(v: Vector3): Matrix4;
+    scaleScalar(s: number): Matrix4;
+    translate(v: Vector3): Matrix4;
+    compose(translation: Vector3, quaternion: Quaternion, scale: Vector3): Matrix4;
+    decompose(): {
+        rotation: Quaternion;
+        scale: Vector3;
+        translation: Vector3;
+    };
+    toString(): string;
+}
+
 declare const mbToHg: (mb: number) => number;
 
 declare const mbToPa: (mb: number) => number;
-
-export declare type Measurement = keyof typeof Units | 'height' | 'snowfall' | 'intensity';
 
 export declare type MessageHandler = (result: any) => any;
 
-declare const miToM: (mi: number) => number;
+/**
+ * Converts precipitation rate in mm/hr (or mm/s if perSecond=true) to dBZ.
+ * This is the inverse of the dbzToMMRate formula:
+ *   dbzToMMRate(dbz) = (10 ** (dbz / 10) / 200) ** (5/8)
+ *
+ * So,
+ *   dbz = 10 * log10(200 * (mmRate) ** (8/5))
+ *
+ * @param mmRate Precipitation rate in mm/hr or mm/s
+ * @param perSecond If true, mmRate is in mm/s (default: false, expects mm/hr)
+ * @returns Equivalent reflectivity (dBZ)
+ */
+declare const mmRateToDbz: (mmRate: number, perSecond?: boolean) => number;
 
 declare const mmToIn: (mm: number) => number;
 
@@ -5200,6 +5820,18 @@ export declare interface PointLegendOptions extends LegendOptions {
 
 export declare type Polygon = Array<Array<Point>>;
 
+export declare interface ProgramConfiguration {
+    vertexShader: string;
+    fragmentShader: string;
+    includes?: Record<string, string>;
+    defines?: Array<string>;
+    uniforms?: Record<string, any>;
+    onBeforeCompile?: (shader: {
+        vertex: string;
+        fragment: string;
+    }) => void;
+}
+
 export declare interface Projection {
     type: ProjectionType;
     zAxisUnit: 'meters' | 'pixels';
@@ -5242,6 +5874,13 @@ export declare interface Projection {
     metersPerPixel(lat: number, zoom: number): number;
 }
 
+export declare class ProjectionMatrix extends Matrix4 {
+    frustum(left: number, right: number, top: number, bottom: number, near: number, far: number): ProjectionMatrix;
+    orthographic(left: number, right: number, top: number, bottom: number, near: number, far: number): ProjectionMatrix;
+    perspective(fovy: number, aspect: number, near: number, far: number): ProjectionMatrix;
+    lookAt(eye: Vector3, center?: Vector3, up?: Vector3): ProjectionMatrix;
+}
+
 declare const ProjectionType: {
     readonly mercator: "mercator";
     readonly globe: "globe";
@@ -5250,30 +5889,80 @@ declare const ProjectionType: {
 export declare type ProjectionType = ObjectValue<typeof ProjectionType>;
 
 /**
- * A `Query` object is a convenience wrapper for setting up and configuring a query string used
- * for API queries.
+ * Implementation of a quaternion that is used to represent rotations.
+ * @see https://en.wikipedia.org/wiki/Quaternion
+ * @see https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation
  */
-export declare class Query {
-    private _conditions;
-    /**
-     * Initializes a query instance, optionally with an array of query conditions.
-     * @param conditions - An array of query conditions to initialize the query with.
-     */
-    constructor(conditions?: QueryCondition[]);
-    /**
-     * Adds a query condition.
-     * @param condition - The query condition to add.
-     */
-    addCondition(condition: QueryCondition): Query;
-    /**
-     * Removes a query condition.
-     * @param condition - The query condition to remove.
-     */
-    removeCondition(condition: QueryCondition): Query;
-    /**
-     * Removes all query conditions.
-     */
-    removeAllConditions(): Query;
+export declare class Quaternion {
+
+get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get w(): number;
+    set w(value: number);
+    get value(): quat;
+    get elements(): number;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    fromArray(array: number[], offset?: number): Quaternion;
+    toArray(array?: number[], offset?: number): number[];
+    fromObject({ x, y, z, w }: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): Quaternion;
+    toObject(): {
+        x: number;
+        y: number;
+    };
+    fromAxisAngle(axis: Vector3, radians: number): Quaternion;
+    fromEuler(e: Euler): Quaternion;
+    fromRotationMatrix(): Quaternion;
+    set(x: number, y: number, z: number, w: number): Quaternion;
+    length(): number;
+    clone(): Quaternion;
+    copy(q: Quaternion): Quaternion;
+    equals(q: Quaternion): boolean;
+    identity(): Quaternion;
+    invert(): Quaternion;
+    conjugate(): Quaternion;
+    normalize(): Quaternion;
+    rotateX(radians: number): Quaternion;
+    rotateY(radians: number): Quaternion;
+    rotateZ(radians: number): Quaternion;
+    dot(q: Quaternion): number;
+    angleTo(q: Quaternion): number;
+
+}
+
+/**
+ * A `Query` object is a convenience wrapper for setting up and configuring a query string used
+ * for API queries.
+ */
+export declare class Query {
+    private _conditions;
+    /**
+     * Initializes a query instance, optionally with an array of query conditions.
+     * @param conditions - An array of query conditions to initialize the query with.
+     */
+    constructor(conditions?: QueryCondition[]);
+    /**
+     * Adds a query condition.
+     * @param condition - The query condition to add.
+     */
+    addCondition(condition: QueryCondition): Query;
+    /**
+     * Removes a query condition.
+     * @param condition - The query condition to remove.
+     */
+    removeCondition(condition: QueryCondition): Query;
+    /**
+     * Removes all query conditions.
+     */
+    removeAllConditions(): Query;
     /**
      * Returns the formatted string from all query conditions to be used for API requests.
      */
@@ -5396,7 +6085,7 @@ export declare interface RemoteSymbolImage {
     /** Indicates if the image is a pattern image. */
     pattern?: boolean;
 }
-
+
 /**
  * Context built by the layer each frame and passed to prerender() and draw().
  * Contains all map and layer state needed for the render path so the renderer
@@ -5481,8 +6170,9 @@ export declare interface RenderFrameContextTileLayer {
     allowExpiredTilesForRender?: boolean;
 }
 
-declare const resolveMeasurementForUnits: (type: ConversionMeasurement) => Measurement;
-
+/** Collapses `'temperature-delta'` to `'temperature'` — `MapUnits` (unlike `Measurement`) has no `'temperature-delta'` key of its own, since a temperature delta is always displayed in the same unit its absolute counterpart is. */
+declare const resolveMeasurementForUnits: (type: ConversionMeasurement) => keyof MapUnits;
+
 /**
  * RGBAImage represents a 2D grid of image data. Them image data should NOT be premultipled since ImageData is not.
  * Therefore, UNPACK_PREMULTIPLY_ALPHA_WEBGL must be used when uploading the image data to the GPU via a texture.
@@ -5497,11 +6187,11 @@ export declare class RGBAImage {
     padding: number;
     get width(): number;
     get height(): number;
-    
-    constructor(data: Uint8Array, dimension: number, pad?: number);
+
+constructor(data: Uint8Array, dimension: number, pad?: number);
     get(x: number, y: number): RGB;
-    
-    /**
+
+/**
      * Computes the index offset for the specified x and y coordinates and image width.
      * @param x -
      * @param y -
@@ -5544,6 +6234,21 @@ export declare const SampleExpression: {
 
 export declare type SampleExpression = ObjectValue<typeof SampleExpression>;
 
+/** Optional nodata gate for interpolated sampling (matches shader `incompleteBilinearCell`). */
+export declare type SamplePixelOptions = {
+    /** Nodata byte value (0–255). When unset or `< 0`, nodata gating is disabled. */
+    noDataValue?: number;
+    /** Channel used to detect nodata corners. Defaults to `r`. */
+    channel?: ColorBand;
+    /**
+     * Fill-shader smoothing (`0`…`1`). CPU queries must use the same coarsened lattice as
+     * `get_texel.glsl` or city labels / inspector values will not match the painted bands.
+     */
+    smoothing?: number;
+    /** Encoded-tile edge padding in texels, used to quantize the smoothing scale like the shader. */
+    edgePad?: number;
+};
+
 /**
  * Sample style properties control how encoded data gets rendered on a map. Sample rendering is performed by sampling
  * values from the underlying data and mapping it to a desired result, such as color fill, contour line, etc.
@@ -5604,6 +6309,68 @@ export declare interface SampleStyleSpec {
     drawRange: Partial<ValueRange>;
 }
 
+/**
+ * The type of shader.
+ */
+declare const enum ShaderType {
+    VERTEX = "vertex",
+    FRAGMENT = "fragment"
+}
+
+export declare type Size = {
+    width: number;
+    height: number;
+};
+
+/**
+ * Definition of a MapsGL layer ordering slot.
+ * Slots are logical bands; Mapbox/MapLibre adapters project them onto the host style stack.
+ */
+export declare interface SlotDefinition {
+    id: SlotId;
+    /**
+     * Classic Mapbox / MapLibre: place this slot's ceiling below this style layer id.
+     */
+    beforeId?: string;
+    /**
+     * Mapbox Standard only: place this slot's layers in a Standard style slot.
+     */
+    mapboxSlot?: MapboxStandardSlot;
+}
+
+/** Identifier for a MapsGL ordering slot (built-in or user-defined). */
+export declare type SlotId = string;
+
+/**
+ * Options for configuring the slot registry at controller construction.
+ * Passed as {@link MapAdapterOptions.slots} to opt in to layer ordering slots.
+ */
+export declare interface SlotRegistryOptions {
+    /**
+     * Partial overrides for built-in or custom slots, keyed by slot id.
+     * Use {@link SlotRegistry.defineSlot} / {@link SlotRegistry.setSlotBeforeId} /
+     * {@link SlotRegistry.setSlotOrder} at runtime for full control.
+     */
+    slots?: Partial<Record<SlotId, Omit<SlotDefinition, 'id'>>>;
+    /**
+     * Overrides for the default layer-type → slot mapping.
+     */
+    typeMapping?: Partial<Record<LayerType, SlotId>>;
+    /**
+     * Default within-slot stack ranks keyed by weather layer code / stack key
+     * (higher paints above siblings in the same slot). Merged over built-in defaults.
+     */
+    stackRanks?: Record<string, number>;
+    /**
+     * Optional override for resolving a layer's stack rank. Return `undefined` to fall
+     * through to {@link stackRanks} / built-in rules.
+     */
+    resolveStackRank?: (ctx: StackRankContext) => number | undefined;
+}
+
+/** Stable style-layer id for a slot sentinel (ceiling marker). */
+export declare const slotSentinelId: (slotId: SlotId) => string;
+
 export declare type SortProperty = {
     property: string;
     direction?: 'asc' | 'desc';
@@ -5851,6 +6618,14 @@ export declare interface SourceSpecification {
     transformMetadata?: (source: DataSource, data: Record<string, any>, options?: SourceMetadataTransformOptions) => Partial<SourceMetadataSchema>;
 }
 
+/** Context passed to a custom stack-rank resolver. */
+export declare interface StackRankContext {
+    layerId: string;
+    /** Weather layer code or other lookup key (often the weather id when the instance id differs). */
+    stackKey?: string;
+    type?: LayerType | string;
+}
+
 export declare class State<T> extends EventDispatcher {
     #private;
     get value(): T;
@@ -5983,12 +6758,30 @@ export declare interface StyledImageRenderer {
 
 export declare type StyleEvaulatorFunction<T> = (properties: Record<string, any>) => T;
 
+/**
+ * The expression *type* and operator vocabulary are owned by the shared weather spec package
+ * (`@xweather/mapsgl-weather-spec`) so they can be authored declaratively in layer specs there;
+ * re-exported here to preserve existing import paths. Only the type/vocabulary moved — the
+ * interpreter below, animation-time globals, and legacy-filter-migration helpers are runtime
+ * concerns and stay in webgl-maps.
+ */
 export declare interface StyleExpression {
     property: string;
     type?: 'identity' | 'expression';
     evaluator?: (value: any) => any;
 }
 
+/**
+ * Style layer descriptors used when resolving a default `underlay` slot ceiling from the
+ * loaded Mapbox/MapLibre style.
+ */
+export declare type StyleLayerRef = {
+    id?: string;
+    type?: string;
+    'source-layer'?: string;
+    sourceLayer?: string;
+};
+
 export declare const styles: {
     datasets: {};
     colorscales: {
@@ -6243,6 +7036,29 @@ export declare interface TaskRunnerConfig<Task extends DownloadTask<any>> {
     taskTransformer?: (task: Task) => Task;
 }
 
+/**
+ * Data that can be used to create a texture.
+ */
+export declare type TexImage2DData = GLintptr | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap | ImageData | ArrayBufferView | ArrayBuffer | undefined;
+
+/**
+ * TextMetrics is a set of metrics for a single character in a font layout spec.
+ */
+export declare type TextMetrics_2 = {
+    id: number;
+    index: number;
+    char: string;
+    width: number;
+    height: number;
+    xoffset: number;
+    yoffset: number;
+    xadvance: number;
+    chnl: number;
+    x: number;
+    y: number;
+    page: number;
+};
+
 /**
  * Text style properties control how text gets rendered on a map from vector features. Use these properties on
  * conjunction with `symbol` to define the style for a text layer.
@@ -6606,6 +7422,10 @@ declare abstract class TileLayer<Data> extends WebGLLayer<TileSource> {
     /**
      * Returns whether expired tiles can still be used for rendering/LOD fallback.
      * Default is disabled so stale tiles are not rendered after data refreshes.
+     *
+     * For dynamic (frequently-updated) GeoJSON sources such as the day/night terminator, keep
+     * rendering the last-good tiles while the source re-slices the new data instead of blanking the
+     * layer during the async reslice window. Mirrors {@link DataQueryTileLayer}.
      */
     shouldRenderExpiredTiles(): boolean;
     refresh(clear?: boolean): void;
@@ -6642,11 +7462,13 @@ declare abstract class TileLayer<Data> extends WebGLLayer<TileSource> {
      * Returns the tile at the specified geographic coordinate.
      * @param coord - Geographic coordinate to get the tile for.
      * @param allowPartials - Whether to allow returning a tile that only partially contains the queried coordinate.
-     * @returns Tile and position within the tile for the specified coordinate.
+     * @returns Tile, position within the tile for the specified coordinate, and the renderable the tile was resolved
+     * from when a partial (ancestor or descendant) was used.
      */
     protected getTile(coord: Coordinate, zoom?: number, allowPartials?: boolean): {
         tile: Tile<Data>;
         position: Point;
+        renderable?: AnyTileRenderable;
     } | undefined;
     /**
      * Returns the visible tile coordinates based on the map's current viewport.
@@ -6712,6 +7534,97 @@ export declare type TilePositionData = {
 };
 
 export declare type TileQuadrant = 'tl' | 'tc' | 'tr' | 'ml' | 'mc' | 'mr' | 'bl' | 'bc' | 'br';
+
+/**
+ * A renderable tile object that contains the necessary transformation information for rendering a tile to a WebGL
+ * context on a map.
+ * @template Data The type of data that the tile contains.
+ */
+export declare class TileRenderable<Data> {
+    /**
+     * The tile to be rendered.
+     */
+    tile: Tile<Data>;
+    /**
+     * The scale to apply to the tile's mesh.
+     */
+    readonly scale: Vector3;
+    /**
+     * The offset to apply to the tile's mesh.
+     */
+    readonly offset: Vector3;
+    /**
+     * The UV offset and scale to use when sampling texture data for the tile. If the tile is not a partial tile,
+     * then this value is `[0, 0, 1, 1]`.
+     */
+    uvOffset: [number, number, number, number];
+    /**
+     * Scale of the mesh relative to the partial tile's scale. If the tile is not a partial tile, then this value
+     * is `1`.
+     */
+    partialScale: number;
+    /**
+     * The tile coordinate of the tile being rendered. This may be different than the tile's actual coordinate if
+     * the tile is a partial tile.
+     */
+    coord: TileCoord;
+    /** Whether this renderable may use expired tile data (layer-level opt-in). */
+    allowExpired: boolean;
+    /**
+     * Resolved textures or vector data for this renderable. When set, draw passes use this instead of
+     * querying tile data or timeState. Resolved at LOD resolution time for both time-series and non-time-series.
+     */
+    resolvedData?: ResolvedTileData;
+    /**
+     * The hash of the tile coordinate of the tile being rendered.
+     * @readonly
+     */
+    get hash(): string;
+    constructor(tile: Tile<Data>, scale: Point, offset: Point, uvOffset?: UVOffset);
+    /**
+     * Updates an existing renderable in place to avoid per-frame allocations.
+     * @param tile - The tile to be rendered.
+     * @param coord - The unnormalized tile coordinate of the tile.
+     */
+    updateFromTile(tile: Tile<Data>, coord: TileCoord): void;
+    /**
+     * Updates an existing renderable in place to avoid per-frame allocations.
+     * @param partial - The tile partial to be rendered.
+     * @param coord - The unnormalized tile coordinate of the tile.
+     */
+    updateFromAncestorPartial(partial: TilePartial<Data>, coord: TileCoord): void;
+    /**
+     * Updates an existing renderable in place to avoid per-frame allocations.
+     * @param partial - The tile partial to be rendered.
+     * @param coord - The unnormalized tile coordinate of the tile.
+     */
+    updateFromDescendantPartial(partial: TilePartial<Data>, coord: TileCoord): void;
+    /**
+     * Returns the view matrix for the tile including its scale and translation transformations.
+     */
+    getViewMatrix(): ProjectionMatrix;
+    /**
+     * Creates and returns a new TileRenderable object from a source tile and a coordinate.
+     * @param tile - The source tile.
+     * @param coord - The coordinate of the tile being rendered.
+     * @returns A new TileRenderable object.
+     */
+    static fromTile<Data>(tile: Tile<Data>, coord: TileCoord): TileRenderable<Data>;
+    /**
+     * Creates and returns a TileRenderable object from an ancestor of the tile.
+     * @param partial - The tile partial to be rendered.
+     * @param coord - The unnormalized tile coordinate of the tile.
+     * @returns
+     */
+    static fromAncestorPartial<Data>(partial: TilePartial<Data>, coord: TileCoord): TileRenderable<Data>;
+    /**
+     * Creates and returns a TileRenderable object from an descendant of the tile.
+     * @param partial - The tile partial to be rendered.
+     * @param coord - The unnormalized tile coordinate of the tile.
+     * @returns
+     */
+    static fromDescendantPartial<Data>(partial: TilePartial<Data>, coord: TileCoord): TileRenderable<Data>;
+}
 
 /**
  * Options for a tile request.
@@ -6970,14 +7883,6 @@ export declare interface TileSourceSpecification extends SourceSpecification {
      * Map projection of the source. Defaults to `EPSG:3857`.
      */
     projection: 'EPSG:3857' | 'EPSG:4326';
-    /**
-     * A function that requests a tile from the source.
-     * @param tile - The tile to load.
-     * @param url - The URL template string to use when requesting the tile.
-     * @param options - Additional options to use when requesting the tile.
-     * @returns A promise that resolves to the response from the tile request.
-     */
-    loadTile: (tile: TileCoord, url: string, options?: Partial<TileRequestOptions>) => Promise<Response>;
 }
 
 export declare const TileState: {
@@ -7103,8 +8008,9 @@ export declare class TimeAnimation extends Animation {
     playFromDate(date: Date): void;
     /**
      * Advances the animation to a specific position based on a date.
-     * @param date - The date to advance to. If the date is outside the range of the animation, it will be clamped to
-     * the start or end date.
+     * @param date - The date to advance to. Must be within the animation's start and end date range.
+     * @throws {TypeError} If `date` is not a valid `Date`.
+     * @throws {RangeError} If `date` is outside the animation's start and end date range.
      */
     goToDate(date: Date): void;
     /**
@@ -7112,6 +8018,12 @@ export declare class TimeAnimation extends Animation {
      * @param offset - The time offset in milliseconds.
      */
     goToOffset(offset: number): void;
+    /**
+     * Gets the position of the animation based on a date clamped to the start and end date. The position is a value
+     * between 0 and 1, where 0 is the start date and 1 is the end date.
+     * @param date - The date to get the position from.
+     * @returns The position of the animation.
+     */
     getPositionFromDate(date: Date): number;
     /**
      * Restricts the animation to a specific date range relative to the overall start and end date.
@@ -7128,6 +8040,7 @@ export declare class TimeAnimation extends Animation {
     private _captureRangeChangeAnchorDate;
     /**
      * Restores the anchor date for the range change event.
+     * Clamps to the new range when the previous playhead falls outside it.
      */
     private _restoreRangeChangeAnchorDate;
 }
@@ -7301,7 +8214,7 @@ export declare type TimeSeriesOperation = {
     period?: TimeSeriesOperationPeriod;
     /**
      * Whether to aggregate the data, meaning to combine the data from multiple intervals of the desired period into a
-     * single value.
+     * single value. When `period` is `full` (or `none`), this aggregates across the entire set of intervals.
      */
     aggregate?: boolean;
     /**
@@ -7319,13 +8232,14 @@ export declare type TimeSeriesOperation = {
  * Period of time to perform an operation on the data within a time series.
  *
  * - `none`: Does not perform the operation on a periodic basis.
+ * - `full`: Performs the operation once across the entire set of intervals (not grouped by calendar period).
  * - `hour`: Performs the operation on an hourly basis.
  * - `day`: Performs the operation on a daily basis.
  * - `week`: Performs the operation on a weekly basis.
  * - `month`: Performs the operation on a monthly basis.
  * - `year`: Performs the operation on a yearly basis.
  */
-export declare type TimeSeriesOperationPeriod = 'none' | 'hour' | 'day' | 'week' | 'month' | 'year';
+export declare type TimeSeriesOperationPeriod = 'none' | 'full' | 'hour' | 'day' | 'week' | 'month' | 'year';
 
 /**
  * Type of operation to perform on the data within a time series.
@@ -7347,74 +8261,14 @@ export declare type TimestampledPixel = {
     pixel: RGB;
 };
 
+export declare type TypedArray = Float64Array | Float32Array | Uint16Array | Int16Array | Uint32Array | Int32Array | Uint8Array | Int8Array | Uint8ClampedArray;
+
 /**
  * A unit converter function.
  */
 export declare type UnitConverter = (value: number, from: string, to: string) => number;
 
-/**
- * The supported units of measurement.
- */
-declare const Units: {
-    readonly temperature: {
-        readonly C: "C";
-        readonly F: "F";
-    };
-    readonly speed: {
-        readonly kmh: "km/h";
-        readonly mph: "mph";
-        readonly ms: "m/s";
-        readonly kts: "kts";
-    };
-    readonly pressure: {
-        readonly mb: "mb";
-        readonly pa: "Pa";
-        readonly hPa: "hPa";
-        readonly hg: "inHg";
-    };
-    readonly distance: {
-        readonly m: "m";
-        readonly km: "km";
-        readonly ft: "ft";
-        readonly mi: "mi";
-    };
-    readonly precipitation: {
-        readonly mm: "mm";
-        readonly cm: "cm";
-        readonly in: "in";
-        readonly m: "m";
-        readonly ft: "ft";
-    };
-    readonly direction: {
-        readonly deg: "°";
-    };
-    readonly time: {
-        readonly hr: "hr";
-        readonly min: "min";
-        readonly sec: "sec";
-        readonly ms: "ms";
-    };
-    readonly rate: {
-        readonly mmhr: "mm/hr";
-        readonly inhr: "in/hr";
-        readonly mms: "mm/sec";
-        readonly dbz: "dBZ";
-    };
-    readonly concentration: {
-        readonly ppm: "ppm";
-        readonly ugm3: "ug/m^3";
-    };
-    readonly ratio: {
-        readonly percent: "%";
-    };
-};
-
 export declare const units: {
-    UnitSystem: {
-        readonly metric: "metric";
-        readonly imperial: "imperial";
-        readonly custom: "custom";
-    };
     Units: {
         readonly temperature: {
             readonly C: "C";
@@ -7467,10 +8321,23 @@ export declare const units: {
         readonly ratio: {
             readonly percent: "%";
         };
+        readonly index: {
+            readonly uvi: "uvi";
+            readonly aqi: "aqi";
+            readonly aqhi: "aqhi";
+        };
+    };
+    miToM: (mi: number) => number;
+    inToMM: (ins: number) => number;
+    inToMMRate: (ins: number) => number;
+    UnitSystem: {
+        readonly metric: "metric";
+        readonly imperial: "imperial";
+        readonly custom: "custom";
     };
-    resolveMeasurementForUnits: (type: _units.ConversionMeasurement) => _units.Measurement;
+    resolveMeasurementForUnits: (type: _units.Measurement) => keyof MapUnits;
     defaultUnits: Record<"metric" | "imperial", MapUnits>;
-    getDefaultUnit: (type: _units.ConversionMeasurement, system: "metric" | "imperial" | "custom") => string;
+    getDefaultUnit: (type: _units.Measurement, system: "metric" | "imperial" | "custom") => string;
     getDefaultUnitsForSystem: (system: "metric" | "imperial" | "custom") => MapUnits;
     equalUnits: (units1: MapUnits, units2: MapUnits) => boolean;
     getSystemForUnits: (units: MapUnits) => "metric" | "imperial" | "custom";
@@ -7493,17 +8360,15 @@ export declare const units: {
     kmToM: (km: number) => number;
     ftToM: (ft: number) => number;
     kmToMi: (km: number) => number;
-    miToM: (mi: number) => number;
     mmToIn: (mm: number) => number;
-    inToMM: (ins: number) => number;
     inToM: (ins: number) => number;
-    inToMMRate: (ins: number) => number;
     mmToMMRate: (mm: number) => number;
     CtoFUnit: (c: number) => number;
     FtoCUnit: (f: number) => number;
     mphToMsUnit: (mph: number) => number;
     msToMphUnit: (ms: number) => number;
     dbzToMMRate: (dbz: number, perSecond?: boolean) => number;
+    mmRateToDbz: (mmRate: number, perSecond?: boolean) => number;
     degToDir: (d: number) => string;
     getUnitPrecision: (unit: string) => number;
     convert: (type: string, value: number, from: string, to: string) => number;
@@ -7512,9 +8377,12 @@ export declare const units: {
 
 declare namespace _units {
     export {
-        UnitSystem,
         Units,
+        miToM,
+        inToMM,
+        inToMMRate,
         Measurement,
+        UnitSystem,
         ConversionMeasurement,
         resolveMeasurementForUnits,
         defaultUnits,
@@ -7541,17 +8409,15 @@ declare namespace _units {
         kmToM,
         ftToM,
         kmToMi,
-        miToM,
         mmToIn,
-        inToMM,
         inToM,
-        inToMMRate,
         mmToMMRate,
         CtoFUnit,
         FtoCUnit,
         mphToMsUnit,
         msToMphUnit,
         dbzToMMRate,
+        mmRateToDbz,
         degToDir,
         getUnitPrecision,
         convert,
@@ -7592,10 +8458,191 @@ export declare const utils: {
     };
 };
 
-export declare type ValueRange = {
-    min: number;
-    max: number;
-};
+/**
+ * Represents the offset and scale for sampling texture data as `[ xOffset, yOffset, xScale, yScale ]`.
+ */
+export declare type UVOffset = [number, number, number, number];
+
+/**
+ * Base class for all vectors.
+ */
+export declare class Vector<T> {
+    /**
+     * The raw value of the vector.
+     * @readonly
+     */
+    get value(): T;
+    /**
+     * Assigns the vector values from an array.
+     * @param array - The array to assign the values from.
+     * @param offset - An optional offset to start assigning the values at.
+     */
+    fromArray(array: number[], offset?: number): Vector<T>;
+    /**
+     * Returns the vector as an array. If an array is provided, the values will be set to that array.
+     * @param array - An optional array to set the values to.
+     * @param offset - An optional offset to start setting the values at.
+     * @returns The array representation of the vector.
+     */
+    toArray(array?: number[], offset?: number): number[];
+}
+
+/**
+ * Class representing a 2D vector and consisting of an ordered pair of numbers (x, y).
+ */
+export declare class Vector2 extends Vector<vec2> {
+    private _value;
+    get value(): vec2;
+    get elements(): number;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    constructor(x?: number, y?: number);
+    fromArray(array: number[], offset?: number): Vector2;
+    toArray(array?: number[], offset?: number): number[];
+    fromObject({ x, y }: {
+        x: number;
+        y: number;
+    }): Vector2;
+    toObject(): {
+        x: number;
+        y: number;
+    };
+    set(x: number, y: number): Vector2;
+    setScalar(v: number): Vector2;
+    length(): number;
+    angle(): number;
+    copy(v: Vector2): Vector2;
+    clone(): Vector2;
+    add(v: Vector2): Vector2;
+    addScalar(s: number): Vector2;
+    subtract(v: Vector2): Vector2;
+    subtractScalar(s: number): Vector2;
+    multiply(v: Vector2): Vector2;
+    multiplyScalar(s: number): Vector2;
+    divide(v: Vector2): Vector2;
+    divideScalar(s: number): Vector2;
+    distanceTo(v: Vector2): number;
+    dot(v: Vector2): number;
+    equals(v: Vector2): boolean;
+    lerp(v: Vector2, factor: number): Vector2;
+    normalize(): Vector2;
+    scale(v: number): Vector2;
+    applyMatrix3(m: Matrix3): Vector2;
+    applyMatrix4(m: Matrix4): Vector2;
+}
+
+/**
+ * Class representing a 3D vector and consisting of an ordered triplet of numbers (x, y, z).
+ */
+export declare class Vector3 extends Vector<vec3> {
+    private _value;
+    get value(): vec3;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get elements(): number;
+    constructor(x?: number, y?: number, z?: number);
+    fromArray(array: number[], offset?: number): Vector3;
+    toArray(array?: number[], offset?: number): number[];
+    fromObject({ x, y, z }: {
+        x: number;
+        y: number;
+        z: number;
+    }): Vector3;
+    toObject(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    set(x: number, y: number, z: number): Vector3;
+    setScalar(v: number): Vector3;
+    length(): number;
+    distanceToSquared(v: Vector3): number;
+    angle(): number;
+    copy(v: Vector3): Vector3;
+    clone(): Vector3;
+    add(v: Vector3): Vector3;
+    addScalar(s: number): Vector3;
+    subtract(v: Vector3): Vector3;
+    subtractScalar(s: number): Vector3;
+    subVectors(a: Vector3, b: Vector3): Vector3;
+    multiply(v: Vector3): Vector3;
+    multiplyScalar(s: number): Vector3;
+    divide(v: Vector3): Vector3;
+    divideScalar(s: number): Vector3;
+    distanceTo(v: Vector3): number;
+    angleTo(v: Vector3): number;
+    dot(v: Vector3): number;
+    equals(v: Vector3): boolean;
+    lerp(v: Vector3, factor: number): Vector3;
+    normalize(): Vector3;
+    scale(v: number): Vector3;
+    rotateX(angle: number): Vector3;
+    rotateY(angle: number): Vector3;
+    rotateZ(angle: number): Vector3;
+    applyEuler(e: Euler): Vector3;
+    applyMatrix3(m: Matrix3): Vector3;
+    applyMatrix4(m: Matrix4): Vector3;
+    applyQuaternion(q: Quaternion): Vector3;
+    negate(): Vector3;
+}
+
+/**
+ * Class representing a 4D vector and consisting of an ordered quadruplet of numbers (x, y, z, w).
+ */
+export declare class Vector4 extends Vector<vec4> {
+    private _value;
+    get value(): vec4;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get w(): number;
+    set w(value: number);
+    get elements(): number;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    fromArray(array: number[], offset?: number): Vector4;
+    toArray(array?: number[], offset?: number): number[];
+    fromObject({ x, y, z, w }: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): Vector4;
+    toObject(): {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    set(x: number, y: number, z: number, w: number): Vector4;
+    setScalar(v: number): Vector4;
+    length(): number;
+    copy(v: Vector4): Vector4;
+    clone(): Vector4;
+    add(v: Vector4): Vector4;
+    addScalar(s: number): Vector4;
+    subtract(v: Vector4): Vector4;
+    subtractScalar(s: number): Vector4;
+    multiply(v: Vector4): Vector4;
+    multiplyScalar(s: number): Vector4;
+    divide(v: Vector4): Vector4;
+    divideScalar(s: number): Vector4;
+    distanceTo(v: Vector4): number;
+    dot(v: Vector4): number;
+    equals(v: Vector4): boolean;
+    lerp(v: Vector4, factor: number): Vector4;
+    normalize(): Vector4;
+    scale(v: number): Vector4;
+    applyMatrix4(m: Matrix4): Vector4;
+}
 
 /**
  * Represents the configuration for a vector tile data source.
@@ -7652,6 +8699,13 @@ export declare class VectorTileSource extends TileSource<VectorTileData, VectorS
 
 export declare const version: string;
 
+export declare interface ViewBounds {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+
 export declare const weather: {
     /**
      * @deprecated
@@ -7749,6 +8803,10 @@ export declare interface WeatherLayerMetadata {
      * Update frequency of the layer's data.
      */
     updateInterval: string;
+    /**
+     * Optional thumbnail image URL for the weather layer.
+     */
+    imageUrl?: string;
 }
 
 /**
@@ -7846,6 +8904,20 @@ export declare type WeatherLayerOptions = {
      * parameters and per-feature animation controllers.
      */
     timeline: TimeAnimation;
+    /**
+     * MapsGL ordering slot for this weather layer. Ignored unless layer slots are
+     * enabled on the controller (`slots: true` or a slots configuration object).
+     * When omitted and slots are enabled, the slot is chosen from the layer type.
+     * Use with {@link MapController.defineSlot} / {@link MapController.moveLayerToSlot}.
+     * Prefer this over a host `beforeId` when targeting a logical band; an explicit `beforeId`
+     * argument to {@link MapController.addWeatherLayer} still wins for host placement.
+     */
+    slot?: string;
+    /**
+     * Within-slot stack rank (higher paints above siblings). When omitted, defaults are
+     * resolved from the weather layer code (e.g. radar above satellite above other underlays).
+     */
+    stackRank?: number;
     /**
      * Options for configuring a mask to apply to the layer.
      */
@@ -7863,6 +8935,11 @@ export declare class WeatherLayerProvider {
 constructor(account: Account);
     initialize(account: Account, style: MapStyle): Promise<void>;
     isWeatherLayer(code: string): boolean;
+    /**
+     * Returns the identifiers for all weather layers supported by this SDK build.
+     * Values come from the provider's `layers` configuration set.
+     */
+    getSupportedLayerIds(): Array<string>;
     /**
      * Returns whether or not the specified weather code is deprecated.
      */
@@ -7895,7 +8972,9 @@ constructor(account: Account);
 export declare type WeatherLayerStyle = `${WeatherLayerType}` | 'composite';
 
 export declare type WeatherLayerType = Exclude<LayerType, 'particles' | 'query' | 'voronoi' | 'data' | 'debug'>;
-
+
+export declare type WebGLContext = WebGLRenderingContext | WebGL2RenderingContext;
+
 /**
  * The base class for all layers rendered with WebGL. This class should not be instantiated directly but rather extended
  * by a subclass that is responsible for rendering a specific type of data from a data source.
@@ -7959,6 +9038,7 @@ get mask(): LayerMask;
      * @readonly
      */
     get visible(): boolean;
+    protected get hasMapController(): boolean;
     /**
      * Registers another layer as depending on this layer (for example it reads this layer via `queryFeatures`
      * while this layer may be hidden). When the registry is non-empty, time-series data providers may load tiles even
@@ -8020,6 +9100,25 @@ get mask(): LayerMask;
      * @param value - New value of the paint style property to set.
      */
     setPaintProperty(property: string, value: any): void;
+    /**
+     * Sets the layer mask used to stencil this layer's output.
+     * Pass `null` or `undefined` to clear any existing mask.
+     * Prefer {@link MapController.setMask} when mask layers need to be created from weather
+     * layer codes or `type: 'water' | 'land'` presets.
+     * @param mask - Resolved mask with live layer instances, or `null`/`undefined` to clear.
+     */
+    setMask(mask: LayerMask | null | undefined): void;
+    /**
+     * Whether this layer would write a stencil bit at the given coordinate when used as a mask.
+     * Override in subclasses that act as masks (coverage, vector fill, …).
+     * Default is `false` so unknown mask layers fail closed for query gating.
+     */
+    coversCoordinate(coord: Coordinate, zoom: number, allowPartials?: boolean): boolean;
+    /**
+     * Whether a point passes this layer's mask (mirrors GPU stencil `mode` / `inverted`).
+     * Returns `true` when the layer has no mask.
+     */
+    passesMask(coord: Coordinate, zoom: number, allowPartials?: boolean): boolean;
     /**
      * Returns all features found for the layer at the specified coordinate and zoom level (optional). If a value for
      * `zoom` is not provided, then the map's current zoom level will be used.