import * as i0 from '@angular/core';
import { AfterViewInit } from '@angular/core';
import { HsShareUrlService } from 'hslayers-ng/services/share';
import { HsEventBusService } from 'hslayers-ng/services/event-bus';
import { HsLayoutService } from 'hslayers-ng/services/layout';
import { HsMapService } from 'hslayers-ng/services/map';
import { HsSidebarService } from 'hslayers-ng/services/sidebar';
import { Subject, ReplaySubject } from 'rxjs';
import { HsLayerManagerService } from 'hslayers-ng/services/layer-manager';
import { Viewer, Cartesian3, GeocoderService, JulianDate, ImageryProvider, ImageryLayer, DataSource, CesiumTerrainProvider, ArcGISTiledElevationTerrainProvider, WebMapServiceImageryProvider } from 'cesium';
import { HsConfig } from 'hslayers-ng/config';
import { HsTerrainLayerDescriptor } from 'hslayers-ng/types';
import { Feature } from 'ol';
import { Layer, Group, Vector as Vector$1, Image } from 'ol/layer';
import { Vector, Source, Image as Image$1 } from 'ol/source';
import * as i2 from '@angular/common';
import * as i3 from 'hslayers-ng/core';

declare class CesiumCameraServiceParams {
    viewer: Viewer;
    lastGoodCenter: any[];
    ellipsoid: any;
    lastSyncedExtentFromOl: any;
}
declare class HsCesiumCameraService extends CesiumCameraServiceParams {
    private hsLog;
    hsMapService: HsMapService;
    hsConfig: HsConfig;
    private hsCesiumConfig;
    constructor();
    /**
     * Calculates the resolution for a given distance from the ground and latitude
     * @param distance - height above the terrain
     * @param latitude - latitude in degrees as decimal
     */
    calcResolutionForDistance(distance: number, latitude: number): number;
    /**
     * Gets the position the camera is pointing to in lon/lat coordinates and resolution as the third array element
     */
    getCameraCenterInLngLat(): number[];
    /**
     * Gets the position the camera is pointing to in cartesian coordinates and resolution as the third array element
     */
    getCameraCenterInCartesian(): Cartesian3;
    getViewportPolygon(): number[][];
    getCornerCoord(startCoordinates: any, endCoordinates: any): Cartesian3;
    setExtentEqualToOlExtent(view: any): void;
    private fitExtent;
    /**
     * Calculates the distance from the ground based on resolution and latitude
     * @deprecated
     */
    calcDistanceForResolution(resolution: any, latitude: any): number;
    fixMorphs(viewer: any): void;
    getDefaultViewport(): {
        rectangle: any;
        viewFactor: number;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<HsCesiumCameraService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsCesiumCameraService>;
}

declare class HsCesiumConfigObject {
    cesiumAccessToken?: string;
    cesiumAnimation?: boolean;
    cesiumBase?: string;
    cesiumBaseLayerPicker?: boolean;
    cesiumBingKey?: string;
    cesiumDebugShowFramesPerSecond?: boolean;
    cesiumFullscreenButton?: boolean;
    cesiumGeocoder?: boolean | Array<GeocoderService>;
    cesiumInfoBox?: boolean;
    cesiumShadows?: number;
    cesiumTime?: JulianDate;
    cesiumTimeline?: boolean;
    creditContainer?: Element | string;
    imageryProvider?: ImageryProvider;
    verticalExaggeration?: number;
    terrainLayers?: HsTerrainLayerDescriptor[];
    constructor();
}
declare class HsCesiumConfig extends HsCesiumConfigObject {
    /**
     * Triggered when cesiumConfig is updated using 'update' function of HsCesiumService.
     */
    cesiumConfigChanges?: Subject<HsCesiumConfigObject>;
    viewerLoaded: ReplaySubject<Viewer>;
    constructor();
    update?(newConfig: HsCesiumConfigObject): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsCesiumConfig, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsCesiumConfig>;
}

declare class OlCesiumObjectMapItem {
    olObject: any;
    csObject: ImageryLayer | DataSource;
}

declare class ParamCacheMapItem {
    cache: any;
    imageryLayer: ImageryLayer;
}

declare class HsCesiumLayersService {
    hsMapService: HsMapService;
    private hsLog;
    hsConfig: HsConfig;
    hsEventBusService: HsEventBusService;
    hsCesiumConfig: HsCesiumConfig;
    private httpClient;
    layersToBeDeleted: any[];
    viewer: Viewer;
    ol2CsMappings: Array<OlCesiumObjectMapItem>;
    paramCaches: Array<ParamCacheMapItem>;
    constructor();
    defineProxy(): void;
    getProjectFromVersion(version: string, srs: any, crs: any): any;
    setupEvents(): Promise<void>;
    /**
     * From provided URL it guess a format of terrain provider and tries to create one
     * @param url - URL of the terrain provider
     * @returns TerrainProvider instance
     */
    createTerrainProviderFromUrl(url: string, options?: CesiumTerrainProvider.ConstructorOptions): Promise<CesiumTerrainProvider | ArcGISTiledElevationTerrainProvider>;
    /**
     * Add all layers from app HsConfig - default_layers to the map. Only layers specified in visible_layers parameter will get instantly visible.
     */
    repopulateLayers(): Promise<void>;
    serializeVectorLayerToGeoJson(ol_source: Vector): any;
    currentMapProjCode(): string;
    findCesiumLayer(ol: Layer<Source> | Source): ImageryLayer | DataSource;
    findOlLayer(cs: ImageryLayer | DataSource): Layer<Source>;
    findOlSource(cs: ImageryLayer | DataSource): Source;
    linkOlLayerToCesiumLayer(ol_layer: Layer<Source>, cesium_layer: ImageryLayer): void;
    linkOlSourceToCesiumDatasource(ol_source: Vector, cesium_layer: ImageryLayer | DataSource): void;
    syncFeatures(ol_source: Vector): Promise<void>;
    processOlLayer(lyr: Layer<Source> | Group): Promise<void>;
    convertOlToCesiumProvider(olLayer: Layer<Source>): Promise<ImageryLayer | DataSource>;
    createVectorDataSource(ol_lyr: Vector$1<Vector<Feature>>): Promise<DataSource>;
    createTileProvider(ol_lyr: any): ImageryLayer;
    private getProxyFromConfig;
    private getProjectionFromParams;
    createSingleImageProvider(ol_lyr: Image<Image$1>): ImageryLayer;
    removeUnwantedParams(prmCache: any): WebMapServiceImageryProvider.ConstructorOptions;
    changeLayerParam(layer: ImageryLayer, parameter: any, new_value: any): void;
    findParamCache(layer: ImageryLayer): any;
    removeLayersWithOldParams(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsCesiumLayersService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsCesiumLayersService>;
}

declare class HsCesiumTimeService {
    hsCesiumLayersService: HsCesiumLayersService;
    hsEventBusService: HsEventBusService;
    private hsCesiumConfig;
    viewer: Viewer;
    constructor();
    monitorTimeLine(): void;
    getLayerListTimes(): any[];
    getTimeParameter(cesium_layer: any): "time" | "TIME";
    static ɵfac: i0.ɵɵFactoryDeclaration<HsCesiumTimeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsCesiumTimeService>;
}

declare class HsCesiumService {
    hsMapService: HsMapService;
    hsLayermanagerService: HsLayerManagerService;
    hsLayoutService: HsLayoutService;
    private hsLog;
    hsCesiumCameraService: HsCesiumCameraService;
    hsCesiumLayersService: HsCesiumLayersService;
    hsCesiumTimeService: HsCesiumTimeService;
    hsEventBusService: HsEventBusService;
    hsCesiumConfig: HsCesiumConfig;
    private hsCesiumPicker;
    private hsCesiumQueryPopupService;
    private hslayersService;
    private hsOverlayConstructorService;
    private hsShareUrlService;
    BING_KEY: string;
    viewer: any;
    visible: boolean;
    cesiumPositionClicked: Subject<any>;
    private end;
    private windowListeners;
    /**
     * Initializes Cesium map
     */
    init(): Promise<void>;
    cesiumDisabled(): void;
    private getShadowMode;
    checkForBingKey(): void;
    getCameraCenterInLngLat(): number[];
    linkOlLayerToCesiumLayer(ol_layer: any, cesium_layer: any): void;
    dimensionChanged(layer: any, dimension: any): void;
    /**
     * Resize cesium container
     * @param size - Size of OL map container
     */
    resize(size: {
        height: number;
        width: number;
    }): void;
    /**
     * Toggles between Cesium and OL maps by setting HsMapService.visible property which is monitored by ngIf.
     */
    toggleCesiumMap(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsCesiumService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsCesiumService>;
}

declare class HslayersCesiumComponent implements AfterViewInit {
    hsCesiumService: HsCesiumService;
    hsShareUrlService: HsShareUrlService;
    hsMapService: HsMapService;
    hsSidebarService: HsSidebarService;
    private hsToolbarPanelContainerService;
    hsEventBusService: HsEventBusService;
    hsLayoutService: HsLayoutService;
    private destroyRef;
    app: string;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HslayersCesiumComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HslayersCesiumComponent, "hs-cesium", never, {}, {}, never, never, false, never>;
}

declare class HsCesiumModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsCesiumModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsCesiumModule, [typeof HslayersCesiumComponent], [typeof i2.CommonModule, typeof i3.HslayersModule], [typeof HslayersCesiumComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsCesiumModule>;
}

export { CesiumCameraServiceParams, HsCesiumCameraService, HsCesiumConfig, HsCesiumConfigObject, HsCesiumLayersService, HsCesiumModule, HsCesiumService, HsCesiumTimeService, HslayersCesiumComponent };