@artstesh/maps 8.0.0 → 9.0.2

package/dist/index.d.ts

@@ -1,5 +1,1722 @@
+import { DefaultsOptions } from 'ol/interaction/defaults';
+import { Feature, MapBrowserEvent, Map as Map$1 } from 'ol';
+export { Feature } from 'ol';
+import { Geometry } from 'ol/geom';
+export { Geometry, LineString, Point } from 'ol/geom';
+import { Control } from 'ol/control';
+import { Options } from 'ol/control/Control';
+import * as i0 from '@angular/core';
+import { OnDestroy, OnInit, AfterViewInit, TemplateRef, ElementRef, ChangeDetectorRef } from '@angular/core';
+import Map from 'ol/Map';
+import { Subscription } from 'rxjs';
+import { PostboyService, IPostboyDependingService, PostboyGenericMessage, PostboyAbstractRegistrator, PostboyCallbackMessage, PostboyExecutor } from '@artstesh/postboy';
+import Style, { StyleFunction, StyleLike } from 'ol/style/Style';
+export { StyleLike } from 'ol/style/Style';
+import { Dictionary } from '@artstesh/collections';
+import { XYZ, Raster } from 'ol/source';
+import TileLayer from 'ol/layer/Tile';
+import TileSource from 'ol/source/Tile';
+import VectorSource from 'ol/source/Vector';
+import { Vector } from 'ol/layer';
+import Cluster from 'ol/source/Cluster';
+import Static from 'ol/source/ImageStatic';
+import ImageLayer from 'ol/layer/Image';
+import { Text } from 'ol/style';
+export { Fill, RegularShape, Stroke, Style, Text } from 'ol/style';
+import Overlay, { Options as Options$1 } from 'ol/Overlay';
+export { FeatureLike } from 'ol/Feature';
+import * as Circle from 'ol/style/Circle';
+export { Circle as CircleStyle };
+
+declare enum MapLyrs {
+    Hybrid = 1,
+    Satellite = 2,
+    Streets = 3,
+    Terrain = 4
+}
+declare class MapLyrsLabel {
+    private static lyrs;
+    static get(lyrs: MapLyrs): string;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Represents the configurable settings for a map instance, providing
+ * options for center coordinates, zoom levels, map layers, and language.
  */
-/// <amd-module name="maps-components" />
-export * from './public-api';
+declare class MapSettings {
+    center: number[];
+    maxZoom: number;
+    minZoom: number;
+    zoom: number;
+    lyrs: MapLyrs;
+    language: string;
+    osmOpacity: number;
+    interactionSettings: DefaultsOptions;
+    static copy(model: MapSettings): MapSettings;
+    /**
+     * Updates the interaction settings of the map and returns a new MapSettings instance
+     * with the updated settings.
+     *
+     * @param {DefaultsOptions} interactionSettings - The new interaction settings to be applied.
+     * @return {MapSettings} A new MapSettings instance with the updated interaction settings.
+     */
+    setInteractionSettings(interactionSettings: DefaultsOptions): MapSettings;
+    /**
+     * Sets the center for the map settings.
+     *
+     * @param {number[]} center - A two-element array representing the latitude and longitude of the map's center.
+     * @return {MapSettings} A new MapSettings object with the updated center.
+     */
+    setCenter(center: number[]): MapSettings;
+    /**
+     * Sets the maximum zoom level for the map.
+     *
+     * @param {number} maxZoom - The maximum zoom level to be set.
+     * @return {MapSettings} A new instance of MapSettings with the updated maximum zoom level.
+     */
+    setMaxZoom(maxZoom: number): MapSettings;
+    /**
+     * Sets the minimum zoom level for the map settings.
+     *
+     * @param {number} minZoom The minimum zoom level to be set. Must be a valid numeric value.
+     * @return {MapSettings} A new MapSettings object with the updated minimum zoom level.
+     */
+    setMinZoom(minZoom: number): MapSettings;
+    /**
+     * Adjusts the zoom level of the map by setting the specified value.
+     *
+     * @param {number} zoom - The desired zoom level to be set.
+     * @return {MapSettings} A new MapSettings instance with the updated zoom level.
+     */
+    setZoom(zoom: number): MapSettings;
+    /**
+     * Sets the layers in the map settings with the provided layers.
+     *
+     * @param {MapLyrs} lyrs - The layers to be set in the map settings.
+     * @return {MapSettings} A new instance of MapSettings with the updated layers.
+     */
+    setLyrs(lyrs: MapLyrs): MapSettings;
+    /**
+     * Updates the language setting for the map configuration and returns a new instance with the updated language.
+     *
+     * @param {string} language - The language to be set for the map configuration.
+     * @return {MapSettings} A new instance of MapSettings with the updated language.
+     */
+    setLanguage(language: string): MapSettings;
+    /**
+     * Sets the opacity level for the OpenStreetMap layer.
+     *
+     * @param {number} osmOpacity - The opacity value for the OpenStreetMap layer, where 0 is fully transparent and 1 is fully opaque.
+     * @return {MapSettings} A new MapSettings instance with the updated OpenStreetMap opacity.
+     */
+    setOsmOpacity(osmOpacity: number): MapSettings;
+    /**
+     * Compares the current MapSettings instance with another to determine if they are identical.
+     *
+     * @param {MapSettings} model - The MapSettings instance to compare with the current instance.
+     * @return {boolean} Returns true if both MapSettings instances have the same properties and values; otherwise, false.
+     */
+    isSame(model: MapSettings): boolean;
+}
+
+declare class MarkerModel {
+    readonly lat: number;
+    readonly lng: number;
+    info?: {
+        [id: string]: any;
+    } | undefined;
+    readonly id: string | number;
+    constructor(lat: number, lng: number, id?: string | number, info?: {
+        [id: string]: any;
+    } | undefined);
+    private _feature;
+    get feature(): Feature<Geometry>;
+    private getFeature;
+}
+
+declare class PolygonModel {
+    info?: {
+        [id: string]: any;
+    } | undefined;
+    readonly id: string | number;
+    readonly lat: number;
+    readonly lng: number;
+    private constructor();
+    private _feature;
+    get feature(): Feature<Geometry>;
+    static fromGeoJson(id: string | number, json: string, info?: {
+        [id: string]: any;
+    }): PolygonModel;
+    static fromWKT(id: string | number, wkt: string, info?: {
+        [id: string]: any;
+    }): PolygonModel;
+    static circle(id: string | number, lat: number, lng: number, radius: number, vertices?: number, info?: {
+        [id: string]: any;
+    }): PolygonModel;
+}
+
+/**
+ * Enum representing various drawing types.
+ *
+ * This enumeration is used to define the types of drawable shapes
+ * within a specific drawing context. Each member corresponds to
+ * a specific type of drawing.
+ *
+ * Members:
+ * - `Polygon`: Represents a polygonal shape (e.g., triangle, pentagon, etc.).
+ * - `Circle`: Represents a circular shape.
+ * - `Square`: Represents a square shape.
+ * - `Box`: Represents a rectangular box shape.
+ */
+declare enum DrawingType {
+    Polygon = 1,
+    Circle = 2,
+    Square = 3,
+    Box = 4,
+    LineString = 5
+}
+
+/**
+ * An enumeration representing different formats for feature outputs.
+ * This can be used to specify the desired output format when dealing with geospatial data.
+ *
+ * Enumerators:
+ * - GeoJson: Represents the GeoJSON format for geospatial data.
+ * - WKT: Represents the Well-Known Text (WKT) format for geospatial data.
+ */
+declare enum FeatureOutputFormat {
+    GeoJson = 1,
+    WKT = 2,
+    Geometry = 3
+}
+
+/**
+ *
+ * A control is a visible widget with a DOM element in a fixed position on the screen. They can involve user input (buttons), or be informational only; the position is determined using CSS. By default, these are placed in the container with CSS class name ol-overlaycontainer-stopevent, but can use any outside DOM element.
+ * This is the base class for controls. You can use it for simple custom controls by creating the element with listeners, creating an instance:
+ * var myControl = new Control({element: myElement}); and then adding this to the map.
+ * The main advantage of having this as a control rather than a simple separate DOM element is that preventing propagation is handled for you. Controls will also be objects in a module:ol/Collection~Collection, so you can use their methods.
+ * You can also extend this base for your own control class. See examples/custom-controls for an example of how to do this.
+ */
+declare class MapControl extends Control {
+    constructor(options: Options);
+}
+
+declare class MapConstants {
+    static FeatureInfo: string;
+    static DrawingLayerId: string;
+    static FeatureLayerName: string;
+}
+
+/**
+ * Represents a position and view configuration on a map.
+ *
+ * This interface is utilized to store and retrieve geographic and viewport details,
+ * including location coordinates, zoom level, and map extent.
+ *
+ * Properties:
+ * - `latitude`: The latitude coordinate of the map's center point.
+ * - `longitude`: The longitude coordinate of the map's center point.
+ * - `zoom`: The zoom level of the map's view.
+ * - `extent`: The geographical rectangular bounds defining the visible area of the map, represented as an array of coordinates [minX, minY, maxX, maxY].
+ */
+interface MapPosition {
+    latitude: number;
+    longitude: number;
+    zoom: number;
+    extent: number[];
+}
+
+declare class DestructibleComponent implements OnDestroy {
+    protected subs: Subscription[];
+    protected onDestroy?: () => void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DestructibleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DestructibleComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class MapPostboyService extends PostboyService {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapPostboyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MapPostboyService>;
+}
+
+declare class MapManagementService implements IPostboyDependingService {
+    private postboy;
+    private map?;
+    private layers;
+    constructor(postboy: MapPostboyService);
+    up(): void;
+    private observeLayerQuery;
+    private observeAddTile;
+    private observeImageLayer;
+    private observeMapRender;
+    private observeAddLayer;
+    private observePlaceFeatures;
+    private observeRemoveLayer;
+    private observeFeaturesInArea;
+    private observeFeaturesInPoint;
+    private forEachLayer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapManagementService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MapManagementService>;
+}
+
+declare class MapStateService implements IPostboyDependingService {
+    private postboy;
+    private map?;
+    constructor(postboy: MapPostboyService);
+    up(): void;
+    getMapPosition(): MapPosition | null;
+    private observeMapRendering;
+    private observeCenter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MapStateService>;
+}
+
+interface IIdentified {
+    id: string | number;
+}
+
+/**
+ * Represents an event triggered by a click on a map, containing information about the
+ * click's location, relevant entities, and features present at the clicked position.
+ *
+ * @extends {PostboyGenericMessage}
+ */
+declare class MapClickEvent extends PostboyGenericMessage {
+    coordinates: number[];
+    entities: {
+        [layer: string]: IIdentified[];
+    };
+    features: {
+        [layer: string]: Feature<Geometry>[];
+    };
+    static readonly ID = "ee31a86c-e838-4531-8399-983753a354df";
+    /**
+     * Creates an instance of this class with the provided coordinates, entities, and features.
+     *
+     * @param {number[]} coordinates - An array representing the coordinates.
+     * @param {{ [layer: string]: IIdentified[] }} entities - A mapping of layer names to arrays of IIdentified entities.
+     * @param {{ [layer: string]: Feature<Geometry>[] }} features - A mapping of layer names to arrays of features with geometry.
+     */
+    constructor(coordinates: number[], entities: {
+        [layer: string]: IIdentified[];
+    }, features: {
+        [layer: string]: Feature<Geometry>[];
+    });
+}
+
+declare class MapClickService implements IPostboyDependingService {
+    private postboy;
+    private map?;
+    constructor(postboy: MapPostboyService);
+    up(): void;
+    onClick(ev: MapBrowserEvent<PointerEvent>): MapClickEvent;
+    private observeMapRender;
+    private getFeatureCollectionWithInner;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapClickService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MapClickService>;
+}
+
+declare class MapFeatureService implements IPostboyDependingService {
+    private postboy;
+    private map?;
+    private fitPolygonsWaiting?;
+    constructor(postboy: MapPostboyService);
+    up(): void;
+    private observeMapRender;
+    private observePointerMove;
+    private observeFitToFeatures;
+    private observeFitToPolygons;
+    private fitToGeometries;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapFeatureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MapFeatureService>;
+}
+
+declare class DrawingService implements IPostboyDependingService {
+    private postboy;
+    private drawInteraction?;
+    private map?;
+    constructor(postboy: MapPostboyService);
+    up(): void;
+    private observeSelectArea;
+    private observeDrawing;
+    private onEnd;
+    private observeMapRender;
+    private draw;
+    private observeCancelation;
+    private clearInteraction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DrawingService>;
+}
+
+declare class FeatureModificationService implements IPostboyDependingService {
+    private postboy;
+    private modify?;
+    private translate?;
+    private map?;
+    constructor(postboy: MapPostboyService);
+    up(): void;
+    private observeModification;
+    private initFeature;
+    private addModify;
+    private addDragging;
+    private onModified;
+    private observeMapRender;
+    private defineLayer;
+    private observeCancelation;
+    private clearInteraction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureModificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FeatureModificationService>;
+}
+
+declare class ControlsService implements IPostboyDependingService {
+    private postboy;
+    private map?;
+    constructor(postboy: MapPostboyService);
+    up(): void;
+    private observeMapRender;
+    private observeAdding;
+    private observeRemoving;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ControlsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ControlsService>;
+}
+
+declare class MessageRegistratorService extends PostboyAbstractRegistrator {
+    private state;
+    constructor(service: MapPostboyService, management: MapManagementService, state: MapStateService, mapFeature: MapFeatureService, interaction: MapClickService, drawing: DrawingService, featureModification: FeatureModificationService, controls: ControlsService);
+    protected _up(): void;
+    private setExecutors;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageRegistratorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageRegistratorService>;
+}
+
+declare class MapPlateFactory {
+    build(settings: MapSettings): Map;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapPlateFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MapPlateFactory>;
+}
+
+/**
+ * Class representing settings for a tile layer.
+ */
+declare class TileLayerSettings {
+    /**
+     * The maximum zoom level for a map view.
+     *
+     * @type {number}
+     * @default 19
+     */
+    maxZoom: number;
+    /**
+     * The minimum zoom level allowed.
+     *
+     * @type {number}
+     */
+    minZoom: number;
+    /**
+     * The opacity of an element.
+     *
+     * @type {number}
+     * @default 0.6
+     */
+    opacity: number;
+    /**
+     * Represents the tiles URL.
+     * @typedef {string} url
+     *
+     * @example
+     * 'https://example.ex/{z}/{x}/{y}.png'
+     */
+    url: string;
+    /**
+     * The projection of the coordinate system.
+     *
+     * @type {string}
+     * @default 'EPSG:3857'
+     */
+    projection: string;
+    /**
+     * Additional headers that should be added to each tile request
+     *
+     * @type {Record<string, string>}
+     * @default An empty array
+     */
+    requestHeaders: Record<string, string> | null;
+    /**
+     * Creates a copy of the given tile layer settings.
+     *
+     * @param {TileLayerSettings} model - The tile layer settings to be copied.
+     * @return {TileLayerSettings} - A new instance of TileLayerSettings with the same properties as the model.
+     */
+    static copy(model: TileLayerSettings): TileLayerSettings;
+    /**
+     * Sets the URL of the TileLayerSettings object.
+     *
+     * @param {string} url - The URL to be set.
+     * @return {TileLayerSettings} - The updated TileLayerSettings object.
+     */
+    setUrl(url: string): TileLayerSettings;
+    /**
+     * Sets the requestHeaders of the TileLayerSettings object.
+     *
+     * @param {Record<string, string>} requestHeaders - The headers which should be provided.
+     * @return {TileLayerSettings} - The updated TileLayerSettings object.
+     */
+    setRequestHeaders(requestHeaders: Record<string, string>): TileLayerSettings;
+    /**
+     * Sets the maximum zoom level for the tile layer.
+     *
+     * @param {number} maxZoom - The maximum zoom level.
+     * @returns {TileLayerSettings} - The updated tile layer settings object.
+     */
+    setMaxZoom(maxZoom: number): TileLayerSettings;
+    /**
+     * Sets the minimum zoom level for the Tile Layer.
+     *
+     * @param {number} minZoom - The minimum zoom level to be set.
+     * @return {TileLayerSettings} The modified TileLayerSettings object with the updated minimum zoom level.
+     */
+    setMinZoom(minZoom: number): TileLayerSettings;
+    /**
+     * Sets the opacity of the TileLayerSettings.
+     *
+     * @param {number} opacity - The opacity value to set. Must be a number between 0 and 1.
+     * @return {TileLayerSettings} - A new instance of TileLayerSettings with the opacity set.
+     */
+    setOpacity(opacity: number): TileLayerSettings;
+    /**
+     * Sets the projection for the tile layer settings.
+     *
+     * @param {string} projection - The desired projection for the tile layer settings.
+     * @return {TileLayerSettings} - The updated tile layer settings with the new projection.
+     */
+    setProjection(projection: string): TileLayerSettings;
+    /**
+     * Checks if the current instance of TileLayerSettings is equal to the given model.
+     * @param {TileLayerSettings} model - The model to compare against.
+     * @return {boolean} - True if all properties of the current instance matches the properties of the model;
+     *                    otherwise, false.
+     */
+    isSame(model: TileLayerSettings): boolean;
+}
+
+declare class TileLayerFactory {
+    build(settings: TileLayerSettings): TileLayer<XYZ>;
+    private getTileFunc;
+    private tileLoader;
+    private getNormalizedCoord;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TileLayerFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TileLayerFactory>;
+}
+
+declare class TileLayerComponent extends DestructibleComponent {
+    private postboy;
+    private factory;
+    layer?: TileLayer<XYZ>;
+    constructor(postboy: MapPostboyService, factory: TileLayerFactory);
+    _settings: TileLayerSettings;
+    set settings(value: TileLayerSettings | undefined);
+    ngOnInit(): void;
+    onDestroy: () => void;
+    private initLayer;
+    private removeLayer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TileLayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TileLayerComponent, "art-tile-layer", never, { "settings": { "alias": "settings"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class OsmTileLayerComponent extends DestructibleComponent implements OnInit {
+    layer?: TileLayer<TileSource>;
+    constructor();
+    private _url;
+    private _map?;
+    private _opacity;
+    set url(value: string | undefined);
+    set opacity(value: number);
+    set map(value: Map$1 | undefined);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private initLayer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OsmTileLayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OsmTileLayerComponent, "art-osm-tile-layer", never, { "url": { "alias": "url"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "map": { "alias": "map"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A layer that is responsible for showing and styling main features on the map, such as markers and polygons
+ */
+declare class FeatureLayerSettings {
+    /**
+     * The identifier of the field, it is autogenerated by default, but can be set manually
+     */
+    name: string;
+    /**
+     * The priority of showing - layers with higher zIndex cover others in case of collisions
+     */
+    zIndex: number;
+    /**
+     The maximum view zoom level (inclusive) at which this layer will be visible.
+  
+     @type {number}
+     @default 19
+     */
+    maxZoom: number;
+    /**
+     The minimum view zoom level (exclusive) at which this layer will be visible.
+  
+     @type {number}
+     */
+    minZoom: number;
+    /**
+     * The styling definition of layer's features. The easiest way is to use {@link PolygonStyleHelper},{@link MarkerStyleHelper}
+     */
+    style?: Style | StyleFunction;
+    /**
+     * Defines the style applied to a feature when it is hovered over.
+     *
+     * This property can accept either a static style object or a dynamic style function.
+     * When a `StyleFunction` is provided, it will determine the style dynamically
+     * based on the feature being hovered.
+     *
+     * The style is applied temporarily, specifically for the hovered feature,
+     * and overrides any default or predefined styles for that feature.
+     *
+     * Optional property.
+     *
+     * @type {(Style | StyleFunction)}
+     */
+    featureHoverStyle?: Style | StyleFunction;
+    /**
+     * Copies the given FeatureLayerSettings object
+     *
+     * @param {FeatureLayerSettings} model - The FeatureLayerSettings object to be copied
+     * @returns {FeatureLayerSettings} - A copy of the FeatureLayerSettings object
+     */
+    static copy(model: FeatureLayerSettings): FeatureLayerSettings;
+    /**
+     * Sets the z-index value for the FeatureLayerSettings object.
+     *
+     * @param {number} zIndex - The new z-index value.
+     * @return {FeatureLayerSettings} - The updated FeatureLayerSettings object.
+     */
+    setZIndex(zIndex: number): FeatureLayerSettings;
+    /**
+     * Sets the name of the FeatureLayerSettings.
+     *
+     * @param {string} name - The name to set for the FeatureLayerSettings.
+     *
+     * @return {FeatureLayerSettings} - The updated FeatureLayerSettings object with the new name.
+     */
+    setName(name: string): FeatureLayerSettings;
+    /**
+     * Sets the maximum zoom level for the FeatureLayerSettings.
+     *
+     * @param {number} maxZoom - The maximum zoom level.
+     * @return {FeatureLayerSettings} - The updated FeatureLayerSettings object.
+     */
+    setMaxZoom(maxZoom: number): FeatureLayerSettings;
+    /**
+     * Sets the minimum zoom level for the feature layer.
+     *
+     * @param {number} minZoom The minimum zoom level to be set.
+     * @returns {FeatureLayerSettings} The updated feature layer settings object.
+     */
+    setMinZoom(minZoom: number): FeatureLayerSettings;
+    /**
+     * Sets the style for the FeatureLayerSettings object.
+     *
+     * @param {Style | StyleFunction} style - The new style to set. It can be either a Style object or a StyleFunction.
+     * @return {FeatureLayerSettings} - The updated FeatureLayerSettings object with the new style.
+     */
+    setStyle(style: Style | StyleFunction): FeatureLayerSettings;
+    /**
+     * Sets the style to apply to features when they are hovered over.
+     *
+     * @param {Style | StyleFunction} featureHoverStyle - The style or style function to use for hovered features.
+     * @return {FeatureLayerSettings} A new instance of FeatureLayerSettings with the updated hover style.
+     */
+    setFeatureHoverStyle(featureHoverStyle: Style | StyleFunction): FeatureLayerSettings;
+    /**
+     * Checks if the given FeatureLayerSettings object is identical to the current object.
+     *
+     * @param {FeatureLayerSettings} model - The FeatureLayerSettings object to compare with.
+     * @return {boolean} - Returns true if the given object is identical to the current object, otherwise false.
+     */
+    isSame(model: FeatureLayerSettings): boolean;
+}
+
+declare class FeatureLayerFactory {
+    build(settings: FeatureLayerSettings): Vector<VectorSource<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureLayerFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FeatureLayerFactory>;
+}
+
+declare class FeatureLayerComponent extends DestructibleComponent implements OnInit {
+    private postboy;
+    private factory;
+    layer: Vector<VectorSource<any>> | null;
+    constructor(postboy: MapPostboyService, factory: FeatureLayerFactory);
+    _settings: FeatureLayerSettings;
+    set settings(value: FeatureLayerSettings | undefined);
+    ngOnInit(): void;
+    onDestroy: () => void;
+    private initLayer;
+    private removeLayer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureLayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FeatureLayerComponent, "art-feature-layer", never, { "settings": { "alias": "settings"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ClusterLayerSettings {
+    name: string;
+    zIndex: number;
+    /**
+     * The maximum view zoom level (inclusive) at which this layer will be visible.
+     *
+     * @type {number}
+     * @default 19
+     */
+    maxZoom: number;
+    /**
+     * The minimum view zoom level (exclusive) at which this layer will be visible.
+     *
+     * @type {number}
+     */
+    minZoom: number;
+    /**
+     * Distance in pixels within which features will be clustered together.
+     *
+     * @type {number}
+     */
+    distance: number;
+    bbox: boolean;
+    clusterCancel: number;
+    style?: (features: IIdentified[]) => Style;
+    /**
+     * Creates a copy of the given ClusterLayerSettings object.
+     *
+     * @param {ClusterLayerSettings} model - The ClusterLayerSettings object to be copied.
+     * @returns {ClusterLayerSettings} - A new ClusterLayerSettings object that is a copy of the original object.
+     */
+    static copy(model: ClusterLayerSettings): ClusterLayerSettings;
+    /**
+     * Set the z-index for the ClusterLayer.
+     *
+     * @param {number} zIndex - The new z-index for the ClusterLayer.
+     * @return {ClusterLayerSettings} - The updated ClusterLayerSettings object.
+     */
+    setZIndex(zIndex: number): ClusterLayerSettings;
+    /**
+     * Sets the distance value for ClusterLayerSettings.
+     *
+     * @param {number} distance - The distance value to be set.
+     * @return {ClusterLayerSettings} - The modified ClusterLayerSettings object.
+     */
+    setDistance(distance: number): ClusterLayerSettings;
+    /**
+     * Sets the name of the ClusterLayerSettings object.
+     *
+     * @param {string} name - The name to set for the ClusterLayerSettings.
+     * @return {ClusterLayerSettings} - A new ClusterLayerSettings object with the updated name.
+     */
+    setName(name: string): ClusterLayerSettings;
+    /**
+     * Sets the maximum zoom level for the Cluster Layer.
+     *
+     * @param {number} maxZoom - The maximum zoom level to be set.
+     * @return {ClusterLayerSettings} - The updated ClusterLayerSettings object.
+     */
+    setMaxZoom(maxZoom: number): ClusterLayerSettings;
+    /**
+     * Sets the minimum zoom level for the ClusterLayerSettings.
+     *
+     * @param {number} minZoom - The minimum zoom level to set.
+     * @return {ClusterLayerSettings} - The updated ClusterLayerSettings object.
+     */
+    setMinZoom(minZoom: number): ClusterLayerSettings;
+    /**
+     * Sets the cluster cancel number for the ClusterLayerSettings.
+     *
+     * @param {number} clusterCancel - The new cluster cancel number.
+     * @returns {ClusterLayerSettings} - The updated ClusterLayerSettings object.
+     */
+    setClusterCancel(clusterCancel: number): ClusterLayerSettings;
+    /**
+     * Sets the value of 'bbox' property in the ClusterLayerSettings object.
+     *
+     * @param {boolean} bbox - A boolean value indicating whether to include bounding box calculation in the cluster layer settings.
+     * @returns {ClusterLayerSettings} - The updated ClusterLayerSettings object with the newly set 'bbox' value.
+     */
+    setBbox(bbox: boolean): ClusterLayerSettings;
+    /**
+     * Sets the style for the ClusterLayerSettings.
+     *
+     * @param {function} style - A function that takes an array of identified features as input and returns a Style or StyleFunction.
+     *
+     * @return {ClusterLayerSettings} - The updated ClusterLayerSettings object with the new style applied.
+     */
+    setStyle(style: (features: IIdentified[]) => Style | StyleFunction): ClusterLayerSettings;
+    /**
+     * Checks if the current ClusterLayerSettings object is the same as the specified model.
+     *
+     * @param {ClusterLayerSettings} model - The model to compare with the current object.
+     *
+     * @return {boolean} - Returns true if the current ClusterLayerSettings object is the same as the specified model, otherwise false.
+     */
+    isSame(model: ClusterLayerSettings): boolean;
+}
+
+declare class ClusterLayerManager {
+    private settings;
+    readonly layer: Vector<Cluster>;
+    private postboy;
+    constructor(settings: ClusterLayerSettings, layer: Vector<Cluster>, postboy: MapPostboyService);
+    private observeMapMovement;
+    private observeClick;
+    private checkClusterNecessity;
+}
+
+declare class ClusterLayerFactory {
+    build(settings: ClusterLayerSettings, postboy: MapPostboyService): ClusterLayerManager;
+    styleFunc(settings: ClusterLayerSettings): StyleFunction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClusterLayerFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClusterLayerFactory>;
+}
+
+/**
+ * Represents a cluster layer component.
+ */
+declare class ClusterLayerComponent extends DestructibleComponent implements OnInit {
+    private postboy;
+    private factory;
+    manager: ClusterLayerManager | null;
+    constructor(postboy: MapPostboyService, factory: ClusterLayerFactory);
+    _settings: ClusterLayerSettings;
+    /**
+     * Sets the settings for the cluster layer.
+     *
+     * @param {ClusterLayerSettings | undefined} value - The settings for the cluster layer.
+     */
+    set settings(value: ClusterLayerSettings | undefined);
+    ngOnInit(): void;
+    onDestroy: () => void;
+    private initLayer;
+    private removeLayer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClusterLayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClusterLayerComponent, "art-cluster-layer", never, { "settings": { "alias": "settings"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ImageLayerSettings {
+    /**
+     * Represents the tiles URL.
+     * @typedef {string} url
+     *
+     * @example
+     * 'https://example.ex/{z}/{x}/{y}.png'
+     */
+    url: string;
+    /**
+     * Use interpolated values when resampling.
+     * By default, linear interpolation is used when resampling.
+     * Set to false to use the nearest neighbor instead.
+     */
+    interpolate?: boolean;
+    /**
+     * The projection of the coordinate system.
+     *
+     * @type {string}
+     * @default 'EPSG:3857'
+     */
+    projection: string;
+    extent: number[];
+    /**
+     * Additional headers that should be added to each tile request
+     *
+     * @type {Record<string, string>}
+     * @default An empty array
+     */
+    requestHeaders: Record<string, string> | null;
+    /**
+     * Creates a copy of the given tile layer settings.
+     *
+     * @param {ImageLayerSettings} model - The tile layer settings to be copied.
+     * @return {ImageLayerSettings} - A new instance of ImageLayerSettings with the same properties as the model.
+     */
+    static copy(model: ImageLayerSettings): ImageLayerSettings;
+    /**
+     * Sets the URL of the ImageLayerSettings object.
+     *
+     * @param {string} url - The URL to be set.
+     * @return {ImageLayerSettings} - The updated ImageLayerSettings object.
+     */
+    setUrl(url: string): ImageLayerSettings;
+    /**
+     * Sets the interpolation state for the image layer settings.
+     *
+     * @param {boolean} [interpolate] - Use interpolated values when resampling.
+     * By default, linear interpolation is used when resampling.
+     * Set to false to use the nearest neighbor instead.
+     * @return {ImageLayerSettings} A new instance of ImageLayerSettings with the updated interpolation setting.
+     */
+    setInterpolate(interpolate?: boolean): ImageLayerSettings;
+    setExtent(extent: number[]): ImageLayerSettings;
+    /**
+     * Sets the requestHeaders of the ImageLayerSettings object.
+     *
+     * @param {Record<string, string>} requestHeaders - The headers which should be provided.
+     * @return {ImageLayerSettings} - The updated ImageLayerSettings object.
+     */
+    setRequestHeaders(requestHeaders: Record<string, string>): ImageLayerSettings;
+    /**
+     * Sets the maximum zoom level for the tile layer.
+     *
+     * @param {number} maxZoom - The maximum zoom level.
+     * @returns {ImageLayerSettings} - The updated tile layer settings object.
+     */
+    setMaxZoom(maxZoom: number): ImageLayerSettings;
+    /**
+     * Sets the minimum zoom level for the Tile Layer.
+     *
+     * @param {number} minZoom - The minimum zoom level to be set.
+     * @return {ImageLayerSettings} The modified ImageLayerSettings object with the updated minimum zoom level.
+     */
+    setMinZoom(minZoom: number): ImageLayerSettings;
+    /**
+     * Sets the opacity of the ImageLayerSettings.
+     *
+     * @param {number} opacity - The opacity value to set. Must be a number between 0 and 1.
+     * @return {ImageLayerSettings} - A new instance of ImageLayerSettings with the opacity set.
+     */
+    setOpacity(opacity: number): ImageLayerSettings;
+    /**
+     * Sets the projection for the tile layer settings.
+     *
+     * @param {string} projection - The desired projection for the tile layer settings.
+     * @return {ImageLayerSettings} - The updated tile layer settings with the new projection.
+     */
+    setProjection(projection: string): ImageLayerSettings;
+    /**
+     * Checks if the current instance of ImageLayerSettings is equal to the given model.
+     * @param {ImageLayerSettings} model - The model to compare against.
+     * @return {boolean} - True if all properties of the current instance matches the properties of the model;
+     *                    otherwise, false.
+     */
+    isSame(model: ImageLayerSettings): boolean;
+}
+
+declare class ImageLayerFactory {
+    build(settings: ImageLayerSettings): ImageLayer<Static>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageLayerFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImageLayerFactory>;
+}
+
+declare class ImageLayerComponent extends DestructibleComponent implements OnInit {
+    private postboy;
+    private factory;
+    layer?: ImageLayer<Static>;
+    constructor(postboy: MapPostboyService, factory: ImageLayerFactory);
+    _settings: ImageLayerSettings;
+    set settings(value: ImageLayerSettings | undefined);
+    ngOnInit(): void;
+    onDestroy: () => void;
+    private initLayer;
+    private removeLayer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageLayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageLayerComponent, "art-image-layer", never, { "settings": { "alias": "settings"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RasterTileLayerSettings {
+    /**
+     * The maximum zoom level for a map view.
+     *
+     * @type {number}
+     * @default 19
+     */
+    maxZoom: number;
+    /**
+     * The minimum zoom level allowed.
+     *
+     * @type {number}
+     */
+    minZoom: number;
+    /**
+     * The opacity of an element.
+     *
+     * @type {number}
+     * @default 0.6
+     */
+    opacity: number;
+    /**
+     * Represents the tiles URL.
+     * @typedef {string} url
+     *
+     * @example
+     * 'https://example.ex/{z}/{x}/{y}.png'
+     */
+    url: string;
+    /**
+     * The projection of the coordinate system.
+     *
+     * @type {string}
+     * @default 'EPSG:3857'
+     */
+    projection: string;
+    /**
+     * Additional headers that should be added to each tile request
+     *
+     * @type {Record<string, string>}
+     * @default An empty array
+     */
+    requestHeaders: Record<string, string> | null;
+    /**
+     * The priority of showing - layers with higher zIndex cover others in case of collisions
+     */
+    zIndex: number;
+    operation: (data: number[][] | ImageData[]) => number[] | ImageData;
+    /**
+     * Creates a copy of the given tile layer settings.
+     *
+     * @param {RasterTileLayerSettings} model - The tile layer settings to be copied.
+     * @return {RasterTileLayerSettings} - A new instance of RasterTileLayerSettings with the same properties as the model.
+     */
+    static copy(model: RasterTileLayerSettings): RasterTileLayerSettings;
+    /**
+     * Sets the URL of the RasterTileLayerSettings object.
+     *
+     * @param {string} url - The URL to be set.
+     * @return {RasterTileLayerSettings} - The updated RasterTileLayerSettings object.
+     */
+    setUrl(url: string): RasterTileLayerSettings;
+    /**
+     * Sets the operation to apply on raster tile data.
+     *
+     * @param {function} operation - A function that takes an input of either a two-dimensional array of numbers or an array of ImageData objects and returns either a one-dimensional array of numbers or an ImageData object.
+     * @return {RasterTileLayerSettings} A new instance of RasterTileLayerSettings with the updated operation.
+     */
+    setOperation(operation: (data: number[][] | ImageData[]) => number[] | ImageData): RasterTileLayerSettings;
+    /**
+     * Sets the requestHeaders of the RasterTileLayerSettings object.
+     *
+     * @param {Record<string, string>} requestHeaders - The headers which should be provided.
+     * @return {RasterTileLayerSettings} - The updated RasterTileLayerSettings object.
+     */
+    setRequestHeaders(requestHeaders: Record<string, string>): RasterTileLayerSettings;
+    /**
+     * Sets the maximum zoom level for the tile layer.
+     *
+     * @param {number} maxZoom - The maximum zoom level.
+     * @returns {RasterTileLayerSettings} - The updated tile layer settings object.
+     */
+    setMaxZoom(maxZoom: number): RasterTileLayerSettings;
+    /**
+     * Sets the z-index for the RasterTileLayerSettings.
+     *
+     * @param {number} zIndex - The new z-index to be assigned.
+     * @return {RasterTileLayerSettings} A new RasterTileLayerSettings instance with the updated z-index.
+     */
+    setZIndex(zIndex: number): RasterTileLayerSettings;
+    /**
+     * Sets the minimum zoom level for the Tile Layer.
+     *
+     * @param {number} minZoom - The minimum zoom level to be set.
+     * @return {RasterTileLayerSettings} The modified RasterTileLayerSettings object with the updated minimum zoom level.
+     */
+    setMinZoom(minZoom: number): RasterTileLayerSettings;
+    /**
+     * Sets the opacity of the RasterTileLayerSettings.
+     *
+     * @param {number} opacity - The opacity value to set. Must be a number between 0 and 1.
+     * @return {RasterTileLayerSettings} - A new instance of RasterTileLayerSettings with the opacity set.
+     */
+    setOpacity(opacity: number): RasterTileLayerSettings;
+    /**
+     * Sets the projection for the tile layer settings.
+     *
+     * @param {string} projection - The desired projection for the tile layer settings.
+     * @return {RasterTileLayerSettings} - The updated tile layer settings with the new projection.
+     */
+    setProjection(projection: string): RasterTileLayerSettings;
+    /**
+     * Checks if the current instance of RasterTileLayerSettings is equal to the given model.
+     * @param {RasterTileLayerSettings} model - The model to compare against.
+     * @return {boolean} - True if all properties of the current instance matches the properties of the model;
+     *                    otherwise, false.
+     */
+    isSame(model: RasterTileLayerSettings): boolean;
+}
+
+declare class RasterTileLayerFactory {
+    build(settings: RasterTileLayerSettings): ImageLayer<Raster>;
+    private getTileFunc;
+    private tileLoader;
+    private getNormalizedCoord;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RasterTileLayerFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RasterTileLayerFactory>;
+}
+
+declare class RasterTileLayerComponent extends DestructibleComponent {
+    private postboy;
+    private factory;
+    layer?: ImageLayer<Raster>;
+    constructor(postboy: MapPostboyService, factory: RasterTileLayerFactory);
+    _settings: RasterTileLayerSettings;
+    set settings(value: RasterTileLayerSettings | undefined);
+    ngOnInit(): void;
+    onDestroy: () => void;
+    private initLayer;
+    private removeLayer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RasterTileLayerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RasterTileLayerComponent, "art-raster-tile-layer", never, { "settings": { "alias": "settings"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapPlateComponent extends DestructibleComponent implements AfterViewInit {
+    private elementRef;
+    private postboy;
+    private mapFactory;
+    private registrator;
+    private detector;
+    contentRef: i0.InputSignal<TemplateRef<any>>;
+    private renderTryCount;
+    map: Map;
+    osmUrl: string;
+    drawingLayerSettings: FeatureLayerSettings;
+    constructor(elementRef: ElementRef, postboy: MapPostboyService, mapFactory: MapPlateFactory, registrator: MessageRegistratorService, detector: ChangeDetectorRef);
+    _settings: MapSettings;
+    set settings(value: MapSettings | undefined);
+    private initializeMap;
+    ngAfterViewInit(): void;
+    onDestroy: () => void;
+    private setOsm;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapPlateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapPlateComponent, "art-map-plate", never, { "contentRef": { "alias": "contentRef"; "required": true; "isSignal": true; }; "settings": { "alias": "settings"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a command to add a custom control to a map.
+ */
+declare class AddControlCommand extends PostboyGenericMessage {
+    item: MapControl;
+    static readonly ID = "2921fb19-f1c4-4bf4-97be-001f98241f3b";
+    /**
+     * Creates an instance of the class with the specified MapControl object.
+     *
+     * @param {MapControl} item - The MapControl object to be associated with the instance.
+     */
+    constructor(item: MapControl);
+}
+
+/**
+ * A command class that represents the action to close a tooltip.
+ */
+declare class CloseTooltipCommand extends PostboyGenericMessage {
+    tooltipId: string;
+    static readonly ID = "df687e26-7298-46d7-8911-d014801dafac";
+    /**
+     * Creates an instance of the class with the specified tooltip ID.
+     *
+     * @param {string} tooltipId - The unique identifier for the tooltip.
+     */
+    constructor(tooltipId: string);
+}
+
+/**
+ * Represents a command to start a drawing operation.
+ */
+declare class StartDrawingCommand extends PostboyCallbackMessage<string | null> {
+    type: DrawingType;
+    style: StyleLike;
+    format: FeatureOutputFormat;
+    static readonly ID = "4407e9ee-d6c3-4e77-8000-c1aae7433fb6";
+    /**
+     * Constructor for creating an instance of the class that represents a drawing feature with specific type, style, and output format.
+     *
+     * @param {DrawingType} type - The type of the drawing to be created.
+     * @param {Style} style - The style defining visual appearance of the drawing.
+     * @param {FeatureOutputFormat} [format=FeatureOutputFormat.GeoJson] - The format of the feature output. Defaults to GeoJson.
+     */
+    constructor(type: DrawingType, style: StyleLike, format?: FeatureOutputFormat);
+}
+
+/**
+ * Represents a command to cancel a drawing action.
+ */
+declare class CancelDrawingCommand extends PostboyGenericMessage {
+    static readonly ID = "192d70f8-9d12-4cb3-a8ad-0fc2dc5af1de";
+}
+
+/**
+ * Class representing a command to draw a selection area with a specific type and style.
+ *
+ * @return {Dictionary<IIdentified[]>} - a collection of features inside the selected area, grouped by a layer's name
+ */
+declare class DrawSelectionAreaCommand extends PostboyCallbackMessage<Dictionary<IIdentified[]>> {
+    type: DrawingType;
+    style: Style;
+    ignore: Set<string>;
+    static readonly ID = "06e43f59-c6ba-41bb-9c5b-f6534d914905";
+    /**
+     * Constructs a new instance with the specified type, style, and optional set of ignored items.
+     *
+     * @param {DrawingType} type - The type of drawing to be created.
+     * @param {Style} style - The style information for the drawing.
+     * @param {Set<string>} [ignore=new Set<string>()] - Optional set of items to be ignored.
+     */
+    constructor(type: DrawingType, style: Style, ignore?: Set<string>);
+}
+
+/**
+ * Represents a command to modify a feature with a specific style and output format
+ * for a polygonal model.
+ *
+ * @return {string | null} a string representation of the modified feature in the appropriate format
+ */
+declare class ModifyFeatureCommand extends PostboyCallbackMessage<string | null> {
+    model: PolygonModel;
+    style: StyleLike;
+    format: FeatureOutputFormat;
+    draggable: boolean;
+    static readonly ID = "8f76507e-f18d-4232-bab7-f3d4e3d707bb";
+    /**
+     * Constructs an instance of the class.
+     *
+     * @param {PolygonModel} model - The model representing the polygon data.
+     * @param {StyleLike} style - The style to be applied to the polygon.
+     * @param {FeatureOutputFormat} [format=FeatureOutputFormat.GeoJson] - The output format of the feature, defaults to GeoJson.
+     * @param {boolean} [draggable=true] - Determines whether the polygon is draggable, defaults to true.
+     */
+    constructor(model: PolygonModel, style: StyleLike, format?: FeatureOutputFormat, draggable?: boolean);
+}
+
+/**
+ * Represents a command to cancel a feature modification.
+ */
+declare class CancelFeatureModificationCommand extends PostboyGenericMessage {
+    static readonly ID = "e7886353-53b3-4bbe-93b5-6490e5f1305e";
+}
+
+/**
+ * Represents a command to remove a map control from the map.
+ *
+ * The command is identified by a unique static ID, and it requires a MapControl item
+ * to specify the control to be removed.
+ *
+ * @extends PostboyGenericMessage
+ */
+declare class RemoveControlCommand extends PostboyGenericMessage {
+    item: MapControl;
+    static readonly ID = "73bcb4f5-ce7d-4c71-b70d-e772100136a1";
+    /**
+     * Constructs an instance of the class.
+     *
+     * @param {MapControl} item - The map control instance to be removed.
+     */
+    constructor(item: MapControl);
+}
+
+/**
+ * Forces map to move to a specific point
+ */
+declare class SetMapCenterCommand extends PostboyGenericMessage {
+    lat: number;
+    lng: number;
+    zoom?: number | undefined;
+    static readonly ID = "d4e3cf4f-0be7-4c1a-8355-8607d02c3dea";
+    /**
+     *
+     * @param lat - the desired latitude
+     * @param lng - the desired longitude
+     * @param zoom - the desired zoom; doesn't change zoom if undefined
+     */
+    constructor(lat: number, lng: number, zoom?: number | undefined);
+}
+
+/**
+ * FitToPolygonsCommand is a command used to fit a given set of polygon features
+ * to the viewable area, optionally applying a zoom transformation afterwards.
+ */
+declare class FitToPolygonsCommand extends PostboyGenericMessage {
+    features: PolygonModel[];
+    zoomAfter: number;
+    static readonly ID = "308394ce-48d3-45f5-8671-52207fba4be3";
+    /**
+     * Creates an instance of the class with specified polygon features and an optional zoom level.
+     *
+     * @param {PolygonModel[]} features - An array of polygon models to fit to.
+     * @param {number} [zoomAfter=0] - Optional zoom level change to apply after initialization. Defaults to 0.
+     */
+    constructor(features: PolygonModel[], zoomAfter?: number);
+}
+
+/**
+ * Represents an event triggered when a map rendering process is completed.
+ */
+declare class MapRenderedEvent extends PostboyGenericMessage {
+    map: Map;
+    static readonly ID = "4515dde8-1519-4e3f-a0e3-10d3c52deabe";
+    /**
+     * Constructor for creating an instance of the class.
+     *
+     * @param {Map} map - The map instance to be used by the class.
+     */
+    constructor(map: Map);
+}
+
+/**
+ * Represents an event that is triggered when the movement of a map ends.
+ * This class is used to capture the final position of a map after a movement operation.
+ *
+ * @property {MapPosition | null} position - The final position of the map after movement ends. Can be null.
+ */
+declare class MapMoveEndEvent extends PostboyGenericMessage {
+    position: MapPosition | null;
+    static readonly ID = "d210ec7e-032f-4ce8-8a39-7b816519eaae";
+    constructor(position: MapPosition | null);
+}
+
+/**
+ * Represents an event that is triggered when the pointer moves on a map.
+ * This class extends PostboyGenericMessage.
+ *
+ * It contains information about the coordinates of the pointer when the event occurs.
+ */
+declare class MapPointerMoveEvent extends PostboyGenericMessage {
+    point: Array<number>;
+    static readonly ID = "193cb41d-2489-45cc-b349-59c3ec18ed72";
+    /**
+     * Constructor for initializing an instance with a given point.
+     *
+     * @param {Array<number>} point - An array representing the coordinates of the point.
+     */
+    constructor(point: Array<number>);
+}
+
+/**
+ * Represents an event triggered when a map feature is hovered over.
+ * This event contains information about the hovered feature and its associated layer.
+ * Extends the PostboyGenericMessage class.
+ */
+declare class MapFeatureHoveredEvent extends PostboyGenericMessage {
+    feature: Feature | null;
+    layer: string | null;
+    static readonly ID = "eb9b032a-1616-4823-a628-0fd8ffc3b57a";
+    /**
+     * Constructs an instance of the class.
+     *
+     * @param {Feature|null} feature - The feature associated with this instance. Can be null.
+     * @param {string|null} layer - The layer associated with this instance. Can be null.
+     */
+    constructor(feature: Feature | null, layer: string | null);
+}
+
+/**
+ * A class responsible for executing filtering of geographical features
+ * based on a specific geographical point (latitude and longitude).
+ *
+ * @template Feature - A geographical feature that is processed by the executor.
+ * @template Geometry - The type of geometry associated with the feature.
+ */
+declare class FilterFeaturesInPointExecutor extends PostboyExecutor<Feature<Geometry>[]> {
+    lat: number;
+    lng: number;
+    features: Feature<Geometry>[];
+    static readonly ID = "dcbb156d-def3-45b4-91af-84d1483d8941";
+    /**
+     * Constructs a new instance with the specified latitude, longitude, and features.
+     *
+     * @param {number} lat - The latitude coordinate.
+     * @param {number} lng - The longitude coordinate.
+     * @param {Feature<Geometry>[]} features - The array of features associated with the location.
+     */
+    constructor(lat: number, lng: number, features: Feature<Geometry>[]);
+}
+
+/**
+ * A class that extends the PostboyExecutor to filter geographical features within a specified area.
+ * This class is designed to process a list of input features and determine which of them are located inside the provided area geometry.
+ *
+ * Parameters:
+ * - `area`: A Geometry object defining the area to filter geographical features.
+ * - `features`: An array of geographical features, represented as `Feature<Geometry>` objects, to be filtered by their presence within the specified area.
+ */
+declare class FilterFeaturesInAreaExecutor extends PostboyExecutor<Feature<Geometry>[]> {
+    area: Geometry;
+    features: Feature<Geometry>[];
+    static readonly ID = "4d26e1e3-e60f-4e49-804b-5b3eadc2adce";
+    constructor(area: Geometry, features: Feature<Geometry>[]);
+}
+
+/**
+ * An executor responsible for calculating the area of a given polygon.
+ *
+ * Use this class to manage and execute area-calculation logic for a polygon.
+ *
+ * @return {number} - the spherical area (in square meters)
+ */
+declare class CalculateAreaExecutor extends PostboyExecutor<Feature<Geometry>[]> {
+    polygon: PolygonModel;
+    static readonly ID = "82347b8c-7635-45ec-85ef-75aaf43bc34c";
+    constructor(polygon: PolygonModel);
+}
+
+/**
+ * A message that allows to get the current state of the map.
+ * If the map's state is not defined yet, the executor would return null
+ * @returns {MapPosition | null}
+ */
+declare class GetMapPositionExecutor extends PostboyExecutor<MapPosition | null> {
+    static readonly ID = "52c95689-d09b-4082-ba58-9183ea96a213";
+    constructor();
+}
+
+declare class PolygonSelfIntersectionExecutor extends PostboyGenericMessage {
+    polygon: PolygonModel;
+    static readonly ID = "a4ef116d-fe40-4e92-9d4a-653f8b398c62";
+    constructor(polygon: PolygonModel);
+}
+
+/**
+ * Class representing a query to get features within a specified geographical area.
+ * The query optionally takes a set of layer names to ignore during the operation.
+ */
+declare class GetFeaturesInAreaQuery extends PostboyCallbackMessage<Dictionary<IIdentified[]>> {
+    area: Geometry;
+    ignore: Set<string>;
+    static readonly ID = "317cf427-a029-4a43-97c4-cb6b8148ff65";
+    /**
+     * Constructor to initialize the object with a Geometry instance and an optional set of strings to ignore.
+     *
+     * @param {Geometry} area - The Geometry object used to define the area.
+     * @param {Set<string>} [ignore] - An optional set of layer names that will be ignored. Defaults to an empty set.
+     */
+    constructor(area: Geometry, ignore?: Set<string>);
+}
+
+/**
+ * Represents a query to retrieve features located at a specific geographical point.
+ * The query is defined by latitude, longitude, and an optional set of features to ignore.
+ */
+declare class GetFeaturesInPointQuery extends PostboyCallbackMessage<Dictionary<IIdentified[]>> {
+    lat: number;
+    lng: number;
+    ignore: Set<string>;
+    static readonly ID = "99bbc56f-34a2-4064-8300-13bb3d0662c1";
+    /**
+     * Constructor for initializing a geographic coordinate object.
+     *
+     * @param {number} lat - The latitude of the location.
+     * @param {number} lng - The longitude of the location.
+     * @param {Set<string>} [ignore=new Set<string>()] - An optional set of strings to ignore during processing.
+     */
+    constructor(lat: number, lng: number, ignore?: Set<string>);
+}
+
+declare class FitToFeaturesCommand extends PostboyGenericMessage {
+    features: Feature<Geometry>[];
+    zoomAfter: number;
+    static readonly ID = "04d67609-0b4c-4f52-aa53-ad0a3db967dc";
+    constructor(features: Feature<Geometry>[], zoomAfter?: number);
+}
+
+declare class GetGeometryLengthExecutor extends PostboyExecutor<number> {
+    geometry: Geometry;
+    projection: string;
+    static readonly ID = "763146df-6d93-4dc2-a532-0e9ba2b2d023";
+    constructor(geometry: Geometry, projection?: string);
+}
+
+/**
+ * MarkersComponent is a component that displays markers on a map.
+ * It listens for changes in the `markers` input property and
+ * automatically puts the markers on the map using the MapPostboyService.
+ */
+declare class MarkersComponent extends DestructibleComponent implements OnInit {
+    private postboy;
+    layerName: string;
+    constructor(postboy: MapPostboyService);
+    _markers: MarkerModel[];
+    /**
+     * Sets the markers property.
+     *
+     * @param {MarkerModel[]} value - The array of MarkerModel objects to set as markers.
+     */
+    set markers(value: MarkerModel[]);
+    ngOnInit(): void;
+    private putMarkers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkersComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MarkersComponent, "art-markers", never, { "layerName": { "alias": "layerName"; "required": false; }; "markers": { "alias": "markers"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Component for rendering polygons on a map.
+ * It listens for changes in the `polygons` input property and
+ * automatically puts the polygons on the map using the MapPostboyService.
+ */
+declare class PolygonsComponent extends DestructibleComponent implements OnInit {
+    private postboy;
+    layerName: string;
+    constructor(postboy: MapPostboyService);
+    _polygons: PolygonModel[];
+    /**
+     * Sets the value of polygons.
+     *
+     * @param {PolygonModel[]} value - The new value for polygons.
+     */
+    set polygons(value: PolygonModel[]);
+    ngOnInit(): void;
+    private putPolygons;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PolygonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PolygonsComponent, "art-polygons", never, { "layerName": { "alias": "layerName"; "required": false; }; "polygons": { "alias": "polygons"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Helper class to create and modify marker styles.
+ */
+declare class MarkerStyleHelper {
+    /**
+     * Creates a new Style object from an SVG.
+     * @param {string} svg - The SVG string.
+     * @param {Array<number>} [size=[30, 30]] - The size of the icon image.
+     * @param {number} [zIndex=400] - The zIndex of the style.
+     * @returns {Style} A new Style object.
+     */
+    static fromSvg(svg: string, size?: [number, number], zIndex?: number): Style;
+    /**
+     * Returns a Style object with a circle style.
+     *
+     * @param {number} radius - The radius of the circle.
+     * @param {string} fill - The fill color of the circle. Format: '#RRGGBB' or 'rgba(R, G, B, A)'.
+     * @param {string} strokeColor - The stroke color of the circle. Format: '#RRGGBB' or 'rgba(R, G, B, A)'.
+     * @param {number} [strokeWidth=1] - The width of the stroke. Default is 1.
+     * @returns {Style} - A Style object with a Circle image.
+     */
+    static circle(radius: number, fill: string, strokeColor: string, strokeWidth?: number): Style;
+    /**
+     * Applies the given Text to the provided Style.
+     *
+     * @param {Style} style - The Style to modify.
+     * @param {Text} text - The Text to apply to the Style.
+     * @return {Style} - The modified Style with the applied Text.
+     */
+    static withText(style: Style, text: Text): Style;
+}
+
+/**
+ * A helper class for creating polygon styles.
+ * @class
+ */
+declare class PolygonStyleHelper {
+    /**
+     * Creates a Style object with the given fill color, stroke color, and stroke width.
+     *
+     * @param {string} fill - The fill color in hexadecimal or RGB format.
+     * @param {string} stroke - The stroke color in hexadecimal or RGB format.
+     * @param {number} [strokeWidth=1] - The width of the stroke. Defaults to 1.
+     * @return {Style} The created Style object.
+     */
+    static simple(fill: string, stroke: string, strokeWidth?: number): Style;
+    /**
+     * Creates a new Style object with the given fill, stroke, stroke width, and pin radius.
+     *
+     * @param {string} fill - The color to use for the fill of the style.
+     * @param {string} stroke - The color to use for the stroke of the style.
+     * @param {number} [strokeWidth=1] - The width of the stroke. Defaults to 1.
+     * @param {number} [pinRadius=5] - The radius of the circle used as the image for the style. Defaults to 5.
+     * @returns {Style} - The newly created Style object.
+     */
+    static edit(fill: string, stroke: string, strokeWidth?: number, pinRadius?: number): Style;
+}
+
+/**
+ * Helper class for creating text styles.
+ */
+declare class TextStyleHelper {
+    /**
+     * Creates and returns a new Text instance with specified styling properties.
+     *
+     * @param {string} text - The text content to display.
+     * @param {string} font - The font style to use for the text.
+     * @param {string} color - The color of the text.
+     * @param {string|null|undefined} [backColor] - The background color of the text. Optional.
+     * @param {number[]|null|undefined} [padding] - The padding around the text in pixels. Optional.
+     * @param {string|null|undefined} [textBaseline] - The text baseline alignment. Optional.
+     * @param {number|null|undefined} [offsetY] - The vertical offset for the text. Optional.
+     * @return {Text} A new Text instance configured with the specified properties.
+     */
+    static get(text: string, font: string, color: string, backColor?: string | null, padding?: number[] | null, textBaseline?: 'bottom' | 'top' | 'middle' | 'alphabetic' | 'hanging' | 'ideographic' | null, offsetY?: number | null): Text;
+}
+
+/**
+ * A helper class for converting and stringify features.
+ */
+declare class StringifyFeatureHelper {
+    static polygon(feature: Feature<Geometry>, format?: FeatureOutputFormat): string;
+    /**
+     * Creates a polygon feature representing a circle based on a given feature with a circle geometry.
+     *
+     * @param {Feature<Geometry>} feature - The input feature with a circle geometry.
+     * @param {FeatureOutputFormat} format - The format for outputting the polygon feature. (default: FeatureOutputFormat.GeoJson)
+     *
+     * @return {string} - The string representation of the polygon feature.
+     */
+    static circle(feature: Feature<Geometry>, format?: FeatureOutputFormat): string;
+    /**
+     * Draw a circle based on a center point and radius.
+     *
+     * @param {number[]} point - The center point coordinates in EPSG:4326 format.
+     * @param {number} radius - The radius of the circle in meters.
+     * @return {Coordinate[][]} - The coordinates of the circle boundary in EPSG:4326 format.
+     */
+    private static drawCircle;
+}
+
+/**
+ * Represents the settings for a zoom control.
+ */
+declare class ZoomControlSettings {
+    /**
+     * The CSS class name of the control element.
+     *
+     * @type {string}
+     */
+    controlClass: string;
+    /**
+     * The CSS class name for zoom in button.
+     * @type {string}
+     */
+    zoomInClass: string;
+    /**
+     * The CSS class name for the zoom out button element.
+     *
+     * @type {string}
+     */
+    zoomOutClass: string;
+    /**
+     * The label for the zoom in action.
+     *
+     * @type {string}
+     */
+    zoomInLabel: string;
+    /**
+     * The label for the zoom out control.
+     *
+     * @type {string}
+     */
+    zoomOutLabel: string;
+    /**
+     * Copies the provided ZoomControlSettings object.
+     *
+     * @param {ZoomControlSettings} model - The ZoomControlSettings object to be copied.
+     * @return {ZoomControlSettings} - The copied ZoomControlSettings object.
+     */
+    static copy(model: ZoomControlSettings): ZoomControlSettings;
+    /**
+     * Checks if the current ZoomControlSettings object is equal to the given model.
+     *
+     * @param {ZoomControlSettings} model - The ZoomControlSettings object to compare with.
+     *
+     * @return {boolean} - true if the current object is equal to the given model, false otherwise.
+     */
+    isSame(model: ZoomControlSettings): boolean;
+    /**
+     * Sets the zoom in label of the Zoom Control Settings.
+     *
+     * @param {string} zoomInLabel - The label for the zoom in button.
+     * @return {ZoomControlSettings} - The new Zoom Control Settings object with the updated zoom in label.
+     */
+    setZoomInLabel(zoomInLabel: string): ZoomControlSettings;
+    /**
+     * Sets the zoomOutClass property of the ZoomControlSettings object.
+     *
+     * @param {string} zoomOutClass - The CSS class to be assigned to the zoom out button.
+     * @return {ZoomControlSettings} - The updated ZoomControlSettings object with the new zoomOutClass value.
+     */
+    setZoomOutClass(zoomOutClass: string): ZoomControlSettings;
+    /**
+     * Sets the zoom in class for the zoom control settings.
+     *
+     * @param {string} zoomInClass - The new zoom in class to be set.
+     * @return {ZoomControlSettings} - The updated zoom control settings.
+     */
+    setZoomInClass(zoomInClass: string): ZoomControlSettings;
+    /**
+     * Set the label for the zoom out control.
+     *
+     * @param {string} zoomOutLabel - The label for the zoom out control.
+     * @returns {ZoomControlSettings} - The updated zoom control settings.
+     */
+    setZoomOutLabel(zoomOutLabel: string): ZoomControlSettings;
+    /**
+     * Sets the control class for the ZoomControlSettings.
+     *
+     * @param {string} controlClass - The class name of the control to be set.
+     *
+     * @return {ZoomControlSettings} - The modified ZoomControlSettings object.
+     */
+    setControlClass(controlClass: string): ZoomControlSettings;
+}
+
+/**
+ * @class
+ * @classdesc Represents a component for the Zoom control on a map.
+ * @extends DestructibleComponent
+ * @implements OnInit
+ */
+declare class MapControlZoomComponent extends DestructibleComponent implements OnInit {
+    private postboy;
+    private map?;
+    private control?;
+    constructor(postboy: MapPostboyService);
+    private _settings;
+    /**
+     * Sets the settings for the Zoom Control.
+     *
+     * @param {ZoomControlSettings | undefined} value - The new settings for the Zoom Control.
+     *
+     * @description
+     * This method sets the settings for the Zoom Control. It takes a parameter `value` which should be an object of type `ZoomControlSettings` or `undefined`.
+     *
+     * If the `value` is `undefined` or the same as the current settings, the method will return without making any changes.
+     *
+     */
+    set settings(value: ZoomControlSettings | undefined);
+    ngOnInit(): void;
+    onDestroy: () => void;
+    private setControl;
+    private eliminate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapControlZoomComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapControlZoomComponent, "art-map-control-zoom", never, { "settings": { "alias": "settings"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TooltipSettings {
+    readonly id: string;
+    containerClass: string;
+    constructor(id?: string);
+    static copy(model: TooltipSettings): TooltipSettings;
+    show: (ev: MapClickEvent) => boolean;
+    setShow(show: (ev: MapClickEvent) => boolean): TooltipSettings;
+    setClass(containerClass: string): TooltipSettings;
+    isSame(model: TooltipSettings): boolean;
+}
+
+declare class TooltipComponent extends DestructibleComponent implements OnInit {
+    private postboy;
+    private detector;
+    contentRef: i0.InputSignal<TemplateRef<any>>;
+    container: ElementRef<HTMLElement>;
+    overlay?: Overlay;
+    show: boolean;
+    private map?;
+    constructor(postboy: MapPostboyService, detector: ChangeDetectorRef);
+    _settings: TooltipSettings;
+    set settings(value: TooltipSettings | undefined);
+    ngOnInit(): void;
+    addOverlay(coordinates: number[]): void;
+    options: (coordinates: number[]) => Options$1;
+    private observeMapClick;
+    private observeClose;
+    private observeMapRender;
+    private removeOverlay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "art-tooltip", never, { "contentRef": { "alias": "contentRef"; "required": true; "isSignal": true; }; "settings": { "alias": "settings"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { AddControlCommand, CalculateAreaExecutor, CancelDrawingCommand, CancelFeatureModificationCommand, CloseTooltipCommand, ClusterLayerComponent, ClusterLayerSettings, DrawSelectionAreaCommand, DrawingType, FeatureLayerComponent, FeatureLayerSettings, FeatureOutputFormat, FilterFeaturesInAreaExecutor, FilterFeaturesInPointExecutor, FitToFeaturesCommand, FitToPolygonsCommand, GetFeaturesInAreaQuery, GetFeaturesInPointQuery, GetGeometryLengthExecutor, GetMapPositionExecutor, ImageLayerComponent, ImageLayerSettings, MapClickEvent, MapConstants, MapControl, MapControlZoomComponent, MapFeatureHoveredEvent, MapLyrs, MapLyrsLabel, MapMoveEndEvent, MapPlateComponent, MapPointerMoveEvent, MapPostboyService, MapRenderedEvent, MapSettings, MarkerModel, MarkerStyleHelper, MarkersComponent, MessageRegistratorService, ModifyFeatureCommand, OsmTileLayerComponent, PolygonModel, PolygonSelfIntersectionExecutor, PolygonStyleHelper, PolygonsComponent, RasterTileLayerComponent, RasterTileLayerSettings, RemoveControlCommand, SetMapCenterCommand, StartDrawingCommand, StringifyFeatureHelper, TextStyleHelper, TileLayerComponent, TileLayerSettings, TooltipComponent, TooltipSettings, ZoomControlSettings };
+export type { MapPosition };