@igo2/context 19.0.3 → 20.0.0-next.2

package/index.d.ts

@@ -1,5 +1,1035 @@
+import * as i0 from '@angular/core';
+import { OnInit, ModuleWithProviders, OnDestroy, EventEmitter } from '@angular/core';
+import { UntypedFormGroup, UntypedFormControl } from '@angular/forms';
+import { AnyLayerOptions, MapViewOptions, MapExtent, MapScaleLineOptions, MapAttributionOptions, VectorLayer, AnyLayer, IgoMap, Feature, StyleListService, StyleService, ImportExportServiceOptions, LayerOptions, LayerGroupOptions, AnyDataSourceOptions } from '@igo2/geo';
+import { BehaviorSubject, ReplaySubject, Subscription, Observable, Subject } from 'rxjs';
+import { Tool } from '@igo2/common/tool';
+import { Message, MessageService } from '@igo2/core/message';
+import { FeatureCollection } from 'geojson';
+import { AuthService, AuthOptions } from '@igo2/auth';
+import { ActionStore, ActionbarMode } from '@igo2/common/action';
+import { ConfigService } from '@igo2/core/config';
+import { MatDialogRef } from '@angular/material/dialog';
+import { Title } from '@angular/platform-browser';
+import { FlexibleState } from '@igo2/common/flexible';
+import { Media } from '@igo2/core/media';
+import { Params } from '@angular/router';
+import { RouteServiceOptions, RouteService } from '@igo2/core/route';
+
+declare enum TypePermission {
+    null = 0,
+    read = 1,
+    write = 2
+}
+declare enum Scope {
+    public = 0,
+    protected = 1,
+    private = 2
+}
+
+interface Context {
+    id?: string;
+    title?: string;
+    uri?: string;
+    scope?: string;
+    permission?: string;
+    description?: string;
+    icon?: string;
+    iconImage?: string;
+    hidden?: boolean;
+    imported?: boolean;
+}
+interface ContextsList {
+    ours: Context[];
+    shared?: Context[];
+    public?: Context[];
+}
+type ExtraFeatures = FeatureCollection & {
+    name: string;
+    opacity: number;
+    visible: boolean;
+};
+interface DetailedContext extends Context {
+    layers?: AnyLayerOptions[];
+    base?: string;
+    map?: ContextMap;
+    tools?: Tool[];
+    toolbar?: string[];
+    message?: Message;
+    messages?: Message[];
+    removeLayersOnContextChange?: boolean;
+    extraFeatures?: ExtraFeatures[];
+}
+interface ContextMapView extends MapViewOptions {
+    keepCurrentView?: boolean;
+    homeExtent?: ContextHomeExtent;
+}
+interface ContextHomeExtent {
+    extent?: MapExtent;
+    center?: [number, number];
+    zoom?: number;
+}
+interface ContextMap {
+    view: ContextMapView;
+    controls?: {
+        scaleLine?: boolean | MapScaleLineOptions;
+        attribution?: boolean | MapAttributionOptions;
+    };
+}
+interface ContextServiceOptions {
+    url?: string;
+    basePath?: string;
+    contextListFile?: string;
+    defaultContextUri?: string;
+}
+interface ContextPermission {
+    id?: string;
+    contextId?: string;
+    profil: string;
+    profilTitle?: string;
+    typePermission: TypePermission;
+}
+interface ContextPermissionsList {
+    read: ContextPermission[];
+    write: ContextPermission[];
+}
+interface ContextUserPermission {
+    name: string;
+    checked: boolean;
+    indeterminate?: boolean;
+}
+interface ContextProfils {
+    name: string;
+    title: string;
+    childs?: ContextProfils[];
+}
+
+declare class ContextImportExportComponent implements OnInit {
+    private contextImportService;
+    private contextExportService;
+    private messageService;
+    private formBuilder;
+    private config;
+    private contextService;
+    form: UntypedFormGroup;
+    layers: VectorLayer[];
+    inputProj: string;
+    loading$: BehaviorSubject<boolean>;
+    forceNaming: boolean;
+    layerList: AnyLayer[];
+    userControlledLayerList: readonly AnyLayer[];
+    res: DetailedContext;
+    private clientSideFileSizeMax;
+    fileSizeMb: number;
+    activeImportExport: string;
+    map: IgoMap;
+    constructor();
+    ngOnInit(): void;
+    importFiles(files: File[]): void;
+    handleExportFormSubmit(contextOptions: any): void;
+    private buildForm;
+    private onFileImportSuccess;
+    private onFileImportError;
+    private onFileExportError;
+    private onFileExportSuccess;
+    selectAll(e: any): void;
+    onImportExportChange(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextImportExportComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextImportExportComponent, "igo-context-import-export", never, { "map": { "alias": "map"; "required": false; }; }, {}, never, never, true, never>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * @deprecated import the ContextImportExportComponent directly
  */
-/// <amd-module name="@igo2/context" />
-export * from './public_api';
+declare class IgoContextImportExportModule {
+    static forRoot(): ModuleWithProviders<IgoContextImportExportModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoContextImportExportModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoContextImportExportModule, never, [typeof ContextImportExportComponent], [typeof ContextImportExportComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoContextImportExportModule>;
+}
+
+declare enum ContextListControlsEnum {
+    always = "always",
+    never = "never",
+    default = "default"
+}
+
+declare class ContextListComponent implements OnInit, OnDestroy {
+    configService: ConfigService<any>;
+    auth: AuthService;
+    private dialog;
+    private languageService;
+    private storageService;
+    contextConfigs: ContextServiceOptions;
+    private contextsInitial;
+    contexts$: BehaviorSubject<ContextsList>;
+    change$: ReplaySubject<void>;
+    private change$$;
+    get contexts(): ContextsList;
+    set contexts(value: ContextsList);
+    private _contexts;
+    selectedContext: DetailedContext;
+    map: IgoMap;
+    get defaultContextId(): string;
+    set defaultContextId(value: string);
+    private _defaultContextId;
+    collapsed: {
+        contextScope: any;
+    }[];
+    select: EventEmitter<DetailedContext>;
+    unselect: EventEmitter<DetailedContext>;
+    edit: EventEmitter<DetailedContext>;
+    delete: EventEmitter<DetailedContext>;
+    save: EventEmitter<DetailedContext>;
+    clone: EventEmitter<DetailedContext>;
+    create: EventEmitter<{
+        title: string;
+        empty: boolean;
+    }>;
+    hide: EventEmitter<DetailedContext>;
+    show: EventEmitter<DetailedContext>;
+    showHiddenContexts: EventEmitter<boolean>;
+    favorite: EventEmitter<DetailedContext>;
+    managePermissions: EventEmitter<DetailedContext>;
+    manageTools: EventEmitter<DetailedContext>;
+    filterPermissionsChanged: EventEmitter<ContextUserPermission[]>;
+    titleMapping: {
+        ours: string;
+        shared: string;
+        public: string;
+    };
+    users: ContextProfils[];
+    permissions: ContextUserPermission[];
+    actionStore: ActionStore;
+    actionbarMode: ActionbarMode;
+    color: string;
+    showHidden: boolean;
+    /**
+     * Context filter term
+     */
+    set term(value: string);
+    get term(): string;
+    _term: string;
+    get sortedAlpha(): boolean;
+    set sortedAlpha(value: boolean);
+    private _sortedAlpha;
+    showContextFilter: ContextListControlsEnum;
+    thresholdToFilter: number;
+    get isEmpty(): boolean;
+    constructor();
+    ngOnInit(): void;
+    private next;
+    private filterContextsList;
+    ngOnDestroy(): void;
+    showFilter(): boolean;
+    sortContextsList(contexts: ContextsList): any;
+    normalize(str: string): string;
+    toggleSort(): void;
+    clearFilter(): void;
+    createContext(empty?: boolean): void;
+    getPermission(user?: any): ContextUserPermission;
+    handleToggleCategory(user: any, parent?: any): void;
+    hideContext(context: DetailedContext): void;
+    showContext(context: DetailedContext): void;
+    onSelect(context: DetailedContext): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextListComponent, "igo-context-list", never, { "contexts": { "alias": "contexts"; "required": false; }; "selectedContext": { "alias": "selectedContext"; "required": false; }; "map": { "alias": "map"; "required": false; }; "defaultContextId": { "alias": "defaultContextId"; "required": false; }; "term": { "alias": "term"; "required": false; }; }, { "select": "select"; "unselect": "unselect"; "edit": "edit"; "delete": "delete"; "save": "save"; "clone": "clone"; "create": "create"; "hide": "hide"; "show": "show"; "showHiddenContexts": "showHiddenContexts"; "favorite": "favorite"; "managePermissions": "managePermissions"; "manageTools": "manageTools"; "filterPermissionsChanged": "filterPermissionsChanged"; }, never, never, true, never>;
+}
+
+declare class ContextListBindingDirective implements OnInit, OnDestroy {
+    private contextService;
+    private mapService;
+    private languageService;
+    private confirmDialogService;
+    private messageService;
+    private auth;
+    private storageService;
+    private cdRef;
+    private component;
+    private contexts$$;
+    private selectedContext$$;
+    private defaultContextId$$;
+    private previousMessageId;
+    onSelect(context: Context): void;
+    onEdit(context: Context): void;
+    onSave(context: Context): void;
+    onFavorite(context: Context): void;
+    onManageTools(context: Context): void;
+    onManagePermissions(context: Context): void;
+    onDelete(context: Context): void;
+    onClone(context: DetailedContext): void;
+    onCreate(opts: {
+        title: string;
+        empty: boolean;
+    }): void;
+    loadContexts(): void;
+    showHiddenContexts(): void;
+    onShowContext(context: DetailedContext): void;
+    onHideContext(context: DetailedContext): void;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private handleContextsChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextListBindingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextListBindingDirective, "[igoContextListBinding]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ContextItemComponent {
+    auth: AuthService;
+    private storageService;
+    typePermission: typeof TypePermission;
+    color: string;
+    collapsed: boolean;
+    showFavorite: boolean;
+    context: DetailedContext;
+    default: boolean;
+    selected: boolean;
+    edit: EventEmitter<DetailedContext>;
+    delete: EventEmitter<DetailedContext>;
+    save: EventEmitter<DetailedContext>;
+    clone: EventEmitter<DetailedContext>;
+    hide: EventEmitter<DetailedContext>;
+    show: EventEmitter<DetailedContext>;
+    favorite: EventEmitter<DetailedContext>;
+    managePermissions: EventEmitter<DetailedContext>;
+    manageTools: EventEmitter<DetailedContext>;
+    get hidden(): boolean;
+    get canShare(): boolean;
+    favoriteClick(context: DetailedContext): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextItemComponent, "igo-context-item", never, { "showFavorite": { "alias": "showFavorite"; "required": false; }; "context": { "alias": "context"; "required": false; }; "default": { "alias": "default"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "edit": "edit"; "delete": "delete"; "save": "save"; "clone": "clone"; "hide": "hide"; "show": "show"; "favorite": "favorite"; "managePermissions": "managePermissions"; "manageTools": "manageTools"; }, never, never, true, never>;
+}
+
+declare class ContextFormComponent implements OnInit {
+    private clipboard;
+    private formBuilder;
+    private messageService;
+    form: UntypedFormGroup;
+    prefix: string;
+    get btnSubmitText(): string;
+    set btnSubmitText(value: string);
+    private _btnSubmitText;
+    get context(): Context;
+    set context(value: Context);
+    private _context;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    submitForm: EventEmitter<any>;
+    clone: EventEmitter<any>;
+    delete: EventEmitter<any>;
+    ngOnInit(): void;
+    handleFormSubmit(value: any): void;
+    copyTextToClipboard(): void;
+    private buildForm;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextFormComponent, "igo-context-form", never, { "btnSubmitText": { "alias": "btnSubmitText"; "required": false; }; "context": { "alias": "context"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "submitForm": "submitForm"; "clone": "clone"; "delete": "delete"; }, never, never, true, never>;
+}
+
+declare class ContextEditComponent {
+    private cd;
+    get context(): Context;
+    set context(value: Context);
+    private _context;
+    submitForm: EventEmitter<Context>;
+    refresh(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextEditComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextEditComponent, "igo-context-edit", never, { "context": { "alias": "context"; "required": false; }; }, { "submitForm": "submitForm"; }, never, never, true, never>;
+}
+
+declare class ContextEditBindingDirective implements OnInit, OnDestroy {
+    private contextService;
+    private messageService;
+    private component;
+    private editedContext$$;
+    submitSuccessed: EventEmitter<Context>;
+    onEdit(context: Context): void;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private handleEditedContextChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextEditBindingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextEditBindingDirective, "[igoContextEditBinding]", never, {}, { "submitSuccessed": "submitSuccessed"; }, never, never, true, never>;
+}
+
+declare class ContextPermissionsComponent implements OnInit {
+    private formBuilder;
+    private cd;
+    private http;
+    authService: AuthService;
+    private config;
+    form: UntypedFormGroup;
+    get context(): Context;
+    set context(value: Context);
+    private _context;
+    get permissions(): ContextPermissionsList;
+    set permissions(value: ContextPermissionsList);
+    private _permissions;
+    get profils(): ContextProfils[];
+    set profils(value: ContextProfils[]);
+    private _profils;
+    get canWrite(): boolean;
+    private baseUrlProfils;
+    formControl: UntypedFormControl;
+    formValueChanges$$: Subscription;
+    addPermission: EventEmitter<ContextPermission>;
+    removePermission: EventEmitter<ContextPermission>;
+    scopeChanged: EventEmitter<Context>;
+    ngOnInit(): void;
+    displayFn(profil?: ContextProfils): string | undefined;
+    handleFormSubmit(value: any): void;
+    private buildForm;
+    onProfilSelected(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextPermissionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextPermissionsComponent, "igo-context-permissions", never, { "context": { "alias": "context"; "required": false; }; "permissions": { "alias": "permissions"; "required": false; }; }, { "addPermission": "addPermission"; "removePermission": "removePermission"; "scopeChanged": "scopeChanged"; }, never, never, true, never>;
+}
+
+declare class ContextPermissionsBindingDirective implements OnInit, OnDestroy {
+    private contextService;
+    private languageService;
+    private messageService;
+    private cd;
+    private component;
+    private editedContext$$;
+    onAddPermission(permission: ContextPermission): void;
+    onRemovePermission(permission: ContextPermission): void;
+    onScopeChanged(context: Context): void;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private handleEditedContextChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextPermissionsBindingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextPermissionsBindingDirective, "[igoContextPermissionsBinding]", never, {}, {}, never, never, true, never>;
+}
+
+declare class LayerContextDirective implements OnInit, OnDestroy {
+    private component;
+    private contextService;
+    private layerService;
+    private configService;
+    private styleListService;
+    private styleService;
+    private shareMapService;
+    private context$$;
+    private queryParams;
+    private contextLayers;
+    removeLayersOnContextChange: boolean;
+    contextLayersLoaded: EventEmitter<boolean>;
+    get map(): IgoMap;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private handleContextChange;
+    private handleAddLayers;
+    private computeLayerVisibilityFromUrl;
+    private handleContextWithSharedUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerContextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LayerContextDirective, "[igoLayerContext]", never, { "removeLayersOnContextChange": { "alias": "removeLayersOnContextChange"; "required": false; }; }, { "contextLayersLoaded": "contextLayersLoaded"; }, never, never, true, never>;
+}
+
+declare class MapContextDirective implements OnInit, OnDestroy {
+    private contextService;
+    private mediaService;
+    private shareMapService;
+    private component;
+    private context$$;
+    get map(): IgoMap;
+    private queryParams;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private handleContextChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapContextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MapContextDirective, "[igoMapContext]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the components/directives directly or CONTEXT_MANAGER_DIRECTIVES for the set
+ */
+declare class IgoContextManagerModule {
+    static forRoot(): ModuleWithProviders<IgoContextManagerModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoContextManagerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoContextManagerModule, never, [typeof ContextListComponent, typeof ContextListBindingDirective, typeof ContextItemComponent, typeof ContextFormComponent, typeof ContextEditComponent, typeof ContextEditBindingDirective, typeof ContextPermissionsComponent, typeof ContextPermissionsBindingDirective, typeof LayerContextDirective, typeof MapContextDirective], [typeof ContextListComponent, typeof ContextListBindingDirective, typeof ContextItemComponent, typeof ContextFormComponent, typeof ContextEditComponent, typeof ContextEditBindingDirective, typeof ContextPermissionsComponent, typeof ContextPermissionsBindingDirective, typeof LayerContextDirective, typeof MapContextDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoContextManagerModule>;
+}
+
+declare class BookmarkButtonComponent {
+    private dialog;
+    private contextService;
+    private messageService;
+    get map(): IgoMap;
+    set map(value: IgoMap);
+    private _map;
+    get color(): string;
+    set color(value: string);
+    private _color;
+    createContext(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BookmarkButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BookmarkButtonComponent, "igo-bookmark-button", never, { "map": { "alias": "map"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BookmarkDialogComponent {
+    dialogRef: MatDialogRef<BookmarkDialogComponent, any>;
+    title: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BookmarkDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BookmarkDialogComponent, "igo-bookmark-dialog", never, {}, {}, never, never, true, never>;
+}
+
+interface Poi {
+    id?: string;
+    title: string;
+    x: number;
+    y: number;
+    zoom: number;
+}
+
+declare class PoiButtonComponent implements OnInit, OnDestroy {
+    private dialog;
+    private authService;
+    private poiService;
+    private messageService;
+    private languageService;
+    private confirmDialogService;
+    get map(): IgoMap;
+    set map(value: IgoMap);
+    private _map;
+    get color(): string;
+    set color(value: string);
+    private _color;
+    pois: Poi[];
+    private authenticate$$;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    deletePoi(poi: Poi): void;
+    private getPois;
+    createPoi(): void;
+    zoomOnPoi(id: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PoiButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PoiButtonComponent, "igo-poi-button", never, { "map": { "alias": "map"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class UserButtonComponent {
+    private dialog;
+    private config;
+    auth: AuthService;
+    get map(): IgoMap;
+    set map(value: IgoMap);
+    private _map;
+    get color(): string;
+    set color(value: string);
+    private _color;
+    expand: boolean;
+    visible: boolean;
+    hasApi: boolean;
+    constructor();
+    accountClick(): void;
+    logout(): void;
+    infoUser(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserButtonComponent, "igo-user-button", never, { "map": { "alias": "map"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the components/directives directly or CONTEXT_MAP_BUTTON_DIRECTIVES for the set
+ */
+declare class IgoContextMapButtonModule {
+    static forRoot(): ModuleWithProviders<IgoContextMapButtonModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoContextMapButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoContextMapButtonModule, never, [typeof BookmarkButtonComponent, typeof BookmarkDialogComponent, typeof PoiButtonComponent, typeof UserButtonComponent], [typeof BookmarkButtonComponent, typeof PoiButtonComponent, typeof UserButtonComponent, typeof BookmarkDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoContextMapButtonModule>;
+}
+
+declare class ShareMapApiComponent implements OnInit {
+    private clipboard;
+    private languageService;
+    private messageService;
+    private auth;
+    private shareMapService;
+    private formBuilder;
+    private contextService;
+    form: UntypedFormGroup;
+    map: IgoMap;
+    url: string;
+    userId: string;
+    idContextShared: string;
+    ngOnInit(): void;
+    createUrl(values?: any): void;
+    updateContextShared(values?: any): void;
+    copyTextToClipboard(textArea: HTMLTextAreaElement): void;
+    buildForm(): void;
+    private createContextShared;
+    private _updateContextShared;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShareMapApiComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ShareMapApiComponent, "igo-share-map-api", never, { "map": { "alias": "map"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ShareMapUrlComponent implements OnInit, OnDestroy {
+    private clipboard;
+    private messageService;
+    private shareMapService;
+    private contextService;
+    private cdRef;
+    private route;
+    private mapState$$;
+    map: IgoMap;
+    url: string;
+    private publicShareOption;
+    private language;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    generateUrl(): void;
+    copyTextToClipboard(textArea: HTMLTextAreaElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShareMapUrlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ShareMapUrlComponent, "igo-share-map-url", never, { "map": { "alias": "map"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ShareMapComponent {
+    private config;
+    map: IgoMap;
+    hasApi: boolean;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShareMapComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ShareMapComponent, "igo-share-map", never, { "map": { "alias": "map"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const SHARE_MAP_DIRECTIVES: readonly [typeof ShareMapComponent, typeof ShareMapUrlComponent, typeof ShareMapApiComponent];
+/**
+ * @deprecated import the components/directives directly or SHARE_MAP_DIRECTIVES for the set
+ */
+declare class IgoShareMapModule {
+    static forRoot(): ModuleWithProviders<IgoShareMapModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoShareMapModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoShareMapModule, never, [typeof ShareMapComponent, typeof ShareMapUrlComponent, typeof ShareMapApiComponent], [typeof ShareMapComponent, typeof ShareMapUrlComponent, typeof ShareMapApiComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoShareMapModule>;
+}
+
+declare class SidenavComponent {
+    titleService: Title;
+    private format;
+    get map(): IgoMap;
+    set map(value: IgoMap);
+    private _map;
+    get opened(): boolean;
+    set opened(value: boolean);
+    private _opened;
+    get feature(): Feature;
+    set feature(value: Feature);
+    private _feature;
+    get tool(): Tool;
+    set tool(value: Tool);
+    private _tool;
+    get media(): Media;
+    set media(value: Media);
+    private _media;
+    get title(): string;
+    set title(value: string);
+    private _title;
+    topPanelState: FlexibleState;
+    get featureTitle(): string;
+    constructor();
+    zoomToFeatureExtent(): void;
+    toggleTopPanel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidenavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidenavComponent, "igo-sidenav", never, { "map": { "alias": "map"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; "feature": { "alias": "feature"; "required": false; }; "tool": { "alias": "tool"; "required": false; }; "media": { "alias": "media"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the SidenavComponent directly
+ */
+declare class IgoSidenavModule {
+    static forRoot(): ModuleWithProviders<IgoSidenavModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoSidenavModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoSidenavModule, never, [typeof SidenavComponent], [typeof SidenavComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoSidenavModule>;
+}
+
+/**
+ * @deprecated import the components/directives directly or SHARE_MAP_DIRECTIVES for the set
+ */
+declare class IgoContextModule {
+    static forRoot(): ModuleWithProviders<IgoContextModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoContextModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoContextModule, never, never, [typeof IgoContextImportExportModule, typeof IgoContextManagerModule, typeof IgoContextMapButtonModule, typeof IgoShareMapModule, typeof IgoSidenavModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoContextModule>;
+}
+
+declare class ExportError extends Error {
+}
+declare class ExportInvalidFileError extends ExportError {
+    constructor();
+}
+declare class ExportNothingToExportError extends ExportError {
+    constructor();
+}
+
+declare class ImportError extends Error {
+}
+declare class ImportInvalidFileError extends ImportError {
+    constructor();
+}
+declare class ImportUnreadableFileError extends ImportError {
+    constructor();
+}
+declare class ImportNothingToImportError extends ImportError {
+    constructor();
+}
+declare class ImportSizeError extends ImportError {
+    constructor();
+}
+declare class ImportSRSError extends ImportError {
+    constructor();
+}
+
+declare class ContextExportService {
+    export(res: DetailedContext): Observable<void>;
+    protected exportAsync(res: DetailedContext): Observable<void>;
+    protected nothingToExport(res: DetailedContext): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextExportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContextExportService>;
+}
+
+declare class ContextImportService {
+    private config;
+    static allowedMimeTypes: string[];
+    static allowedExtensions: string;
+    private clientSideFileSizeMax;
+    constructor();
+    import(file: File): Observable<DetailedContext>;
+    private getFileImporter;
+    private importAsync;
+    private importFile;
+    private parseContextFromFile;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextImportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContextImportService>;
+}
+
+interface ContextExportOptions {
+    layer: AnyLayer[];
+    name: string;
+}
+
+declare class ContextService {
+    private http;
+    private authService;
+    private languageService;
+    private config;
+    private messageService;
+    private storageService;
+    private exportService;
+    private shareMapService;
+    private route;
+    context$: BehaviorSubject<DetailedContext>;
+    contexts$: BehaviorSubject<ContextsList>;
+    defaultContextId$: BehaviorSubject<string>;
+    editedContext$: BehaviorSubject<DetailedContext>;
+    importedContext: DetailedContext[];
+    toolsChanged$: Subject<DetailedContext>;
+    private mapViewFromRoute;
+    private options;
+    private baseUrl;
+    private tools;
+    private toolbar;
+    get defaultContextUri(): string;
+    set defaultContextUri(uri: string);
+    private _defaultContextUri;
+    constructor();
+    get(permissions?: string[], hidden?: boolean): Observable<ContextsList>;
+    getById(id: string): Observable<Context>;
+    getDetails(id: string): Observable<DetailedContext>;
+    getDefault(): Observable<DetailedContext>;
+    getProfilByUser(): Observable<ContextProfils[]>;
+    setDefault(id: string): Observable<any>;
+    hideContext(id: string): Observable<Object>;
+    showContext(id: string): Observable<Object>;
+    delete(id: string, imported?: boolean): Observable<void>;
+    create(context: DetailedContext): Observable<Context>;
+    clone(id: string, properties?: {}): Observable<Context>;
+    update(id: string, context: DetailedContext): Observable<Context>;
+    addToolAssociation(contextId: string, toolId: string): Observable<void>;
+    deleteToolAssociation(contextId: string, toolId: string): Observable<any>;
+    getPermissions(id: string): Observable<ContextPermission[]>;
+    addPermissionAssociation(contextId: string, profil: string, type: TypePermission): Observable<ContextPermission[]>;
+    deletePermissionAssociation(contextId: string, permissionId: string): Observable<void>;
+    getLocalContexts(): Observable<ContextsList>;
+    getLocalContext(uri: string): Observable<DetailedContext>;
+    loadContexts(permissions?: string[], hidden?: boolean): void;
+    loadDefaultContext(): void;
+    loadContext(uri: string): void;
+    setContext(context: DetailedContext): void;
+    loadEditedContext(uri: string): void;
+    setEditedContext(context: DetailedContext): void;
+    getContextFromMap(igoMap: IgoMap, empty?: boolean): DetailedContext;
+    getContextFromLayers(igoMap: IgoMap, layers: AnyLayer[], name: string, keepCurrentView?: boolean): DetailedContext;
+    private getExtraFeatures;
+    setTools(tools: Tool[]): void;
+    setToolbar(toolbar: string[]): void;
+    private handleContextMessage;
+    private getContextByUri;
+    getContextLayers(map: IgoMap): readonly AnyLayer[];
+    private getPath;
+    private handleError;
+    private handleContextsChange;
+    private addContextToList;
+    private findContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContextService>;
+}
+
+declare function handleFileImportSuccess(file: File, context: DetailedContext, messageService: MessageService, contextService: ContextService): void;
+declare function handleFileImportError(file: File, error: Error, messageService: MessageService, sizeMb?: number): void;
+declare function handleInvalidFileImportError(file: File, error: Error, messageService: MessageService): void;
+declare function handleSizeFileImportError(file: File, error: Error, messageService: MessageService, sizeMb: number): void;
+declare function handleUnreadbleFileImportError(file: File, error: Error, messageService: MessageService): void;
+declare function handleNothingToImportError(file: File, messageService: MessageService): void;
+declare function addContextToContextList(context: DetailedContext, contextTitle: string, contextService: ContextService): void;
+declare function getFileExtension(file: File): string;
+declare function computeLayerTitleFromFile(file: File): string;
+declare function addImportedFeaturesToMap(extraFeatures: ExtraFeatures, map: IgoMap): VectorLayer;
+declare function addImportedFeaturesStyledToMap(extraFeatures: ExtraFeatures, map: IgoMap, styleListService: StyleListService, styleService: StyleService): VectorLayer;
+
+declare function handleFileExportError(error: Error, messageService: MessageService): void;
+declare function handleFileExportSuccess(messageService: MessageService): void;
+declare function handleNothingToExportError(messageService: MessageService): void;
+
+declare const CONTEXT_MANAGER_DIRECTIVES: readonly [typeof ContextListComponent, typeof ContextListBindingDirective, typeof ContextItemComponent, typeof ContextFormComponent, typeof ContextEditComponent, typeof ContextEditBindingDirective, typeof ContextPermissionsComponent, typeof ContextPermissionsBindingDirective, typeof MapContextDirective, typeof LayerContextDirective];
+
+declare class PoiDialogComponent {
+    dialogRef: MatDialogRef<PoiDialogComponent, any>;
+    title: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PoiDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PoiDialogComponent, "igo-poi-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class PoiService {
+    private http;
+    private config;
+    private baseUrl;
+    constructor();
+    get(): Observable<Poi[]>;
+    delete(id: string): Observable<void>;
+    create(context: Poi): Observable<Poi>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PoiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PoiService>;
+}
+
+declare class UserDialogComponent {
+    dialogRef: MatDialogRef<UserDialogComponent, any>;
+    private auth;
+    private storageService;
+    user: any;
+    exp: any;
+    constructor();
+    clearPreferences(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserDialogComponent, "igo-user-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare const CONTEXT_MAP_BUTTON_DIRECTIVES: readonly [typeof BookmarkButtonComponent, typeof BookmarkDialogComponent, typeof PoiButtonComponent, typeof UserButtonComponent];
+
+interface EnvironmentOptions {
+    auth?: AuthOptions;
+    context?: ContextServiceOptions;
+    favoriteContext4NonAuthenticated?: boolean;
+    importExport?: ImportExportServiceOptions;
+}
+
+declare const ServiceType: readonly ["wms", "wmts", "arcgisrest", "imagearcgisrest", "tilearcgisrest"];
+type ServiceType = (typeof ServiceType)[number];
+declare enum ServiceTypeEnum {
+    wms = 0,
+    wmts = 1,
+    arcgisrest = 2,
+    imagearcgisrest = 3,
+    tilearcgisrest = 4
+}
+interface ShareOption {
+    layerlistControls: {
+        querystring: string;
+    };
+}
+declare const LayerParamsKeys: readonly ["index", "names", "type", "version", "queryString", "visible", "opacity", "zIndex", "parentId"];
+type LayerParamsKeys = (typeof LayerParamsKeys)[number];
+declare const GroupParamsKeys: readonly ["title", "id", "expanded", "visible", "opacity", "zIndex", "parentId"];
+type GroupParamsKeys = (typeof GroupParamsKeys)[number];
+declare const PositionParamsKeys: readonly ["center", "zoom", "rotation", "projection"];
+type PositionParamsKeys = (typeof PositionParamsKeys)[number];
+interface ShareMapKeysDefinitions {
+    urlsKey: string;
+    contextKey: string;
+    languageKey: string;
+    pos: DefinitionKeyParams<PositionParamsKeys>;
+    layers: DefinitionKeyParams<LayerParamsKeys>;
+    groups: DefinitionKeyParams<GroupParamsKeys>;
+}
+interface DefinitionKeyParams<T extends string> extends BaseKeyParams {
+    params: DefinitionParams<T>;
+}
+type DefinitionParams<T extends string = string> = Record<T, BaseKeyParams | undefined>;
+interface BaseKeyParams {
+    key: string;
+    parse?: (value: string) => unknown;
+    stringify?: (value: unknown) => string;
+}
+interface PositionParams {
+    center?: [number, number];
+    zoom?: number;
+    rotation?: number;
+    projection?: string;
+}
+interface LayerProperties {
+    zIndex: number;
+    visibility: boolean;
+    type: ServiceType;
+    opacity: number;
+    parentId: string;
+}
+interface UrlParsedParam {
+    position: PositionParams;
+    layersOptions: LayerOptions[];
+    context: string;
+}
+type LayerParams = BaseLayerParams & {
+    index: number;
+    names: string;
+    type: string;
+    queryString?: string;
+};
+type GroupParams = BaseLayerParams & Pick<LayerGroupOptions, 'title' | 'id'> & {
+    expanded?: boolean;
+};
+type BaseLayerParams = Pick<LayerOptions, 'visible' | 'opacity' | 'zIndex' | 'parentId'>;
+interface ShareMapRouteKeysOptions extends RouteServiceOptions {
+    context: string;
+    urls: string;
+    position: string;
+    layers: string;
+    groups: string;
+    center: string;
+    zoom: string;
+    projection: string;
+    rotation: string;
+    opacity: string;
+}
+declare const SHARE_MAP_KEYS_DEFAULT_OPTIONS: ShareMapRouteKeysOptions;
+
+declare class ShareMapEncoder {
+    private SHARE_MAP_DEFS;
+    private document;
+    private context;
+    constructor(SHARE_MAP_DEFS: ShareMapKeysDefinitions, document: Document);
+    generateUrl(map: IgoMap, context: DetailedContext, publicShareOption: ShareOption, language: string | undefined): string;
+    /**
+     * Replaces local group IDs with unique IDs to avoid conflicts and have short URL.
+     * This is necessary for sharing the map context.
+     */
+    private replaceGroupLocalIds;
+    private getUniqueId;
+    private getCurrentContext;
+    /**
+     * Filters layers to include only LayerGroups or LayerItems with a valid ServiceType.
+     */
+    private isLayerSharable;
+    /**
+     * Extracts only LayerGroup items from the filtered layers.
+     */
+    private getLayerGroups;
+    /**
+     * Extracts only LayerItem items from the filtered layers.
+     */
+    private getLayerItems;
+    private buildQueryUrl;
+    /**
+     * Retrieves the current context layers and maps them by identifier.
+     */
+    private getContextLayersMap;
+    /**
+     * Filters layers and context layers based on visibility, opacity, and expanded state.
+     */
+    private getFilteredMapLayers;
+    private getIdsNestedParent;
+    private generateLayersOptionsByService;
+    private generateLayerOption;
+    private getLayerNames;
+    private getWmsVersion;
+    private concatUrlWithVersion;
+    private getLayerParams;
+    private getOpacity;
+    private getVisibility;
+    private getQueryString;
+    private buildLayersQueryUrl;
+    private stringifyLayerParams;
+    private getBaseUrlConfig;
+    private sanitizeBaseUrl;
+    private extractKeys;
+    private getPosition;
+    private getProjection;
+    private getZoom;
+    private getRotation;
+    private stringifyPosition;
+    private stringifyDefinitions;
+    private buildGroupsQueryUrl;
+    private getLayerGroupParams;
+    private stringifyGroupParams;
+}
+
+declare class ShareMapLegacyParser {
+    private options;
+    constructor(options: RouteServiceOptions);
+    parseUrl(params: Params): LayerOptions[] | undefined;
+    parsePosition(params: Params): PositionParams;
+    private readLayersQueryParamsByType;
+    private getQueryKeyByType;
+    private sanitizeUrl;
+    private getQueryParam;
+    private extractLayersByService;
+    private removeParenthesis;
+    private extractLayersOptions;
+    private computeLayerVisibilityFromUrl;
+}
+
+declare class ShareMapParser {
+    private keysDefinitions;
+    private legacyOptions;
+    legacy: ShareMapLegacyParser;
+    constructor(keysDefinitions: ShareMapKeysDefinitions, legacyOptions: RouteServiceOptions);
+    parseLayers(params: Params): AnyLayerOptions[] | undefined;
+    private splitParam;
+    parsePosition(params: Params): PositionParams | undefined;
+    private parseLayer;
+    private parseGroup;
+    private extractVersionFromUrl;
+    private extractUrlIndex;
+    private extractLayerNames;
+    private extractLayerProperties;
+}
+
+declare class ShareMapService {
+    routeService: RouteService;
+    document: Document;
+    private language;
+    options: ShareMapRouteKeysOptions;
+    optionsLegacy: RouteServiceOptions;
+    keysDefinitions: ShareMapKeysDefinitions;
+    encoder: ShareMapEncoder;
+    parser: ShareMapParser;
+    constructor();
+    getContext(params: Params): string | undefined;
+    getZoom(params: Params): number | undefined;
+    getUrlWithApi(formValues: any): string;
+    hasPositionParams(params: Params): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShareMapService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShareMapService>;
+}
+
+declare function buildDataSourceOptions(type: ServiceType, url: string, layers: string[], version: string): AnyDataSourceOptions;
+declare function getFlattenOptions(options: AnyLayerOptions[]): AnyLayerOptions[];
+/**
+ * Checks if the provided query parameters contain legacy parameter pairs
+ * (e.g., layers and URLs) that indicate older configuration formats.
+ */
+declare function hasLegacyParams(params: Params, optionsLegacy: RouteServiceOptions): boolean;
+declare function hasModernShareParams(params: Params, keysDefinitions: ShareMapKeysDefinitions): boolean;
+declare function getParamValue(params: Params, key: string): string | undefined;
+
+export { BookmarkButtonComponent, BookmarkDialogComponent, CONTEXT_MANAGER_DIRECTIVES, CONTEXT_MAP_BUTTON_DIRECTIVES, ContextEditBindingDirective, ContextEditComponent, ContextExportService, ContextFormComponent, ContextImportExportComponent, ContextImportService, ContextItemComponent, ContextListBindingDirective, ContextListComponent, ContextPermissionsBindingDirective, ContextPermissionsComponent, ContextService, ExportError, ExportInvalidFileError, ExportNothingToExportError, GroupParamsKeys, IgoContextImportExportModule, IgoContextManagerModule, IgoContextMapButtonModule, IgoContextModule, IgoShareMapModule, IgoSidenavModule, ImportError, ImportInvalidFileError, ImportNothingToImportError, ImportSRSError, ImportSizeError, ImportUnreadableFileError, LayerContextDirective, LayerParamsKeys, MapContextDirective, PoiButtonComponent, PoiDialogComponent, PoiService, SHARE_MAP_DIRECTIVES, SHARE_MAP_KEYS_DEFAULT_OPTIONS, Scope, ServiceType, ServiceTypeEnum, ShareMapApiComponent, ShareMapComponent, ShareMapLegacyParser, ShareMapService, ShareMapUrlComponent, SidenavComponent, TypePermission, UserButtonComponent, UserDialogComponent, addContextToContextList, addImportedFeaturesStyledToMap, addImportedFeaturesToMap, buildDataSourceOptions, computeLayerTitleFromFile, getFileExtension, getFlattenOptions, getParamValue, handleFileExportError, handleFileExportSuccess, handleFileImportError, handleFileImportSuccess, handleInvalidFileImportError, handleNothingToExportError, handleNothingToImportError, handleSizeFileImportError, handleUnreadbleFileImportError, hasLegacyParams, hasModernShareParams };
+export type { BaseKeyParams, Context, ContextExportOptions, ContextHomeExtent, ContextMap, ContextMapView, ContextPermission, ContextPermissionsList, ContextProfils, ContextServiceOptions, ContextUserPermission, ContextsList, DefinitionKeyParams, DefinitionParams, DetailedContext, EnvironmentOptions, ExtraFeatures, GroupParams, LayerParams, LayerProperties, Poi, PositionParams, ShareMapKeysDefinitions, ShareMapRouteKeysOptions, ShareOption, UrlParsedParam };