@maptiler/sdk 2.2.1 → 2.3.0

package/dist/src/converters/xml.d.ts

@@ -0,0 +1,54 @@
+export interface Link {
+    href: string | null;
+}
+export interface XMLProperties {
+    links?: Link[];
+}
+export interface PlacemarkProperties {
+    name?: string;
+    address?: string;
+    styleUrl?: string;
+    description?: string;
+    styleHash?: string;
+    styleMapHash?: Record<string, string | null>;
+    timespan?: {
+        begin: string;
+        end: string;
+    };
+    timestamp?: string;
+    stroke?: string;
+    "stroke-opacity"?: number;
+    "stroke-width"?: number;
+    fill?: string;
+    "fill-opacity"?: number;
+    visibility?: string;
+    icon?: string;
+    coordTimes?: (string | null)[] | (string | null)[][];
+}
+/**
+ * create a function that converts a string to XML
+ * https://developer.mozilla.org/en-US/docs/Web/API/DOMParser
+ */
+export declare function str2xml(str: string): Document;
+/**
+ * Check one of the top level child node is of a given type ("gpx", "kml").
+ * The check is not case sensitive.
+ * @param doc
+ * @param nodeName
+ * @returns
+ */
+export declare function hasChildNodeWithName(doc: Document, nodeName: string): boolean;
+/**
+ * create a function that converts a XML to a string
+ * https://developer.mozilla.org/en-US/docs/Web/API/XMLSerializer
+ */
+export declare function xml2str(node: Node): string;
+/**
+ * Given a XML document using the GPX spec, return GeoJSON
+ */
+export declare function gpx(doc: string | Document): GeoJSON.FeatureCollection;
+/**
+ * Given a XML document using the KML spec, return GeoJSON
+ */
+export declare function kml(doc: string | Document, xml2string?: (node: Node) => string): GeoJSON.FeatureCollection;
+export declare function gpxOrKml(doc: string | Document): GeoJSON.FeatureCollection | null;

package/dist/src/defaults.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Some default settings for the SDK
+ */
+declare const defaults: {
+    maptilerLogoURL: string;
+    maptilerURL: string;
+    maptilerApiHost: string;
+    rtlPluginURL: string;
+    primaryLanguage: import('@maptiler/client').LanguageInfo;
+    secondaryLanguage: import('@maptiler/client').LanguageInfo;
+    terrainSourceURL: string;
+    terrainSourceId: string;
+};
+export { defaults };

package/dist/src/helpers/index.d.ts

@@ -0,0 +1,14 @@
+import { takeScreenshot } from './screenshot';
+import { addPolyline, addPolygon, addPoint, addHeatmap } from './vectorlayerhelpers';
+
+export type { ZoomStringValues, ZoomNumberValues, PropertyValues, CommonShapeLayerOptions, PolylineLayerOptions, PolygonLayerOptions, PointLayerOptions, HeatmapLayerOptions, } from './vectorlayerhelpers';
+/**
+ * Helpers are a set of functions to facilitate the creation of sources and layers
+ */
+export declare const helpers: {
+    addPolyline: typeof addPolyline;
+    addPolygon: typeof addPolygon;
+    addPoint: typeof addPoint;
+    addHeatmap: typeof addHeatmap;
+    takeScreenshot: typeof takeScreenshot;
+};

package/dist/src/helpers/screenshot.d.ts

@@ -0,0 +1,19 @@
+import { Map as MapSDK } from '../Map';
+
+/**
+ * Takes a screenshot (PNG file) of the curent map view.
+ * Depending on the options, this function can automatically trigger a download of te file.
+ */
+export declare function takeScreenshot(map: MapSDK, options?: {
+    /**
+     * If `true`, this function will trigger a download in addition to returning a blob.
+     * Default: `false`
+     */
+    download?: boolean;
+    /**
+     * Only if `options.download` is `true`. Indicates the filename under which
+     * the file will be downloaded.
+     * Default: `"maptiler_screenshot.png"`
+     */
+    filename?: string;
+}): Promise<Blob>;

package/dist/src/helpers/stylehelper.d.ts

@@ -0,0 +1,29 @@
+import { DataDrivenPropertyValueSpecification, ExpressionSpecification } from 'maplibre-gl';
+import { ColorRamp } from '../colorramp';
+import { DataDrivenStyle, PropertyValues, ZoomNumberValues, ZoomStringValues } from './vectorlayerhelpers';
+
+export type ColorPalette = [string, string, string, string];
+export declare const colorPalettes: Array<ColorPalette>;
+export declare function getRandomColor(): string;
+export declare function generateRandomSourceName(): string;
+export declare function generateRandomLayerName(): string;
+/**
+ * Linera interpolation to find a value at an arbitrary zoom level, given a list of tuple zoom-value
+ */
+export declare function lerpZoomNumberValues(znv: ZoomNumberValues, z: number): number;
+export declare function paintColorOptionsToPaintSpec(color: ZoomStringValues): DataDrivenPropertyValueSpecification<string>;
+export declare function rampedOptionsToLayerPaintSpec(ramp: ZoomNumberValues): DataDrivenPropertyValueSpecification<number>;
+export declare function computeRampedOutlineWidth(lineWidth: number | ZoomNumberValues, outlineWidth: number | ZoomNumberValues): number | DataDrivenPropertyValueSpecification<number>;
+export declare function rampedPropertyValueWeight(ramp: PropertyValues, property: string): DataDrivenPropertyValueSpecification<number>;
+/**
+ * Create a dash array from a string pattern that uses underscore and whitespace characters
+ */
+export declare function dashArrayMaker(pattern: string): Array<number>;
+export declare function colorDrivenByProperty(style: DataDrivenStyle, property: string): DataDrivenPropertyValueSpecification<string>;
+export declare function radiusDrivenByProperty(style: DataDrivenStyle, property: string, zoomCompensation?: boolean): DataDrivenPropertyValueSpecification<number>;
+export declare function radiusDrivenByPropertyHeatmap(style: PropertyValues, property: string, zoomCompensation?: boolean): DataDrivenPropertyValueSpecification<number>;
+/**
+ * Turns a ColorRamp instance into a MapLibre style for ramping the opacity, driven by a property
+ */
+export declare function opacityDrivenByProperty(colorramp: ColorRamp, property: string): DataDrivenPropertyValueSpecification<number>;
+export declare function heatmapIntensityFromColorRamp(colorRamp: ColorRamp, steps?: number): ExpressionSpecification;

package/dist/src/helpers/vectorlayerhelpers.d.ts

@@ -0,0 +1,509 @@
+import { FeatureCollection } from 'geojson';
+import { Map as SDKMap } from '../Map';
+import { ColorRamp } from '../colorramp';
+
+/**
+ * Array of string values that depend on zoom level
+ */
+export type ZoomStringValues = Array<{
+    /**
+     * Zoom level
+     */
+    zoom: number;
+    /**
+     * Value for the given zoom level
+     */
+    value: string;
+}>;
+/**
+ *
+ * Array of number values that depend on zoom level
+ */
+export type ZoomNumberValues = Array<{
+    /**
+     * Zoom level
+     */
+    zoom: number;
+    /**
+     * Value for the given zoom level
+     */
+    value: number;
+}>;
+export type PropertyValues = Array<{
+    /**
+     * Value of the property (input)
+     */
+    propertyValue: number;
+    /**
+     * Value to associate it with (output)
+     */
+    value: number;
+}>;
+/**
+ * Describes how to render a cluster of points
+ */
+export type DataDrivenStyle = Array<{
+    /**
+     * Numerical value to observe and apply the style upon.
+     * In case of clusters, the value to observe is automatically the number of elements in a cluster.
+     * In other cases, it can be a provided value.
+     */
+    value: number;
+    /**
+     * Radius of the cluster circle
+     */
+    pointRadius: number;
+    /**
+     * Color of the cluster
+     */
+    color: string;
+}>;
+export type CommonShapeLayerOptions = {
+    /**
+     * ID to give to the layer.
+     * If not provided, an auto-generated ID of the for "maptiler-layer-xxxxxx" will be auto-generated,
+     * with "xxxxxx" being a random string.
+     */
+    layerId?: string;
+    /**
+     * ID to give to the geojson source.
+     * If not provided, an auto-generated ID of the for "maptiler-source-xxxxxx" will be auto-generated,
+     * with "xxxxxx" being a random string.
+     */
+    sourceId?: string;
+    /**
+     * A geojson Feature collection or a URL to a geojson or the UUID of a MapTiler Cloud dataset.
+     */
+    data: FeatureCollection | string;
+    /**
+     * The ID of an existing layer to insert the new layer before, resulting in the new layer appearing
+     * visually beneath the existing layer. If this argument is not specified, the layer will be appended
+     * to the end of the layers array and appear visually above all other layers.
+     */
+    beforeId?: string;
+    /**
+     * Zoom level at which it starts to show.
+     * Default: `0`
+     */
+    minzoom?: number;
+    /**
+     * Zoom level after which it no longer show.
+     * Default: `22`
+     */
+    maxzoom?: number;
+    /**
+     * Whether or not to add an outline.
+     * Default: `false`
+     */
+    outline?: boolean;
+    /**
+     * Color of the outline. This is can be a constant color string or a definition based on zoom levels.
+     * Applies only if `.outline` is `true`.
+     * Default: `white`
+     */
+    outlineColor?: string | ZoomStringValues;
+    /**
+     * Width of the outline (relative to screen-space). This is can be a constant width or a definition based on zoom levels.
+     * Applies only if `.outline` is `true`.
+     * Default: `1`
+     */
+    outlineWidth?: number | ZoomNumberValues;
+    /**
+     * Opacity of the outline. This is can be a constant opacity in [0, 1] or a definition based on zoom levels
+     * Applies only if `.outline` is `true`.
+     * Default: `1`
+     */
+    outlineOpacity?: number | ZoomNumberValues;
+};
+export type PolylineLayerOptions = CommonShapeLayerOptions & {
+    /**
+     * Color of the line (or polyline). This is can be a constant color string or a definition based on zoom levels.
+     * Default: a color randomly pick from a list
+     */
+    lineColor?: string | ZoomStringValues;
+    /**
+     * Width of the line (relative to screen-space). This is can be a constant width or a definition based on zoom levels
+     * Default: `3`
+     */
+    lineWidth?: number | ZoomNumberValues;
+    /**
+     * Opacity of the line. This is can be a constant opacity in [0, 1] or a definition based on zoom levels.
+     * Default: `1`
+     */
+    lineOpacity?: number | ZoomNumberValues;
+    /**
+     * How blury the line is, with `0` being no blur and `10` and beyond being quite blurry.
+     * Default: `0`
+     */
+    lineBlur?: number | ZoomNumberValues;
+    /**
+     * Draws a line casing outside of a line's actual path. Value indicates the width of the inner gap.
+     * Default: `0`
+     */
+    lineGapWidth?: number | ZoomNumberValues;
+    /**
+     * Sequence of line and void to create a dash pattern. The unit is the line width so that
+     * a dash array value of `[3, 1]` will create a segment worth 3 times the width of the line,
+     * followed by a spacing worth 1 time the line width, and then repeat.
+     *
+     * Alternatively, this property can be a string made of underscore and whitespace characters
+     * such as `"___ _ "` and internaly this will be translated into [3, 1, 1, 1]. Note that
+     * this way of describing dash arrays with a string only works for integer values.
+     *
+     * Dash arrays can contain more than 2 element to create more complex patters. For instance
+     * a dash array value of [3, 2, 1, 2] will create the following sequence:
+     * - a segment worth 3 times the width
+     * - a spacing worth 2 times the width
+     * - a segment worth 1 times the width
+     * - a spacing worth 2 times the width
+     * - repeat
+     *
+     * Default: no dash pattern
+     */
+    lineDashArray?: Array<number> | string;
+    /**
+     * The display of line endings for both the line and the outline (if `.outline` is `true`)
+     * - "butt": A cap with a squared-off end which is drawn to the exact endpoint of the line.
+     * - "round": A cap with a rounded end which is drawn beyond the endpoint of the line at a radius of one-half of the line's width and centered on the endpoint of the line.
+     * - "square": A cap with a squared-off end which is drawn beyond the endpoint of the line at a distance of one-half of the line's width.
+     * Default: "round"
+     */
+    lineCap?: "butt" | "round" | "square";
+    /**
+     * The display of lines when joining for both the line and the outline (if `.outline` is `true`)
+     * - "bevel": A join with a squared-off end which is drawn beyond the endpoint of the line at a distance of one-half of the line's width.
+     * - "round": A join with a rounded end which is drawn beyond the endpoint of the line at a radius of one-half of the line's width and centered on the endpoint of the line.
+     * - "miter": A join with a sharp, angled corner which is drawn with the outer sides beyond the endpoint of the path until they meet.
+     * Default: "round"
+     */
+    lineJoin?: "bevel" | "round" | "miter";
+    /**
+     * How blury the outline is, with `0` being no blur and `10` and beyond being quite blurry.
+     * Applies only if `.outline` is `true`.
+     * Default: `0`
+     */
+    outlineBlur?: number | ZoomNumberValues;
+};
+export type PolygonLayerOptions = CommonShapeLayerOptions & {
+    /**
+     * Color of the polygon. This is can be a constant color string or a definition based on zoom levels.
+     * Default: a color randomly pick from a list
+     */
+    fillColor?: string | ZoomStringValues;
+    /**
+     * Opacity of the polygon. This is can be a constant opacity in [0, 1] or a definition based on zoom levels
+     * Default: `1`
+     */
+    fillOpacity?: ZoomNumberValues;
+    /**
+     * Position of the outline with regard to the polygon edge (when `.outline` is `true`)
+     * Default: `"center"`
+     */
+    outlinePosition: "center" | "inside" | "outside";
+    /**
+     * Sequence of line and void to create a dash pattern. The unit is the line width so that
+     * a dash array value of `[3, 1]` will create a segment worth 3 times the width of the line,
+     * followed by a spacing worth 1 time the line width, and then repeat.
+     *
+     * Alternatively, this property can be a string made of underscore and whitespace characters
+     * such as `"___ _ "` and internaly this will be translated into [3, 1, 1, 1]. Note that
+     * this way of describing dash arrays with a string only works for integer values.
+     *
+     * Dash arrays can contain more than 2 element to create more complex patters. For instance
+     * a dash array value of [3, 2, 1, 2] will create the following sequence:
+     * - a segment worth 3 times the width
+     * - a spacing worth 2 times the width
+     * - a segment worth 1 times the width
+     * - a spacing worth 2 times the width
+     * - repeat
+     *
+     * Default: no dash pattern
+     */
+    outlineDashArray?: Array<number> | string;
+    /**
+     * The display of line endings for both the line and the outline (if `.outline` is `true`)
+     * - "butt": A cap with a squared-off end which is drawn to the exact endpoint of the line.
+     * - "round": A cap with a rounded end which is drawn beyond the endpoint of the line at a radius of one-half of the line's width and centered on the endpoint of the line.
+     * - "square": A cap with a squared-off end which is drawn beyond the endpoint of the line at a distance of one-half of the line's width.
+     * Default: "round"
+     */
+    outlineCap?: "butt" | "round" | "square";
+    /**
+     * The display of lines when joining for both the line and the outline (if `.outline` is `true`)
+     * - "bevel": A join with a squared-off end which is drawn beyond the endpoint of the line at a distance of one-half of the line's width.
+     * - "round": A join with a rounded end which is drawn beyond the endpoint of the line at a radius of one-half of the line's width and centered on the endpoint of the line.
+     * - "miter": A join with a sharp, angled corner which is drawn with the outer sides beyond the endpoint of the path until they meet.
+     * Default: "round"
+     */
+    outlineJoin?: "bevel" | "round" | "miter";
+    /**
+     * The pattern is an image URL to be put as a repeated background pattern of the polygon.
+     * Default: `null` (no pattern, `fillColor` will be used)
+     */
+    pattern?: string | null;
+    /**
+     * How blury the outline is, with `0` being no blur and `10` and beyond being quite blurry.
+     * Applies only if `.outline` is `true`.
+     * Default: `0`
+     */
+    outlineBlur?: number | ZoomNumberValues;
+};
+export type PointLayerOptions = CommonShapeLayerOptions & {
+    /**
+     * Can be a unique point color as a string (CSS color such as "#FF0000" or "red").
+     * Alternatively, the color can be a ColorRamp with a range.
+     * In case of `.cluster` being `true`, the range of the ColorRamp will be addressed with the number of elements in
+     * the cluster. If `.cluster` is `false`, the color will be addressed using the value of the `.property`.
+     * If no `.property` is given but `.pointColor` is a ColorRamp, the chosen color is the one at the lower bound of the ColorRamp.
+     * Default: a color randomly pick from a list
+     */
+    pointColor?: string | ColorRamp;
+    /**
+     * Radius of the points. Can be a fixed size or a value dependant on the zoom.
+     * If `.pointRadius` is not provided, the radius will depend on the size of each cluster (if `.cluster` is `true`)
+     * or on the value of each point (if `.property` is provided and `.pointColor` is a ColorRamp).
+     * The radius will be between `.minPointRadius` and `.maxPointRadius`
+     */
+    pointRadius?: number | ZoomNumberValues;
+    /**
+     * The minimum point radius posible.
+     * Default: `10`
+     */
+    minPointRadius?: number;
+    /**
+     * The maximum point radius posible.
+     * Default: `40`
+     */
+    maxPointRadius?: number;
+    /**
+     * The point property to observe and apply the radius and color upon.
+     * This is ignored if `.cluster` is `true` as the observed value will be fiorced to being the number
+     * of elements in each cluster.
+     *
+     * Default: none
+     */
+    property?: string;
+    /**
+     * Opacity of the point or icon. This is can be a constant opacity in [0, 1] or a definition based on zoom levels.
+     * Alternatively, if not provided but the `.pointColor` is a ColorRamp, the opacity will be extracted from tha alpha
+     * component if present.
+     * Default: `1`
+     */
+    pointOpacity?: number | ZoomNumberValues;
+    /**
+     * If `true`, the points will keep their circular shape align with the wiewport.
+     * If `false`, the points will be like flatten on the map. This difference shows
+     * when the map is tilted.
+     * Default: `true`
+     */
+    alignOnViewport?: boolean;
+    /**
+     * Whether the points should cluster
+     */
+    cluster?: boolean;
+    /**
+     * Shows a label with the numerical value id `true`.
+     * If `.cluster` is `true`, the value will be the numebr of elements in the cluster.
+     *
+     *
+     * Default: `true` if `cluster` or `dataDrivenStyleProperty` are used, `false` otherwise.
+     */
+    showLabel?: boolean;
+    /**
+     * text color used for the number elements in each cluster.
+     * Applicable only when `cluster` is `true`.
+     * Default: `#000000` (black)
+     */
+    labelColor?: string;
+    /**
+     * text size used for the number elements in each cluster.
+     * Applicable only when `cluster` is `true`.
+     * Default: `12`
+     */
+    labelSize?: number;
+    /**
+     * Only if `.cluster` is `false`.
+     * If the radius is driven by a property, then it will also scale by zoomming if `.zoomCompensation` is `true`.
+     * If `false`, the radius will not adapt according to the zoom level.
+     * Default: `true`
+     */
+    zoomCompensation?: boolean;
+};
+export type HeatmapLayerOptions = {
+    /**
+     * ID to give to the layer.
+     * If not provided, an auto-generated ID of the for "maptiler-layer-xxxxxx" will be auto-generated,
+     * with "xxxxxx" being a random string.
+     */
+    layerId?: string;
+    /**
+     * ID to give to the geojson source.
+     * If not provided, an auto-generated ID of the for "maptiler-source-xxxxxx" will be auto-generated,
+     * with "xxxxxx" being a random string.
+     */
+    sourceId?: string;
+    /**
+     * A geojson Feature collection or a URL to a geojson or the UUID of a MapTiler Cloud dataset.
+     */
+    data: FeatureCollection | string;
+    /**
+     * The ID of an existing layer to insert the new layer before, resulting in the new layer appearing
+     * visually beneath the existing layer. If this argument is not specified, the layer will be appended
+     * to the end of the layers array and appear visually above all other layers.
+     */
+    beforeId?: string;
+    /**
+     * Zoom level at which it starts to show.
+     * Default: `0`
+     */
+    minzoom?: number;
+    /**
+     * Zoom level after which it no longer show.
+     * Default: `22`
+     */
+    maxzoom?: number;
+    /**
+     * The ColorRamp instance to use for visualization. The color ramp is expected to be defined in the
+     * range `[0, 1]` or else will be forced to this range.
+     * Default: `ColorRampCollection.TURBO`
+     */
+    colorRamp?: ColorRamp;
+    /**
+     * Use a property to apply a weight to each data point. Using a property requires also using
+     * the options `.propertyValueWeight` or otherwise will be ignored.
+     * Default: none, the points will all have a weight of `1`.
+     */
+    property?: string;
+    /**
+     * The weight to give to each data point. If of type `PropertyValueWeights`, then the options `.property`
+     * must also be provided. If used a number, all data points will be weighted by the same number (which is of little interest)
+     */
+    weight?: PropertyValues | number;
+    /**
+     * The radius (in screenspace) can be:
+     * - a fixed number that will be constant across zoom level
+     * - of type `ZoomNumberValues` to be ramped accoding to zoom level (`.zoomCompensation` will then be ignored)
+     * - of type `PropertyValues` to be driven by the value of a property.
+     *   If so, the option `.property` must be provided and will still be resized according to zoom level,
+     *   unless the option `.zoomCompensation` is set to `false`.
+     *
+     * Default:
+     */
+    radius?: number | ZoomNumberValues | PropertyValues;
+    /**
+     * The opacity can be a fixed value or zoom-driven.
+     * Default: fades-in 0.25z after minzoom and fade-out 0.25z before maxzoom
+     */
+    opacity?: number | ZoomNumberValues;
+    /**
+     * The intensity is zoom-dependent. By default, the intensity is going to be scaled by zoom to preserve
+     * a natural aspect or the data distribution.
+     */
+    intensity?: number | ZoomNumberValues;
+    /**
+     * If the radius is driven by a property, then it will also scale by zoomming if `.zoomCompensation` is `true`.
+     * If `false`, the radius will not adapt according to the zoom level.
+     * Default: `true`
+     */
+    zoomCompensation?: boolean;
+};
+/**
+ * Add a polyline to the map from various sources and with builtin styling.
+ * Compatible sources:
+ * - gpx content as string
+ * - gpx file from URL
+ * - kml content from string
+ * - kml from url
+ * - geojson from url
+ * - geojson content as string
+ * - geojson content as JS object
+ * - uuid of a MapTiler Cloud dataset
+ *
+ * The method also gives the possibility to add an outline layer (if `options.outline` is `true`)
+ * and if so , the returned property `polylineOutlineLayerId` will be a string. As a result, two layers
+ * would be added.
+ *
+ * The default styling creates a line layer of constant width of 3px, the color will be randomly picked
+ * from a curated list of colors and the opacity will be 1.
+ * If the outline is enabled, the outline width is of 1px at all zoom levels, the color is white and
+ * the opacity is 1.
+ *
+ * Those style properties can be changed and ramped according to zoom level using an easier syntax.
+ *
+ */
+export declare function addPolyline(
+/**
+ * Map instance to add a polyline layer to
+ */
+map: SDKMap, 
+/**
+ * Options related to adding a polyline layer
+ */
+options: PolylineLayerOptions, 
+/**
+ * When the polyline data is loaded from a distant source, these options are propagated to the call of `fetch`
+ */
+fetchOptions?: RequestInit): Promise<{
+    polylineLayerId: string;
+    polylineOutlineLayerId: string;
+    polylineSourceId: string;
+}>;
+/**
+ * Add a polygon with styling options.
+ */
+export declare function addPolygon(map: SDKMap, options: PolygonLayerOptions): {
+    /**
+     * ID of the fill layer
+     */
+    polygonLayerId: string;
+    /**
+     * ID of the outline layer (will be `""` if no outline)
+     */
+    polygonOutlineLayerId: string;
+    /**
+     * ID of the source that contains the data
+     */
+    polygonSourceId: string;
+};
+/**
+ * Add a point layer from a GeoJSON source (or an existing sourceId) with many styling options
+ */
+export declare function addPoint(
+/**
+ * The Map instance to add a point layer to
+ */
+map: SDKMap, options: PointLayerOptions): {
+    /**
+     * ID of the unclustered point layer
+     */
+    pointLayerId: string;
+    /**
+     * ID of the clustered point layer (empty if `cluster` options id `false`)
+     */
+    clusterLayerId: string;
+    /**
+     * ID of the layer that shows the count of elements in each cluster (empty if `cluster` options id `false`)
+     */
+    labelLayerId: string;
+    /**
+     * ID of the data source
+     */
+    pointSourceId: string;
+};
+/**
+ * Add a polyline witgh optional outline from a GeoJSON object
+ */
+export declare function addHeatmap(
+/**
+ * Map instance to add a heatmap layer to
+ */
+map: SDKMap, options: HeatmapLayerOptions): {
+    /**
+     * ID of the heatmap layer
+     */
+    heatmapLayerId: string;
+    /**
+     * ID of the data source
+     */
+    heatmapSourceId: string;
+};