@maptiler/sdk 3.8.0-rc2 → 3.8.0-rc4

package/dist/src/ColorRamp.d.ts

@@ -0,0 +1,359 @@
+export type RgbaColor = [number, number, number] | [number, number, number, number];
+export type ColorStop = {
+    /**
+     * The "value" at which this ColorStop should be applied.
+     */
+    value: number;
+    /**
+     * RGB[A] - Array of 3-4 numbers. 0-255 per channel.
+     */
+    color: RgbaColor;
+};
+/**
+ * A RGBA color as per the array definition
+ */
+export type ArrayColor = [number, number, number, number];
+/**
+ * A color ramp stop as per array definition
+ */
+export type ArrayColorRampStop = [
+    /**
+     * Real world value in a real world unit
+     */
+    number,
+    /**
+     * Color RGBA
+     */
+    ArrayColor
+];
+/**
+ * A color ramp as per array definition
+ */
+export type ArrayColorRamp = Array<ArrayColorRampStop>;
+export type ColorRampOptions = {
+    /**
+     * The value the colorramp starts
+     */
+    min?: number;
+    /**
+     * The value the colorramp ends
+     */
+    max?: number;
+    /**
+     * Some color stops to copy from
+     */
+    stops?: Array<ColorStop>;
+};
+export declare class ColorRamp extends Array<ColorStop> {
+    /**
+     * Converts a array-definition color ramp definition into a usable ColorRamp instance.
+     * Note: units are not converted and may need to to be converted beforehand (eg. kelvin to centigrade)
+     * @param cr
+     * @returns
+     */
+    static fromArrayDefinition(cr: ArrayColorRamp): ColorRamp;
+    private min;
+    private max;
+    constructor(options?: ColorRampOptions);
+    setStops(stops: Array<ColorStop>, options?: {
+        clone?: boolean;
+    }): ColorRamp;
+    scale(min: number, max: number, options?: {
+        clone?: boolean;
+    }): ColorRamp;
+    at(pos: number): ColorStop;
+    clone(): ColorRamp;
+    getRawColorStops(): Array<ColorStop>;
+    reverse(options?: {
+        clone?: boolean;
+    }): ColorRamp;
+    getBounds(): {
+        min: number;
+        max: number;
+    };
+    getColor(value: number, options?: {
+        smooth?: boolean;
+    }): RgbaColor;
+    /**
+     * Get the color as an hexadecimal string
+     */
+    getColorHex(value: number, options?: {
+        smooth?: boolean;
+        withAlpha?: boolean;
+    }): string;
+    /**
+     * Get the color of the color ramp at a relative position in [0, 1]
+     */
+    getColorRelative(value: number, options?: {
+        smooth?: boolean;
+    }): RgbaColor;
+    getCanvasStrip(options?: {
+        horizontal?: boolean;
+        size?: number;
+        smooth?: boolean;
+    }): HTMLCanvasElement;
+    /**
+     * Apply a non-linear ressampling. This will create a new instance of ColorRamp with the same bounds.
+     */
+    resample(method: "ease-in-square" | "ease-out-square" | "ease-in-sqrt" | "ease-out-sqrt" | "ease-in-exp" | "ease-out-exp", samples?: number): ColorRamp;
+    /**
+     * Makes a clone of this color ramp that is fully transparant at the begining of their range
+     */
+    transparentStart(): ColorRamp;
+    /**
+     * Check if this color ramp has a transparent start
+     */
+    hasTransparentStart(): boolean;
+}
+/**
+ * This is a collection of built-in color ramps. They are all defined in the range [0, 1]
+ * but can be scaled or reversed to fit specific usages.
+ */
+export declare const ColorRampCollection: {
+    /**
+     * A fully transparent [0, 0, 0, 0] colorramp to hide data.
+     * Defined in interval [0, 1], without unit.
+     */
+    NULL: ColorRamp;
+    GRAY: ColorRamp;
+    /**
+     * Classic jet color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    JET: ColorRamp;
+    /**
+     * Classic HSV color ramp (hue, saturation, value).
+     * Defined in interval [0, 1], without unit.
+     */
+    HSV: ColorRamp;
+    /**
+     * Classic hot color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    HOT: ColorRamp;
+    /**
+     * Classic spring color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    SPRING: ColorRamp;
+    /**
+     * Classic summer color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    SUMMER: ColorRamp;
+    /**
+     * Classic autommn color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    AUTOMN: ColorRamp;
+    /**
+     * Classic winter color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    WINTER: ColorRamp;
+    /**
+     * Classic bone color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    BONE: ColorRamp;
+    /**
+     * Classic copper color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    COPPER: ColorRamp;
+    /**
+     * Classic greys color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    GREYS: ColorRamp;
+    /**
+     * Classic yignbu color ramp (blue to light yellow).
+     * Defined in interval [0, 1], without unit.
+     */
+    YIGNBU: ColorRamp;
+    /**
+     * Classic greens color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    GREENS: ColorRamp;
+    /**
+     * Classic yiorrd color ramp (red to light yellow).
+     * Defined in interval [0, 1], without unit.
+     */
+    YIORRD: ColorRamp;
+    /**
+     * Classic blue-red color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    BLUERED: ColorRamp;
+    /**
+     * Classic rdbu color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    RDBU: ColorRamp;
+    /**
+     * Classic picnic color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    PICNIC: ColorRamp;
+    /**
+     * Classic rainbow color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    RAINBOW: ColorRamp;
+    /**
+     * Classic Portland color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    PORTLAND: ColorRamp;
+    /**
+     * Classic blackbody color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    BLACKBODY: ColorRamp;
+    /**
+     * Classic earth color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    EARTH: ColorRamp;
+    /**
+     * Classic electric color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    ELECTRIC: ColorRamp;
+    /**
+     * Classic viridis color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    VIRIDIS: ColorRamp;
+    /**
+     * Classic inferno color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    INFERNO: ColorRamp;
+    /**
+     * Classic magma color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    MAGMA: ColorRamp;
+    /**
+     * Classic plasma color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    PLASMA: ColorRamp;
+    /**
+     * Classic warm color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    WARM: ColorRamp;
+    /**
+     * Classic cool color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    COOL: ColorRamp;
+    /**
+     * Classic rainboz soft color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    RAINBOW_SOFT: ColorRamp;
+    /**
+     * Classic bathymetry color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    BATHYMETRY: ColorRamp;
+    /**
+     * Classic cdom color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    CDOM: ColorRamp;
+    /**
+     * Classic chlorophyll color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    CHLOROPHYLL: ColorRamp;
+    /**
+     * Classic density color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    DENSITY: ColorRamp;
+    /**
+     * Classic freesurface blue color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    FREESURFACE_BLUE: ColorRamp;
+    /**
+     * Classic freesurface red color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    FREESURFACE_RED: ColorRamp;
+    /**
+     * Classic oxygen color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    OXYGEN: ColorRamp;
+    /**
+     * Classic par color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    PAR: ColorRamp;
+    /**
+     * Classic phase color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    PHASE: ColorRamp;
+    /**
+     * Classic salinity color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    SALINITY: ColorRamp;
+    /**
+     * Classic temperature color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    TEMPERATURE: ColorRamp;
+    /**
+     * Classic turbidity color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    TURBIDITY: ColorRamp;
+    /**
+     * Classic velocity blue color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    VELOCITY_BLUE: ColorRamp;
+    /**
+     * Classic velocity green color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    VELOCITY_GREEN: ColorRamp;
+    /**
+     * Classic cube helix color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    CUBEHELIX: ColorRamp;
+    /**
+     * The cividis color ramp is color blind friendly.
+     * Read more here https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0199239
+     * Defined in interval [0, 1], without unit.
+     */
+    CIVIDIS: ColorRamp;
+    /**
+     * Classic turbo color ramp.
+     * This is a luminance-constant alternative to the jet, making it more
+     * clor-blind friendly.
+     * Defined in interval [0, 1], without unit.
+     */
+    TURBO: ColorRamp;
+    /**
+     * The rocket color ramp is perceptually uniform, which makes it more
+     * color bliend friendly than the classic magma color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    ROCKET: ColorRamp;
+    /**
+     * The mako color ramp is perceptually uniform and can be seen as
+     * a color blind friendly alternative to bathymetry or yignbu.
+     * Defined in interval [0, 1], without unit.
+     */
+    MAKO: ColorRamp;
+};

package/dist/src/ImageViewer/ImageViewer.d.ts

@@ -0,0 +1,66 @@
+import { DoubleClickZoomHandler, DragPanHandler, EaseToOptions, PointLike, TwoFingersTouchZoomRotateHandler } from 'maplibre-gl';
+import { FlyToOptions, MapDataEvent, MapOptions, JumpToOptions, ScrollZoomHandler, BoxZoomHandler, KeyboardHandler, CooperativeGesturesHandler } from '..';
+import { Map } from '../Map';
+import { Evented } from '../';
+type AllowedConstrcutorOptions = "container" | "apiKey" | "maxZoom" | "minZoom" | "zoom" | "bearing";
+type ImageViewerConstructorOptions = Pick<MapOptions, AllowedConstrcutorOptions> & {
+    imageUUID: string;
+    debug?: boolean;
+    center?: [number, number];
+};
+export default class ImageViewer extends Evented {
+    private imageUUID;
+    private debug;
+    private imageMetadata?;
+    /**
+     * Why not extend the Map class?
+     * Because ImageViewer technically operates in screen space and not in map space.
+     * We wrap map and perform calculations in screen space.
+     * We do not want to have to extend the Map class and give access to
+     * methods and properties that operate in LngLat space.   *
+     */
+    private sdk;
+    private options;
+    private imageSize?;
+    private paddedSizeMax?;
+    get version(): string;
+    constructor(imageViewerConstructorOptions: Partial<ImageViewerConstructorOptions>);
+    onReadyAsync(): Promise<void>;
+    init(): Promise<void>;
+    fetchImageMetadata(): Promise<void>;
+    addImageSource(): void;
+    triggerRepaint(): void;
+    get scrollZoom(): ScrollZoomHandler;
+    set scrollZoom(value: ScrollZoomHandler);
+    get boxZoom(): BoxZoomHandler;
+    set boxZoom(value: BoxZoomHandler);
+    get dragPan(): DragPanHandler;
+    set dragPan(value: DragPanHandler);
+    get keyboard(): KeyboardHandler;
+    set keyboard(value: KeyboardHandler);
+    get doubleClickZoom(): DoubleClickZoomHandler;
+    set doubleClickZoom(value: DoubleClickZoomHandler);
+    get touchZoomRotate(): TwoFingersTouchZoomRotateHandler;
+    set touchZoomRotate(value: TwoFingersTouchZoomRotateHandler);
+    get cooperativeGestures(): CooperativeGesturesHandler;
+    set cooperativeGestures(value: CooperativeGesturesHandler);
+    private lngLatToPx;
+    private pxToLngLat;
+    flyTo(options: Omit<ImageViewerFlyToOptions, "bearing" | "pitch">, eventData?: MapDataEvent): Map;
+    jumpTo(options: Omit<ImageViewerJumpToOptions, "bearing" | "pitch">, eventData?: MapDataEvent): Map;
+    setZoom(zoom: number): void;
+    getZoom(): number;
+    getCenter(): [number, number];
+    setCenter(center: [number, number]): void;
+    setBearing(bearing: number): void;
+    getBearing(): number;
+    panBy(delta: PointLike, options?: EaseToOptions, eventData?: any): void;
+    panTo(center: [number, number], options?: EaseToOptions, eventData?: any): void;
+}
+type ImageViewerFlyToOptions = Omit<FlyToOptions, "bearing" | "pitch"> & {
+    center: [number, number];
+};
+type ImageViewerJumpToOptions = Omit<JumpToOptions, "bearing" | "pitch"> & {
+    center: [number, number];
+};
+export {};

package/dist/src/ImageViewer/events.d.ts

@@ -0,0 +1,22 @@
+import { Map } from '../Map';
+import { default as ImageViewer } from './ImageViewer';
+import { LngLat } from 'maplibre-gl';
+export declare class ImageViewerEvent {
+    readonly type: string;
+    readonly target: ImageViewer;
+    readonly originalEvent: MouseEvent | TouchEvent | WheelEvent | WebGLContextEvent | null;
+    readonly data?: Record<string, any>;
+    constructor(type: string, viewer: ImageViewer, originalEvent?: MouseEvent | TouchEvent | WheelEvent | WebGLContextEvent | null, data?: Record<string, any>);
+}
+export declare const ALL_MAP_EVENT_TYPES: string[];
+type LngLatToPixel = (lngLat: LngLat) => [number, number];
+interface SetupGlobalMapEventForwarderOptions {
+    map: Map;
+    viewer: ImageViewer;
+    lngLatToPx: LngLatToPixel;
+}
+/**
+ * Sets up event forwarding from Map to ImageViewer with proper categorization
+ */
+export declare function setupGlobalMapEventForwarder({ map, viewer, lngLatToPx }: SetupGlobalMapEventForwarderOptions): void;
+export {};

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

@@ -0,0 +1 @@
+export { default as ImageViewer } from './ImageViewer';

package/dist/src/ImageViewer/utils.d.ts

@@ -0,0 +1,5 @@
+export declare class FetchError extends Error {
+    status: number;
+    statusText: string;
+    constructor(response: Response, resource: string);
+}

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

@@ -0,0 +1,5 @@
+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,7 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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?: Record<string, unknown>);
+}

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

@@ -0,0 +1,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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,5 @@
+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;
+}