@igo2/integration 19.0.2 → 20.0.0-next.1

package/index.d.ts

@@ -1,5 +1,1467 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, ModuleWithProviders } from '@angular/core';
+import { IgoMap, LayerListControlsOptions, Catalog, CatalogItem, CatalogItemState, StopsStore, StopsFeatureStore, RoutesFeatureStore, StepsFeatureStore, FeatureStore, FeatureWithDraw, DrawControl, VectorLayer, AnyLayer, ExportOptions, ProjectionsLimitationsOptions, Feature, LayerViewerOptions, Layer, FeatureWithMeasure, SearchResult, Research, SpatialFilterType, SpatialFilterItemType, SpatialFilterQueryType, SpatialFilterThematic, MeasureLengthUnit, EnvironmentOptions as EnvironmentOptions$4, IOfflineOptions, WfsWorkspace, FeatureWorkspace, CommonVectorStyleOptions, FeatureMotion } from '@igo2/geo';
+import * as _igo2_common_entity from '@igo2/common/entity';
+import { EntityStore, EntityTableComponent, EntityTableTemplate, EntityRecord, EntityState } from '@igo2/common/entity';
+import * as rxjs from 'rxjs';
+import { BehaviorSubject, Subject, Observable, ReplaySubject, Subscription } from 'rxjs';
+import { DetailedContext, EnvironmentOptions as EnvironmentOptions$3 } from '@igo2/context';
+import { WorkspaceStore, Workspace } from '@igo2/common/workspace';
+import { MatRadioChange } from '@angular/material/radio';
+import { Coordinate } from 'ol/coordinate';
+import { MediaService } from '@igo2/core/media';
+import { MatTabChangeEvent } from '@angular/material/tabs';
+import { FlexibleState } from '@igo2/common/flexible';
+import { Toolbox } from '@igo2/common/tool';
+import * as olstyle from 'ol/style';
+import { AuthService } from '@igo2/auth';
+import { ConfigService } from '@igo2/core/config';
+import * as i5 from '@igo2/common/form';
+import { Form } from '@igo2/common/form';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/material/button';
+import * as i4 from '@igo2/core/language';
+import { LanguageService } from '@igo2/core/language';
+import * as i6 from '@igo2/core/message';
+import { AuthEnvironmentOptions } from '@igo2/auth/environment';
+import { EnvironmentOptions as EnvironmentOptions$1 } from '@igo2/common/environment';
+import { EnvironmentOptions as EnvironmentOptions$2, BaseEnvironmentOptions } from '@igo2/core/environment';
+import { Action } from '@igo2/common/action';
+import { StorageService } from '@igo2/core/storage';
+import { Widget } from '@igo2/common/widget';
+
+declare class ContextEditorToolComponent {
+    private toolState;
+    submitSuccessed(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextEditorToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextEditorToolComponent, "igo-context-editor-tool", never, {}, {}, never, never, true, never>;
+}
+
+declare class ContextManagerToolComponent {
+    private toolState;
+    private mapState;
+    toolToOpenOnContextChange: string;
+    get map(): IgoMap;
+    editContext(): void;
+    managePermissions(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextManagerToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextManagerToolComponent, "igo-context-manager-tool", never, { "toolToOpenOnContextChange": { "alias": "toolToOpenOnContextChange"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ContextPermissionManagerToolComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextPermissionManagerToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextPermissionManagerToolComponent, "igo-context-permission-manager-tool", never, {}, {}, never, never, true, never>;
+}
+
+declare class ContextShareToolComponent {
+    private mapState;
+    private layerListToolState;
+    get map(): IgoMap;
+    get layerListControls(): LayerListControlsOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextShareToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextShareToolComponent, "igo-context-share-tool", never, {}, {}, never, never, true, never>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * @deprecated import the components/directive directly or INTEGRATION_CONTEXT_DIRECTIVES for the set
  */
-/// <amd-module name="@igo2/integration" />
-export * from './public_api';
+declare class IgoAppContextModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppContextModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppContextModule, never, [typeof ContextEditorToolComponent, typeof ContextManagerToolComponent, typeof ContextPermissionManagerToolComponent, typeof ContextShareToolComponent], [typeof ContextEditorToolComponent, typeof ContextManagerToolComponent, typeof ContextPermissionManagerToolComponent, typeof ContextShareToolComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppContextModule>;
+}
+
+interface ListExport {
+    id: string;
+    rank: string;
+    layerTitle: string;
+    layerGroup: string;
+    catalog: string;
+    provider: string;
+    url: string;
+    layerName: string;
+    context: string;
+    metadataAbstract: string;
+    metadataUrl: string;
+}
+
+/**
+ * Tool to browse the list of available catalogs.
+ */
+declare class CatalogLibraryToolComponent implements OnInit, OnDestroy {
+    private contextService;
+    private catalogService;
+    private catalogState;
+    private toolState;
+    private storageService;
+    private languageService;
+    private generatelist$$;
+    /**
+     * Store that contains the catalogs
+     * @internal
+     */
+    get store(): EntityStore<Catalog>;
+    /**
+     * Determine if the form to add a catalog is allowed
+     */
+    addCatalogAllowed: boolean;
+    /**
+     * Determine if the export button is shown
+     */
+    exportButton: boolean;
+    /**
+     * List of predefined catalogs
+     */
+    predefinedCatalogs: Catalog[];
+    set selectedCatalogId(id: any);
+    get currentTool(): string;
+    get lastTool(): string;
+    /**
+     * @internal
+     */
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * When the selected catalog changes, toggle the the CatalogBrowser tool.
+     * @internal
+     * @param event Select event
+     */
+    onCatalogSelectChange(event: {
+        selected: boolean;
+        catalog: Catalog;
+    }): void;
+    /**
+     * Get all the available catalogs from the CatalogService and
+     * load them into the store.
+     */
+    private loadCatalogs;
+    /**
+     * Get the item abstract for getCatalogList
+     */
+    private getMetadataAbstract;
+    /**
+     * Get the item url metadata for getCatalogList
+     */
+    private getMetadataUrl;
+    private layersInfoFromContexts;
+    private listExportFromCatalogs;
+    getCatalogList(): Promise<void>;
+    private formatLayer;
+    /**
+     * Match a list of layer info with an other list derived from contexts
+     * @param catalogOutputs The row list to be written into a file
+     * @param layerInfosFromDetailedContexts Layers info derived from the context
+     * @returns An altered list, with layer/context association
+     */
+    private matchLayersWithLayersFromContext;
+    /**
+     * Write a Excel file
+     * @param catalogOutputs The row list to be written into a excel file
+     */
+    exportExcel(catalogOutputs: ListExport[]): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogLibraryToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogLibraryToolComponent, "igo-catalog-library-tool", never, { "addCatalogAllowed": { "alias": "addCatalogAllowed"; "required": false; }; "exportButton": { "alias": "exportButton"; "required": false; }; "predefinedCatalogs": { "alias": "predefinedCatalogs"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the CatalogLibraryToolComponent directly
+ */
+declare class IgoAppCatalogLibraryToolModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppCatalogLibraryToolModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppCatalogLibraryToolModule, never, [typeof CatalogLibraryToolComponent], [typeof CatalogLibraryToolComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppCatalogLibraryToolModule>;
+}
+
+/**
+ * Tool to browse a catalog's groups and layers and display them to a map.
+ */
+declare class CatalogBrowserToolComponent implements OnInit, OnDestroy {
+    private catalogService;
+    private catalogState;
+    private mapState;
+    private authService;
+    catalog: Catalog;
+    /**
+     * Store that contains the catalog items
+     * @internal
+     */
+    store$: BehaviorSubject<EntityStore<CatalogItem, CatalogItemState>>;
+    /**
+     * Subscription to the selected catalog
+     */
+    private catalog$$;
+    /**
+     * Whether a group can be toggled when it's collapsed
+     */
+    toggleCollapsedGroup: boolean;
+    /**
+     * Map to add layers to
+     * @internal
+     */
+    get map(): IgoMap;
+    /**
+     * @internal
+     */
+    ngOnInit(): void;
+    /**
+     * @internal
+     */
+    ngOnDestroy(): void;
+    /**
+     * Get the selected catalog's items from the CatalogService and
+     * load them into the store.
+     * @param catalog Selected catalog
+     */
+    private loadCatalogItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogBrowserToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogBrowserToolComponent, "igo-catalog-browser-tool", never, { "toggleCollapsedGroup": { "alias": "toggleCollapsedGroup"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the CatalogBrowserToolComponent directly
+ */
+declare class IgoAppCatalogBrowserToolModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppCatalogBrowserToolModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppCatalogBrowserToolModule, never, [typeof CatalogBrowserToolComponent], [typeof CatalogBrowserToolComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppCatalogBrowserToolModule>;
+}
+
+/**
+ * @deprecated import the components directly
+ */
+declare class IgoAppCatalogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppCatalogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppCatalogModule, never, never, [typeof IgoAppCatalogLibraryToolModule, typeof IgoAppCatalogBrowserToolModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppCatalogModule>;
+}
+
+/**
+ * Service that holds the state of the context module
+ */
+declare class ContextState {
+    private contextService;
+    private toolService;
+    private toolState;
+    private languageService;
+    /**
+     * Observable of the active context
+     */
+    context$: BehaviorSubject<DetailedContext>;
+    constructor();
+    /**
+     * Set the active context
+     * @param context Detailed context
+     */
+    private setContext;
+    /**
+     * Update the tool state with the context's tools
+     * @param context Detailed context
+     */
+    private updateTools;
+    /**
+     * Set a new context and update the tool state
+     * @param context Detailed context
+     */
+    private onContextChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContextState>;
+}
+
+declare class DirectionsToolComponent implements OnInit {
+    private directionState;
+    private mapState;
+    private languageService;
+    private messageService;
+    private storageService;
+    contextState: ContextState;
+    private authService;
+    currentContextUri: string;
+    /**
+     * stops
+     * @internal
+     */
+    get stopsStore(): StopsStore;
+    get debounceTime(): number;
+    /**
+     * stops
+     * @internal
+     */
+    get stopsFeatureStore(): StopsFeatureStore;
+    /**
+     * routes
+     * @internal
+     */
+    get routesFeatureStore(): RoutesFeatureStore;
+    /**
+     * step store
+     * @internal
+     */
+    get stepFeatureStore(): StepsFeatureStore;
+    /**
+     * step store
+     * @internal
+     */
+    get zoomOnActiveRoute$(): Subject<void>;
+    get authenticated$(): BehaviorSubject<boolean>;
+    /**
+     * Map to measure on
+     * @internal
+     */
+    get map(): IgoMap;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DirectionsToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DirectionsToolComponent, "igo-directions-tool", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the DirectionsToolComponent directly
+ */
+declare class IgoAppDirectionsModule {
+    static forRoot(): ModuleWithProviders<IgoAppDirectionsModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppDirectionsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppDirectionsModule, never, [typeof DirectionsToolComponent], [typeof DirectionsToolComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppDirectionsModule>;
+}
+
+/**
+ * Tool to measure lengths and areas
+ */
+declare class DrawingToolComponent {
+    private drawState;
+    private mapState;
+    /**
+     * Map to measure on
+     * @internal
+     */
+    get stores(): FeatureStore<FeatureWithDraw>[];
+    /**
+     * Map to measure on
+     * @internal
+     */
+    get map(): IgoMap;
+    get layersID(): string[];
+    get drawControls(): [string, DrawControl][];
+    set drawControls(dc: [string, DrawControl][]);
+    get activeDrawingLayer(): VectorLayer;
+    set activeDrawingLayer(value: VectorLayer);
+    addLayersID(layerID: string): void;
+    addDrawControls(dc: [string, DrawControl][]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawingToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DrawingToolComponent, "igo-drawing-tool", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the DrawingToolComponent directly
+ */
+declare class IgoAppDrawingToolModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppDrawingToolModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppDrawingToolModule, never, [typeof DrawingToolComponent], [typeof DrawingToolComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppDrawingToolModule>;
+}
+
+/**
+ * @deprecated import the DrawingToolComponent directly
+ */
+declare class IgoAppDrawModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppDrawModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppDrawModule, never, never, [typeof IgoAppDrawingToolModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppDrawModule>;
+}
+
+declare class WorkspaceButtonComponent implements OnInit, OnDestroy {
+    private workspaceState;
+    hasWorkspace$: BehaviorSubject<boolean>;
+    private hasWorkspace$$;
+    private layer$;
+    set layer(value: AnyLayer);
+    get layer(): AnyLayer;
+    private _layer;
+    color: string;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    activateWorkspace(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkspaceButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WorkspaceButtonComponent, "igo-workspace-button", never, { "layer": { "alias": "layer"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the WorkspaceButtonComponent directly
+ */
+declare class IgoAppWorkspaceModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppWorkspaceModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppWorkspaceModule, never, [typeof WorkspaceButtonComponent], [typeof WorkspaceButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppWorkspaceModule>;
+}
+
+declare enum ImportExportType {
+    layer = "layer",
+    context = "context"
+}
+declare enum ImportExportMode {
+    import = "import",
+    export = "export"
+}
+/**
+ * Service that holds the state of the importExport module
+ */
+declare class ImportExportState {
+    readonly importExportType$: BehaviorSubject<ImportExportType>;
+    readonly selectedMode$: BehaviorSubject<ImportExportMode>;
+    readonly exportOptions$: BehaviorSubject<ExportOptions>;
+    setImportExportType(type: ImportExportType): void;
+    setMode(mode: ImportExportMode): void;
+    setsExportOptions(exportOptions: ExportOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImportExportState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImportExportState>;
+}
+
+declare class ImportExportToolComponent implements OnInit {
+    private mapState;
+    importExportState: ImportExportState;
+    private workspaceState;
+    contextState: ContextState;
+    projectionsLimitations: ProjectionsLimitationsOptions;
+    selectFirstProj: boolean;
+    /**
+     * Map to measure on
+     * @internal
+     */
+    get map(): IgoMap;
+    get workspaceStore(): WorkspaceStore;
+    importExportType: ImportExportType;
+    importExportShowBothType: boolean;
+    ngOnInit(): void;
+    private selectType;
+    private selectMode;
+    modeChanged(mode: ImportExportMode): void;
+    exportOptionsChange(exportOptions: ExportOptions): void;
+    importExportTypeChange(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImportExportToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImportExportToolComponent, "igo-import-export-tool", never, { "projectionsLimitations": { "alias": "projectionsLimitations"; "required": false; }; "selectFirstProj": { "alias": "selectFirstProj"; "required": false; }; "importExportType": { "alias": "importExportType"; "required": false; }; "importExportShowBothType": { "alias": "importExportShowBothType"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the ImportExportToolComponent directly
+ */
+declare class IgoAppImportExportModule {
+    static forRoot(): ModuleWithProviders<IgoAppImportExportModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppImportExportModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppImportExportModule, never, [typeof ImportExportToolComponent], [typeof ImportExportToolComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppImportExportModule>;
+}
+
+/**
+ * Service that holds the state of the map module
+ */
+declare class MapState {
+    private mapService;
+    private projectionService;
+    private storageService;
+    private configService;
+    get showAllLegendsValue(): boolean;
+    set showAllLegendsValue(value: boolean);
+    private _legendToolShowAll;
+    /**
+     * Active map
+     */
+    get map(): IgoMap;
+    private _map;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MapState>;
+}
+
+declare class AdvancedMapToolComponent {
+    mapState: MapState;
+    get tracking$(): rxjs.BehaviorSubject<boolean>;
+    get followPosition$(): rxjs.BehaviorSubject<boolean>;
+    toggleTracking(value: any): void;
+    toggleFollow(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdvancedMapToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AdvancedMapToolComponent, "igo-advanced-map-tool", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Service that holds the state of the direction module
+ */
+declare class MapProximityState {
+    private mapState;
+    private storageService;
+    private defaultProximityRadiusValue;
+    enabled$: BehaviorSubject<boolean>;
+    proximityRadiusValue$: BehaviorSubject<number>;
+    proximitylocationType$: BehaviorSubject<string>;
+    proximityFeatureStore: FeatureStore<Feature>;
+    private subs$$;
+    currentPositionCoordinate$: BehaviorSubject<Coordinate>;
+    get map(): IgoMap;
+    constructor();
+    subscribeProximityMonitor(): void;
+    /**
+     * Add a feature with proximity properties to the store
+     * @internal
+     */
+    private addFeatureToStore;
+    getQueryTitle(feature: Feature, layer: AnyLayer): string | undefined;
+    getLabelMatch(feature: Feature, labelMatch: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapProximityState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MapProximityState>;
+}
+
+declare class MapProximityToolComponent implements OnInit, OnDestroy {
+    private clipboard;
+    mapState: MapState;
+    mapProximityState: MapProximityState;
+    private languageService;
+    private messageService;
+    private subs$$;
+    table: EntityTableComponent;
+    get maxDistance(): number;
+    set maxDistance(value: number);
+    get map(): IgoMap;
+    userDefinedMapCenter: boolean;
+    userDefinedFollowPosition: boolean;
+    /**
+     * Table template
+     * @internal
+     */
+    tableTemplate: EntityTableTemplate;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onLocationTypeChange(e: MatRadioChange): void;
+    /**
+     * Copy the coordinates to a clipboard
+     */
+    copyTextToClipboard(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapProximityToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapProximityToolComponent, "igo-map-proximity-tool", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Tool to browse a map's layers or to choose a different map
+ */
+declare class MapToolComponent implements OnInit {
+    private mapState;
+    private toolState;
+    private importExportState;
+    private configService;
+    mediaService: MediaService;
+    private cdr;
+    isDesktop: boolean;
+    toggleLegendOnVisibilityChange: boolean;
+    expandLegendOfVisibleLayers: boolean;
+    updateLegendOnResolutionChange: boolean;
+    ogcButton: boolean;
+    timeButton: boolean;
+    layerListControls: LayerListControlsOptions;
+    queryBadge: boolean;
+    get map(): IgoMap;
+    get excludeBaseLayers(): boolean;
+    get layerFilterAndSortOptions(): any;
+    private _layerViewerOptions;
+    get layerViewerOptions(): LayerViewerOptions;
+    constructor();
+    ngOnInit(): void;
+    activateExport(layer: Layer): void;
+    private handleMedia;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapToolComponent, "igo-map-tool", never, { "toggleLegendOnVisibilityChange": { "alias": "toggleLegendOnVisibilityChange"; "required": false; }; "expandLegendOfVisibleLayers": { "alias": "expandLegendOfVisibleLayers"; "required": false; }; "updateLegendOnResolutionChange": { "alias": "updateLegendOnResolutionChange"; "required": false; }; "ogcButton": { "alias": "ogcButton"; "required": false; }; "timeButton": { "alias": "timeButton"; "required": false; }; "layerListControls": { "alias": "layerListControls"; "required": false; }; "queryBadge": { "alias": "queryBadge"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Service that holds the state of layer list tool values
+ */
+declare class LayerListToolState {
+    readonly keyword$: BehaviorSubject<string>;
+    readonly sortAlpha$: BehaviorSubject<boolean>;
+    readonly onlyVisible$: BehaviorSubject<boolean>;
+    readonly selectedTab$: BehaviorSubject<number>;
+    setKeyword(keyword: string): void;
+    setSortAlpha(sort: boolean): void;
+    setOnlyVisible(onlyVisible: boolean): void;
+    setSelectedTab(tab: number): void;
+    getLayerListControls(): LayerListControlsOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerListToolState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayerListToolState>;
+}
+
+/**
+ * Tool to browse a map's layers or to choose a different map
+ */
+declare class MapToolsComponent implements OnInit, OnDestroy {
+    layerListToolState: LayerListToolState;
+    private toolState;
+    mapState: MapState;
+    private searchSourceService;
+    private importExportState;
+    private configService;
+    mediaService: MediaService;
+    private cdr;
+    isDesktop: boolean;
+    layers$: BehaviorSubject<AnyLayer[]>;
+    showAllLegendsValue$: BehaviorSubject<boolean>;
+    private resolution$$;
+    private visibleOrInRangeLayers$$;
+    delayedShowEmptyMapContent: boolean;
+    allowShowAllLegends: boolean;
+    showAllLegendsValue: boolean;
+    toggleLegendOnVisibilityChange: boolean;
+    expandLegendOfVisibleLayers: boolean;
+    updateLegendOnResolutionChange: boolean;
+    selectedTabAtOpening: string;
+    ogcButton: boolean;
+    timeButton: boolean;
+    layerAdditionAllowed: boolean;
+    get layerListControls(): LayerListControlsOptions;
+    set layerListControls(value: LayerListControlsOptions);
+    private _layerListControls;
+    get map(): IgoMap;
+    queryBadge: boolean;
+    get visibleOrInRangeLayers$(): Observable<AnyLayer[]>;
+    get visibleLayers$(): Observable<AnyLayer[]>;
+    get excludeBaseLayers(): boolean;
+    get layerFilterAndSortOptions(): LayerListControlsOptions;
+    private _layerViewerOptions;
+    get layerViewerOptions(): LayerViewerOptions;
+    tabGroup: any;
+    get searchToolInToolbar(): boolean;
+    get catalogToolInToolbar(): boolean;
+    get contextToolInToolbar(): boolean;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onShowAllLegends(event: any): void;
+    private selectedTab;
+    tabChanged(tab: MatTabChangeEvent): void;
+    onLayerListChange(appliedFilters: LayerListControlsOptions): void;
+    showAllLegend(): boolean;
+    activateExport(layer: Layer): void;
+    activateTimeFilter(): void;
+    activateOgcFilter(): void;
+    searchEmit(): void;
+    catalogEmit(): void;
+    contextEmit(): void;
+    isTimeFilterButton(layer: any): boolean;
+    isOGCFilterButton(layer: any): boolean;
+    isExportButton(layer: Layer): boolean;
+    isStyleEditButton(layer: Layer): boolean;
+    private handleMedia;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapToolsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapToolsComponent, "igo-map-tools", never, { "allowShowAllLegends": { "alias": "allowShowAllLegends"; "required": false; }; "showAllLegendsValue": { "alias": "showAllLegendsValue"; "required": false; }; "toggleLegendOnVisibilityChange": { "alias": "toggleLegendOnVisibilityChange"; "required": false; }; "expandLegendOfVisibleLayers": { "alias": "expandLegendOfVisibleLayers"; "required": false; }; "updateLegendOnResolutionChange": { "alias": "updateLegendOnResolutionChange"; "required": false; }; "selectedTabAtOpening": { "alias": "selectedTabAtOpening"; "required": false; }; "ogcButton": { "alias": "ogcButton"; "required": false; }; "timeButton": { "alias": "timeButton"; "required": false; }; "layerAdditionAllowed": { "alias": "layerAdditionAllowed"; "required": false; }; "layerListControls": { "alias": "layerListControls"; "required": false; }; "queryBadge": { "alias": "queryBadge"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapDetailsToolComponent implements OnInit {
+    private mapState;
+    private toolState;
+    private searchSourceService;
+    private importExportState;
+    private configService;
+    mediaService: MediaService;
+    private cdr;
+    isDesktop: boolean;
+    delayedShowEmptyMapContent: boolean;
+    toggleLegendOnVisibilityChange: boolean;
+    expandLegendOfVisibleLayers: boolean;
+    updateLegendOnResolutionChange: boolean;
+    ogcButton: boolean;
+    timeButton: boolean;
+    layerListControls: LayerListControlsOptions;
+    queryBadge: boolean;
+    layerAdditionAllowed: boolean;
+    private _layerViewerOptions;
+    get layerViewerOptions(): LayerViewerOptions;
+    get map(): IgoMap;
+    get layers$(): Observable<AnyLayer[]>;
+    get excludeBaseLayers(): boolean;
+    get layerFilterAndSortOptions(): any;
+    get searchToolInToolbar(): boolean;
+    get catalogToolInToolbar(): boolean;
+    get contextToolInToolbar(): boolean;
+    constructor();
+    ngOnInit(): void;
+    searchEmit(): void;
+    catalogEmit(): void;
+    contextEmit(): void;
+    activateExport(layer: Layer): void;
+    private handleMedia;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapDetailsToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapDetailsToolComponent, "igo-map-details-tool", never, { "toggleLegendOnVisibilityChange": { "alias": "toggleLegendOnVisibilityChange"; "required": false; }; "expandLegendOfVisibleLayers": { "alias": "expandLegendOfVisibleLayers"; "required": false; }; "updateLegendOnResolutionChange": { "alias": "updateLegendOnResolutionChange"; "required": false; }; "ogcButton": { "alias": "ogcButton"; "required": false; }; "timeButton": { "alias": "timeButton"; "required": false; }; "layerListControls": { "alias": "layerListControls"; "required": false; }; "queryBadge": { "alias": "queryBadge"; "required": false; }; "layerAdditionAllowed": { "alias": "layerAdditionAllowed"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapLegendToolComponent implements OnInit, OnDestroy {
+    private mapState;
+    private toolState;
+    private searchSourceService;
+    private cdRef;
+    delayedShowEmptyMapContent: boolean;
+    layers$: BehaviorSubject<AnyLayer[]>;
+    showAllLegendsValue$: BehaviorSubject<boolean>;
+    change$: ReplaySubject<void>;
+    private resolution$$;
+    private visibleOrInRangeLayers$$;
+    updateLegendOnResolutionChange: boolean;
+    layerAdditionAllowed: boolean;
+    allowShowAllLegends: boolean;
+    showAllLegendsValue: boolean;
+    layerListControls: LayerListControlsOptions;
+    get map(): IgoMap;
+    get visibleOrInRangeLayers$(): Observable<AnyLayer[]>;
+    get visibleLayers$(): Observable<AnyLayer[]>;
+    get excludeBaseLayers(): boolean;
+    get searchToolInToolbar(): boolean;
+    get catalogToolInToolbar(): boolean;
+    get contextToolInToolbar(): boolean;
+    ngOnInit(): void;
+    onShowAllLegends(event: any): void;
+    showAllLegend(): boolean;
+    ngOnDestroy(): void;
+    searchEmit(): void;
+    catalogEmit(): void;
+    contextEmit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapLegendToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapLegendToolComponent, "igo-map-legend-tool", never, { "updateLegendOnResolutionChange": { "alias": "updateLegendOnResolutionChange"; "required": false; }; "layerAdditionAllowed": { "alias": "layerAdditionAllowed"; "required": false; }; "allowShowAllLegends": { "alias": "allowShowAllLegends"; "required": false; }; "showAllLegendsValue": { "alias": "showAllLegendsValue"; "required": false; }; "layerListControls": { "alias": "layerListControls"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the ImportExportToolComponent directly or INTEGRATION_MAP_DIRECTIVES for the set
+ */
+declare class IgoAppMapModule {
+    static forRoot(): ModuleWithProviders<IgoAppMapModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppMapModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppMapModule, never, [typeof AdvancedMapToolComponent, typeof MapProximityToolComponent, typeof MapToolComponent, typeof MapToolsComponent, typeof MapDetailsToolComponent, typeof MapLegendToolComponent], [typeof AdvancedMapToolComponent, typeof MapProximityToolComponent, typeof MapToolComponent, typeof MapToolsComponent, typeof MapDetailsToolComponent, typeof MapLegendToolComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppMapModule>;
+}
+
+/**
+ * Tool to measure lengths and areas
+ */
+declare class MeasurerToolComponent {
+    private measureState;
+    private mapState;
+    /**
+     * Map to measure on
+     * @internal
+     */
+    get store(): FeatureStore<FeatureWithMeasure>;
+    /**
+     * Map to measure on
+     * @internal
+     */
+    get map(): IgoMap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MeasurerToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MeasurerToolComponent, "igo-measurer-tool", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the MeasurerToolComponent directly
+ */
+declare class IgoAppMeasurerToolModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppMeasurerToolModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppMeasurerToolModule, never, [typeof MeasurerToolComponent], [typeof MeasurerToolComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppMeasurerToolModule>;
+}
+
+/**
+ * @deprecated import the MeasurerToolComponent directly
+ */
+declare class IgoAppMeasureModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppMeasureModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppMeasureModule, never, never, [typeof IgoAppMeasurerToolModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppMeasureModule>;
+}
+
+declare class PrintToolComponent {
+    private mapState;
+    get map(): IgoMap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrintToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PrintToolComponent, "igo-print-tool", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the PrintToolComponent directly
+ */
+declare class IgoAppPrintModule {
+    static forRoot(): ModuleWithProviders<IgoAppPrintModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppPrintModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppPrintModule, never, [typeof PrintToolComponent], [typeof PrintToolComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppPrintModule>;
+}
+
+declare class SearchBarBindingDirective implements OnInit, OnDestroy {
+    private component;
+    private searchState;
+    get searchTerm(): string;
+    get searchType(): string;
+    private searchTerm$$;
+    private searchType$$;
+    private searchDisabled$$;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onSearchTermChange(searchTerm?: string): void;
+    onSearchTypeChange(searchType?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchBarBindingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SearchBarBindingDirective, "[igoSearchBarBinding]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Service that holds the state of the search module
+ */
+declare class ToolState {
+    private toolService;
+    private importExportState;
+    get toolbox(): Toolbox;
+    openSidenav$: BehaviorSubject<boolean>;
+    toolToActivateFromOptions(toolToActivate: {
+        tool: string;
+        options: ExportOptions;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToolState>;
+}
+
+/**
+ * Tool to browse the search results
+ */
+declare class SearchResultsToolComponent implements OnInit, OnDestroy {
+    private mapState;
+    private searchState;
+    private elRef;
+    toolState: ToolState;
+    private directionState;
+    /**
+     * to show hide results icons
+     */
+    showIcons: boolean;
+    /**
+     * Determine the top panel default state
+     */
+    topPanelStateDefault: string;
+    private hasFeatureEmphasisOnSelection;
+    saveSearchResultInLayer: boolean;
+    private showResultsGeometries$$;
+    private getRoute$$;
+    private shownResultsGeometries;
+    private shownResultsEmphasisGeometries;
+    private focusedResult$;
+    isSelectedResultOutOfView$: BehaviorSubject<boolean>;
+    private isSelectedResultOutOfView$$;
+    private abstractFocusedResult;
+    private abstractSelectedResult;
+    debouncedEmpty$: BehaviorSubject<boolean>;
+    private debouncedEmpty$$;
+    /**
+     * Store holding the search results
+     * @internal
+     */
+    get store(): EntityStore<SearchResult>;
+    /**
+     * Map to display the results on
+     * @internal
+     */
+    get map(): IgoMap;
+    get featureTitle(): string;
+    get feature$(): Observable<Feature>;
+    feature: Feature;
+    term: string;
+    private searchTerm$$;
+    settingsChange$: BehaviorSubject<boolean>;
+    topPanelState$: BehaviorSubject<FlexibleState>;
+    private topPanelState$$;
+    set topPanelState(value: FlexibleState);
+    get topPanelState(): FlexibleState;
+    get termSplitter(): string;
+    private format;
+    get stores(): FeatureStore<Feature>[];
+    constructor();
+    ngOnInit(): void;
+    private monitorResultOutOfView;
+    private buildResultEmphasis;
+    private clearFeatureEmphasis;
+    ngOnDestroy(): void;
+    /**
+     * Try to add a feature to the map when it's being focused
+     * @internal
+     * @param result A search result that could be a feature
+     */
+    onResultFocus(result: SearchResult): void;
+    onResultUnfocus(result: SearchResult): void;
+    /**
+     * Try to add a feature to the map when it's being selected
+     * @internal
+     * @param result A search result that could be a feature or some layer options
+     */
+    onResultSelect(result: SearchResult): void;
+    onSearch(event: {
+        research: Research;
+        results: SearchResult[];
+    }): void;
+    computeElementRef(): any[];
+    adjustTopPanel(elemSource: any, elem: any): void;
+    toggleTopPanel(event?: MouseEvent): void;
+    zoomToFeatureExtent(): void;
+    /**
+     * Try to add a feature to the map overlay
+     * @param result A search result that could be a feature
+     * @param motion A FeatureMotion to trigger when adding the searchresult to the map search overlay
+     */
+    private tryAddFeatureToMap;
+    isScrolledIntoView(elemSource: any, elem: any): boolean;
+    getRoute(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchResultsToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SearchResultsToolComponent, "igo-search-results-tool", never, { "showIcons": { "alias": "showIcons"; "required": false; }; "topPanelStateDefault": { "alias": "topPanelStateDefault"; "required": false; }; "topPanelState": { "alias": "topPanelState"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the components/directive directly or INTEGRATION_SEARCH_DIRECTIVES for the set
+ */
+declare class IgoAppSearchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppSearchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppSearchModule, never, [typeof SearchBarBindingDirective, typeof SearchResultsToolComponent], [typeof SearchBarBindingDirective, typeof SearchResultsToolComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppSearchModule>;
+}
+
+declare class OgcFilterToolComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OgcFilterToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OgcFilterToolComponent, "igo-ogc-filter-tool", never, {}, {}, never, never, true, never>;
+}
+
+declare class ActiveOgcFilterToolComponent {
+    mapState: MapState;
+    get map(): IgoMap;
+    get layer(): Layer;
+    animate: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActiveOgcFilterToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActiveOgcFilterToolComponent, "igo-active-ogc-filter-tool", never, {}, {}, never, never, true, never>;
+}
+
+declare class TimeFilterToolComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeFilterToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimeFilterToolComponent, "igo-time-filter-tool", never, {}, {}, never, never, true, never>;
+}
+
+declare class ActiveTimeFilterToolComponent {
+    mapState: MapState;
+    get map(): IgoMap;
+    get layer(): Layer;
+    animate: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActiveTimeFilterToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActiveTimeFilterToolComponent, "igo-active-time-filter-tool", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Tool to apply spatial filter
+ */
+declare class SpatialFilterToolComponent implements OnInit, OnDestroy {
+    private matIconRegistry;
+    private spatialFilterService;
+    private layerService;
+    private mapState;
+    private messageService;
+    private languageService;
+    private importExportState;
+    private toolState;
+    private workspaceState;
+    private cdRef;
+    get map(): IgoMap;
+    type: SpatialFilterType;
+    itemType: SpatialFilterItemType;
+    freehandDrawIsActive: boolean;
+    layers: AnyLayer[];
+    activeLayers: AnyLayer[];
+    queryType: SpatialFilterQueryType;
+    thematics: SpatialFilterThematic[];
+    zone: Feature;
+    zoneWithBuffer: Feature;
+    buffer: number;
+    iterator: number;
+    selectedFeature$: BehaviorSubject<Feature<Record<string, any>>>;
+    private format;
+    store: EntityStore<Feature>;
+    spatialListStore: EntityStore<Feature>;
+    loading: boolean;
+    thematicLength: number;
+    measureUnit: MeasureLengthUnit;
+    private unsubscribe$;
+    defaultStyle: olstyle.Style | ((feature: any, resolution: any) => olstyle.Style);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getOutputType(event: SpatialFilterType): void;
+    getOutputQueryType(event: SpatialFilterQueryType): void;
+    activateExportTool(): void;
+    activateWorkspace(record?: any): void;
+    private selectWorkspaceEntity;
+    private loadFilterList;
+    getOutputToggleSearch(): void;
+    getOutputClearSearch(): void;
+    clearMap(): void;
+    private loadThematics;
+    onZoneChange(feature: Feature, buffer?: boolean): void;
+    /**
+     * Try to add zone feature to the map overlay
+     */
+    tryAddFeaturesToMap(features: Feature[], buffer?: boolean): void;
+    /**
+     * Try to add point features to the map
+     * Necessary to create clusters
+     */
+    private tryAddPointToMap;
+    private createSvgIcon;
+    /**
+     * Try to add line or polygon features to the map
+     */
+    private tryAddLayerToMap;
+    zoomToFeatureExtent(feature: any): void;
+    pushLayer(layer: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpatialFilterToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpatialFilterToolComponent, "igo-spatial-filter-tool", never, { "type": { "alias": "type"; "required": false; }; "itemType": { "alias": "itemType"; "required": false; }; "freehandDrawIsActive": { "alias": "freehandDrawIsActive"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the components directly or INTEGRATION_FILTER_DIRECTIVES for the set
+ */
+declare class IgoAppFilterModule {
+    static forRoot(): ModuleWithProviders<IgoAppFilterModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppFilterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppFilterModule, never, [typeof OgcFilterToolComponent, typeof ActiveOgcFilterToolComponent, typeof TimeFilterToolComponent, typeof ActiveTimeFilterToolComponent, typeof SpatialFilterToolComponent], [typeof OgcFilterToolComponent, typeof ActiveOgcFilterToolComponent, typeof TimeFilterToolComponent, typeof ActiveTimeFilterToolComponent, typeof SpatialFilterToolComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppFilterModule>;
+}
+
+declare class AboutToolComponent implements OnInit {
+    configService: ConfigService<any>;
+    auth: AuthService;
+    private http;
+    private cdRef;
+    private languageService;
+    private configOptions;
+    get headerHtml(): string;
+    set headerHtml(value: string);
+    get html(): string;
+    set html(value: string);
+    private _discoverTitleInLocale;
+    discoverTitleInLocale$: Observable<string>;
+    get discoverTitleInLocale(): string;
+    set discoverTitleInLocale(value: string);
+    trainingGuideURLs: any;
+    effectiveVersion: string;
+    private _html;
+    private _headerHtml;
+    private baseUrlProfil;
+    private baseUrlGuide;
+    loading: boolean;
+    constructor();
+    ngOnInit(): void;
+    openGuide(guide?: any): void;
+    formatFileName(name: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AboutToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AboutToolComponent, "igo-about-tool", never, { "headerHtml": { "alias": "headerHtml"; "required": false; }; "html": { "alias": "html"; "required": false; }; "discoverTitleInLocale": { "alias": "discoverTitleInLocale"; "required": false; }; "trainingGuideURLs": { "alias": "trainingGuideURLs"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the AboutToolComponent directly
+ */
+declare class IgoAppAboutModule {
+    static forRoot(): ModuleWithProviders<IgoAppAboutModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppAboutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppAboutModule, never, [typeof AboutToolComponent], [typeof AboutToolComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppAboutModule>;
+}
+
+interface DataIssueReporterData {
+    geometry: object;
+    layer: string;
+    desc: string;
+    email: string;
+}
+declare class DataIssueReporterToolComponent implements OnInit, OnDestroy {
+    private mapState;
+    private formService;
+    private languageService;
+    private messageService;
+    private httpClient;
+    /**
+     * Url to report the data issue. Use the Post protocol to send the form.
+     */
+    url: string;
+    /**
+     * Map to link to the form
+     * @internal
+     */
+    get map(): IgoMap;
+    form$: BehaviorSubject<Form>;
+    data$: BehaviorSubject<Record<string, any>>;
+    submitDisabled: boolean;
+    private valueChanges$$;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    clearForm(): void;
+    onSubmit(data: DataIssueReporterData): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataIssueReporterToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataIssueReporterToolComponent, "igo-issue-reporter-tool", never, { "url": { "alias": "url"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class IgoAppGeometryFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppGeometryFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppGeometryFormModule, [typeof DataIssueReporterToolComponent], [typeof i2.CommonModule, typeof i3.MatButtonModule, typeof i4.IgoLanguageModule, typeof i5.IgoFormModule, typeof i6.IgoMessageModule], [typeof DataIssueReporterToolComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppGeometryFormModule>;
+}
+
+/**
+ * @deprecated import the components directly
+ */
+declare class IgoIntegrationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoIntegrationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoIntegrationModule, never, never, [typeof IgoAppContextModule, typeof IgoAppCatalogModule, typeof IgoAppDirectionsModule, typeof IgoAppDrawModule, typeof IgoAppWorkspaceModule, typeof IgoAppImportExportModule, typeof IgoAppMapModule, typeof IgoAppMeasureModule, typeof IgoAppPrintModule, typeof IgoAppSearchModule, typeof IgoAppFilterModule, typeof IgoAppAboutModule, typeof IgoAppGeometryFormModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoIntegrationModule>;
+}
+
+/**
+ * Service that holds the state of the search module
+ */
+declare class AnalyticsListenerService {
+    private analyticsService;
+    private authService;
+    private contextState;
+    private toolState;
+    private mapState;
+    listen(): void;
+    listenUser(): void;
+    listenContext(): void;
+    listenTool(): void;
+    /**
+     * Listener for adding layers to the map
+     */
+    listenLayer(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsListenerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnalyticsListenerService>;
+}
+
+declare const INTEGRATION_CONTEXT_DIRECTIVES: readonly [typeof ContextEditorToolComponent, typeof ContextManagerToolComponent, typeof ContextPermissionManagerToolComponent, typeof ContextShareToolComponent];
+
+/**
+ * Service that holds the state of the catalog module
+ */
+declare class CatalogState {
+    /**
+     * Store that contains all the catalogs
+     */
+    get catalogStore(): EntityStore<Catalog>;
+    private _catalogStore;
+    /**
+     * Catalog -> Catalog items store mapping
+     */
+    private catalogItemsStores;
+    constructor();
+    /**
+     * Get a catalog's items store
+     * @param catalog Catalog
+     * @returns Store that contains the catalog items
+     */
+    getCatalogItemsStore(catalog: Catalog): EntityStore<CatalogItem>;
+    /**
+     * Bind a catalog items store to a catalog
+     * @param catalog Catalog
+     * @param store Catalog items store
+     */
+    setCatalogItemsStore(catalog: Catalog, store: EntityStore<CatalogItem>): void;
+    /**
+     * Clear all catalog items stores
+     */
+    clearCatalogItemsStores(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogState>;
+}
+
+/**
+ * Service that holds the state of the direction module
+ */
+declare class DirectionState {
+    private mapState;
+    zoomToActiveRoute$: Subject<void>;
+    /**
+     * Store that holds the stop
+     */
+    stopsStore: StopsStore;
+    /**
+     * Store that holds the driving stops as feature
+     */
+    stopsFeatureStore: StopsFeatureStore;
+    /**
+     * Store that holds the driving route as feature
+     */
+    routesFeatureStore: RoutesFeatureStore;
+    stepFeatureStore: StepsFeatureStore;
+    debounceTime: number;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DirectionState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DirectionState>;
+}
+
+/**
+ * Service that holds the state of the measure module
+ */
+declare class DrawState {
+    private mapState;
+    stores: FeatureStore<FeatureWithDraw>[];
+    layersID: string[];
+    drawControls: [string, DrawControl][];
+    activeDrawingLayer: VectorLayer;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DrawState>;
+}
+
+type AllEnvironmentOptions = AuthEnvironmentOptions & EnvironmentOptions$1 & EnvironmentOptions$2 & EnvironmentOptions$3 & EnvironmentOptions$4 & IntegrationEnvironmentOptions;
+interface EnvironmentOptions extends BaseEnvironmentOptions {
+    igo: AllEnvironmentOptions;
+}
+interface IntegrationEnvironmentOptions {
+    app?: AppOptions;
+    hasFeatureEmphasisOnSelection?: boolean;
+    saveSearchResultInLayer?: boolean;
+}
+interface AppOptions {
+    forceCoordsNA: boolean;
+    install: {
+        enabled?: boolean;
+        promote?: boolean;
+        manifestPath?: string;
+    };
+    pwa?: {
+        enabled?: boolean;
+        path?: string;
+    };
+    offline?: IOfflineOptions;
+}
+
+declare class WfsActionsService implements OnDestroy {
+    private storageState;
+    languageService: LanguageService;
+    private mediaService;
+    private toolState;
+    private interactiveSelectionFormWidget;
+    private ogcFilterWidget;
+    maximize$: BehaviorSubject<boolean>;
+    selectOnlyCheckCondition$: BehaviorSubject<boolean>;
+    zoomAuto$: BehaviorSubject<boolean>;
+    private storageChange$$;
+    get storageService(): StorageService;
+    get zoomAuto(): boolean;
+    constructor();
+    ngOnDestroy(): void;
+    loadActions(workspace: WfsWorkspace, rowsInMapExtentCheckCondition$: BehaviorSubject<boolean>, selectOnlyCheckCondition$: BehaviorSubject<boolean>): void;
+    buildActions(workspace: WfsWorkspace, rowsInMapExtentCheckCondition$: BehaviorSubject<boolean>, selectOnlyCheckCondition$: BehaviorSubject<boolean>): Action[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<WfsActionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WfsActionsService>;
+}
+
+declare class FeatureActionsService implements OnDestroy {
+    private storageState;
+    languageService: LanguageService;
+    private toolState;
+    private mediaService;
+    private interactiveSelectionFormWidget;
+    maximize$: BehaviorSubject<boolean>;
+    zoomAuto$: BehaviorSubject<boolean>;
+    private storageChange$$;
+    get storageService(): StorageService;
+    get zoomAuto(): boolean;
+    constructor();
+    ngOnDestroy(): void;
+    loadActions(workspace: FeatureWorkspace, rowsInMapExtentCheckCondition$: BehaviorSubject<boolean>, selectOnlyCheckCondition$: BehaviorSubject<boolean>): void;
+    buildActions(workspace: FeatureWorkspace, rowsInMapExtentCheckCondition$: BehaviorSubject<boolean>, selectOnlyCheckCondition$: BehaviorSubject<boolean>): Action[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureActionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FeatureActionsService>;
+}
+
+/**
+ * Service that holds the state of the workspace module
+ */
+declare class WorkspaceState implements OnDestroy {
+    private featureActionsService;
+    private wfsActionsService;
+    private editionActionsService;
+    private storageService;
+    workspacePanelExpanded: boolean;
+    readonly workspaceEnabled$: BehaviorSubject<boolean>;
+    readonly rowsInMapExtentCheckCondition$: BehaviorSubject<boolean>;
+    readonly selectOnlyCheckCondition$: BehaviorSubject<boolean>;
+    readonly workspaceMaximize$: BehaviorSubject<boolean>;
+    private actionMaximize$$;
+    private rowsInMapExtentCheckCondition$$;
+    private selectOnlyCheckCondition$$;
+    /** Subscription to the active workspace */
+    private activeWorkspace$$;
+    /** Subscription to the active workspace widget */
+    private activeWorkspaceWidget$$;
+    /** Active widget observable. Only one may be active for all available workspaces */
+    readonly activeWorkspaceWidget$: BehaviorSubject<Widget>;
+    /**
+     * Observable of the active workspace
+     */
+    workspace$: BehaviorSubject<Workspace<object>>;
+    /**
+     * Store that holds all the available workspaces
+     */
+    get store(): WorkspaceStore;
+    private _store;
+    get workspaceSelection(): EntityRecord<object, EntityState>[];
+    get workspaceSelection$(): Observable<EntityRecord<object, EntityState>[]>;
+    constructor();
+    /**
+     * Initialize the workspace store. Each time a workspace is activated,
+     * subscribe to it's active widget. Tracking the active widget is useful
+     * to make sure only one widget is active at a time.
+     */
+    private initWorkspaces;
+    private setWorkspaceIsMaximized;
+    setActiveWorkspaceById(id: string): void;
+    setActiveWorkspaceByTitle(title: string): void;
+    /**
+     * Teardown all the workspaces
+     * @internal
+     */
+    ngOnDestroy(): void;
+    /**
+     * Teardown the workspace store and any subscribers
+     */
+    private teardownWorkspaces;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkspaceState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WorkspaceState>;
+}
+
+declare const INTEGRATION_FILTER_DIRECTIVES: (typeof OgcFilterToolComponent)[];
+
+declare const INTEGRATION_MAP_DIRECTIVES: readonly [typeof AdvancedMapToolComponent, typeof MapProximityToolComponent, typeof MapToolComponent, typeof MapToolsComponent, typeof MapDetailsToolComponent, typeof MapLegendToolComponent];
+
+/**
+ * Service that holds the state of the measure module
+ */
+declare class MeasureState {
+    private mapState;
+    /**
+     * Store that holds the measures
+     */
+    store: FeatureStore<FeatureWithMeasure>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MeasureState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MeasureState>;
+}
+
+/**
+ * Service that holds the state of the query module
+ */
+declare class QueryState {
+    private configService;
+    private propertyTypeDetectorService;
+    private capabilitiesService;
+    private mapState;
+    /**
+     * Store that holds the query results
+     */
+    store: EntityStore<SearchResult<Record<string, any>>, _igo2_common_entity.EntityState>;
+    queryOverlayStyle: CommonVectorStyleOptions;
+    queryOverlayStyleSelection: CommonVectorStyleOptions;
+    queryOverlayStyleFocus: CommonVectorStyleOptions;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueryState>;
+}
+
+/**
+ * Define the FeatureMotion to apply when adding the SearchResult to the map as an overlay.
+ */
+interface SearchFeatureMotion {
+    selected?: FeatureMotion;
+    focus?: FeatureMotion;
+}
+/**
+ * Service that holds the state of the search module
+ */
+declare class SearchState {
+    private searchSourceService;
+    private storageService;
+    private workspaceState;
+    private configService;
+    private mapState;
+    searchLayerStores: FeatureStore<Feature>[];
+    searchOverlayStyle: CommonVectorStyleOptions;
+    searchOverlayStyleSelection: CommonVectorStyleOptions;
+    searchOverlayStyleFocus: CommonVectorStyleOptions;
+    focusedOrResolution$$: Subscription;
+    selectedOrResolution$$: Subscription;
+    /**
+     * Default feature motion are:
+     * on selection = FeatureMotion.Default and
+     * on focus = FeatureMotion.None
+     */
+    featureMotion: SearchFeatureMotion;
+    readonly searchTermSplitter$: BehaviorSubject<string>;
+    readonly searchTerm$: BehaviorSubject<string>;
+    readonly searchType$: BehaviorSubject<string>;
+    readonly searchDisabled$: BehaviorSubject<boolean>;
+    readonly searchResultsGeometryEnabled$: BehaviorSubject<boolean>;
+    readonly searchSettingsChange$: BehaviorSubject<boolean>;
+    readonly selectedResult$: BehaviorSubject<SearchResult<Record<string, any>>>;
+    /**
+     * Store that holds the search results
+     */
+    readonly store: EntityStore<SearchResult<Record<string, any>>, _igo2_common_entity.EntityState>;
+    /**
+     * Search types currently enabled in the search source service
+     */
+    get searchTypes(): string[];
+    constructor();
+    private monitorLayerDeletion;
+    private createCustomFilterTermStrategy;
+    /**
+     * Activate custom strategy
+     *
+     */
+    activateCustomFilterTermStrategy(): void;
+    /**
+     * Deactivate custom strategy
+     *
+     */
+    deactivateCustomFilterTermStrategy(): void;
+    enableSearch(): void;
+    disableSearch(): void;
+    setSearchTerm(searchTerm: string): void;
+    setSearchType(searchType: string): void;
+    setSearchSettingsChange(): void;
+    setSelectedResult(result: SearchResult): void;
+    setSearchResultsGeometryStatus(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchState>;
+}
+
+/**
+ * @deprecated import the SearchResultsToolComponent directly
+ */
+declare class IgoAppSearchResultsToolModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppSearchResultsToolModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppSearchResultsToolModule, never, [typeof SearchResultsToolComponent], [typeof SearchResultsToolComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppSearchResultsToolModule>;
+}
+
+/**
+ * @deprecated import the SearchBarBindingDirective directly
+ */
+declare class IgoAppSearchBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoAppSearchBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoAppSearchBarModule, never, [typeof SearchBarBindingDirective], [typeof SearchBarBindingDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoAppSearchBarModule>;
+}
+
+/**
+ * Service that holds the state of storage service
+ */
+declare class StorageState {
+    private igoStorageService;
+    get storageService(): StorageService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageState>;
+}
+
+export { AboutToolComponent, ActiveOgcFilterToolComponent, ActiveTimeFilterToolComponent, AdvancedMapToolComponent, AnalyticsListenerService, CatalogBrowserToolComponent, CatalogLibraryToolComponent, CatalogState, ContextEditorToolComponent, ContextManagerToolComponent, ContextPermissionManagerToolComponent, ContextShareToolComponent, ContextState, DataIssueReporterToolComponent, DirectionState, DirectionsToolComponent, DrawState, DrawingToolComponent, FeatureActionsService, INTEGRATION_CONTEXT_DIRECTIVES, INTEGRATION_FILTER_DIRECTIVES, INTEGRATION_MAP_DIRECTIVES, IgoAppAboutModule, IgoAppCatalogBrowserToolModule, IgoAppCatalogLibraryToolModule, IgoAppCatalogModule, IgoAppContextModule, IgoAppDirectionsModule, IgoAppDrawModule, IgoAppDrawingToolModule, IgoAppFilterModule, IgoAppGeometryFormModule, IgoAppImportExportModule, IgoAppMapModule, IgoAppMeasureModule, IgoAppMeasurerToolModule, IgoAppPrintModule, IgoAppSearchBarModule, IgoAppSearchModule, IgoAppSearchResultsToolModule, IgoAppWorkspaceModule, IgoIntegrationModule, ImportExportMode, ImportExportState, ImportExportToolComponent, ImportExportType, MapDetailsToolComponent, MapLegendToolComponent, MapProximityState, MapProximityToolComponent, MapState, MapToolComponent, MapToolsComponent, MeasureState, MeasurerToolComponent, OgcFilterToolComponent, PrintToolComponent, QueryState, SearchBarBindingDirective, SearchResultsToolComponent, SearchState, SpatialFilterToolComponent, StorageState, TimeFilterToolComponent, ToolState, WfsActionsService, WorkspaceButtonComponent, WorkspaceState };
+export type { AllEnvironmentOptions, AppOptions, EnvironmentOptions, SearchFeatureMotion };