@xweather/mapsgl 1.8.4 → 1.9.0

package/dist/mapsgl.d.ts

@@ -546,6 +546,8 @@ declare const enum ShaderType {
     FRAGMENT = "fragment"
 }
 
+export declare const sharedFPSMeter: FPSMeter;
+
 export declare type Size = {
     width: number;
     height: number;
@@ -1064,7 +1066,7 @@ export declare class Animation extends EventDispatcher {
     /**
      * Stops the animation and resets it to its original starting position.
      */
-    stop(): void;
+    stop(advanceToStopPosition?: boolean): void;
     /**
      * Restarts the animation from the beginning if it is currently playing.
      */
@@ -1207,6 +1209,8 @@ export declare type AnimationState = ObjectValue<typeof AnimationState>;
 export declare type AnyAuthenticator = Authenticator<any>;
 
 export declare type AnyMapController = MapController<any>;
+
+export declare type AnyTileCache = TileCache<any>;
 
 /**
  * An enumerated value representing an API endpoint action.
@@ -1693,15 +1697,6 @@ export declare class Bounds {
     constructor(left: number, right: number, top: number, bottom: number);
 }
 
-/**
- * Defines the granularity of subdivision for circles with `circle-pitch-alignment: 'map'` and for heatmap kernels.
- * More subdivision will cause circles to more closely follow the planet's surface.
- *
- * Possible values: 1, 3, 5, 7.
- * Subdivision of 1 results in a simple quad.
- */
-export declare type CircleGranularity = 1 | 3 | 5 | 7;
-
 /**
  * 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.
@@ -1860,6 +1855,10 @@ export declare interface ColorScaleOptions {
      */
     masks?: Array<ColorMaskOptions>;
 }
+
+export declare class ConstantStyleValue<T> extends StyleValue_2<T> {
+    constructor(value: T | any[] | StyleEvaulatorFunction<T>);
+}
 
 /**
  * Contour style properties control how contoured data gets rendered on a map. Contour layers are rendered by sampling
@@ -1876,7 +1875,13 @@ export declare interface ContourStyleSpec {
      * major contour lines will not be rendered. This value must be in the same units as the data source.
      */
     majorInterval: StyleValue<number>;
+    /**
+     * The width of the contour lines in pixels.
+     */
     width: StyleValue<number>;
+    /**
+     * The width of the major contour lines in pixels.
+     */
     majorWidth: StyleValue<number>;
     scale: StyleValue<number>;
     offset: StyleValue<number>;
@@ -1890,7 +1895,9 @@ export declare interface ControlStore {
     dataInspector: DataInspectorControl;
 }
 
-declare const convert: (type: string, value: number, from: string, to: string) => number;
+export declare type ConversionMeasurement = Measurement | 'temperature-change';
+
+declare const convert: (type: ConversionMeasurement | string, value: number, from: string, to: string) => number;
 
 export declare type Coordinate = {
     lat: number;
@@ -1913,6 +1920,9 @@ declare const CtoF: (c: number) => number;
 
 declare const CtoFUnit: (c: number) => number;
 
+export declare class DataDrivenStyleValue<T> extends StyleValue_2<T> {
+}
+
 export declare interface DataEvaluator {
     title: string | ((data: FeatureQueryResult) => string);
     alwaysShow?: boolean;
@@ -1956,6 +1966,7 @@ export declare class DataInspectorControl {
 export declare interface DataInspectorControlOptions {
     event: 'click' | 'move';
     stream: boolean;
+    showCoordinates: boolean;
     tooltip: any;
 }
 
@@ -2101,9 +2112,11 @@ export declare interface Disposable {
  * @template Task - The download task type that extends DownloadTask
  */
 export declare class DownloadManager<Task extends DownloadTask<any>> extends EventDispatcher {
+    id: string;
 
 /**
      * Gets the progress tracker for download operations.
+     * Progress is calculated from actual task states for accuracy.
      * @returns The Progress instance tracking download statistics.
      */
     get progress(): Progress;
@@ -2116,7 +2129,7 @@ export declare class DownloadManager<Task extends DownloadTask<any>> extends Eve
      * @param options.defaultConcurrency - Default maximum concurrent downloads. Defaults to 16.
      * @param options.perHostConcurrency - Per-host concurrency limits, keyed by host name.
      */
-    constructor(options?: Partial<DownloadManagerOptions<TaskData<Task>>>);
+    constructor(options?: Partial<DownloadManagerOptions<Task>>);
     /**
      * Checks if a task result exists in the cache.
      * @param key - The unique identifier for the task.
@@ -2129,12 +2142,6 @@ export declare class DownloadManager<Task extends DownloadTask<any>> extends Eve
      * @returns The cached task data, or undefined if not found.
      */
     get(key: string): TaskData<Task> | undefined;
-    /**
-     * Sets the tile fetcher function to use for requests.
-     * The fetcher function should return a Promise that resolves with a Response object.
-     * @param fetcher -
-     */
-    setFetcher(fetcher: Fetcher<Task>): void;
     /**
      * Sets the task runner function used to execute download tasks.
      * @param runner - The task runner function that handles task execution with retry logic.
@@ -2160,13 +2167,15 @@ export declare class DownloadManager<Task extends DownloadTask<any>> extends Eve
      * @param predicate - A callback that receives a task and returns true for a match.
      */
     hasTask(predicate: (task: Task) => boolean): boolean;
+    private _totalTasks;
     /**
      * Adds a task to the download queue and optionally starts processing.
      * Tasks are organized by host for per-host concurrency control and sorted by priority.
      * @param task - The download task to enqueue.
      * @param start - If true, immediately starts processing the queue. Defaults to true.
+     * @param isRetry - If true, this is a retry and should not increment total. Defaults to false.
      */
-    enqueue(task: Task, start?: boolean): void;
+    enqueue(task: Task, start?: boolean, isRetryParam?: boolean): void;
     /**
      * Aborts a specific download task.
      * If the task is in-flight, the request is aborted. If pending, it's removed from the queue.
@@ -2179,6 +2188,9 @@ export declare class DownloadManager<Task extends DownloadTask<any>> extends Eve
      * @param predicate - A callback that receives a task and returns true if it should be aborted.
      */
     abortWhere(predicate: (task: Task) => boolean): void;
+    /**
+     * Aborts all tasks.
+     */
     abortAll(): void;
 
 }
@@ -2413,16 +2425,25 @@ export declare interface EncodedRasterDataset {
  */
 export declare interface EncodedSourceSpecification<Dataset extends EncodedRasterDataset> extends TileSourceSpecification {
     /**
-     * The datasets that are encoded in the tile data.
+     * The datasets that are encoded in the tile data. These are used for requesting tiles from the server.
+     * If the data is transformed (e.g., converting precip to snowfall), use `effectiveDatasets` to provide
+     * the transformed datasets with updated dataMin/dataMax values for operations and rendering.
      */
     datasets: Array<Partial<Dataset>>;
+    /**
+     * The effective datasets used for operations and rendering. If not provided, defaults to `datasets`.
+     * Use this when data transformations change the dataMin/dataMax values (e.g., converting precipitation
+     * to snowfall). The original `datasets` are still used for tile requests.
+     */
+    effectiveDatasets?: Array<Partial<Dataset>>;
     /**
      * Optional function to transform tile data after it has been loaded. This allows for custom processing or
      * modification of the tile data before it is used for rendering, such as converting it to other values
      * derived from the original encoded data.
      * @param data - The loaded tile data as an RGBA image.
      * @param datasets - An array of dataset objects associated with this source, which contains information about the
-     * original encoded data and its value ranges.
+     * original encoded data and its value ranges. This array can be modified in-place to update dataMin/dataMax
+     * values for transformed data.
      */
     transformTileData?: (data: RGBAImage, datasets: Array<Dataset>) => void;
 }
@@ -2438,10 +2459,15 @@ export declare class EncodedTileSource<Source extends EncodedSourceSpecification
     shouldUseTimesFromMetadata: boolean;
     maxTextureSize: number;
     private _worker;
+    private _aggregateProgress;
     
     get type(): string;
+    get operation(): TimeSeriesOperationType;
     constructor(id: string, spec: Partial<Source>);
     
+    shouldRequestTile(tile: Tile<EncodedTileData>, reload?: boolean, intervals?: Array<Date>): boolean;
+    abortTileByCoord(coord: TileCoord): void;
+    
     /**
      * Returns the metadata for the specified band, if available.
      * @param band - The band to get metadata for.
@@ -2456,6 +2482,7 @@ export declare class EncodedTileSource<Source extends EncodedSourceSpecification
      */
     getDataRange(band: SampleChannel): ValueRange;
 
+protected onLoadProgress(e: any): void;
 }
 
 /**
@@ -2466,24 +2493,17 @@ export declare class EncodedTileSource<Source extends EncodedSourceSpecification
  */
 declare const equalUnits: (units1: MapUnits, units2: MapUnits) => boolean;
 
-export declare type ExpressionInputType = string | number | boolean | ExpressionLookupType;
-
-export declare type ExpressionLookupType = [
-'get',
-string,
-...(ExpressionLookupType)[]
-] | [
-'has',
-string,
-...(ExpressionLookupType)[]
-] | [
-'at',
-number,
-Array<any>
-] | [
-'length',
-string | number | Array<any>
-];
+/**
+ * Mapbox-style expression: operator name followed by arguments.
+ * Arguments may be literals or nested expressions (recursive).
+ */
+export declare type Expression = [ExpressionOperator, ...ExpressionValue[]];
+
+/**
+ * Mapbox-style expression array, e.g. ['get', 'opacity'] or ['*', ['get', 'x'], 2].
+ * Allowed in style config; converted to DataDrivenStyleValue in the PaintStyle constructor.
+ */
+export declare type ExpressionArray = any[];
 
 /**
  * Defines a custom expression operation to calculate the result of a custom expression function. The custom expression
@@ -2527,44 +2547,82 @@ export declare interface ExpressionOperation {
     chunk: string;
 }
 
-export declare type ExpressionSpecification = [
-'!',
-ExpressionInputType
-] | [
-'==',
-ExpressionInputType,
-ExpressionInputType
-] | [
-'!=',
-ExpressionInputType,
-ExpressionInputType
-] | [
-'>',
-ExpressionInputType,
-ExpressionInputType
-] | [
-'>=',
-ExpressionInputType,
-ExpressionInputType
-] | [
-'<',
-ExpressionInputType,
-ExpressionInputType
-] | [
-'<=',
-ExpressionInputType,
-ExpressionInputType
-] | [
-'in',
-ExpressionInputType,
-...(ExpressionInputType | ExpressionInputType[])[]
-] | [
-'all',
-...(boolean | ExpressionSpecification)[]
-] | [
-'any',
-...(boolean | ExpressionSpecification)[]
-];
+/**
+ * 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 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";
+};
+
+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;
@@ -2592,7 +2650,7 @@ export declare interface FillStyleSpec {
     /**
      * Color of the fill.
      */
-    color: StyleValue<string | Color | StyleExpression>;
+    color: StyleValue<string | Color>;
     /**
      * The image to use for the fill pattern. Can be an image identifier string or a {@link RemoteSymbolImage}.
      * @remarks
@@ -2613,6 +2671,14 @@ export declare interface FillStyleSpec {
      */
     sort: string | SortProperty;
 }
+
+/**
+ * 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
+ */
+export declare type FilterExpression = ExpressionValue;
 
 declare const FtoC: (f: number) => number;
 
@@ -2769,8 +2835,18 @@ export declare type GeoJsonProperties = {
 
 /**
  * A subclass of {@link VectorTileSource} that is used to represent GeoJSON data.
+ *
+ * This source tracks a single in-flight data update (`pendingDataUpdate`) to make update
+ * lifecycle events deterministic when remote loads and `setData()` calls overlap. The revision-
+ * based update state prevents duplicate or out-of-order `DATA_UPDATE_*` events, avoids stale
+ * async completions mutating newer state, and reduces no-op update churn during rapid updates.
  */
 export declare class GeoJSONSource extends VectorTileSource {
+    private static readonly DATA_UPDATE_ERROR_MESSAGE;
+    /**
+     * Whether the GeoJSON data is dynamic, meaning it will be updated frequently. Default is `false`.
+     */
+    dynamic: boolean;
     
     private _transformGeoJSON?;
     get type(): string;
@@ -2783,8 +2859,15 @@ export declare class GeoJSONSource extends VectorTileSource {
      * The GeoJSON data associated with the source, either provided statically or from a remote source.
      */
     get data(): GeoJSONFeatureCollection;
-    private coalesce;
-    private pendingLoad;
+    private needsUpdate;
+    /**
+     * The revision number of the data.
+     */
+    private dataRevision;
+    /**
+     * The pending data update being processed.
+     */
+    private pendingDataUpdate;
     constructor(id: string, spec: Partial<GeoJSONSourceSpecification>);
     /**
      * Sets the URL of the GeoJSON data.
@@ -2805,6 +2888,11 @@ export declare class GeoJSONSource extends VectorTileSource {
     expireAllTiles(): void;
     reload(): void;
     private updateWorkerData;
+    private processWorkerUpdate;
+    private beginDataUpdate;
+    private flushQueuedDataUpdate;
+    private completeDataUpdate;
+    private failDataUpdate;
 }
 
 /**
@@ -2819,6 +2907,10 @@ export declare interface GeoJSONSourceSpecification extends SourceSpecification
      * The GeoJSON URL template string to use when requesting GeoJSON data.
      */
     url: string;
+    /**
+     * Whether the GeoJSON data is dynamic, meaning it will be updated frequently. Default is `false`.
+     */
+    dynamic?: boolean;
     /**
      * A function that transforms the GeoJSON data before it is sent to the worker for processing.
      * @param source - The GeoJSON source.
@@ -2840,7 +2932,7 @@ export declare type GeoJSONTypes = GeoJSON['type'];
  * @param system - The system to get the default unit for.
  * @returns The default unit for the given measurement and system.
  */
-declare const getDefaultUnit: (type: Measurement, system: UnitSystem) => string;
+declare const getDefaultUnit: (type: ConversionMeasurement, system: UnitSystem) => string;
 
 /**
  * Returns the default units for the given system.
@@ -2858,6 +2950,8 @@ declare const getMeasurementType: (str: string) => Measurement | undefined;
  * @returns The system for the given units.
  */
 declare const getSystemForUnits: (units: MapUnits) => UnitSystem;
+
+declare const getUnitPrecision: (unit: string) => number;
 
 export declare type GoogleMap = google.maps.Map;
 
@@ -2917,7 +3011,7 @@ export declare interface HeatmapStyleSpec {
      * Defines the normalized (`0` to `1`) color scale used to color pixels based on its density value, where `0`
      * is none and `1` being the highest density.
      */
-    color: Array<number | string>;
+    color: StyleValue<Array<number | string>>;
     /**
      * Radius of influence of each data point in screen points.
      */
@@ -3252,7 +3346,7 @@ export declare type LayerMetadata = {
     sourceLayerId: string;
     sourceLayerType: string;
     type: string;
-    filter: ExpressionSpecification;
+    filter: FilterExpression;
     paint: PaintStyle;
     options?: Record<string, unknown>;
 };
@@ -3333,13 +3427,15 @@ export declare interface LayerRenderer {
      * Called before the primary render method to perform any setup or rendering that needs to be done before
      * rendering, such as rendering to a framebuffer or updating compute passes.
      * @param elapsedTime - The render loop's elapsed time.
+     * @param frameContext - Map and layer state for this frame; the renderer must use this instead of reading from the layer or map.
      */
-    prerender(elapsedTime: number): void;
+    prerender(elapsedTime: number, frameContext: RenderFrameContext): void;
     /**
      * Render the layer's data.
      * @param elapsedTime - The render loop's elapsed time.
+     * @param frameContext - Map and layer state for this frame; the renderer must use this instead of reading from the layer or map.
      */
-    draw(elapsedTime: number): void;
+    draw(elapsedTime: number, frameContext: RenderFrameContext): void;
     /**
      * Performs any necessary set up to prepare the renderer for offscreen rendering, such as setting up a framebuffer.
      */
@@ -3358,6 +3454,14 @@ export declare interface LayerSpecification {
      * Type of layer.
      */
     type: LayerType;
+    /**
+     * The minimum zoom level for the layer.
+     */
+    minZoom?: number;
+    /**
+     * The maximum zoom level for the layer.
+     */
+    maxZoom?: number;
     /**
      * Data source associated with the layer.
      * @remarks
@@ -3392,15 +3496,21 @@ export declare interface LayerSpecification {
      */
     mask?: LayerMaskSpecification;
     /**
-     * Filter expression to use for filtering features from the data source. This is only used for vector tile data
-     * sources whose tiles are in the Mapbox Vector Tile (MVT) format.
-     * @see ExpressionSpecification
+     * Filter expression for vector tile layers. Evaluated with StyleExpression.
+     * @see FilterExpression
      */
-    filter?: ExpressionSpecification;
+    filter?: FilterExpression;
     /**
      * Time series configuration for the layer when time-based.
      */
     timeSeries?: Partial<LayerTiming>;
+    /**
+     * Optional measurement metadata associated with this layer's values.
+     */
+    measurement?: {
+        type: ConversionMeasurement;
+        units: string;
+    };
     /**
      * Data resolution to use, which controls which data zoom level is requested for a specific map zoom level.
      * @remarks
@@ -4101,14 +4211,14 @@ get needsViewportUpdate(): boolean;
     
     /**
      * Adds a new weather layer to the map.
-     * @param id - One of the supported weather layer identifiers.
+     * @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.
      * @returns The newly added map layer or an array of layers if the weather layer identifier maps to multiple layers.
      */
-    addWeatherLayer(id: string, overrides?: Partial<WeatherLayerOptions>, beforeId?: string): WebGLLayer | Array<WebGLLayer>;
+    addWeatherLayer(idOrConfig: WeatherLayerConfiguration | string, overrides?: Partial<WeatherLayerOptions>, beforeId?: string): WebGLLayer | Array<WebGLLayer>;
     /**
      * Removes a weather layer from the map.
      * @param id - One of the supported weather layer identifiers.
@@ -4719,6 +4829,10 @@ declare const Operator: {
 
 export declare type Operator = ObjectValue<typeof Operator>;
 
+export declare interface Opts {
+    capacity: number;
+}
+
 /**
  * The mode for handling symbol overlap.
  */
@@ -4808,7 +4922,7 @@ export declare class PaintStyle {
     iconAnimated(data?: StylableData): boolean;
     iconFactor(data?: StylableData): number;
     iconAtlas(data?: StylableData): SymbolIconAtlas;
-    textValue(data?: StylableData, line?: number): string | PropertyValue;
+    textValue(data?: StylableData, line?: number): string;
     textTransform(data?: StylableData, line?: number): string;
     textFont(data?: StylableData, line?: number): string;
     textSize(data?: StylableData, line?: number): number;
@@ -4909,22 +5023,22 @@ export declare const ParticleDensity: {
      * Least amount of particles will be rendered. This density setting may not provide enough speed and direction
      * information on the map since coverage is minimal. Sets the particle count per tile to 8^2.
      */
-    readonly minimal: 8;
+    readonly minimal: 16;
     /**
      * Slightly less particle density than `normal`, allowing the most visibiilty to content underneath while
      * providing good speed and direction information. Sets the particle count per tile to 16^2.
      */
-    readonly low: 24;
+    readonly low: 32;
     /**
      * Provides a good amount of particles and speed and direction information while still allowing a good portion
      * of content underneath to remain visible. Sets the particle count per tile to 48^2.
      */
-    readonly normal: 48;
+    readonly normal: 64;
     /**
      * Slightly higher particle density than `normal` while still allowing some content underneath to remain visible.
      * Sets the particle count per tile to 76^2.
      */
-    readonly high: 76;
+    readonly high: 96;
     /**
      * Highest density that will essentially fill the layer with particle data, preventing content underneath from
      * being visible. Note that overall map performance may be affected with this setting for some hardware
@@ -5079,32 +5193,6 @@ declare const ProjectionType: {
 
 export declare type ProjectionType = ObjectValue<typeof ProjectionType>;
 
-/**
- * Defines a property value that is based on a property name or an array of property names from a JSON object. The
- * property value can also be transformed using a custom function to format the value before rendering.
- */
-export declare interface PropertyValue {
-    /**
-     * Property key path or an array of property key paths from a JSON object. If an array is provided, then the first
-     * property that is not undefined will be used.
-     */
-    property: string | Array<string>;
-    /**
-     * Optional measurement type the value represents. This is used to select the proper units to convert the value to
-     * before rendering. If not provided, then the value will be rendered as is.
-     */
-    measurement?: {
-        type: string;
-        units: string;
-    };
-    /**
-     * Custom function to transform the property value before rendering. This is useful for formatting the value before
-     * rendering, such as converting units, rounding, or applying other transformations.
-     * @param value - The property value to transform.
-     */
-    transform?: (value: string | number, units?: string) => string | number;
-}
-
 /**
  * A `Query` object is a convenience wrapper for setting up and configuring a query string used
  * for API queries.
@@ -5252,7 +5340,92 @@ 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
+ * does not access the parent layer or the layer's map.
+ */
+export declare interface RenderFrameContext {
+    /** Elapsed time since the start of the render loop. Used by the renderer to animate the layer. */
+    elapsedTime: number;
+    /** Latest calculated FPS of the context. */
+    fps: number;
+    /** Map state snapshot. */
+    map: RenderFrameContextMap;
+    /** Layer id. */
+    layerId: string;
+    /** Scene to render into. */
+    scene: MapScene;
+    /** Whether this layer is used as a mask (stencil). */
+    isLayerMask: boolean;
+    /** Layer mask config if any. */
+    mask?: LayerMask;
+    /** Whether the layer is visible. */
+    visible: boolean;
+    /** Request a redraw on the next frame. */
+    setNeedsUpdate(): void;
+    /** Tile-layer-specific state; set when the layer is a tile layer. */
+    tileLayer?: RenderFrameContextTileLayer;
+    /** Tile cache from the layer's source; set when the layer has a tile source. Used by renderers instead of accessing layer.source.tiles. */
+    tileCache?: AnyTileCache;
+    /** Tile dimensions from the layer's source; set when the layer has a tile source. Used for texture array setup. */
+    tileSize?: {
+        width: number;
+        height: number;
+    };
+    /** Layer paint style (from layer.paint). Set by the layer when building context. */
+    paint?: PaintStyle;
+    /** Map style (map.style). Used by vector/grid passes for fonts, image atlas, etc. */
+    mapStyle?: MapStyle;
+}
+
+/**
+ * Snapshot of map transform state passed into the render path so the renderer
+ * does not read from the map or layer during prerender/draw.
+ */
+export declare interface RenderFrameContextMap {
+    center: Coordinate;
+    zoom: number;
+    bounds: CoordinateBounds;
+    bearing: number;
+    pitch: number;
+    tileSize: number;
+    projection: {
+        type: ProjectionType;
+        subdivisionGranularity: SubdivisionGranularitySetting;
+    };
+    transform: MapTransform;
+    placement: SymbolPlacement;
+    globiness: number;
+    isGlobe: boolean;
+    camera: {
+        position: Vector3;
+    };
+    clippingPlane: Vector4;
+    globeMatrix: Matrix4;
+    mercatorMatrix: Matrix4;
+    projGlobeMatrix: Matrix4;
+    zoomTransition: number;
+    cutoffParams: [number, number, number, number];
+    farZ: number;
+    pixelsPerMercatorPixelRatio: number;
+}
+
+/**
+ * Optional tile-layer-specific state for resolution and LOD. Present when the
+ * layer is a tile layer.
+ */
+export declare interface RenderFrameContextTileLayer {
+    viewport: Viewport;
+    pyramid: TilePyramid<any>;
+    getDataZoom(): number;
+    getVisibleTileCoords(zoom: number): TileCoord[];
+    getCurrentInterval?(): TimeInterval | undefined;
+}
 
+declare const resolveMeasurementForUnits: (type: ConversionMeasurement) => Measurement;
+
 /**
  * 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.
@@ -5445,10 +5618,10 @@ export declare class SourceMetadata extends EventDispatcher {
      */
     get hasLoaded(): boolean;
     /**
-     * Whether the metadata has valid time information.
+     * Whether the data source is a time-series data source.
      * @readonly
      */
-    get hasValidTimes(): boolean;
+    get isTimeSeries(): boolean;
     get validTimeRange(): TimeRange;
     getAllValidTimes(): Array<Date>;
     /**
@@ -5631,6 +5804,12 @@ export declare class State<T> extends EventDispatcher {
     };
 }
 
+/**
+ * Legacy style value: a static value or a function (data) => value.
+ * Supported for backwards compatibility.
+ */
+export declare type StaticOrFunctionStyleValue<T> = T | ((data: StylableData) => T);
+
 /**
  * Stroke style properties control how one or more polylines get rendered on a map. These properties also control
  * strokes around circles and other vector shapes.
@@ -5639,7 +5818,7 @@ export declare interface StrokeStyleSpec {
     /**
      * Color of the stroke.
      */
-    color: StyleValue<string | Color | StyleExpression>;
+    color: StyleValue<string | Color>;
     /**
      * Opacity of the stroke. Opacity can also be specified by including an alpha channel in the `color` value.
      */
@@ -5743,6 +5922,8 @@ export declare interface StyledImageRenderer {
     dispose?: () => void;
 }
 
+export declare type StyleEvaulatorFunction<T> = (properties: Record<string, any>) => T;
+
 export declare interface StyleExpression {
     property: string;
     type?: 'identity' | 'expression';
@@ -5773,6 +5954,8 @@ export declare const styles: {
         };
         prate: (string | number)[];
         precip_accum: (string | number)[];
+        sleet_accum: (string | number)[];
+        ice_accum: (string | number)[];
         radar: {
             rain: (string | number)[];
             mix: (string | number)[];
@@ -5790,97 +5973,36 @@ export declare const styles: {
 };
 
 /**
- * Defines a style value that can be either a static value or a function that returns a value based on the data for
- * data-driven styling.
- */
-export declare type StyleValue<T> = T | ((data: StylableData) => T);
-
-/**
- * Controls how much subdivision happens for a given type of geometry at different zoom levels.
+ * Style value accepted by paint specs. Can be:
+ * - A constant (number, string, boolean, object, etc.)
+ * - A function (data) => value
+ * - An expression array (Mapbox-style, e.g. ['get', 'opacity'])
+ * - A {@link ConstantStyleValue} or {@link DataDrivenStyleValue} instance (used as-is)
+ *
+ * Constants, functions, and expression arrays are converted to StyleValue instances in the PaintStyle constructor.
  */
-export declare class SubdivisionGranularityExpression {
-    /**
-     * A tile of zoom level 0 will be subdivided to this granularity level.
-     * Each subsequent zoom level will have its granularity halved.
-     */
-    private readonly _baseZoomGranularity;
-    /**
-     * No tile will have granularity level smaller than this.
-     */
-    private readonly _minGranularity;
-    constructor(baseZoomGranularity: number, minGranularity: number);
-    getGranularityForZoomLevel(zoomLevel: number): number;
-}
-
-export declare interface SubdivisionGranularityOptions {
-    /**
-     * Granularity settings used for fill and fill-extrusion layers (for fill, both polygons and their anti-aliasing outlines).
-     */
-    fill: {
-        base: number;
-        min: number;
-    };
-    /**
-     * Granularity used for the line layer.
-     */
-    line: {
-        base: number;
-        min: number;
-    };
-    /**
-     * Granularity used for geometry covering the entire tile: stencil masks, raster tiles, etc.
-     */
-    tile: {
-        base: number;
-        min: number;
-    };
-    /**
-     * Granularity used for stencil masks for tiles.
-     */
-    stencil: {
-        base: number;
-        min: number;
-    };
-    /**
-     * Controls the granularity of `pitch-alignment: map` circles and heatmap kernels.
-     * More granular circles will more closely follow the map's surface.
-     */
-    circle: CircleGranularity;
-}
+export declare type StyleValue<T> = StaticOrFunctionStyleValue<T> | ExpressionArray | DataDrivenStyleValue<T> | ConstantStyleValue<T>;
 
-/**
- * An object describing how much subdivision should be applied to different types of geometry at different zoom levels.
- */
-export declare class SubdivisionGranularitySetting {
-    /**
-     * Granularity settings used for fill and fill-extrusion layers (for fill, both polygons and their anti-aliasing outlines).
-     */
-    readonly fill: SubdivisionGranularityExpression;
-    /**
-     * Granularity used for the line layer.
-     */
-    readonly line: SubdivisionGranularityExpression;
+declare abstract class StyleValue_2<T> {
+    private constant;
+    private expression;
+    private fn;
+    constructor(value: T | any[] | StyleEvaulatorFunction<T>);
     /**
-     * Granularity used for geometry covering the entire tile: raster tiles, etc.
+     * Returns whether this value is an expression.
      */
-    readonly tile: SubdivisionGranularityExpression;
+    isExpression(): boolean;
     /**
-     * Granularity used for stencil masks for tiles.
+     * Resolves the final value based on input properties.
+     * If it's a constant, returns it directly.
      */
-    readonly stencil: SubdivisionGranularityExpression;
+    resolve(properties?: Record<string, any>): T;
     /**
-     * Controls the granularity of `pitch-alignment: map` circles and heatmap kernels.
-     * More granular circles will more closely follow the map's surface.
+     * Returns the raw constant or expression for debugging or serialization.
      */
-    readonly circle: CircleGranularity;
-    constructor(options: SubdivisionGranularityOptions);
-    /**
-     * Granularity settings that disable subdivision altogether.
-     */
-    static readonly noSubdivision: SubdivisionGranularityOptions;
-    static readonly globeSubdivision: SubdivisionGranularityOptions;
+    getRaw(): T | any[] | StyleEvaulatorFunction<T> | null;
 }
-
+
 /**
  * Supported color bands.
  */
@@ -6054,8 +6176,6 @@ export declare type TaskRunner<Task extends DownloadTask<any>> = (task: Task, co
  * @template Task - The download task type that extends DownloadTask
  */
 export declare interface TaskRunnerConfig<Task extends DownloadTask<any>> {
-    /** Function that performs the fetch operation. */
-    fetcher: Fetcher<Task>;
     /** Maximum number of retry attempts for failed tasks. */
     maxRetries: number;
     /** HTTP status code range [min, max] that triggers retry attempts. */
@@ -6070,10 +6190,9 @@ export declare interface TaskRunnerConfig<Task extends DownloadTask<any>> {
  */
 export declare interface TextStyleSpec {
     /**
-     * Text to render. This can be a static string or a property value that is based on a property name or an array of
-     * property names from a JSON object.
+     * Text to render. This can be a static string or an expression that evaluates to a string.
      */
-    value: StyleValue<string | PropertyValue>;
+    value: StyleValue<string>;
     /**
      * The size of the text in pixels.
      */
@@ -6152,6 +6271,11 @@ export declare class Tile<Data> implements Disposable {
     private _span;
     private _bounds;
     private _state;
+    /**
+     * Monotonically increasing identifier for the most recent request that started loading this tile.
+     * Used by `TileSource` to guard against out-of-order async responses overwriting newer data.
+     */
+    requestId: number;
     private _data;
     /**
      * The tile coordinate of the tile as `x`, `y`, and `z`.
@@ -6234,6 +6358,13 @@ export declare class TileBounds {
     get center(): Point;
     get info(): Rect_2;
     constructor(left: number, right: number, top: number, bottom: number);
+    /**
+     * Expands the bounds by the specified offsets.
+     * @param xOffset - The offset to expand the bounds horizontally.
+     * @param yOffset - The offset to expand the bounds vertically.
+     * @returns The expanded bounds.
+     */
+    expand(xOffset: number, yOffset: number): TileBounds;
     /**
      * Returns whether the bounds equals the specified bounds.
      * @param bounds -
@@ -6373,22 +6504,123 @@ export declare type TileCoordinateBounds = {
     nw: TileCoordinate;
     se: TileCoordinate;
 };
-
-export declare class TileDownloadTask extends DownloadTask<{
-    data: Blob;
-    headers: Headers;
-}> {
-    readonly coord: TileCoord;
-    readonly intervals: Array<number>;
-    constructor(key: string, coord: TileCoord, intervals: Array<number>, url: string, options: Partial<TileRequestOptions>, priority?: DownloadPriority);
-}
-
+
 export declare interface TileInfo {
     x: number;
     y: number;
     z: number;
 }
 
+/**
+ * Represents a layer that renders data from a tile-based data source. This is the base class for all tile-based layers
+ * and is not intended to be used directly.
+ * @template Data Type of data stored in the layer's tiles.
+ */
+declare abstract class TileLayer<Data> extends WebGLLayer<TileSource> {
+    /**
+     * Tile pyramid used to calculating and requesting tiles for the layer from the data source.
+     */
+    readonly pyramid: TilePyramid<Data>;
+    readonly zoomOffset: number;
+    private tileBounds;
+    private dataQuality;
+    private upgradeDataQuality;
+    private lastHiddenTime;
+    private tileLoadProgress;
+    /**
+     * Returns the layer's data render quality.
+     * @see DataQuality
+     */
+    get quality(): DataQuality;
+    /**
+     * Sets the layer's data render quality.
+     * @see DataQuality
+     */
+    set quality(value: DataQuality);
+    /**
+     * Creates an instance of TileLayer.
+     * @param id - Unique identifier of the layer.
+     * @param config - Config options for the layer.
+     */
+    constructor(id: string, { quality, ...config }: Partial<TileLayerConfig>);
+    refresh(clear?: boolean): void;
+    /**
+     * Returns the layer's tile cache so renderers can use it via RenderFrameContext instead of accessing layer.source.tiles.
+     */
+    getTileCache(): AnyTileCache;
+    /**
+     * Returns the layer's tile dimensions for texture array setup.
+     */
+    getTileSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Returns the data zoom level used for the specified map zoom level based on the configured `quality` level.
+     * @param zoom - Map zoom level to get the data zoom level for.
+     * @param reduceDataQuality - Whether to reduce the data quality by 1 level.
+     * @returns Data zoom level.
+     */
+    getDataZoom(zoom?: number, reduceDataQuality?: boolean): number;
+    preloadWorldTile(): void;
+    /**
+     * 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.
+     */
+    protected getTile(coord: Coordinate, zoom?: number, allowPartials?: boolean): {
+        tile: Tile<Data>;
+        position: Point;
+    } | undefined;
+    /**
+     * Returns the visible tile coordinates based on the map's current viewport.
+     * @returns Array of visible tile coordinates.
+     */
+    getVisibleTileCoords(): Array<TileCoord>;
+    /**
+     * Requests visible tiles from the tile pyramid.
+     * @param reload - Whether to reload tiles that have already been requested.
+     * @returns Promise that resolves when the tiles have been requested.
+     */
+    private requestVisibleTiles;
+    protected requestTiles(coords: Array<TileCoord>, reload?: boolean): Promise<void>;
+    protected shouldReloadTile(coord: TileCoord): boolean;
+    onAdd(context: Context): void;
+    onMove(): void;
+    onVisible(): void;
+    onHidden(): void;
+    private onDataStale;
+    private onDataChange;
+    private onTileLoad;
+    private onTileError;
+    private onLoadProgress;
+    private onLoadStart;
+    private onLoadComplete;
+    protected onTimeSeriesDataChange(): void;
+    protected onMaskLayerChange(): void;
+    protected onMaskStateChange(): void;
+}
+
+/**
+ * Configuration options for a tile-based layer.
+ */
+export declare interface TileLayerConfig extends WebGLLayerConfig {
+    /**
+     * Quality to use when rendering data.
+     */
+    quality: DataQuality;
+    /**
+     * Range of values to use when rendering data.
+     */
+    dataRange: ValueRange;
+    /**
+     * Offset to apply to the map's zoom level when requesting data from the data source. This is useful to render data
+     * at a different zoom level than the map's zoom level.
+     */
+    zoomOffset: number;
+}
+
 export declare type TileQuadrant = 'tl' | 'tc' | 'tr' | 'ml' | 'mc' | 'mr' | 'bl' | 'bc' | 'br';
 
 /**
@@ -6427,10 +6659,6 @@ export declare type TileRequestOptions = {
      * Whether to reload the tile if it has already been loaded.
      */
     reload: boolean;
-    /**
-     * Whether to check if the tile is already pending before loading.
-     */
-    checkPending: boolean;
     /**
      * The time intervals to load for the tile.
      */
@@ -6441,10 +6669,42 @@ export declare type TileRequestOptions = {
  * `TileSource` is an abstract class that provides the primary implementation of a tile-based data source object that
  * loads tiles from a remote source. This class is not intended to be used directly, but rather extended by a concrete
  * implementation of a tile-based data source.
+ *
+ * @remarks
+ * **Tile loading: two complementary mechanisms**
+ *
+ * Network fetches are orchestrated by {@link TileSource.downloadManager} (`DownloadManager`). `requestTile` may run
+ * decode/parse work after bytes arrive. Understanding these two behaviors avoids duplicate work and stale tiles:
+ *
+ * 1. **Download deduplication** — For a given `TileDownloadTask` key (tile coordinate plus optional interval key from
+ *    {@link makeTileKey} / {@link makeTileArrayKey}), the manager ensures at most one in-flight or pending fetch. If
+ *    `requestTile` is called again while that task is still pending or in-flight, callers await the **same** promise
+ *    instead of starting a second HTTP request. This reduces redundant bandwidth and coordinates multiple callers
+ *    (e.g. layers or rapid map updates) that share the exact same request identity.
+ *
+ * 2. **Load generation guard (`tile.requestId` / `task.loadRequestId`)** — Deduping only merges identical
+ *    **keys**. It does **not** decide which result is "current" when the logical request for a tile slot changes:
+ *    different URL parameters (time, style, reload), a new fetch after a previous task finished, or a slow
+ *    {@link parseTile} finishing after a newer `requestTile` has already started. For non-interval loads, each **new**
+ *    enqueued download task gets a monotonically increasing id; callers that shared that task share the same id.
+ *    After `parseTile` resolves, the result is applied only if that id still matches `tile.requestId` (see
+ *    `requestTile` and `loadTile`). Stale completions are dropped so an older response cannot overwrite newer data for
+ *    the same tile instance.
+ *
+ * **Interval-based loads** (time-series tiles with multiple intervals on one tile) intentionally skip this per-tile
+ * id guard so a single tile can accumulate multiple interval results; ordering for those paths is handled elsewhere
+ * in the data model.
+ *
  * @template Data The type of data stored in a tile.
  * @template Source The type of the source specification.
  */
 declare abstract class TileSource<Data = any, Source extends TileSourceSpecification = TileSourceSpecification> extends DataSource<Source> {
+    /**
+     * Monotonic counter used when assigning {@link TileDownloadTask.loadRequestId} for non-interval loads. Each new
+     * enqueued download task gets the next id; waiters sharing the same task reuse that id. See class-level docs on
+     * deduplication vs. load-generation guard.
+     */
+    private _tileLoadRequestId;
     /**
      * The minimum zoom level for the source.  Defaults to `0`.
      */
@@ -6509,34 +6769,38 @@ constructor(id: string, spec: Partial<Source>);
      */
     getTileUrl(coord: TileCoord, params?: Record<string, any>): string;
     /**
-     * Returns whether or not the source has a tile for the given tile coordinate.
-     * @param coord - The tile coordinate.
-     * @param layerId -
-     * @returns Whether or not the source has a tile for the given tile coordinate.
-     */
-    hasTile(coord: TileCoord, layerId?: string): boolean;
-    /**
-     * Returns whether or not the source has tile data for the given tile coordinate. If the tile's state is `expired`,
-     * this method will return `false` even if the tile has data.
+     * Checks if tile data exists for the given coordinate.
+     * For time-series sources, pass `intervals` to require data for those intervals; otherwise
+     * only the coord is checked and a single cached tile counts as "has data".
      * @param coord - The tile coordinate.
-     * @param layerId -
-     * @returns Whether or not the source has tile data for the given tile coordinate.
-     */
-    hasTileData(coord: TileCoord, layerId?: string): boolean;
-    /**
-     * Returns the data for the given tile coordinate.
+     * @param layerId - Optional layer ID for per-layer data (unused but retained for API compatibility). If provided,
+     *   the tile data must have data for the given layer ID. This is only used for vector tile sources.
+     * @param allowExpired - If true, allows expired tiles to be considered as having data.
+     * @param intervals - Optional time intervals (e.g. from request options). When provided, the tile must have
+     *   data for all of these intervals (used for time-series / multi-interval requests). The base implementation
+     *   only checks for data for the given intervals if the tile data is a time series data object.
+     * @returns Whether tile data exists (optionally including expired/stale and/or for the given intervals).
+     */
+    hasTileData(coord: TileCoord, layerId?: string, allowExpired?: boolean, intervals?: Array<Date>): boolean;
+    /**
+     * Returns whether there is already a pending or in-flight request for the given coordinate
+     * (and optionally for the given intervals). Used to avoid duplicate requests when the
+     * same tile+intervals are requested multiple times.
      * @param coord - The tile coordinate.
-     * @returns The data for the given tile coordinate.
+     * @param intervals - Optional time intervals. When provided, only a task for the same coord and
+     *   these intervals is considered; when omitted, any task for this coord is considered.
+     * @returns True if a matching request is pending or in-flight.
      */
-    getTileData(coord: TileCoord): Data;
+    isPending(coord: TileCoord, intervals?: Array<Date>): boolean;
     getTileDataSize(data?: Data): Size;
     /**
-     * Returns whether or not the source should request a tile.
+     * Returns whether the source should request a tile.
      * @param tile - The tile to check.
-     * @param reload - Whether or not the tile should be reloaded.
-     * @returns Whether or not the source should request a tile.
+     * @param options - Optional request options (reload, intervals for time-series, etc.). Subclasses may use
+     *   this to request a tile when cached data does not satisfy the request (e.g. missing interval).
+     * @returns Whether the source should request a tile.
      */
-    shouldRequestTile(tile: Tile<Data>, reload?: boolean): boolean;
+    shouldRequestTile(tile: Tile<Data>, reload?: boolean, intervals?: Array<Date>): boolean;
     /**
      * Reloads all cached tiles.
      */
@@ -6547,17 +6811,12 @@ constructor(id: string, spec: Partial<Source>);
      * @param options - Additional options to use when requesting the tile.
      * @returns A promise that resolves with the tile data.
      */
-    requestTile(coord: TileCoord, options?: Partial<TileRequestOptions>): Promise<Data>;
-    /**
-     * Returns a tile instance for the given tile coordinate. If the tile does not exist, it will be created and added
-     * to the cache.
-     * @param coord - The tile coordinate.
-     * @returns The tile instance.
-     */
-    protected getOrCreateTile(coord: TileCoord): Tile<Data>;
-    protected loadTile(tile: Tile<Data>, options?: Partial<TileRequestOptions>): Promise<{
-        data: Blob;
-        headers: Headers;
+    requestTile(coord: TileCoord, options?: Partial<TileRequestOptions>): Promise<Data | null>;
+    protected loadTile(tile: Tile<Data>, options?: Partial<TileRequestOptions>, loadRequestCtx?: {
+        loadRequestId: number;
+    }): Promise<{
+        data: Blob | null;
+        headers: Headers | null;
     }>;
     getMetadata(options?: Partial<UrlRequestOptions>): Promise<unknown>;
     removeConsumer(consumer: DataSourceConsumer): void;
@@ -6566,8 +6825,14 @@ constructor(id: string, spec: Partial<Source>);
      * @param tile - The tile to abort.
      */
     protected abortTile(tile: Tile<Data>): void;
-
-/**
+    /**
+     * Aborts in-worker requests for a tile by coordinate (e.g. when tile is no longer visible).
+     * Override in subclasses that run work in a worker (e.g. encoded operation layers).
+     * @param coord - The tile coordinate to abort.
+     */
+    abortTileByCoord(_coord: TileCoord): void;
+    
+    /**
      * Cancels all active tile requests.
      */
     cancelAllRequests(): void;
@@ -6710,6 +6975,7 @@ export declare class TimeAnimation extends Animation {
     private _endDate;
     private _endOffset;
     private _now;
+    private _rangeChangeAnchorDate?;
     constructor({ start, end, alwaysStopAtStart, ...animationOpts }: Partial<TimeAnimationOptions>);
     /**
      * Sets the start date of the animation using an offset from a reference date.
@@ -6762,6 +7028,14 @@ export declare class TimeAnimation extends Animation {
     protected eventPayload(): Record<string, any>;
     protected advanceToStopPosition(): void;
     private _debouncedRangeChangeEvent;
+    /**
+     * Captures the current date as an anchor date for the range change event.
+     */
+    private _captureRangeChangeAnchorDate;
+    /**
+     * Restores the anchor date for the range change event.
+     */
+    private _restoreRangeChangeAnchorDate;
 }
 
 export declare type TimeAnimationInfo = {
@@ -6940,6 +7214,11 @@ export declare type TimeSeriesOperation = {
      * Bands to restrict the operation to. If not specified, the operation will be applied to all bands.
      */
     bands?: Array<ColorBand>;
+    /**
+     * The data range to remap the data to. If not specified, the data range will not be remapped and use provided data
+     * range or the range based on the datasets being used by the operation.
+     */
+    remappedDataRange?: ValueRange;
 };
 
 /**
@@ -7095,11 +7374,12 @@ export declare const units: {
             readonly percent: "%";
         };
     };
+    resolveMeasurementForUnits: (type: _units.ConversionMeasurement) => _units.Measurement;
     defaultUnits: Record<"metric" | "imperial", MapUnits>;
-    getDefaultUnit: (type: _units.Measurement, system: "custom" | "metric" | "imperial") => string;
-    getDefaultUnitsForSystem: (system: "custom" | "metric" | "imperial") => MapUnits;
+    getDefaultUnit: (type: _units.ConversionMeasurement, system: "metric" | "imperial" | "custom") => string;
+    getDefaultUnitsForSystem: (system: "metric" | "imperial" | "custom") => MapUnits;
     equalUnits: (units1: MapUnits, units2: MapUnits) => boolean;
-    getSystemForUnits: (units: MapUnits) => "custom" | "metric" | "imperial";
+    getSystemForUnits: (units: MapUnits) => "metric" | "imperial" | "custom";
     FtoC: (f: number) => number;
     CtoF: (c: number) => number;
     mphToKph: (mph: number) => number;
@@ -7131,6 +7411,7 @@ export declare const units: {
     msToMphUnit: (ms: number) => number;
     dbzToMMRate: (dbz: number, perSecond?: boolean) => number;
     degToDir: (d: number) => string;
+    getUnitPrecision: (unit: string) => number;
     convert: (type: string, value: number, from: string, to: string) => number;
     getMeasurementType: (str: string) => _units.Measurement;
 };
@@ -7140,6 +7421,8 @@ declare namespace _units {
         UnitSystem,
         Units,
         Measurement,
+        ConversionMeasurement,
+        resolveMeasurementForUnits,
         defaultUnits,
         getDefaultUnit,
         getDefaultUnitsForSystem,
@@ -7176,6 +7459,7 @@ declare namespace _units {
         msToMphUnit,
         dbzToMMRate,
         degToDir,
+        getUnitPrecision,
         convert,
         getMeasurementType
     }
@@ -7233,6 +7517,9 @@ export declare const VectorSourceType: {
 
 export declare type VectorSourceType = ObjectValue<typeof VectorSourceType>;
 
+/** Static vector tile data or time-series container for animated vector tiles. */
+export declare type VectorTileData = VectorData | VectorTimeSeriesData;
+
 /**
  * A {@link TileSource} for vector tile data.
  * Vector tiles are a compact representation of geographic data. They are typically used to render map data in a vector
@@ -7240,25 +7527,32 @@ export declare type VectorSourceType = ObjectValue<typeof VectorSourceType>;
  * Vector tiles are typically served as a compressed binary format, such as
  * Mapbox's [MVT](https://docs.mapbox.com/vector-tiles/reference/mapbox-vector-tile-spec/).
  */
-export declare class VectorTileSource extends TileSource<VectorData, VectorSourceSpecification> {
+export declare class VectorTileSource extends TileSource<VectorTileData, VectorSourceSpecification> {
     
+    /**
+     * Tracks deferred tile refresh requests while a tile is still loading.
+     * Map key: tile coord hash.
+     * Map value: layer ids to refresh once parsing completes (`*` means refresh all consumers).
+     */
+    private readonly _pendingRefreshByTile;
     get type(): string;
     
     constructor(id: string, spec: Partial<VectorSourceSpecification>);
-    hasTile(coord: TileCoord, layerId?: string): boolean;
-    hasTileData(coord: TileCoord, layerId?: string): boolean;
+    hasTileData(coord: TileCoord, layerId?: string, allowExpired?: boolean, _intervals?: Array<Date>): boolean;
     expireAllTiles(): void;
-    expireTile(tile: Tile<VectorData>): void;
+    expireTile(tile: Tile<VectorTileData>): void;
+    addConsumer(consumer: DataSourceConsumer): void;
     /**
      * Refreshes the data for all tiles in the source.
+     * @param layerId - The layer ID to refresh. If not provided, all layers will be refreshed.
      */
-    refreshAllTileData(): void;
+    refreshAllTileData(layerId?: string): void;
     /**
-     * Refreshes the data for a single tile in the source by re-parsing the existing data. This is useful when the
-     * filter expression has changed for a consuming layer.
+     * Refreshes the data for a single tile in the source by re-parsing the existing data. This is useful when a new
+     * consumer is added or the filter expression has changed for a consuming layer.
      * @param tile - The tile to refresh.
      */
-    refreshTileData(tile: Tile<VectorData>): Promise<void>;
+    refreshTileData(tile: Tile<VectorTileData>, layerId?: string): Promise<void>;
     
 }
 
@@ -7375,6 +7669,14 @@ export declare type WeatherLayerOptions = {
      * The render style to use for rendering the layer's data.
      */
     type: LayerType;
+    /**
+     * The minimum zoom level for the layer.
+     */
+    minZoom?: number;
+    /**
+     * The maximum zoom level for the layer.
+     */
+    maxZoom?: number;
     /**
      * Whether the layer should be hidden by default. Default is `false`.
      */
@@ -7428,10 +7730,9 @@ export declare type WeatherLayerOptions = {
      */
     timing: Partial<Omit<LayerTiming, 'mode'>>;
     /**
-     * Filter expression to use for filtering features from the data source. This is only used for vector tile data
-     * sources whose tiles are in the Mapbox Vector Tile (MVT) format.
+     * Filter expression for vector tile layers. Evaluated with StyleExpression.
      */
-    filter: ExpressionSpecification;
+    filter: FilterExpression;
     /**
      * Paint style overrides for the layer.
      */
@@ -7477,6 +7778,12 @@ constructor(account: Account);
      * Returns the metadata for all available weather layers.
      */
     getLayerMetadata(): Promise<Array<WeatherLayerMetadata>>;
+    /**
+     * Returns a weather layer configuration for the specified Xweather Raster Maps layer code.
+     * @param code - The raster layer code to get the configuration for.
+     * @returns The weather layer configuration.
+     */
+    getRasterLayerConfig(code: string): WeatherLayerConfiguration;
     /**
      * Returns the weather layer configuration for the specified weather code. If the code represents a combined layer,
      * then an array of weather codes will be returned instead.
@@ -7510,6 +7817,14 @@ declare abstract class WebGLLayer<Source extends DataSource = DataSource> extend
      * The type of layer.
      */
     type: LayerType;
+    /**
+     * The minimum zoom level for the layer.
+     */
+    minZoom: number;
+    /**
+     * The maximum zoom level for the layer.
+     */
+    maxZoom: number;
     /**
      * The map controller that this layer is associated with.
      */
@@ -7563,7 +7878,14 @@ get mask(): LayerMask;
      * @readonly
      */
     get isDirty(): boolean;
-    constructor(id: string, { source, renderer }: Partial<WebGLLayerConfig>);
+    /**
+     * Optional measurement metadata associated with this layer's values.
+     */
+    measurement: {
+        type: ConversionMeasurement;
+        units: string;
+    } | undefined;
+    constructor(id: string, { source, renderer, measurement }: Partial<WebGLLayerConfig>);
     /**
      * Shows the layer if it is hidden.
      */
@@ -7592,9 +7914,11 @@ get mask(): LayerMask;
      * GeoJSON layer style will return the model properties associated with the feature at that location.
      * @param coord - Geographic coordinate to query for features.
      * @param zoom - Zoom level to query for features. If not provided, the map's current zoom level will be used.
+     * @param allowPartials - Whether to use partial data (ancestor or descendant) if the exact tile is not loaded.
+     * @param requestIfMissing - Whether to request the tile if it is missing.
      * @returns The features found at the specified coordinate and zoom level.
      */
-    queryFeatures(coord: Coordinate, zoom: number, allowPartials: boolean): FeatureQueryResult;
+    queryFeatures(coord: Coordinate, zoom: number, allowPartials: boolean, requestIfMissing?: boolean): FeatureQueryResult;
     /**
      * Returns a Promise that will query the layer for all features 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.
@@ -7655,5 +7979,12 @@ export declare interface WebGLLayerConfig {
      * Animation instance that controls the animation of this layer if time-based.
      */
     animation: Animation;
+    /**
+     * Optional measurement metadata associated with this layer's values.
+     */
+    measurement: {
+        type: ConversionMeasurement;
+        units: string;
+    };
 }