@igo2/geo 18.0.0-next.1 → 18.0.0-next.11

package/lib/layer/layer-item/layer-item.component.d.ts

@@ -1,62 +1,43 @@
-import { ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy, OnInit, Renderer2 } from '@angular/core';
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { MatCheckboxChange } from '@angular/material/checkbox';
 import { ConnectionState, NetworkService } from '@igo2/core/network';
 import { BehaviorSubject } from 'rxjs';
-import { Layer } from '../shared/layers/layer';
+import { LayerViewerOptions } from '../layer-viewer/layer-viewer.interface';
+import type { Layer } from '../shared/layers/layer';
 import * as i0 from "@angular/core";
 export declare class LayerItemComponent implements OnInit, OnDestroy {
     private networkService;
-    private renderer;
-    private elRef;
-    private cdRef;
-    focusedCls: string;
-    get activeLayer(): any;
-    set activeLayer(value: any);
-    private _activeLayer;
-    layerTool$: BehaviorSubject<boolean>;
     showLegend$: BehaviorSubject<boolean>;
     inResolutionRange$: BehaviorSubject<boolean>;
     queryBadgeHidden$: BehaviorSubject<boolean>;
     tooltipText: string;
     state: ConnectionState;
-    get selectAll(): boolean;
-    set selectAll(value: boolean);
-    private _selectAll;
-    layerCheck: any;
     private resolution$$;
     private network$$;
-    private layers$$;
-    layers$: BehaviorSubject<Layer>;
-    get layer(): any;
-    set layer(value: any);
-    private _layer;
-    toggleLegendOnVisibilityChange: boolean;
-    expandLegendIfVisible: boolean;
-    updateLegendOnResolutionChange: boolean;
-    orderable: boolean;
-    lowerDisabled: boolean;
-    raiseDisabled: boolean;
-    queryBadge: boolean;
-    selectionMode: any;
-    changeDetection: any;
+    layer: Layer;
+    /** Pass the visibility to trigger change detection */
+    visible: boolean;
+    selected: boolean;
+    selectionDisabled: boolean;
+    viewerOptions: LayerViewerOptions;
+    action: EventEmitter<Layer>;
+    selectChange: EventEmitter<boolean>;
+    visibilityChange: EventEmitter<Event>;
+    isDisabled: boolean;
     get opacity(): number;
     set opacity(opacity: number);
-    get eyeTooltip(): "igo.geo.layer.notInResolution" | "igo.geo.layer.hideLayer" | "igo.geo.layer.showLayer";
-    action: EventEmitter<Layer>;
-    checkbox: EventEmitter<{
-        layer: Layer;
-        check: boolean;
-    }>;
-    constructor(networkService: NetworkService, renderer: Renderer2, elRef: ElementRef, cdRef: ChangeDetectorRef);
+    get visibilityTooltip(): "igo.geo.layer.notInResolution" | "igo.geo.layer.group.hideChildren" | "igo.geo.layer.hideLayer" | "igo.geo.layer.showLayer";
+    constructor(networkService: NetworkService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     toggleLegend(collapsed: boolean): void;
     toggleLegendOnClick(): void;
-    toggleVisibility(event: Event): void;
+    handleVisibilityChange(event: Event): void;
     computeTooltip(): string;
     private onResolutionChange;
     private updateQueryBadge;
     toggleLayerTool(): void;
-    check(): void;
+    handleSelect(event: MatCheckboxChange): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<LayerItemComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LayerItemComponent, "igo-layer-item", never, { "activeLayer": { "alias": "activeLayer"; "required": false; }; "selectAll": { "alias": "selectAll"; "required": false; }; "layerCheck": { "alias": "layerCheck"; "required": false; }; "layer": { "alias": "layer"; "required": false; }; "toggleLegendOnVisibilityChange": { "alias": "toggleLegendOnVisibilityChange"; "required": false; }; "expandLegendIfVisible": { "alias": "expandLegendIfVisible"; "required": false; }; "updateLegendOnResolutionChange": { "alias": "updateLegendOnResolutionChange"; "required": false; }; "orderable": { "alias": "orderable"; "required": false; }; "lowerDisabled": { "alias": "lowerDisabled"; "required": false; }; "raiseDisabled": { "alias": "raiseDisabled"; "required": false; }; "queryBadge": { "alias": "queryBadge"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "changeDetection": { "alias": "changeDetection"; "required": false; }; }, { "action": "action"; "checkbox": "checkbox"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerItemComponent, "igo-layer-item", never, { "layer": { "alias": "layer"; "required": true; }; "visible": { "alias": "visible"; "required": true; }; "selected": { "alias": "selected"; "required": false; }; "selectionDisabled": { "alias": "selectionDisabled"; "required": false; }; "viewerOptions": { "alias": "viewerOptions"; "required": false; }; }, { "action": "action"; "selectChange": "selectChange"; "visibilityChange": "visibilityChange"; }, never, ["*"], true, never>;
 }

package/lib/layer/layer-legend/layer-legend.component.d.ts

@@ -5,8 +5,8 @@ import { ConfigService } from '@igo2/core/config';
 import { LanguageService } from '@igo2/core/language';
 import { BehaviorSubject, Observable } from 'rxjs';
 import { CapabilitiesService } from '../../datasource/shared/capabilities.service';
-import { Legend } from '../../datasource/shared/datasources/datasource.interface';
-import { Layer } from '../shared/layers/layer';
+import { Legend } from '../../datasource/shared/datasources';
+import { Layer } from '../shared/layers';
 import * as i0 from "@angular/core";
 export declare class LayerLegendComponent implements OnInit, OnDestroy {
     private capabilitiesService;
@@ -47,9 +47,6 @@ export declare class LayerLegendComponent implements OnInit, OnDestroy {
      * List of size of images displayed
      */
     imagesHeight: Record<string, number>;
-    /**
-     * Layer
-     */
     layer: Layer;
     /**
      * if getLegendGraphic is authorized

package/lib/layer/layer-legend-list/layer-legend-list.component.d.ts

@@ -1,29 +1,28 @@
 import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
 import { BehaviorSubject, ReplaySubject } from 'rxjs';
-import { Layer } from '../shared/layers/layer';
+import { AnyLayer } from '../shared/layers/any-layer';
+import { isLayerItem } from '../utils';
 import * as i0 from "@angular/core";
 export declare class LayerLegendListComponent implements OnInit, OnDestroy {
     orderable: boolean;
     hasVisibleOrInRangeLayers$: BehaviorSubject<boolean>;
     hasVisibleAndNotInRangeLayers$: BehaviorSubject<boolean>;
-    layersInUi$: BehaviorSubject<Layer[]>;
-    layers$: BehaviorSubject<Layer[]>;
+    layersInUi$: BehaviorSubject<AnyLayer[]>;
+    layers$: BehaviorSubject<AnyLayer[]>;
     showAllLegend: boolean;
     change$: ReplaySubject<void>;
     private change$$;
-    set layers(value: Layer[]);
-    get layers(): Layer[];
-    private _layers;
+    layers: AnyLayer[];
     excludeBaseLayers: boolean;
     updateLegendOnResolutionChange: boolean;
     allowShowAllLegends: boolean;
     showAllLegendsValue: boolean;
     allLegendsShown: EventEmitter<boolean>;
+    isLayerItem: typeof isLayerItem;
     ngOnInit(): void;
     ngOnDestroy(): void;
     private next;
     private computeShownLayers;
-    private sortLayersByZindex;
     toggleShowAllLegends(toggle: boolean): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<LayerLegendListComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<LayerLegendListComponent, "igo-layer-legend-list", never, { "layers": { "alias": "layers"; "required": false; }; "excludeBaseLayers": { "alias": "excludeBaseLayers"; "required": false; }; "updateLegendOnResolutionChange": { "alias": "updateLegendOnResolutionChange"; "required": false; }; "allowShowAllLegends": { "alias": "allowShowAllLegends"; "required": false; }; "showAllLegendsValue": { "alias": "showAllLegendsValue"; "required": false; }; }, { "allLegendsShown": "allLegendsShown"; }, never, never, true, never>;

package/lib/layer/layer-list/index.d.ts

@@ -1,3 +1 @@
 export * from './layer-list.component';
-export * from './layer-list-binding.directive';
-export * from './layer-list.enum';

package/lib/layer/layer-list/layer-list.component.d.ts

@@ -1,127 +1,55 @@
-import { ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
-import type { TemplateRef } from '@angular/core';
-import { FloatLabelType } from '@angular/material/form-field';
-import { MatSliderChange } from '@angular/material/slider';
-import { BehaviorSubject, ReplaySubject } from 'rxjs';
-import { IgoMap } from '../../map/shared/map';
-import { LayerListControlsOptions } from '../layer-list-tool/layer-list-tool.interface';
-import { Layer } from '../shared/layers/layer';
-import { LayerListDisplacement } from './layer-list.enum';
-import { LayerListSelectVisibleEnum } from './layer-list.enum';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { EventEmitter } from '@angular/core';
+import { MatTreeFlatDataSource, MatTreeFlattener } from '@angular/material/tree';
+import { DropPermission, TreeDropEvent, TreeFlatNode } from '@igo2/common/drag-drop';
+import { IconSvg } from '@igo2/common/icon';
+import { MessageService } from '@igo2/core/message';
+import type { LayerViewerOptions } from '../layer-viewer/layer-viewer.interface';
+import { LayerType } from '../shared';
+import type { LayerController } from '../shared/layer-controller';
+import type { AnyLayer } from '../shared/layers/any-layer';
+import type { Layer } from '../shared/layers/layer';
+import type { LayerGroup } from '../shared/layers/layer-group';
+import { isLayerGroup, isLayerItem } from '../utils/layer.utils';
 import * as i0 from "@angular/core";
-export declare class LayerListComponent implements OnInit, OnDestroy {
-    private elRef;
-    orderable: boolean;
-    thresholdToFilterAndSort: number;
-    layers$: BehaviorSubject<Layer[]>;
-    change$: ReplaySubject<void>;
-    showToolbar$: BehaviorSubject<boolean>;
-    layerTool: boolean;
-    hideSelectedLayers: boolean;
-    activeLayer$: BehaviorSubject<Layer>;
-    layersChecked: Layer[];
-    selection: boolean;
-    private change$$;
-    private layers$$;
-    layerItemChangeDetection$: BehaviorSubject<any>;
-    templateLayerToolbar: TemplateRef<any>;
-    layersAreAllVisible: boolean;
-    ogcButton: boolean;
-    timeButton: boolean;
-    get map(): IgoMap;
-    set map(value: IgoMap);
-    private _map;
-    set layers(value: Layer[]);
-    get layers(): Layer[];
-    private _layers;
-    set activeLayer(value: Layer);
-    get activeLayer(): Layer;
-    private _activeLayer;
-    floatLabel: FloatLabelType;
-    layerFilterAndSortOptions: LayerListControlsOptions;
-    excludeBaseLayers: boolean;
-    toggleLegendOnVisibilityChange: boolean;
-    expandLegendOfVisibleLayers: boolean;
-    updateLegendOnResolutionChange: boolean;
-    queryBadge: boolean;
-    appliedFilterAndSort: EventEmitter<LayerListControlsOptions>;
-    get keyword(): string;
-    set keyword(value: string);
-    private _keyword;
-    get onlyVisible(): boolean;
-    set onlyVisible(value: boolean);
-    private _onlyVisible;
-    get sortAlpha(): boolean;
-    set sortAlpha(value: boolean);
-    private _sortedAlpha;
-    get opacity(): number;
-    set opacity(opacity: number);
-    get badgeOpacity(): number;
-    get raiseDisabled(): boolean;
-    get lowerDisabled(): boolean;
-    get raiseDisabledSelection(): boolean;
-    get lowerDisabledSelection(): boolean;
-    get checkOpacity(): number;
-    set checkOpacity(opacity: number);
-    get layerListDisplacement(): typeof LayerListDisplacement;
+type LayerFlatNode<T = AnyLayer> = TreeFlatNode<T>;
+export declare class LayerListComponent {
+    private messageService;
     toggleOpacity: boolean;
-    selectAllCheck: boolean;
-    selectAllCheck$: BehaviorSubject<boolean>;
-    private selectAllCheck$$;
-    constructor(elRef: ElementRef);
-    /**
-     * Subscribe to the search term stream and trigger researches
-     * @internal
-     */
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    activeLayerExtentIsValid(layer: Layer): boolean;
-    activeLayersExtentAreValid(layers: Layer[]): boolean;
-    zoomLayerExtents(layer: Layer): void;
-    zoomLayersExtents(layers: Layer[]): void;
-    changeOpacity(event: MatSliderChange): void;
-    clearKeyword(): void;
-    getLowerLayer(): {
-        zIndex: any;
-        id: any;
-    };
-    isLowerBaselayer(layer: any): boolean;
-    getUpperLayer(): {
-        zIndex: any;
-        id: any;
-    };
-    isUpperBaselayer(layer: any): boolean;
-    moveActiveLayer(activeLayer: Layer, actiontype: LayerListDisplacement, fromUi?: boolean): void;
-    raisableLayers(layers: Layer[]): boolean;
-    raisableLayer(index: number): any;
-    raiseLayers(layers: Layer[], fromUi?: boolean): void;
-    lowerableLayers(layers: Layer[]): boolean;
-    lowerableLayer(index: number): any;
-    lowerLayers(layers: Layer[], fromUi?: boolean): void;
-    private next;
-    private computeLayers;
-    onKeywordChange(term: any): void;
-    onAppliedFilterAndSortChange(appliedFilter: LayerListControlsOptions): void;
-    private filterLayers;
-    private sortLayersByZindex;
-    private sortLayersByTitle;
-    private normalize;
-    private computeShowToolbar;
-    toggleLayerTool(layer: any): void;
-    removeLayers(layers?: Layer[]): void;
-    toggleVisibility(layers?: Layer[]): void;
-    isLayerRemovable(layer: Layer): boolean;
-    isAllLayersRemovable(layers: Layer[]): boolean;
-    get statusSelectedLayersCheck(): LayerListSelectVisibleEnum;
-    layersCheck(event: {
-        layer: Layer;
-        check: boolean;
-    }): void;
-    toggleSelectionMode(value: boolean): void;
-    layersCheckedOpacity(): any;
-    selectAll(): void;
-    isScrolledIntoView(elemSource: any, elem: any): boolean;
-    removeProblemLayerInList(layersList: Layer[]): Layer[];
+    isInit: boolean;
+    controller: LayerController;
+    set layers(layers: AnyLayer[]);
+    get layers(): AnyLayer[];
+    private _layers;
+    isDesktop: boolean;
+    isDragDropDisabled: boolean;
+    selectAll: boolean;
+    viewerOptions: LayerViewerOptions;
+    activeChange: EventEmitter<AnyLayer>;
+    private _transformer;
+    treeControl: FlatTreeControl<LayerFlatNode<AnyLayer>, LayerFlatNode<AnyLayer>>;
+    treeFlattener: MatTreeFlattener<AnyLayer, LayerFlatNode<AnyLayer>, LayerFlatNode<AnyLayer>>;
+    dataSource: MatTreeFlatDataSource<AnyLayer, LayerFlatNode>;
+    constructor(messageService: MessageService);
+    isGroup: (_: number, node: LayerFlatNode) => boolean;
+    isLayerGroup: typeof isLayerGroup;
+    isLayerItem: typeof isLayerItem;
+    isSelected: (layer: AnyLayer) => boolean;
+    isDescendantSelection: (layer: AnyLayer) => boolean;
+    toggleActive(layer: AnyLayer): void;
+    handleSelect(checked: boolean, layer: AnyLayer): void;
+    getLayerType(layer: Layer): LayerType | 'measure' | 'draw';
+    getLayerIcon(layer: Layer): string | IconSvg;
+    dropNode({ node, ref, position }: TreeDropEvent<AnyLayer>): void;
+    dropNodeError(details: DropPermission): void;
+    dragStart(): void;
+    handleNodeToggle(node: LayerFlatNode<LayerGroup>): void;
+    private findNodeByLayerId;
+    private updateDatasource;
+    /** Recursive */
+    private expandGroup;
+    private restoreModel;
     static ɵfac: i0.ɵɵFactoryDeclaration<LayerListComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LayerListComponent, "igo-layer-list", never, { "layersAreAllVisible": { "alias": "layersAreAllVisible"; "required": false; }; "ogcButton": { "alias": "ogcButton"; "required": false; }; "timeButton": { "alias": "timeButton"; "required": false; }; "map": { "alias": "map"; "required": false; }; "layers": { "alias": "layers"; "required": false; }; "floatLabel": { "alias": "floatLabel"; "required": false; }; "layerFilterAndSortOptions": { "alias": "layerFilterAndSortOptions"; "required": false; }; "excludeBaseLayers": { "alias": "excludeBaseLayers"; "required": false; }; "toggleLegendOnVisibilityChange": { "alias": "toggleLegendOnVisibilityChange"; "required": false; }; "expandLegendOfVisibleLayers": { "alias": "expandLegendOfVisibleLayers"; "required": false; }; "updateLegendOnResolutionChange": { "alias": "updateLegendOnResolutionChange"; "required": false; }; "queryBadge": { "alias": "queryBadge"; "required": false; }; }, { "appliedFilterAndSort": "appliedFilterAndSort"; }, ["templateLayerToolbar"], ["[igoLayerItemToolbar]"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerListComponent, "igo-layer-list", never, { "controller": { "alias": "controller"; "required": true; }; "layers": { "alias": "layers"; "required": true; }; "isDesktop": { "alias": "isDesktop"; "required": false; }; "isDragDropDisabled": { "alias": "isDragDropDisabled"; "required": false; }; "selectAll": { "alias": "selectAll"; "required": false; }; "viewerOptions": { "alias": "viewerOptions"; "required": false; }; }, { "activeChange": "activeChange"; }, never, never, true, never>;
 }
+export {};

package/lib/layer/layer-list-tool/index.d.ts

@@ -1,4 +1,3 @@
 export * from './layer-list-tool.component';
-export * from './layer-list-tool.enum';
 export * from './layer-list-tool.interface';
 export * from './layer-list-tool.service';

package/lib/layer/layer-list-tool/layer-list-tool.component.d.ts

@@ -1,32 +1,25 @@
-import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { EventEmitter } from '@angular/core';
 import { FloatLabelType } from '@angular/material/form-field';
-import { BehaviorSubject, Subscription } from 'rxjs';
-import { LayerListControlsOptions } from './layer-list-tool.interface';
+import { LayerToolMode, LayerViewerOptions } from '../layer-viewer/layer-viewer.interface';
+import { LayerGroup } from '../shared/layers/layer-group';
+import { LayerListToolService } from './layer-list-tool.service';
 import * as i0 from "@angular/core";
-export declare class LayerListToolComponent implements OnInit, OnDestroy {
-    onlyVisible$: BehaviorSubject<boolean>;
-    sortAlpha$: BehaviorSubject<boolean>;
-    term$: BehaviorSubject<string>;
-    onlyVisible$$: Subscription;
-    sortAlpha$$: Subscription;
-    term$$: Subscription;
-    layersAreAllVisible: boolean;
+export declare class LayerListToolComponent {
+    private layerListToolService;
+    mode: LayerToolMode;
+    viewerOptions: LayerViewerOptions;
     floatLabel: FloatLabelType;
-    set onlyVisible(value: boolean);
-    get onlyVisible(): boolean;
-    set sortAlpha(value: boolean);
-    get sortAlpha(): boolean;
-    set term(value: string);
-    get term(): string;
-    selectionMode: boolean;
-    appliedFilterAndSort: EventEmitter<LayerListControlsOptions>;
-    selection: EventEmitter<boolean>;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    clearTerm(): void;
-    toggleSortAlpha(): void;
-    toggleOnlyVisible(): void;
+    onlyVisible: boolean;
+    term: string;
+    searchChange: EventEmitter<string>;
+    visibilityOnlyChange: EventEmitter<boolean>;
+    modeChange: EventEmitter<boolean>;
+    addedLayer: EventEmitter<LayerGroup>;
+    get selectionActive(): boolean;
+    constructor(layerListToolService: LayerListToolService);
+    handleTermChange(value: string | undefined): void;
     toggleSelectionMode(): void;
+    createGroup(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<LayerListToolComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LayerListToolComponent, "igo-layer-list-tool", never, { "layersAreAllVisible": { "alias": "layersAreAllVisible"; "required": false; }; "floatLabel": { "alias": "floatLabel"; "required": false; }; "onlyVisible": { "alias": "onlyVisible"; "required": false; }; "sortAlpha": { "alias": "sortAlpha"; "required": false; }; "term": { "alias": "term"; "required": false; }; }, { "appliedFilterAndSort": "appliedFilterAndSort"; "selection": "selection"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerListToolComponent, "igo-layer-list-tool", never, { "mode": { "alias": "mode"; "required": true; }; "viewerOptions": { "alias": "viewerOptions"; "required": false; }; "floatLabel": { "alias": "floatLabel"; "required": false; }; "onlyVisible": { "alias": "onlyVisible"; "required": false; }; "term": { "alias": "term"; "required": false; }; }, { "searchChange": "searchChange"; "visibilityOnlyChange": "visibilityOnlyChange"; "modeChange": "modeChange"; "addedLayer": "addedLayer"; }, never, never, true, never>;
 }

package/lib/layer/layer-list-tool/layer-list-tool.interface.d.ts

@@ -1,4 +1,3 @@
-import { LayerListControlsEnum } from '../layer-list/layer-list.enum';
 export interface LayerListControlsOptions {
     excludeBaseLayers?: boolean;
     showToolbar?: LayerListControlsEnum;
@@ -6,3 +5,8 @@ export interface LayerListControlsOptions {
     sortAlpha?: boolean;
     onlyVisible?: boolean;
 }
+export declare enum LayerListControlsEnum {
+    always = "always",
+    never = "never",
+    default = "default"
+}

package/lib/layer/layer-list-tool/layer-list-tool.service.d.ts

@@ -1,13 +1,14 @@
+import { FormDialogService } from '@igo2/common/form';
+import { Observable } from 'rxjs';
+import { LayerService } from '../shared/layer.service';
+import { LayerGroup } from '../shared/layers/layer-group';
 import * as i0 from "@angular/core";
 export declare class LayerListToolService {
-    keyword: string;
-    sortAlpha: boolean;
-    onlyVisible: boolean;
-    onlyInRange: boolean;
-    keywordInitialized: boolean;
-    sortedAlphaInitialized: boolean;
-    onlyVisibleInitialized: boolean;
-    onlyInRangeInitialized: boolean;
+    private layerService;
+    private formDialogService;
+    constructor(layerService: LayerService, formDialogService: FormDialogService);
+    createGroup(): Observable<LayerGroup | undefined>;
+    renameGroup(group: LayerGroup): Observable<string | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<LayerListToolService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<LayerListToolService>;
 }

package/lib/layer/layer-search/index.d.ts

@@ -0,0 +1 @@
+export * from './layer-search.component';

package/lib/layer/layer-search/layer-search.component.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { FloatLabelType } from '@angular/material/form-field';
+import * as i0 from "@angular/core";
+export declare class LayerSearchComponent implements OnInit {
+    control: FormControl<any>;
+    initialValue: string;
+    floatLabel: FloatLabelType;
+    placeholder: string;
+    tooltip: string;
+    searchChange: EventEmitter<string>;
+    ngOnInit(): void;
+    clearTerm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerSearchComponent, "igo-layer-search", never, { "initialValue": { "alias": "initialValue"; "required": false; }; "floatLabel": { "alias": "floatLabel"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; }, { "searchChange": "searchChange"; }, never, never, true, never>;
+}

package/lib/layer/layer-unavailable/index.d.ts

@@ -0,0 +1,2 @@
+export * from './layer-unavailable.component';
+export * from './layer-unavailable-list/layer-unavailable-list.component';

package/lib/layer/layer-unavailable/layer-unavailable-list/layer-unavailable-list.component.d.ts

@@ -0,0 +1,10 @@
+import { AnyLayerOptions, LayerService } from '../../shared';
+import * as i0 from "@angular/core";
+export declare class LayerUnavailableListComponent {
+    private layerService;
+    layersOptions: AnyLayerOptions[];
+    constructor(layerService: LayerService);
+    deleteUnavailableLayer(options: AnyLayerOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerUnavailableListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerUnavailableListComponent, "igo-layer-unavailable-list", never, { "layersOptions": { "alias": "layersOptions"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/layer/layer-unavailable/layer-unavailable.component.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from '@angular/core';
+import { AnyLayerItemOptions, AnyLayerOptions } from '../shared';
+import * as i0 from "@angular/core";
+export declare class LayerUnavailableComponent {
+    layerOptions: AnyLayerItemOptions;
+    remove: EventEmitter<AnyLayerOptions>;
+    get title(): string | undefined;
+    handleRemove(layerOptions: AnyLayerOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerUnavailableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerUnavailableComponent, "igo-layer-unavailable", never, { "layerOptions": { "alias": "layerOptions"; "required": false; }; }, { "remove": "remove"; }, never, never, true, never>;
+}

package/lib/layer/layer-viewer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './layer-viewer.component';
+export * from './layer-viewer.interface';

package/lib/layer/layer-viewer/layer-viewer.component.d.ts

@@ -0,0 +1,52 @@
+import { ChangeDetectorRef, EventEmitter, OnInit, TemplateRef } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import type { MapBase } from '../../map/shared/map.abstract';
+import { LayerListControlsOptions } from '../layer-list-tool/layer-list-tool.interface';
+import { LayerController } from '../shared';
+import { LayerService } from '../shared/layer.service';
+import { AnyLayer, LayerGroup, LayerOptionsBase } from '../shared/layers';
+import { isLayerItem } from '../utils/layer.utils';
+import { LayerToolMode, LayerViewerOptions } from './layer-viewer.interface';
+import * as i0 from "@angular/core";
+export declare class LayerViewerComponent implements OnInit {
+    private cdr;
+    private layerService;
+    layers: AnyLayer[];
+    baselayers: AnyLayer[];
+    keyword$: BehaviorSubject<string>;
+    mode: LayerToolMode;
+    isDragDropDisabled: boolean;
+    map: MapBase;
+    options: LayerViewerOptions;
+    isDesktop: boolean;
+    excludeBaseLayers: boolean;
+    appliedFilterAndSort: EventEmitter<LayerListControlsOptions>;
+    customBottomActions: TemplateRef<unknown> | undefined;
+    get layerViewerOptions(): LayerViewerOptions;
+    get layerController(): LayerController;
+    get unavailableLayers(): LayerOptionsBase[];
+    constructor(cdr: ChangeDetectorRef, layerService: LayerService);
+    isLayerItem: typeof isLayerItem;
+    /**
+     * Subscribe to the search term stream and trigger researches
+     * @internal
+     */
+    ngOnInit(): void;
+    clearKeyword(): void;
+    onVisibilityOnlyChange(): void;
+    onLayerChange(): void;
+    onSearchChange(value: string | undefined): void;
+    toggleSelectionMode(active: boolean): void;
+    toggleAllRows(): void;
+    isAllSelected(): boolean;
+    isScrolledIntoView(elemSource: any, elem: any): boolean;
+    createGroup(group: LayerGroup): void;
+    private computeLayers;
+    private filterLayers;
+    /** Recursive */
+    private filterSearch;
+    private layerHasTerm;
+    private normalizeString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerViewerComponent, "igo-layer-viewer", never, { "map": { "alias": "map"; "required": true; }; "options": { "alias": "options"; "required": false; }; "isDesktop": { "alias": "isDesktop"; "required": false; }; "excludeBaseLayers": { "alias": "excludeBaseLayers"; "required": false; }; }, { "appliedFilterAndSort": "appliedFilterAndSort"; }, ["customBottomActions"], ["[emptyList]", "*"], true, never>;
+}

package/lib/layer/layer-viewer/layer-viewer.interface.d.ts

@@ -0,0 +1,22 @@
+import { LayerListControlsOptions } from '../layer-list-tool/layer-list-tool.interface';
+export interface LayerConfig {
+    group?: {
+        enable: boolean;
+        maxHierarchyLevel?: number;
+        canCreate?: boolean;
+        canRename?: boolean;
+    };
+}
+export interface LayerViewerOptions extends LayerConfig {
+    mode?: LayerToolMode;
+    queryBadge?: boolean;
+    legend?: Partial<ViewerLegendOptions>;
+    filterAndSortOptions?: LayerListControlsOptions;
+}
+interface ViewerLegendOptions {
+    showOnVisibilityChange: boolean;
+    updateOnResolutionChange: boolean;
+    showForVisibleLayers: boolean;
+}
+export type LayerToolMode = 'selection';
+export {};

package/lib/layer/layer-viewer-bottom-actions/index.d.ts

@@ -0,0 +1 @@
+export * from './layer-viewer-bottom-actions.component';

package/lib/layer/layer-viewer-bottom-actions/layer-viewer-bottom-actions.component.d.ts

@@ -0,0 +1,44 @@
+import { EventEmitter } from '@angular/core';
+import { MatSliderChange } from '@angular/material/slider';
+import type { MapBase } from '../../map/shared/map.abstract';
+import { LayerListToolService } from '../layer-list-tool';
+import { LayerViewerOptions } from '../layer-viewer/layer-viewer.interface';
+import { LayerController } from '../shared/layer-controller';
+import type { AnyLayer } from '../shared/layers';
+import { isLayerItem } from '../utils/layer.utils';
+import * as i0 from "@angular/core";
+export declare class LayerViewerBottomActionsComponent {
+    private layerListToolService;
+    orderable: boolean;
+    map: MapBase;
+    controller: LayerController;
+    searchTerm: string;
+    viewerOptions: LayerViewerOptions;
+    layerChange: EventEmitter<any>;
+    get layersFlattened(): AnyLayer[];
+    get hasMultipleSelection(): boolean;
+    get selected(): AnyLayer[];
+    get opacity(): number;
+    set opacity(opacity: number);
+    get allSelectionVisibilityHidden(): boolean;
+    get isSelectionRaisable(): boolean;
+    get isSelectionLowerable(): boolean;
+    get canRename(): boolean;
+    constructor(layerListToolService: LayerListToolService);
+    isLayerItem: typeof isLayerItem;
+    handleRename(): void;
+    isLayersRemovable(layers: AnyLayer[]): boolean;
+    removeLayers(): void;
+    isExtentsValid(): boolean;
+    zoomLayersExtents(): void;
+    raiseSelection(): void;
+    lowerSelection(): void;
+    changeOpacity(event: MatSliderChange): void;
+    toggleSelectionVisibility(): void;
+    private isLowerable;
+    private isRaisable;
+    private getRecipientOfVisibleLayer;
+    private isLayerRemovable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerViewerBottomActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerViewerBottomActionsComponent, "igo-layer-viewer-bottom-actions", never, { "map": { "alias": "map"; "required": true; }; "controller": { "alias": "controller"; "required": true; }; "searchTerm": { "alias": "searchTerm"; "required": true; }; "viewerOptions": { "alias": "viewerOptions"; "required": false; }; }, { "layerChange": "layerChange"; }, never, ["*"], true, never>;
+}

package/lib/layer/layer-visibility-button/index.d.ts

@@ -0,0 +1 @@
+export * from './layer-visibility-button.component';