import * as i0 from '@angular/core';
import { NgZone, EventEmitter, OnChanges, OnInit, AfterViewInit, OnDestroy, ElementRef, SimpleChanges, AfterContentInit, PipeTransform, DoCheck, Renderer2, ChangeDetectorRef, ViewContainerRef, ComponentFactoryResolver, TemplateRef, ModuleWithProviders } from '@angular/core';
import * as i54 from '@auscope/angular2parse';
import { PipesConfig, Parse } from '@auscope/angular2parse';
import * as Cesium from 'cesium';
import { Cartesian3, Cartographic, CallbackProperty, Cartesian2, PolygonHierarchy, Rectangle } from 'cesium';
import { ConnectableObservable, Observable, Subject, BehaviorSubject } from 'rxjs';
import * as geodesy from 'geodesy';
import { hemisphere } from 'geodesy';
import * as i1 from '@angular/common';

/**
 * The interface defines the options object that can be passed to AngularCesiumModule on initialization.
 */

interface ModuleConfiguration {
    fixEntitiesShadows?: boolean;
    customPipes: PipesConfig[];
}

declare class ViewerFactory {
    /**
     * Creates a viewer with default or custom options
     * @param mapContainer - container to initialize the viewer on
     * @param options - Options to create the viewer with - Optional
     *
     * @returns new viewer
     */
    createViewer(mapContainer: HTMLElement, options?: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ViewerFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ViewerFactory>;
}

/**
 * Service for setting cesium viewer map options.
 * defaulty angular-cesium doesnt provide this service and viewer is created with default options.
 * In order set specific options you must set this service as provider in your component and
 * set the wanted options.
 * ```typescript
 * constructor(viewerConf :ViewerConfiguration ) {
 *   viewerConf.viewerOptions = { timeline: false };
 * }
 * ```
 * notice this configuration will be for all <ac-maps> in your component.
 */
declare class ViewerConfiguration {
    /**
     * cesium viewer options According to [Viewer]{@link https://cesiumjs.org/Cesium/Build/Documentation/Viewer.html?classFilter=vie}
     */
    private _viewerOptions;
    private _viewerModifier;
    private nextViewerOptionsIndex;
    private nextViewerModifierIndex;
    get viewerOptions(): object | object[];
    Ï: any;
    getNextViewerOptions(): object | object[];
    /**
     * Can be used to set initial map viewer options.
     * If there is more than one map you can give the function an array of options.
     * The map initialized first will be set with the first option object in the options array and so on.
     */
    set viewerOptions(value: object | object[]);
    get viewerModifier(): Function | Function[];
    getNextViewerModifier(): Function | Function[];
    /**
     * Can be used to set map viewer options after the map has been initialized.
     * If there is more than one map you can give the function an array of functions.
     * The map initialized first will be set with the first option object in the options array and so on.
     */
    set viewerModifier(value: Function | Function[]);
    static ɵfac: i0.ɵɵFactoryDeclaration<ViewerConfiguration, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ViewerConfiguration>;
}

/**
 *  Service that initialize cesium viewer and expose cesium viewer and scene.
 */
declare class CesiumService {
    private ngZone;
    private viewerFactory;
    private viewerConfiguration;
    private cesiumViewer;
    private mapContainer;
    constructor(ngZone: NgZone, viewerFactory: ViewerFactory, viewerConfiguration: ViewerConfiguration);
    init(mapContainer: HTMLElement): void;
    /**
     * For more information see https://cesiumjs.org/Cesium/Build/Documentation/Viewer.html?classFilter=viewe
     * @returns cesiumViewer
     */
    getViewer(): any;
    /**
     * For more information see https://cesiumjs.org/Cesium/Build/Documentation/Scene.html?classFilter=scene
     * @returns cesium scene
     */
    getScene(): any;
    /**
     * For more information see https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API
     * @returns cesium canvas
     */
    getCanvas(): HTMLCanvasElement;
    getMapContainer(): HTMLElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<CesiumService, [null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CesiumService>;
}

/**
 * Cesium scene modes
 */
declare enum SceneMode {
    SCENE3D = 0,
    COLUMBUS_VIEW = 1,
    SCENE2D = 2,
    PERFORMANCE_SCENE2D = 3
}

/**
 *  The service exposes the scene's camera and screenSpaceCameraController
 *  SceneMode.PERFORMANCE_SCENE2D -  is a 3D scene mode that acts like Cesium 2D mode,
 *  but is more efficient performance wise.
 */
declare class CameraService {
    static PERFORMANCE_2D_ALTITUDE: number;
    private viewer;
    private scene;
    private camera;
    private screenSpaceCameraController;
    private morphListenerCancelFn;
    private lastRotate;
    private lastTilt;
    private lastLook;
    private isSceneModePerformance2D;
    constructor();
    init(cesiumService: CesiumService): void;
    _listenToSceneModeMorph(callback: Function): void;
    _revertCameraProperties(): void;
    /**
     * Gets the scene's camera
     */
    getCamera(): any;
    /**
     * Gets the scene's screenSpaceCameraController
     */
    getScreenSpaceCameraController(): any;
    /**
     * Gets the minimum zoom value in meters
     */
    getMinimumZoom(): number;
    /**
     * Sets the minimum zoom value in meters
     * @param zoom amount
     */
    setMinimumZoom(amount: number): void;
    /**
     * Gets the maximum zoom value in meters
     */
    getMaximumZoom(): number;
    /**
     * Sets the maximum zoom value in meters
     * @param zoom amount
     */
    setMaximumZoom(amount: number): void;
    /**
     * Sets if the camera is able to tilt
     */
    enableTilt(tilt: boolean): void;
    /**
     * Sets if the camera is able to rotate
     */
    enableRotate(rotate: boolean): void;
    /**
     * Sets if the camera is able to free-look
     */
    enableLook(lock: boolean): void;
    /**
     * Sets if the camera is able to translate
     */
    enableTranslate(translate: boolean): void;
    /**
     * Sets if the camera is able to zoom
     */
    enableZoom(zoom: boolean): void;
    /**
     * Sets if the camera receives inputs
     */
    enableInputs(inputs: boolean): void;
    /**
     * Sets the map's SceneMode
     * @param sceneMode - The SceneMode to morph the scene into.
     * @param duration - The duration of scene morph animations, in seconds
     */
    setSceneMode(sceneMode: SceneMode, duration?: number): void;
    /**
     * Flies the camera to a destination
     * API: https://cesiumjs.org/Cesium/Build/Documentation/Camera.html?classFilter=cam#flyTo
     */
    cameraFlyTo(options: any): any;
    /**
     * Flies the camera to a target
     * API: https://cesiumjs.org/Cesium/Build/Documentation/Viewer.html?classFilter=viewer#flyTo
     * @returns Promise<boolean>
     */
    flyTo(target: any, options?: any): any;
    /**
     * Zooms amount along the camera's view vector.
     * API: https://cesiumjs.org/Cesium/Build/Documentation/Camera.html#zoomIn
     */
    zoomIn(amount: number): any;
    /**
     * Zooms amount along the opposite direction of the camera's view vector.
     * API: https://cesiumjs.org/Cesium/Build/Documentation/Camera.html#zoomOut
     */
    zoomOut(amount: number): any;
    /**
     * Zoom the camera to a target
     * API: https://cesiumjs.org/Cesium/Build/Documentation/Viewer.html?classFilter=viewer#zoomTo
     * @returns Promise<boolean>
     */
    zoomTo(target: any, offset?: any): any;
    /**
     * Flies the camera to a destination
     * API: https://cesiumjs.org/Cesium/Build/Documentation/Camera.html?classFilter=camera#setView
     * @param options viewer options
     */
    setView(options: any): void;
    /**
     * Set camera's rotation
     */
    setRotation(degreesInRadians: number): void;
    /**
     * Locks or unlocks camera rotation
     */
    lockRotation(lock: boolean): void;
    /**
     * Make the camera track a specific entity
     * API: https://cesiumjs.org/Cesium/Build/Documentation/Viewer.html?classFilter=viewer#trackedEntity
     * @param cesiumEntity - cesium entity( billboard, polygon...) to track
     * @param options - track entity options
     */
    trackEntity(cesiumEntity?: any, options?: {
        flyTo: boolean;
        flyToDuration?: number;
        altitude?: number;
    }): Promise<void>;
    untrackEntity(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CameraService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CameraService>;
}

/**
 * Interface of context menu options that can be passed when opening a context menu.
 */
interface ContextMenuOptions<D = any> {
    data?: D;
    closeOnLeftCLick?: boolean;
    closeOnLeftClickPriority?: number;
}

/**
 * Event options for registration on map-event-manager.
 */
declare enum CesiumEvent {
    MOUSE_MOVE = 15,
    LEFT_CLICK = 2,
    LEFT_DOUBLE_CLICK = 3,
    LEFT_DOWN = 0,
    LEFT_UP = 1,
    MIDDLE_CLICK = 12,
    MIDDLE_DOWN = 10,
    MIDDLE_UP = 11,
    PINCH_START = 17,
    PINCH_END = 18,
    PINCH_MOVE = 19,
    RIGHT_CLICK = 7,
    RIGHT_DOWN = 5,
    RIGHT_UP = 6,
    WHEEL = 16,
    LONG_LEFT_PRESS = 110,
    LONG_RIGHT_PRESS = 111,
    LONG_MIDDLE_PRESS = 112,
    LEFT_CLICK_DRAG = 113,
    RIGHT_CLICK_DRAG = 114,
    MIDDLE_CLICK_DRAG = 115
}

/**
 * EventModifier options for registration on map-event-manager.
 */
declare enum CesiumEventModifier {
    ALT = 2,
    CTRL = 1,
    SHIFT = 0
}

declare class CesiumEventBuilder {
    private cesiumService;
    constructor(cesiumService: CesiumService);
    static longPressEvents: Set<CesiumEvent>;
    private eventsHandler;
    private cesiumEventsObservables;
    static getEventFullName(event: CesiumEvent, modifier?: CesiumEventModifier): string;
    init(): void;
    get(event: CesiumEvent, modifier?: CesiumEventModifier): ConnectableObservable<any>;
    private createCesiumEventObservable;
    private createSpecialCesiumEventObservable;
    static ɵfac: i0.ɵɵFactoryDeclaration<CesiumEventBuilder, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CesiumEventBuilder>;
}

/**
 *  NO_PICK,    - will not pick entities
 *  PICK_FIRST  - first entity will be picked . use Cesium.scene.pick()
 *  PICK_ONE    - in case a few entities are picked plonter is resolved . use Cesium.scene.drillPick()
 *  PICK_ALL    - all entities are picked. use Cesium.scene.drillPick()
 */
declare enum PickOptions {
    NO_PICK = 0,
    PICK_FIRST = 1,
    PICK_ONE = 2,
    PICK_ALL = 3
}

interface PickConfiguration {
    pickHeight?: number;
    pickWidth?: number;
    drillPickLimit?: number;
}
/**
 * Interface for Event Registration Input
 * __usage:__
 * ```
 * MapEventsManagerService.register(eventRegistrationInput).subscribe()
 * ```
 */
interface EventRegistrationInput {
    event: CesiumEvent;
    modifier?: CesiumEventModifier;
    entityType?: any;
    priority?: number;
    pick?: PickOptions;
    pickFilter?: (any: any) => boolean;
    pickConfig?: PickConfiguration;
}

declare class DisposableObservable<T> extends Observable<T> {
    dispose: Function;
}

/**
 * Angular Cesium parent entity, all entities should inherit from it.
 * ```typescript
 * entity= new AcEntity({
 *  	id: 0,
 *  	name: 'click me',
 *  	position: Cartesian3.fromRadians(0.5, 0.5),
 * });
 * ```
 */
declare class AcEntity {
    /**
     * Creates entity from a json
     * @param json entity object
     * @returns entity as AcEntity
     */
    static create(json?: any): any;
    /**
     * Creates entity from a json
     * @param json (Optional) entity object
     */
    constructor(json?: any);
}

/**
 * Service for solving plonter.
 * Used by map-event-manager and plonter context component
 */
declare class PlonterService {
    private _plonterShown;
    private _entitesToPlonter;
    private _plonterObserver;
    private _eventResult;
    private _plonterChangeNotifier;
    constructor();
    get plonterChangeNotifier(): EventEmitter<any>;
    get plonterShown(): boolean;
    get entitesToPlonter(): AcEntity[];
    get plonterClickPosition(): Movement;
    plonterIt(eventResult: EventResult): Subject<EventResult>;
    resolvePlonter(entity: AcEntity): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlonterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PlonterService>;
}

/**
 * Returns screen position, drag boolean for drag events only
 */
interface Movement {
    startPosition: {
        x: number;
        y: number;
    };
    endPosition: {
        x: number;
        y: number;
    };
    drop?: boolean;
}
interface EventResult {
    movement: Movement;
    cesiumEntities: any[];
    entities: any[];
}
/**
 * Manages all map events. Notice events will run outside of Angular zone.
 * Provided by `<ac-map/>` component there for could be injected at any component under `<ac-map/>` hierarchy
 * or from the `<ac-map/>` component reference `acMapComponent.getMapEventsManager()`
 *
 * __usage:__
 * ```
 * MapEventsManagerService.register({event, modifier, priority, entityType, pickOption}).subscribe()
 * ```
 * __param:__ {CesiumEvent} event
 * __param:__ {CesiumEventModifier} modifier
 * __param:__ priority - the bigger the number the bigger the priority. default : 0.
 * __param:__ entityType - entity type class that you are interested like (Track). the class must extends AcEntity
 * __param:__ pickOption - self explained
 */
declare class MapEventsManagerService {
    private cesiumService;
    private eventBuilder;
    private plonterService;
    private scene;
    private eventRegistrations;
    constructor(cesiumService: CesiumService, eventBuilder: CesiumEventBuilder, plonterService: PlonterService);
    init(): void;
    /**
     * Register to map event
     * @param input Event Registration Input
     *
     * @returns DisposableObservable<EventResult>
     */
    register(input: EventRegistrationInput): DisposableObservable<EventResult>;
    private disposeObservable;
    private sortRegistrationsByPriority;
    private createEventRegistration;
    private createDragEvent;
    private triggerPick;
    private addEntities;
    private plonter;
    static ɵfac: i0.ɵɵFactoryDeclaration<MapEventsManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MapEventsManagerService>;
}

/**
 * The basic context menu class. All context menu components should extend this class.
 */
interface BasicContextMenu {
    data: any;
}

/**
 * The Service manages a singleton context menu over the map. It should be initialized with MapEventsManager.
 * The Service allows opening and closing of the context menu and passing data to the context menu inner component.
 *
 * notice, `data` will be injected to your custom menu component into the `data` field in the component.
 * __Usage :__
 * ```
 *  ngOnInit() {
 *   this.clickEvent$ = this.eventsManager.register({ event: CesiumEvent.RIGHT_CLICK, pick: PickOptions.PICK_ONE });
 *   this.clickEvent$.subscribe(result => {
 *    if (result.entities) {
 *      const pickedMarker = result.entities[0];
 *      this.contextMenuService.open(MapContextmenuComponent, pickedMarker.position, {
 *        data: {
 *          myData: data,
 *          onDelete: () => this.delete(pickedMarker.id)
 *        }
 *      });
 *    }
 *   });
 *  }
 *
 *
 *  private delete(id) {
 *    this.mapMenu.close();
 *    this.detailedSiteService.removeMarker(id);
 *  }
 * ```
 */
declare class ContextMenuService {
    private _showContextMenu;
    private _options;
    private _position;
    private _content;
    private mapEventsManager;
    private leftClickRegistration;
    private leftClickSubscription;
    private _contextMenuChangeNotifier;
    private _onOpen;
    private _onClose;
    private _defaultContextMenuOptions;
    get contextMenuChangeNotifier(): EventEmitter<any>;
    get showContextMenu(): boolean;
    get options(): ContextMenuOptions;
    get position(): Cartesian3;
    get content(): BasicContextMenu;
    get onOpen(): EventEmitter<any>;
    get onClose(): EventEmitter<any>;
    init(mapEventsManager: MapEventsManagerService): void;
    open<D>(contentComponent: any, position: Cartesian3, options?: ContextMenuOptions<D>): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ContextMenuService>;
}

/**
 *  Given different types of coordinates, we provide you a service converting those types to the most common other types.
 *  We are using the geodesy implementation of UTM conversion. see: https://github.com/chrisveness/geodesy.
 *
 * @example
 * import { Component, OnInit } from '@angular/core';
 * import { CoordinateConverter } from 'angular2-cesium';
 *
 * @Component({
 * 		selector:'my-component',
 * 		template:'<div>{{showCartographic}}</div>',
 * 		providers:[CoordinateConverter]
 * })
 * export class MyComponent implements OnInit {
 * 		showCartographic;
 *
 * 		constructor(private coordinateConverter:CoordinateConverter){
 * 		}
 *
 * 		ngOnInit(){
 * 			this.showCartographic = this.coordinateConverter.degreesToCartographic(5, 5, 5);
 *  }
 * }
 *
 */
declare class CoordinateConverter {
    private cesiumService?;
    constructor(cesiumService?: CesiumService);
    static cartesian3ToLatLon(cartesian3: Cartesian3, ellipsoid?: any): {
        lon: number;
        lat: number;
        height: number;
    };
    screenToCartesian3(screenPos: {
        x: number;
        y: number;
    }, addMapCanvasBoundsToPos?: boolean): any;
    screenToCartographic(screenPos: {
        x: number;
        y: number;
    }, ellipsoid?: any): Cartographic;
    cartesian3ToCartographic(cartesian: Cartesian3, ellipsoid?: any): Cartographic;
    degreesToCartographic(longitude: number, latitude: number, height?: number): Cartographic;
    radiansToCartographic(longitude: number, latitude: number, height?: number): Cartographic;
    degreesToUTM(longitude: number, latitude: number): geodesy.Utm;
    UTMToDegrees(zone: number, hemisphereType: hemisphere, easting: number, northing: number): {
        longitude: number;
        latitude: number;
        height: any;
    };
    private geodesyToCesiumObject;
    /**
     * middle point between two points
     * @param first  (latitude,longitude) in radians
     * @param second (latitude,longitude) in radians
     */
    midPointToCartesian3(first: {
        latitude: number;
        longitude: number;
    }, second: {
        latitude: number;
        longitude: number;
    }): Cartesian3;
    middlePointByScreen(position0: Cartesian3, position1: Cartesian3): Cartesian3;
    /**
     * initial bearing between two points
     *
     * * @return bearing in degrees
     * @param first - {latitude,longitude} in radians
     * @param second - {latitude,longitude} in radians
     */
    bearingTo(first: {
        latitude: number;
        longitude: number;
    }, second: {
        latitude: number;
        longitude: number;
    }): number;
    /**
     * initial bearing between two points
     *
     * @return bearing in degrees
     */
    bearingToCartesian(firstCartesian3: Cartesian3, secondCartesian3: Cartesian3): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoordinateConverter, [{ optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CoordinateConverter>;
}

/**
 *  Abstract drawer. All drawers extends this class.
 */
declare abstract class BasicDrawerService {
    protected _propsAssigner: Function;
    constructor();
    abstract add(cesiumProps: any, ...args: any[]): any;
    abstract update(primitive: any, cesiumProps: any, ...args: any[]): void;
    abstract remove(primitive: any): void;
    abstract removeAll(): void;
    abstract setShow(showValue: boolean): void;
    abstract init(options?: any): any;
    setPropsAssigner(assigner: Function): void;
}

/**
 *  General primitives drawer responsible of drawing Cesium primitives.
 *  Drawers the handle Cesium primitives extend it.
 */
declare abstract class PrimitivesDrawerService extends BasicDrawerService {
    private drawerType;
    private cesiumService;
    private _show;
    private _primitiveCollectionWrap;
    protected _cesiumCollection: any;
    protected _propsAssigner: Function;
    constructor(drawerType: any, cesiumService: CesiumService);
    init(): void;
    add(cesiumProps: any, ...args: any[]): any;
    update(entity: any, cesiumProps: any, ...args: any[]): void;
    remove(entity: any): void;
    removeAll(): void;
    setShow(showValue: boolean): void;
    getShow(): boolean;
}

/**
 +  This drawer is responsible for drawing an arc over the Cesium map.
 +  This implementation uses simple PolylineGeometry and Primitive parameters.
 +  This doesn't allow us to change the position, color, etc.. of the arc but setShow only.
 */
declare class ArcDrawerService extends PrimitivesDrawerService {
    constructor(cesiumService: CesiumService);
    _calculateArcPositions(cesiumProps: any): any[];
    _calculateTriangle(cesiumProps: any): any[];
    _calculateArc(cesiumProps: any): any[];
    add(cesiumProps: any): any;
    update(primitive: any, cesiumProps: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArcDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ArcDrawerService>;
}

declare class GraphicsType {
    static ellipse: typeof Cesium.EllipseGraphics;
    static ellipsoid: typeof Cesium.EllipsoidGraphics;
    static polygon: typeof Cesium.PolygonGraphics;
    static polyline: typeof Cesium.PolylineGraphics;
    static polylineVolume: typeof Cesium.PolylineVolumeGraphics;
    static box: typeof Cesium.BoxGraphics;
    static corridor: typeof Cesium.CorridorGraphics;
    static cylinder: typeof Cesium.CylinderGraphics;
    static label: typeof Cesium.LabelGraphics;
    static billboard: typeof Cesium.BillboardGraphics;
    static model: typeof Cesium.ModelGraphics;
    static path: typeof Cesium.PathGraphics;
    static point: typeof Cesium.PointGraphics;
    static rectangle: typeof Cesium.RectangleGraphics;
    static wall: typeof Cesium.WallGraphics;
}

interface EntitiesDrawerOptions {
    collectionSuspensionTime: number;
    collectionsNumber: number;
    collectionMaxSize: number;
}

/**
 *  General primitives drawer responsible of drawing Cesium primitives.
 *  Drawers the handle Cesium primitives extend it.
 */
declare class EntitiesDrawerService extends BasicDrawerService {
    private cesiumService;
    private graphicsType;
    private defaultOptions;
    private entityCollections;
    private graphicsTypeName;
    constructor(cesiumService: CesiumService, graphicsType: GraphicsType, defaultOptions?: EntitiesDrawerOptions);
    private getFreeEntitiesCollection;
    init(options?: EntitiesDrawerOptions): any[];
    add(cesiumProps: any): any;
    update(entity: any, cesiumProps: any): void;
    remove(entity: any): void;
    removeAll(): void;
    setShow(showValue: boolean): void;
    private suspendEntityCollection;
}

/**
 *  This drawer is responsible for drawing billboards.
 */
declare class BillboardDrawerService extends EntitiesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<BillboardDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BillboardDrawerService>;
}

/**
 *  This drawer is responsible for drawing czml dataSources.
 */
declare class CzmlDrawerService extends BasicDrawerService {
    private cesiumService;
    czmlStream: any;
    constructor(cesiumService: CesiumService);
    init(options?: EntitiesDrawerOptions): any[];
    add(cesiumProps: any): any;
    update(entity: any, cesiumProps: any): void;
    remove(entity: any): void;
    removeAll(): void;
    setShow(showValue: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CzmlDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CzmlDrawerService>;
}

/**
 *  This drawer is responsible for drawing ellipses.
 */
declare class EllipseDrawerService extends EntitiesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<EllipseDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EllipseDrawerService>;
}

/**
 *  This drawer is responsible for drawing labels.
 */
declare class LabelDrawerService extends EntitiesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<LabelDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LabelDrawerService>;
}

/**
 *  This drawer is responsible for drawing points.
 */
declare class PointDrawerService extends EntitiesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<PointDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PointDrawerService>;
}

/**
 *  This drawer is responsible for drawing polygons.
 */
declare class PolygonDrawerService extends EntitiesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<PolygonDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PolygonDrawerService>;
}

/**
 *  This drawer is responsible of drawing polylines.
 */
declare class PolylineDrawerService extends EntitiesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<PolylineDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PolylineDrawerService>;
}

declare enum KeyboardAction {
    CAMERA_FORWARD = 0,
    CAMERA_BACKWARD = 1,
    CAMERA_RIGHT = 2,
    CAMERA_LEFT = 3,
    CAMERA_UP = 4,
    CAMERA_DOWN = 5,
    CAMERA_LOOK_RIGHT = 6,
    CAMERA_LOOK_LEFT = 7,
    CAMERA_LOOK_UP = 8,
    CAMERA_LOOK_DOWN = 9,
    CAMERA_TWIST_RIGHT = 10,
    CAMERA_TWIST_LEFT = 11,
    CAMERA_ROTATE_RIGHT = 12,
    CAMERA_ROTATE_LEFT = 13,
    CAMERA_ROTATE_UP = 14,
    CAMERA_ROTATE_DOWN = 15,
    CAMERA_ZOOM_IN = 16,
    CAMERA_ZOOM_OUT = 17
}

type KeyboardControlActionFn = (cesiumService: CesiumService, params: any, event: KeyboardEvent) => boolean | void;
type KeyboardControlValidationFn = (cesiumService: CesiumService, params: any, event: KeyboardEvent) => boolean;
type KeyboardControlDoneFn = (cesiumService: CesiumService, event: KeyboardEvent) => boolean;
interface KeyboardControlParams {
    action: KeyboardAction | KeyboardControlActionFn;
    validation?: KeyboardControlValidationFn;
    params?: {
        [paramName: string]: any;
    };
    done?: KeyboardControlDoneFn;
}
interface KeyboardControlDefinition {
    [keyboardCharCode: string]: KeyboardControlParams;
}
/**
 *  Service that manages keyboard keys and execute actions per request.
 *  Inject the keyboard control service into any layer, under your `ac-map` component,
 *  And defined you keyboard handlers using `setKeyboardControls`.
 *
 * <caption>Simple Example</caption>
 * ```typescript
 * Component({
 *   selector: 'keyboard-control-layer',
 *   template: '',
 * })
 * export class KeyboardControlLayerComponent implements OnInit, OnDestroy {
 *   constructor(private keyboardControlService: KeyboardControlService) {}
 *
 *   ngOnInit() {
 *     this.keyboardControlService.setKeyboardControls({
 *       W: { action: KeyboardAction.CAMERA_FORWARD },
 *       S: { action: KeyboardAction.CAMERA_BACKWARD },
 *       D: { action: KeyboardAction.CAMERA_RIGHT },
 *       A: { action: KeyboardAction.CAMERA_LEFT },
 *     });
 *    }
 *
 *   ngOnDestroy() {
 *     this.keyboardControlService.removeKeyboardControls();
 *   }
 * }
 * ```
 *
 * <caption>Advanced Example</caption>
 * ```typescript
 * Component({
 *   selector: 'keyboard-control-layer',
 *   template: '',
 * })
 * export class KeyboardControlLayerComponent implements OnInit, OnDestroy {
 *   constructor(private keyboardControlService: KeyboardControlService) {}
 *
 *   private myCustomValue = 10;
 *
 *   ngOnInit() {
 *     this.keyboardControlService.setKeyboardControls({
 *       W: {
 *          action: KeyboardAction.CAMERA_FORWARD,
 *          validate: (camera, scene, params, key) => {
 *            // Replace `checkCamera` you with your validation logic
 *            if (checkCamera(camera) || params.customParams === true) {
 *              return true;
 *            }
 *
 *            return false;
 *          },
 *          params: () => {
 *            return {
 *              myValue: this.myCustomValue,
 *            };
 *          },
 *        }
 *     });
 *    }
 *
 *   ngOnDestroy() {
 *     this.keyboardControlService.removeKeyboardControls();
 *   }
 * }
 * ```
 * <b>Predefined keyboard actions:</b>
 * + `KeyboardAction.CAMERA_FORWARD` - Moves the camera forward, accepts a numeric parameter named `moveRate` that controls
 * the factor of movement, according to the camera height.
 * + `KeyboardAction.CAMERA_BACKWARD` - Moves the camera backward, accepts a numeric parameter named `moveRate` that controls
 * the factor of movement, according to the camera height.
 * + `KeyboardAction.CAMERA_UP` - Moves the camera up, accepts a numeric parameter named `moveRate` that controls
 * the factor of movement, according to the camera height.
 * + `KeyboardAction.CAMERA_DOWN` - Moves the camera down, accepts a numeric parameter named `moveRate` that controls
 * the factor of movement, according to the camera height.
 * + `KeyboardAction.CAMERA_RIGHT` - Moves the camera right, accepts a numeric parameter named `moveRate` that controls
 * the factor of movement, according to the camera height.
 * + `KeyboardAction.CAMERA_LEFT` - Moves the camera left, accepts a numeric parameter named `moveRate` that controls
 * the factor of movement, according to the camera height.
 * + `KeyboardAction.CAMERA_LOOK_RIGHT` - Changes the camera to look to the right, accepts a numeric parameter named `lookFactor` that
 * controls the factor of looking, according to the camera current position.
 * + `KeyboardAction.CAMERA_LOOK_LEFT` - Changes the camera to look to the left, accepts a numeric parameter named `lookFactor` that
 * controls the factor of looking, according to the camera current position.
 * + `KeyboardAction.CAMERA_LOOK_UP` - Changes the camera to look up, accepts a numeric parameter named `lookFactor` that controls
 * the factor of looking, according to the camera current position.
 * + `KeyboardAction.CAMERA_LOOK_DOWN` - Changes the camera to look down, accepts a numeric parameter named `lookFactor` that controls
 * the factor of looking, according to the camera current position.
 * + `KeyboardAction.CAMERA_TWIST_RIGHT` - Twists the camera to the right, accepts a numeric parameter named `amount` that controls
 * the twist amount
 * + `KeyboardAction.CAMERA_TWIST_LEFT` - Twists the camera to the left, accepts a numeric parameter named `amount` that controls
 * the twist amount
 * + `KeyboardAction.CAMERA_ROTATE_RIGHT` - Rotates the camera to the right, accepts a numeric parameter named `angle` that controls
 * the rotation angle
 * + `KeyboardAction.CAMERA_ROTATE_LEFT` - Rotates the camera to the left, accepts a numeric parameter named `angle` that controls
 * the rotation angle
 * + `KeyboardAction.CAMERA_ROTATE_UP` - Rotates the camera upwards, accepts a numeric parameter named `angle` that controls
 * the rotation angle
 * + `KeyboardAction.CAMERA_ROTATE_DOWN` - Rotates the camera downwards, accepts a numeric parameter named `angle` that controls
 * the rotation angle
 * + `KeyboardAction.CAMERA_ZOOM_IN` - Zoom in into the current camera center position, accepts a numeric parameter named
 * `amount` that controls the amount of zoom in meters.
 * + `KeyboardAction.CAMERA_ZOOM_OUT` -  Zoom out from the current camera center position, accepts a numeric parameter named
 * `amount` that controls the amount of zoom in meters.
 */
declare class KeyboardControlService {
    private ngZone;
    private cesiumService;
    private document;
    private _currentDefinitions;
    private _activeDefinitions;
    private _keyMappingFn;
    /**
     * Creats the keyboard control service.
     */
    constructor(ngZone: NgZone, cesiumService: CesiumService, document: any);
    /**
     * Initializes the keyboard control service.
     */
    init(): void;
    /**
     * Sets the current map keyboard control definitions.
     * The definitions is a key mapping between a key string and a KeyboardControlDefinition:
     * - `action` is a predefine action from `KeyboardAction` enum, or a custom method:
     * `(camera, scene, params, key) => boolean | void` - returning false will cancel the current keydown.
     * - `validation` is a method that validates if the event should occur or not (`camera, scene, params, key`)
     * - `params` is an object (or function that returns object) that will be passed into the action executor.
     * - `done` is a function that will be triggered when `keyup` is triggered.
     * @param definitions Keyboard Control Definition
     * @param keyMappingFn - Mapping function for custom keys
     * @param outsideOfAngularZone - if key down events will run outside of angular zone.
     */
    setKeyboardControls(definitions: KeyboardControlDefinition, keyMappingFn?: (keyEvent: KeyboardEvent) => string, outsideOfAngularZone?: boolean): void;
    /**
     * Removes the current set of keyboard control items, and unregister from map events.
     */
    removeKeyboardControls(): void;
    /**
     * Returns the current action that handles `char` key string, or `null` if not exists
     */
    private getAction;
    /**
     * The default `defaultKeyMappingFn` that maps `KeyboardEvent` into a key string.
     */
    private defaultKeyMappingFn;
    /**
     * document's `keydown` event handler
     */
    private handleKeydown;
    /**
     * document's `keyup` event handler
     */
    private handleKeyup;
    /**
     * `tick` event handler that triggered by Cesium render loop
     */
    private handleTick;
    /**
     *
     * Params resolve function, returns object.
     * In case of params function, executes it and returns it's return value.
     *
     */
    private getParams;
    /**
     *
     * Executes a given `KeyboardControlParams` object.
     *
     */
    private executeAction;
    /**
     * Registers to keydown, keyup of `document`, and `tick` of Cesium.
     */
    private registerEvents;
    /**
     * Unregisters to keydown, keyup of `document`, and `tick` of Cesium.
     */
    private unregisterEvents;
    static ɵfac: i0.ɵɵFactoryDeclaration<KeyboardControlService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<KeyboardControlService>;
}

declare class MapLayersService {
    private cesiumService;
    private layersDataSources;
    constructor(cesiumService: CesiumService);
    registerLayerDataSources(dataSources: any[], zIndex: number): void;
    drawAllLayers(): void;
    updateAndRefresh(dataSources: any[], newZIndex: number): void;
    removeDataSources(dataSources: any[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MapLayersService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MapLayersService>;
}

/**
 *  The service manages `ac-map` instances. `ac-map` register itself to this service.
 *  This allows retrieval of maps provided services outside of `ac-map` scope.
 */
declare class MapsManagerService {
    private defaultIdCounter;
    private _Maps;
    private firstMap;
    private eventRemoveCallbacks;
    constructor();
    getMap(id?: string): AcMapComponent | undefined;
    _registerMap(id: string, acMap: AcMapComponent): string;
    _removeMapById(id: string): boolean;
    private generateDefaultId;
    /**
     * Binds multiple 2D map's cameras together.
     * @param mapsConfiguration - binding options.
     * mapId - the id of the maps to bind.
     * sensitivity - the amount the camera position should change in order to sync other maps.
     * bindZoom - should bind zoom level
     */
    sync2DMapsCameras(mapsConfiguration: {
        id: string;
        sensitivity?: number;
        bindZoom?: boolean;
    }[]): void;
    /**
     * Unsyncs maps cameras
     */
    unsyncMapsCameras(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MapsManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MapsManagerService>;
}

/**
 * Take screenshot of your cesium globe.
 *
 * usage:
 * ```typescript
 * // get base 64 data url
 * const dataUrl = screenshotService.getMapScreenshotDataUrl();
 *
 * // or download as png
 * screenshotService.downloadMapScreenshot('my-map.png');
 *
 * ```
 *
 */
declare class ScreenshotService {
    private cesiumService;
    constructor(cesiumService: CesiumService);
    getMapScreenshotDataUrlBase64(): string;
    downloadMapScreenshot(filename?: string): void;
    private downloadURI;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenshotService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ScreenshotService>;
}

/**
 * This is a map implementation, creates the cesium map.
 * Every layer should be tag inside ac-map tag
 *
 * Accessing cesium viewer:
 * 1. acMapComponent.getCesiumViewer()
 * 2. Use MapManagerService.getMap().getCesiumViewer() or if more then one map: MapManagerService.getMap(mapId).getCesiumViewer()
 *
 *
 * @example
 * <ac-map>
 *     <ac-map-layer-provider></ac-map-layer-provider>
 *     <dynamic-ellipse-layer #layer></dynamic-ellipse-layer>
 * </ac-map>
 */
declare class AcMapComponent implements OnChanges, OnInit, AfterViewInit, OnDestroy {
    private _cesiumService;
    private _cameraService;
    private _elemRef;
    private document;
    private mapsManagerService;
    private billboardDrawerService;
    private labelDrawerService;
    private ellipseDrawerService;
    private polylineDrawerService;
    private polygonDrawerService;
    private arcDrawerService;
    private pointDrawerService;
    private czmlDrawerService;
    private mapEventsManager;
    private keyboardControlService;
    private mapLayersService;
    private screenshotService;
    contextMenuService: ContextMenuService;
    private coordinateConverter;
    /**
     * Disable default plonter context menu
     */
    disableDefaultPlonter: boolean;
    /**
     * Set the id name of the map
     * default: 'default-map-id-[index]'
     */
    mapId: string;
    /**
     * flyTo options according to https://cesiumjs.org/Cesium/Build/Documentation/Camera.html?classFilter=cam#flyTo
     */
    flyTo: any;
    /**
     * Sets the map's SceneMode
     */
    sceneMode: SceneMode;
    /**
     * Optional - the container element's id in which the map's canvas will be appended to.
     * If not supplied - the container element will be the parent element of ac-map;
     */
    containerId: string;
    private mapContainer;
    constructor(_cesiumService: CesiumService, _cameraService: CameraService, _elemRef: ElementRef, document: any, mapsManagerService: MapsManagerService, billboardDrawerService: BillboardDrawerService, labelDrawerService: LabelDrawerService, ellipseDrawerService: EllipseDrawerService, polylineDrawerService: PolylineDrawerService, polygonDrawerService: PolygonDrawerService, arcDrawerService: ArcDrawerService, pointDrawerService: PointDrawerService, czmlDrawerService: CzmlDrawerService, mapEventsManager: MapEventsManagerService, keyboardControlService: KeyboardControlService, mapLayersService: MapLayersService, screenshotService: ScreenshotService, contextMenuService: ContextMenuService, coordinateConverter: CoordinateConverter);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * @returns ac-map's cesium service
     */
    getCesiumService(): CesiumService;
    /**
     * @returns map's cesium viewer
     */
    getCesiumViewer(): any;
    getCameraService(): CameraService;
    getId(): string;
    getMapContainer(): HTMLElement;
    getMapEventsManager(): MapEventsManagerService;
    getContextMenuService(): ContextMenuService;
    getScreenshotService(): ScreenshotService;
    getKeyboardControlService(): KeyboardControlService;
    getCoordinateConverter(): CoordinateConverter;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcMapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcMapComponent, "ac-map", never, { "disableDefaultPlonter": { "alias": "disableDefaultPlonter"; "required": false; }; "mapId": { "alias": "mapId"; "required": false; }; "flyTo": { "alias": "flyTo"; "required": false; }; "sceneMode": { "alias": "sceneMode"; "required": false; }; "containerId": { "alias": "containerId"; "required": false; }; }, {}, never, ["*"], false, never>;
}

interface IDescription {
    draw(context: any, id: string, contextEntity: any): void;
    remove(id: string): void;
    removeAll(): void;
}

interface LayerOptions {
    ellipse?: EntitiesDrawerOptions;
    circle?: EntitiesDrawerOptions;
    polygon?: EntitiesDrawerOptions;
    model?: EntitiesDrawerOptions;
    box?: EntitiesDrawerOptions;
    corridor?: EntitiesDrawerOptions;
    cylinder?: EntitiesDrawerOptions;
    ellipsoid?: EntitiesDrawerOptions;
    polylineVolume?: EntitiesDrawerOptions;
    rectangle?: EntitiesDrawerOptions;
    wall?: EntitiesDrawerOptions;
}

declare class LayerService {
    private _context;
    private _options;
    private _show;
    private _zIndex;
    private _entityName;
    private _cache;
    private descriptions;
    private layerUpdate;
    get cache(): boolean;
    set cache(value: boolean);
    get zIndex(): number;
    set zIndex(value: number);
    get show(): boolean;
    set show(value: boolean);
    get options(): LayerOptions;
    set options(value: LayerOptions);
    get context(): any;
    set context(context: any);
    setEntityName(name: string): void;
    getEntityName(): string;
    registerDescription(descriptionComponent: IDescription): void;
    unregisterDescription(descriptionComponent: IDescription): void;
    getDescriptions(): IDescription[];
    layerUpdates(): EventEmitter<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LayerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LayerService>;
}

/**
 * Action to do on entity
 */
declare enum ActionType {
    ADD_UPDATE = 0,
    DELETE = 1
}

/**
 * Interface of  Angular2Cesium notification.
 * ac-layer receives an observer of AcNotifications
 */
interface AcNotification {
    id: string;
    entity?: AcEntity;
    actionType: ActionType;
}
declare class AcNotification {
    id: string;
    entity?: AcEntity;
    actionType: ActionType;
}

declare class ComputationCache {
    private _cache;
    get(expression: string, insertFn: (() => any)): any;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComputationCache, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ComputationCache>;
}

/**
 *  This drawer is responsible for creating the dynamic version of the ellipse component.
 *  We are using the primitive-primitives implementation of an ellipse. see: https://github.com/gotenxds/Primitive-primitives
 *  This allows us to change the position of the ellipses without creating a new primitive object
 *  as Cesium does not allow updating an ellipse.
 */
declare class DynamicEllipseDrawerService extends PrimitivesDrawerService {
    constructor(cesiumService: CesiumService);
    add(cesiumProps: any): any;
    update(ellipse: any, cesiumProps: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicEllipseDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicEllipseDrawerService>;
}

/**
 *  This drawer is responsible for creating the dynamic version of the polyline component.
 */
declare class DynamicPolylineDrawerService extends PrimitivesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPolylineDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicPolylineDrawerService>;
}

/**
 *
 * This drawer is deprecated.
 * General static primitives drawer responsible of drawing static Cesium primitives with material.
 */
declare abstract class StaticPrimitiveDrawer extends PrimitivesDrawerService {
    private geometryType;
    constructor(geometryType: any, cesiumService: CesiumService);
    add(geometryProps: any, instanceProps: any, primitiveProps: any): any;
    update(primitive: any, geometryProps: any, instanceProps: any, primitiveProps: any): any;
}

/**
 *  This drawer is responsible for creating the static version of the circle component.
 */
declare class StaticCircleDrawerService extends StaticPrimitiveDrawer {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<StaticCircleDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StaticCircleDrawerService>;
}

/**
 *  This drawer is responsible for creating the static version of the polyline component.
 *  This also allows us to change the color of the polylines.
 */
declare class StaticPolylineDrawerService extends StaticPrimitiveDrawer {
    constructor(cesiumService: CesiumService);
    /**
     * Update function can only change the primitive color.
     */
    update(primitive: any, geometryProps: any, instanceProps: any, primitiveProps: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<StaticPolylineDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StaticPolylineDrawerService>;
}

/**
 + This drawer is responsible for drawing a polygon over the Cesium map.
 + This implementation uses simple PolygonGeometry and Primitive parameters.
 + This doesn't allow us to change the position, color, etc.. of the polygons. For that you may use the dynamic polygon component.
 */
declare class StaticPolygonDrawerService extends StaticPrimitiveDrawer {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<StaticPolygonDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StaticPolygonDrawerService>;
}

/**
 + *  This drawer is responsible for drawing an ellipse over the Cesium map.
 + *  This implementation uses simple EllipseGeometry and Primitive parameters.
 + *  This doesn't allow us to change the position, color, etc.. of the ellipses. For that you may use the dynamic ellipse component.
 + */
declare class StaticEllipseDrawerService extends StaticPrimitiveDrawer {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<StaticEllipseDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StaticEllipseDrawerService>;
}

/**
 *  This drawer is responsible for drawing models.
 */
declare class ModelDrawerService extends EntitiesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<ModelDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModelDrawerService>;
}

/**
 *  This drawer is responsible for drawing box.
 */
declare class BoxDrawerService extends EntitiesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<BoxDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BoxDrawerService>;
}

/**
 *  This drawer is responsible for drawing corridors .
 */
declare class CorridorDrawerService extends EntitiesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<CorridorDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CorridorDrawerService>;
}

/**
 *  This drawer is responsible for drawing cylinders.
 */
declare class CylinderDrawerService extends EntitiesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<CylinderDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CylinderDrawerService>;
}

/**
 *  This drawer is responsible for drawing ellipsoid.
 */
declare class EllipsoidDrawerService extends EntitiesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<EllipsoidDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EllipsoidDrawerService>;
}

/**
 *  This drawer is responsible for drawing polylines.
 */
declare class PolylineVolumeDrawerService extends EntitiesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<PolylineVolumeDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PolylineVolumeDrawerService>;
}

/**
 *  This drawer is responsible for drawing polygons.
 */
declare class WallDrawerService extends EntitiesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<WallDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WallDrawerService>;
}

/**
 *  This drawer is responsible for drawing rectangles.
 */
declare class RectangleDrawerService extends EntitiesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<RectangleDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RectangleDrawerService>;
}

/**
 *  This drawer is responsible of drawing polylines as primitives.
 *  This drawer is more efficient than PolylineDrawerService when drawing dynamic polylines.
 */
declare class PolylinePrimitiveDrawerService extends PrimitivesDrawerService {
    constructor(cesiumService: CesiumService);
    add(cesiumProps: any): any;
    update(cesiumObject: any, cesiumProps: any): void;
    withColorMaterial(cesiumProps: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<PolylinePrimitiveDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PolylinePrimitiveDrawerService>;
}

/**
 *  This drawer is responsible for drawing labels as primitives.
 *  This drawer is more efficient than LabelDrawerService when drawing dynamic labels.
 */
declare class LabelPrimitiveDrawerService extends PrimitivesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<LabelPrimitiveDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LabelPrimitiveDrawerService>;
}

/**
 *  This drawer is responsible for drawing billboards as primitives.
 *  This drawer is more efficient than BillboardDrawerService when drawing dynamic billboards.
 */
declare class BillboardPrimitiveDrawerService extends PrimitivesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<BillboardPrimitiveDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BillboardPrimitiveDrawerService>;
}

/**
 *  This drawer is responsible of drawing points as primitives.
 *  This drawer is more efficient than PointDrawerService when drawing dynamic points.
 */
declare class PointPrimitiveDrawerService extends PrimitivesDrawerService {
    constructor(cesiumService: CesiumService);
    static ɵfac: i0.ɵɵFactoryDeclaration<PointPrimitiveDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PointPrimitiveDrawerService>;
}

declare class HtmlDrawerService extends PrimitivesDrawerService {
    private _cesiumService;
    constructor(_cesiumService: CesiumService);
    add(cesiumProps: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlDrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HtmlDrawerService>;
}

/**
 *  This is a ac-layer implementation.
 *  The ac-layer element must be a child of ac-map element.
 *  + acFor `{string}` - get the tracked observable and entityName (see the example).
 *  + show `{boolean}` - show/hide layer's entities.
 *  + context `{any}` - get the context layer that will use the componnet (most of the time equal to "this").
 *  + options `{LayerOptions}` - sets the layer options for each drawer.
 *  + zIndex `{number}` - controls the zIndex (order) of the layer, layers with greater zIndex will be in front of layers with lower zIndex
 *    (Exception For `Billboard` and `Label`, should use `[eyeOffset]` prop instead)</br>
 *    zIndex won't work for pritimitve descs (like ac-primitive-polyline...)
 *  + debug `{boolean}` - prints every acNotification
 *
 *
 *  __Usage :__
 *  ```
 *  <ac-map>
 *    <ac-layer acFor="let track of tracks$" [show]="show" [context]="this" [options]="options" [zIndex]="1">
 *      <ac-billboard-desc props="{
 *        image: track.image,
 *        position: track.position,
 *        scale: track.scale,
 *        color: track.color,
 *        name: track.name
 *      }">
 *      </ac-billboard-desc>
 *        <ac-label-desc props="{
 *          position: track.position,
 *          pixelOffset : [-15,20] | pixelOffset,
 *          text: track.name,
 *          font: '15px sans-serif'
 *        }">
 *      </ac-label-desc>
 *    </ac-layer>
 *  </ac-map>
 *  ```
 */
declare class AcLayerComponent implements OnInit, OnChanges, AfterContentInit, OnDestroy {
    private layerService;
    private _computationCache;
    private mapLayersService;
    show: boolean;
    acFor: string;
    context: any;
    store: boolean;
    options: LayerOptions;
    zIndex: number;
    debug: boolean;
    private readonly acForRgx;
    private entityName;
    private stopObservable;
    private observable;
    private _drawerList;
    private _updateStream;
    private entitiesStore;
    private layerDrawerDataSources;
    constructor(layerService: LayerService, _computationCache: ComputationCache, mapLayersService: MapLayersService, billboardDrawerService: BillboardDrawerService, labelDrawerService: LabelDrawerService, ellipseDrawerService: EllipseDrawerService, polylineDrawerService: PolylineDrawerService, polygonDrawerService: PolygonDrawerService, arcDrawerService: ArcDrawerService, pointDrawerService: PointDrawerService, modelDrawerService: ModelDrawerService, boxDrawerService: BoxDrawerService, corridorDrawerService: CorridorDrawerService, cylinderDrawerService: CylinderDrawerService, ellipsoidDrawerSerice: EllipsoidDrawerService, polylineVolumeDrawerService: PolylineVolumeDrawerService, wallDrawerService: WallDrawerService, rectangleDrawerService: RectangleDrawerService, dynamicEllipseDrawerService: DynamicEllipseDrawerService, dynamicPolylineDrawerService: DynamicPolylineDrawerService, staticCircleDrawerService: StaticCircleDrawerService, staticPolylineDrawerService: StaticPolylineDrawerService, staticPolygonDrawerService: StaticPolygonDrawerService, staticEllipseDrawerService: StaticEllipseDrawerService, polylinePrimitiveDrawerService: PolylinePrimitiveDrawerService, labelPrimitiveDrawerService: LabelPrimitiveDrawerService, billboardPrimitiveDrawerService: BillboardPrimitiveDrawerService, pointPrimitiveDrawerService: PointPrimitiveDrawerService, htmlDrawerService: HtmlDrawerService, czmlDrawerService: CzmlDrawerService);
    init(): void;
    private updateStore;
    private initValidParams;
    /** Test for a rxjs Observable */
    private isObservable;
    ngAfterContentInit(): void;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    getLayerService(): LayerService;
    /**
     * Returns an array of DataSources registered by a drawer of this layer
     * @return Array of Cesium.DataSources
     */
    getLayerDrawerDataSources(): any[];
    /**
     * Returns an Array of DataSources of the drawer with the provided DataSource.name
     * Example: getDataSourceOfDrawer('polyline') returns the dataSource of polyline drawer
     * @return Array of Cesium.DataSources
     */
    getDrawerDataSourcesByName(name: string): any[];
    /**
     * Returns the store.
     */
    getStore(): Map<string, any>;
    /**
     * Remove all the entities from the layer.
     */
    removeAll(): void;
    /**
     * remove entity from the layer
     */
    remove(entityId: string): void;
    /**
     * add/update entity to/from the layer
     */
    updateNotification(notification: AcNotification): void;
    /**
     * add/update entity to/from the layer
     */
    update(entity: AcEntity, id: string): void;
    refreshAll(collection: AcNotification[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcLayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcLayerComponent, "ac-layer", never, { "show": { "alias": "show"; "required": false; }; "acFor": { "alias": "acFor"; "required": false; }; "context": { "alias": "context"; "required": false; }; "store": { "alias": "store"; "required": false; }; "options": { "alias": "options"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; }, {}, never, ["*"], false, never>;
}

/**
 *  Extend this class to create drawing on map components.
 */
declare class EntityOnMapComponent implements OnInit, OnChanges, OnDestroy {
    protected _drawer: BasicDrawerService;
    private mapLayers;
    props: any;
    protected selfPrimitive: any;
    protected selfPrimitiveIsDraw: boolean;
    protected dataSources: any;
    constructor(_drawer: BasicDrawerService, mapLayers: MapLayersService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    drawOnMap(): any;
    removeFromMap(): void;
    updateOnMap(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityOnMapComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EntityOnMapComponent, never, never, { "props": { "alias": "props"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 *  This is a billboard implementation.
 *  The element must be a child of ac-map element.
 *  The properties of props are the same as the properties of Entity and BillboardGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/BillboardGraphics.html
 *
 *  __Usage :__
 *  ```
 *    <ac-billboard [props]="{
 *      image: image,
 *      position: position,
 *      scale: scale,
 *      color: color,
 *      name: name
 *    }">;
 *    </ac-billboard>
 *  ```
 */
declare class AcBillboardComponent extends EntityOnMapComponent {
    constructor(billboardDrawer: BillboardDrawerService, mapLayers: MapLayersService);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcBillboardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcBillboardComponent, "ac-billboard", never, {}, {}, never, never, false, never>;
}

declare class JsonMapper {
    private _mapper;
    constructor();
    map(expression: string): Map<string, string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<JsonMapper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<JsonMapper>;
}

declare class CesiumProperties {
    private _parser;
    private _jsonMapper;
    private _assignersCache;
    private _evaluatorsCache;
    constructor(_parser: Parse, _jsonMapper: JsonMapper);
    _compile(expression: string, withCache?: boolean): (cache: ComputationCache, context: Object) => Object;
    _build(expression: string): (oldVal: Object, newVal: Object) => Object;
    createEvaluator(expression: string, withCache?: boolean, newEvaluator?: boolean): (cache: ComputationCache, context: Object) => Object;
    createAssigner(expression: string): (oldVal: Object, newVal: Object) => Object;
    static ɵfac: i0.ɵɵFactoryDeclaration<CesiumProperties, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CesiumProperties>;
}

interface OnDrawParams {
    acEntity: AcEntity;
    entityId: string;
    cesiumEntity: any;
}
/**
 *  the ancestor class for creating components.
 *  extend this class to create desc component.
 */
declare class BasicDesc implements OnInit, OnDestroy, IDescription {
    protected _drawer: BasicDrawerService;
    protected _layerService: LayerService;
    protected _computationCache: ComputationCache;
    protected _cesiumProperties: CesiumProperties;
    props: any;
    onDraw: EventEmitter<OnDrawParams>;
    onRemove: EventEmitter<OnDrawParams>;
    protected _cesiumObjectsMap: Map<string, any>;
    private _propsEvaluateFn;
    private _propsAssignerFn;
    constructor(_drawer: BasicDrawerService, _layerService: LayerService, _computationCache: ComputationCache, _cesiumProperties: CesiumProperties);
    protected _propsEvaluator(context: Object): any;
    protected _getPropsAssigner(): (cesiumObject: Object, desc: Object) => Object;
    getLayerService(): LayerService;
    setLayerService(layerService: LayerService): void;
    ngOnInit(): void;
    getCesiumObjectsMap(): Map<string, any>;
    draw(context: any, id: string, entity: AcEntity): void;
    remove(id: string): void;
    removeAll(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BasicDesc, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BasicDesc, never, never, { "props": { "alias": "props"; "required": false; }; }, { "onDraw": "onDraw"; "onRemove": "onRemove"; }, never, never, true, never>;
}

/**
 *  This is a billboard implementation.
 *  The element must be a child of ac-layer element.
 *  The properties of props are the same as the properties of Entity and BillboardGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/BillboardGraphics.html
 *
 *  __Usage :__
 *  ```
 *    <ac-billboard-desc props="{
 *      image: track.image,
 *      position: track.position,
 *      scale: track.scale,
 *      color: track.color,
 *      name: track.name
 *    }">
 *    </ac-billboard-desc>
 *  ```
 */
declare class AcBillboardDescComponent extends BasicDesc {
    constructor(billboardDrawer: BillboardDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcBillboardDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcBillboardDescComponent, "ac-billboard-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a billboard primitive implementation.
 *  The element must be a child of ac-layer element.
 *  The properties of props are:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Billboard.html
 *
 *  __Usage :__
 *  ```
 *    <ac-billboard-primitive-desc props="{
 *      image: track.image,
 *      position: track.position,
 *      scale: track.scale,
 *      color: track.color,
 *      name: track.name
 *    }">
 *    </ac-billboard-primitive-desc>
 *  ```
 */
declare class AcBillboardPrimitiveDescComponent extends BasicDesc {
    constructor(billboardPrimitiveDrawer: BillboardPrimitiveDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcBillboardPrimitiveDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcBillboardPrimitiveDescComponent, "ac-billboard-primitive-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a label implementation.
 *  The ac-label element must be a child of ac-layer element.
 *  The properties of props are the same as the properties of Entity and LabelGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/LabelGraphics.html
 *
 *  __Usage :__
 *  ```
 *    <ac-label-desc props="{
 *      position: track.position,
 *      pixelOffset : [-15,20] | pixelOffset,
 *      text: track.name,
 *      font: '15px sans-serif'
 *    }">
 *    </ac-label-desc>
 *  ```
 */
declare class AcLabelDescComponent extends BasicDesc {
    constructor(labelDrawer: LabelDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcLabelDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcLabelDescComponent, "ac-label-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a label primitive implementation.
 *  The ac-label element must be a child of ac-layer element.
 *  The properties of props are:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Label.html
 *
 *  __Usage :__
 *  ```
 *    <ac-label-primitive-desc props="{
 *      position: track.position,
 *      pixelOffset : [-15,20] | pixelOffset,
 *      text: track.name,
 *      font: '15px sans-serif'
 *    }">
 *    </ac-label-primitive-desc>
 *  ```
 */
declare class AcLabelPrimitiveDescComponent extends BasicDesc {
    constructor(labelPrimitiveDrawer: LabelPrimitiveDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcLabelPrimitiveDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcLabelPrimitiveDescComponent, "ac-label-primitive-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is an ellipse implementation.
 *  The element must be a child of ac-layer element.
 *  _Set `height` prop for performance enhancement_
 *  The properties of props are the same as the properties of Entity and EllipseGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/EllipseGraphics.html
 *
 *  __Usage :__
 *  ```
 *    <ac-ellipse-desc props="{
 *      position: data.position,
 *      semiMajorAxis:250000.0,
 *      semiMinorAxis:400000.0,
 *      height: 0
 *    }">
 *    </ac-ellipse-desc>
 *  ```
 */
declare class AcEllipseDescComponent extends BasicDesc {
    constructor(ellipseDrawer: EllipseDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcEllipseDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcEllipseDescComponent, "ac-ellipse-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a polyline implementation.
 *  The ac-label element must be a child of ac-map element.
 *  The properties of props are the same as the properties of Entity and PolylineGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/PolylineGraphics.html
 *
 *  __Usage:__
 *  ```
 *    <ac-polyline-desc props="{
 *      width : polyline.width,
 *      positions: polyline.positions,
 *      material: polyline.material
 *    }">
 *    </ac-polyline-desc>
 * ```
 */
declare class AcPolylineDescComponent extends BasicDesc {
    constructor(dynamicPolylineDrawerService: PolylineDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcPolylineDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcPolylineDescComponent, "ac-polyline-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a polyline primitive implementation.
 *  The ac-label element must be a child of ac-map element.
 *  The properties of props are the same as the properties of Polyline Primitive:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Polyline.html
 *
 *  __Usage:__
 *  ```
 *    <ac-polyline-primitive-desc props="{
 *      width : polyline.width,
 *      positions: polyline.positions,
 *      material: polyline.material
 *    }">
 *    </ac-polyline-primitive-desc>
 * ```
 */
declare class AcPolylinePrimitiveDescComponent extends BasicDesc {
    constructor(polylinePrimitiveDrawerService: PolylinePrimitiveDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcPolylinePrimitiveDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcPolylinePrimitiveDescComponent, "ac-polyline-primitive-desc", never, {}, {}, never, never, false, never>;
}

/**
 * @example
 * <ac-label-desc props="{
 *            position: track.position,
 *            pixelOffset : [-15,20] | pixelOffset,
 *            text: track.name,
 *            font: '15px sans-serif'
 *    }">
 * </ac-label-desc>
 */
declare class PixelOffsetPipe implements PipeTransform {
    transform(value: any, args?: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<PixelOffsetPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PixelOffsetPipe, "pixelOffset", false>;
}

declare class RadiansToDegreesPipe implements PipeTransform {
    transform(value: any, args?: any): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadiansToDegreesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RadiansToDegreesPipe, "radiansToDegrees", false>;
}

/**
 *  This is a circle implementation.
 *  The element must be a child of ac-layer element.
 *  semiMajorAxis ans semiMinorAxis are replaced with radius property.
 *  All other properties of props are the same as the properties of Entity and EllipseGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/EllipseGraphics.html
 *
 *__Usage :__
 *  ```
 *    <ac-circle-desc props="{
 *      position: data.position,
 *      radius: 5
 *      granularity:0.08 // Optional
 *    }">
 *    </ac-circle-desc>
 *  ```
 */
declare class AcCircleDescComponent extends BasicDesc {
    constructor(ellipseDrawer: EllipseDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    protected _propsEvaluator(context: Object): any;
    protected _getPropsAssigner(): (cesiumObject: Object, desc: Object) => Object;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcCircleDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcCircleDescComponent, "ac-circle-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is an implementation of an arc.
 *  The element must be a child of ac-layer element.
 *  An arc is not cesium natively implemented and therefore it's API doesn't appear anywhere
 *
 *  __Usage :__
 *  ```
 *    <ac-arc-desc props="{
 *          center: arc.center,
 *          angle: arc.angle,
 *          delta: arc.delta,
 *          radius: arc.radius,
 *          color : arc.color - The color should be Cesium.Color type
 *    }">
 *    </ac-arc-desc>
 *    ```
 *
 *    description of the props :
 *    center - The arc is a section of an outline of a circle, This is the center of the circle
 *    angle - the initial angle of the arc in radians
 *    delta - the spreading of the arc,
 *    radius - the distance from the center to the arc
 *
 *    for example :
 *    angle - 0
 *    delta - π
 *
 *    will draw an half circle
 */
declare class AcArcDescComponent extends BasicDesc {
    constructor(arcDrawer: ArcDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcArcDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcArcDescComponent, "ac-arc-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This component is used for adding a map provider service to the map (ac-map)
 *  options according to selected map provider MapLayerProviderOptions enum.
 *  additional setting can be done with cesium imageryLayer (exposed as class member)
 *  check out: https://cesiumjs.org/Cesium/Build/Documentation/ImageryLayer.html
 *  and: https://cesiumjs.org/Cesium/Build/Documentation/ImageryLayerCollection.html
 *
 *
 *  __Usage :__
 *  ```
 *    <ac-map-layer-provider [options]="optionsObject" [provider]="myProvider">
 *    </ac-map-layer-provider>
 *  ```
 */
declare class AcMapLayerProviderComponent implements OnInit, OnChanges, OnDestroy {
    private cesiumService;
    /**
     * refer to cesium docs for details https://cesiumjs.org/Cesium/Build/Documentation/ImageryProvider.html
     */
    options: {
        url?: string;
    };
    /**
     * the provider
     */
    provider: any;
    /**
     * index (optional) - The index to add the layer at. If omitted, the layer will added on top of all existing layers.
     */
    index: Number;
    /**
     * show (optional) - Determines if the map layer is shown.
     */
    show: boolean;
    /**
     * The alpha blending value of this layer: 0.0 to 1.0
     */
    alpha: number;
    /**
     * The brightness of this layer: 0.0 to 1.0
     */
    brightness: number;
    /**
     * The contrast of this layer: 0.0 to 1.0
     */
    contrast: number;
    imageryLayer: any;
    imageryLayersCollection: any;
    layerProvider: any;
    constructor(cesiumService: CesiumService);
    private createOfflineMapProvider;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcMapLayerProviderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcMapLayerProviderComponent, "ac-map-layer-provider", never, { "options": { "alias": "options"; "required": false; }; "provider": { "alias": "provider"; "required": false; }; "index": { "alias": "index"; "required": false; }; "show": { "alias": "show"; "required": false; }; "alpha": { "alias": "alpha"; "required": false; }; "brightness": { "alias": "brightness"; "required": false; }; "contrast": { "alias": "contrast"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 *  This component is used for adding a terrain provider service to the map (ac-map)
 *  options according to selected terrain provider MapTerrainProviderOptions enum.
 *
 *
 *  __Usage :__
 *  ```
 *    <ac-map-terrain-provider [options]="optionsObject" [provider]="myProvider">
 *    </ac-map-terrain-provider>
 *  ```
 */
declare class AcMapTerrainProviderComponent implements OnInit, OnChanges, OnDestroy {
    private cesiumService;
    /**
     * refer to cesium docs for details https://cesiumjs.org/Cesium/Build/Documentation/TerrainProvider.html
     */
    options: {
        url?: string;
    };
    /**
     * the provider
     */
    provider: any;
    /**
     * show (optional) - Determines if the map layer is shown.
     */
    show: boolean;
    private terrainProvider;
    private defaultTerrainProvider;
    constructor(cesiumService: CesiumService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcMapTerrainProviderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcMapTerrainProviderComponent, "ac-map-terrain-provider", never, { "options": { "alias": "options"; "required": false; }; "provider": { "alias": "provider"; "required": false; }; "show": { "alias": "show"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 *  This is a point implementation.
 *  The ac-label element must be a child of ac-layer element.
 *  The properties of props are the same as the properties of Entity and PointGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/PointGraphics.html
 *
 *  __Usage:__
 *  ```
 *   <ac-point-desc props="{
 *     pixelSize : point.pixelSize, //optional
 *     position : point.positions,
 *     color : point.color  //optional
 *   }">
 *   </ac-point-desc>
 *  ```
 */
declare class AcPointDescComponent extends BasicDesc {
    constructor(pointDrawerService: PointDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcPointDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcPointDescComponent, "ac-point-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a label implementation.
 *  The ac-label element must be a child of ac-map element.
 *  The properties of props are the same as the properties of Entity and LabelGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/LabelGraphics.html
 *
 *  __Usage:__
 *  ```
 *  <ac-label [props]="{
 *    position: position,
 *    text: 'labelText',
 *    font: '30px sans-serif',
 *    fillColor : aquamarine
 *  }">
 *  </ac-label>;
 *  ```
 */
declare class AcLabelComponent extends EntityOnMapComponent {
    constructor(labelDrawer: LabelDrawerService, mapLayers: MapLayersService);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcLabelComponent, "ac-label", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a polyline implementation.
 *  The ac-label element must be a child of ac-map element.
 *  The properties of props are the same as the properties of Polyline Primitive:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Polyline.html
 *
 *  __Usage:__
 *  ```
 *  <ac-polyline [props]="{
 *    position: position,
 *    text: 'labelText',
 *    font: '30px sans-serif'
 *    color: Color.GREEN
 *  }">;
 *  </ac-polyline>
 *  ```
 */
declare class AcPolylineComponent extends EntityOnMapComponent {
    constructor(polylineDrawer: PolylineDrawerService, mapLayers: MapLayersService);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcPolylineComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcPolylineComponent, "ac-polyline", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a polyline implementation.
 *  The ac-label element must be a child of ac-map element.
 *  The properties of props are the same as the properties of Polyline Primitive:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Polyline.html
 *
 *  __Usage:__
 *  ```
 *  <ac-polyline [props]="{
 *    position: position,
 *    text: 'labelText',
 *    font: '30px sans-serif'
 *    color: Color.GREEN
 *  }">;
 *  </ac-polyline>
 *  ```
 */
declare class AcPrimitivePolylineComponent extends EntityOnMapComponent {
    constructor(polylineDrawer: PolylinePrimitiveDrawerService, mapLayers: MapLayersService);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcPrimitivePolylineComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcPrimitivePolylineComponent, "ac-primitive-polyline", never, {}, {}, never, never, false, never>;
}

/**
 *  This is an ellipse implementation.
 *  The element must be a child of ac-map element.
 *  The properties of props are the same as the properties of Entity and EllipseGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/EllipseGraphics.html
 *
 *  __Usage:__
 *  ```
 *  <ac-ellipse [props]="{
 *    position: position,
 *    semiMajorAxis:40000.0,
 *    semiMinorAxis:25000.0,
 *    rotation : 0.785398
 *  }">
 *  </ac-ellipse>
 *  ```
 */
declare class AcEllipseComponent extends EntityOnMapComponent {
    constructor(ellipseDrawer: EllipseDrawerService, mapLayers: MapLayersService);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcEllipseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcEllipseComponent, "ac-ellipse", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a point implementation.
 *  The ac-label element must be a child of ac-map element.
 *  The properties of props are the same as the properties of Entity and PointGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/PointGraphics.html
 *
 *  __Usage:__
 *  ```
 *  <ac-point [props]="{
 *    position: position,
 *    width: 3
 *  }">
 *  </ac-point>
 *  ```
 */
declare class AcPointComponent extends EntityOnMapComponent {
    constructor(pointDrawer: PointDrawerService, mapLayers: MapLayersService);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcPointComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcPointComponent, "ac-point", never, {}, {}, never, never, false, never>;
}

/**
 *  This is an html implementation.
 *  The ac-html element must be a child of ac-map element.
 *  __Usage:__
 *  ```
 *  <ac-html [props]="{position: position, show: true}">;
 *    <p>html element</p>
 *  </ac-html>
 *  ```
 */
declare class AcHtmlComponent implements DoCheck, OnDestroy, OnInit {
    private cesiumService;
    private elementRef;
    private renderer;
    props: any;
    private isDraw;
    preRenderEventListener: () => void;
    constructor(cesiumService: CesiumService, elementRef: ElementRef, renderer: Renderer2);
    setScreenPosition(screenPosition: any): void;
    ngOnInit(): void;
    remove(): void;
    hideElement(): void;
    add(): void;
    ngDoCheck(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcHtmlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcHtmlComponent, "ac-html", never, { "props": { "alias": "props"; "required": false; }; }, {}, never, ["*"], false, never>;
}

/**
 *  This is a circle implementation.
 *  The element must be a child of ac-map element.
 *  semiMajorAxis ans semiMinorAxis are replaced with radius property.
 *  All other properties of props are the same as the properties of Entity and EllipseGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/EllipseGraphics.html
 *
 *  __Usage:__
 *  ```
 *  <ac-circle [props]="{
 *    position: position,
 *    radius:40000.0,
 *    granularity:0.03,
 *  }">
 *  </ac-circle>
 *  ```
 */
declare class AcCircleComponent extends EntityOnMapComponent {
    constructor(ellipseDrawerService: EllipseDrawerService, mapLayers: MapLayersService);
    private updateEllipseProps;
    drawOnMap(): void;
    updateOnMap(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcCircleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcCircleComponent, "ac-circle", never, {}, {}, never, never, false, never>;
}

/**
 *  This is an implementation of an arc.
 *  The element must be a child of ac-map element.
 *  An arc is not natively implemented in cesium.
 *
 *  __Usage :__
 *  ```
 *    <ac-arc-desc geometryProps="{
 *          center: arc.center,
 *          angle: arc.angle,
 *          delta: arc.delta,
 *          radius: arc.radius
 *       }"
 *       instanceProps="{
 *          attributes: arc.attributes
 *       }"
 *       primitiveProps="{
 *          appearance: arc.appearance
 *       }">
 *    </ac-arc-desc>
 *    ```
 */
declare class AcArcComponent extends EntityOnMapComponent implements OnChanges {
    geometryProps: any;
    instanceProps: any;
    primitiveProps: any;
    constructor(arcDrawer: ArcDrawerService, mapLayers: MapLayersService);
    updateOnMap(): void;
    drawOnMap(): any;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcArcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcArcComponent, "ac-arc", never, { "geometryProps": { "alias": "geometryProps"; "required": false; }; "instanceProps": { "alias": "instanceProps"; "required": false; }; "primitiveProps": { "alias": "primitiveProps"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 *  This is a polygon implementation.
 *  The properties of props are the same as the properties of Entity and PolygonGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/PolygonGraphics.html
 *
 *  __Usage:__
 *  ```
 *    <ac-polygon-desc props="{
 *      hierarchy: polygon.hierarchy,
 *      material: polygon.material,
 *      height: polygon.height
 *    }">
 *    </ac-polygon-desc>
 *  ```
 */
declare class AcPolygonDescComponent extends BasicDesc implements OnInit {
    constructor(polygonDrawer: PolygonDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcPolygonDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcPolygonDescComponent, "ac-polygon-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a polygon implementation.
 *  The ac-label element must be a child of ac-map element.
 *  _Set `height` prop for performance enhancement_
 *  The properties of props are the same as the properties of Entity and PolygonGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/PolygonGraphics.html
 *
 *  __Usage:__
 *  ```
 *    <ac-polygon props="{
 *      hierarchy: polygon.hierarchy,
 *      material: polygon.material,
 *      height: polygon.height
 *    }">
 *    </ac-polygon>
 *  ```
 */
declare class AcPolygonComponent extends EntityOnMapComponent {
    constructor(polygonDrawer: PolygonDrawerService, mapLayers: MapLayersService);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcPolygonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcPolygonComponent, "ac-polygon", never, {}, {}, never, never, false, never>;
}

declare class AcDefaultPlonterComponent implements OnInit {
    plonterService: PlonterService;
    private cd;
    private geoConverter;
    constructor(plonterService: PlonterService, cd: ChangeDetectorRef, geoConverter: CoordinateConverter);
    ngOnInit(): void;
    get plonterPosition(): any;
    chooseEntity(entity: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcDefaultPlonterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcDefaultPlonterComponent, "ac-default-plonter", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a model implementation.
 *  The ac-model element must be a child of ac-layer element.
 *  The properties of props are the same as the properties of Entity and ModelGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/ModelGraphics.html
 *
 *  __Usage:__
 *  ```
 *    <ac-model-desc props="{
 *       position : Cesium.Cartesian3.fromDegrees(-123.0744619, 44.0503706),
 *       uri : '../../SampleData/models/CesiumGround/Cesium_Ground.gltf'
 *   }
 *    }">
 *    </ac-model-desc>
 *  ```
 */
declare class AcModelDescComponent extends BasicDesc implements OnInit {
    constructor(modelDrawer: ModelDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcModelDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcModelDescComponent, "ac-model-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This component is used for adding a 3d tileset layer to the map (ac-map).
 *  options according to `Cesium3DTileset` definition.
 *  check out: https://cesiumjs.org/Cesium/Build/Documentation/Cesium3DTileset.html
 *
 *
 *  __Usage :__
 *  ```
 *    <ac-3d-tile-layer [options]="optionsObject">
 *    </ac-3d-tile-layer>
 *  ```
 */
declare class AcTileset3dComponent implements OnInit, OnChanges, OnDestroy {
    private cesiumService;
    /**
     * refer to cesium docs for details https://cesiumjs.org/Cesium/Build/Documentation/Cesium3DTileset.html
     */
    options: {
        url: any;
    };
    /**
     * index (optional) - The index to add the layer at. If omitted, the layer will added on top of all existing layers.
     */
    index: Number;
    /**
     * show (optional) - Determines if the map layer is shown.
     */
    show: boolean;
    /**
     * show (optional) - Sets 3Dtiles style.
     */
    style: any;
    tilesetInstance: any;
    private _3dtilesCollection;
    constructor(cesiumService: CesiumService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcTileset3dComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcTileset3dComponent, "ac-3d-tile-layer", never, { "options": { "alias": "options"; "required": false; }; "index": { "alias": "index"; "required": false; }; "show": { "alias": "show"; "required": false; }; "style": { "alias": "style"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 *  This is a point implementation.
 *  The ac-box-desc element must be a child of ac-layer element.
 *  The properties of props are the same as the properties PointGraphics and the general properties
 *  of Entity (like `position`)
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/BoxGraphics.html
 *
 *  __Usage:__
 *  ```
 *   <ac-box-desc props="{
 *     show : point.show, //optional
 *     position : point.positions,
 *     material : point.color  //optional
 *   }">
 *   </ac-box-desc>
 *  ```
 */
declare class AcBoxDescComponent extends BasicDesc {
    constructor(drawerService: BoxDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcBoxDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcBoxDescComponent, "ac-box-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a point implementation.
 *  The ac-box-desc element must be a child of ac-layer element.
 *  The properties of props are the same as the properties PointGraphics and the general properties
 *  of Entity (like `position`)
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/CylinderGraphics.html
 *
 *  __Usage:__
 *  ```
 *   <ac-cylinder-desc props="{
 *     show : cylinder.show, //optional
 *     position : cylinder.position,
 *     material : cylinder.color  //optional
 *   }">
 *   </ac-cylinder-desc>
 *  ```
 */
declare class AcCylinderDescComponent extends BasicDesc {
    constructor(drawerService: CylinderDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcCylinderDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcCylinderDescComponent, "ac-cylinder-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a point implementation.
 *  The ac-box-desc element must be a child of ac-layer element.
 *  The properties of props are the same as the properties PointGraphics and the general properties
 *  of Entity
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/CorridorGraphics.html
 *
 *  __Usage:__
 *  ```
 *   <ac-corridor-desc props="{
 *     show : point.show, //optional
 *     positions : point.positions,
 *     material : point.color  //optional
 *   }">
 *   </ac-corridor-desc>
 *  ```
 */
declare class AcCorridorDescComponent extends BasicDesc {
    constructor(drawerService: CorridorDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcCorridorDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcCorridorDescComponent, "ac-corridor-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a point implementation.
 *  The ac-box-desc element must be a child of ac-layer element.
 *  The properties of props are the same as the properties PointGraphics and the general properties
 *  of Entity
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/EllipsoidGraphics.html
 *
 *  __Usage:__
 *  ```
 *   <ac-ellipsoid-desc props="{
 *     show : ellipsoid.show, //optional
 *     radii : ellipsoid.radii,
 *     material : ellipsoid.color  //optional
 *   }">
 *   </ac-ellipsoid-desc>
 *  ```
 */
declare class AcEllipsoidDescComponent extends BasicDesc {
    constructor(drawerService: EllipsoidDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcEllipsoidDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcEllipsoidDescComponent, "ac-ellipsoid-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a point implementation.
 *  The element must be a child of ac-layer element.
 *  The properties of props are the same as the properties PointGraphics and the general properties
 *  of Entity
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/PolylineVolumeGraphics.html
 *
 *  __Usage:__
 *  ```
 *   <ac-polyline-volume-desc props="{
 *     show : line.show, //optional
 *     positions : line.positions,
 *     material : line.color  //optional
 *   }">
 *   </ac-polyline-volume-desc>
 *  ```
 */
declare class AcPolylineVolumeDescComponent extends BasicDesc {
    constructor(drawerService: PolylineVolumeDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcPolylineVolumeDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcPolylineVolumeDescComponent, "ac-polyline-volume-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a point implementation.
 *  The ac-box-desc element must be a child of ac-layer element.
 *  The properties of props are the same as the properties PointGraphics and the general properties
 *  of Entity
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/WallGraphics.html
 *
 *  __Usage:__
 *  ```
 *   <ac-wall-desc props="{
 *     show : wall.show, //optional
 *     positions : wall.positions,
 *     material : wall.color  //optional
 *   }">
 *   </ac-wall-desc>
 *  ```
 */
declare class AcWallDescComponent extends BasicDesc {
    constructor(drawerService: WallDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcWallDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcWallDescComponent, "ac-wall-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a point implementation.
 *  The ac-rectangle-desc element must be a child of ac-layer element.
 *  The properties of props are the same as the properties RectangleGraphics and the general properties
 *  of Entity
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/RectangleGraphics.html
 *
 *  __Usage:__
 *  ```
 *   <ac-rectangle-desc props="{
 *     show : rectangle.show, //optional
 *     coordinates : rectangle.positions,
 *     material : rectangle.color  //optional
 *   }">
 *   </ac-rectangle-desc>
 *  ```
 */
declare class AcRectangleDescComponent extends BasicDesc {
    constructor(drawerService: RectangleDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcRectangleDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcRectangleDescComponent, "ac-rectangle-desc", never, {}, {}, never, never, false, never>;
}

/**
 * This component is used to inject the component that is passed to the ContextMenuService when opening a context menu.
 * It shouldn't be used directly.
 *
 * usage:
 * ```typescript
 * // We want to open the context menu on mouse right click.
 * // Register to mouse right click with the MapEventsManager
 * this.mapEventsManager.register({ event: CesiumEvent.RIGHT_CLICK, pick: PickOptions.NO_PICK })
 *    .subscribe(event => {
 *       const position = this.coordinateConverter.screenToCartesian3(event.movement.endPosition, true);
 *       if (!position) {
 *         return;
 *       }
 *       // Open the context menu on the position that was clicked and pass some data to MyCustomContextMenuComponent.
 *       this.contextMenuService.open(
 *         MyCustomContextMenuComponent,
 *         position,
 *         { data: { items: ['New Track', 'Change Map', 'Context Menu', 'Do Something'] } }
 *       )
 *    });
 *
 * ```
 */
declare class AcContextMenuWrapperComponent implements OnInit, OnDestroy {
    contextMenuService: ContextMenuService;
    private cd;
    private componentFactoryResolver;
    private contextMenuChangeSubscription;
    private contextMenuOpenSubscription;
    viewContainerRef: ViewContainerRef;
    constructor(contextMenuService: ContextMenuService, cd: ChangeDetectorRef, componentFactoryResolver: ComponentFactoryResolver);
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcContextMenuWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcContextMenuWrapperComponent, "ac-context-menu-wrapper", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a label primitive implementation.
 *  The ac-label element must be a child of ac-layer element.
 *  The properties of props are:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Point.html
 *
 *  __Usage :__
 *  ```
 *    <ac-point-primitive-desc props="{
 *      position: track.position,
 *      color: Color.RED
 *    }">
 *    </ac-point-primitive-desc>
 *  ```
 */
declare class AcPointPrimitiveDescComponent extends BasicDesc {
    constructor(pointPrimitiveDrawerService: PointPrimitiveDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcPointPrimitiveDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcPointPrimitiveDescComponent, "ac-point-primitive-desc", never, {}, {}, never, never, false, never>;
}

declare class AcHtmlManager {
    private _entities;
    constructor();
    has(id: string): boolean;
    get(id: string): {
        entity: any;
        primitive: any;
    };
    addOrUpdate(id: any, info: {
        entity: any;
        primitive: any;
    }): void;
    remove(id: string): void;
    forEach(callback: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcHtmlManager, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AcHtmlManager>;
}

declare class AcHtmlContext {
    id: any;
    context: any;
    constructor(id: any, context: any);
}
declare class AcHtmlDirective implements OnInit {
    private _templateRef;
    private _viewContainerRef;
    private _changeDetector;
    private _layerService;
    private _acHtmlManager;
    private _views;
    constructor(_templateRef: TemplateRef<AcHtmlContext>, _viewContainerRef: ViewContainerRef, _changeDetector: ChangeDetectorRef, _layerService: LayerService, _acHtmlManager: AcHtmlManager);
    ngOnInit(): void;
    private _handleView;
    addOrUpdate(id: any, primitive: any): void;
    remove(id: any, primitive: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcHtmlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AcHtmlDirective, "[acHtml]", never, {}, {}, never, never, false, never>;
}

/**
 *  This is an html implementation.
 *  The ac-html element must be a child of ac-layer element.
 *  <br>
 *  [props] accepts position(Cartesian3) and show(boolean).
 *
 *  __Usage:__
 *  ```
 *  <ac-layer acFor="let html of htmls$" [context]="this">
 <ac-html-desc props="{position: html.position, show: html.show}">
 <ng-template let-html>
 <div>
 <h1>This is ac-html {{html.name}}</h1>
 <button (click)="changeText(html, 'Test')">change text</button>
 </div>
 </ng-template>
 </ac-html-desc>
 *  <ac-html [props]="{position: position, show: true}">;
 *    <p>html element</p>
 *  </ac-html>
 *  ```
 */
declare class AcHtmlDescComponent extends BasicDesc implements OnInit {
    acHtmlCreator: AcHtmlDirective;
    acHtmlTemplate: TemplateRef<any>;
    constructor(htmlDrawer: HtmlDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    ngOnInit(): void;
    draw(context: any, id: any): any;
    remove(id: string): void;
    removeAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcHtmlDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcHtmlDescComponent, "ac-html-desc", never, {}, {}, ["acHtmlTemplate"], never, false, never>;
}

declare class AcHtmlContainerDirective implements OnInit {
    private _element;
    private _acHtmlManager;
    private _id;
    constructor(_element: ElementRef, _acHtmlManager: AcHtmlManager);
    set acHtmlContainer(id: string);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcHtmlContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AcHtmlContainerDirective, "[acHtmlContainer]", never, { "acHtmlContainer": { "alias": "acHtmlContainer"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 *  This is component represents an array under `ac-layer`.
 *  The element must be a child of ac-layer element.
 *  + acFor `{string}` - get the tracked array and entityName (see the example).
 *  + idGetter `{Function}` - a function that gets the id for a given element in the array -should be defined for maximum performance.
 *  + show `{boolean}` - show/hide array's entities.
 *
 *  __Usage :__
 *  ```
 *<ac-layer acFor="let track of tracks$" [show]="show" [context]="this" [store]="true">
 *  <ac-array-desc acFor="let arrayItem of track.array" [idGetter]="trackArrayIdGetter">
 *    <ac-array-desc acFor="let innerArrayItem of arrayItem.innerArray" [idGetter]="trackArrayIdGetter">
 *      <ac-point-desc props="{
 *        position: innerArrayItem.pos,
 *        pixelSize: 10,
 *        color: getTrackColor(track),
 *        outlineColor: Color.BLUE,
 *        outlineWidth: 1
 *      }">
 *      </ac-point-desc>
 *    </ac-array-desc>
 *  </ac-array-desc>
 *</ac-layer>
 *  ```
 */
declare class AcArrayDescComponent implements OnChanges, OnInit, AfterContentInit, OnDestroy, IDescription {
    layerService: LayerService;
    private cd;
    acFor: string;
    idGetter: (item: any, index: number) => string;
    show: boolean;
    private layer;
    private basicDescs;
    private arrayDescs;
    private entitiesMap;
    private layerServiceSubscription;
    private id;
    private readonly acForRgx;
    entityName: string;
    arrayPath: string;
    arrayObservable$: Subject<AcNotification>;
    constructor(layerService: LayerService, cd: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    setLayerService(layerService: LayerService): void;
    draw(context: any, id: string, contextEntity: any): void;
    remove(id: string): void;
    removeAll(): void;
    getAcForString(): string;
    private generateCombinedId;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcArrayDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcArrayDescComponent, "ac-array-desc", never, { "acFor": { "alias": "acFor"; "required": false; }; "idGetter": { "alias": "idGetter"; "required": false; }; "show": { "alias": "show"; "required": false; }; }, {}, ["basicDescs", "arrayDescs"], ["*"], false, never>;
}

/**
 *  This is a czml implementation.
 *  The ac-czml-desc element must be a child of ac-layer element.
 *
 *  See CZML Guide for the structure of props.czmlPacket:
 *  + https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/CZML-Structure
 *
 *  Attention: the first czmlPacket in the stream needs to be a document
 *  with an id and a name attribute. See this example
 *  + https://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=CZML%20Point%20-%20Time%20Dynamic.html&label=CZML
 *
 *  To see a working example, use the demo app and
 *  + uncomment <czml-layer></czml-layer> in demo-map.component.html
 *  + set the properties 'timeline', 'animation' and 'shouldAnimate' true in viewerOptions of demo-map.component.ts
 *
 *
 *  __Usage:__
 *  ```
 *    <ac-czml-desc props="{
 *      czmlPacket: czmlPacket
 *    }">
 *    </ac-czml-desc>
 *  ```
 */
declare class AcCzmlDescComponent extends BasicDesc implements OnInit {
    constructor(czmlDrawer: CzmlDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcCzmlDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcCzmlDescComponent, "ac-czml-desc", never, {}, {}, never, never, false, never>;
}

declare class BasicStaticPrimitiveDesc extends BasicDesc implements OnInit {
    protected _staticPrimitiveDrawer: StaticPrimitiveDrawer;
    geometryProps: any;
    instanceProps: any;
    primitiveProps: any;
    private _geometryPropsEvaluator;
    private _instancePropsEvaluator;
    private _primitivePropsEvaluator;
    constructor(_staticPrimitiveDrawer: StaticPrimitiveDrawer, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    ngOnInit(): void;
    draw(context: any, id: string, entity: AcEntity): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<BasicStaticPrimitiveDesc, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BasicStaticPrimitiveDesc, never, never, { "geometryProps": { "alias": "geometryProps"; "required": false; }; "instanceProps": { "alias": "instanceProps"; "required": false; }; "primitiveProps": { "alias": "primitiveProps"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 *
 * @deprecated use ac-ellipse-desc instead
 *
 *  This is a static (position, color, etc.. are not updated) implementation of an ellipse.
 *  __usage:__
 *  ```
 *  &lt;ac-static-ellipse-desc-desc
 *      geometryProps="{
 *          center: ellipse.geometry.center,
 *          semiMajorAxis: ellipse.geometry.semiMajorAxis,
 *          semiMinorAxis: ellipse.geometry.semiMinorAxis,
 *          height: ellipse.geometry.height,
 *          rotation: ellipse.geometry.rotation
 *      }"
 *      instanceProps="{
 *          attributes: ellipse.attributes //Optional
 *      }"
 *      primitiveProps="{
 *          appearance: ellipse.appearance //Optional
 *      }"&gt;
 *  &lt;/ac-static-ellipse-desc-desc&gt;
 *  ```
 */
declare class AcStaticEllipseDescComponent extends BasicStaticPrimitiveDesc {
    constructor(ellipseDrawer: StaticEllipseDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcStaticEllipseDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcStaticEllipseDescComponent, "ac-static-ellipse-desc", never, {}, {}, never, never, false, never>;
}

/**
 *
 *
 *  This is a dynamic(position is updatable) implementation of an ellipse.
 *
 *  __Usage :__
 *  ```
 *    &lt;ac-dynamic-ellipse-desc props="{
 *      center: data.position,
 *      semiMajorAxis:250000.0,
 *      semiMinorAxis:400000.0,
 *      rotation : 0.785398,
 *      width:3, // Optional
 *      granularity:0.08 // Optional
 *      }"&gt;
 *    ">
 *    &lt;/ac-dynamic-ellipse-desc&gt;
 *  ```
 *  __param:__ {Cartesian3} center
 *  __param:__ {number} semiMajorAxis
 *  __param:__ {number} semiMinorAxis
 *  __param:__ {number} rotation
 *   __param__: {number} [1] width
 *   __param__: {number} [0.003] granularity
 */
declare class AcDynamicEllipseDescComponent extends BasicDesc {
    constructor(ellipseDrawer: DynamicEllipseDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcDynamicEllipseDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcDynamicEllipseDescComponent, "ac-dynamic-ellipse-desc", never, {}, {}, never, never, false, never>;
}

/**
 * @deprecated use ac-polylinc-desc instead
 *
 *  This is a dynamic(position is updatable) implementation of an polyline.
 *  The ac-dynamic-polyline-desc element must be a child of ac-layer element.
 *  __Usage:__
 *  ```
 *    &lt;ac-dynamic-polyline-desc props="{width : polyline.width, //optional
 *                                      positions: polyline.positions,
 *                                      material: polyline.material //optional
 *                                      }"
 *    &gt;
 *    &lt;/ac-dynamic-polyline-desc&gt;
 * ```
 */
declare class AcDynamicPolylineDescComponent extends BasicDesc {
    constructor(dynamicPolylineDrawerService: DynamicPolylineDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcDynamicPolylineDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcDynamicPolylineDescComponent, "ac-dynamic-polyline-desc", never, {}, {}, never, never, false, never>;
}

/**
 * @deprecated use ac-ployline-desc instead
 *
 *  This is a static implementation of an polyline.
 *  __usage:__
 *  ```
 *    &ltac-static-polyline-desc
 *            geometryProps="{
 *            	width: poly.geometry.width,
 *            	positions: poly.geometry.positions
 *            }"
 *            instanceProps="{
 *              attributes: {
 *                  ColorGeometryInstanceAttribute.fromColor(Color.fromRandom())
 *              }
 *            }"
 *            primitiveProps="{
 *              appearance: new PolylineColorAppearance()
 *    }"&gt&lt/ac-static-polyline-desc&gt
 *  ```
 */
declare class AcStaticPolylineDescComponent extends BasicStaticPrimitiveDesc {
    constructor(polylineDrawerService: StaticPolylineDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcStaticPolylineDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcStaticPolylineDescComponent, "ac-static-polyline-desc", never, {}, {}, never, never, false, never>;
}

/**
 * @deprecated use ac-circle-desc instead
 *
 *  This is a dynamic(position is updatable) implementation of an circle.
 __Usage :__
 *  ```
 *    &lt;ac-dynamic-circle-desc props="{
 *      center: data.position,
 *      radius: 5
 *      rotation : 0.785398,
 *      width:3, // Optional
 *      granularity:0.08 // Optional
 *      }"&gt;
 *    &lt;/ac-dynamic-circle-desc&gt;
 *  ```
 *
 *  __param__: {Cartesian3} center
 *   __param__: {number} rotation
 *   __param__: {number} radius in meters
 *   __param__: {number} [1] width
 *   __param__: {number} [0.003] granularity
 */
declare class AcDynamicCircleDescComponent extends BasicDesc {
    constructor(ellipseDrawer: DynamicEllipseDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    protected _propsEvaluator(context: Object): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcDynamicCircleDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcDynamicCircleDescComponent, "ac-dynamic-circle-desc", never, {}, {}, never, never, false, never>;
}

/**
 * @deprecated use ac-circle-desc
 *
 *  This is a static (position, color, etc.. are not updated) implementation of an circle.
 *  __usage:__
 *  ```
 *    &lt;ac-static-circle-desc
 *      geometryProps="{
 *          center: circle.geometry.center,
 *          radius: circle.geometry.radius,
 *      }"
 *      instanceProps="{
 *          attributes: circle.attributes //Optional
 *      }"
 *      primitiveProps="{
 *          appearance: circle.appearance //Optional
 *      }"&gt;
 *    &lt;/ac-static-circle-desc&gt;
 *    ```
 */
declare class AcStaticCircleDescComponent extends BasicStaticPrimitiveDesc {
    constructor(staticCircleDrawer: StaticCircleDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcStaticCircleDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcStaticCircleDescComponent, "ac-static-circle", never, {}, {}, never, never, false, never>;
}

/**
 * @deprecated use ac-ploygon-desc instead
 *
 *  This is a static (position, color, etc.. are not updated) implementation of a polygon.
 *  __Usage:__
 *  ```
 *    &lt;ac-static-polygon-desc
 *          geometryProps="{
 *                     polygonHierarchy: polygon.geometry.polygonHierarchy,
 *                     height: polygon.geometry.height,
 *                     granularity: polygon.geometry.granularity
 *                 }"
 *          instanceProps="{
 *                     attributes: polygon.attributes
 *                 }"
 *          primitiveProps="{
 *                     appearance: polygon.appearance
 *                 }"
 *    &gt;&lt;/ac-static-polygon-desc&gt;
 *    ```
 */
declare class AcStaticPolygonDescComponent extends BasicStaticPrimitiveDesc {
    constructor(polygonDrawer: StaticPolygonDrawerService, layerService: LayerService, computationCache: ComputationCache, cesiumProperties: CesiumProperties);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcStaticPolygonDescComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcStaticPolygonDescComponent, "ac-static-polygon-desc", never, {}, {}, never, never, false, never>;
}

/**
 *  This is a rectangle implementation.
 *  The ac-label element must be a child of ac-map element.
 *  The properties of props are the same as the properties of Entity and RectangleGraphics:
 *  + https://cesiumjs.org/Cesium/Build/Documentation/Entity.html
 *  + https://cesiumjs.org/Cesium/Build/Documentation/RectangleGraphics.html
 *
 *  __Usage:__
 *  ```
 *    <ac-rectangle props="{
 *      coordinates: rectangle.coordinates,
 *      material: rectangle.material,
 *      height: rectangle.height
 *    }">
 *    </ac-rectangle>
 *  ```
 */
declare class AcRectangleComponent extends EntityOnMapComponent {
    constructor(rectangleDrawer: RectangleDrawerService, mapLayers: MapLayersService);
    static ɵfac: i0.ɵɵFactoryDeclaration<AcRectangleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcRectangleComponent, "ac-rectangle", never, {}, {}, never, never, false, never>;
}

declare class UtilsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UtilsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UtilsModule, never, [typeof i1.CommonModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UtilsModule>;
}

declare class AngularCesiumModule {
    static forRoot(config?: ModuleConfiguration): ModuleWithProviders<AngularCesiumModule>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AngularCesiumModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularCesiumModule, [typeof AcMapComponent, typeof AcLayerComponent, typeof AcBillboardComponent, typeof AcBillboardDescComponent, typeof AcBillboardPrimitiveDescComponent, typeof AcLabelDescComponent, typeof AcLabelPrimitiveDescComponent, typeof AcEllipseDescComponent, typeof AcPolylineDescComponent, typeof AcPolylinePrimitiveDescComponent, typeof PixelOffsetPipe, typeof RadiansToDegreesPipe, typeof AcCircleDescComponent, typeof AcArcDescComponent, typeof AcMapLayerProviderComponent, typeof AcMapTerrainProviderComponent, typeof AcPointDescComponent, typeof AcLabelComponent, typeof AcPolylineComponent, typeof AcPrimitivePolylineComponent, typeof AcEllipseComponent, typeof AcPointComponent, typeof AcBillboardComponent, typeof AcHtmlComponent, typeof AcCircleComponent, typeof AcArcComponent, typeof AcPolygonDescComponent, typeof AcPolygonComponent, typeof AcDefaultPlonterComponent, typeof AcModelDescComponent, typeof AcTileset3dComponent, typeof AcBoxDescComponent, typeof AcCylinderDescComponent, typeof AcCorridorDescComponent, typeof AcEllipsoidDescComponent, typeof AcPolylineVolumeDescComponent, typeof AcWallDescComponent, typeof AcRectangleDescComponent, typeof AcContextMenuWrapperComponent, typeof AcPointPrimitiveDescComponent, typeof AcHtmlDescComponent, typeof AcHtmlDirective, typeof AcHtmlContainerDirective, typeof AcArrayDescComponent, typeof AcCzmlDescComponent, typeof AcStaticEllipseDescComponent, typeof AcDynamicEllipseDescComponent, typeof AcDynamicPolylineDescComponent, typeof AcStaticPolylineDescComponent, typeof AcDynamicCircleDescComponent, typeof AcStaticCircleDescComponent, typeof AcStaticPolygonDescComponent, typeof AcRectangleComponent], [typeof i1.CommonModule, typeof i54.Angular2ParseModule, typeof UtilsModule], [typeof AcMapComponent, typeof AcBillboardComponent, typeof AcBillboardDescComponent, typeof AcBillboardPrimitiveDescComponent, typeof AcLabelDescComponent, typeof AcLabelPrimitiveDescComponent, typeof AcEllipseDescComponent, typeof AcPolylineDescComponent, typeof AcPolylinePrimitiveDescComponent, typeof AcLayerComponent, typeof AcCircleDescComponent, typeof AcArcDescComponent, typeof AcMapLayerProviderComponent, typeof AcMapTerrainProviderComponent, typeof AcPointDescComponent, typeof AcLabelComponent, typeof AcPolylineComponent, typeof AcPrimitivePolylineComponent, typeof AcEllipseComponent, typeof AcPointComponent, typeof AcBillboardComponent, typeof AcHtmlComponent, typeof AcCircleComponent, typeof AcArcComponent, typeof AcPolygonDescComponent, typeof AcPolygonComponent, typeof AcDefaultPlonterComponent, typeof AcModelDescComponent, typeof AcTileset3dComponent, typeof AcBoxDescComponent, typeof AcCylinderDescComponent, typeof AcCorridorDescComponent, typeof AcEllipsoidDescComponent, typeof AcPolylineVolumeDescComponent, typeof AcWallDescComponent, typeof AcRectangleDescComponent, typeof AcPointPrimitiveDescComponent, typeof AcHtmlDescComponent, typeof AcArrayDescComponent, typeof AcCzmlDescComponent, typeof AcRectangleComponent, typeof AcStaticEllipseDescComponent, typeof AcDynamicEllipseDescComponent, typeof AcDynamicPolylineDescComponent, typeof AcStaticPolylineDescComponent, typeof AcDynamicCircleDescComponent, typeof AcStaticCircleDescComponent, typeof AcStaticPolygonDescComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AngularCesiumModule>;
}

interface Vec3 {
    x: number;
    y: number;
    z: number;
}

declare class GeoUtilsService {
    private cesiumService;
    static pointByLocationDistanceAndAzimuth(currentLocation: any, meterDistance: number, radianAzimuth: number, deprecated?: any): any;
    static _pointByLocationDistanceAndAzimuth(cartographicLocation: any, distance: number, radianAzimuth: number): Cartesian3;
    static distance(pos0: Cartesian3, pos1: Cartesian3): number;
    static getPositionsDelta(position0: Cartesian3, position1: Cartesian3): Vec3;
    static addDeltaToPosition(position: Cartesian3, delta: Vec3, updateReference?: boolean): Cartesian3;
    static middleCartesian3Point(position0: Cartesian3, position1: Cartesian3): Cartesian3;
    constructor(cesiumService: CesiumService);
    screenPositionToCartesian3(screenPos: {
        x: number;
        y: number;
    }): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<GeoUtilsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GeoUtilsService>;
}

declare const PREDEFINED_KEYBOARD_ACTIONS: {
    [key: number]: KeyboardControlActionFn;
};

interface SelectionOptions {
    event?: CesiumEvent;
    modifier?: CesiumEventModifier;
    entityType?: any;
}
/**
 * Manages entity selection service for any given mouse event and modifier
 * the service will manage the list of selected items.
 * check out the example
 * you must provide the service yourself
 *
 *  __Usage :__
 * ```
 * // provide the service in some component
 * @Component({
 * //...
 *  providers: [SelectionManagerService]
 * }
 *
 * // Usage example:
 * // init selection
 * const selectedIndicator = ture; // optional default true, if true a boolean "selected" property will be added to the selected entity
 * selectionManagerService.initSelection({ event: CesiumEvent.LEFT_CLICK,
 * 																			modifier: CesiumEventModifier.CTRL
 * 																		},selectedIndicator);
 * // Get selected
 * const selected = selectionManagerService.selected();
 *
 * // Or as observer
 * const selected$ = selectionManagerService.selected$();
 *
 * ```
 *
 */
declare class SelectionManagerService {
    private mapsManager;
    selectedEntitiesItems$: BehaviorSubject<AcEntity[]>;
    selectedEntitySubject$: Subject<AcEntity>;
    private mapEventsManagerService;
    constructor(mapsManager: MapsManagerService);
    selectedEntities$(): Observable<AcEntity[]>;
    selectedEntities(): AcEntity[];
    selectedEntity$(): Subject<AcEntity>;
    toggleSelection(entity: AcEntity, addSelectedIndicator: boolean): void;
    private addToSelected;
    private removeSelected;
    initSelection(selectionOptions?: SelectionOptions, addSelectedIndicator?: boolean, eventPriority?: number, mapId?: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SelectionManagerService>;
}

declare class MapLayerProviderOptions {
    static ArcGisMapServer: typeof Cesium.ArcGisMapServerImageryProvider;
    static WebMapTileService: typeof Cesium.WebMapTileServiceImageryProvider;
    static MapTileService: typeof Cesium.TileMapServiceImageryProvider;
    static WebMapService: typeof Cesium.WebMapServiceImageryProvider;
    static SingleTileImagery: typeof Cesium.SingleTileImageryProvider;
    static OpenStreetMap: typeof Cesium.OpenStreetMapImageryProvider;
    static BingMaps: typeof Cesium.BingMapsImageryProvider;
    static GoogleEarthEnterpriseMaps: typeof Cesium.GoogleEarthEnterpriseMapsProvider;
    static MapBox: typeof Cesium.MapboxImageryProvider;
    static MapboxStyleImageryProvider: typeof Cesium.MapboxStyleImageryProvider;
    static UrlTemplateImagery: typeof Cesium.UrlTemplateImageryProvider;
    static OFFLINE: any;
}

declare class MapTerrainProviderOptions {
    static CesiumTerrain: typeof Cesium.CesiumTerrainProvider;
    static ArcGISTiledElevation: typeof Cesium.ArcGISTiledElevationTerrainProvider;
    static GoogleEarthEnterprise: typeof Cesium.GoogleEarthEnterpriseTerrainProvider;
    static VRTheWorld: typeof Cesium.VRTheWorldTerrainProvider;
    static Ellipsoid: typeof Cesium.EllipsoidTerrainProvider;
    static WorldTerrain: typeof Cesium.createWorldTerrainAsync;
}

interface Vec2 {
    x: number;
    y: number;
}

interface ClampTo3DOptions {
    clampToTerrain?: boolean;
    clampMostDetailed?: boolean;
    clampToHeightPickWidth?: number;
}
interface PolylineProps {
    width?: number;
    material?: Function;
    clampToGround?: boolean;
    zIndex?: number;
    classificationType?: any;
}
interface PolylineEditOptions extends EditorEditOptions {
    addLastPointEvent?: CesiumEvent;
    addLastPointModifier?: CesiumEventModifier;
    removePointEvent?: CesiumEvent;
    removePointModifier?: CesiumEventModifier;
    maximumNumberOfPoints?: number;
    clampHeightTo3D?: boolean;
    clampHeightTo3DOptions?: ClampTo3DOptions;
}

interface EditorEditOptions {
    addPointEvent?: CesiumEvent;
    addPointModifier?: CesiumEventModifier;
    dragPointEvent?: CesiumEvent;
    dragShapeEvent?: CesiumEvent;
    pointProps?: PointProps;
    polylineProps?: PolylineProps;
    allowDrag?: boolean;
    pickConfiguration?: PickConfiguration;
}

interface PointProps {
    color?: any;
    outlineColor?: any;
    outlineWidth?: number;
    virtualPointPixelSize?: number;
    pixelSize?: number;
    showVirtual?: boolean;
    show?: boolean;
    disableDepthTestDistance?: number;
    heightReference?: any;
}
interface PointEditOptions extends EditorEditOptions {
    addLastPointEvent?: CesiumEvent;
    addLastPointModifier?: CesiumEventModifier;
    removePointEvent?: CesiumEvent;
    removePointModifier?: CesiumEventModifier;
}

declare class EditPoint extends AcEntity {
    static counter: number;
    private id;
    private editedEntityId;
    private position;
    private _virtualEditPoint;
    private pointProps;
    private _show;
    constructor(entityId: string, position: Cartesian3, pointProps?: PointProps, virtualPoint?: boolean);
    get show(): boolean;
    set show(value: boolean);
    get props(): PointProps;
    set props(value: PointProps);
    isVirtualEditPoint(): boolean;
    setVirtualEditPoint(value: boolean): void;
    getEditedEntityId(): string;
    getPosition(): Cartesian3;
    getPositionCallbackProperty(): CallbackProperty;
    setPosition(position: Cartesian3): void;
    getId(): string;
    private generateId;
}

interface LabelStyle {
    show?: boolean;
    font?: string;
    style?: any;
    fillColor?: any;
    outlineColor?: any;
    backgroundColor?: any;
    backgroundPadding?: any;
    showBackground?: boolean;
    scale?: number;
    distanceDisplayCondition?: any;
    heightReference?: any;
    horizontalOrigin?: any;
    eyeOffset?: Cartesian3;
    position?: Cartesian3;
    pixelOffset?: Cartesian2;
    pixelOffsetScaleByDistance?: any;
    outlineWidth?: any;
    scaleByDistance?: any;
    translucencyByDistance?: any;
    verticalOrigin?: any;
    disableDepthTestDistance?: number;
}
interface LabelProps {
    text: string;
    show?: boolean;
    font?: string;
    style?: any;
    fillColor?: any;
    outlineColor?: any;
    backgroundColor?: any;
    backgroundPadding?: any;
    showBackground?: boolean;
    scale?: number;
    distanceDisplayCondition?: any;
    heightReference?: any;
    horizontalOrigin?: any;
    eyeOffset?: Cartesian3;
    position?: Cartesian3;
    pixelOffset?: Cartesian2;
    pixelOffsetScaleByDistance?: any;
    outlineWidth?: any;
    scaleByDistance?: any;
    translucencyByDistance?: any;
    verticalOrigin?: any;
    disableDepthTestDistance?: number;
}
declare const defaultLabelProps: LabelProps;

interface PositionWithPointProps {
    position: Cartesian3;
    pointProp?: PointProps;
}
declare class EditablePoint extends AcEntity {
    private id;
    private pointLayer;
    private coordinateConverter;
    private editOptions;
    private point;
    private _enableEdit;
    private _props;
    private _labels;
    constructor(id: string, pointLayer: AcLayerComponent, coordinateConverter: CoordinateConverter, editOptions: PointEditOptions, position?: Cartesian3);
    get labels(): LabelProps[];
    set labels(labels: LabelProps[]);
    get props(): PointProps;
    set props(value: PointProps);
    get enableEdit(): boolean;
    set enableEdit(value: boolean);
    private createFromExisting;
    private hasPosition;
    setManually(point: PositionWithPointProps | Cartesian3, props?: PointProps): void;
    addLastPoint(position: Cartesian3): void;
    movePoint(toPosition: Cartesian3): void;
    getCurrentPoint(): EditPoint;
    getPosition(): Cartesian3;
    getPositionCallbackProperty(): CallbackProperty;
    private updatePointLayer;
    update(): void;
    dispose(): void;
    getId(): string;
}

declare class PointsManagerService {
    points: Map<string, EditablePoint>;
    createEditablePoint(id: string, editPointLayer: AcLayerComponent, coordinateConverter: CoordinateConverter, editOptions?: PointEditOptions, position?: Cartesian3): void;
    enableAll(): void;
    disableAll(): void;
    dispose(id: string): void;
    get(id: string): EditablePoint;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PointsManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PointsManagerService>;
}

declare enum EditModes {
    CREATE = 0,
    EDIT = 1,
    CREATE_OR_EDIT = 2
}

declare enum EditActions {
    INIT = 0,
    MOUSE_MOVE = 1,
    ADD_POINT = 2,
    ADD_LAST_POINT = 3,
    CHANGE_TO_EDIT = 4,
    REMOVE_POINT = 5,
    DRAG_POINT = 6,
    DRAG_POINT_FINISH = 7,
    DRAG_SHAPE = 8,
    DRAG_SHAPE_FINISH = 9,
    DONE = 10,
    DISABLE = 11,
    ENABLE = 12,
    DISPOSE = 13,
    SET_EDIT_LABELS_RENDER_CALLBACK = 14,
    UPDATE_EDIT_LABELS = 15,
    SET_MANUALLY = 16,
    TRANSFORM = 17
}

interface BasicEditUpdate<T> {
    id: string;
    editMode: EditModes;
    editAction: EditActions;
    labelsRenderFn?: (update: T, labels: LabelProps[]) => LabelProps[];
    updateLabels?: LabelProps[];
}

interface PointEditUpdate extends BasicEditUpdate<PointEditUpdate> {
    position?: Cartesian3;
    updatedPosition?: Cartesian3;
    draggedPosition?: Cartesian3;
    point?: EditPoint;
    pointOptions?: PointEditOptions;
}

declare class EditorObservable<T> extends Observable<T> {
    dispose: Function;
    enable: Function;
    disable: Function;
    getLabels: () => LabelProps[];
    getEditValue: () => T;
    setLabelsRenderFn: (func: (update: T, labels: LabelProps[]) => LabelProps[]) => void;
    updateLabels: (labels: LabelProps[]) => void;
    finishCreation: () => boolean;
}

declare class PointEditorObservable extends EditorObservable<PointEditUpdate> {
    setManually: (point: {
        position: Cartesian3;
        pointProp?: PointProps;
    } | Cartesian3, pointProps?: PointProps) => void;
    getCurrentPoint: () => EditPoint;
}

declare const DEFAULT_POINT_OPTIONS: PointEditOptions;
/**
 * Service for creating editable point
 *
 *  * You must provide `PointsEditorService` yourself.
 * PolygonsEditorService works together with `<points-editor>` component. Therefor you need to create `<points-editor>`
 * for each `PointsEditorService`, And of course somewhere under `<ac-map>`/
 *
 * + `create` for starting a creation of the shape over the map. Returns a extension of `PointEditorObservable`.
 * + `edit` for editing shape over the map starting from a given positions. Returns an extension of `PointEditorObservable`.
 * + To stop editing call `dsipose()` from the `PointEditorObservable` you get back from `create()` \ `edit()`.
 *
 * **Labels over editted shapes**
 * Angular Cesium allows you to draw labels over a shape that is being edited with one of the editors.
 * To add label drawing logic to your editor use the function `setLabelsRenderFn()` that is defined on the
 * `PointEditorObservable` that is returned from calling `create()` \ `edit()` of one of the editor services.
 * `setLabelsRenderFn()` - receives a callback that is called every time the shape is redrawn
 * (except when the shape is being dragged). The callback is called with the last shape state and with an array of the current labels.
 * The callback should return type `LabelProps[]`.
 * You can also use `updateLabels()` to pass an array of labels of type `LabelProps[]` to be drawn.
 *
 * usage:
 * ```typescript
 *  // Start creating point
 *  const editing$ = pointEditorService.create();
 *  this.editing$.subscribe(editResult => {
 *				console.log(editResult.positions);
 *		});
 *
 *  // Or edit point from existing point cartesian3 positions
 *  const editing$ = this.pointEditor.edit(initialPos);
 *
 * ```
 */
declare class PointsEditorService {
    private mapEventsManager;
    private updateSubject;
    private updatePublisher;
    private coordinateConverter;
    private cameraService;
    private pointManager;
    private observablesMap;
    private cesiumScene;
    init(mapEventsManager: MapEventsManagerService, coordinateConverter: CoordinateConverter, cameraService: CameraService, pointManager: PointsManagerService, cesiumViewer: CesiumService): void;
    onUpdate(): Observable<PointEditUpdate>;
    private screenToPosition;
    create(options?: PointEditOptions, eventPriority?: number): PointEditorObservable;
    private switchToEditMode;
    edit(position: Cartesian3, options?: PointEditOptions, priority?: number): PointEditorObservable;
    private editPoint;
    private setOptions;
    private createEditorObservable;
    private getPosition;
    private getPoint;
    static ɵfac: i0.ɵɵFactoryDeclaration<PointsEditorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PointsEditorService>;
}

declare class PointsEditorComponent implements OnDestroy {
    private pointsEditor;
    private coordinateConverter;
    private mapEventsManager;
    private cameraService;
    private pointsManager;
    private cesiumService;
    private editLabelsRenderFn;
    editPoint$: Subject<AcNotification>;
    pointLabels$: Subject<AcNotification>;
    private editPointLayer;
    private pointLabelsLayer;
    constructor(pointsEditor: PointsEditorService, coordinateConverter: CoordinateConverter, mapEventsManager: MapEventsManagerService, cameraService: CameraService, pointsManager: PointsManagerService, cesiumService: CesiumService);
    private startListeningToEditorUpdates;
    getLabelId(element: any, index: number): string;
    renderEditLabels(point: EditablePoint, update: PointEditUpdate, labels?: LabelProps[]): void;
    removeEditLabels(point: EditablePoint): void;
    handleCreateUpdates(update: PointEditUpdate): void;
    handleEditUpdates(update: PointEditUpdate): void;
    ngOnDestroy(): void;
    getPointSize(point: EditPoint): number;
    getPointShow(point: EditPoint): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PointsEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PointsEditorComponent, "points-editor", never, {}, {}, never, never, false, never>;
}

interface HippodromeProps {
    width?: number;
    material?: any;
    outline?: boolean;
    outlineColor?: any;
    outlineWidth?: number;
    fill?: boolean;
    classificationType?: any;
    zIndex?: any;
    shadows?: any;
}
interface HippodromeEditOptions extends EditorEditOptions {
    hippodromeProps?: HippodromeProps;
}

declare class EditableHippodrome extends AcEntity {
    private id;
    private pointsLayer;
    private hippodromeLayer;
    private coordinateConverter;
    private positions;
    private movingPoint;
    private done;
    private _enableEdit;
    private _defaultPointProps;
    private _hippodromeProps;
    private lastDraggedToPosition;
    private _labels;
    constructor(id: string, pointsLayer: AcLayerComponent, hippodromeLayer: AcLayerComponent, coordinateConverter: CoordinateConverter, editOptions: HippodromeEditOptions, positions?: Cartesian3[]);
    get labels(): LabelProps[];
    set labels(labels: LabelProps[]);
    get hippodromeProps(): HippodromeProps;
    set hippodromeProps(value: HippodromeProps);
    get defaultPointProps(): PointProps;
    set defaultPointProps(value: PointProps);
    get enableEdit(): boolean;
    set enableEdit(value: boolean);
    private createFromExisting;
    setPointsManually(points: EditPoint[], widthMeters?: number): void;
    addPointFromExisting(position: Cartesian3): void;
    addPoint(position: Cartesian3): void;
    private createHeightEditPoints;
    private createMiddleEditablePoint;
    movePoint(toPosition: Cartesian3, editPoint: EditPoint): void;
    private changeWidthByNewPoint;
    moveShape(startMovingPosition: Cartesian3, draggedToPosition: Cartesian3): void;
    endMoveShape(): void;
    endMovePoint(): void;
    moveTempMovingPoint(toPosition: Cartesian3): void;
    removePoint(pointToRemove: EditPoint): void;
    addLastPoint(position: Cartesian3): void;
    getRealPositions(): Cartesian3[];
    getRealPositionsCallbackProperty(): CallbackProperty;
    getRealPoints(): EditPoint[];
    getWidth(): number;
    getPositions(): Cartesian3[];
    private removePosition;
    private updatePointsLayer;
    private updateHippdromeLayer;
    dispose(): void;
    getPointsCount(): number;
    getId(): string;
}

declare class HippodromeManagerService {
    hippodromes: Map<string, EditableHippodrome>;
    createEditableHippodrome(id: string, editHippodromeLayer: AcLayerComponent, editPointsLayer: AcLayerComponent, coordinateConverter: CoordinateConverter, hippodromeEditOptions?: HippodromeEditOptions, positions?: Cartesian3[]): void;
    get(id: string): EditableHippodrome;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HippodromeManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HippodromeManagerService>;
}

interface HippodromeEditUpdate extends BasicEditUpdate<HippodromeEditUpdate> {
    positions?: Cartesian3[];
    updatedPosition?: Cartesian3;
    draggedPosition?: Cartesian3;
    points?: EditPoint[];
    width?: number;
    updatedPoint?: EditPoint;
    hippodromeOptions?: HippodromeEditOptions;
}

declare class HippodromeEditorObservable extends EditorObservable<HippodromeEditUpdate> {
    setManually: (firstPosition: Cartesian3, secondPosition: Cartesian3, widthMeters?: number, firstPointProp?: PointProps, secondPointProp?: PointProps) => void;
    getCurrentPoints: () => EditPoint[];
    getCurrentWidth: () => number;
}

declare const DEFAULT_HIPPODROME_OPTIONS: HippodromeEditOptions;
/**
 * Service for creating editable hippodromes
 *
 * You must provide `HippodromeEditorService` yourself.
 * HippodromeEditorService works together with `<hippodromes-editor>` component. Therefor you need to create `<hippodromes-editor>`
 * for each `PolylineEditorService`, And of course somewhere under `<ac-map>`/
 *
 * + `create` for starting a creation of the shape over the map. Returns a extension of `HippodromeEditorObservable`.
 * + `edit` for editing shape over the map starting from a given positions. Returns an extension of `HippodromeEditorObservable`.
 * + To stop editing call `dsipose()` from the `HippodromeEditorObservable` you get back from `create()` \ `edit()`.
 *
 * **Labels over editted shapes**
 * Angular Cesium allows you to draw labels over a shape that is being edited with one of the editors.
 * To add label drawing logic to your editor use the function `setLabelsRenderFn()` that is defined on the
 * `HippodromeEditorObservable` that is returned from calling `create()` \ `edit()` of one of the editor services.
 * `setLabelsRenderFn()` - receives a callback that is called every time the shape is redrawn
 * (except when the shape is being dragged). The callback is called with the last shape state and with an array of the current labels.
 * The callback should return type `LabelProps[]`.
 * You can also use `updateLabels()` to pass an array of labels of type `LabelProps[]` to be drawn.
 *
 *
 * usage:
 * ```typescript
 *  // Start creating hippodrome
 *  const editing$ = hippodromeEditorService.create();
 *  this.editing$.subscribe(editResult => {
 *				console.log(editResult.positions);
 *		});
 *
 *  // Or edit hippodromes from existing hippodromes cartesian3 positions
 *  const editing$ = this.hippodromeEditor.edit(initialPos);
 *
 * ```
 */
declare class HippodromeEditorService {
    private mapEventsManager;
    private updateSubject;
    private updatePublisher;
    private coordinateConverter;
    private cameraService;
    private hippodromeManager;
    private observablesMap;
    init(mapEventsManager: MapEventsManagerService, coordinateConverter: CoordinateConverter, cameraService: CameraService, managerService: HippodromeManagerService): void;
    onUpdate(): Observable<HippodromeEditUpdate>;
    create(options?: HippodromeEditOptions, eventPriority?: number): HippodromeEditorObservable;
    edit(positions: Cartesian3[], options?: HippodromeEditOptions, priority?: number): HippodromeEditorObservable;
    private editHippodrome;
    private setOptions;
    private createEditorObservable;
    private getPositions;
    private getPoints;
    private getWidth;
    static ɵfac: i0.ɵɵFactoryDeclaration<HippodromeEditorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HippodromeEditorService>;
}

declare class HippodromeEditorComponent implements OnDestroy {
    private hippodromesEditor;
    private coordinateConverter;
    private mapEventsManager;
    private cameraService;
    private hippodromesManager;
    private editLabelsRenderFn;
    editPoints$: Subject<AcNotification>;
    editHippodromes$: Subject<AcNotification>;
    private editPointsLayer;
    private editHippodromesLayer;
    constructor(hippodromesEditor: HippodromeEditorService, coordinateConverter: CoordinateConverter, mapEventsManager: MapEventsManagerService, cameraService: CameraService, hippodromesManager: HippodromeManagerService);
    private startListeningToEditorUpdates;
    getLabelId(element: any, index: number): string;
    renderEditLabels(hippodrome: EditableHippodrome, update: HippodromeEditUpdate, labels?: LabelProps[]): void;
    removeEditLabels(hippodrome: EditableHippodrome): void;
    handleCreateUpdates(update: HippodromeEditUpdate): void;
    handleEditUpdates(update: HippodromeEditUpdate): void;
    ngOnDestroy(): void;
    getPointSize(point: EditPoint): number;
    getPointShow(point: EditPoint): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HippodromeEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HippodromeEditorComponent, "hippodrome-editor", never, {}, {}, never, never, false, never>;
}

interface PolygonProps {
    material?: any;
    fill?: boolean;
    classificationType?: any;
    zIndex?: any;
}
interface PolygonEditOptions extends PolylineEditOptions {
    polygonProps?: PolygonProps;
}

interface PolygonEditUpdate extends BasicEditUpdate<PolygonEditUpdate> {
    positions?: Cartesian3[];
    updatedPosition?: Cartesian3;
    draggedPosition?: Cartesian3;
    points?: EditPoint[];
    updatedPoint?: EditPoint;
    polygonOptions?: PolygonEditOptions;
}

declare class EditablePolygon extends AcEntity {
    private id;
    private polygonsLayer;
    private pointsLayer;
    private polylinesLayer;
    private coordinateConverter;
    private polygonOptions;
    private positions;
    private polylines;
    private movingPoint;
    private doneCreation;
    private _enableEdit;
    private _polygonProps;
    private _defaultPointProps;
    private _defaultPolylineProps;
    private lastDraggedToPosition;
    private _labels;
    constructor(id: string, polygonsLayer: AcLayerComponent, pointsLayer: AcLayerComponent, polylinesLayer: AcLayerComponent, coordinateConverter: CoordinateConverter, polygonOptions: PolygonEditOptions, positions?: Cartesian3[]);
    get labels(): LabelProps[];
    set labels(labels: LabelProps[]);
    get defaultPolylineProps(): PolylineProps;
    set defaultPolylineProps(value: PolylineProps);
    get defaultPointProps(): PointProps;
    get polygonProps(): PolygonProps;
    set polygonProps(value: PolygonProps);
    set defaultPointProps(value: PointProps);
    get enableEdit(): boolean;
    set enableEdit(value: boolean);
    private createFromExisting;
    setPointsManually(points: {
        position: Cartesian3;
        pointProps: PointProps;
    }[] | Cartesian3[], polygonProps?: PolygonProps): void;
    private addAllVirtualEditPoints;
    private setMiddleVirtualPoint;
    private updateMiddleVirtualPoint;
    changeVirtualPointToRealPoint(point: EditPoint): void;
    private renderPolylines;
    addPointFromExisting(position: Cartesian3): void;
    addPoint(position: Cartesian3): void;
    movePointFinish(editPoint: EditPoint): void;
    movePoint(toPosition: Cartesian3, editPoint: EditPoint): void;
    moveTempMovingPoint(toPosition: Cartesian3): void;
    movePolygon(startMovingPosition: Cartesian3, draggedToPosition: Cartesian3): void;
    endMovePolygon(): void;
    removePoint(pointToRemove: EditPoint): void;
    addLastPoint(position: Cartesian3): void;
    getRealPositions(): Cartesian3[];
    getRealPoints(): EditPoint[];
    getPoints(): EditPoint[];
    getPositionsHierarchy(): PolygonHierarchy;
    getPositionsHierarchyCallbackProperty(): CallbackProperty;
    private removePosition;
    private updatePolygonsLayer;
    private updatePointsLayer;
    dispose(): void;
    getPointsCount(): number;
    getId(): string;
}

declare class PolygonsManagerService {
    polygons: Map<string, EditablePolygon>;
    createEditablePolygon(id: string, editPolygonsLayer: AcLayerComponent, editPointsLayer: AcLayerComponent, editPolylinesLayer: AcLayerComponent, coordinateConverter: CoordinateConverter, polygonOptions?: PolygonEditOptions, positions?: Cartesian3[]): void;
    dispose(id: string): void;
    get(id: string): EditablePolygon;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PolygonsManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PolygonsManagerService>;
}

declare class PolygonEditorObservable extends EditorObservable<PolygonEditUpdate> {
    setManually: (points: {
        position: Cartesian3;
        pointProp?: PointProps;
    }[] | Cartesian3[], polygonProps?: PolygonProps) => void;
    getCurrentPoints: () => EditPoint[];
}

declare const DEFAULT_POLYGON_OPTIONS: PolygonEditOptions;
/**
 * Service for creating editable polygons
 *
 * You must provide `PolygonsEditorService` yourself.
 * PolygonsEditorService works together with `<polygons-editor>` component. Therefor you need to create `<polygons-editor>`
 * for each `PolygonsEditorService`, And of course somewhere under `<ac-map>`/
 *
 * + `create` for starting a creation of the shape over the map. Returns a extension of `PolygonEditorObservable`.
 * + `edit` for editing shape over the map starting from a given positions. Returns an extension of `PolygonEditorObservable`.
 * + To stop editing call `dsipose()` from the `PolygonEditorObservable` you get back from `create()` \ `edit()`.
 *
 * **Labels over edited shapes**
 * Angular Cesium allows you to draw labels over a shape that is being edited with one of the editors.
 * To add label drawing logic to your editor use the function `setLabelsRenderFn()` that is defined on the
 * `PolygonEditorObservable` that is returned from calling `create()` \ `edit()` of one of the editor services.
 * `setLabelsRenderFn()` - receives a callback that is called every time the shape is redrawn
 * (except when the shape is being dragged). The callback is called with the last shape state and with an array of the current labels.
 * The callback should return type `LabelProps[]`.
 * You can also use `updateLabels()` to pass an array of labels of type `LabelProps[]` to be drawn.
 *
 * usage:
 * ```typescript
 *  // Start creating polygon
 *  const editing$ = polygonsEditorService.create();
 *  this.editing$.subscribe(editResult => {
 *				console.log(editResult.positions);
 *		});
 *
 *  // Or edit polygon from existing polygon positions
 *  const editing$ = this.polygonsEditorService.edit(initialPos);
 *
 * ```
 */
declare class PolygonsEditorService {
    private mapEventsManager;
    private updateSubject;
    private updatePublisher;
    private coordinateConverter;
    private cameraService;
    private polygonsManager;
    private observablesMap;
    private cesiumScene;
    private clampPointsDebounced;
    init(mapEventsManager: MapEventsManagerService, coordinateConverter: CoordinateConverter, cameraService: CameraService, polygonsManager: PolygonsManagerService, cesiumViewer: CesiumService): void;
    onUpdate(): Observable<PolygonEditUpdate>;
    private clampPoints;
    private screenToPosition;
    create(options?: PolygonEditOptions, priority?: number): PolygonEditorObservable;
    private switchToEditMode;
    edit(positions: Cartesian3[], options?: PolygonEditOptions, priority?: number): PolygonEditorObservable;
    private editPolygon;
    private setOptions;
    private createEditorObservable;
    private getPositions;
    private getPoints;
    static ɵfac: i0.ɵɵFactoryDeclaration<PolygonsEditorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PolygonsEditorService>;
}

declare class PolygonsEditorComponent implements OnDestroy {
    private polygonsEditor;
    private coordinateConverter;
    private mapEventsManager;
    private cameraService;
    private polygonsManager;
    private cesiumService;
    private editLabelsRenderFn;
    editPoints$: Subject<AcNotification>;
    editPolylines$: Subject<AcNotification>;
    editPolygons$: Subject<AcNotification>;
    private editPolygonsLayer;
    private editPointsLayer;
    private editPolylinesLayer;
    constructor(polygonsEditor: PolygonsEditorService, coordinateConverter: CoordinateConverter, mapEventsManager: MapEventsManagerService, cameraService: CameraService, polygonsManager: PolygonsManagerService, cesiumService: CesiumService);
    private startListeningToEditorUpdates;
    getLabelId(element: any, index: number): string;
    renderEditLabels(polygon: EditablePolygon, update: PolygonEditUpdate, labels?: LabelProps[]): void;
    removeEditLabels(polygon: EditablePolygon): void;
    handleCreateUpdates(update: PolygonEditUpdate): void;
    handleEditUpdates(update: PolygonEditUpdate): void;
    ngOnDestroy(): void;
    getPointSize(point: EditPoint): number;
    getPointShow(point: EditPoint): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PolygonsEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PolygonsEditorComponent, "polygons-editor", never, {}, {}, never, never, false, never>;
}

interface RectangleProps {
    material?: any;
    fill?: boolean;
    classificationType?: any;
    zIndex?: any;
    outline?: boolean;
    outlineColor?: any;
    outlineWidth?: number;
    height?: number;
    extrudedHeight?: number;
}
interface RectangleEditOptions extends PolygonEditOptions {
    rectangleProps?: RectangleProps;
}

interface RectangleEditUpdate extends BasicEditUpdate<PolygonEditUpdate> {
    positions?: Cartesian3[];
    updatedPosition?: Cartesian3;
    draggedPosition?: Cartesian3;
    points?: EditPoint[];
    updatedPoint?: EditPoint;
    rectangleOptions?: RectangleEditOptions;
}

declare class EditableRectangle extends AcEntity {
    private id;
    private pointsLayer;
    private rectangleLayer;
    private coordinateConverter;
    private positions;
    private movingPoint;
    private done;
    private _enableEdit;
    private _defaultPointProps;
    private _rectangleProps;
    private lastDraggedToPosition;
    private _labels;
    constructor(id: string, pointsLayer: AcLayerComponent, rectangleLayer: AcLayerComponent, coordinateConverter: CoordinateConverter, editOptions: RectangleEditOptions, positions?: Cartesian3[]);
    get labels(): LabelProps[];
    set labels(labels: LabelProps[]);
    get rectangleProps(): RectangleProps;
    set rectangleProps(value: RectangleProps);
    get defaultPointProps(): PointProps;
    set defaultPointProps(value: PointProps);
    get enableEdit(): boolean;
    set enableEdit(value: boolean);
    private createFromExisting;
    setPointsManually(points: EditPoint[], widthMeters?: number): void;
    addPointFromExisting(position: Cartesian3): void;
    addPoint(position: Cartesian3): void;
    movePoint(toPosition: Cartesian3, editPoint: EditPoint): void;
    moveShape(startMovingPosition: Cartesian3, draggedToPosition: Cartesian3): void;
    endMoveShape(): void;
    endMovePoint(): void;
    moveTempMovingPoint(toPosition: Cartesian3): void;
    removePoint(pointToRemove: EditPoint): void;
    addLastPoint(position: Cartesian3): void;
    getRealPositions(): Cartesian3[];
    getRealPositionsCallbackProperty(): CallbackProperty;
    getRealPoints(): EditPoint[];
    getPositions(): Cartesian3[];
    getRectangle(): Rectangle;
    getRectangleCallbackProperty(): CallbackProperty;
    private removePosition;
    private updatePointsLayer;
    private updateRectangleLayer;
    dispose(): void;
    getPointsCount(): number;
    getId(): string;
}

declare class RectanglesManagerService {
    rectangles: Map<string, EditableRectangle>;
    createEditableRectangle(id: string, editRectanglesLayer: AcLayerComponent, editPointsLayer: AcLayerComponent, coordinateConverter: CoordinateConverter, rectangleOptions?: RectangleEditOptions, positions?: Cartesian3[]): void;
    dispose(id: string): void;
    get(id: string): EditableRectangle;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RectanglesManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RectanglesManagerService>;
}

declare class RectangleEditorObservable extends EditorObservable<RectangleEditUpdate> {
    setManually: (firstPosition: Cartesian3, secondPosition: Cartesian3, firstPointProp?: PointProps, secondPointProp?: PointProps) => void;
    getCurrentPoints: () => EditPoint[];
}

declare const DEFAULT_RECTANGLE_OPTIONS: RectangleEditOptions;
/**
 * Service for creating editable rectangles
 *
 * You must provide `RectanglesEditorService` yourself.
 * RectanglesEditorService works together with `<rectangles-editor>` component. Therefor you need to create `<rectangles-editor>`
 * for each `RectanglesEditorService`, And of course somewhere under `<ac-map>`/
 *
 * + `create` for starting a creation of the shape over the map. Returns a extension of `RectangleEditorObservable`.
 * + `edit` for editing shape over the map starting from a given positions. Returns an extension of `RectangleEditorObservable`.
 * + To stop editing call `dsipose()` from the `RectangleEditorObservable` you get back from `create()` \ `edit()`.
 *
 * **Labels over editted shapes**
 * Angular Cesium allows you to draw labels over a shape that is being edited with one of the editors.
 * To add label drawing logic to your editor use the function `setLabelsRenderFn()` that is defined on the
 * `RectangleEditorObservable` that is returned from calling `create()` \ `edit()` of one of the editor services.
 * `setLabelsRenderFn()` - receives a callback that is called every time the shape is redrawn
 * (except when the shape is being dragged). The callback is called with the last shape state and with an array of the current labels.
 * The callback should return type `LabelProps[]`.
 * You can also use `updateLabels()` to pass an array of labels of type `LabelProps[]` to be drawn.
 *
 * usage:
 * ```typescript
 *  // Start creating rectangle
 *  const editing$ = rectanglesEditorService.create();
 *  this.editing$.subscribe(editResult => {
 *				console.log(editResult.positions);
 *		});
 *
 *  // Or edit rectangle from existing rectangle positions
 *  const editing$ = this.rectanglesEditorService.edit(initialPos);
 *
 * ```
 */
declare class RectanglesEditorService {
    private mapEventsManager;
    private updateSubject;
    private updatePublisher;
    private coordinateConverter;
    private cameraService;
    private rectanglesManager;
    private observablesMap;
    private cesiumScene;
    init(mapEventsManager: MapEventsManagerService, coordinateConverter: CoordinateConverter, cameraService: CameraService, rectanglesManager: RectanglesManagerService, cesiumViewer: CesiumService): void;
    onUpdate(): Observable<RectangleEditUpdate>;
    create(options?: RectangleEditOptions, priority?: number): RectangleEditorObservable;
    edit(positions: Cartesian3[], options?: RectangleEditOptions, priority?: number): RectangleEditorObservable;
    private editRectangle;
    private setOptions;
    private createEditorObservable;
    private getPositions;
    private getPoints;
    static ɵfac: i0.ɵɵFactoryDeclaration<RectanglesEditorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RectanglesEditorService>;
}

declare class RectanglesEditorComponent implements OnDestroy {
    private rectanglesEditor;
    private coordinateConverter;
    private mapEventsManager;
    private cameraService;
    private rectanglesManager;
    private cesiumService;
    private editLabelsRenderFn;
    editPoints$: Subject<AcNotification>;
    editRectangles$: Subject<AcNotification>;
    private editRectanglesLayer;
    private editPointsLayer;
    constructor(rectanglesEditor: RectanglesEditorService, coordinateConverter: CoordinateConverter, mapEventsManager: MapEventsManagerService, cameraService: CameraService, rectanglesManager: RectanglesManagerService, cesiumService: CesiumService);
    private startListeningToEditorUpdates;
    getLabelId(element: any, index: number): string;
    renderEditLabels(rectangle: EditableRectangle, update: RectangleEditUpdate, labels?: LabelProps[]): void;
    removeEditLabels(rectangle: EditableRectangle): void;
    handleCreateUpdates(update: RectangleEditUpdate): void;
    handleEditUpdates(update: RectangleEditUpdate): void;
    ngOnDestroy(): void;
    getPointSize(point: EditPoint): number;
    getPointShow(point: EditPoint): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<RectanglesEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RectanglesEditorComponent, "rectangles-editor", never, {}, {}, never, never, false, never>;
}

interface EllipseProps {
    material?: any;
    outline: boolean;
    outlineWidth?: number;
    outlineColor?: any;
    granularity?: number;
    fill?: boolean;
    zIndex?: number;
    classificationType?: any;
    shadows?: any;
}
interface EllipseEditOptions extends EditorEditOptions {
    ellipseProps?: EllipseProps;
    circleToEllipseTransformEvent?: CesiumEvent;
    circleToEllipseTransformEventModifier?: CesiumEventModifier;
    circleToEllipseTransformation?: boolean;
}

interface CircleEditOptions extends EditorEditOptions {
    circleProps?: EllipseProps;
}

declare class EditableCircle extends AcEntity {
    private id;
    private circlesLayer;
    private pointsLayer;
    private arcsLayer;
    private options;
    private _center;
    private _radiusPoint;
    private _outlineArc;
    private doneCreation;
    private _enableEdit;
    private lastDraggedToPosition;
    private _circleProps;
    private _pointProps;
    private _polylineProps;
    private _labels;
    constructor(id: string, circlesLayer: AcLayerComponent, pointsLayer: AcLayerComponent, arcsLayer: AcLayerComponent, options: CircleEditOptions);
    get labels(): LabelProps[];
    set labels(labels: LabelProps[]);
    get polylineProps(): PolylineProps;
    set polylineProps(value: PolylineProps);
    get pointProps(): PointProps;
    set pointProps(value: PointProps);
    get circleProps(): EllipseProps;
    set circleProps(value: EllipseProps);
    get center(): EditPoint;
    get radiusPoint(): EditPoint;
    get enableEdit(): boolean;
    set enableEdit(value: boolean);
    setManually(center: Cartesian3, radiusPoint: Cartesian3, centerPointProp?: PointProps, radiusPointProp?: PointProps, circleProp?: EllipseProps): void;
    addPoint(position: Cartesian3): void;
    addLastPoint(position: Cartesian3): void;
    movePoint(toPosition: Cartesian3): void;
    moveCircle(dragStartPosition: Cartesian3, dragEndPosition: Cartesian3): void;
    endMovePolygon(): void;
    getRadius(): number;
    getRadiusCallbackProperty(): CallbackProperty;
    getCenter(): Cartesian3;
    getCenterCallbackProperty(): CallbackProperty;
    getRadiusPoint(): Cartesian3;
    dispose(): void;
    getId(): string;
    private updateCirclesLayer;
    private updatePointsLayer;
    private updateArcsLayer;
    private createOutlineArc;
}

declare class CirclesManagerService {
    private circles;
    createEditableCircle(id: string, editCirclesLayer: AcLayerComponent, editPointsLayer: AcLayerComponent, editArcsLayer: AcLayerComponent, circleOptions: CircleEditOptions): EditableCircle;
    dispose(id: string): void;
    get(id: string): EditableCircle;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CirclesManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CirclesManagerService>;
}

interface CircleEditUpdate extends BasicEditUpdate<CircleEditUpdate> {
    startDragPosition?: Cartesian3;
    endDragPosition?: Cartesian3;
    center?: Cartesian3;
    radiusPoint?: Cartesian3;
    radius?: number;
    circleOptions?: CircleEditOptions;
}

declare class CircleEditorObservable extends EditorObservable<CircleEditUpdate> {
    setManually: (center: Cartesian3, radius: number, centerPointProp?: PointProps, radiusPointProp?: PointProps, circleProp?: EllipseProps) => void;
    getCenter: () => Cartesian3;
    getRadius: () => number;
}

declare const DEFAULT_CIRCLE_OPTIONS: CircleEditOptions;
/**
 * Service for creating editable circles
 *
 * You must provide `CircleEditorService` yourself.
 * PolygonsEditorService works together with `<circle-editor>` component. Therefor you need to create `<circle-editor>`
 * for each `CircleEditorService`, And of course somewhere under `<ac-map>`/
 *
 * + `create` for starting a creation of the shape over the map. Returns a extension of `CircleEditorObservable`.
 * + `edit` for editing shape over the map starting from a given positions. Returns an extension of `CircleEditorObservable`.
 * + To stop editing call `dsipose()` from the `CircleEditorObservable` you get back from `create()` \ `edit()`.
 *
 * **Labels over editted shapes**
 * Angular Cesium allows you to draw labels over a shape that is being edited with one of the editors.
 * To add label drawing logic to your editor use the function `setLabelsRenderFn()` that is defined on the
 * `CircleEditorObservable` that is returned from calling `create()` \ `edit()` of one of the editor services.
 * `setLabelsRenderFn()` - receives a callback that is called every time the shape is redrawn
 * (except when the shape is being dragged). The callback is called with the last shape state and with an array of the current labels.
 * The callback should return type `LabelProps[]`.
 * You can also use `updateLabels()` to pass an array of labels of type `LabelProps[]` to be drawn.
 *
 * usage:
 * ```typescript
 *  // Start creating circle
 *  const editing$ = circlesEditorService.create();
 *  this.editing$.subscribe(editResult => {
 *				console.log(editResult.positions);
 *		});
 *
 *  // Or edit circle from existing center point and radius
 *  const editing$ = this.circlesEditorService.edit(center, radius);
 *
 * ```
 */
declare class CirclesEditorService {
    private mapEventsManager;
    private updateSubject;
    private updatePublisher;
    private coordinateConverter;
    private cameraService;
    private circlesManager;
    private observablesMap;
    init(mapEventsManager: MapEventsManagerService, coordinateConverter: CoordinateConverter, cameraService: CameraService, circlesManager: CirclesManagerService): void;
    onUpdate(): Observable<CircleEditUpdate>;
    create(options?: CircleEditOptions, priority?: number): CircleEditorObservable;
    edit(center: Cartesian3, radius: number, options?: CircleEditOptions, priority?: number): CircleEditorObservable;
    private editCircle;
    private createEditorObservable;
    private setOptions;
    private getCenterPosition;
    private getCenterPoint;
    private getRadiusPosition;
    private getRadius;
    private getCircleProperties;
    static ɵfac: i0.ɵɵFactoryDeclaration<CirclesEditorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CirclesEditorService>;
}

declare class CirclesEditorComponent implements OnDestroy {
    private circlesEditor;
    private coordinateConverter;
    private mapEventsManager;
    private cameraService;
    private circlesManager;
    private editLabelsRenderFn;
    editPoints$: Subject<AcNotification>;
    editCircles$: Subject<AcNotification>;
    editArcs$: Subject<AcNotification>;
    private editCirclesLayer;
    private editArcsLayer;
    private editPointsLayer;
    constructor(circlesEditor: CirclesEditorService, coordinateConverter: CoordinateConverter, mapEventsManager: MapEventsManagerService, cameraService: CameraService, circlesManager: CirclesManagerService);
    private startListeningToEditorUpdates;
    getLabelId(element: any, index: number): string;
    renderEditLabels(circle: EditableCircle, update: CircleEditUpdate, labels?: LabelProps[]): void;
    removeEditLabels(circle: EditableCircle): void;
    handleCreateUpdates(update: CircleEditUpdate): void;
    handleEditUpdates(update: CircleEditUpdate): void;
    ngOnDestroy(): void;
    getPointSize(point: EditPoint): number;
    getPointShow(point: EditPoint): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CirclesEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CirclesEditorComponent, "circles-editor", never, {}, {}, never, never, false, never>;
}

declare class EditableEllipse extends AcEntity {
    private id;
    private ellipsesLayer;
    private pointsLayer;
    private coordinateConverter;
    private options;
    private _center;
    private _majorRadiusPoint;
    private _majorRadius;
    private _minorRadius;
    private _rotation;
    private doneCreation;
    private _enableEdit;
    private _minorRadiusPoints;
    private lastDraggedToPosition;
    private _ellipseProps;
    private _pointProps;
    private _polylineProps;
    private _labels;
    constructor(id: string, ellipsesLayer: AcLayerComponent, pointsLayer: AcLayerComponent, coordinateConverter: CoordinateConverter, options: EllipseEditOptions);
    get labels(): LabelProps[];
    set labels(labels: LabelProps[]);
    get polylineProps(): PolylineProps;
    set polylineProps(value: PolylineProps);
    get pointProps(): PointProps;
    set pointProps(value: PointProps);
    get ellipseProps(): EllipseProps;
    set ellipseProps(value: EllipseProps);
    get center(): EditPoint;
    get majorRadiusPoint(): EditPoint;
    getMajorRadiusPointPosition(): Cartesian3;
    getMinorRadiusPointPosition(): Cartesian3;
    get enableEdit(): boolean;
    set enableEdit(value: boolean);
    setManually(center: Cartesian3, majorRadius: number, rotation?: number, minorRadius?: number, centerPointProp?: PointProps, radiusPointProp?: PointProps, ellipseProp?: EllipseProps): void;
    addPoint(position: Cartesian3): void;
    transformToEllipse(): void;
    addLastPoint(position: Cartesian3): void;
    movePoint(toPosition: Cartesian3, editPoint: EditPoint): void;
    moveEllipse(dragStartPosition: Cartesian3, dragEndPosition: Cartesian3): void;
    endMoveEllipse(): void;
    private updateMinorRadiusEditPoints;
    getMajorRadius(): number;
    getMinorRadius(): number;
    getRotation(): number;
    updateRotation(): number;
    getRotationCallbackProperty(): CallbackProperty;
    getMinorRadiusCallbackProperty(): CallbackProperty;
    getMajorRadiusCallbackProperty(): CallbackProperty;
    getCenter(): Cartesian3;
    getCenterCallbackProperty(): CallbackProperty;
    dispose(): void;
    getId(): string;
    private updateEllipsesLayer;
    private updatePointsLayer;
}

declare class EllipsesManagerService {
    private ellipses;
    createEditableEllipse(id: string, editEllipsesLayer: AcLayerComponent, editPointsLayer: AcLayerComponent, coordinateConverter: CoordinateConverter, ellipseOptions: EllipseEditOptions): EditableEllipse;
    dispose(id: string): void;
    get(id: string): EditableEllipse;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EllipsesManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EllipsesManagerService>;
}

interface EllipseEditUpdate extends BasicEditUpdate<EllipseEditUpdate> {
    startDragPosition?: Cartesian3;
    endDragPosition?: Cartesian3;
    updatedPoint?: EditPoint;
    updatedPosition?: Cartesian3;
    center?: Cartesian3;
    rotation?: number;
    majorRadius?: number;
    minorRadius?: number;
    ellipseOptions?: EllipseEditOptions;
    minorRadiusPointPosition?: Cartesian3;
    majorRadiusPointPosition?: Cartesian3;
}

declare class EllipseEditorObservable extends EditorObservable<EllipseEditUpdate> {
    setManually: (center: Cartesian3, majorRadius: number, rotation?: number, minorRadius?: number, centerPointProp?: PointProps, radiusPointProp?: PointProps, ellipseProp?: EllipseProps) => void;
    getCenter: () => Cartesian3;
    getMinorRadius: () => number;
    getMajorRadius: () => number;
}

declare const DEFAULT_ELLIPSE_OPTIONS: EllipseEditOptions;
/**
 * Service for creating editable ellipses
 *
 * You must provide `EllipsesEditorService` yourself.
 * EllipsesEditorService works together with `<ellipse-editor>` component. Therefor you need to create `<ellipse-editor>`
 * for each `EllipsesEditorService`, And of course somewhere under `<ac-map>`/
 *
 * + `create` for starting a creation of the shape over the map. Returns a extension of `EllipseEditorObservable`.
 * + `edit` for editing shape over the map starting from a given positions. Returns an extension of `EllipseEditorObservable`.
 * + To stop editing call `dispose()` from the `EllipseEditorObservable` you get back from `create()` \ `edit()`.
 *
 * **Labels over edited shapes**
 * Angular Cesium allows you to draw labels over a shape that is being edited with one of the editors.
 * To add label drawing logic to your editor use the function `setLabelsRenderFn()` that is defined on the
 * `EllipseEditorObservable` that is returned from calling `create()` \ `edit()` of one of the editor services.
 * `setLabelsRenderFn()` - receives a callback that is called every time the shape is redrawn
 * (except when the shape is being dragged). The callback is called with the last shape state and with an array of the current labels.
 * The callback should return type `LabelProps[]`.
 * You can also use `updateLabels()` to pass an array of labels of type `LabelProps[]` to be drawn.
 *
 * usage:
 * ```typescript
 *  // Start creating ellipse
 *  const editing$ = ellipsesEditorService.create();
 *  this.editing$.subscribe(editResult => {
 *				console.log(editResult.positions);
 *		});
 *
 *  // Or edit ellipse from existing center point, two radiuses and rotation
 *  const editing$ = this.ellipsesEditorService.edit(center, majorRadius, rotation, minorRadius);
 *
 * ```
 */
declare class EllipsesEditorService {
    private mapEventsManager;
    private updateSubject;
    private updatePublisher;
    private coordinateConverter;
    private cameraService;
    private ellipsesManager;
    private observablesMap;
    private cesiumScene;
    init(mapEventsManager: MapEventsManagerService, coordinateConverter: CoordinateConverter, cameraService: CameraService, ellipsesManager: EllipsesManagerService, cesiumViewer: CesiumService): void;
    onUpdate(): Observable<EllipseEditUpdate>;
    create(options?: EllipseEditOptions, priority?: number): EllipseEditorObservable;
    edit(center: Cartesian3, majorRadius: number, rotation?: number, minorRadius?: number, options?: EllipseEditOptions, priority?: number): EllipseEditorObservable;
    private editEllipse;
    private createEditorObservable;
    private setOptions;
    private getCenterPosition;
    private getCenterPoint;
    private getMajorRadius;
    private getMinorRadius;
    private getEllipseProperties;
    static ɵfac: i0.ɵɵFactoryDeclaration<EllipsesEditorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EllipsesEditorService>;
}

declare class EllipsesEditorComponent implements OnDestroy {
    private ellipsesEditor;
    private coordinateConverter;
    private mapEventsManager;
    private cameraService;
    private ellipsesManager;
    private cesiumService;
    private editLabelsRenderFn;
    editPoints$: Subject<AcNotification>;
    editEllipses$: Subject<AcNotification>;
    private editEllipsesLayer;
    private editPointsLayer;
    constructor(ellipsesEditor: EllipsesEditorService, coordinateConverter: CoordinateConverter, mapEventsManager: MapEventsManagerService, cameraService: CameraService, ellipsesManager: EllipsesManagerService, cesiumService: CesiumService);
    private startListeningToEditorUpdates;
    getLabelId(element: any, index: number): string;
    renderEditLabels(ellipse: EditableEllipse, update: EllipseEditUpdate, labels?: LabelProps[]): void;
    removeEditLabels(ellipse: EditableEllipse): void;
    handleCreateUpdates(update: EllipseEditUpdate): void;
    handleEditUpdates(update: EllipseEditUpdate): void;
    ngOnDestroy(): void;
    getPointSize(point: EditPoint): number;
    getPointShow(point: EditPoint): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<EllipsesEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EllipsesEditorComponent, "ellipses-editor", never, {}, {}, never, never, false, never>;
}

declare class EditablePolyline extends AcEntity {
    private id;
    private pointsLayer;
    private polylinesLayer;
    private coordinateConverter;
    private editOptions;
    private positions;
    private polylines;
    private movingPoint;
    private doneCreation;
    private _enableEdit;
    private _pointProps;
    private polylineProps;
    private lastDraggedToPosition;
    private _labels;
    constructor(id: string, pointsLayer: AcLayerComponent, polylinesLayer: AcLayerComponent, coordinateConverter: CoordinateConverter, editOptions: PolylineEditOptions, positions?: Cartesian3[]);
    get labels(): LabelProps[];
    set labels(labels: LabelProps[]);
    get props(): PolylineProps;
    set props(value: PolylineProps);
    get pointProps(): PointProps;
    set pointProps(value: PointProps);
    get enableEdit(): boolean;
    set enableEdit(value: boolean);
    private createFromExisting;
    setManually(points: {
        position: Cartesian3;
        pointProp?: PointProps;
    }[] | Cartesian3[], polylineProps?: PolylineProps): void;
    private addAllVirtualEditPoints;
    private setMiddleVirtualPoint;
    private updateMiddleVirtualPoint;
    changeVirtualPointToRealPoint(point: EditPoint): void;
    private renderPolylines;
    addPointFromExisting(position: Cartesian3): void;
    addPoint(position: Cartesian3): void;
    movePointFinish(editPoint: EditPoint): void;
    movePoint(toPosition: Cartesian3, editPoint: EditPoint): void;
    moveTempMovingPoint(toPosition: Cartesian3): void;
    moveShape(startMovingPosition: Cartesian3, draggedToPosition: Cartesian3): void;
    endMoveShape(): void;
    removePoint(pointToRemove: EditPoint): void;
    addLastPoint(position: Cartesian3): void;
    getRealPositions(): Cartesian3[];
    getRealPoints(): EditPoint[];
    getPoints(): EditPoint[];
    getPositions(): Cartesian3[];
    getPositionsCallbackProperty(): CallbackProperty;
    private removePosition;
    private updatePointsLayer;
    update(): void;
    dispose(): void;
    getPointsCount(): number;
    getId(): string;
}

declare class PolylinesManagerService {
    polylines: Map<string, EditablePolyline>;
    createEditablePolyline(id: string, editPolylinesLayer: AcLayerComponent, editPointsLayer: AcLayerComponent, coordinateConverter: CoordinateConverter, polylineOptions?: PolygonEditOptions, positions?: Cartesian3[]): void;
    get(id: string): EditablePolyline;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PolylinesManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PolylinesManagerService>;
}

interface PolylineEditUpdate extends BasicEditUpdate<PolylineEditUpdate> {
    positions?: Cartesian3[];
    updatedPosition?: Cartesian3;
    draggedPosition?: Cartesian3;
    points?: EditPoint[];
    updatedPoint?: EditPoint;
    polylineOptions?: PolylineEditOptions;
}

declare class PolylineEditorObservable extends EditorObservable<PolylineEditUpdate> {
    setManually: (points: {
        position: Cartesian3;
        pointProp?: PointProps;
    }[] | Cartesian3[], polylineProps?: PolylineProps) => void;
    getCurrentPoints: () => EditPoint[];
}

declare const DEFAULT_POLYLINE_OPTIONS: PolylineEditOptions;
/**
 * Service for creating editable polylines
 *
 *  * You must provide `PolylineEditorService` yourself.
 * PolygonsEditorService works together with `<polylines-editor>` component. Therefor you need to create `<polylines-editor>`
 * for each `PolylineEditorService`, And of course somewhere under `<ac-map>`/
 *
 * + `create` for starting a creation of the shape over the map. Returns a extension of `PolylineEditorObservable`.
 * + `edit` for editing shape over the map starting from a given positions. Returns an extension of `PolylineEditorObservable`.
 * + To stop editing call `dsipose()` from the `PolylineEditorObservable` you get back from `create()` \ `edit()`.
 *
 * **Labels over editted shapes**
 * Angular Cesium allows you to draw labels over a shape that is being edited with one of the editors.
 * To add label drawing logic to your editor use the function `setLabelsRenderFn()` that is defined on the
 * `PolylineEditorObservable` that is returned from calling `create()` \ `edit()` of one of the editor services.
 * `setLabelsRenderFn()` - receives a callback that is called every time the shape is redrawn
 * (except when the shape is being dragged). The callback is called with the last shape state and with an array of the current labels.
 * The callback should return type `LabelProps[]`.
 * You can also use `updateLabels()` to pass an array of labels of type `LabelProps[]` to be drawn.
 *
 * usage:
 * ```typescript
 *  // Start creating polyline
 *  const editing$ = polylinesEditorService.create();
 *  this.editing$.subscribe(editResult => {
 *				console.log(editResult.positions);
 *		});
 *
 *  // Or edit polyline from existing polyline cartesian3 positions
 *  const editing$ = this.polylinesEditor.edit(initialPos);
 *
 * ```
 */
declare class PolylinesEditorService {
    private mapEventsManager;
    private updateSubject;
    private updatePublisher;
    private coordinateConverter;
    private cameraService;
    private polylinesManager;
    private observablesMap;
    private cesiumScene;
    private clampPointsDebounced;
    init(mapEventsManager: MapEventsManagerService, coordinateConverter: CoordinateConverter, cameraService: CameraService, polylinesManager: PolylinesManagerService, cesiumViewer: CesiumService): void;
    onUpdate(): Observable<PolylineEditUpdate>;
    private clampPoints;
    private screenToPosition;
    create(options?: PolylineEditOptions, eventPriority?: number): PolylineEditorObservable;
    private switchToEditMode;
    edit(positions: Cartesian3[], options?: PolylineEditOptions, priority?: number): PolylineEditorObservable;
    private editPolyline;
    private setOptions;
    private createEditorObservable;
    private getPositions;
    private getPoints;
    static ɵfac: i0.ɵɵFactoryDeclaration<PolylinesEditorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PolylinesEditorService>;
}

declare class PolylinesEditorComponent implements OnDestroy {
    private polylinesEditor;
    private coordinateConverter;
    private mapEventsManager;
    private cameraService;
    private polylinesManager;
    private cesiumService;
    private editLabelsRenderFn;
    editPoints$: Subject<AcNotification>;
    editPolylines$: Subject<AcNotification>;
    polylineLabels$: Subject<AcNotification>;
    private editPointsLayer;
    private editPolylinesLayer;
    private polylineLabelsLayer;
    constructor(polylinesEditor: PolylinesEditorService, coordinateConverter: CoordinateConverter, mapEventsManager: MapEventsManagerService, cameraService: CameraService, polylinesManager: PolylinesManagerService, cesiumService: CesiumService);
    private startListeningToEditorUpdates;
    getLabelId(element: any, index: number): string;
    renderEditLabels(polyline: EditablePolyline, update: PolylineEditUpdate, labels?: LabelProps[]): void;
    removeEditLabels(polyline: EditablePolyline): void;
    handleCreateUpdates(update: PolylineEditUpdate): void;
    handleEditUpdates(update: PolylineEditUpdate): void;
    ngOnDestroy(): void;
    getPointSize(point: EditPoint): number;
    getPointShow(point: EditPoint): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PolylinesEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PolylinesEditorComponent, "polylines-editor", never, {}, {}, never, never, false, never>;
}

interface IconDragEvent {
    initialScreenPosition: Vec2;
    screenPosition: Vec2;
    mapPosition: Cartesian3;
    drop: boolean;
}
/**
 * The Service is used to preform, handle and subscribe to icon dragging when using the `DraggableToMapDirective`.
 * For more info check `DraggableToMapDirective` docs.
 */
declare class DraggableToMapService {
    private document;
    private mapsManager;
    private coordinateConverter;
    private dragObservable;
    private stopper;
    private mainSubject;
    constructor(document: any, mapsManager: MapsManagerService);
    setCoordinateConverter(coordinateConverter: CoordinateConverter): void;
    drag(imageSrc: string, style?: any): void;
    dragUpdates(): Observable<IconDragEvent>;
    cancel(): void;
    private createDragObservable;
    static ɵfac: i0.ɵɵFactoryDeclaration<DraggableToMapService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DraggableToMapService>;
}

/**
 * This directive is used to allow dragging of icons from outside the map over the map
 * while being notified of the dragging position and drop position with an observable exposed from `DraggableToMapService`.
 * @Input {src: string, style?: any} | string -
 * the [src: string | string] should be the image src of the dragged image.
 * The style is an optional style object for the image.
 *
 * example:
 * ```
 * <a href="..." class="..." [draggableToMap]="{src: '../assets/GitHub-Mark-Light.png', style: {width: '50px', height: '50px'}}">
 *     <img class="github" src="../assets/GitHub-Mark-Light.png">
 * </a>
 * ```
 *
 * In order the get notified of the dragging location  and drop state subscribe to `DraggableToMapService.dragUpdates()`
 * ```
 *  this.iconDragService.dragUpdates().subscribe(e => console.log(e));
 * ```
 *
 * In order the cancel dragging use `DraggableToMapService.cancel()`
 * ```
 *  this.iconDragService.cancel();
 * ```
 */
declare class DraggableToMapDirective implements OnInit {
    private iconDragService;
    draggableToMap: {
        src: string;
        style?: any;
    } | string;
    private src;
    private style;
    constructor(el: ElementRef, iconDragService: DraggableToMapService);
    ngOnInit(): void;
    onMouseDown(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DraggableToMapDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DraggableToMapDirective, "[draggableToMap]", never, { "draggableToMap": { "alias": "draggableToMap"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DragIconComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<DragIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DragIconComponent, "ac-drag-icon", never, {}, {}, never, never, false, never>;
}

/**
 * Toolbar widget, act as a container for ac-toolbar-button components
 * allowing drag configuration and passing `toolbarClass` as attributes
 *
 * Usage:
 * ```
 * <ac-toolbar [allowDrag]="true" (onDrag)="handleDrag($event)">
 <ac-toolbar-button [iconUrl]="'assets/home-icon.svg'" (onClick)="goHome()">
 </ac-toolbar-button>
 <ac-toolbar-button [iconUrl]="'assets/explore-icon.svg'" (onClick)="rangeAndBearing()">
 </ac-toolbar-button>
 </ac-toolbar>
 * ```
 *
 */
declare class AcToolbarComponent implements OnInit, OnChanges, OnDestroy {
    private element;
    private cesiumService;
    toolbarClass: string;
    allowDrag: boolean;
    onDrag: EventEmitter<MouseEvent>;
    dragStyle: {
        'height.px': number;
        'width.px': number;
    };
    private mouseDown$;
    private mouseMove$;
    private mouseUp$;
    private drag$;
    private dragSubscription;
    constructor(element: ElementRef, cesiumService: CesiumService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private listenForDragging;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcToolbarComponent, "ac-toolbar", never, { "toolbarClass": { "alias": "toolbarClass"; "required": false; }; "allowDrag": { "alias": "allowDrag"; "required": false; }; }, { "onDrag": "onDrag"; }, never, ["*"], false, never>;
}

/**
 * Toolbar button widget, act as a single button inside ac-toolbar component
 * Can accepts content components or passing [iconUrl]
 * configure with: `[iconUrl]`,`[buttonClass]`,`[iconClass]`,`(onClick)`
 *
 * Usage:
 * ```
 * <ac-toolbar [allowDrag]="true">
 <ac-toolbar-button [iconUrl]="'assets/home-icon.svg'" (onClick)="goHome()">
 </ac-toolbar-button>
 <ac-toolbar-button [iconUrl]="'assets/explore-icon.svg'" (onClick)="rangeAndBearing()">
 </ac-toolbar-button>
 </ac-toolbar>
 * ```
 *
 */
declare class AcToolbarButtonComponent implements OnInit {
    iconUrl: string;
    buttonClass: string;
    iconClass: string;
    onClick: EventEmitter<any>;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AcToolbarButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AcToolbarButtonComponent, "ac-toolbar-button", never, { "iconUrl": { "alias": "iconUrl"; "required": false; }; "buttonClass": { "alias": "buttonClass"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; }, { "onClick": "onClick"; }, never, ["*"], false, never>;
}

/**
 *
 * Range and bearing component that is used to draw range and bearing on the map.
 * The inputs are used to customize the range and bearing style and behavior.
 * Create component reference and use the `create()` function to start creating R&B on the map.
 * The function receives an optional RangeAndBearingOptions object that defines the created range and bearing style and behavior
 * (on top of the default and global definitions).
 *
 * Usage:
 *
 * my-component.ts:
 *
 * ```
 * \@ViewChild('rangeAndBearing', {static: false}) private rangeAndBearing: RangeAndBearingComponent; // Get R&B reference
 *  // ...
 * this.rangeAndBearing.create({style: { pointProps: { pixelSize: 12 } }, bearingLabelsStyle: { fillColor: Color.GREEN } });
 * ```
 *
 * my-component.html
 * ```
 * <range-and-bearing #rangeAndBearing></range-and-bearing> // Optional inputs defines global style and behavior.
 * ```
 *
 */
declare class RangeAndBearingComponent {
    private polylineEditor;
    private coordinateConverter;
    lineEditOptions?: PolylineEditOptions;
    labelsStyle?: LabelStyle;
    distanceLabelsStyle?: LabelStyle;
    bearingLabelsStyle?: LabelStyle;
    bearingStringFn?: (value: number) => string;
    distanceStringFn?: (value: number) => string;
    labelsRenderFn?: (update: PolylineEditUpdate, labels: LabelProps[]) => LabelProps[];
    constructor(polylineEditor: PolylinesEditorService, coordinateConverter: CoordinateConverter);
    create({ lineEditOptions, labelsStyle, distanceLabelsStyle, bearingLabelsStyle, bearingStringFn, distanceStringFn, labelsRenderFn, }?: RangeAndBearingOptions): PolylineEditorObservable;
    static ɵfac: i0.ɵɵFactoryDeclaration<RangeAndBearingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RangeAndBearingComponent, "range-and-bearing", never, { "lineEditOptions": { "alias": "lineEditOptions"; "required": false; }; "labelsStyle": { "alias": "labelsStyle"; "required": false; }; "distanceLabelsStyle": { "alias": "distanceLabelsStyle"; "required": false; }; "bearingLabelsStyle": { "alias": "bearingLabelsStyle"; "required": false; }; "bearingStringFn": { "alias": "bearingStringFn"; "required": false; }; "distanceStringFn": { "alias": "distanceStringFn"; "required": false; }; "labelsRenderFn": { "alias": "labelsRenderFn"; "required": false; }; }, {}, never, never, false, never>;
}
interface RangeAndBearingOptions {
    lineEditOptions?: PolylineEditOptions;
    labelsStyle?: LabelStyle;
    distanceLabelsStyle?: LabelStyle;
    bearingLabelsStyle?: LabelStyle;
    bearingStringFn?: (value: number) => string;
    distanceStringFn?: (value: number) => string;
    labelsRenderFn?: (update: PolylineEditUpdate, labels: LabelProps[]) => LabelProps[];
}

declare class AngularCesiumWidgetsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AngularCesiumWidgetsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularCesiumWidgetsModule, [typeof PointsEditorComponent, typeof HippodromeEditorComponent, typeof PolygonsEditorComponent, typeof RectanglesEditorComponent, typeof CirclesEditorComponent, typeof EllipsesEditorComponent, typeof PolylinesEditorComponent, typeof DraggableToMapDirective, typeof DragIconComponent, typeof AcToolbarComponent, typeof AcToolbarButtonComponent, typeof RangeAndBearingComponent], [typeof i1.CommonModule, typeof AngularCesiumModule], [typeof PointsEditorComponent, typeof HippodromeEditorComponent, typeof PolygonsEditorComponent, typeof RectanglesEditorComponent, typeof CirclesEditorComponent, typeof EllipsesEditorComponent, typeof PolylinesEditorComponent, typeof DraggableToMapDirective, typeof AcToolbarComponent, typeof AcToolbarButtonComponent, typeof RangeAndBearingComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AngularCesiumWidgetsModule>;
}

declare class EditPolyline extends AcEntity {
    static counter: number;
    private editedEntityId;
    private id;
    private positions;
    private _polylineProps;
    constructor(entityId: string, startPosition: Cartesian3, endPosition: Cartesian3, polylineProps?: PolylineProps);
    get props(): PolylineProps;
    set props(value: PolylineProps);
    getEditedEntityId(): string;
    getPositions(): any[];
    getPositionsCallbackProperty(): CallbackProperty;
    validatePositions(): boolean;
    getStartPosition(): Cartesian3;
    getEndPosition(): Cartesian3;
    setStartPosition(position: Cartesian3): void;
    setEndPosition(position: Cartesian3): void;
    getId(): string;
    private generateId;
}

declare class EditArc extends AcEntity {
    private _arcProps;
    static counter: number;
    private id;
    private editedEntityId;
    private _center;
    private _radius;
    private _delta;
    private _angle;
    constructor(entityId: string, center: Cartesian3, radius: number, delta: number, angle: number, _arcProps: PolylineProps);
    get props(): PolylineProps;
    set props(props: PolylineProps);
    get angle(): number;
    set angle(value: number);
    get delta(): number;
    set delta(value: number);
    get radius(): number;
    set radius(value: number);
    get center(): Cartesian3;
    set center(value: Cartesian3);
    updateCenter(center: Cartesian3): void;
    getId(): string;
    private generateId;
}

/**
 * The Service is as a "zoom to rectangle" tool
 *
 * example:
 * ```
 * constructor(
 *   private cameraService: CameraService,
 *   private cesiumService: CesiumService,
 *   private zoomToRectangleService: ZoomToRectangleService,
 * ) {
 *   this.zoomToRectangleService.init(cesiumService, cameraService);
 * }
 * ...
 * this.zoomToRectangleService.activate({onComplete: () => this.zoomToRectangleService.disable()});
 * ```
 *
 * `init()` - initialize the service with CameraService and CesiumService.
 * If no mapId is provided to activate() - must be called before calling `activate()`.
 *
 * `disable()` - disables the tool.
 *
 * `activate()` -
 * @param options
 * {
 *  onStart - optional - a callback that will be called when the user start drawing the rectangle
 *  onComplete - optional - a callback that will be called when the tool zoom in
 *  autoDisableOnZoom - optional - determines if the tool should auto disable after zoom - default: true
 *  animationDurationInSeconds - optional - zoom animation duration in seconds - default: 0.5
 *  borderStyle - optional - the style of the rectangle element border - default: '3px dashed #FFFFFF'
 *  backgroundColor - optional - the background color of the rectangle element - default: 'transparent'
 *  resetKeyCode - optional - the key code of the key that is used to reset the drawing of the rectangle - default: 27 (ESC key)
 *  threshold - optional - the minimum area of the screen rectangle (in pixels) that is required to perform zoom - default: 9
 *  keepRotation - optional - whether or not to keep the rotation when zooming in - default: true
 *  mouseButton - optional - sets the mouse button for drawing the rectangle - default: left mouse button (0)
 * }
 * @param mapId - optional - the mapId of the map that the tool will be used in.
 *
 */
declare enum MouseButtons {
    LEFT = 0,
    MIDDLE = 1,
    RIGHT = 2
}
declare class ZoomToRectangleService {
    private mapsManager;
    constructor(mapsManager: MapsManagerService, cameraService: CameraService, cesiumService: CesiumService);
    private cameraService;
    private cesiumService;
    private mapsZoomElements;
    private defaultOptions;
    init(cesiumService: CesiumService, cameraService: CameraService): void;
    activate(options?: {
        onStart?: (acMap?: AcMapComponent) => any;
        onComplete?: (acMap?: AcMapComponent) => any;
        mouseButton?: MouseButtons;
        autoDisableOnZoom?: boolean;
        animationDurationInSeconds?: number;
        threshold?: number;
        keepRotation?: boolean;
        borderStyle?: string;
        backgroundColor?: string;
        resetKeyCode?: number;
    }, mapId?: string): void;
    disable(mapId?: string): void;
    private zoomCameraToRectangle;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZoomToRectangleService, [null, { optional: true; }, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ZoomToRectangleService>;
}

export { AcArcComponent, AcArcDescComponent, AcArrayDescComponent, AcBillboardComponent, AcBillboardDescComponent, AcBillboardPrimitiveDescComponent, AcBoxDescComponent, AcCircleComponent, AcCircleDescComponent, AcCorridorDescComponent, AcCylinderDescComponent, AcCzmlDescComponent, AcDefaultPlonterComponent, AcDynamicCircleDescComponent, AcDynamicEllipseDescComponent, AcDynamicPolylineDescComponent, AcEllipseComponent, AcEllipseDescComponent, AcEllipsoidDescComponent, AcEntity, AcHtmlComponent, AcHtmlDescComponent, AcLabelComponent, AcLabelDescComponent, AcLabelPrimitiveDescComponent, AcLayerComponent, AcMapComponent, AcMapLayerProviderComponent, AcMapTerrainProviderComponent, AcModelDescComponent, AcNotification, AcPointComponent, AcPointDescComponent, AcPointPrimitiveDescComponent, AcPolygonComponent, AcPolygonDescComponent, AcPolylineComponent, AcPolylineDescComponent, AcPolylinePrimitiveDescComponent, AcPolylineVolumeDescComponent, AcPrimitivePolylineComponent, AcRectangleComponent, AcRectangleDescComponent, AcStaticCircleDescComponent, AcStaticEllipseDescComponent, AcStaticPolygonDescComponent, AcStaticPolylineDescComponent, AcTileset3dComponent, AcToolbarButtonComponent, AcToolbarComponent, AcWallDescComponent, ActionType, AngularCesiumModule, AngularCesiumWidgetsModule, CameraService, CesiumEvent, CesiumEventModifier, CesiumService, CircleEditorObservable, CirclesEditorComponent, CirclesEditorService, ContextMenuService, CoordinateConverter, DEFAULT_CIRCLE_OPTIONS, DEFAULT_ELLIPSE_OPTIONS, DEFAULT_HIPPODROME_OPTIONS, DEFAULT_POINT_OPTIONS, DEFAULT_POLYGON_OPTIONS, DEFAULT_POLYLINE_OPTIONS, DEFAULT_RECTANGLE_OPTIONS, DisposableObservable, DraggableToMapDirective, DraggableToMapService, EditActions, EditArc, EditModes, EditPoint, EditPolyline, EditableCircle, EditableEllipse, EditableHippodrome, EditablePoint, EditablePolygon, EditablePolyline, EditableRectangle, EditorObservable, EllipseEditorObservable, EllipsesEditorComponent, EllipsesEditorService, GeoUtilsService, HippodromeEditorComponent, HippodromeEditorObservable, HippodromeEditorService, KeyboardAction, KeyboardControlService, MapEventsManagerService, MapLayerProviderOptions, MapTerrainProviderOptions, MapsManagerService, MouseButtons, PREDEFINED_KEYBOARD_ACTIONS, PickOptions, PixelOffsetPipe, PlonterService, PointEditorObservable, PointsEditorComponent, PointsEditorService, PolygonEditorObservable, PolygonsEditorComponent, PolygonsEditorService, PolylineEditorObservable, PolylinesEditorComponent, PolylinesEditorService, RadiansToDegreesPipe, RangeAndBearingComponent, RectangleEditorObservable, RectanglesEditorComponent, RectanglesEditorService, SceneMode, ScreenshotService, SelectionManagerService, ViewerConfiguration, ZoomToRectangleService, defaultLabelProps };
export type { BasicContextMenu, BasicEditUpdate, CircleEditOptions, CircleEditUpdate, ClampTo3DOptions, ContextMenuOptions, EditorEditOptions, EllipseEditOptions, EllipseEditUpdate, EllipseProps, EntitiesDrawerOptions, EventRegistrationInput, EventResult, HippodromeEditOptions, HippodromeEditUpdate, HippodromeProps, IDescription, IconDragEvent, KeyboardControlActionFn, KeyboardControlDefinition, KeyboardControlDoneFn, KeyboardControlParams, KeyboardControlValidationFn, LabelProps, LabelStyle, LayerOptions, ModuleConfiguration, Movement, PickConfiguration, PointEditOptions, PointEditUpdate, PointProps, PolygonEditOptions, PolygonEditUpdate, PolygonProps, PolylineEditOptions, PolylineEditUpdate, PolylineProps, RangeAndBearingOptions, RectangleEditOptions, RectangleEditUpdate, RectangleProps, SelectionOptions, Vec2, Vec3 };