/**
 * Provides help functions that helps you to create and manage layers.
 *
 * @param {angular.IQService} $q Angular promises/deferred service.
 * @param {angular.IHttpService} $http Angular http service.
 * @param {import('ngeo/options').ngeoTilesPreloadingLimit} ngeoTilesPreloadingLimit Load tiles up to preload levels.
 *     By default preload is Infinity,
 *     which means load all tiles on the top of the visible level. See also preload value
 *     in documentation for ol.Layer.Tile.
 * @class
 * @ngdoc service
 * @ngname ngeoLayerHelper
 * @hidden
 */
export function LayerHelper($q: angular.IQService, $http: angular.IHttpService, ngeoTilesPreloadingLimit: import("ngeo/options").ngeoTilesPreloadingLimit): void;
export class LayerHelper {
    /**
     * Provides help functions that helps you to create and manage layers.
     *
     * @param {angular.IQService} $q Angular promises/deferred service.
     * @param {angular.IHttpService} $http Angular http service.
     * @param {import('ngeo/options').ngeoTilesPreloadingLimit} ngeoTilesPreloadingLimit Load tiles up to preload levels.
     *     By default preload is Infinity,
     *     which means load all tiles on the top of the visible level. See also preload value
     *     in documentation for ol.Layer.Tile.
     * @class
     * @ngdoc service
     * @ngname ngeoLayerHelper
     * @hidden
     */
    constructor($q: angular.IQService, $http: angular.IHttpService, ngeoTilesPreloadingLimit: import("ngeo/options").ngeoTilesPreloadingLimit);
    /**
     * @type {angular.IQService}
     */
    $q_: angular.IQService;
    /**
     * @type {angular.IHttpService}
     */
    $http_: angular.IHttpService;
    /**
     * The Tiles Preloading Limit value
     *
     * @type {number}
     */
    tilesPreloadingLimit_: number;
    /**
     * Copy each properties from a layer onto an other layer, with the
     * option to exclude specific ones.
     *
     * @param {import('ol/layer/Layer').default<import('ol/source/Source').default>} layerFrom The layer
     *     from which to copy the properties.
     * @param {import('ol/layer/Layer').default<import('ol/source/Source').default>} layerTo The layer onto
     *     which the properties are copied.
     * @param {string[]} [opt_excludes] A list of properties that should
     *     not be copied.
     */
    copyProperties(layerFrom: import("ol/layer/Layer").default<import("ol/source/Source").default>, layerTo: import("ol/layer/Layer").default<import("ol/source/Source").default>, opt_excludes?: string[]): void;
    /**
     * Create and return a basic WMS layer with only a source URL and a comma
     * separated layers names (see {@link import('ol/source/ImageWMS').default}).
     *
     * @param {string} sourceURL The source URL.
     * @param {string} sourceLayersName A comma separated names string.
     * @param {string} sourceFormat Image format, for example 'image/png'.
     * @param {string} [opt_serverType] Type of the server ("mapserver",
     *     "geoserver", "qgisserver", …).
     * @param {string} [opt_time] time parameter for layer queryable by time/period
     * @param {Object<string, string>} [opt_params] WMS parameters.
     * @param {string} [opt_crossOrigin] crossOrigin.
     * @param {unknown} [opt_customSourceOptions] Some layer's source initial options.
     * @param {unknown} [opt_customLayerOptions] Some layer initial options.
     * @returns {import('ol/layer/Image').default<import('ol/source/Image').default>} WMS Layer.
     */
    createBasicWMSLayer(sourceURL: string, sourceLayersName: string, sourceFormat: string, opt_serverType?: string, opt_time?: string, opt_params?: {
        [x: string]: string;
    }, opt_crossOrigin?: string, opt_customSourceOptions?: unknown, opt_customLayerOptions?: unknown): import("ol/layer/Image").default<import("ol/source/Image").default>;
    /**
     * Create and return a basic WMS layer using an OGC data source.
     *
     * @param {import('ngeo/datasource/OGC').default} dataSource OGC data source.
     * @param {string} [opt_crossOrigin] crossOrigin.
     * @returns {import('ol/layer/Image').default<import('ol/source/Image').default>} WMS Layer.
     */
    createBasicWMSLayerFromDataSource(dataSource: import("ngeo/datasource/OGC").default, opt_crossOrigin?: string): import("ol/layer/Image").default<import("ol/source/Image").default>;
    /**
     * Small hack to get perfect sync with the on resolution status and the zoom to resolution.
     *
     * @param {number} opt_maxResolution resolution.
     * @returns {number} fixed maximum resolution.
     */
    fixResolution_(opt_maxResolution: number): number;
    /**
     * Create and return a promise that provides a WMTS layer with source on
     * success, no layer else.
     * The WMTS layer source will be configured by the capabilities that are
     * loaded from the given capabilitiesUrl.
     * The style object described in the capabilities for this layer will be added
     * as key 'capabilitiesStyles' as param of the new layer.
     *
     * @param {string} capabilitiesURL The getCapabilities url.
     * @param {string} layerName The name of the layer.
     * @param {string} [opt_matrixSet] Optional WMTS matrix set.
     * @param {Object<string, ?string>} [opt_dimensions] WMTS dimensions.
     * @param {Object} [opt_customOptions] Some initial options.
     * @param {number} [opt_minResolution] WMTS minimum resolution.
     * @param {number} [opt_maxResolution] WMTS maximum resolution.
     * @param {number} [opt_opacity] The opacity.
     * @returns {angular.IPromise<import('ol/layer/WebGLTile').default<import('ol/source/Tile').default>>} A Promise with a layer (with source) on
     *    success, no layer else.
     */
    createWMTSLayerFromCapabilitites(capabilitiesURL: string, layerName: string, opt_matrixSet?: string, opt_dimensions?: {
        [x: string]: string;
    }, opt_customOptions?: Object, opt_minResolution?: number, opt_maxResolution?: number, opt_opacity?: number): angular.IPromise<import("ol/layer/WebGLTile").default<import("ol/source/Tile").default>>;
    /**
     * Create and return a WMTS layer using a formatted capabilities response
     * and a capability layer.
     *
     * @param {Object<string, any>} capabilities The complete capabilities object of the service
     * @param {Object<string, any>} layerCap The layer capability object
     * @param {Object<string, string>} [opt_dimensions] WMTS dimensions.
     * @returns {import('ol/layer/WebGLTile').default<import('ol/source/Tile').default>} WMTS layer
     */
    createWMTSLayerFromCapabilititesObj(capabilities: {
        [x: string]: any;
    }, layerCap: {
        [x: string]: any;
    }, opt_dimensions?: {
        [x: string]: string;
    }): import("ol/layer/WebGLTile").default<import("ol/source/Tile").default>;
    /**
     * @param {string} url URL template. Must include {x}, {y} or {-y}, and {z} placeholders.
     * A {?-?} template pattern, for example subdomain{a-f}.domain.com, may be used instead.
     * of defining each one separately in the urls option.
     * @param {string|Object} style a Mapbox Style object.
     * @param {string} layername the name of the url as identified in the style.
     * @param {string} projection The projection code.
     * @param {import('ol/tilegrid/TileGrid').default} tileGrid The tile grid to define the source with.
     * @param {number} [opt_minResolution] WMTS minimum resolution.
     * @param {number} [opt_maxResolution] WMTS maximum resolution.
     * @param {number} [opt_opacity] The opacity.
     * @returns {import('ol/layer/VectorTile').default<import('ol/source/VectorTile').default>} Vector
     * tile layer.
     */
    createBasicVectorTilesLayer(url: string, style: string | Object, layername: string, projection: string, tileGrid: import("ol/tilegrid/TileGrid").default, opt_minResolution?: number, opt_maxResolution?: number, opt_opacity?: number): import("ol/layer/VectorTile").default<import("ol/source/VectorTile").default>;
    /**
     * Create and return an ol.layer.Group. You can pass a collection of layers to
     * directly add them in the returned group.
     *
     * @param {import('ol/Collection').default<import('ol/layer/Base').default>} [opt_layers] The layer to
     *    add to the returned Group.
     * @returns {import('ol/layer/Group').default} Layer group.
     */
    createBasicGroup(opt_layers?: import("ol/Collection").default<import("ol/layer/Base").default>): import("ol/layer/Group").default;
    /**
     * Retrieve (or create if it doesn't exist) and return a group of layer from
     * the base array of layers of a map. The given name is used as unique
     * identifier. If the group is created, it will be automatically added to
     * the map.
     *
     * @param {import('ol/Map').default} map A map.
     * @param {string} groupName The name of the group.
     * @returns {import('ol/layer/Group').default} The group corresponding to the given name.
     */
    getGroupFromMap(map: import("ol/Map").default, groupName: string): import("ol/layer/Group").default;
    /**
     * Get an array of all layers in a group. The group can contain multiple levels
     * of others groups.
     *
     * @param {import('ol/layer/Base').default} layer The base layer, mostly a group of layers.
     * @returns {import('ol/layer/Layer').default<import('ol/source/Source').default>[]} Layers.
     */
    getFlatLayers(layer: import("ol/layer/Base").default): import("ol/layer/Layer").default<import("ol/source/Source").default>[];
    /**
     * Get an array of all layers in a group. The group can contain multiple levels
     * of others groups. When we flatten a group, we get the child layers.
     * If opacity is defined on the group, this value is lost.
     * Computed opacity is a custom 'back-up' value that contains
     * the calculated value of all ancestors and the given layer.
     *
     * @param {import('ol/layer/Base').default} layer The base layer, mostly a group of layers.
     * @param {olLayerLayer<import('ol/source/Source').default>[]} array An array to add layers.
     * @param {number|undefined} computedOpacity Opacity inherited from ancestor layer groups.
     * @returns {olLayerLayer<import('ol/source/Source').default>[]} Layers.
     */
    getFlatLayers_(layer: import("ol/layer/Base").default, array: olLayerLayer<import("ol/source/Source").default>[], computedOpacity: number | undefined): olLayerLayer<import("ol/source/Source").default>[];
    /**
     * Get a layer that has the LAYER_NODE_NAME_KEY property equal to a given layer name from
     * an array of layers. If one of the layers in the array is a group, then the
     * layers contained in that group are searched as well.
     *
     * @param {string} nodeName The node name of the layer we're looking for.
     * @param {import("ol/layer/Base").default[]} layers Layers.
     * @returns {?import("ol/layer/Base").default} Layer.
     */
    getLayerByNodeName(nodeName: string, layers: import("ol/layer/Base").default[]): import("ol/layer/Base").default | null;
    /**
     * Get the WMTS legend URL for the given layer.
     *
     * @param {import('ol/layer/WebGLTile').default<import('ol/source/Tile').default>} layer Tile layer as returned by the
     * ngeo layerHelper service.
     * @returns {string|undefined} The legend URL or undefined.
     */
    getWMTSLegendURL(layer: import("ol/layer/WebGLTile").default<import("ol/source/Tile").default>): string | undefined;
    /**
     * Get the WMS legend URL for the given node.
     *
     * @param {string|undefined} url The base url of the wms service.
     * @param {string} layerName The name of a wms layer.
     * @param {number} [opt_scale] A scale.
     * @param {string} [opt_legendRule] rule parameters to add to the returned URL.
     * @param {number} [opt_legendWidth] the legend width.
     * @param {number} [opt_legendHeight] the legend height.
     * @param {string} [opt_servertype] the OpenLayers server type.
     * @param {number} [opt_dpi] the DPI.
     * @param {number[]} [opt_bbox] the bbox.
     * @param {string} [opt_srs] The projection code.
     * @param {Object<string, string>} [opt_additionalQueryString] Additional query string parameters.
     * @returns {string|undefined} The legend URL or undefined.
     */
    getWMSLegendURL(url: string | undefined, layerName: string, opt_scale?: number, opt_legendRule?: string, opt_legendWidth?: number, opt_legendHeight?: number, opt_servertype?: string, opt_dpi?: number, opt_bbox?: number[], opt_srs?: string, opt_additionalQueryString?: {
        [x: string]: string;
    }): string | undefined;
    /**
     * Returns if this layer is visible at the current resolution.
     *
     * @param {import('ol/layer/Base').default} layer Layer.
     * @param {import('ol/Map').default} map Map.
     * @returns {boolean} Is the layer currently visible?
     */
    isLayerVisible(layer: import("ol/layer/Base").default, map: import("ol/Map").default): boolean;
    /**
     * Force a WMS layer to refresh using a random value.
     *
     * @param {import('ol/layer/Image').default<import('ol/source/Image').default>|import('ol/layer/WebGLTile').default<import('ol/source/Tile').default>} layer Layer to refresh.
     */
    refreshWMSLayer(layer: import("ol/layer/Image").default<import("ol/source/Image").default> | import("ol/layer/WebGLTile").default<import("ol/source/Tile").default>): void;
    /**
     * Set ZIndex property to first level children elements
     *
     * @param {import('ol/layer/Group').default|import('ol/layer/Base').default} element The group of
     *    layer with first level children layers.
     * @param {number} ZIndex The ZIndex for children element.
     */
    setZIndexToFirstLevelChildren(element: import("ol/layer/Group").default | import("ol/layer/Base").default, ZIndex: number): void;
    /**
     * Update the LAYERS parameter of the source of the given WMS layer.
     *
     * @param {import('ol/layer/Image').default<import('ol/source/Image').default>} layer The WMS layer.
     * @param {string} names The names that will be used to set
     * the LAYERS parameter.
     * @param {string} [opt_time] The start
     * and optionally the end datetime (for time range selection) selected by user
     * in a ISO-8601 string datetime or time interval format
     */
    updateWMSLayerState(layer: import("ol/layer/Image").default<import("ol/source/Image").default>, names: string, opt_time?: string): void;
    /**
     * @param {import('ol/layer/Image').default<import('ol/source/Image').default>} layer The WMS layer.
     * @returns {number[]|undefined} List of query source ids, a.k.a.
     *     the data source ids this layer is composed of.
     */
    getQuerySourceIds(layer: import("ol/layer/Image").default<import("ol/source/Image").default>): number[] | undefined;
}
export namespace LayerHelper {
    let $inject: string[];
}
/**
 * Layer node name key in layer parameters.
 * To identify the OpenLayers layer by its name.
 */
export const LAYER_NODE_NAME_KEY: "layerNodeName";
/**
 * Key to know if the layer is used as a leaf in a tree.
 * In mixed WMS groups that would be probably the case but not in a
 * not-mixed WMS groups where we want to toggle each wms names (sub-layers).
 */
export const NODE_IS_LEAF: "layerIsLeaf";
/**
 * Id of the datasource
 */
export const DATASOURCE_ID: "dataSourceId";
/**
 * Name key for layer groups in the map.
 */
export const GROUP_KEY: "groupName";
export default myModule;
import angular from 'angular';
import olLayerLayer from 'ol/layer/Layer';
/**
 * @type {angular.IModule}
 * @hidden
 */
declare const myModule: angular.IModule;