azure-maps-control 3.2.0 → 3.3.0

package/typings/index.d.ts

@@ -1,5 +1,5 @@
-import { PublicClientApplication } from "@azure/msal-browser";
-import { DataDrivenPropertyValueSpecification, PropertyValueSpecification, ExpressionFilterSpecification } from "@maplibre/maplibre-gl-style-spec";
+import {PublicClientApplication} from "@azure/msal-browser";
+import {DataDrivenPropertyValueSpecification, PropertyValueSpecification, ExpressionFilterSpecification} from "@maplibre/maplibre-gl-style-spec";
 
 type PositionAnchor = "center" | "top" | "bottom" | "left" | "right" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
 type Position = atlas.data.Position;
@@ -20,12 +20,12 @@ declare namespace atlas {
              * @param latitude The position's latitude.
              * @param elevation The position's elevation.
              */
-            constructor(longitude: number, latitude: number, elevation?: number);
+            constructor (longitude: number, latitude: number, elevation?: number);
             /**
              * Clones a position.
              * @param position The position to clone.
              */
-            static fromPosition(position: Position): Position;
+            static fromPosition (position: Position): Position;
             /**
              * Compares the longitude and latitude values of two positions to see if they are equal at an accuracy of 6 decimal places.
              * @param pos1 First position to compare.
@@ -33,7 +33,7 @@ declare namespace atlas {
              * @param precision The number of decimal places to compare to. Default: 6.
              * @returns A boolean indicating if two positions to see if they are equal at an accuracy of the specified precision or 6 decimal places.
              */
-            static areEqual(pos1: Position, pos2: Position, precision?: number): boolean;
+            static areEqual (pos1: Position, pos2: Position, precision?: number): boolean;
             /**
              * Generates a Position object from an object that contains coordinate information.
              * The object is scanned for the following properties using a case insensitive test.
@@ -43,7 +43,7 @@ declare namespace atlas {
              * @param latLng The object to extract coordinate information from.
              * @returns A Position object that represents the provided LatLng information.
              */
-            static fromLatLng(latLng: object): Position;
+            static fromLatLng (latLng: object): Position;
             /**
              * Generates a Position object from latitude and longitude values.
              * @param lat The latitude value.
@@ -51,13 +51,13 @@ declare namespace atlas {
              * @param elv An elevation value in meters.
              * @returns A Position object that represents the provided LatLng information.
              */
-            static fromLatLng(lat: number, lng: number, elv?: number): Position;
+            static fromLatLng (lat: number, lng: number, elv?: number): Position;
             /**
              * Generates a Position object from an array that has the format; [lat, lng] or [lat, lng, elv]
              * @param latLng An array that contains latitude/longitude information in the format; [lat, lng] or [lat, lng, elv]
              * @returns A Position object that represents the provided LatLng information.
              */
-            static fromLatLng(latLng: number[]): Position;
+            static fromLatLng (latLng: number[]): Position;
             /**
              * Converts an array of objects that contain coordinate information into an array of Positions. Objects that can't be converted are discarded.
              * Each object is either an array in the format; [lat, lng] or [lat, lng, elv], or an object with the any combination of the following properties:
@@ -67,7 +67,7 @@ declare namespace atlas {
              * @param latLngs The objects that contain coordinate information.
              * @returns An array of Position objects that contain all the provided coordinate information.
              */
-            static fromLatLngs(latLngs: Array<object | number[]>): Position[];
+            static fromLatLngs (latLngs: Array<object | number[]>): Position[];
         }
 
         /**
@@ -81,25 +81,25 @@ declare namespace atlas {
              * Constructs a BoundingBox
              * @param positions Can be either [west, south, east, north] or [west, south, elevation1, east, north, elevation2]
              */
-            constructor(positions: number[]);
+            constructor (positions: number[]);
             /**
              * Constructs a BoundingBox.
              * @param southwestPosition The southwestern most position of the bounding box.
              * @param northeastPosition The northeastern most position of the bounding box.
              */
-            constructor(southwestPosition: Position, northeastPosition: Position);
+            constructor (southwestPosition: Position, northeastPosition: Position);
             /**
              * Clones a bounding box.
              * @param boundingBox The bounding box to clone.
              */
-            static fromBoundingBox(boundingBox: BoundingBox): BoundingBox;
+            static fromBoundingBox (boundingBox: BoundingBox): BoundingBox;
             /**
              * Constructs a BoundingBox from the specified dimensions.
              * @param center The center position of the bounding box.
              * @param width The width of the bounding box.
              * @param height The height of the bounding box.
              */
-            static fromDimensions(center: Position, width: number, height: number): BoundingBox;
+            static fromDimensions (center: Position, width: number, height: number): BoundingBox;
             /**
              * Constructs a BoundingBox from the specified edges.
              * @param west The west edge of the bounding box.
@@ -107,106 +107,106 @@ declare namespace atlas {
              * @param east The east edge of the bounding box.
              * @param north The north edge of the bounding box.
              */
-            static fromEdges(west: number, south: number, east: number, north: number): BoundingBox;
+            static fromEdges (west: number, south: number, east: number, north: number): BoundingBox;
             /**
              * Determines if a position is within a bounding box.
              * @param bounds The bounding box to see if the position is in.
              * @param position The position to see if it is in the bounding box.
              * @returns True if the position is within the bounding box.
              */
-            static containsPosition(bounds: BoundingBox, position: Position): boolean;
+            static containsPosition (bounds: BoundingBox, position: Position): boolean;
             /**
              * Returns a boolean indicating if the bounding box crosses the antimeridian or not.
              * @param bounds The bounding box to check.
              * @returns A boolean indicating if the bounding box crosses the antimeridian or not.
              */
-            static crossesAntimeridian(bounds: BoundingBox): boolean;
+            static crossesAntimeridian (bounds: BoundingBox): boolean;
             /**
              * Calculates the center of a bounding box.
              * @param bounds A bounding box to calculate the center of.
              * @returns A position that represents the center of the bounding box.
              */
-            static getCenter(bounds: BoundingBox): Position;
+            static getCenter (bounds: BoundingBox): Position;
             /**
              * Gets the height of a bounding box in degrees.
              * @param bounds The bounding box to check.
              * @returns The height of the bounding box in degrees.
              */
-            static getHeight(bounds: BoundingBox): number;
+            static getHeight (bounds: BoundingBox): number;
             /**
              * Gets the width of a bounding box in degrees.
              * @param bounds The bounding box to check.
              * @returns The width of the bounding box in degrees.
              */
-            static getWidth(bounds: BoundingBox): number;
+            static getWidth (bounds: BoundingBox): number;
             /**
              * Returns the south west position of the bounding box.
              * @param bounds The bounding box to get the position from.
              * @returns The south west position of the bounding box.
              */
-            static getSouthWest(bounds: BoundingBox): Position;
+            static getSouthWest (bounds: BoundingBox): Position;
             /**
              * Returns the north east position of the bounding box.
              * @param bounds The bounding box to get the position from.
              * @returns The north east position of the bounding box.
              */
-            static getNorthEast(bounds: BoundingBox): Position;
+            static getNorthEast (bounds: BoundingBox): Position;
             /**
              * Returns the north west position of the bounding box.
              * @param bounds The bounding box to get the position from.
              * @returns The north west position of the bounding box.
              */
-            static getNorthWest(bounds: BoundingBox): Position;
+            static getNorthWest (bounds: BoundingBox): Position;
             /**
              * Returns the south east position of the bounding box.
              * @param bounds The bounding box to get the position from.
              * @returns The south east position of the bounding box.
              */
-            static getSouthEast(bounds: BoundingBox): Position;
+            static getSouthEast (bounds: BoundingBox): Position;
             /**
              * Returns the south position value of the bounding box.
              * @param bounds The bounding box to get the position from.
              * @returns The south position value of the bounding box.
              */
-            static getSouth(bounds: BoundingBox): number;
+            static getSouth (bounds: BoundingBox): number;
             /**
              * Returns the west position value of the bounding box.
              * @param bounds The bounding box to get the position from.
              * @returns The west position value of the bounding box.
              */
-            static getWest(bounds: BoundingBox): number;
+            static getWest (bounds: BoundingBox): number;
             /**
              * Returns the north position value of the bounding box.
              * @param bounds The bounding box to get the position from.
              * @returns The north position value of the bounding box.
              */
-            static getNorth(bounds: BoundingBox): number;
+            static getNorth (bounds: BoundingBox): number;
             /**
              * Returns the east position value of the bounding box.
              * @param bounds The bounding box to get the position from.
              * @returns The east position value of the bounding box.
              */
-            static getEast(bounds: BoundingBox): number;
+            static getEast (bounds: BoundingBox): number;
             /**
              * Determines is two bounding boxes intersect.
              * @param bounds1 The first bounding box to compare with.
              * @param bounds2 The second bounding box to compare with.
              * @returns true if the provided bounding boxes intersect.
              */
-            static intersect(bounds1: BoundingBox, bounds2: BoundingBox): boolean;
+            static intersect (bounds1: BoundingBox, bounds2: BoundingBox): boolean;
             /**
              * Merges two bounding boxes together.
              * @param bounds1 The first bounding box to merge with.
              * @param bounds2 The second bounding box to merge with.
              * @returns A bounding box in the format [minLon, minLat, maxLon, maxLat].
              */
-            static merge(bounds1: BoundingBox, bounds2: BoundingBox): BoundingBox;
+            static merge (bounds1: BoundingBox, bounds2: BoundingBox): BoundingBox;
             /**
              * Creates a BoundingBox that contains all provided Position objects.
              * @param positions An array of locations to use to generate the bounding box.
              * @returns A bounding box that contains all given positions.
              */
-            static fromPositions(positions: Position[]): BoundingBox;
+            static fromPositions (positions: Position[]): BoundingBox;
             /**
              * Creates a BoundingBox from any array of objects that contain coordinate information.
              * Each object is either an array in the format; [lat, lng] or [lat, lng, elv], or an object with the any combination of the following properties:
@@ -216,18 +216,18 @@ declare namespace atlas {
              * @param latLngs The objects that contain coordinate information.
              * @returns A BoundingBox that contains all the provided coordinate information.
              */
-            static fromLatLngs(latLngs: Array<object | number[]>): BoundingBox;
+            static fromLatLngs (latLngs: Array<object | number[]>): BoundingBox;
             /**
              * Calculates the bounding box of a FeatureCollection, Feature, Geometry, Shape or array of these objects.
              * @param data The FeatureCollection, Feature, Geometry, Shape or array of these objects to calculate the bounding box for.
              * @returns A bounding box in the format [minLon, minLat, maxLon, maxLat].
              */
-            static fromData(data: FeatureCollection | Feature<Geometry, any> | Geometry | Shape | Array<FeatureCollection | Feature<Geometry, any> | Geometry | Shape>): BoundingBox;
+            static fromData (data: FeatureCollection | Feature<Geometry, any> | Geometry | Shape | Array<FeatureCollection | Feature<Geometry, any> | Geometry | Shape>): BoundingBox;
             /**
              * Splits a BoundingBox that crosses the Antimeridian into two BoundingBox's. One entirely west of the Antimerdian and another entirely east of the Antimerdian.
              * @param bounds
              */
-            static splitOnAntimeridian(bounds: BoundingBox): BoundingBox[];
+            static splitOnAntimeridian (bounds: BoundingBox): BoundingBox[];
         }
 
         /**
@@ -261,7 +261,7 @@ declare namespace atlas {
              * @param features The collection of features that make up the feature collection.
              * @param bbox The bounding box of the feature collection.
              */
-            constructor(features: Array<Feature<Geometry, any>>, bbox?: BoundingBox);
+            constructor (features: Array<Feature<Geometry, any>>, bbox?: BoundingBox);
         }
 
         /**
@@ -300,7 +300,7 @@ declare namespace atlas {
              * @param id The id of the feature.
              * @param bbox The bounding box of the feature.
              */
-            constructor(geometry: G, properties?: P, id?: string | number, bbox?: BoundingBox);
+            constructor (geometry: G, properties?: P, id?: string | number, bbox?: BoundingBox);
         }
 
         /**
@@ -324,7 +324,7 @@ declare namespace atlas {
              * Constructs a Point.
              * @param coordinates The position defining the point.
              */
-            constructor(coordinates: Position);
+            constructor (coordinates: Position);
 
         }
 
@@ -355,7 +355,7 @@ declare namespace atlas {
              * @param coordinates The ordered list of positions defining the linestring.
              * @param bbox The bounding box of the linestring.
              */
-            constructor(coordinates: Position[], bbox?: BoundingBox);
+            constructor (coordinates: Position[], bbox?: BoundingBox);
         }
 
         /**
@@ -385,7 +385,7 @@ declare namespace atlas {
              * @param coordinates The array of linear ring coordinate arrays defining the polygon.
              * @param bbox The bounding box of the polygon.
              */
-            constructor(coordinates: Position[][] | Position[], bbox?: BoundingBox);
+            constructor (coordinates: Position[][] | Position[], bbox?: BoundingBox);
         }
 
         /**
@@ -419,7 +419,7 @@ declare namespace atlas {
              * @param coordinates The array of multiple positions defining the multipoint.
              * @param bbox The bounding box of the multipoint.
              */
-            constructor(coordinates: Position[], bbox?: BoundingBox)
+            constructor (coordinates: Position[], bbox?: BoundingBox);
         }
 
         /**
@@ -453,7 +453,7 @@ declare namespace atlas {
              * @param coordinates The array of LineString coordinate arrays defining the multilinestring.
              * @param bbox The bounding box of the multilinestring.
              */
-            constructor(coordinates: Position[][], bbox?: BoundingBox)
+            constructor (coordinates: Position[][], bbox?: BoundingBox);
         }
 
         /**
@@ -487,7 +487,7 @@ declare namespace atlas {
              * @param coordinates The array of polygon coordinate arrays defining the multipolygon.
              * @param bbox The bounding box of the multipolygon.
              */
-            constructor(coordinates: Position[][][], bbox?: BoundingBox)
+            constructor (coordinates: Position[][][], bbox?: BoundingBox);
         }
 
         /**
@@ -515,7 +515,7 @@ declare namespace atlas {
              * Constructs a GeometryCollection.
              * @param geometries The collection of geometries that make up the geometry collection.
              */
-            constructor(geometries: Geometry[]);
+            constructor (geometries: Geometry[]);
         }
 
         /**
@@ -539,37 +539,37 @@ declare namespace atlas {
              * @param y A points y position in mercator units.
              * @param z A points z position in mercator units.
              */
-            constructor(x: number, y: number, z?: number);
+            constructor (x: number, y: number, z?: number);
             /**
              * Converts a position into a mercator point.
              * @param position Position to convert.
              * @returns A mercator point.
              */
-            static fromPosition(position: Position): MercatorPoint;
+            static fromPosition (position: Position): MercatorPoint;
             /**
              * Converts an array of positions into an array of mercator points.
              * @param positions Array of positions to convert.
              * @returns An array of  mercator points.
              */
-            static fromPositions(positions: Position[]): MercatorPoint[];
+            static fromPositions (positions: Position[]): MercatorPoint[];
             /**
              * Converts an array of positions into a Float32Array of mercator xyz values.
              * @param positions Array of positions to convert.
              * @returns A Float32Array of mercator xyz values.
              */
-            static toFloat32Array(positions: Position[]): Float32Array;
+            static toFloat32Array (positions: Position[]): Float32Array;
             /**
              * Converts a mercator point into a map position.
              * @param mercator Mercator point to convert.
              * @returns A map position.
              */
-            static toPosition(mercator: MercatorPoint): Position;
+            static toPosition (mercator: MercatorPoint): Position;
             /**
              * Converts an array of mercator points into an array of map positions.
              * @param mercators Mercator points to convert.
              * @returns An array of map positions.
              */
-            static toPositions(mercators: MercatorPoint[]): Position[];
+            static toPositions (mercators: MercatorPoint[]): Position[];
             /**
              * Determine the Mercator scale factor for a given latitude, see
              * https://en.wikipedia.org/wiki/Mercator_projection#Scale_factor
@@ -579,7 +579,7 @@ declare namespace atlas {
              * @param latitude Latitude
              * @returns The mercator scale factor.
              */
-            static mercatorScale(latitude: number): number;
+            static mercatorScale (latitude: number): number;
             /**
              * Returns the distance of 1 meter in `MercatorPoint` units at this latitude.
              *
@@ -588,7 +588,7 @@ declare namespace atlas {
              *
              * @returns {number} Distance of 1 meter in `MercatorPoint` units.
              */
-            static meterInMercatorUnits(latitude: number): number;
+            static meterInMercatorUnits (latitude: number): number;
         }
     }
 
@@ -611,12 +611,12 @@ declare namespace atlas {
              * @param options The ControlOptions for this control.
              * @return An HTMLElement to be placed on the map for the control.
              */
-            abstract onAdd(map: Map, options?: ControlOptions): HTMLElement;
+            abstract onAdd (map: Map, options?: ControlOptions): HTMLElement;
             /**
              * Method that is called when the control is removed from the map. Should perform any necessary cleanup for the
              * control.
              */
-            onRemove(): void;
+            onRemove (): void;
             /**
              * Build the outermost container for the control, applies styling including any listeners for auto styling.
              */
@@ -639,14 +639,14 @@ declare namespace atlas {
              * Constructs a CompassControl.
              * @param options The options for the control.
              */
-            constructor(options?: CompassControlOptions);
+            constructor (options?: CompassControlOptions);
             /**
              * Initialization method for the control which is called when added to the map.
              * @param map The map that the control will be added to.
              * @param options The ControlOptions for this control.
              * @return An HTMLElement to be placed on the map for the control.
              */
-            onAdd(map: Map, options?: ControlOptions): HTMLElement;
+            onAdd (map: Map, options?: ControlOptions): HTMLElement;
 
             protected constructRotationGrid: (map: Map, options?: ControlOptions) => HTMLElement;
             protected constructRotationButton: (map: Map) => HTMLElement;
@@ -678,15 +678,15 @@ declare namespace atlas {
              * Constructs a PitchControl.
              * @param options The options for the control.
              */
-            constructor(options?: PitchControlOptions);
+            constructor (options?: PitchControlOptions);
             /**
              * Initialization method for the control which is called when added to the map.
              * @param map The map that the control will be added to.
              * @param options The ControlOptions for this control.
              * @return An HTMLElement to be placed on the map for the control.
              */
-            onAdd(map: Map, options?: ControlOptions): HTMLElement;
-            onRemove(): void;
+            onAdd (map: Map, options?: ControlOptions): HTMLElement;
+            onRemove (): void;
 
             protected pitchChanged: (map: MapEvent) => void;
 
@@ -710,25 +710,25 @@ declare namespace atlas {
             * Constructs a ScaleControl.
             * @param options The options for the control.
             */
-            constructor(options?: ScaleControlOptions);
+            constructor (options?: ScaleControlOptions);
             /**
              * Initialization method for the control which is called when added to the map.
              * @param map The map that the control will be added to.
              * @param options The ControlOptions for this control.
              * @return An HTMLElement to be placed on the map for the control.
              */
-            onAdd(map: Map, options?: ControlOptions): HTMLElement;
+            onAdd (map: Map, options?: ControlOptions): HTMLElement;
             /**
              * Method that is called when the control is removed from the map. Should perform any necessary cleanup for the
              * control.
              */
-            onRemove(): void;
+            onRemove (): void;
 
             /**
              * Set the scale's unit of the distance
              * @param unit - Unit of the distance (`'imperial'`, `'metric'` or `'nautical'`).
              */
-            setUnit(unit: "imperial" | "metric" | "nautical"): void;
+            setUnit (unit: "imperial" | "metric" | "nautical"): void;
         }
 
         /**
@@ -745,35 +745,35 @@ declare namespace atlas {
              * Constructs a StyleControl.
              * @param options The options for the control.
              */
-            constructor(options?: StyleControlOptions);
+            constructor (options?: StyleControlOptions);
             /**
              * Initialization method for the control which is called when added to the map.
              * @param map The map that the control will be added to.
              * @param options The ControlOptions for this control.
              * @return An HTMLElement to be placed on the map for the control.
              */
-            onAdd(map: Map, options?: ControlOptions): HTMLElement;
+            onAdd (map: Map, options?: ControlOptions): HTMLElement;
             /**
              * Method that is called when the control is removed from the map. Should perform any necessary cleanup for the
              * control.
              */
-            onRemove(): void;
+            onRemove (): void;
             /**
              * Set the style that need to be displayed as currently selected.
              * Style will automatically get selected if `StyleControlOptions.autoSelectionMode` is `true`
              * @param styleName - Style name that need to be disabled as currently selected
              */
-            setSelectedStyle(styleName: string): void;
+            setSelectedStyle (styleName: string): void;
             /**
              * Set style in a disabled state
              * @param styleName Style to be disabled
              */
-            disableStyle(styleName: string): void;
+            disableStyle (styleName: string): void;
             /**
              * Enabled style that was previously disabled
              * @param styleName Style to be disabled
              */
-            enableStyle(styleName: string): void;
+            enableStyle (styleName: string): void;
             private buildSelectStyleBtn;
             private buildCurrStyleBtn;
             private buildStyleOpsGrid;
@@ -797,20 +797,20 @@ declare namespace atlas {
              * Constructs a ZoomControl.
              * @param options The options for the control.
              */
-            constructor(options?: ZoomControlOptions);
+            constructor (options?: ZoomControlOptions);
             /**
              * Initialization method for the control which is called when added to the map.
              * @param map The map that the control will be added to.
              * @return An HTMLElement to be placed on the map for the control.
              */
-            onAdd(map: Map): HTMLElement;
+            onAdd (map: Map): HTMLElement;
             onRemove (): void;
 
             protected zoomChanged: (event: MapEvent) => void;
             protected minZoomChanged: (zoom: number) => void;
             protected maxZoomChanged: (zoom: number) => void;
 
-            protected updateZoomButtonsState(): void;
+            protected updateZoomButtonsState (): void;
             protected constructZoomInButton: (map: Map) => HTMLElement;
             protected constructZoomOutButton: (map: Map) => HTMLElement;
         }
@@ -832,17 +832,17 @@ declare namespace atlas {
             * Constructs a TrafficControl
             * @param options The options for the control.
             */
-            constructor(options?: TrafficControlOptions);
+            constructor (options?: TrafficControlOptions);
 
             /**
              * Current control state (is traffic information displayed?)
              */
-            get isActive(): boolean;
+            get isActive (): boolean;
 
             /**
              * Sets the control state
              */
-            set isActive(newValue: boolean);
+            set isActive (newValue: boolean);
 
             /**
              * Initialization method for the control which is called when added to the map.
@@ -850,23 +850,23 @@ declare namespace atlas {
              * @param options The ControlOptions for this control.
              * @return An HTMLElement to be placed on the map for the control.
              */
-            onAdd(map: Map): HTMLElement;
+            onAdd (map: Map): HTMLElement;
 
             /**
              * Method that is called when the control is removed from the map. Should perform any necessary cleanup for the
              * control.
              */
-            onRemove(): void;
+            onRemove (): void;
 
             /**
              * Updates the button state according to current traffic state
              */
-            updateButtonState(): void;
+            updateButtonState (): void;
 
             /**
              * Get the TrafficControlOptions
              */
-            getOptions(): TrafficControlOptions
+            getOptions (): TrafficControlOptions;
             private constructTrafficButton;
         }
 
@@ -878,7 +878,7 @@ declare namespace atlas {
             /**
              * Construct a traffic legend control
              */
-            constructor();
+            constructor ();
 
             /**
              * Initialization method for the control which is called when added to the map.
@@ -886,7 +886,7 @@ declare namespace atlas {
              * @param options The ControlOptions for this control.
              * @return An HTMLElement to be placed on the map for the control.
              */
-            onAdd(map: Map): HTMLElement
+            onAdd (map: Map): HTMLElement;
             private buildTrafficLegendDiv;
         }
     }
@@ -910,14 +910,14 @@ declare namespace atlas {
              * @param callback The event handler callback.
              */
             _addEventListener<K extends keyof T>(eventType: K, callback: (e: T[K]) => void, once: boolean): void;
-            _addEventListener(eventType: string, callback: (e: T[string]) => void, once: boolean): void;
+            _addEventListener (eventType: string, callback: (e: T[string]) => void, once: boolean): void;
             /**
              * Removes an event listener.
              * @param eventType The event name.
              * @param callback The event handler callback.
              */
             _removeEventListener<K extends keyof T>(eventType: K, callback: (e: T[K]) => void): void;
-            _removeEventListener(eventType: string, callback: (e: T[string]) => void): void;
+            _removeEventListener (eventType: string, callback: (e: T[string]) => void): void;
             /**
              * Invokes a given event type.
              * @param eventType The event name.
@@ -941,23 +941,23 @@ declare namespace atlas {
              * @param id The id of the layer. If not specified a random one will be generated.
              * @param options The options of the bubble layer.
              */
-            constructor(source: string | atlas.source.Source, id?: string, options?: BubbleLayerOptions);
+            constructor (source: string | atlas.source.Source, id?: string, options?: BubbleLayerOptions);
 
             /**
              * Gets the options of the bubble layer.
              */
-            getOptions(): BubbleLayerOptions;
+            getOptions (): BubbleLayerOptions;
 
             /**
              * Gets the source provided when creating the layer.
              */
-            getSource(): string | atlas.source.Source;
+            getSource (): string | atlas.source.Source;
 
             /**
              * Sets the options of the bubble layer.
              * @param newOptions The new options of the bubble layer.
              */
-            setOptions(options: BubbleLayerOptions): void;
+            setOptions (options: BubbleLayerOptions): void;
         }
 
         export interface LayerEvents {
@@ -976,25 +976,34 @@ declare namespace atlas {
              * A property for associating custom data with the layer.
              */
             metadata?: any;
-            constructor(id?: string);
+            constructor (id?: string);
             /**
              * Gets the id of the layer
              */
-            getId(): string;
+            getId (): string;
             /**
              * Gets the map that the layer is currently added to, or null.
              */
-            getMap(): Map;
+            getMap (): Map;
             /**
              * Initialization method for the layer which is called when added to the map.
              * @param map The map the layer has been added to.
              */
-            onAdd(map: Map): void;
+            onAdd (map: Map): void;
             /**
              * Method that is called when the layer is removed from the map.
              * Should perform any necessary cleanup for the layer.
              */
-            onRemove(): void;
+            onRemove (): void;
+            /**
+             * Gets the options of the layer.
+             */
+            abstract getOptions (): LayerOptions;
+            /**
+             * Sets the options of the layer.
+             * @param options The new options of the layer.
+             */
+            abstract setOptions (options: LayerOptions): void;
         }
 
         /**
@@ -1008,23 +1017,23 @@ declare namespace atlas {
              * @param id The id of the layer. If not specified a random one will be generated.
              * @param options The options of the line layer.
              */
-            constructor(source: string | atlas.source.Source, id?: string, options?: HeatMapLayerOptions);
+            constructor (source: string | atlas.source.Source, id?: string, options?: HeatMapLayerOptions);
 
             /**
              * Gets the options of the heat map layer.
              */
-            getOptions(): HeatMapLayerOptions;
+            getOptions (): HeatMapLayerOptions;
 
             /**
              * Gets the source provided when creating the layer.
              */
-            getSource(): string | atlas.source.Source;
+            getSource (): string | atlas.source.Source;
 
             /**
              * Sets the options of the heat map layer.
              * @param newOptions The new options of the heat map layer.
              */
-            setOptions(options: HeatMapLayerOptions): void;
+            setOptions (options: HeatMapLayerOptions): void;
 
         }
 
@@ -1037,26 +1046,26 @@ declare namespace atlas {
              * @param options The options for the tile layer.
              * @param id The id of the layer. If not specified a random one will be generated.
              */
-            constructor(options: ImageLayerOptions, id?: string);
+            constructor (options: ImageLayerOptions, id?: string);
             /**
              * Gets the options of the tile layer.
              */
-            getOptions(): ImageLayerOptions;
+            getOptions (): ImageLayerOptions;
             /**
              * Sets the options of the tile layer.
              * @param newOptions The new options of the tile layer.
              */
-            setOptions(options: ImageLayerOptions): void;
+            setOptions (options: ImageLayerOptions): void;
             /**
              * Calculates the approximate positions that align with the provided pixels from the source image.
              * @param pixels the provided pixels from the source image used to calculate the positions
              */
-            getPositions(pixels: Pixel[]): Promise<atlas.data.Position[]>;
+            getPositions (pixels: Pixel[]): Promise<atlas.data.Position[]>;
             /**
              * Calculates the approximate pixels on the source image that align with the provided positions.
              * @param positions the provided positions from the source image used to calculate the pixels
              */
-            getPixels(positions: atlas.data.Position[]): Promise<Pixel[]>;
+            getPixels (positions: atlas.data.Position[]): Promise<Pixel[]>;
             /**
              * Calculates coordinates for a rotated image layer when provided with the bounding box edges and rotation value.
              * Note: If your rotation value is from a KML Ground Overlay it will need to be converted to a clockwise rotation using the following formula: `rotation = 360 – KmlRotation`
@@ -1066,7 +1075,7 @@ declare namespace atlas {
              * @param west The west edge of the bounding box.
              * @param rotation Clockwise rotation in degrees
             */
-            static getCoordinatesFromEdges(north: number, south: number, east: number, west: number, rotation?: number): atlas.data.Position[];
+            static getCoordinatesFromEdges (north: number, south: number, east: number, west: number, rotation?: number): atlas.data.Position[];
             /**
             * Calculates coordinates for a rotated image layer when provided with the bounding box edges and rotation value.
             * Note: If your rotation value is from a KML Ground Overlay it will need to be converted to a clockwise rotation using the following formula: `rotation = 360 – KmlRotation`
@@ -1076,7 +1085,7 @@ declare namespace atlas {
             * @param west The west edge of the bounding box.
             * @param rotation Clockwise rotation in degrees
             */
-            static getCoordinatesFromEdges(north: number, south: number, east: number, west: number, rotation?: number): atlas.data.Position[];
+            static getCoordinatesFromEdges (north: number, south: number, east: number, west: number, rotation?: number): atlas.data.Position[];
         }
 
         /**
@@ -1091,20 +1100,20 @@ declare namespace atlas {
              * @param id The id of the layer. If not specified a random one will be generated.
              * @param options The options of the line layer.
              */
-            constructor(source: string | atlas.source.Source, id?: string, options?: LineLayerOptions);
+            constructor (source: string | atlas.source.Source, id?: string, options?: LineLayerOptions);
             /**
              * Gets the options of the line layer.
              */
-            getOptions(): LineLayerOptions;
+            getOptions (): LineLayerOptions;
             /**
              * Gets the source provided when creating the layer.
              */
-            getSource(): string | atlas.source.Source;
+            getSource (): string | atlas.source.Source;
             /**
              * Sets the options of the line layer.
              * @param options The new options of the line layer.
              */
-            setOptions(options: LineLayerOptions): void;
+            setOptions (options: LineLayerOptions): void;
         }
 
         /**
@@ -1118,20 +1127,20 @@ declare namespace atlas {
              * @param id The id of the layer. If not specified a random one will be generated.
              * @param options The options of the polygon extrusion layer.
              */
-            constructor(source: string | atlas.source.Source, id?: string, options?: PolygonExtrusionLayerOptions);
+            constructor (source: string | atlas.source.Source, id?: string, options?: PolygonExtrusionLayerOptions);
             /**
              * Gets the options of the polygon layer.
              */
-            getOptions(): PolygonExtrusionLayerOptions;
+            getOptions (): PolygonExtrusionLayerOptions;
             /**
              * Gets the source provided when creating the layer.
              */
-            getSource(): string | atlas.source.Source;
+            getSource (): string | atlas.source.Source;
             /**
              * Sets the options of the polygon layer.
              * @param newOptions The new options of the polygon layer.
              */
-            setOptions(options: PolygonExtrusionLayerOptions): void;
+            setOptions (options: PolygonExtrusionLayerOptions): void;
         }
 
         /**
@@ -1145,17 +1154,17 @@ declare namespace atlas {
              * @param id The id of the layer. If not specified a random one will be generated.
              * @param options The options of the polygon layer.
              */
-            constructor(source: string | atlas.source.Source, id?: string, options?: PolygonLayerOptions);
+            constructor (source: string | atlas.source.Source, id?: string, options?: PolygonLayerOptions);
 
             /**
              * Gets the options of the polygon layer.
              */
-            getOptions(): PolygonLayerOptions;
+            getOptions (): PolygonLayerOptions;
 
             /**
              * Gets the source provided when creating the layer.
              */
-            getSource(): string | atlas.source.Source;
+            getSource (): string | atlas.source.Source;
 
             /**
              * Sets the options of the polygon layer.
@@ -1163,7 +1172,7 @@ declare namespace atlas {
              * To set `fillColor`, make sure `fillPattern` is set to `undefined`.
              * @param newOptions The new options of the polygon layer.
              */
-            setOptions(options: PolygonLayerOptions): void;
+            setOptions (options: PolygonLayerOptions): void;
 
         }
 
@@ -1178,20 +1187,20 @@ declare namespace atlas {
              * @param id The id of the layer. If not specified a random one will be generated.
              * @param options The options of the polygon layer.
              */
-            constructor(source: string | atlas.source.Source, id?: string, options?: SymbolLayerOptions);
+            constructor (source: string | atlas.source.Source, id?: string, options?: SymbolLayerOptions);
             /**
              * Gets the options of the symbol layer.
              */
-            getOptions(): SymbolLayerOptions;
+            getOptions (): SymbolLayerOptions;
             /**
              * Gets the source provided when creating the layer.
              */
-            getSource(): string | atlas.source.Source;
+            getSource (): string | atlas.source.Source;
             /**
              * Sets the options of the symbol layer.
              * @param newOptions The new options of the polygon layer.
              */
-            setOptions(options: SymbolLayerOptions): void;
+            setOptions (options: SymbolLayerOptions): void;
         }
 
         /**
@@ -1203,16 +1212,16 @@ declare namespace atlas {
              * @param options The options for the tile layer.
              * @param id The id of the layer. If not specified a random one will be generated.
              */
-            constructor(options?: TileLayerOptions, id?: string);
+            constructor (options?: TileLayerOptions, id?: string);
             /**
              * Gets the options of the tile layer.
              */
-            getOptions(): TileLayerOptions;
+            getOptions (): TileLayerOptions;
             /**
              * Sets the options of the tile layer.
              * @param newOptions The new options of the tile layer.
              */
-            setOptions(options: TileLayerOptions): void;
+            setOptions (options: TileLayerOptions): void;
         }
 
         /**
@@ -1224,16 +1233,16 @@ declare namespace atlas {
              * @param id The id of the layer. If not specified a random one will be generated.
              * @param options The options of the WebGL layer.
             */
-            constructor(id?: string, options?: WebGLLayerOptions);
+            constructor (id?: string, options?: WebGLLayerOptions);
             /**
              * Gets the options of the WebGL layer.
              */
-            getOptions(): WebGLLayerOptions;
+            getOptions (): WebGLLayerOptions;
             /**
              * Sets the options of the WebGL layer.
              * @param options The new options of the WebGL layer.
              */
-            setOptions(options: WebGLLayerOptions): void;
+            setOptions (options: WebGLLayerOptions): void;
         }
     }
 
@@ -1262,7 +1271,7 @@ declare namespace atlas {
              * @param id a unique id that the user assigns to the data source. If this is not specified, then the data source will automatically be assigned an id.
              * @param options the options for the data source.
              */
-            constructor(id?: string, options?: DataSourceOptions);
+            constructor (id?: string, options?: DataSourceOptions);
             /**
              * Adds shapes to the data source.
              * GeoJSON objects will be wrapped within a Shape class to make them easier to manage.
@@ -1270,80 +1279,80 @@ declare namespace atlas {
              * @param data
              * @param index
              */
-            add(data: atlas.data.FeatureCollection | atlas.data.Feature<atlas.data.Geometry, any> | atlas.data.Geometry | atlas.data.GeometryCollection | Shape | Array<atlas.data.Feature<atlas.data.Geometry, any> | atlas.data.Geometry | Shape>, index?: number): void;
+            add (data: atlas.data.FeatureCollection | atlas.data.Feature<atlas.data.Geometry, any> | atlas.data.Geometry | atlas.data.GeometryCollection | Shape | Array<atlas.data.Feature<atlas.data.Geometry, any> | atlas.data.Geometry | Shape>, index?: number): void;
             /**
              * Removes all data in the data source.
              */
-            clear(): void;
+            clear (): void;
             /**
              * Cleans up any resources this object is consuming.
              */
-            dispose(): void;
+            dispose (): void;
             /**
              * Calculates a zoom level at which the cluster will start expanding or break apart.
              * @param clusterId
              */
-            getClusterExpansionZoom(clusterId: number): Promise<number>;
+            getClusterExpansionZoom (clusterId: number): Promise<number>;
             /**
              * Retrieves the children of the given cluster on the next zoom level. This may be a combination of shapes and sub-clusters.
              * The sub-clusters will be features with properties matching ClusteredProperties.
              * @param clusterId
              */
-            getClusterChildren(clusterId: number): Promise<Array<atlas.data.Feature<atlas.data.Geometry, ClusteredProperties | any> | Shape>>;
+            getClusterChildren (clusterId: number): Promise<Array<atlas.data.Feature<atlas.data.Geometry, ClusteredProperties | any> | Shape>>;
             /**
              * Retrieves shapes that are within the cluster.
              * @param clusterId
              * @param limit The maximum number of features to return. Set to Infinity to return all shapes.
              * @param offset The number of shapes to skip. Allows you to page through the shapes in the cluster.
              */
-            getClusterLeaves(clusterId: number, limit: number, offset: number): Promise<Array<atlas.data.Feature<atlas.data.Geometry, any> | Shape>>;
+            getClusterLeaves (clusterId: number, limit: number, offset: number): Promise<Array<atlas.data.Feature<atlas.data.Geometry, any> | Shape>>;
             /**
              * Gets the options used by the data source.
              */
-            getOptions(): DataSourceOptions;
+            getOptions (): DataSourceOptions;
             /**
              * Returns all shapes that are in the DataSource.
              */
-            getShapes(): Shape[];
+            getShapes (): Shape[];
             /**
              * Downloads a GeoJSON document and imports its data into the data source.
              * The GeoJSON document must be on the same domain or accessible using CORS.
              * @param url
              */
-            importDataFromUrl(url: string): Promise<void>;
+            importDataFromUrl (url: string): Promise<void>;
             /**
              * Retrieves a shape with the specified id.
              * If no shape with the specified id is contained in the data source, null will be return.
              * @param id The id of the shape to return.
              */
-            getShapeById(id: string | number): Shape;
+            getShapeById (id: string | number): Shape;
             /**
              * Removes one or more shapes from the data source.
              * If a string is passed in, it is assumed to be an id.
              * If a number is passed in, removes the shape at that index.
              * @param shape The shape(s), shape id(s), or feature(s) to be removed
              */
-            remove(shape: number | string | Shape | atlas.data.Feature<atlas.data.Geometry, any> | Array<number | string | Shape | atlas.data.Feature<atlas.data.Geometry, any>>): void;
+            remove (shape: number | string | Shape | atlas.data.Feature<atlas.data.Geometry, any> | Array<number | string | Shape | atlas.data.Feature<atlas.data.Geometry, any>>): void;
             /**
              * Removes one or more shapes from the datasource based on its id.
              * @param shape shape id
              */
-            removeById(id: number | string | Array<number | string>): void;
+            removeById (id: number | string | Array<number | string>): void;
             /**
              * Sets the data source options.
              * The data source will retain its current values for any option not specified in the supplied options.
              * @param options the DataSourceOptions to be set
              */
-            setOptions(options: DataSourceOptions): void;
+            setOptions (options: DataSourceOptions): void;
             /**
              * Overwrites all shapes in the data source with the new array of shapes.
              * @param shape the new shapes to update
              */
-            setShapes(shape: atlas.data.FeatureCollection | Array<atlas.data.Feature<atlas.data.Geometry, any> | atlas.data.Geometry | Shape>): void;
+            setShapes (shape: atlas.data.FeatureCollection | Array<atlas.data.Feature<atlas.data.Geometry, any> | atlas.data.Geometry | Shape>): void;
             /**
              * Returns a GeoJSON FeatureCollection which contains all the shape data that is in the data source.
              */
-            toJson(): atlas.data.FeatureCollection;
+            toJson (): atlas.data.FeatureCollection;
             private _addToSources;
             private _removeFromSources;
             private _updateShapesMap;
@@ -1362,11 +1371,11 @@ declare namespace atlas {
         export abstract class Source<T extends SourceEvents = SourceEvents> extends atlas.internal.EventEmitter<T> {
             private id;
             protected map: Map;
-            constructor(id?: string);
+            constructor (id?: string);
             /**
              * Gets the id of the data source
              */
-            getId(): string;
+            getId (): string;
         }
 
         /**
@@ -1374,17 +1383,17 @@ declare namespace atlas {
          * Vector tile sources can be used with; SymbolLayer, LineLayer, PolygonLayer, BubbleLayer, HeatmapLayer and VectorTileLayer.
          */
         export class VectorTileSource extends Source {
-            constructor(id?: string, options?: VectorTileSourceOptions);
+            constructor (id?: string, options?: VectorTileSourceOptions);
             /**
              * Gets the options of the VectorTileSource.
              */
-            getOptions(): VectorTileSourceOptions;
+            getOptions (): VectorTileSourceOptions;
             /**
              * Returns all GeoJSON features that are in the VectorTileSource and which satisfy the specified filter expression.
              * @param sourceLayer Required if the source is a VectorTileSource. Specifies the layer within the VectorTileSource to query.
              * @param filter A filter that will limit the query.
              */
-            getShape(sourceLayer: string, filter?: Expression): Array<atlas.data.Feature<atlas.data.Geometry, any>>;
+            getShape (sourceLayer: string, filter?: Expression): Array<atlas.data.Feature<atlas.data.Geometry, any>>;
         }
 
         /**
@@ -1414,21 +1423,21 @@ declare namespace atlas {
              * @param source A set of reference points from the source reference system to transform from.
              * @param target A set of reference points from the target reference system to transform to.
              */
-            constructor(source: number[][], target: number[][]);
+            constructor (source: number[][], target: number[][]);
             /**
              * Converts an array of points from the source reference system to the target reference system.
              * @param sourcePoints An array of points from the source reference system to transform.
              * @param decimals Number of decimal places to round the results off to.
              * @returns An array of points that have been transformed to the target reference system.
              */
-            toTarget(sourcePoints: number[][], decimals?: number): number[][];
+            toTarget (sourcePoints: number[][], decimals?: number): number[][];
             /**
              * Converts an array of points from the target reference system to the source reference system.
              * @param targetPoints An array of points from the target reference system to transform.
              * @param decimals Number of decimal places to round the results off to.
              * @returns An array of points that have been transformed to the source reference system.
              */
-            toSource(targetPoints: number[][], decimals?: number): number[][];
+            toSource (targetPoints: number[][], decimals?: number): number[][];
         }
         /**
          * Units of measurement for areas.
@@ -1625,7 +1634,7 @@ declare namespace atlas {
          * @param bounds The BoundingBox to convert to a Polygon.
          * @returns A polygon representation of the BoundingBox.
          */
-        export function boundingBoxToPolygon(bounds: atlas.data.BoundingBox): atlas.data.Polygon;
+        export function boundingBoxToPolygon (bounds: atlas.data.BoundingBox): atlas.data.Polygon;
         /**
          * Converts a distance from one distance units to another. Supported units: miles, nauticalMiles, yards, meters, kilometers, feet
          * @param distance A number that represents a distance to convert.
@@ -1634,7 +1643,7 @@ declare namespace atlas {
          * @param decimals Specifies the number of decimal places to round the result to. If undefined, no rounding will occur.
          * @returns A distance in the new units.
          */
-        export function convertDistance(distance: number, fromUnits: string | DistanceUnits, toUnits: string | DistanceUnits, decimals?: number): number;
+        export function convertDistance (distance: number, fromUnits: string | DistanceUnits, toUnits: string | DistanceUnits, decimals?: number): number;
         /**
          * Calculates an array of positions that form a cardinal spline between the specified array of positions.
          * @param positions The array of positions to calculate the spline through.
@@ -1643,7 +1652,7 @@ declare namespace atlas {
          * @param close A boolean indicating if the spline should be a closed ring or not. Default: false
          * @returns An array of positions that form a cardinal spline between the specified array of positions.
          */
-        export function getCardinalSpline(positions: atlas.data.Position[], tension?: number, nodeSize?: number, close?: boolean): atlas.data.Position[];
+        export function getCardinalSpline (positions: atlas.data.Position[], tension?: number, nodeSize?: number, close?: boolean): atlas.data.Position[];
         /**
          * Calculates a destination position based on a starting position, a heading, a distance, and a distance unit type.
          * @param origin Position that the destination is relative to.
@@ -1652,7 +1661,7 @@ declare namespace atlas {
          * @param units Unit of distance measurement. Default is meters.
          * @returns A position that is the specified distance away from the origin.
          */
-        export function getDestination(origin: atlas.data.Position | atlas.data.Point, heading: number, distance: number, units?: string | DistanceUnits): atlas.data.Position;
+        export function getDestination (origin: atlas.data.Position | atlas.data.Point, heading: number, distance: number, units?: string | DistanceUnits): atlas.data.Position;
         /**
          * Calculate the distance between two position objects on the surface of the earth using the Haversine formula.
          * @param origin First position to calculate distance between.
@@ -1660,41 +1669,41 @@ declare namespace atlas {
          * @param units Unit of distance measurement. Default is meters.
          * @returns The shortest distance between two positions in the specified units.
          */
-        export function getDistanceTo(origin: atlas.data.Position | atlas.data.Point, destination: atlas.data.Position | atlas.data.Point, units?: string | DistanceUnits): number;
+        export function getDistanceTo (origin: atlas.data.Position | atlas.data.Point, destination: atlas.data.Position | atlas.data.Point, units?: string | DistanceUnits): number;
         /**
          * Retrieves the radius of the earth in a specific distance unit for WGS84.
          * @param units Unit of distance measurement. Default: meters
          * @returns A number that represents the radius of the earth in a specific distance unit.
          */
-        export function getEarthRadius(units?: string | DistanceUnits): number;
+        export function getEarthRadius (units?: string | DistanceUnits): number;
         /**
          * Takes an array of positions objects and fills in the space between them with accurately positioned positions to form an approximated Geodesic path.
          * @param path Array of position objects that form a path to fill in.
          * @param nodeSize Number of nodes to insert between each position. Default: 15
          * @returns An array of position objects that form a geodesic paths, geodesic path crossing antimeridian will contain longitude outside of -180 to 180 range. See getGeodesicPaths() when this is undesired.
          */
-        export function getGeodesicPath(path: atlas.data.LineString | atlas.data.Position[], nodeSize?: number): atlas.data.Position[];
+        export function getGeodesicPath (path: atlas.data.LineString | atlas.data.Position[], nodeSize?: number): atlas.data.Position[];
         /**
          * Takes an array of positions objects and fills in the space between them with accurately positioned positions to form an approximated Geodesic path broken by antimeridian into multiple sub-paths.
          * @param path Array of position objects that form a path to fill in.
          * @param nodeSize Number of nodes to insert between each position. Default: 15
          * @returns An array of paths that form geodesic paths, Comparing to getGeodesicPath, sub-paths will always contain longitude in -180 to 180 range
          */
-        export function getGeodesicPaths(path: atlas.data.LineString | atlas.data.Position[], nodeSize?: number): atlas.data.Position[][]
+        export function getGeodesicPaths (path: atlas.data.LineString | atlas.data.Position[], nodeSize?: number): atlas.data.Position[][];
         /**
          * Calculates the heading from one position object to another.
          * @param origin Point of origin.
          * @param destination Destination to calculate relative heading to.
          * @returns A heading in degrees between 0 and 360. 0 degrees points due North.
          */
-        export function getHeading(origin: atlas.data.Position | atlas.data.Point, destination: atlas.data.Position | atlas.data.Point): number;
+        export function getHeading (origin: atlas.data.Position | atlas.data.Point, destination: atlas.data.Position | atlas.data.Point): number;
         /**
          * Calculates the distance between all position objects in an array.
          * @param path The array of position objects that make up the path to calculate the length of.
          * @param units Unit of distance measurement. Default: meters
          * @returns The distance between all positions in between all position objects in an array on the surface of a earth in the specified units.
          */
-        export function getLengthOfPath(path: atlas.data.LineString | atlas.data.Position[], units?: string | DistanceUnits): number;
+        export function getLengthOfPath (path: atlas.data.LineString | atlas.data.Position[], units?: string | DistanceUnits): number;
         /**
          * Calculates the position object on a path that is a specified distance away from the start of the path. If the specified distance is longer
          * than the length of the path, the last position of the path will be returned.
@@ -1703,7 +1712,7 @@ declare namespace atlas {
          * @param units Unit of distance measurement. Default is meters.
          * @returns A position object that is the specified distance away from the start of the path when following the path.
          */
-        export function getPositionAlongPath(path: atlas.data.LineString | atlas.data.Position[], distance: number, units?: string | DistanceUnits): atlas.data.Position;
+        export function getPositionAlongPath (path: atlas.data.LineString | atlas.data.Position[], distance: number, units?: string | DistanceUnits): atlas.data.Position;
         /**
          * Calculates an array of position objects that are an equal distance away from a central point to create a regular polygon.
          * @param origin Center of the regular polygon.
@@ -1713,7 +1722,7 @@ declare namespace atlas {
          * @param offset An offset to rotate the polygon. When 0 the first position will align with North.
          * @returns An array of position objects that form a regular polygon.
          */
-        export function getRegularPolygonPath(origin: atlas.data.Position | atlas.data.Point, radius: number, numberOfPositions: number, units?: string | DistanceUnits, offset?: number): atlas.data.Position[];
+        export function getRegularPolygonPath (origin: atlas.data.Position | atlas.data.Point, radius: number, numberOfPositions: number, units?: string | DistanceUnits, offset?: number): atlas.data.Position[];
         /**
          * Calculates an array of position objects that are an equal distance away from a central point to create a regular polygon broken by antimeridian into multiple sub-paths.
          * @param origin Center of the regular polygon.
@@ -1723,7 +1732,7 @@ declare namespace atlas {
          * @param offset An offset to rotate the polygon. When 0 the first position will align with North.
          * @returns An array of paths that form a regular polygon. Comparing to getRegularPolygonPath, sub-paths will always contain longitude in -180 to 180 range
          */
-        export function getRegularPolygonPaths(origin: Position | atlas.data.Point, radius: number, numberOfPositions: number, units?: string | DistanceUnits, offset?: number): Position[][]
+        export function getRegularPolygonPaths (origin: Position | atlas.data.Point, radius: number, numberOfPositions: number, units?: string | DistanceUnits, offset?: number): Position[][];
         /**
          * Calculates a position object that is a fractional distance between two position objects.
          * @param origin First position to calculate mid-point between.
@@ -1731,30 +1740,30 @@ declare namespace atlas {
          * @param fraction The fractional parameter to calculate a mid-point for. Default 0.5.
          * @returns A position that lies a fraction of the distance between two position objects, relative to the first position object.
          */
-        export function interpolate(origin: atlas.data.Position | atlas.data.Point, destination: atlas.data.Position | atlas.data.Point, fraction?: number): atlas.data.Position;
+        export function interpolate (origin: atlas.data.Position | atlas.data.Point, destination: atlas.data.Position | atlas.data.Point, fraction?: number): atlas.data.Position;
         /**
          * Normalizes a latitude value between -90 and 90 degrees.
          * @param lat The latitude value to normalize.
          */
-        export function normalizeLatitude(lat: number): number;
+        export function normalizeLatitude (lat: number): number;
         /**
          * Normalizes a longitude value between -180 and 180 degrees.
          * @param lng The longitude value to normalize.
          */
-        export function normalizeLongitude(lng: number): number;
+        export function normalizeLongitude (lng: number): number;
         /**
          * Takes an array of positions and rotates them around a given position for the specified angle of rotation.
          * @param positions An array of positions to be rotated.
          * @param origin The position to rotate the positions around.
          * @param angle The amount to rotate the array of positions in degrees clockwise.
          */
-        export function rotatePositions(positions: atlas.data.Position[], origin: atlas.data.Position | atlas.data.Point, angle: number): atlas.data.Position[];
+        export function rotatePositions (positions: atlas.data.Position[], origin: atlas.data.Position | atlas.data.Point, angle: number): atlas.data.Position[];
         /**
          * Calculates the pixel accurate heading from one position to another based on the Mercator map projection. This heading is visually accurate.
          * @param origin
          * @param destination
          */
-        export function getPixelHeading(origin: atlas.data.Position | atlas.data.Point, destination: atlas.data.Position | atlas.data.Point): number;
+        export function getPixelHeading (origin: atlas.data.Position | atlas.data.Point, destination: atlas.data.Position | atlas.data.Point): number;
         /**
          * Converts an array of global Mercator pixel coordinates into an array of geospatial positions at a specified zoom level.
          * Global pixel coordinates are relative to the top left corner of the map [-180, 90].
@@ -1762,14 +1771,14 @@ declare namespace atlas {
          * @param zoom Zoom level.
          * @returns An array of positions.
          */
-        export function mercatorPixelsToPositions(pixels: Pixel[], zoom: number): atlas.data.Position[];
+        export function mercatorPixelsToPositions (pixels: Pixel[], zoom: number): atlas.data.Position[];
         /**
          * Converts an array of positions into an array of global Mercator pixel coordinates at a specified zoom level.
          * @param positions Array of positions.
          * @param zoom Zoom level.
          * @returns Array of global Mercator pixels.
          */
-        export function mercatorPositionsToPixels(positions: atlas.data.Position[], zoom: number): Pixel[];
+        export function mercatorPositionsToPixels (positions: atlas.data.Position[], zoom: number): Pixel[];
         /**
          * Converts an acceleration value from one unit to another.
          * Supported units:
@@ -1781,7 +1790,7 @@ declare namespace atlas {
          * @param decimals The number of decimal places to round the result to.
          * @returns An acceleration value convertered from one unit to another.
          */
-        export function convertAcceleration(acceleration: number, fromUnits: string | AccelerationUnits, toUnits: string | AccelerationUnits, decimals?: number): number;
+        export function convertAcceleration (acceleration: number, fromUnits: string | AccelerationUnits, toUnits: string | AccelerationUnits, decimals?: number): number;
         /**
          * Converts an area value from one unit to another.
          * Supported units: squareMeters, acres, hectares, squareFeet, squareYards, squareMiles, squareKilometers
@@ -1791,7 +1800,7 @@ declare namespace atlas {
          * @param decimals The number of decimal places to round the result to.
          * @returns An area value convertered from one unit to another.
          */
-        export function convertArea(area: number, fromUnits: string, toUnits: string, decimals?: number): number;
+        export function convertArea (area: number, fromUnits: string, toUnits: string, decimals?: number): number;
         /**
          * Converts a speed value from one unit to another.
          * Supported units:
@@ -1802,7 +1811,7 @@ declare namespace atlas {
          * @param decimals The number of decimal places to round the result to.
          * @returns A speed value convertered from one unit to another.
          */
-        export function convertSpeed(speed: number, fromUnits: string | SpeedUnits, toUnits: string | SpeedUnits, decimals?: number): number;
+        export function convertSpeed (speed: number, fromUnits: string | SpeedUnits, toUnits: string | SpeedUnits, decimals?: number): number;
         /**
          * Converts a timespan value from one unit to another.
          * Supported units:
@@ -1813,7 +1822,7 @@ declare namespace atlas {
          * @param decimals The number of decimal places to round the result to.
          * @returns A time value convertered from one unit to another.
          */
-        export function convertTimespan(timespan: number, fromUnits: string | TimeUnits, toUnits: string | TimeUnits, decimals?: number): number;
+        export function convertTimespan (timespan: number, fromUnits: string | TimeUnits, toUnits: string | TimeUnits, decimals?: number): number;
         /**
          * Calculates an acceleration based on an initial speed, travel distance and timespan. Formula: a = 2*(d - v*t)/t^2
          * @param initialSpeed The initial speed.
@@ -1826,7 +1835,7 @@ declare namespace atlas {
          * @param decimals The number of decimal places to round the result to.
          * @returns An acceleration based on an initial speed, travel distance and timespan.
          */
-        export function getAcceleration(initialSpeed: number, distance: number, timespan: number, speedUnits?: string | SpeedUnits, distanceUnits?: string | DistanceUnits, timeUnits?: string | TimeUnits, accelerationUnits?: string | AccelerationUnits, decimals?: number): number;
+        export function getAcceleration (initialSpeed: number, distance: number, timespan: number, speedUnits?: string | SpeedUnits, distanceUnits?: string | DistanceUnits, timeUnits?: string | TimeUnits, accelerationUnits?: string | AccelerationUnits, decimals?: number): number;
         /**
          * Calculates an acceleration based on an initial speed, final speed and timespan. Formula: a = 2* (v2 - v1)/t
          * @param initialSpeed The initial speed.
@@ -1838,7 +1847,7 @@ declare namespace atlas {
          * @param decimals The number of decimal places to round the result to.
          * @returns An acceleration based on an initial speed, final speed and timespan.
          */
-        export function getAccelerationFromSpeeds(initialSpeed: number, finalSpeed: number, timespan: number, speedUnits?: string | SpeedUnits, timeUnits?: string | TimeUnits, accelerationUnits?: string | AccelerationUnits, decimals?: number): number;
+        export function getAccelerationFromSpeeds (initialSpeed: number, finalSpeed: number, timespan: number, speedUnits?: string | SpeedUnits, timeUnits?: string | TimeUnits, accelerationUnits?: string | AccelerationUnits, decimals?: number): number;
         /**
          * Calculates an acceleration between two point features that have a timestamp property and optionally a speed property.
          * if speeds are provided, ignore distance between points as the path may not have been straight and calculate: a = (v2 - v1)/(t2 - t1)
@@ -1852,7 +1861,7 @@ declare namespace atlas {
          * @param decimals The number of decimal places to round the result to.
          * @returns An acceleration between two point features that have a timestamp property and optionally a speed property. Returns NaN if unable to parse timestamp.
          */
-        export function getAccelerationFromFeatures(origin: atlas.data.Feature<atlas.data.Point, any>, destination: atlas.data.Feature<atlas.data.Point, any>, timestampProperty: string, speedProperty?: string, speedUnits?: string | SpeedUnits, accelerationUnits?: string | AccelerationUnits, decimals?: number): number;
+        export function getAccelerationFromFeatures (origin: atlas.data.Feature<atlas.data.Point, any>, destination: atlas.data.Feature<atlas.data.Point, any>, timestampProperty: string, speedProperty?: string, speedUnits?: string | SpeedUnits, accelerationUnits?: string | AccelerationUnits, decimals?: number): number;
         /**
          * Calculates the approximate area of a geometry in the specified units
          * @param coordinates The coordinates of the polyon ring.
@@ -1861,7 +1870,7 @@ declare namespace atlas {
          * @param decimals The number of decimal places to round the result to.
          * @returns The area of a geometry in the specified units.
          */
-        export function getArea(data: atlas.data.Geometry | atlas.data.Feature<atlas.data.Geometry, any> | atlas.Shape, areaUnits?: AreaUnits, decimals?: number): number;
+        export function getArea (data: atlas.data.Geometry | atlas.data.Feature<atlas.data.Geometry, any> | atlas.Shape, areaUnits?: AreaUnits, decimals?: number): number;
         /**
          * Calculates the average speed of travel between two points based on the provided amount of time.
          * @param origin The initial point in which the speed is calculated from.
@@ -1872,7 +1881,7 @@ declare namespace atlas {
          * @param decimals The number of decimal places to round the result to.
          * @returns The average speed of travel between two points based on the provided amount of time.
          */
-        export function getSpeed(origin: atlas.data.Position | atlas.data.Point | atlas.data.Feature<atlas.data.Point, any>, destination: atlas.data.Position | atlas.data.Point | atlas.data.Feature<atlas.data.Point, any>, timespan: number, timeUnits?: string | TimeUnits, speedUnits?: string | SpeedUnits, decimals?: number): number;
+        export function getSpeed (origin: atlas.data.Position | atlas.data.Point | atlas.data.Feature<atlas.data.Point, any>, destination: atlas.data.Position | atlas.data.Point | atlas.data.Feature<atlas.data.Point, any>, timespan: number, timeUnits?: string | TimeUnits, speedUnits?: string | SpeedUnits, decimals?: number): number;
         /**
          * Calculates the average speed of travel between two point features that have a property containing a timestamp.
          * The timestamp can be;
@@ -1889,7 +1898,7 @@ declare namespace atlas {
          * @param decimals The number of decimal places to round the result to.
          * @returns The speed in the specified units or NaN if valid timestamps are not found.
          */
-        export function getSpeedFromFeatures(origin: atlas.data.Feature<atlas.data.Point, any>, destination: atlas.data.Feature<atlas.data.Point, any>, timestampProperty: string, speedUnits?: string | SpeedUnits, decimals?: number): number;
+        export function getSpeedFromFeatures (origin: atlas.data.Feature<atlas.data.Point, any>, destination: atlas.data.Feature<atlas.data.Point, any>, timestampProperty: string, speedUnits?: string | SpeedUnits, decimals?: number): number;
         /**
          * Calculates the timespan between two dates or timestamps.
          * Timestamps can be;
@@ -1904,7 +1913,7 @@ declare namespace atlas {
          * @param units The units to return the time value in. If not specified seconds are used.
          * @returns A timespan between two dates or timestamps. Returns NaN if unable to parse timestamps.
          */
-        export function getTimespan(startTime: Date | string | number, endTime: Date | string | number, units?: TimeUnits, decimals?: number): number;
+        export function getTimespan (startTime: Date | string | number, endTime: Date | string | number, units?: TimeUnits, decimals?: number): number;
         /**
          * Calculates the distance traveled for a specified timespan, speed and optionally an acceleration.
          * Formula: d = v*t + 0.5*a*t^2
@@ -1918,7 +1927,7 @@ declare namespace atlas {
          * @param decimals The number of decimal places to round the result to.
          * @returns The distance traveled for a specified timespan, speed and optionally an acceleration.
          */
-        export function getTravelDistance(distanceUnits: string, timespan: number, speed: number, acceleration?: number, timeUnits?: string | TimeUnits, speedUnits?: string | SpeedUnits, accelerationUnits?: string, decimals?: number): number;
+        export function getTravelDistance (distanceUnits: string, timespan: number, speed: number, acceleration?: number, timeUnits?: string | TimeUnits, speedUnits?: string | SpeedUnits, accelerationUnits?: string, decimals?: number): number;
         /**
          * Parses a timestamp into a JavaScript Date object.
          * Timestamps can be;
@@ -1931,32 +1940,32 @@ declare namespace atlas {
          * @param timestamp The timestamp value to parse.
          * @returns A Date object that represents the timestamp or null if the timestamp could not be parsed.
          */
-        export function parseTimestamp(timestamp: Date | string | number): Date;
+        export function parseTimestamp (timestamp: Date | string | number): Date;
         /**
          * Calculates a Convex Hull from an array of positions, geometries or features.
          * @param data The array of positions, geometries or features to calculate a convex hull for.
          * @returns A Convex Hull from an array of positions, geometries or features.
          */
-        export function getConvexHull(data: atlas.data.Position[] | atlas.data.Geometry | atlas.data.Feature<atlas.data.Geometry, any> | atlas.data.FeatureCollection | atlas.data.GeometryCollection | atlas.data.Geometry[] | Array<atlas.data.Feature<atlas.data.Geometry, any> | atlas.Shape> | atlas.Shape): atlas.data.Polygon;
+        export function getConvexHull (data: atlas.data.Position[] | atlas.data.Geometry | atlas.data.Feature<atlas.data.Geometry, any> | atlas.data.FeatureCollection | atlas.data.GeometryCollection | atlas.data.Geometry[] | Array<atlas.data.Feature<atlas.data.Geometry, any> | atlas.Shape> | atlas.Shape): atlas.data.Polygon;
         /**
          * Retrieves an array of all positions in the provided geometry, feature or array of geometries/features.
          * @param data The geometries or features to retrieve the positions from.
          * @returns An array of all positions in the provided geometry, feature or array of geometries/features.
          */
-        export function getPositions(data: atlas.data.Position[] | atlas.data.Geometry | atlas.data.Feature<atlas.data.Geometry, any> | atlas.data.FeatureCollection | atlas.data.GeometryCollection | atlas.data.Geometry[] | Array<atlas.data.Feature<atlas.data.Geometry, any> | atlas.Shape> | atlas.Shape): atlas.data.Position[];
+        export function getPositions (data: atlas.data.Position[] | atlas.data.Geometry | atlas.data.Feature<atlas.data.Geometry, any> | atlas.data.FeatureCollection | atlas.data.GeometryCollection | atlas.data.Geometry[] | Array<atlas.data.Feature<atlas.data.Geometry, any> | atlas.Shape> | atlas.Shape): atlas.data.Position[];
         /**
          * Gets the position of an object that is a position, point, point feature, or circle. If it is a circle, its center coordinate will be returned.
          * @param data The data object to extract the position from.
          * @returns The position of an object that is a position, point, or point feature. Returns null if invalid data passed in.
          */
-        export function getPosition(data: atlas.data.Position | atlas.data.Point | atlas.data.Feature<atlas.data.Point, any> | atlas.Shape): atlas.data.Position;
+        export function getPosition (data: atlas.data.Position | atlas.data.Point | atlas.data.Feature<atlas.data.Point, any> | atlas.Shape): atlas.data.Position;
         /**
          * Gets an array of evenly spaced positions along a path.
          * @param path The path to get the positions from.
          * @param numPositions The number of positions to get.
          * @returns An array of evenly spaced positions along a path.
          */
-        export function getPositionsAlongPath(path: atlas.data.LineString | atlas.data.Position[], numPositions: number): atlas.data.Position[];
+        export function getPositionsAlongPath (path: atlas.data.LineString | atlas.data.Position[], numPositions: number): atlas.data.Position[];
         /**
          * Gets a point with heading a specified distance along a path.
          * @param path The path to get the point from.
@@ -1964,7 +1973,7 @@ declare namespace atlas {
          * @param units The distance units.
          * @returns A point with heading a specified distance along a path.
          */
-        export function getPointWithHeadingAlongPath(path: atlas.data.LineString | atlas.data.Position[], distance: number, units?: string | DistanceUnits): atlas.data.Feature<atlas.data.Point, {
+        export function getPointWithHeadingAlongPath (path: atlas.data.LineString | atlas.data.Position[], distance: number, units?: string | DistanceUnits): atlas.data.Feature<atlas.data.Point, {
             heading: number;
         }>;
         /**
@@ -1973,7 +1982,7 @@ declare namespace atlas {
          * @param numPoints The number of points to get.
          * @returns An array of evenly spaced points with headings along a path.
          */
-        export function getPointsWithHeadingsAlongPath(path: atlas.data.LineString | atlas.data.Position[], numPoints: number): Array<atlas.data.Feature<atlas.data.Point, {
+        export function getPointsWithHeadingsAlongPath (path: atlas.data.LineString | atlas.data.Position[], numPoints: number): Array<atlas.data.Feature<atlas.data.Point, {
             heading: number;
         }>>;
         /**
@@ -1988,7 +1997,7 @@ declare namespace atlas {
          * @param decimals The number of decimal places to round the result to.
          * @returns
          */
-        export function getClosestPointOnGeometry(pt: atlas.data.Position | atlas.data.Point | atlas.data.Feature<atlas.data.Point, any> | atlas.Shape, geom: atlas.data.Geometry | atlas.data.Feature<atlas.data.Geometry, any> | atlas.Shape, units?: string | DistanceUnits, decimals?: number): atlas.data.Feature<atlas.data.Point, {
+        export function getClosestPointOnGeometry (pt: atlas.data.Position | atlas.data.Point | atlas.data.Feature<atlas.data.Point, any> | atlas.Shape, geom: atlas.data.Geometry | atlas.data.Feature<atlas.data.Geometry, any> | atlas.Shape, units?: string | DistanceUnits, decimals?: number): atlas.data.Feature<atlas.data.Point, {
             distance: number;
         }>;
 
@@ -1998,7 +2007,7 @@ declare namespace atlas {
          * @param tolerance A tolerance to use in the simplification.
          * @returns A new array of the simplified set of points.
          */
-        export function simplify(points: (Position | Pixel)[], tolerance: number): (Position | Pixel)[];
+        export function simplify (points: (Position | Pixel)[], tolerance: number): (Position | Pixel)[];
 
         /**
          * Denormalizes path on antimeridian, this makes lines with coordinates on the opposite side of the antimeridian to always cross it. Note that the path crossing antimeridian will contain longitude outside of -180 to 180 range.
@@ -2006,7 +2015,7 @@ declare namespace atlas {
          * @param path Array of position objects or linestring to denormalize
          * @returns A denormalized array of position objects, path crossing antimeridian will contain longitude outside of -180 to 180 range.
          */
-        export function getPathDenormalizedAtAntimerian(path: atlas.data.LineString | Position[]): Position[];
+        export function getPathDenormalizedAtAntimerian (path: atlas.data.LineString | Position[]): Position[];
 
         /**
          * Split path on antimeridian into multiple paths.
@@ -2014,7 +2023,7 @@ declare namespace atlas {
          * @param path Array of position objects or linestring to split
          * @returns A path split into multiple paths by antimeridian.
          */
-        export function getPathSplitByAntimeridian(path: atlas.data.LineString | Position[]): Position[][];
+        export function getPathSplitByAntimeridian (path: atlas.data.LineString | Position[]): Position[][];
     }
 
     /**
@@ -2050,109 +2059,109 @@ declare namespace atlas {
          * @param container The id of the element where the map should be displayed.
          * @param options Options for the initial display and interactability with the map.
          */
-        constructor(container: string | HTMLElement, options: ServiceOptions & StyleOptions & UserInteractionOptions & (CameraOptions | CameraBoundsOptions));
+        constructor (container: string | HTMLElement, options: ServiceOptions & StyleOptions & UserInteractionOptions & (CameraOptions | CameraBoundsOptions));
         /**
          * Returns true if the map has been disposed.
          */
-        get isDisposed(): boolean;
+        get isDisposed (): boolean;
         /**
          * Returns the HTMLCanvasElement that the map is drawn to.
          */
-        getCanvas(): HTMLCanvasElement;
+        getCanvas (): HTMLCanvasElement;
         /**
          * Returns the HTMLElement that contains the map's HTMLCanvasElement. The map's events (e.g. panning and zooming)
          * are attached to this element.
          */
-        getCanvasContainer(): HTMLElement;
+        getCanvasContainer (): HTMLElement;
         /**
          * Returns the HTMLElement that contains the map.
          */
-        getMapContainer(): HTMLElement;
+        getMapContainer (): HTMLElement;
         /**
          * Returns the service options with which the map control was initialized.
          */
-        getServiceOptions(): ServiceOptions;
+        getServiceOptions (): ServiceOptions;
         /**
          * Set the service options.
          */
-        setServiceOptions(options: ServiceOptions): void;
+        setServiceOptions (options: ServiceOptions): void;
         /**
          * Set the camera of the map control with an animated transition. Any options not specified will default to their
          * current values.
          * @param options The options for setting the map's camera and for the animation of any view change.
          */
-        setCamera(options?: (CameraOptions | (CameraBoundsOptions & { pitch?: number, bearing?: number })) & AnimationOptions): void;
+        setCamera (options?: (CameraOptions | (CameraBoundsOptions & { pitch?: number, bearing?: number })) & AnimationOptions): void;
         /**
          * Returns the camera's current properties.
          */
-        getCamera(): CameraOptions & CameraBoundsOptions;
+        getCamera (): CameraOptions & CameraBoundsOptions;
         /**
          * Set the map control's style options. Any options not specified will default to their current values.
          * @param options The options for setting the style of the map control.
          * @param diff [true] If false, forces a 'full' style update, removing the current style and building the given one instead of attempting a diff-based update. Defaults to true.
          */
-        setStyle(options?: StyleOptions, diff?: boolean): void;
+        setStyle (options?: StyleOptions, diff?: boolean): void;
         /**
          * Returns the map control's current style settings.
          */
-        getStyle(): StyleOptions;
+        getStyle (): StyleOptions;
         /**
          * Set the map control's user interaction handlers. Any options not specified will default to their current values.
          * @param options The options for enabling/disabling the user interaction handlers.
          */
-        setUserInteraction(options?: UserInteractionOptions): void;
+        setUserInteraction (options?: UserInteractionOptions): void;
         /**
          * Return the map control's current user interaction handler settings.
          */
-        getUserInteraction(): UserInteractionOptions;
+        getUserInteraction (): UserInteractionOptions;
         /**
          * Set the traffic options for the map. Any options not specified will default to their current values.
          * @param options The options for defining the map's traffic display.
          */
-        setTraffic(options?: TrafficOptions): void;
+        setTraffic (options?: TrafficOptions): void;
         /**
          * Return the map control's current traffic settings.
          */
-        getTraffic(): TrafficOptions;
+        getTraffic (): TrafficOptions;
         /**
          * Removes all sources, layers, markers, and popups from the map.
          * User added images are preserved.
          */
-        clear(): void;
+        clear (): void;
         /**
          * Clean up the map's resources. Map will not function correctly after calling this method.
          */
-        dispose(): void;
+        dispose (): void;
         /**
          * Resize the map according to the dimensions of its container element.
          * @param eventData Optional additional properties to be added to event objects of events triggered by this method.
          */
-        resize(eventData?: any): void;
+        resize (eventData?: any): void;
         /**
          * Resizes the map's container element then the map itself.
          * @param height The height for the map and its container element. A number input is assumed to be in pixels.
          * @param width The width for the map and its container element. A number input is assumed to be in pixels.
          * @param eventData Optional additional properties to be added to event objects of events triggered by this method.
          */
-        resize(height: number | string, width: number | string, eventData?: any): void;
+        resize (height: number | string, width: number | string, eventData?: any): void;
         /**
          * Converts an array of Pixel objects to an array of geographic Positions objects on the map.
          * @param pixels The pixels to be converted.
          */
-        pixelsToPositions(pixels: Pixel[]): atlas.data.Position[];
+        pixelsToPositions (pixels: Pixel[]): atlas.data.Position[];
         /**
          * Converts an array of Positions objects to an array of Pixel objects relative to the map container.
          * @param positions The positions to be converted.
          */
-        positionsToPixels(positions: atlas.data.Position[]): Pixel[];
+        positionsToPixels (positions: atlas.data.Position[]): Pixel[];
         /**
          * Returns a boolean indicating if all tiles in the current viewport for all sources have loaded or not.
          */
-        areTilesLoaded(): boolean;
+        areTilesLoaded (): boolean;
         /**
          * Stops any animated transition that is currently underway.
          */
-        stop(): void;
+        stop (): void;
         /**
          * Trigger the rendering of a single frame.
          * Use this method with WebGL layers to repaint the map when the layer's
@@ -2160,18 +2169,18 @@ declare namespace atlas {
          * Calling this multiple times before the next frame is rendered will still
          * result in only a single frame being rendered.
          */
-        triggerRepaint(): void;
+        triggerRepaint (): void;
         /**
          * Loads a 3D terrain mesh, based on a "raster-dem" source.
          *
          * @param elevationSource elevation tile source
          * @param exaggeration the elevation exaggeration factor
          */
-        enableElevation(elevationSource: string | atlas.source.ElevationTileSource, exaggeration?: number): void;
+        enableElevation (elevationSource: string | atlas.source.ElevationTileSource, exaggeration?: number): void;
         /**
          * Disables the 3D terrain mesh.
          */
-        disableElevation(): void;
+        disableElevation (): void;
         /**
          * The callback used when styleOptions.autoResize is true.
          */
@@ -2204,24 +2213,24 @@ declare namespace atlas {
          * @param x The horizontal pixel offset.
          * @param y The vertical pixel offset.
          */
-        constructor(x: number, y: number);
+        constructor (x: number, y: number);
         /**
          * Generates a Pixel object from an object that contains coordinate information.
          * The object is scanned for x and y properties using a case insensitive test.
          * @param data The object to extract coordinate information from.
          * @returns A Pixel object that represents the provided data information.
          */
-        static fromData(data: object): Pixel;
+        static fromData (data: object): Pixel;
         /**
          * Return the x coordinate of the specified pixel.
          * @param pixel The pixel to get the x coordinate of.
          */
-        static getX(pixel: Pixel): number;
+        static getX (pixel: Pixel): number;
         /**
          * Return the y coordinate of the specified pixel.
          * @param pixel The pixel to get the y coordinate of.
          */
-        static getY(pixel: Pixel): number;
+        static getY (pixel: Pixel): number;
         /**
          * Calculates a destination pixel given an origin pixel,
          * a heading relative to the y-axis (0 = north) with clockwise-rotation,
@@ -2230,20 +2239,20 @@ declare namespace atlas {
          * @param heading The heading at which to move away from the origin pixel.
          * @param distance The distance to move from the origin pixel.
          */
-        static getDestination(origin: Pixel, heading: number, distance: number): Pixel;
+        static getDestination (origin: Pixel, heading: number, distance: number): Pixel;
         /**
          * Calculates the distance between two pixels.
          * Returned value is in screen pixel units.
          * @param p1 The first pixel.
          * @param p2 The second pixel.
          */
-        static getDistance(p1: Pixel, p2: Pixel): number;
+        static getDistance (p1: Pixel, p2: Pixel): number;
         /**
          * Calculates the heading between two pixels.​ The heading value is relative to the y-axis (0 = north) with clockwise-rotation.
          * @param origin The pixel the heading will point away from.
          * @param destination The pixel the heading will point toward.
          */
-        static getHeading(origin: Pixel, destination: Pixel): number;
+        static getHeading (origin: Pixel, destination: Pixel): number;
     }
 
     export interface PopupEvents {
@@ -2274,31 +2283,31 @@ declare namespace atlas {
          * Constructs a Popup object and initializes it with the specified options.
          * @param options The options for the popup.
          */
-        constructor(options?: PopupOptions);
+        constructor (options?: PopupOptions);
         /**
          * Sets the options for the popup.
          * @param options The options for the popup.
          * @deprecated Use setOptions(...) instead.
          */
-        setPopupOptions(options?: PopupOptions): void;
+        setPopupOptions (options?: PopupOptions): void;
         /**
          * Sets the options for the popup.
          * @param options The options for the popup.
          */
-        setOptions(options?: PopupOptions): void;
+        setOptions (options?: PopupOptions): void;
         /**
          * Returns the options for the popup.
          * @deprecated Use getOptions() instead.
          */
-        getPopupOptions(): PopupOptions;
+        getPopupOptions (): PopupOptions;
         /**
          * Returns the options for the popup.
          */
-        getOptions(): PopupOptions;
+        getOptions (): PopupOptions;
         /**
          * Returns popup container element.
          */
-        getPopupContainer(): HTMLElement
+        getPopupContainer (): HTMLElement;
         /**
          * Attaches the popup to the HTML document in a hidden state.
          * @param map The map.
@@ -2488,7 +2497,7 @@ declare namespace atlas {
          * @param prop The properties object generate the popup content from.
          * @param template The template to apply.
          */
-        static applyTemplate(prop: Properties, template?: PopupTemplate): HTMLElement;
+        static applyTemplate (prop: Properties, template?: PopupTemplate): HTMLElement;
         /** Regular expression for content property placeholders. */
         private static readonly _placeholderRx;
         /** Regular expression for external URLs. */
@@ -2553,7 +2562,7 @@ declare namespace atlas {
          * @param key The property name key.
          * @param value The value of the property.
          */
-        static _ignoreProperty(key: string, value: any): boolean;
+        static _ignoreProperty (key: string, value: any): boolean;
     }
 
     export interface ShapeEvents {
@@ -2572,69 +2581,69 @@ declare namespace atlas {
          * @param data: a Feature which contains a Geometry object and properties.
          * If the feature does not have an id, a unique id value will be assigned to it.
          */
-        constructor(data: atlas.data.Feature<atlas.data.Geometry, any>);
+        constructor (data: atlas.data.Feature<atlas.data.Geometry, any>);
         /**
          * Constructs a Shape object and initializes it with the specified Geometry, ID, and properties.
          * @param data a Geometry object
          * @param id a unique id that the user assigns to the shape. If not provided, a unique id value will be assigned to it.
          * @param properties User defined properties for the shape.
          */
-        constructor(data: atlas.data.Geometry, id?: string | number, properties?: any);
+        constructor (data: atlas.data.Geometry, id?: string | number, properties?: any);
         /**
          * Adds or updates an existing property value in the shape.
          * @param key
          * @param value
          */
-        addProperty(key: string, value: any): void;
+        addProperty (key: string, value: any): void;
         /**
          * Gets the bounding box of the shape
          */
-        getBounds(): atlas.data.BoundingBox;
+        getBounds (): atlas.data.BoundingBox;
         /**
          * Gets the coordinates of the shape.
          */
-        getCoordinates(): atlas.data.Position | atlas.data.Position[] | atlas.data.Position[][] | atlas.data.Position[][][];
+        getCoordinates (): atlas.data.Position | atlas.data.Position[] | atlas.data.Position[][] | atlas.data.Position[][][];
         /**
          * If the shape is a circle, this gets its coordinates. Otherwise returns null.
          */
-        getCircleCoordinates(): atlas.data.Position[];
+        getCircleCoordinates (): atlas.data.Position[];
         /**
          * Gets the id of the shape.
          */
-        getId(): string | number;
+        getId (): string | number;
         /**
          * Gets the properties of the shape.
          */
-        getProperties(): any;
+        getProperties (): any;
         /**
          * Returns a string indicating the type of geometry this shape contains.
          */
-        getType(): string;
+        getType (): string;
         /**
          * Indicates if the contained shape is a Circle, defined by the extended GeoJSON specification supported by Azure Maps.
          * [Extended Spec]{@link https://docs.microsoft.com/en-us/azure/azure-maps/extend-geojson}
          */
-        isCircle(): boolean;
+        isCircle (): boolean;
         /**
          * Indicates if the contained shape is a Rectangle, defined by the extended GeoJSON specification supported by Azure Maps.
          * [Extended Spec]{@link https://docs.microsoft.com/en-us/azure/azure-maps/extend-geojson}
          */
-        isRectangle(): boolean;
+        isRectangle (): boolean;
         /**
          * Updates the coordinates of the shape
          * @param coords Point: Position, LineString: Position[], Polygon: Position[][],
          * MultiPoint: Position[], MultiLineString: Position[][], MultiPolygon: Position[][]
          */
-        setCoordinates(coords: atlas.data.Position | atlas.data.Position[] | atlas.data.Position[][] | atlas.data.Position[][][]): void;
+        setCoordinates (coords: atlas.data.Position | atlas.data.Position[] | atlas.data.Position[][] | atlas.data.Position[][][]): void;
         /**
          * Sets the properties on the shape. Overwrites all existing properties.
          * @param properties
          */
-        setProperties(properties: any): void;
+        setProperties (properties: any): void;
         /**
          * Returns a GeoJSON feature that represents the shape.
          */
-        toJson(): atlas.data.Feature<atlas.data.Geometry, any>;
+        toJson (): atlas.data.Feature<atlas.data.Geometry, any>;
         /**
          * Check if the shape's wrapped feature is a circle form the extended GeoJSON spec.
          * If so it will calculate a polygon feature that approximates the specified circle.
@@ -2677,24 +2686,24 @@ declare namespace atlas {
          * Constructs a new HtmlMarker.
          * @param options The options for the HtmlMarker.
          */
-        constructor(options?: HtmlMarkerOptions);
+        constructor (options?: HtmlMarkerOptions);
         /**
          * Gets the HTML marker options.
          */
-        getOptions(): HtmlMarkerOptions;
+        getOptions (): HtmlMarkerOptions;
         /**
          * Returns the underlying `Marker`'s HTML element.
          */
-        getElement(): HTMLElement;
+        getElement (): HTMLElement;
         /**
          * Sets the options of the marker.
          * @param options The options for the marker.
          */
-        setOptions(options: HtmlMarkerOptions): void;
+        setOptions (options: HtmlMarkerOptions): void;
         /**
          * Toggles the popup attached to the marker.
          */
-        togglePopup(): void;
+        togglePopup (): void;
         /**
          * Builds the Mapbox marker that this HtmlMarker will wrap.
          * @private
@@ -2747,54 +2756,54 @@ declare namespace atlas {
      * Gets the default authentication options that were provided.
      * If not previously set all properties will be undefined.
      */
-    export function getAuthenticationOptions(): AuthenticationOptions;
+    export function getAuthenticationOptions (): AuthenticationOptions;
     /**
      * Gets the default domain that was provided.
      * If not previously set the default value is `"atlas.microsoft.com"`.
      */
-    export function getDomain(): string;
+    export function getDomain (): string;
     /**
      * Gets the default language that was provided.
      * If not previously set the default value is `"NGT"`.
      */
-    export function getLanguage(): string;
+    export function getLanguage (): string;
     /**
      * Gets the Maximum number of images (raster tiles, sprites, icons) to load in parallel
      */
-    export function getMaxParallelImageRequests(): number;
+    export function getMaxParallelImageRequests (): number;
     /**
      * Gets the default session id that was provided.
      * If not previously set the default value is a random UUID.
      */
-    export function getSessionId(): string;
+    export function getSessionId (): string;
     /**
      * Gets the default Azure Maps subscription key that was provided.
      */
-    export function getSubscriptionKey(): string;
+    export function getSubscriptionKey (): string;
     /**
      * @deprecated use atlas.getView() instead
      */
-    export function getUserRegion(): string;
+    export function getUserRegion (): string;
     /**
      * Gets the default view setting of the map control.
      * If not previously set the default value is `undefined`.
      */
-    export function getView(): string;
+    export function getView (): string;
     /**
      * Current API version number based on build number.
      */
-    export function getVersion(): string;
+    export function getVersion (): string;
     /**
      * Gets the worker count that will get created.
      */
-    export function getWorkerCount(): number;
+    export function getWorkerCount (): number;
     /**
      * Checks to see if the user's browser is supported by the map control.
      * @param failIfMajorPerformanceCaveat If true the function will return false
      * if the performance of the map control would be dramatically worse than expected
      * (e.g. a software WebGL renderer would be used).
      */
-    export function isSupported(failIfMajorPerformanceCaveat?: boolean): boolean;
+    export function isSupported (failIfMajorPerformanceCaveat?: boolean): boolean;
     /**
      * Sets your authentication options as the default options in the atlas namespace
      * which is used by the map control and any modules that make requests to the Azure maps services.
@@ -2802,7 +2811,7 @@ declare namespace atlas {
      * setAuthenticationOptions hasn't previously been called it will automatically be called by the Map constructor.
      * @param options The new default authentication options.
      */
-    export function setAuthenticationOptions(options: AuthenticationOptions): void;
+    export function setAuthenticationOptions (options: AuthenticationOptions): void;
     /**
      * Sets the default domain used by the map and service modules unless the
      * domain is explicitly specified when using those parts of the API.
@@ -2811,7 +2820,7 @@ declare namespace atlas {
      * If the protocol is not specified `https` is assumed.
      * @param domain The new default domain.
      */
-    export function setDomain(domain: string): void;
+    export function setDomain (domain: string): void;
     /**
      * Sets the default language used by the map and service modules unless the
      * language is explicitly specified when using those parts of the API.
@@ -2819,13 +2828,13 @@ declare namespace atlas {
      * setLanguage hasn't previously been called it will automatically be called by the Map constructor.
      * @param language The new default language.
      */
-    export function setLanguage(language: string): void;
+    export function setLanguage (language: string): void;
     /**
      * Sets Maximum number of images (raster tiles, sprites, icons) to load in parallel,
      * which affects performance in raster-heavy maps. 16 by default.
      * @param maxParallelImageRequests Maximum number of images to load in parallel.
      */
-    export function setMaxParallelImageRequests(maxParallelImageRequests: number): void;
+    export function setMaxParallelImageRequests (maxParallelImageRequests: number): void;
     /**
      * Sets the default session id used by the map and service modules unless the
      * session id is explicitly specified when using those parts of the API.
@@ -2833,7 +2842,7 @@ declare namespace atlas {
      * setSessionId hasn't previously been called it will automatically be called by the Map constructor.
      * @param id The new default session id.
      */
-    export function setSessionId(id: string): void;
+    export function setSessionId (id: string): void;
     /**
      * Sets your Azure Maps subscription key as the default subscription key in the atlas namespace
      * which is used by the map control and any modules that make requests to the Azure maps services.
@@ -2841,41 +2850,41 @@ declare namespace atlas {
      * setSubscriptionKey hasn't previously been called it will automatically be called by the Map constructor.
      * @param key The new default subscription key.
      */
-    export function setSubscriptionKey(key: string): void;
+    export function setSubscriptionKey (key: string): void;
     /**
      * @deprecated use atlas.setView(view: string) instead.
      */
-    export function setUserRegion(userRegion: string): void;
+    export function setUserRegion (userRegion: string): void;
     /**
      * Specifies which set of geopolitically disputed borders and labels are displayed on the map. The View parameter (also referred to as “user region parameter”) is a 2-letter ISO-3166 Country Code that will show the correct maps for that country/region. Country/Regions that are not on the View list or if unspecified will default to the “Unified” View.
      * Please see the supported [Views]{@link https://aka.ms/AzureMapsLocalizationViews }.
      * It is your responsibility to determine the location of your users, and then set the View parameter correctly for that location. The View parameter in Azure Maps must be used in compliance with applicable laws, including those regarding mapping, of the country/region where maps, images and other data and third party content that You are authorized to access via Azure Maps is made available.
      * @param view The new default view
      */
-    export function setView(view: string): void;
+    export function setView (view: string): void;
     /**
      * Sets number of web workers instantiated on a page.
      * By default, it is set to half the number of CPU cores (capped at 6).
      * @param workerCount worker count.
      */
-    export function setWorkerCount(workerCount: number): void;
+    export function setWorkerCount (workerCount: number): void;
     /**
      * Adds an image template to the atlas namespace.
      * @param templateName The name of the template.
      * @param template The SVG template to add. Supports {color}, {secondaryColor}, {scale}, {text}.
      * @param override Specifies if it should override existing templates if one with the same name already exists.
      */
-    export function addImageTemplate(templateName: string, template: string, override: boolean): void;
+    export function addImageTemplate (templateName: string, template: string, override: boolean): void;
     /**
      * Retrieves an SVG template by name.
      * @param templateName The name of the template to retrieve.
      * @param scale Specifies how much to scale the template. For best results, scale the icon to the maximum size you want to display it on the map, then use the symbol layers icon size option to scale down if needed. This will reduce blurriness due to scaling. Default: 1
      */
-    export function getImageTemplate(templateName: string, scale?: number): string;
+    export function getImageTemplate (templateName: string, scale?: number): string;
     /**
      * Retrieves an array of names for all image templates that are available in the atlas namespace.
      */
-    export function getAllImageTemplateNames(): string[];
+    export function getAllImageTemplateNames (): string[];
     /**
      * Initializes resources like WebWorkers that can be shared across maps to lower load
      * times in some situations. `atlas.setWorkerCount`, if being
@@ -2893,14 +2902,14 @@ declare namespace atlas {
      * would navigate between various views that can cause Map instances to constantly be
      * created and destroyed.
      */
-    export function prewarm(): void;
+    export function prewarm (): void;
     /**
      * Clears up resources that have previously been created by `atlas.prewarm()`.
      * Note that this is typically not necessary. You should only call this function
      * if you expect the user of your app to not return to a Map view at any point
      * in your application.
      */
-    export function clearPrewarmedResources(): void;
+    export function clearPrewarmedResources (): void;
     /**
      * Options used when rendering Point objects in a BubbleLayer.
      */
@@ -2953,9 +2962,9 @@ declare namespace atlas {
          */
         strokeWidth?: number | DataDrivenPropertyValueSpecification<number>;
         /**
-         * Specifies the orientation of circle when map is pitched.
-         * <p>`"map"`: The circle is aligned to the plane of the map.</p>
-         * <p>`"viewport"`: The circle is aligned to the plane of the viewport.</p>
+         * Specifies the orientation of circle when map is pitched.<br />
+         * `"map"`: The circle is aligned to the plane of the map.<br />
+         * `"viewport"`: The circle is aligned to the plane of the viewport.<br />
          * Default: `"viewport"`
          * @default "viewport"
          */
@@ -2982,16 +2991,16 @@ declare namespace atlas {
          */
         allowOverlap?: boolean;
         /**
-         * Specifies which part of the icon is placed closest to the icons anchor position on the map.
-         * <p>`"center"`: The center of the icon is placed closest to the anchor.</p>
-         * <p>`"left"`: The left side of the icon is placed closest to the anchor.</p>
-         * <p>`"right"`: The right side of the icon is placed closest to the anchor.</p>
-         * <p>`"top"`: The top of the icon is placed closest to the anchor.</p>
-         * <p>`"bottom"`: The bottom of the icon is placed closest to the anchor.</p>
-         * <p>`"top-left"`: The top left corner of the icon is placed closest to the anchor.</p>
-         * <p>`"top-right"`: The top right corner of the icon is placed closest to the anchor.</p>
-         * <p>`"bottom-left"`: The bottom left corner of the icon is placed closest to the anchor.</p>
-         * <p>`"bottom-right"`: The bottom right corner of the icon is placed closest to the anchor.</p>
+         * Specifies which part of the icon is placed closest to the icons anchor position on the map.<br />
+         * `"center"`: The center of the icon is placed closest to the anchor.<br />
+         * `"left"`: The left side of the icon is placed closest to the anchor.<br />
+         * `"right"`: The right side of the icon is placed closest to the anchor.<br />
+         * `"top"`: The top of the icon is placed closest to the anchor.<br />
+         * `"bottom"`: The bottom of the icon is placed closest to the anchor.<br />
+         * `"top-left"`: The top left corner of the icon is placed closest to the anchor.<br />
+         * `"top-right"`: The top right corner of the icon is placed closest to the anchor.<br />
+         * `"bottom-left"`: The bottom left corner of the icon is placed closest to the anchor.<br />
+         * `"bottom-right"`: The bottom right corner of the icon is placed closest to the anchor.<br />
          * Default `"bottom"`.
          * @default "bottom"
          */
@@ -3036,10 +3045,10 @@ declare namespace atlas {
          */
         padding?: number | DataDrivenPropertyValueSpecification<number>;
         /**
-         * Specifies the orientation of the icon when the map is pitched.
-         * <p>`"auto"`: Automatically matches the value of `rotationAlignment`.</p>
-         * <p>`"map"`: The icon is aligned to the plane of the map.</p>
-         * <p>`"viewport"`: The icon is aligned to the plane of the viewport</p>
+         * Specifies the orientation of the icon when the map is pitched.<br />
+         * `"auto"`: Automatically matches the value of `rotationAlignment`.<br />
+         * `"map"`: The icon is aligned to the plane of the map.<br />
+         * `"viewport"`: The icon is aligned to the plane of the viewport<br />
          * Default `"auto"`
          * @default "auto"
          */
@@ -3052,12 +3061,12 @@ declare namespace atlas {
         rotation?: number | DataDrivenPropertyValueSpecification<number>;
         /**
          * In combination with the placement property of a SymbolLayerOptions
-         * this determines the rotation behavior of icons.
-         * <p>`"auto"`: When placement is "point" this is equivalent to "viewport".
-         * When placement is "line" this is equivalent to "map".</p>
-         * <p>`"map"`: When placement is "point" aligns icons east-west.
-         * When placement is "line" aligns the icons' x-axes with the line.</p>
-         * <p>`"viewport"`: Icons' x-axes will align with the x-axis of the viewport.</p>
+         * this determines the rotation behavior of icons.<br />
+         * `"auto"`: When placement is "point" this is equivalent to "viewport".
+         * When placement is "line" this is equivalent to "map".<br />
+         * `"map"`: When placement is "point" aligns icons east-west.
+         * When placement is "line" aligns the icons' x-axes with the line.<br />
+         * `"viewport"`: Icons' x-axes will align with the x-axis of the viewport.<br />
          * Default `"auto"`.
          * @default "auto"
          */
@@ -3196,24 +3205,24 @@ declare namespace atlas {
          */
         sourceLayer?: string;
         /**
-         * Specifies how the ends of the lines are rendered.
-         * <p>`"butt"`: A cap with a squared-off end which is drawn to the exact endpoint of the line.</p>
-         * <p>`"round"`: A cap with a rounded end which is drawn beyond the endpoint of the line
-         * at a radius of one-half of the lines width and centered on the endpoint of the line.</p>
-         * <p>`"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 width.</p>
+         * Specifies how the ends of the lines are rendered.<br />
+         * `"butt"`: A cap with a squared-off end which is drawn to the exact endpoint of the line.<br />
+         * `"round"`: A cap with a rounded end which is drawn beyond the endpoint of the line
+         * at a radius of one-half of the lines width and centered on the endpoint of the line.<br />
+         * `"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 width.<br />
          * Default `"round"`.
          * @default "round"
          */
         lineCap?: "butt" | "round" | "square";
         /**
-         * Specifies how the joints in the lines are rendered.
-         * <p>`"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 lines width.</p>
-         * <p>`"round"`: A join with a rounded end which is drawn beyond the endpoint of the line
-         * at a radius of one-half of the lines width and centered on the endpoint of the line.</p>
-         * <p>`"miter"`: A join with a sharp, angled corner which is drawn with the outer sides
-         * beyond the endpoint of the path until they meet.</p>
+         * Specifies how the joints in the lines are rendered.<br />
+         * `"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 lines width.<br />
+         * `"round"`: A join with a rounded end which is drawn beyond the endpoint of the line
+         * at a radius of one-half of the lines width and centered on the endpoint of the line.<br />
+         * `"miter"`: A join with a sharp, angled corner which is drawn with the outer sides
+         * beyond the endpoint of the path until they meet.<br />
          * Default `"round"`.
          * @default "round"
          */
@@ -3264,9 +3273,9 @@ declare namespace atlas {
          */
         translate?: Pixel;
         /**
-         * Specifies the frame of reference for `translate`.
-         * <p>`"map"`: Lines are translated relative to the map.</p>
-         * <p>`"viewport"`: Lines are translated relative to the viewport</p>
+         * Specifies the frame of reference for `translate`.<br />
+         * `"map"`: Lines are translated relative to the map.<br />
+         * `"viewport"`: Lines are translated relative to the viewport<br />
          * Default: `"map"`
          * @default "map"
          */
@@ -3385,9 +3394,9 @@ declare namespace atlas {
          */
         translate?: Pixel;
         /**
-         * Specifies the frame of reference for `translate`.
-         * <p>`"map"`: Polygons are translated relative to the map.</p>
-         * <p>`"viewport"`: Polygons are translated relative to the viewport.</p>
+         * Specifies the frame of reference for `translate`.<br />
+         * `"map"`: Polygons are translated relative to the map.<br />
+         * `"viewport"`: Polygons are translated relative to the viewport.<br />
          * Default: `"map"`
          * @default "map"
          */
@@ -3463,12 +3472,12 @@ declare namespace atlas {
          */
         textOptions?: TextOptions;
         /**
-         * Specifies the label placement relative to its geometry.
-         * <p>`"point"`: The label is placed at the point where the geometry is located.</p>
-         * <p>`"line"`: The label is placed along the line of the geometry.
-         * Can only be used on LineString and Polygon geometries.</p>
-         * <p> `"line-center"`: The label is placed at the center of the line of the geometry.
-         * Can only be used on `LineString` and `Polygon` geometries </p>
+         * Specifies the label placement relative to its geometry.<br />
+         * `"point"`: The label is placed at the point where the geometry is located.<br />
+         * `"line"`: The label is placed along the line of the geometry.
+         * Can only be used on LineString and Polygon geometries.<br />
+         *  `"line-center"`: The label is placed at the center of the line of the geometry.
+         * Can only be used on `LineString` and `Polygon` geometries <br />
          * Default `"point"`.
          * @default "point"
          */
@@ -3483,12 +3492,12 @@ declare namespace atlas {
         /**
          * Determines whether overlapping symbols in the same layer are rendered in the order
          * that they appear in the data source, or by their y position relative to the viewport.
-         * To control the order and prioritization of symbols otherwise, use `sortKey`.
-         * <p>`"auto"`: Sorts symbols by `sortKey` if set. Otherwise behaves like `"viewport-y"`.
-         * <p>`"viewport-y"`: Sorts symbols by their y position if `allowOverlap` is `true` or
-         * if `ignorePlacement` is `false`.
-         * <p>`"source"`: Sorts symbols by `sortKey` if set. Otherwise, symbols are rendered in the
-         * same order as the source data.
+         * To control the order and prioritization of symbols otherwise, use `sortKey`.<br />
+         * `"auto"`: Sorts symbols by `sortKey` if set. Otherwise behaves like `"viewport-y"`.<br />
+         * `"viewport-y"`: Sorts symbols by their y position if `allowOverlap` is `true` or
+         * if `ignorePlacement` is `false`.<br />
+         * `"source"`: Sorts symbols by `sortKey` if set. Otherwise, symbols are rendered in the
+         * same order as the source data.<br />
          * Default `"auto"`
          * @default "auto"
          */
@@ -3513,16 +3522,16 @@ declare namespace atlas {
          */
         allowOverlap?: boolean;
         /**
-         * Specifies which part of the icon is placed closest to the icons anchor position on the map.
-         * <p>`"center"`: The center of the icon is placed closest to the anchor.</p>
-         * <p>`"left"`: The left side of the icon is placed closest to the anchor.</p>
-         * <p>`"right"`: The right side of the icon is placed closest to the anchor.</p>
-         * <p>`"top"`: The top of the icon is placed closest to the anchor.</p>
-         * <p>`"bottom"`: The bottom of the icon is placed closest to the anchor.</p>
-         * <p>`"top-left"`: The top left corner of the icon is placed closest to the anchor.</p>
-         * <p>`"top-right"`: The top right corner of the icon is placed closest to the anchor.</p>
-         * <p>`"bottom-left"`: The bottom left corner of the icon is placed closest to the anchor.</p>
-         * <p>`"bottom-right"`: The bottom right corner of the icon is placed closest to the anchor.</p>
+         * Specifies which part of the icon is placed closest to the icons anchor position on the map.<br />
+         * `"center"`: The center of the icon is placed closest to the anchor.<br />
+         * `"left"`: The left side of the icon is placed closest to the anchor.<br />
+         * `"right"`: The right side of the icon is placed closest to the anchor.<br />
+         * `"top"`: The top of the icon is placed closest to the anchor.<br />
+         * `"bottom"`: The bottom of the icon is placed closest to the anchor.<br />
+         * `"top-left"`: The top left corner of the icon is placed closest to the anchor.<br />
+         * `"top-right"`: The top right corner of the icon is placed closest to the anchor.<br />
+         * `"bottom-left"`: The bottom left corner of the icon is placed closest to the anchor.<br />
+         * `"bottom-right"`: The bottom right corner of the icon is placed closest to the anchor.<br />
          * Default `"center"`.
          * @default "center"
          */
@@ -3552,11 +3561,11 @@ declare namespace atlas {
          */
         ignorePlacement?: boolean;
         /**
-         * Text justification options.
-         * <p>`"auto"`: The text is aligned towards the anchor position.
-         * <p>`"left"`: The text is aligned to the left.
-         * <p>`"center"`: The text is centered.
-         * <p>`"right"`: The text is aligned to the right.
+         * Text justification options.<br />
+         * `"auto"`: The text is aligned towards the anchor position.<br />
+         * `"left"`: The text is aligned to the left.<br />
+         * `"center"`: The text is centered.<br />
+         * `"right"`: The text is aligned to the right.<br />
          * Default `"center"`.
          * @default "center"
          */
@@ -3584,10 +3593,10 @@ declare namespace atlas {
          */
         padding?: number | PropertyValueSpecification<number>;
         /**
-         * Specifies the orientation of the text when the map is pitched.
-         * <p>`"auto"`: Automatically matches the value of `rotationAlignment`.</p>
-         * <p>`"map"`: The text is aligned to the plane of the map.</p>
-         * <p>`"viewport"`: The text is aligned to the plane of the viewport.</p>
+         * Specifies the orientation of the text when the map is pitched.<br />
+         * `"auto"`: Automatically matches the value of `rotationAlignment`.<br />
+         * `"map"`: The text is aligned to the plane of the map.<br />
+         * `"viewport"`: The text is aligned to the plane of the viewport.<br />
          * Default: `"auto"`
          * @default "auto"
          */
@@ -3607,13 +3616,13 @@ declare namespace atlas {
         rotation?: number | DataDrivenPropertyValueSpecification<number>;
         /**
          * In combination with the `placement` property of the `SymbolLayerOptions`,
-         * specifies the rotation behavior of the individual glyphs forming the text.
-         * <p>`"auto"`: When the `placement` is set to `"point"`, this is equivalent to `"map"`.
-         * When the `placement` is set to `"line"` this is equivalent to `"map"`.</p>
-         * <p>`"map"`: When the `placement` is set to `"point"`, aligns text east-west.
-         * When the `placement` is set to `"line"`, aligns text x-axes with the line.</p>
-         * <p>`"viewport"`: Produces glyphs whose x-axes are aligned with the x-axis of the viewport,
-         * regardless of the value of `placement`.</p>
+         * specifies the rotation behavior of the individual glyphs forming the text.<br />
+         * `"auto"`: When the `placement` is set to `"point"`, this is equivalent to `"map"`.
+         * When the `placement` is set to `"line"` this is equivalent to `"map"`.<br />
+         * `"map"`: When the `placement` is set to `"point"`, aligns text east-west.
+         * When the `placement` is set to `"line"`, aligns text x-axes with the line.<br />
+         * `"viewport"`: Produces glyphs whose x-axes are aligned with the x-axis of the viewport,
+         * regardless of the value of `placement`.<br />
          * Default: `"auto"`
          * @default "auto"
          */
@@ -3623,16 +3632,16 @@ declare namespace atlas {
          * labels on the map. The renderer will attempt to place the label at each location,
          * in order, before moving onto the next label. Use `justify: "auto"` to choose text
          * justification based on anchor position. To apply an offset use the `radialOffset` or
-         * two-dimensional `offset` options.
-         * <p>`"center"`: The center of the icon is placed closest to the anchor.</p>
-         * <p>`"left"`: The left side of the icon is placed closest to the anchor.</p>
-         * <p>`"right"`: The right side of the icon is placed closest to the anchor.</p>
-         * <p>`"top"`: The top of the icon is placed closest to the anchor.</p>
-         * <p>`"bottom"`: The bottom of the icon is placed closest to the anchor.</p>
-         * <p>`"top-left"`: The top left corner of the icon is placed closest to the anchor.</p>
-         * <p>`"top-right"`: The top right corner of the icon is placed closest to the anchor.</p>
-         * <p>`"bottom-left"`: The bottom left corner of the icon is placed closest to the anchor.</p>
-         * <p>`"bottom-right"`: The bottom right corner of the icon is placed closest to the anchor.</p>
+         * two-dimensional `offset` options.<br />
+         * `"center"`: The center of the icon is placed closest to the anchor.<br />
+         * `"left"`: The left side of the icon is placed closest to the anchor.<br />
+         * `"right"`: The right side of the icon is placed closest to the anchor.<br />
+         * `"top"`: The top of the icon is placed closest to the anchor.<br />
+         * `"bottom"`: The bottom of the icon is placed closest to the anchor.<br />
+         * `"top-left"`: The top left corner of the icon is placed closest to the anchor.<br />
+         * `"top-right"`: The top right corner of the icon is placed closest to the anchor.<br />
+         * `"bottom-left"`: The bottom left corner of the icon is placed closest to the anchor.<br />
+         * `"bottom-right"`: The bottom right corner of the icon is placed closest to the anchor.<br />
          * Default: `undefined`
          * @default undefined
          */
@@ -3834,9 +3843,9 @@ declare namespace atlas {
      */
     export interface StyleControlOptions extends Options {
         /**
-         * The layout to display the styles in.
-         * <p>`"icons"`: A row of clickable icons for each style.</p>
-         * <p>`"list"`: A scrollable list with the icons and names for each style.</p>
+         * The layout to display the styles in.<br />
+         * `"icons"`: A row of clickable icons for each style.<br />
+         * `"list"`: A scrollable list with the icons and names for each style.<br />
          * Default `"icons"`
          * @default "icons"
          */
@@ -3886,13 +3895,12 @@ declare namespace atlas {
 
     export interface TrafficControlOptions extends Options {
         /**
-         * The type of traffic flow to display:
-         * <p>"none" is to display no traffic flow data</p>
-         * <p>"relative" is the speed of the road relative to free-flow</p>
-         * <p>@deprecated "absolute" is the absolute speed of the road</p>
-         * <p>@deprecated "relative-delay" displays relative speed only where they differ from free-flow;
-         * false to stop displaying the traffic flow.</p>
-         * default `"relative"``
+         * The type of traffic flow to display:<br />
+         * `"none"` is to display no traffic flow data<br />
+         * `"relative"` is the speed of the road relative to free-flow<br />
+         * @deprecated `"absolute"` is the absolute speed of the road<br />
+         * @deprecated `"relative-delay"` displays relative speed only where they differ from free-flow;
+         * false to stop displaying the traffic flow.<br />
          * @default "relative"
          */
         flow?: "none" | "relative" | "absolute" | "relative-delay";
@@ -3929,10 +3937,10 @@ declare namespace atlas {
          */
         duration?: number;
         /**
-         * The type of animation.
-         * <p>"jump" is an immediate change.</p>
-         * <p>"ease" is a gradual change of the camera's settings.</p>
-         * <p>"fly" is a gradual change of the camera's settings following an arc resembling flight.</p>
+         * The type of animation.<br />
+         * `"jump"` is an immediate change.<br />
+         * `"ease"` is a gradual change of the camera's settings.<br />
+         * `"fly"` is a gradual change of the camera's settings following an arc resembling flight.<br />
          * Default `"jump"`.
          * @default "jump"
          */
@@ -4016,6 +4024,7 @@ declare namespace atlas {
         pitch?: number;
         /**
          * The minimum zoom level that the map can be zoomed out to during the animation. Must be between 0 and 24, and less than or equal to `maxZoom`.
+         * Setting `minZoom` below 1 may result in an empty map when the zoom level is less than 1.
          * `default 1`
          * @default 1
          */
@@ -4158,7 +4167,8 @@ declare namespace atlas {
          */
         generateId?: boolean | undefined;
         /**
-         * A property to use as a feature id (for feature state). Either a property name, or an object of the form {<sourceLayer>: <propertyName>}.
+         * A specified property name to be used as a feature ID (for feature state).
+         * This can either be a property name or an object in the form `{<sourceLayer>: <propertyName>}`.
          */
         promoteId?: { [key: string]: string } | string | undefined;
         /**
@@ -4228,9 +4238,9 @@ declare namespace atlas {
 
     export interface ElevationTileSourceOptions extends RasterTileSourceOptions {
         /**
-         * DEM tiles encoding format. Supported: `mapbox` or `terrarium`.
-         * <p>`"terrarium": Terrarium format PNG tiles. See https://aws.amazon.com/es/public-datasets/terrain/ for more info.</p>
-         * <p>`"mapbox": Mapbox Terrain RGB tiles. See https://www.mapbox.com/help/access-elevation-data/#mapbox-terrain-rgb for more info.</p>
+         * DEM tiles encoding format. Supported: `mapbox` or `terrarium`.<br />
+         * `"terrarium": Terrarium format PNG tiles. See https://aws.amazon.com/es/public-datasets/terrain/ for more info.<br />
+         * `"mapbox": Mapbox Terrain RGB tiles. See https://www.mapbox.com/help/access-elevation-data/#mapbox-terrain-rgb for more info.<br />
          * default `mapbox`
          * @default mapbox
          */
@@ -4376,15 +4386,15 @@ declare namespace atlas {
     export interface LightOptions extends Options {
         /**
          * Specifies wether extruded geometries are lit relative to the map or viewport.
-         * Supported values:
-         * <p>`"map"`: The position of the light source is aligned to the rotation of the map.</p>
-         * <p>`"viewport"`: The position fo the light source is aligned to the rotation of the viewport.</p>
+         * Supported values:<br />
+         * `"map"`: The position of the light source is aligned to the rotation of the map.<br />
+         * `"viewport"`: The position fo the light source is aligned to the rotation of the viewport.<br />
          * Default: `"map"`
          * @default "map"
          */
         anchor?: "map" | "viewport";
         /**
-         * Color tint for lighting extruded geometries
+         * Color tint for lighting extruded geometries.
          * Default: `"#FFFFFF"`
          * @default "#FFFFFF"
          */
@@ -4521,13 +4531,13 @@ declare namespace atlas {
      */
     export interface TrafficOptions extends Options {
         /**
-         * The type of traffic flow to display:
-         * <p>"none" is to display no traffic flow data</p>
-         * <p>"relative" is the speed of the road relative to free-flow</p>
-         * <p>@deprecated "absolute" is the absolute speed of the road</p>
-         * <p>@deprecated "relative-delay" displays relative speed only where they differ from free-flow;
-         * false to stop displaying the traffic flow.</p>
-         * default `"none"``
+          * The type of traffic flow to display:<br />
+          * `"none"` is to display no traffic flow data<br />
+          * `"relative"` is the speed of the road relative to free-flow<br />
+          * @deprecated `"absolute"` is the absolute speed of the road<br />
+          * @deprecated `"relative-delay"` displays relative speed only where they differ from free-flow;
+          * false to stop displaying the traffic flow.<br />
+          * default `"none"`
          * @default "none"
          */
         flow?: "none" | "relative" | "absolute" | "relative-delay";
@@ -5061,281 +5071,281 @@ declare namespace atlas {
          * @param eventType The data event name.
          * @param callback The event handler callback.
          */
-        add(eventType: "data" | "sourcedata" | "styledata", callback: (e: MapDataEvent) => void): void;
+        add (eventType: "data" | "sourcedata" | "styledata", callback: (e: MapDataEvent) => void): void;
         /**
          * Adds an event to the map.
          * @param eventType The error event name.
          * @param callback The event handler callback.
          */
-        add(eventType: "error", callback: (e: MapErrorEvent) => void): void;
+        add (eventType: "error", callback: (e: MapErrorEvent) => void): void;
         /**
          * Adds a touch event to the map.
          * @param eventType The touch event name.
          * @param callback The event handler callback.
          */
-        add(eventType: "touchstart" | "touchend" | "touchmove" | "touchcancel", callback: (e: MapTouchEvent) => void): void;
+        add (eventType: "touchstart" | "touchend" | "touchmove" | "touchcancel", callback: (e: MapTouchEvent) => void): void;
         /**
          * Adds a mouse event to the map.
          * @param eventType The mouse event name.
          * @param callback The event handler callback.
          */
-        add(eventType: "mousedown" | "mouseup" | "mouseover" | "mousemove" | "click" | "dblclick" | "mouseout" | "contextmenu", callback: (e: MapMouseEvent) => void): void;
+        add (eventType: "mousedown" | "mouseup" | "mouseover" | "mousemove" | "click" | "dblclick" | "mouseout" | "contextmenu", callback: (e: MapMouseEvent) => void): void;
         /**
          * Adds a style image missing event to the map.
          * @param eventType The style image missing event name.
          * @param callback The event handler callback.
          */
-        add(eventType: "styleimagemissing", callback: (e: string) => void): void;
+        add (eventType: "styleimagemissing", callback: (e: string) => void): void;
         /**
          * Adds a wheel event to the map.
          * @param eventType The wheel event name.
          * @param callback The event handler callback.
          */
-        add(eventType: "stylechanged", callback: (e: StyleChangedEvent) => void): void;
+        add (eventType: "stylechanged", callback: (e: StyleChangedEvent) => void): void;
         /**
          * Adds a mapConfiguration change event to the map.
          * @param eventType A mapConfiguration changed event name
          * @param callback The event handler callback
          */
-        add(eventType: "mapconfigurationchanged", callback: (e: MapConfiguration) => void): void;
+        add (eventType: "mapconfigurationchanged", callback: (e: MapConfiguration) => void): void;
         /**
          * Adds a wheel event to the map.
          * @param eventType The wheel event name.
          * @param callback The event handler callback.
          */
-        add(eventType: "wheel", callback: (e: MapMouseWheelEvent) => void): void;
+        add (eventType: "wheel", callback: (e: MapMouseWheelEvent) => void): void;
         /**
          * Adds an event to the map.
          * @param eventType The event name.
          * @param callback The event handler callback.
          */
-        add(eventType: "boxzoomstart" | "boxzoomend" | "dragstart" | "drag" | "dragend" | "idle" | "load" | "movestart" | "move" | "moveend" | "pitchstart" | "pitch" | "pitchend" | "ready" | "render" | "resize" | "rotatestart" | "rotate" | "rotateend" | "tokenacquired" | "zoomstart" | "zoom" | "zoomend", callback: (e: MapEvent) => void): void;
+        add (eventType: "boxzoomstart" | "boxzoomend" | "dragstart" | "drag" | "dragend" | "idle" | "load" | "movestart" | "move" | "moveend" | "pitchstart" | "pitch" | "pitchend" | "ready" | "render" | "resize" | "rotatestart" | "rotate" | "rotateend" | "tokenacquired" | "zoomstart" | "zoom" | "zoomend", callback: (e: MapEvent) => void): void;
         /**
          * Adds an event to the map.
          * @param eventType The event name.
          * @param callback The event handler callback.
          */
-        add(eventType: "layeradded" | "layerremoved", callback: (e: atlas.layer.Layer) => void): void;
+        add (eventType: "layeradded" | "layerremoved", callback: (e: atlas.layer.Layer) => void): void;
         /**
          * Adds an event to the map.
          * @param eventType The event name.
          * @param callback The event handler callback.
          */
-        add(eventType: "sourceadded" | "sourceremoved", callback: (e: atlas.source.Source) => void): void;
+        add (eventType: "sourceadded" | "sourceremoved", callback: (e: atlas.source.Source) => void): void;
         /**
          * Adds an event to the DataSource(s).
          * @param eventType The event name.
          * @param target The DataSource(s) to add the event for.
          * @param callback The event handler callback.
          */
-        add(eventType: "datasourceupdated", target: atlas.source.DataSource | atlas.source.DataSource[], callback: (e: atlas.source.DataSource) => void): void;
+        add (eventType: "datasourceupdated", target: atlas.source.DataSource | atlas.source.DataSource[], callback: (e: atlas.source.DataSource) => void): void;
         /**
          * Adds an event to the DataSource(s).
          * @param eventType The event name.
          * @param target The DataSource(s) to add the event for.
          * @param callback The event handler callback.
          */
-        add(eventType: "dataadded" | "dataremoved", target: atlas.source.DataSource | atlas.source.DataSource[], callback: (e: Shape[]) => void): void;
+        add (eventType: "dataadded" | "dataremoved", target: atlas.source.DataSource | atlas.source.DataSource[], callback: (e: Shape[]) => void): void;
         /**
          * Adds an event to the HtmlMarker(s).
          * @param eventType The event name.
          * @param target The HtmlMarker(s) to add the event for.
          * @param callback The event handler callback.
          */
-        add(eventType: "click" | "contextmenu" | "dblclick" | "drag" | "dragstart" | "dragend" | "keydown" | "keypress" | "keyup" | "mousedown" | "mouseenter" | "mouseleave" | "mousemove" | "mouseout" | "mouseover" | "mouseup", target: HtmlMarker | HtmlMarker[], callback: (e: TargetedEvent) => void): void;
+        add (eventType: "click" | "contextmenu" | "dblclick" | "drag" | "dragstart" | "dragend" | "keydown" | "keypress" | "keyup" | "mousedown" | "mouseenter" | "mouseleave" | "mousemove" | "mouseout" | "mouseover" | "mouseup", target: HtmlMarker | HtmlMarker[], callback: (e: TargetedEvent) => void): void;
         /**
          * Adds a touch event to the Layer(s).
          * @param eventType The event name.
          * @param target The Layer(s) to add the event for.
          * @param callback The event handler callback.
          */
-        add(eventType: "touchstart" | "touchend" | "touchmove" | "touchcancel", target: atlas.layer.Layer | atlas.layer.Layer[], callback: (e: MapTouchEvent) => void): void;
+        add (eventType: "touchstart" | "touchend" | "touchmove" | "touchcancel", target: atlas.layer.Layer | atlas.layer.Layer[], callback: (e: MapTouchEvent) => void): void;
         /**
          * Adds an event to the Layer(s).
          * @param eventType The event name.
          * @param target The Layer(s) to add the event for.
          * @param callback The event handler callback.
          */
-        add(eventType: "layeradded" | "layerremoved", target: atlas.layer.Layer | atlas.layer.Layer[], callback: (e: atlas.layer.Layer) => void): void;
+        add (eventType: "layeradded" | "layerremoved", target: atlas.layer.Layer | atlas.layer.Layer[], callback: (e: atlas.layer.Layer) => void): void;
         /**
          * Adds a mouse event to the Layer(s).
          * @param eventType The event name.
          * @param target The Layer(s) to add the event for.
          * @param callback The event handler callback.
          */
-        add(eventType: "mousedown" | "mouseup" | "mouseover" | "mousemove" | "click" | "dblclick" | "mouseout" | "mouseenter" | "mouseleave" | "contextmenu", target: atlas.layer.Layer | atlas.layer.Layer[], callback: (e: MapMouseEvent) => void): void;
+        add (eventType: "mousedown" | "mouseup" | "mouseover" | "mousemove" | "click" | "dblclick" | "mouseout" | "mouseenter" | "mouseleave" | "contextmenu", target: atlas.layer.Layer | atlas.layer.Layer[], callback: (e: MapMouseEvent) => void): void;
         /**
          * Adds a wheel event to the Layer(s).
          * @param eventType The event name.
          * @param target The Layer(s) to add the event for.
          * @param callback The event handler callback.
          */
-        add(eventType: "wheel", target: atlas.layer.Layer | atlas.layer.Layer[], callback: (e: MapMouseWheelEvent) => void): void;
+        add (eventType: "wheel", target: atlas.layer.Layer | atlas.layer.Layer[], callback: (e: MapMouseWheelEvent) => void): void;
         /**
          * Adds an event to the Popup(s).
          * @param eventType The event name.
          * @param target The Popup(s) to add the event for.
          * @param callback The event handler callback.
          */
-        add(eventType: "drag" | "dragend" | "dragstart" | "open" | "close", target: Popup | Popup[], callback: (e: TargetedEvent) => void): void;
+        add (eventType: "drag" | "dragend" | "dragstart" | "open" | "close", target: Popup | Popup[], callback: (e: TargetedEvent) => void): void;
         /**
          * Adds an event to the StyleControl
          * @param eventType The event name.
          * @param target The StyleControl to add the event for.
          * @param callback The event handler callback.
          */
-        add(eventType: "styleselected", target: atlas.control.StyleControl, callback: (e: string) => void): void;
+        add (eventType: "styleselected", target: atlas.control.StyleControl, callback: (e: string) => void): void;
         /**
          * Adds an event to the Shape(s).
          * @param eventType The event name.
          * @param target The Shape(s) to add the event for.
          * @param callback The event handler callback.
          */
-        add(eventType: "shapechanged", target: Shape | Shape[], callback: (e: Shape) => void): void;
+        add (eventType: "shapechanged", target: Shape | Shape[], callback: (e: Shape) => void): void;
         /**
          * Adds an event to the Source(s).
          * @param eventType The event name.
          * @param target The Source(s) to add the event for.
          * @param callback The event handler callback.
          */
-        add(eventType: "sourceadded" | "sourceremoved", target: atlas.source.Source | atlas.source.Source[], callback: (e: atlas.source.Source) => void): void;
+        add (eventType: "sourceadded" | "sourceremoved", target: atlas.source.Source | atlas.source.Source[], callback: (e: atlas.source.Source) => void): void;
         /**
          * Adds a data event to the map.
          * @param eventType The data event name.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "data" | "sourcedata" | "styledata", callback: (e: MapDataEvent) => void): void;
+        addOnce (eventType: "data" | "sourcedata" | "styledata", callback: (e: MapDataEvent) => void): void;
         /**
          * Adds an event to the map.
          * @param eventType The error event name.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "error", callback: (e: MapErrorEvent) => void): void;
+        addOnce (eventType: "error", callback: (e: MapErrorEvent) => void): void;
         /**
          * Adds a touch event to the map.
          * @param eventType The touch event name.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "touchstart" | "touchend" | "touchmove" | "touchcancel", callback: (e: MapTouchEvent) => void): void;
+        addOnce (eventType: "touchstart" | "touchend" | "touchmove" | "touchcancel", callback: (e: MapTouchEvent) => void): void;
         /**
          * Adds an event to the map.
          * @param eventType The event name.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "layeradded" | "layerremoved", callback: (e: atlas.layer.Layer) => void): void;
+        addOnce (eventType: "layeradded" | "layerremoved", callback: (e: atlas.layer.Layer) => void): void;
         /**
          * Adds a mouse event to the map.
          * @param eventType The mouse event name.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "mousedown" | "mouseup" | "mouseover" | "mousemove" | "click" | "dblclick" | "mouseout" | "contextmenu", callback: (e: MapMouseEvent) => void): void;
+        addOnce (eventType: "mousedown" | "mouseup" | "mouseover" | "mousemove" | "click" | "dblclick" | "mouseout" | "contextmenu", callback: (e: MapMouseEvent) => void): void;
         /**
          * Adds an event to the map.
          * @param eventType The event name.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "sourceadded" | "sourceremoved", callback: (e: atlas.source.Source) => void): void;
+        addOnce (eventType: "sourceadded" | "sourceremoved", callback: (e: atlas.source.Source) => void): void;
         /**
          * Adds a style image missing event to the map.
          * @param eventType The style image missing event name.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "styleimagemissing", callback: (e: string) => void): void;
+        addOnce (eventType: "styleimagemissing", callback: (e: string) => void): void;
         /**
          * Adds a wheel event to the map.
          * @param eventType The wheel event name.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "stylechanged", callback: (e: StyleChangedEvent) => void): void;
+        addOnce (eventType: "stylechanged", callback: (e: StyleChangedEvent) => void): void;
         /**
          * Adds a wheel event to the map.
          * @param eventType The wheel event name.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "wheel", callback: (e: MapMouseWheelEvent) => void): void;
+        addOnce (eventType: "wheel", callback: (e: MapMouseWheelEvent) => void): void;
         /**
          * Adds an event to the map.
          * @param eventType The event name.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "boxzoomstart" | "boxzoomend" | "dragstart" | "drag" | "dragend" | "idle" | "load" | "movestart" | "move" | "moveend" | "pitchstart" | "pitch" | "pitchend" | "ready" | "render" | "resize" | "rotatestart" | "rotate" | "rotateend" | "tokenacquired" | "zoomstart" | "zoom" | "zoomend", callback: (e: MapEvent) => void): void;
+        addOnce (eventType: "boxzoomstart" | "boxzoomend" | "dragstart" | "drag" | "dragend" | "idle" | "load" | "movestart" | "move" | "moveend" | "pitchstart" | "pitch" | "pitchend" | "ready" | "render" | "resize" | "rotatestart" | "rotate" | "rotateend" | "tokenacquired" | "zoomstart" | "zoom" | "zoomend", callback: (e: MapEvent) => void): void;
         /**
          * Adds an event to the DataSource.
          * @param eventType The event name.
          * @param target The DataSource to add the event for.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "datasourceupdated", target: atlas.source.DataSource, callback: (e: atlas.source.DataSource) => void): void;
+        addOnce (eventType: "datasourceupdated", target: atlas.source.DataSource, callback: (e: atlas.source.DataSource) => void): void;
         /**
          * Adds an event to the DataSource.
          * @param eventType The event name.
          * @param target The DataSource to add the event for.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "dataadded" | "dataremoved", target: atlas.source.DataSource, callback: (e: Shape[]) => void): void;
+        addOnce (eventType: "dataadded" | "dataremoved", target: atlas.source.DataSource, callback: (e: Shape[]) => void): void;
         /**
          * Adds an event to the HtmlMarker.
          * @param eventType The event name.
          * @param target The HtmlMarker to add the event for.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "click" | "contextmenu" | "dblclick" | "drag" | "dragstart" | "dragend" | "keydown" | "keypress" | "keyup" | "mousedown" | "mouseenter" | "mouseleave" | "mousemove" | "mouseout" | "mouseover" | "mouseup", target: HtmlMarker, callback: (e: TargetedEvent) => void): void;
+        addOnce (eventType: "click" | "contextmenu" | "dblclick" | "drag" | "dragstart" | "dragend" | "keydown" | "keypress" | "keyup" | "mousedown" | "mouseenter" | "mouseleave" | "mousemove" | "mouseout" | "mouseover" | "mouseup", target: HtmlMarker, callback: (e: TargetedEvent) => void): void;
         /**
          * Adds a touch event to the Layer.
          * @param eventType The touch event name.
          * @param target The Layer to add the event for.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "touchstart" | "touchend" | "touchmove" | "touchcancel", target: atlas.layer.Layer, callback: (e: MapTouchEvent) => void): void;
+        addOnce (eventType: "touchstart" | "touchend" | "touchmove" | "touchcancel", target: atlas.layer.Layer, callback: (e: MapTouchEvent) => void): void;
         /**
          * Adds a touch event to the Layer.
          * @param eventType The touch event name.
          * @param target The Layer to add the event for.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "layeradded" | "layerremoved", target: atlas.layer.Layer, callback: (e: atlas.layer.Layer) => void): void;
+        addOnce (eventType: "layeradded" | "layerremoved", target: atlas.layer.Layer, callback: (e: atlas.layer.Layer) => void): void;
         /**
          * Adds a mouse event to the Layer.
          * @param eventType The mouse event name.
          * @param target The Layer to add the event for.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "mousedown" | "mouseup" | "mouseover" | "mousemove" | "click" | "dblclick" | "mouseout" | "mouseenter" | "mouseleave" | "contextmenu", target: atlas.layer.Layer, callback: (e: MapMouseEvent) => void): void;
+        addOnce (eventType: "mousedown" | "mouseup" | "mouseover" | "mousemove" | "click" | "dblclick" | "mouseout" | "mouseenter" | "mouseleave" | "contextmenu", target: atlas.layer.Layer, callback: (e: MapMouseEvent) => void): void;
         /**
          * Adds a wheel event to the Layer.
          * @param eventType The wheel event name.
          * @param target The Layer to add the event for.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "wheel", target: atlas.layer.Layer, callback: (e: MapMouseWheelEvent) => void): void;
+        addOnce (eventType: "wheel", target: atlas.layer.Layer, callback: (e: MapMouseWheelEvent) => void): void;
         /**
          * Adds an event to the Popup.
          * @param eventType The event name.
          * @param target The Popup to add the event for.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "drag" | "dragend" | "dragstart" | "open" | "close", target: Popup, callback: (e: TargetedEvent) => void): void;
+        addOnce (eventType: "drag" | "dragend" | "dragstart" | "open" | "close", target: Popup, callback: (e: TargetedEvent) => void): void;
         /**
          * Adds an event to the StyleControl
          * @param eventType The event name.
          * @param target The StyleControl to add the event for.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "styleselected", target: atlas.control.StyleControl, callback: (e: string) => void): void;
+        addOnce (eventType: "styleselected", target: atlas.control.StyleControl, callback: (e: string) => void): void;
         /**
          * Adds an event to the Shape.
          * @param eventType The event name.
          * @param target The Shape to add the event for.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "shapechanged", target: Shape, callback: (e: Shape) => void): void;
+        addOnce (eventType: "shapechanged", target: Shape, callback: (e: Shape) => void): void;
         /**
          * Adds an event to the Source.
          * @param eventType The event name.
          * @param target The Source to add the event for.
          * @param callback The event handler callback.
          */
-        addOnce(eventType: "sourceadded" | "sourceremoved", target: atlas.source.Source, callback: (e: atlas.source.Source) => void): void;
+        addOnce (eventType: "sourceadded" | "sourceremoved", target: atlas.source.Source, callback: (e: atlas.source.Source) => void): void;
         /**
          * Adds a listener to a single layer. Will add the event listeners to the layer's underlying Mapbox layers too.
          * @private
@@ -5352,7 +5362,7 @@ declare namespace atlas {
          * @param eventType The name of the event to invoke.
          * @param args The data to be passed to the callbacks.
          */
-        invoke(eventType: string, args: any): any;
+        invoke (eventType: string, args: any): any;
         /**
          * Invokes an event of the target.
          * This causes all event handlers on the target with the specified event name to be called.
@@ -5360,7 +5370,7 @@ declare namespace atlas {
          * @param target The target to invoke the event on. Supported target types are Layer, HtmlMarker, and Popup.
          * @param args The data to be passed to the callbacks. The data can be `null` but cannot be `undefined`.
          */
-        invoke(eventType: string, target: any, args: any): any;
+        invoke (eventType: string, target: any, args: any): any;
         /**
          * Invokes all listeners for the given event and layer.
          * @param eventType The event type to invoke.
@@ -5374,56 +5384,56 @@ declare namespace atlas {
          * @param eventType The event name.
          * @param callback The event handler callback.
          */
-        remove(eventType: string, callback: (e: void | atlas.layer.Layer | MapEvent | MapDataEvent | MapMouseEvent | MapTouchEvent | MapMouseWheelEvent | atlas.source.Source | string | MapConfiguration) => void): void;
+        remove (eventType: string, callback: (e: void | atlas.layer.Layer | MapEvent | MapDataEvent | MapMouseEvent | MapTouchEvent | MapMouseWheelEvent | atlas.source.Source | string | MapConfiguration) => void): void;
         /**
          * Removes an event listener from the DataSource(s).
          * @param eventType The event name.
          * @param target The DataSource(s) to remove the event for.
          * @param callback The event handler callback.
          */
-        remove(eventType: string, target: atlas.source.DataSource | atlas.source.DataSource[], callback: (e: atlas.source.DataSource | Shape[]) => void): void;
+        remove (eventType: string, target: atlas.source.DataSource | atlas.source.DataSource[], callback: (e: atlas.source.DataSource | Shape[]) => void): void;
         /**
          * Removes an event listener from the HtmlMarker(s).
          * @param eventType The event name.
          * @param target The HtmlMarker(s) to remove the event for.
          * @param callback The event handler callback.
          */
-        remove(eventType: string, target: HtmlMarker | HtmlMarker[], callback: (e: TargetedEvent) => void): void;
+        remove (eventType: string, target: HtmlMarker | HtmlMarker[], callback: (e: TargetedEvent) => void): void;
         /**
          * Removes an event listener from the Layer(s).
          * @param eventType The event name.
          * @param target The Layer(s) to remove the event for.
          * @param callback The event handler callback.
          */
-        remove(eventType: string, target: atlas.layer.Layer | atlas.layer.Layer[], callback: (e: void | MapMouseEvent | MapTouchEvent | MapMouseWheelEvent | atlas.layer.Layer) => void): void;
+        remove (eventType: string, target: atlas.layer.Layer | atlas.layer.Layer[], callback: (e: void | MapMouseEvent | MapTouchEvent | MapMouseWheelEvent | atlas.layer.Layer) => void): void;
         /**
          * Removes an event listener from the Popup(s).
          * @param eventType The event name.
          * @param target The Popup(s) to remove the event for.
          * @param callback The event handler callback.
          */
-        remove(eventType: string, target: Popup | Popup[], callback: (e: TargetedEvent) => void): void;
+        remove (eventType: string, target: Popup | Popup[], callback: (e: TargetedEvent) => void): void;
         /**
          * Removes an event to the StyleControl
          * @param eventType The event name.
          * @param target The StyleControl to add the event for.
          * @param callback The event handler callback.
          */
-        remove(eventType: string, target: atlas.control.StyleControl, callback: (e: string) => void): void;
+        remove (eventType: string, target: atlas.control.StyleControl, callback: (e: string) => void): void;
         /**
          * Removes an event listener from the Shape(s).
          * @param eventType The event name.
          * @param target The Shapes(s) to remove the event for.
          * @param callback The event handler callback.
          */
-        remove(eventType: string, target: Shape | Shape[], callback: (e: Shape) => void): void;
+        remove (eventType: string, target: Shape | Shape[], callback: (e: Shape) => void): void;
         /**
          * Removes an event listener from the Source(s).
          * @param eventType The event name.
          * @param target The Source(s) to remove the event for.
          * @param callback The event handler callback.
          */
-        remove(eventType: string, target: atlas.source.Source | atlas.source.Source[], callback: (e: atlas.source.Source) => void): void;
+        remove (eventType: string, target: atlas.source.Source | atlas.source.Source[], callback: (e: atlas.source.Source) => void): void;
     }
 
     /**
@@ -5560,20 +5570,20 @@ declare namespace atlas {
          */
         move(layer: string | atlas.layer.Layer, before?: string | atlas.layer.Layer): void;
         /**
-         * Retrieve all Shapes and GeoJSON features that are visible on the map that are in a DataSource or VectorTileSource.
-         * Shape objects are editable, while Feature objects are not editable and either reside in a VectorTileSource or represent a cluster point.
-         * Clusters have the following properties:
-         * <p>cluster: `boolean` - Indicates that the point is a cluster.
-         * This will be set to true if Point object represents a cluster.
-         * All other point objects are unlikely to have this value unless
-         * a property with this same name was added to the Point property data from your app.</p>
-         * <p>cluster_id: `string` - A unique id for the cluster.</p>
-         * <p>point_count: `number` - The number of points inside the cluster.</p>
-         * <p>point_count_abbreviated: `string` - An abbreviated string version of the point count. i.e. `"10K"`</p>
-         * Features/Shapes that are not visible or who's layer zoom range does not include the current zoom level will not be returned.
-         * Symbol features/Shapes that have been hidden due to text or icon collisions are not included.
-         * Features/Shapes from all other layers are included even if they have no contribution to the map rendering, e.g. alpha set to zero.
-         * The topmost rendered features/shapes appears first in the returned array and subsequent features are sorted in descending z-order.
+          * Retrieve all Shapes and GeoJSON features that are visible on the map that are in a DataSource or VectorTileSource.
+          * Shape objects are editable, while Feature objects are not editable and either reside in a VectorTileSource or represent a cluster point.
+          * Clusters have the following properties:<br />
+          * `cluster`: `boolean` - Indicates that the point is a cluster.
+          * This will be set to true if Point object represents a cluster.
+          * All other point objects are unlikely to have this value unless
+          * a property with this same name was added to the Point property data from your app.<br />
+          * `cluster_id`: `string` - A unique id for the cluster.<br />
+          * `point_count`: `number` - The number of points inside the cluster.<br />
+          * `point_count_abbreviated`: `string` - An abbreviated string version of the point count. i.e. `"10K"`<br />
+          * Features/Shapes that are not visible or who's layer zoom range does not include the current zoom level will not be returned.
+          * Symbol features/Shapes that have been hidden due to text or icon collisions are not included.
+          * Features/Shapes from all other layers are included even if they have no contribution to the map rendering, e.g. alpha set to zero.
+          * The topmost rendered features/shapes appears first in the returned array and subsequent features are sorted in descending z-order.
          * @param geometry A Position, Point, or BoundingBox that returned features must intersect. If not specified the whole visible world is used.
          * @param layers An array of layers or their ids to limit the query to.
          * @param filter A expression to filter the returned features by.
@@ -5697,14 +5707,14 @@ declare namespace atlas {
          */
         size: number;
         /**
-         * The state of the tile.
-         * <p>`"loading"`: Tile data is in the process of loading.</p>
-         * <p>`"loaded"`: Tile data has been loaded.</p>
-         * <p>`"reloading"`: Tile data has been loaded and is being updated.</p>
-         * <p>`"unloaded"`: The data has been deleted.</p>
-         * <p>`"errored"`: Tile data was not loaded because of an error.<p>
-         * <p>`"expired"`: Tile data was previously loaded, but has expired per its HTTP headers
-         * and is in the process of refreshing.</p>
+         * The state of the tile.<br />
+         * `"loading"`: Tile data is in the process of loading.<br />
+         * `"loaded"`: Tile data has been loaded.<br />
+         * `"reloading"`: Tile data has been loaded and is being updated.<br />
+         * `"unloaded"`: The data has been deleted.<br />
+         * `"errored"`: Tile data was not loaded because of an error.<br />
+         * `"expired"`: Tile data was previously loaded, but has expired per its HTTP headers
+         * and is in the process of refreshing.
          */
         state: "loading" | "loaded" | "reloading" | "unloaded" | "errored" | "expired";
     }
@@ -5837,14 +5847,14 @@ declare namespace atlas {
          * An array of Shape and Feature objects that the mouse event occurred on.
          * Shape objects are editable, while Feature objects are not editable
          * and either reside in a VectorTileSource or represent a cluster point.
-         * Clusters have the following properties:
-         * <p>cluster: `boolean` - Indicates that the point is a cluster.
+         * Clusters have the following properties:<br />
+         * `cluster`: `boolean` - Indicates that the point is a cluster.
          * This will be set to true if Point object represents a cluster.
          * All other point objects are unlikely to have this value unless
-         * a property with this same name was added to the Point property data from your app.</p>
-         * <p>cluster_id: `string` - A unique id for the cluster.</p>
-         * <p>point_count: `number` - The number of points inside the cluster.</p>
-         * <p>point_count_abbreviated: `string` - An abbreviated string version of the point count. i.e. `"10K"`</p>
+         * a property with this same name was added to the Point property data from your app.<br />
+         * `cluster_id`: `string` - A unique id for the cluster.<br />
+         * `point_count`: `number` - The number of points inside the cluster.<br />
+         * `point_count_abbreviated`: `string` - An abbreviated string version of the point count. i.e. `"10K"`
          */
         shapes?: Array<atlas.data.Feature<atlas.data.Geometry, any> | atlas.Shape>;
         /**