@maptiler/sdk 2.2.1 → 2.2.2

package/dist/src/MLAdapters/AttributionControl.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class AttributionControl extends maplibregl.AttributionControl {
+    onAdd(map: SDKMap | MapMLGL): HTMLElement;
+}

package/dist/src/MLAdapters/BoxZoomHandler.d.ts

@@ -0,0 +1,8 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class BoxZoomHandler extends maplibregl.BoxZoomHandler {
+    constructor(map: SDKMap | MapMLGL, options: {
+        clickTolerance: number;
+    });
+}

package/dist/src/MLAdapters/CanvasSource.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class CanvasSource extends maplibregl.CanvasSource {
+    onAdd(map: SDKMap | MapMLGL): void;
+}

package/dist/src/MLAdapters/CooperativeGesturesHandler.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, GestureOptions, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class CooperativeGesturesHandler extends maplibregl.CooperativeGesturesHandler {
+    constructor(map: SDKMap | MapMLGL, options: GestureOptions);
+}

package/dist/src/MLAdapters/FullscreenControl.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class FullscreenControl extends maplibregl.FullscreenControl {
+    onAdd(map: SDKMap | MapMLGL): HTMLElement;
+}

package/dist/src/MLAdapters/GeoJSONSource.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class GeoJSONSource extends maplibregl.GeoJSONSource {
+    onAdd(map: SDKMap | MapMLGL): void;
+}

package/dist/src/MLAdapters/GeolocateControl.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class GeolocateControl extends maplibregl.GeolocateControl {
+    onAdd(map: SDKMap | MapMLGL): HTMLElement;
+}

package/dist/src/MLAdapters/ImageSource.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class ImageSource extends maplibregl.ImageSource {
+    onAdd(map: SDKMap | MapMLGL): void;
+}

package/dist/src/MLAdapters/KeyboardHandler.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class KeyboardHandler extends maplibregl.KeyboardHandler {
+    constructor(map: SDKMap | MapMLGL);
+}

package/dist/src/MLAdapters/LogoControl.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class LogoControl extends maplibregl.LogoControl {
+    onAdd(map: SDKMap | MapMLGL): HTMLElement;
+}

package/dist/src/MLAdapters/MapMouseEvent.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class MapMouseEvent extends maplibregl.MapMouseEvent {
+    constructor(type: string, map: SDKMap | MapMLGL, originalEvent: MouseEvent, data?: any);
+}

package/dist/src/MLAdapters/MapTouchEvent.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class MapTouchEvent extends maplibregl.MapTouchEvent {
+    constructor(type: string, map: SDKMap | MapMLGL, originalEvent: TouchEvent);
+}

package/dist/src/MLAdapters/MapWheelEvent.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class MapWheelEvent extends maplibregl.MapWheelEvent {
+    constructor(type: string, map: SDKMap | MapMLGL, originalEvent: WheelEvent);
+}

package/dist/src/MLAdapters/Marker.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class Marker extends maplibregl.Marker {
+    addTo(map: SDKMap | MapMLGL): this;
+}

package/dist/src/MLAdapters/NavigationControl.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class NavigationControl extends maplibregl.NavigationControl {
+    onAdd(map: SDKMap | MapMLGL): HTMLElement;
+}

package/dist/src/MLAdapters/Popup.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class Popup extends maplibregl.Popup {
+    addTo(map: SDKMap | MapMLGL): this;
+}

package/dist/src/MLAdapters/RasterDEMTileSource.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class RasterDEMTileSource extends maplibregl.RasterDEMTileSource {
+    onAdd(map: SDKMap | MapMLGL): void;
+}

package/dist/src/MLAdapters/RasterTileSource.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class RasterTileSource extends maplibregl.RasterTileSource {
+    onAdd(map: SDKMap | MapMLGL): void;
+}

package/dist/src/MLAdapters/ScaleControl.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class ScaleControl extends maplibregl.ScaleControl {
+    onAdd(map: SDKMap | MapMLGL): HTMLElement;
+}

package/dist/src/MLAdapters/ScrollZoomHandler.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class ScrollZoomHandler extends maplibregl.ScrollZoomHandler {
+    constructor(map: SDKMap | MapMLGL, triggerRenderFrame: () => void);
+}

package/dist/src/MLAdapters/Style.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, StyleOptions } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class Style extends maplibregl.Style {
+    constructor(map: SDKMap, options?: StyleOptions);
+}

package/dist/src/MLAdapters/TerrainControl.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class TerrainControl extends maplibregl.TerrainControl {
+    onAdd(map: SDKMap | MapMLGL): HTMLElement;
+}

package/dist/src/MLAdapters/TwoFingersTouchPitchHandler.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class TwoFingersTouchPitchHandler extends maplibregl.TwoFingersTouchPitchHandler {
+    constructor(map: SDKMap | MapMLGL);
+}

package/dist/src/MLAdapters/VectorTileSource.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class VectorTileSource extends maplibregl.VectorTileSource {
+    onAdd(map: SDKMap | MapMLGL): void;
+}

package/dist/src/MLAdapters/VideoSource.d.ts

@@ -0,0 +1,6 @@
+import { default as maplibregl, Map as MapMLGL } from 'maplibre-gl';
+import { Map as SDKMap } from '../Map';
+
+export declare class VideoSource extends maplibregl.VideoSource {
+    onAdd(map: SDKMap | MapMLGL): void;
+}

package/dist/src/Map.d.ts

@@ -0,0 +1,349 @@
+import { default as maplibregl, StyleSpecification, MapOptions as MapOptionsML, ControlPosition, StyleSwapOptions, StyleOptions, RequestTransformFunction, LayerSpecification, SourceSpecification, CustomLayerInterface, FilterSpecification, StyleSetterOptions } from 'maplibre-gl';
+import { ReferenceMapStyle, MapStyleVariant } from '@maptiler/client';
+import { SdkConfig } from './config';
+import { LanguageString } from './language';
+import { MinimapOptionsInput } from './Minimap';
+
+export type LoadWithTerrainEvent = {
+    type: "loadWithTerrain";
+    target: Map;
+    terrain: {
+        source: string;
+        exaggeration: number;
+    };
+};
+export declare const GeolocationType: {
+    POINT: "POINT";
+    COUNTRY: "COUNTRY";
+};
+/**
+ * Options to provide to the `Map` constructor
+ */
+export type MapOptions = Omit<MapOptionsML, "style" | "maplibreLogo"> & {
+    /**
+     * Style of the map. Can be:
+     * - a full style URL (possibly with API key)
+     * - a shorthand with only the MapTIler style name (eg. `"streets-v2"`)
+     * - a longer form with the prefix `"maptiler://"` (eg. `"maptiler://streets-v2"`)
+     */
+    style?: ReferenceMapStyle | MapStyleVariant | StyleSpecification | string;
+    /**
+     * Define the language of the map. This can be done directly with a language ISO code (eg. "en")
+     * or with a built-in shorthand (eg. Language.ENGLISH).
+     * Note that this is equivalent to setting the `config.primaryLanguage` and will overwrite it.
+     */
+    language?: LanguageString;
+    /**
+     * Define the MapTiler Cloud API key to be used. This is strictly equivalent to setting
+     * `config.apiKey` and will overwrite it.
+     */
+    apiKey?: string;
+    /**
+     * Shows or hides the MapTiler logo in the bottom left corner.
+     *
+     * For paid plans:
+     * - `true` shows MapTiler logo
+     * - `false` hodes MapTiler logo
+     * - default: `false` (hide)
+     *
+     * For free plans: MapTiler logo always shows, regardless of the value.
+     */
+    maptilerLogo?: boolean;
+    /**
+     * Attribution text to show in an {@link AttributionControl}.
+     */
+    customAttribution?: string | Array<string>;
+    /**
+     * Enables 3D terrain if `true`. (default: `false`)
+     */
+    terrain?: boolean;
+    /**
+     * Exaggeration factor of the terrain. (default: `1`, no exaggeration)
+     */
+    terrainExaggeration?: number;
+    /**
+     * Show the navigation control. (default: `true`, will hide if `false`)
+     */
+    navigationControl?: boolean | ControlPosition;
+    /**
+     * Show the terrain control. (default: `false`, will show if `true`)
+     */
+    terrainControl?: boolean | ControlPosition;
+    /**
+     * Show the geolocate control. (default: `true`, will hide if `false`)
+     */
+    geolocateControl?: boolean | ControlPosition;
+    /**
+     * Show the scale control. (default: `false`, will show if `true`)
+     */
+    scaleControl?: boolean | ControlPosition;
+    /**
+     * Show the full screen control. (default: `false`, will show if `true`)
+     */
+    fullscreenControl?: boolean | ControlPosition;
+    /**
+     * Display a minimap in a user defined corner of the map. (default: `bottom-left` corner)
+     * If set to true, the map will assume it is a minimap and forego the attribution control.
+     */
+    minimap?: boolean | ControlPosition | MinimapOptionsInput;
+    /**
+     * attributionControl
+     */
+    forceNoAttributionControl?: boolean;
+    /**
+     * Method to position the map at a given geolocation. Only if:
+     * - `hash` is `false`
+     * - `center` is not provided
+     *
+     * If the value is `true` of `"POINT"` (given by `GeolocationType.POINT`) then the positionning uses the MapTiler Cloud
+     * Geolocation to find the non-GPS location point.
+     * The zoom level can be provided in the `Map` constructor with the `zoom` option or will be `13` if not provided.
+     *
+     * If the value is `"COUNTRY"` (given by `GeolocationType.COUNTRY`) then the map is centered around the bounding box of the country.
+     * In this case, the `zoom` option will be ignored.
+     *
+     * If the value is `false`, no geolocation is performed and the map centering and zooming depends on other options or on
+     * the built-in defaults.
+     *
+     * If this option is non-false and the options `center` is also provided, then `center` prevails.
+     *
+     * Default: `false`
+     */
+    geolocate?: (typeof GeolocationType)[keyof typeof GeolocationType] | boolean;
+};
+/**
+ * The Map class can be instanciated to display a map in a `<div>`
+ */
+export declare class Map extends maplibregl.Map {
+    private isTerrainEnabled;
+    private terrainExaggeration;
+    private primaryLanguage;
+    private terrainGrowing;
+    private terrainFlattening;
+    private minimap?;
+    private forceLanguageUpdate;
+    private languageAlwaysBeenStyle;
+    private isReady;
+    constructor(options: MapOptions);
+    /**
+     * Awaits for _this_ Map instance to be "loaded" and returns a Promise to the Map.
+     * If _this_ Map instance is already loaded, the Promise is resolved directly,
+     * otherwise, it is resolved as a result of the "load" event.
+     * @returns
+     */
+    onLoadAsync(): Promise<Map>;
+    /**
+     * Awaits for _this_ Map instance to be "ready" and returns a Promise to the Map.
+     * If _this_ Map instance is already ready, the Promise is resolved directly,
+     * otherwise, it is resolved as a result of the "ready" event.
+     * A map instance is "ready" when all the controls that can be managed by the contructor are
+     * dealt with. This happens after the "load" event, due to the asynchronous nature
+     * of some built-in controls.
+     */
+    onReadyAsync(): Promise<Map>;
+    /**
+     * Awaits for _this_ Map instance to be "loaded" as well as with terrain being non-null for the first time
+     * and returns a Promise to the Map.
+     * If _this_ Map instance is already loaded with terrain, the Promise is resolved directly,
+     * otherwise, it is resolved as a result of the "loadWithTerrain" event.
+     * @returns
+     */
+    onLoadWithTerrainAsync(): Promise<Map>;
+    /**
+     * Update the style of the map.
+     * Can be:
+     * - a full style URL (possibly with API key)
+     * - a shorthand with only the MapTIler style name (eg. `"streets-v2"`)
+     * - a longer form with the prefix `"maptiler://"` (eg. `"maptiler://streets-v2"`)
+     */
+    setStyle(style: null | ReferenceMapStyle | MapStyleVariant | StyleSpecification | string, options?: StyleSwapOptions & StyleOptions): this;
+    /**
+     * Adds a [MapLibre style layer](https://maplibre.org/maplibre-style-spec/layers)
+     * to the map's style.
+     *
+     * A layer defines how data from a specified source will be styled. Read more about layer types
+     * and available paint and layout properties in the [MapLibre Style Specification](https://maplibre.org/maplibre-style-spec/layers).
+     *
+     * @param layer - The layer to add,
+     * conforming to either the MapLibre Style Specification's [layer definition](https://maplibre.org/maplibre-style-spec/layers) or,
+     * less commonly, the {@link CustomLayerInterface} specification.
+     * The MapLibre Style Specification's layer definition is appropriate for most layers.
+     *
+     * @param beforeId - 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.
+     *
+     * @returns `this`
+     */
+    addLayer(layer: (LayerSpecification & {
+        source?: string | SourceSpecification;
+    }) | CustomLayerInterface, beforeId?: string): this;
+    /**
+     * Moves a layer to a different z-position.
+     *
+     * @param id - The ID of the layer to move.
+     * @param beforeId - The ID of an existing layer to insert the new layer before. When viewing the map, the `id` layer will appear beneath the `beforeId` layer. If `beforeId` is omitted, the layer will be appended to the end of the layers array and appear above all other layers on the map.
+     * @returns `this`
+     *
+     * @example
+     * Move a layer with ID 'polygon' before the layer with ID 'country-label'. The `polygon` layer will appear beneath the `country-label` layer on the map.
+     * ```ts
+     * map.moveLayer('polygon', 'country-label');
+     * ```
+     */
+    moveLayer(id: string, beforeId?: string): this;
+    /**
+     * Removes the layer with the given ID from the map's style.
+     *
+     * An {@link ErrorEvent} will be fired if the image parameter is invald.
+     *
+     * @param id - The ID of the layer to remove
+     * @returns `this`
+     *
+     * @example
+     * If a layer with ID 'state-data' exists, remove it.
+     * ```ts
+     * if (map.getLayer('state-data')) map.removeLayer('state-data');
+     * ```
+     */
+    removeLayer(id: string): this;
+    /**
+     * Sets the zoom extent for the specified style layer. The zoom extent includes the
+     * [minimum zoom level](https://maplibre.org/maplibre-style-spec/layers/#minzoom)
+     * and [maximum zoom level](https://maplibre.org/maplibre-style-spec/layers/#maxzoom))
+     * at which the layer will be rendered.
+     *
+     * Note: For style layers using vector sources, style layers cannot be rendered at zoom levels lower than the
+     * minimum zoom level of the _source layer_ because the data does not exist at those zoom levels. If the minimum
+     * zoom level of the source layer is higher than the minimum zoom level defined in the style layer, the style
+     * layer will not be rendered at all zoom levels in the zoom range.
+     */
+    setLayerZoomRange(layerId: string, minzoom: number, maxzoom: number): this;
+    /**
+     * Sets the filter for the specified style layer.
+     *
+     * Filters control which features a style layer renders from its source.
+     * Any feature for which the filter expression evaluates to `true` will be
+     * rendered on the map. Those that are false will be hidden.
+     *
+     * Use `setFilter` to show a subset of your source data.
+     *
+     * To clear the filter, pass `null` or `undefined` as the second parameter.
+     */
+    setFilter(layerId: string, filter?: FilterSpecification | null, options?: StyleSetterOptions): this;
+    /**
+     * Sets the value of a paint property in the specified style layer.
+     *
+     * @param layerId - The ID of the layer to set the paint property in.
+     * @param name - The name of the paint property to set.
+     * @param value - The value of the paint property to set.
+     * Must be of a type appropriate for the property, as defined in the [MapLibre Style Specification](https://maplibre.org/maplibre-style-spec/).
+     * @param options - Options object.
+     * @returns `this`
+     * @example
+     * ```ts
+     * map.setPaintProperty('my-layer', 'fill-color', '#faafee');
+     * ```
+     */
+    setPaintProperty(layerId: string, name: string, value: any, options?: StyleSetterOptions): this;
+    /**
+     * Sets the value of a layout property in the specified style layer.
+     * Layout properties define how the layer is styled.
+     * Layout properties for layers of the same type are documented together.
+     * Layers of different types have different layout properties.
+     * See the [MapLibre Style Specification](https://maplibre.org/maplibre-style-spec/) for the complete list of layout properties.
+     * @param layerId - The ID of the layer to set the layout property in.
+     * @param name - The name of the layout property to set.
+     * @param value - The value of the layout property to set.
+     * Must be of a type appropriate for the property, as defined in the [MapLibre Style Specification](https://maplibre.org/maplibre-style-spec/).
+     * @param options - Options object.
+     * @returns `this`
+     */
+    setLayoutProperty(layerId: string, name: string, value: any, options?: StyleSetterOptions): this;
+    /**
+     * Sets the value of the style's glyphs property.
+     *
+     * @param glyphsUrl - Glyph URL to set. Must conform to the [MapLibre Style Specification](https://maplibre.org/maplibre-style-spec/glyphs/).
+     * @param options - Options object.
+     * @returns `this`
+     * @example
+     * ```ts
+     * map.setGlyphs('https://demotiles.maplibre.org/font/{fontstack}/{range}.pbf');
+     * ```
+     */
+    setGlyphs(glyphsUrl: string | null, options?: StyleSetterOptions): this;
+    private getStyleLanguage;
+    /**
+     * Define the primary language of the map. Note that not all the languages shorthands provided are available.
+     */
+    setLanguage(language: LanguageString | string): void;
+    /**
+     * Define the primary language of the map. Note that not all the languages shorthands provided are available.
+     */
+    private setPrimaryLanguage;
+    /**
+     * Get the primary language
+     * @returns
+     */
+    getPrimaryLanguage(): LanguageString;
+    /**
+     * Get the exaggeration factor applied to the terrain
+     * @returns
+     */
+    getTerrainExaggeration(): number;
+    /**
+     * Know if terrian is enabled or not
+     * @returns
+     */
+    hasTerrain(): boolean;
+    private growTerrain;
+    /**
+     * Enables the 3D terrain visualization
+     */
+    enableTerrain(exaggeration?: number): void;
+    /**
+     * Disable the 3D terrain visualization
+     */
+    disableTerrain(): void;
+    /**
+     * Sets the 3D terrain exageration factor.
+     * If the terrain was not enabled prior to the call of this method,
+     * the method `.enableTerrain()` will be called.
+     * If `animate` is `true`, the terrain transformation will be animated in the span of 1 second.
+     * If `animate` is `false`, no animated transition to the newly defined exaggeration.
+     */
+    setTerrainExaggeration(exaggeration: number, animate?: boolean): void;
+    /**
+     * Perform an action when the style is ready. It could be at the moment of calling this method
+     * or later.
+     */
+    private onStyleReady;
+    fitToIpBounds(): Promise<void>;
+    centerOnIpPoint(zoom: number | undefined): Promise<void>;
+    getCameraHash(): string;
+    /**
+     * Get the SDK config object.
+     * This is convenient to dispatch the SDK configuration to externally built layers
+     * that do not directly have access to the SDK configuration but do have access to a Map instance.
+     */
+    getSdkConfig(): SdkConfig;
+    /**
+     * Get the MapTiler session ID. Convenient to dispatch to externaly built component
+     * that do not directly have access to the SDK configuration but do have access to a Map instance.
+     * @returns
+     */
+    getMaptilerSessionId(): string;
+    /**
+     *  Updates the requestManager's transform request with a new function.
+     *
+     * @param transformRequest A callback run before the Map makes a request for an external URL. The callback can be used to modify the url, set headers, or set the credentials property for cross-origin requests.
+     *    Expected to return an object with a `url` property and optionally `headers` and `credentials` properties
+     *
+     * @returns {Map} `this`
+     *
+     *  @example
+     *  map.setTransformRequest((url: string, resourceType: string) => {});
+     */
+    setTransformRequest(transformRequest: RequestTransformFunction): this;
+}

package/dist/src/MaptilerGeolocateControl.d.ts

@@ -0,0 +1,21 @@
+import { GeolocateControl } from './MLAdapters/GeolocateControl';
+
+/**
+ * The MaptilerGeolocateControl is an extension of the original GeolocateControl
+ * with a few changes. In this version, the active mode persists as long as the
+ * location is still centered. This means it's robust to rotation, pitch and zoom.
+ *
+ */
+export declare class MaptilerGeolocateControl extends GeolocateControl {
+    private lastUpdatedCenter;
+    /**
+     * Update the camera location to center on the current position
+     *
+     * @param {Position} position the Geolocation API Position
+     * @private
+     */
+    _updateCamera: (position: GeolocationPosition) => void;
+    _setupUI: (supported: boolean) => void;
+    _updateCircleRadius(): void;
+    _onZoom: () => void;
+}

package/dist/src/MaptilerLogoControl.d.ts

@@ -0,0 +1,20 @@
+import { LogoControlOptions as LogoControlOptionsML } from 'maplibre-gl';
+import { LogoControl } from './MLAdapters/LogoControl';
+import { Map as SDKMap } from './Map';
+
+type LogoControlOptions = LogoControlOptionsML & {
+    logoURL?: string;
+    linkURL?: string;
+};
+/**
+ * This LogoControl extends the MapLibre LogoControl but instead can use any image URL and
+ * any link URL. By default this is using MapTiler logo and URL.
+ */
+export declare class MaptilerLogoControl extends LogoControl {
+    _compact: boolean;
+    private logoURL;
+    private linkURL;
+    constructor(options?: LogoControlOptions);
+    onAdd(map: SDKMap): HTMLElement;
+}
+export {};

package/dist/src/MaptilerNavigationControl.d.ts

@@ -0,0 +1,17 @@
+import { NavigationControl } from './MLAdapters/NavigationControl';
+
+type HTMLButtonElementPlus = HTMLButtonElement & {
+    clickFunction: (e?: Event) => unknown;
+};
+export declare class MaptilerNavigationControl extends NavigationControl {
+    constructor();
+    /**
+     * Overloading: the button now stores its click callback so that we can later on delete it and replace it
+     */
+    _createButton(className: string, fn: (e?: Event) => unknown): HTMLButtonElementPlus;
+    /**
+     * Overloading: Limit how flat the compass icon can get
+     */
+    _rotateCompassArrow: () => void;
+}
+export {};

package/dist/src/MaptilerTerrainControl.d.ts

@@ -0,0 +1,17 @@
+import { Map as SDKMap } from './Map';
+import { IControl } from 'maplibre-gl';
+
+/**
+ * A `MaptilerTerrainControl` control adds a button to turn terrain on and off
+ * by triggering the terrain logic that is already deployed in the Map object.
+ */
+export declare class MaptilerTerrainControl implements IControl {
+    _map: SDKMap;
+    _container: HTMLElement;
+    _terrainButton: HTMLButtonElement;
+    constructor();
+    onAdd(map: SDKMap): HTMLElement;
+    onRemove(): void;
+    _toggleTerrain(): void;
+    _updateTerrainIcon(): void;
+}