/**
 * Guess the type of OGC service from a given url. Default returned value is WMS.
 *
 * @param {string} url URL
 * @returns {string} Guessed OGC service type.
 * @hidden
 */
export function guessServiceTypeByUrl(url: string): string;
/**
 * *
 */
export type ServerType = string;
export namespace ServerType {
    let ARCGIS: string;
    let GEOSERVER: string;
    let MAPSERVER: string;
    let QGISSERVER: string;
}
/**
 * *
 */
export type Type = string;
export namespace Type {
    let WMS: string;
    let WMTS: string;
}
/**
 * *
 */
export type WFSOutputFormat = string;
export namespace WFSOutputFormat {
    let GML2: string;
    let GML3: string;
}
/**
 * *
 */
export type WMSInfoFormat = string;
export namespace WMSInfoFormat {
    let GEOJSON: string;
    let GEO_JSON: string;
    let GML: string;
}
/**
 * @typedef {Object} DimensionFilterConfig
 * @property {string} field
 * @property {string} [value]
 */
/**
 * Dimensions applied by filters configuration.
 *
 * @typedef {Object<string, DimensionFilterConfig>} DimensionsFiltersConfig
 */
/**
 * The options required to create a `OGC`.
 *
 * extends DataSourceOptions
 *
 * @typedef {Object} OGCOptions
 * @property {Dimensions} [activeDimensions] The dimensions that are currently active on the data source.
 * @property {boolean} [copyable] Whether the geometry from this data source can be copied to other data
 *    sources or not. Defaults to `false`.
 * @property {Dimensions} [dimensions] A reference to the dimensions.
 * @property {Dimensions} [dimensionsConfig] The dimensions configuration, which determines those supported
 *    by this data source and whether they should use a static value or the one defined in the dimensions.
 * @property {string} [filterCondition] The filter condition to apply to the filter rules (if any).
 *    Defaults to `ngeo.filter.Condition.AND`.
 * @property {import('ngeo/rule/Rule').default[]} [filterRules] A list of filter rules to apply to
 *    this data source using the filter condition.
 * @property {boolean} [filtrable] Whether the data source is filtrable or not.
 * @property {string} [ogcImageType] The type of images to fetch by queries by the (WMS) or (WMTS).
 * @property {WMSLayer[]} [wmsLayers] A list of layer definitions that are used by WMS queries.
 *    These are **not** used by the (WMTS) queries (the wmtsLayers is used by WMTS queries).
 * @property {WFSLayer[]} [wfsLayers] A list of layer definitions that are used by WFS queries.
 *    These are **not** used by the (WMTS) queries (the wmtsLayers is used by WMTS queries).
 * @property {string} [ogcServerType] The type of OGC server.
 * @property {string} [ogcType] The type data source. Can be: 'WMS' or 'WMTS'.
 * @property {?Object<string, Object<string, import('gmf/themes').GmfOgcServerAttribute>>} [ogcAttributes]
 *    The attributes of the OGC server.
 * @property {number[]} [queryIconPosition] values to define the shape (bbox) to use to query
 *    the layer. The values are used like a padding in css with 1, 2, 3 or 4 comma separated
 *    values: all / top-bottom, left-right / top, right-left, bottom / top, right, bottom, left.
 * @property {boolean} [snappable] Whether the geometry from this data source can be used to snap the geometry
 *    of features from other data sources that are being edited. Defaults to `false`.
 * @property {boolean} [snappingToEdges] Determines whether external features can be snapped to the edges of
 *    features from this data source or not. Defaults to `true`. Requires `snappable` to be set.
 * @property {boolean} [snappingToVertice] Determines whether external features can be snapped to the
 *    vertice of features from this data source or not. Defaults to `true`. Requires `snappable` to be set.
 * @property {number} [snappingTolerance=10] The tolerance in pixels the snapping should occur.
 * @property {string} [timeAttributeName]  The name of the time attribute.
 * @property {number} [timeLowerValue] The time lower value, which can be combined with the time upper value
 *    to determine a range.
 * @property {TimeProperty} [timeProperty] The time property for the data source. Used to apply time filters.
 * @property {number} [timeUpperValue] The time upper value, which can be combined with the time lower value
 *    to determine a range.
 * @property {string} [wfsFeatureNS] The feature namespace to use with WFS requests.
 * @property {string} [wfsFeaturePrefix] The feature prefix to use with WFS requests.
 * @property {string} [wfsOutputFormat] The OutputFormat to use with WFS requests.
 * @property {string} [wfsUrl] The URL to use for (WFS) requests.
 * @property {string} [wmsInfoFormat] The InfoFormat to use with WMS requests.
 * @property {boolean} [wmsIsSingleTile] Whether the (WMS) images returned by this data source should be
 *    single tiles or not. Defaults to `false`
 * @property {string} [wmsUrl] The URL to use for (WMS) requests.
 * @property {string} [wmtsLayer] The layer name to use for the (WMTS) requests.
 * @property {string} [wmtsUrl] The URL to use for (WMTS) requests.
 * @property {import('ngeo/format/Attribute').Attribute[]} [attributes] (DataSourceOptions)
 * @property {DimensionsFiltersConfig} [dimensionsFiltersConfig] (DataSourceOptions)
 * @property {number} id (DataSourceOptions)
 * @property {string} [identifierAttribute] (DataSourceOptions)
 * @property {boolean} [inRange] (DataSourceOptions)
 * @property {number} [minResolution] (DataSourceOptions)
 * @property {number} [maxResolution] (DataSourceOptions)
 * @property {string} name (DataSourceOptions)
 * @property {boolean} [visible=false] (DataSourceOptions)
 */
/**
 * The definition of a single layer (WMS) and/or featureType (WFS).
 *
 * @typedef {Object} WMSLayer
 * @property {string} name The layer name (WMS) and/or feature type name (WFS)
 * @property {boolean} [queryable] Whether the the layer is queryable or not. Defaults to `false`.
 * @property {boolean|undefined} [getData] If the layer is queryable and this property is set to
 *     false, then the layer won't be used in queries issued. Defaults to `true`.
 */
/**
 * The definition of a single layer (WMS) and/or featureType (WFS).
 *
 * @typedef {Object} WFSLayer
 * @property {number} [maxResolution] The maximum resolution the layer should be rendered (when visible).
 * @property {number} [minResolution] The minimum resolution the layer should be rendered (when visible).
 * @property {string} name The layer name (WMS) and/or feature type name (WFS)
 * @property {boolean} [queryable] Whether the the layer is queryable or not. Defaults to `false`.
 * @property {boolean|undefined} [getData] If the layer is queryable and this property is set to
 *     false, then the layer won't be used in queries issued. Defaults to `true`.
 */
/**
 * Time object
 *
 * @typedef {Object} TimeProperty
 * @property {TimePropertyWidgetEnum} widget
 * @property {string} maxValue
 * @property {string} minValue
 * @property {string} [maxDefValue]
 * @property {string} [minDefValue]
 * @property {TimePropertyModeEnum} mode
 * @property {TimePropertyResolutionEnum} [resolution]
 * @property {string[]} [values]
 * @property {number[]} interval
 */
/**
 * @typedef {Object} TimeRange
 * @property {number} [end]
 * @property {number} start
 */
/**
 * Active dimensions definition, where the value can't be null.
 *
 * @typedef {Object<string, string>} DimensionsActive
 */
/**
 * Default name of the geometry attribute.
 *
 * @type {string}
 * @private
 * @hidden
 */
export const DEFAULT_GEOMETRY_NAME: string;
/**
 * @private
 * @hidden
 */
export class GmfDatasourceOGC extends ngeoDatasourceDataSource {
    /**
     * A data source contains information of a single source of data that can
     * show or fetch the data using an OGC server. Several OGC service types are
     * supported by this data source: WMS, WMTS and even WFS.
     *
     * You can use the information stored within an OGC data source to do all
     * sorts of things:
     * - issue WMS/WFS queries
     * - apply filter rules on it
     * - create `ol.layer.Layer` objects using the WMS, WMTS or event WFS
     *   information
     *
     * @param {OGCOptions} options Options.
     */
    constructor(options: OGCOptions);
    /**
     * The dimensions configuration for the data source.
     *
     * @type {?Dimensions}
     */
    dimensionsConfig: Dimensions | null;
    /**
     * The dimensions applied by filters configuration for the data source.
     *
     * @type {?DimensionsFiltersConfig}
     */
    dimensionsFiltersConfig: DimensionsFiltersConfig | null;
    /**
     * The filter condition to apply to the filter rules (if any).
     *
     * @type {string}
     */
    filterCondition_: string;
    /**
     * A list of filter rules to apply to this data source using the filter
     * condition.
     *
     * @type {?import('ngeo/rule/Rule').default[]}
     */
    filterRules: import("ngeo/rule/Rule").default[] | null;
    /**
     * Whether the data source is filtrable or not. When `null`, that means
     * that we do not know if the data source if filtrable or not, yet. In
     * that case, the value of the property needs to be determined from an
     * external way.
     *
     * @type {?boolean}
     */
    filtrable: boolean | null;
    /**
     * Whether the geometry from this data source can be copied to other data
     * sources or not. Defaults to `false`.
     *
     * @type {boolean}
     * @private
     */
    private copyable_;
    /**
     * A reference to the dimensions object.
     *
     * @type {?Dimensions}
     * @private
     */
    private dimensions_;
    /**
     * The name of the geometry attribute.
     *
     * @type {string}
     * @private
     */
    private geometryName_;
    /**
     * The type of images to fetch by queries by the (WMS) or (WMTS) .
     *
     * @type {string}
     * @private
     */
    private ogcImageType_;
    /**
     * A list of layer definitions that are used by WMS queries.
     * These are **not** used by the (WMTS) queries (the wmtsLayers is used
     * by WMTS queries).
     *
     * @type {?WMSLayer[]}
     * @private
     */
    private wmsLayers_;
    /**
     * A list of layer definitions that are used by WFS queries.
     * These are **not** used by the (WMTS) queries (the wmtsLayers is used
     * by WMTS queries).
     *
     * @type {?WFSLayer[]}
     * @private
     */
    private wfsLayers_;
    /**
     * The type of OGC server making the requests.
     *
     * @type {string}
     * @private
     */
    private ogcServerType_;
    /**
     * The type data source. Can be: 'WMS' or 'WMTS'.
     *
     * @type {string}
     * @private
     */
    private ogcType_;
    /**
     * The attributes of the OGC server.
     *
     * @type {?Object<string, Object<string, import('gmf/themes').GmfOgcServerAttribute>>}
     * @private
     */
    private ogcAttributes_;
    /**
     * Values to define the shape (bbox) to use to query the layer. The values work like a css
     * padding.
     *
     * @type {number[]}
     * @private
     */
    private queryIconPosition_;
    /**
     * Whether the geometry from this data source can be used to snap the
     * geometry of features from other data sources that are being edited.
     * Defaults to `false`.
     *
     * @type {boolean}
     * @private
     */
    private snappable_;
    /**
     * Determines whether external features can be snapped to the edges of
     * features from this data source or not. Defaults to `true`. Requires
     * `snappable` to be set.
     *
     * @type {boolean}
     * @private
     */
    private snappingToEdges_;
    /**
     * Determines whether external features can be snapped to the vertice of
     * features from this data source or not. Defaults to `true`. Requires
     * `snappable` to be set.
     *
     * @type {boolean}
     * @private
     */
    private snappingToVertice_;
    /**
     * The tolerance in pixels the snapping should occur. Defaults to `10`.
     *
     * @type {number}
     * @private
     */
    private snappingTolerance_;
    /**
     * The name of the time attribute.
     *
     * @type {string|undefined}
     * @private
     */
    private timeAttributeName_;
    /**
     * Time lower value.
     *
     * @type {number|undefined}
     */
    timeLowerValue: number | undefined;
    /**
     * @type {?TimeProperty}
     * @private
     */
    private timeProperty_;
    /**
     * Time upper value.
     *
     * @type {number|undefined}
     */
    timeUpperValue: number | undefined;
    /**
     * The feature namespace to use with WFS requests.
     *
     * @type {string}
     * @private
     */
    private wfsFeatureNS_;
    /**
     * The feature prefix to use with WFS requests.
     *
     * @type {string}
     * @private
     */
    private wfsFeaturePrefix_;
    /**
     * The OutputFormat to use with WFS requests.
     *
     * @type {string}
     * @private
     */
    private wfsOutputFormat_;
    /**
     * The url to use for (WFS) requests.
     *
     * @type {?string}
     */
    wfsUrl_: string | null;
    /**
     * The InfoFormat to use with WMS requests.
     *
     * @type {string}
     * @private
     */
    private wmsInfoFormat_;
    /**
     * Whether the (WMS) images returned by this data source
     * should be single tiles or not.
     *
     * @type {boolean}
     * @private
     */
    private wmsIsSingleTile_;
    /**
     * The url to use for (WMS) requests.
     *
     * @type {string|undefined}
     * @private
     */
    private wmsUrl_;
    /**
     * The layer name to use for the (WMTS) requests.
     *
     * @type {string|undefined}
     * @private
     */
    private wmtsLayer_;
    /**
     * The url to use for (WMTS) requests.
     *
     * @type {string|undefined}
     * @private
     */
    private wmtsUrl_;
    /**
     * @type {import('gmf/themes').GmfLayer}
     * @private
     */
    private gmfLayer_;
    /**
     * @type {?import('ol/format/WFS').default}
     * @private
     */
    private wfsFormat_;
    /**
     * @type {?olFormatWMSGetFeatureInfo|ngeoFormatArcGISGeoJSON}
     * @private
     */
    private wmsFormat_;
    /**
     * @returns {?Dimensions} Current dimensions to use for this data source
     */
    get dimensions(): {
        [x: string]: string;
    };
    /**
     * @param {string} filterCondition Filter condition
     */
    set filterCondition(filterCondition: string);
    /**
     * @returns {string} Filter condition
     */
    get filterCondition(): string;
    /**
     * @param {?TimeRange} range Time range value
     */
    set timeRangeValue(range: TimeRange);
    /**
     * @returns {?TimeRange} Time range value
     */
    get timeRangeValue(): TimeRange;
    /**
     * @returns {boolean} Copyable
     */
    get copyable(): boolean;
    /**
     * @param {string} [layer] The layer name.
     * @returns {?string} Geometry name
     */
    geometryName(layer?: string): string | null;
    /**
     * @returns {string} OGC image type
     */
    get ogcImageType(): string;
    /**
     * @returns {?WMSLayer[]} WMS layers
     */
    get wmsLayers(): WMSLayer[];
    /**
     * @returns {?WFSLayer[]} WFS layers
     */
    get wfsLayers(): WFSLayer[];
    /**
     * @returns {string} OGC server type
     */
    get ogcServerType(): string;
    /**
     * @returns {string} OGC type
     */
    get ogcType(): string;
    /**
     * @returns {number[]} The queryIconPosition
     */
    get queryIconPosition(): number[];
    /**
     * @returns {boolean} Snappable
     */
    get snappable(): boolean;
    /**
     * @returns {boolean} Snapping to edges
     */
    get snappingToEdges(): boolean;
    /**
     * @returns {boolean} Snapping to vertices
     */
    get snappingToVertice(): boolean;
    /**
     * @returns {number} Snapping tolerance
     */
    get snappingTolerance(): number;
    /**
     * @returns {string|undefined} Time attribute name
     */
    get timeAttributeName(): string;
    /**
     * @returns {?TimeProperty} Time property
     */
    get timeProperty(): TimeProperty;
    /**
     * @returns {string} WFS feature namespace
     */
    get wfsFeatureNS(): string;
    /**
     * @returns {string} WFS feature prefix
     */
    get wfsFeaturePrefix(): string;
    /**
     * @returns {string} WFS output format
     */
    get wfsOutputFormat(): string;
    /**
     * @returns {?string} WFS url
     */
    get wfsUrl(): string;
    /**
     * @returns {string} WMS info format
     */
    get wmsInfoFormat(): string;
    /**
     * @returns {boolean} WMS is single tile
     */
    get wmsIsSingleTile(): boolean;
    /**
     * @returns {string|undefined} WMS url
     */
    get wmsUrl(): string;
    /**
     * @returns {string|undefined} WMTS layer
     */
    get wmtsLayer(): string;
    /**
     * @returns {string|undefined} WMTS url
     */
    get wmtsUrl(): string;
    /**
     * @returns {import('gmf/themes').GmfLayer} GMF layer
     */
    get gmfLayer(): import("gmf/themes").GmfLayer;
    /**
     * @returns {DimensionsActive} Active dimensions
     */
    get activeDimensions(): {
        [x: string]: string;
    };
    /**
     * A data source can't be combined to other data source to issue a single
     * WFS request if:
     *
     * - it has filter rules set
     * - it has time range set
     *
     * @returns {boolean} Whether the data source can be combined to an other
     *     data source to fetch features in a single WFS request.
     */
    get combinableForWFS(): boolean;
    /**
     * A data source can't be combined to other data source to issue a single
     * WMS request if:
     *
     * - it has filter rules set
     * - it has time range set
     *
     * @returns {boolean} Whether the data source can be combined to an other
     *     data source to fetch features in a single WMS request.
     */
    get combinableForWMS(): boolean;
    /**
     * Returns the ogc attributes of only the WFS layers of this data
     * source that are queryable.
     *
     * @returns {?Object<string, import('gmf/themes').GmfOgcServerAttribute>}
     */
    get ogcAttributesWFS(): {
        [x: string]: import("gmf/themes").GmfOgcServerAttribute;
    };
    /**
     * Returns the ogc attributes of only the WMS layers of this data
     * source that are queryable.
     *
     * @returns {?Object<string, import('gmf/themes').GmfOgcServerAttribute>}
     */
    get ogcAttributesWMS(): {
        [x: string]: import("gmf/themes").GmfOgcServerAttribute;
    };
    /**
     * @returns {boolean} Whether the data source supports making WFS requests or not.
     */
    get supportsWFS(): boolean;
    /**
     * To be able to do advanced operations on a data source, such as editing
     * or filtering, a data source must be bound to 1 set of attributes.
     * These attributes are the ones defined by an ogcLayer.  This means that
     * to be considered to support having attributes defined, you either need
     * to define them directly when creating the data source, or if you let
     * the querent service get them for you using a WFS DescribeFeatureType
     * request, the data source must have only 1 ogcLayer set, which must
     * be queryable.
     *
     * @returns {boolean} Supports attributes.
     */
    get supportsAttributes(): boolean;
    /**
     * @returns {boolean} Whether the data source supports making WMS requests or not.
     */
    get supportsWMS(): boolean;
    /**
     * @returns {boolean} Whether the data source supports making WTMS requests or not.
     */
    get supportsWMTS(): boolean;
    /**
     * @returns {?import('ol/format/WFS').default} WFS format.
     */
    get wfsFormat(): olFormatWFS;
    /**
     * @returns {?olFormatWMSGetFeatureInfo|ngeoFormatArcGISGeoJSON} WMS format.
     */
    get wmsFormat(): ngeoFormatArcGISGeoJSON | olFormatWMSGetFeatureInfo;
    /**
     * @param {OGC} dataSource Data source.
     * @returns {boolean} Whether this data source can be combined to the given
     *     other data source to fetch features in a single WFS request.
     */
    combinableWithDataSourceForWFS(dataSource: OGC): boolean;
    /**
     * @param {OGC} dataSource Data source.
     * @returns {boolean} Whether this data source can be combined to the given
     *     other data source to fetch features in a single WMS request.
     */
    combinableWithDataSourceForWMS(dataSource: OGC): boolean;
    /**
     * Check if there's at least one OGC layer in range of a given resolution.
     *
     * @param {number} res Resolution.
     * @param {boolean} queryableOnly Whether to additionally check if the
     *     OGC layer is queryable as well or not. Defaults to `false`.
     * @returns {boolean} At least one OGC layer is in range.
     */
    isAnyOGCLayerInRange(res: number, queryableOnly?: boolean): boolean;
    /**
     * Returns the list of WMS layer names.
     *
     * @param {boolean} queryableOnly Whether to additionally check if the
     *     WMS layer is queryable as well or not. Defaults to `false`.
     * @returns {string[]} The WMS layer names.
     */
    getWMSLayerNames(queryableOnly?: boolean): string[];
    /**
     * Returns a list of WFS layer names that are in range of a given resolution.
     * If there's no WFS layers defined, an empty array is returned.
     *
     * @param {number} res Resolution.
     * @param {boolean} queryableOnly Whether to additionally check if the
     *     WFS layer is queryable as well or not. Defaults to `false`.
     * @returns {string[]} The WFS layer names that are in range.
     */
    getInRangeWFSLayerNames(res: number, queryableOnly?: boolean): string[];
    /**
     * Returns the list of WFS layer names.
     *
     * @param {boolean} queryableOnly Whether to additionally check if the
     *     WFS layer is queryable as well or not. Defaults to `false`.
     * @returns {string[]} The WFS layer names.
     */
    getWFSLayerNames(queryableOnly?: boolean): string[];
    /**
     * Returns the filtrable WFS layer name.
     *
     * Although a data source may contain multiple WFS wfs layers, only
     * the first one is returned. We don't need to return more than one,
     * since in that case a group is used in the WMS GetMap query, and
     * each queryable layers will end up being used in WFS GetData
     * queries sent.
     *
     * @returns {string} WFS layer name.
     */
    getFiltrableWFSLayerName(): string;
    /**
     * Loop in the attributes of the data source. Update the `geometryName`
     * property on the first geometry attribute found. If none is found, then
     * the default geometry name is set.
     *
     * @private
     */
    private updateGeometryNameFromAttributes_;
    /**
     * @param {OGC} dataSource Remote data source to
     *     compare with this one.
     * @returns {boolean} Whether the two data sources have the same active
     *     dimensions. If both have no dimensions, they are considered to be
     *     sharing the same dimensions.
     */
    haveTheSameActiveDimensions(dataSource: OGC): boolean;
    /**
     * Compare active dimensions filters of two data sources. As OpenLayers
     * WFS format does not allow constructing multiple typenames GetFeature
     * request with different filters we need to combine data sources depending
     * on active dimensions filters.
     *
     * @param {!OGC} dataSource Remote data source to
     *     compare with this one.
     * @returns {boolean} Whether the two data sources have the same active
     *     dimensions filters. If both have no dimensions, they are considered
     *     to be sharing the same dimensions filters.
     * @export
     */
    haveTheSameActiveDimensionsFilters(dataSource: OGC): boolean;
    /**
     * Collect the ogc attributes that are shared among the given
     * layers, i.e. only the attributes that are in all the given layers
     * are returned.
     *
     * Among the attributes, geometry columns are returned as
     * well. Therefore, if there are no attributes with a geometry name
     * returned, then the Filter tool have the possibilily to filter the
     * data source using spatial filters.
     *
     * @param {string[]} layerNames List of layer names
     * @returns {?Object<string, import('gmf/themes').GmfOgcServerAttribute>}
     */
    getCommonOGCAttributes_(layerNames: string[]): {
        [x: string]: import("gmf/themes").GmfOgcServerAttribute;
    } | null;
}
/**
 * *
 */
export type TimePropertyWidgetEnum = string;
export namespace TimePropertyWidgetEnum {
    let SLIDER: string;
    let DATEPICKER: string;
}
/**
 * *
 */
export type TimePropertyModeEnum = string;
export namespace TimePropertyModeEnum {
    let RANGE: string;
    let VALUE: string;
    let DISABLED: string;
}
/**
 * *
 */
export type TimePropertyResolutionEnum = string;
export namespace TimePropertyResolutionEnum {
    let DAY: string;
    let MONTH: string;
    let YEAR: string;
    let SECOND: string;
}
export default GmfDatasourceOGC;
/**
 * Dimensions definition.
 */
export type Dimensions = {
    [x: string]: string | null;
};
export type DimensionFilterConfig = {
    field: string;
    value?: string;
};
/**
 * Dimensions applied by filters configuration.
 */
export type DimensionsFiltersConfig = {
    [x: string]: DimensionFilterConfig;
};
/**
 * The options required to create a `OGC`.
 *
 * extends DataSourceOptions
 */
export type OGCOptions = {
    /**
     * The dimensions that are currently active on the data source.
     */
    activeDimensions?: Dimensions;
    /**
     * Whether the geometry from this data source can be copied to other data
     * sources or not. Defaults to `false`.
     */
    copyable?: boolean;
    /**
     * A reference to the dimensions.
     */
    dimensions?: Dimensions;
    /**
     * The dimensions configuration, which determines those supported
     * by this data source and whether they should use a static value or the one defined in the dimensions.
     */
    dimensionsConfig?: Dimensions;
    /**
     * The filter condition to apply to the filter rules (if any).
     * Defaults to `ngeo.filter.Condition.AND`.
     */
    filterCondition?: string;
    /**
     * A list of filter rules to apply to
     * this data source using the filter condition.
     */
    filterRules?: import("ngeo/rule/Rule").default[];
    /**
     * Whether the data source is filtrable or not.
     */
    filtrable?: boolean;
    /**
     * The type of images to fetch by queries by the (WMS) or (WMTS).
     */
    ogcImageType?: string;
    /**
     * A list of layer definitions that are used by WMS queries.
     * These are **not** used by the (WMTS) queries (the wmtsLayers is used by WMTS queries).
     */
    wmsLayers?: WMSLayer[];
    /**
     * A list of layer definitions that are used by WFS queries.
     * These are **not** used by the (WMTS) queries (the wmtsLayers is used by WMTS queries).
     */
    wfsLayers?: WFSLayer[];
    /**
     * The type of OGC server.
     */
    ogcServerType?: string;
    /**
     * The type data source. Can be: 'WMS' or 'WMTS'.
     */
    ogcType?: string;
    /**
     * The attributes of the OGC server.
     */
    ogcAttributes?: {
        [x: string]: {
            [x: string]: import("gmf/themes").GmfOgcServerAttribute;
        };
    } | null;
    /**
     * values to define the shape (bbox) to use to query
     * the layer. The values are used like a padding in css with 1, 2, 3 or 4 comma separated
     * values: all / top-bottom, left-right / top, right-left, bottom / top, right, bottom, left.
     */
    queryIconPosition?: number[];
    /**
     * Whether the geometry from this data source can be used to snap the geometry
     * of features from other data sources that are being edited. Defaults to `false`.
     */
    snappable?: boolean;
    /**
     * Determines whether external features can be snapped to the edges of
     * features from this data source or not. Defaults to `true`. Requires `snappable` to be set.
     */
    snappingToEdges?: boolean;
    /**
     * Determines whether external features can be snapped to the
     * vertice of features from this data source or not. Defaults to `true`. Requires `snappable` to be set.
     */
    snappingToVertice?: boolean;
    /**
     * The tolerance in pixels the snapping should occur.
     */
    snappingTolerance?: number;
    /**
     * The name of the time attribute.
     */
    timeAttributeName?: string;
    /**
     * The time lower value, which can be combined with the time upper value
     * to determine a range.
     */
    timeLowerValue?: number;
    /**
     * The time property for the data source. Used to apply time filters.
     */
    timeProperty?: TimeProperty;
    /**
     * The time upper value, which can be combined with the time lower value
     * to determine a range.
     */
    timeUpperValue?: number;
    /**
     * The feature namespace to use with WFS requests.
     */
    wfsFeatureNS?: string;
    /**
     * The feature prefix to use with WFS requests.
     */
    wfsFeaturePrefix?: string;
    /**
     * The OutputFormat to use with WFS requests.
     */
    wfsOutputFormat?: string;
    /**
     * The URL to use for (WFS) requests.
     */
    wfsUrl?: string;
    /**
     * The InfoFormat to use with WMS requests.
     */
    wmsInfoFormat?: string;
    /**
     * Whether the (WMS) images returned by this data source should be
     * single tiles or not. Defaults to `false`
     */
    wmsIsSingleTile?: boolean;
    /**
     * The URL to use for (WMS) requests.
     */
    wmsUrl?: string;
    /**
     * The layer name to use for the (WMTS) requests.
     */
    wmtsLayer?: string;
    /**
     * The URL to use for (WMTS) requests.
     */
    wmtsUrl?: string;
    /**
     * (DataSourceOptions)
     */
    attributes?: import("ngeo/format/Attribute").Attribute[];
    /**
     * (DataSourceOptions)
     */
    dimensionsFiltersConfig?: DimensionsFiltersConfig;
    /**
     * (DataSourceOptions)
     */
    id: number;
    /**
     * (DataSourceOptions)
     */
    identifierAttribute?: string;
    /**
     * (DataSourceOptions)
     */
    inRange?: boolean;
    /**
     * (DataSourceOptions)
     */
    minResolution?: number;
    /**
     * (DataSourceOptions)
     */
    maxResolution?: number;
    /**
     * (DataSourceOptions)
     */
    name: string;
    /**
     * (DataSourceOptions)
     */
    visible?: boolean;
};
/**
 * The definition of a single layer (WMS) and/or featureType (WFS).
 */
export type WMSLayer = {
    /**
     * The layer name (WMS) and/or feature type name (WFS)
     */
    name: string;
    /**
     * Whether the the layer is queryable or not. Defaults to `false`.
     */
    queryable?: boolean;
    /**
     * If the layer is queryable and this property is set to
     * false, then the layer won't be used in queries issued. Defaults to `true`.
     */
    getData?: boolean | undefined;
};
/**
 * The definition of a single layer (WMS) and/or featureType (WFS).
 */
export type WFSLayer = {
    /**
     * The maximum resolution the layer should be rendered (when visible).
     */
    maxResolution?: number;
    /**
     * The minimum resolution the layer should be rendered (when visible).
     */
    minResolution?: number;
    /**
     * The layer name (WMS) and/or feature type name (WFS)
     */
    name: string;
    /**
     * Whether the the layer is queryable or not. Defaults to `false`.
     */
    queryable?: boolean;
    /**
     * If the layer is queryable and this property is set to
     * false, then the layer won't be used in queries issued. Defaults to `true`.
     */
    getData?: boolean | undefined;
};
/**
 * Time object
 */
export type TimeProperty = {
    widget: TimePropertyWidgetEnum;
    maxValue: string;
    minValue: string;
    maxDefValue?: string;
    minDefValue?: string;
    mode: TimePropertyModeEnum;
    resolution?: TimePropertyResolutionEnum;
    values?: string[];
    interval: number[];
};
export type TimeRange = {
    end?: number;
    start: number;
};
/**
 * Active dimensions definition, where the value can't be null.
 */
export type DimensionsActive = {
    [x: string]: string;
};
import ngeoDatasourceDataSource from 'ngeo/datasource/DataSource';
import olFormatWFS from 'ol/format/WFS';
import ngeoFormatArcGISGeoJSON from 'ngeo/format/ArcGISGeoJSON';
import olFormatWMSGetFeatureInfo from 'ol/format/WMSGetFeatureInfo';
