@provoly/dashboard 0.11.0

package/lib/core/store/image/image.effects.d.ts

@@ -0,0 +1,20 @@
+import { Actions } from '@ngrx/effects';
+import { ImageService } from './image.service';
+import * as i0 from "@angular/core";
+export declare class ImageEffects {
+    private actions$;
+    private imageService;
+    loadImages$: import("rxjs").Observable<({
+        images: import("./image.actions").Image[];
+    } & import("@ngrx/store/src/models").TypedAction<"[Image] Load Images Success">) | ({
+        error: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Image] Load Images Failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    addImages$: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[Image] Load Images"> | ({
+        error: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Image] Load Images Failure">) | ({
+        name: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Image] Added Image">)> & import("@ngrx/effects").CreateEffectMetadata;
+    constructor(actions$: Actions, imageService: ImageService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImageEffects>;
+}

package/lib/core/store/image/image.reducer.d.ts

@@ -0,0 +1,9 @@
+import { Image } from './image.actions';
+export declare const imageFeatureKey = "@pry/image";
+export interface ImageState {
+    loading: boolean;
+    list: Image[];
+    lastAdded?: string;
+}
+export declare const initialImageState: ImageState;
+export declare const imageReducer: import("@ngrx/store").ActionReducer<ImageState, import("@ngrx/store").Action>;

package/lib/core/store/image/image.selectors.d.ts

@@ -0,0 +1,7 @@
+import * as fromImage from './image.reducer';
+export declare const ImagesSelectors: {
+    feature: import("@ngrx/store").MemoizedSelector<object, fromImage.ImageState, import("@ngrx/store").DefaultProjectorFn<fromImage.ImageState>>;
+    images: import("@ngrx/store").MemoizedSelector<object, fromImage.ImageState, (s1: fromImage.ImageState) => fromImage.ImageState>;
+    imageWithFilter: (filter: string) => any;
+    lastAdded: import("@ngrx/store").MemoizedSelector<object, string | undefined, (s1: fromImage.ImageState) => string | undefined>;
+};

package/lib/core/store/image/image.service.d.ts

@@ -0,0 +1,29 @@
+import { HttpClient } from '@angular/common/http';
+import { DomSanitizer, SafeUrl } from '@angular/platform-browser';
+import { Store } from '@ngrx/store';
+import { Observable } from 'rxjs';
+import { PrySnackbarService } from '../../components/snackbar/snackbar.service';
+import { PryI18nService } from '../../i18n/i18n.service';
+import { Image } from './image.actions';
+import * as i0 from "@angular/core";
+export declare const INTERNALLY_STORED_IMAGE_PREFIX = "internal:";
+export declare enum LibraryTypes {
+    ILLUSTRATION = "illustration",
+    ICON = "icon"
+}
+export declare class ImageService {
+    private httpClient;
+    private store;
+    private domSanitizer;
+    private snackbar;
+    private translateService;
+    constructor(httpClient: HttpClient, store: Store<any>, domSanitizer: DomSanitizer, snackbar: PrySnackbarService, translateService: PryI18nService);
+    getImages(): Observable<Image[]>;
+    getImage(path: string): Observable<{
+        type: string;
+        url: SafeUrl;
+    }>;
+    upload(file: any, mediaType: string, type: string): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImageService>;
+}

package/lib/core/store/item/item.actions.d.ts

@@ -0,0 +1,18 @@
+import { Item } from '../../model/item.interface';
+export declare const ItemActions: {
+    create: import("@ngrx/store").ActionCreator<"[Item] create", (props: {
+        item: Item;
+    }) => {
+        item: Item;
+    } & import("@ngrx/store/src/models").TypedAction<"[Item] create">>;
+    createSuccess: import("@ngrx/store").ActionCreator<"[Item] create success", (props: {
+        id: string;
+    }) => {
+        id: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Item] create success">>;
+    createFailure: import("@ngrx/store").ActionCreator<"[Item] create failure", (props: {
+        error: any;
+    }) => {
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Item] create failure">>;
+};

package/lib/core/store/item/item.effects.d.ts

@@ -0,0 +1,27 @@
+import { Actions } from '@ngrx/effects';
+import { Store } from '@ngrx/store';
+import { PrySnackbarService } from '../../components/snackbar/snackbar.service';
+import { PryI18nService } from '../../i18n/i18n.service';
+import { ItemService } from './item.service';
+import * as i0 from "@angular/core";
+export declare class ItemEffects {
+    private actions$;
+    private service;
+    private store;
+    private snackBar;
+    private translateService;
+    create$: import("rxjs").Observable<({
+        item: import("@provoly/dashboard").Item;
+        resultSet?: string | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dashboard] (bus) add item to resultSet">) | ({
+        id: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Item] create success">) | ({
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Item] create failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    createSuccessWarning$: import("rxjs").Observable<{
+        id: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Item] create success">> & import("@ngrx/effects").CreateEffectMetadata;
+    constructor(actions$: Actions, service: ItemService, store: Store, snackBar: PrySnackbarService, translateService: PryI18nService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ItemEffects>;
+}

package/lib/core/store/item/item.service.d.ts

@@ -0,0 +1,28 @@
+import { HttpClient } from '@angular/common/http';
+import { Store } from '@ngrx/store';
+import { Observable } from 'rxjs';
+import { Item } from '../../model/item.interface';
+import { ResultSet } from '../../model/result-set.interface';
+import * as i0 from "@angular/core";
+export declare class ItemService {
+    private store;
+    private httpClient;
+    constructor(store: Store, httpClient: HttpClient);
+    /**
+     * Get item's detail by id
+     * @param id
+     */
+    get(id: string): Observable<Item>;
+    /**
+     * Returns all items connected by a relation to the node of this id
+     * @param id
+     */
+    proximity(id: string): Observable<ResultSet>;
+    /**
+     * Allows to create an item
+     * @param item
+     */
+    create(item: Item): Observable<Item[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ItemService>;
+}

package/lib/core/store/raw/raw.service.d.ts

@@ -0,0 +1,18 @@
+import { HttpClient } from '@angular/common/http';
+import { DomSanitizer, SafeUrl } from '@angular/platform-browser';
+import { Store } from '@ngrx/store';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class RawService {
+    private httpClient;
+    private store;
+    private domSanitizer;
+    constructor(httpClient: HttpClient, store: Store, domSanitizer: DomSanitizer);
+    get(itemId: string, attributeName: string): Observable<{
+        type: string;
+        url: SafeUrl;
+    }>;
+    upload(file: any, fileName: string, mimeType: string): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RawService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RawService>;
+}

package/lib/core/store/relation-types/relation-types.actions.d.ts

@@ -0,0 +1,65 @@
+import { RelationType } from './relation-types.interface';
+export declare const RelationTypesActions: {
+    load: import("@ngrx/store").ActionCreator<"[Relation Types] Load Relation Types", () => import("@ngrx/store/src/models").TypedAction<"[Relation Types] Load Relation Types">>;
+    loadSuccess: import("@ngrx/store").ActionCreator<"[Relation Types Api] Load Relation Types Success", (props: {
+        datas: RelationType[];
+    }) => {
+        datas: RelationType[];
+    } & import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Load Relation Types Success">>;
+    loadFailure: import("@ngrx/store").ActionCreator<"[Relation Types Api] Load Relation Types Failure", (props: {
+        error: any;
+    }) => {
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Load Relation Types Failure">>;
+    saveRelationType: import("@ngrx/store").ActionCreator<"[Relation Types] Save Relation Types", (props: {
+        id: string;
+        name: string;
+    }) => {
+        id: string;
+        name: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Relation Types] Save Relation Types">>;
+    saveRelationTypeSuccess: import("@ngrx/store").ActionCreator<"[Relation Types Api] Save Relation Types Success", () => import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Save Relation Types Success">>;
+    saveRelationTypeFailure: import("@ngrx/store").ActionCreator<"[Relation Types Api] Save Relation Types Failure", (props: {
+        error: any;
+    }) => {
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Save Relation Types Failure">>;
+    selectRelationType: import("@ngrx/store").ActionCreator<"[Relation Types] Select Relation Type", (props: {
+        id: string;
+    }) => {
+        id: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Relation Types] Select Relation Type">>;
+    unSelectRelationType: import("@ngrx/store").ActionCreator<"[Relation Types] UnSelect Relation Type", () => import("@ngrx/store/src/models").TypedAction<"[Relation Types] UnSelect Relation Type">>;
+    deleteRelationType: import("@ngrx/store").ActionCreator<"[Relation Types] Delete Relation Types", (props: {
+        relationType: RelationType;
+    }) => {
+        relationType: RelationType;
+    } & import("@ngrx/store/src/models").TypedAction<"[Relation Types] Delete Relation Types">>;
+    deleteRelationTypeSuccess: import("@ngrx/store").ActionCreator<"[Relation Types Api] Delete Relation Types Success", () => import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Delete Relation Types Success">>;
+    deleteRelationTypeFailure: import("@ngrx/store").ActionCreator<"[Relation Types Api] Delete Relation Types Failure", (props: {
+        error: any;
+    }) => {
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Delete Relation Types Failure">>;
+    createRelation: import("@ngrx/store").ActionCreator<"[Relation Types Api] Create Relation", (props: {
+        from: string[];
+        to: string;
+        typeId: string;
+        inversion: boolean;
+    }) => {
+        from: string[];
+        to: string;
+        typeId: string;
+        inversion: boolean;
+    } & import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Create Relation">>;
+    createRelationSuccess: import("@ngrx/store").ActionCreator<"[Relation Types Api] Create Relation success", () => import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Create Relation success">>;
+    createRelationFailure: import("@ngrx/store").ActionCreator<"[Relation Types Api] Create Relation failure", (props: {
+        error: any;
+    }) => {
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Create Relation failure">>;
+    openModal: import("@ngrx/store").ActionCreator<"[Relation Types] Open modal", () => import("@ngrx/store/src/models").TypedAction<"[Relation Types] Open modal">>;
+    closeModal: import("@ngrx/store").ActionCreator<"[Relation Types] Close modal", () => import("@ngrx/store/src/models").TypedAction<"[Relation Types] Close modal">>;
+    openDeleteModale: import("@ngrx/store").ActionCreator<"[Relation Types] Open delete modal", () => import("@ngrx/store/src/models").TypedAction<"[Relation Types] Open delete modal">>;
+    closeDeleteModale: import("@ngrx/store").ActionCreator<"[Relation Types] Close delete modal", () => import("@ngrx/store/src/models").TypedAction<"[Relation Types] Close delete modal">>;
+};

package/lib/core/store/relation-types/relation-types.effects.d.ts

@@ -0,0 +1,31 @@
+import { Router } from '@angular/router';
+import { Actions } from '@ngrx/effects';
+import { PryDialogService } from '../../components/overlay/dialog.service';
+import { RelationTypesService } from './relation-types.service';
+import * as i0 from "@angular/core";
+export declare class RelationTypesEffects {
+    private actions$;
+    private service;
+    private router;
+    private pryDialog;
+    loadRelationsTypes$: import("rxjs").Observable<({
+        datas: import("@provoly/dashboard").RelationType[];
+    } & import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Load Relation Types Success">) | ({
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Load Relation Types Failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    saveRelationType$: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Save Relation Types Success"> | ({
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Save Relation Types Failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    saveRelationTypeSuccess$: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[Relation Types] Load Relation Types">> & import("@ngrx/effects").CreateEffectMetadata;
+    deleteRelationType$: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Delete Relation Types Success"> | ({
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Delete Relation Types Failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    createRelation$: import("rxjs").Observable<({
+        relations: import("@provoly/dashboard").Relation[];
+    } & import("@ngrx/store/src/models").TypedAction<"[Dashboard] (bus) add relations to resultSet">) | import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Create Relation success"> | ({
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Relation Types Api] Create Relation failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    constructor(actions$: Actions, service: RelationTypesService, router: Router, pryDialog: PryDialogService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RelationTypesEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RelationTypesEffects>;
+}

package/lib/core/store/relation-types/relation-types.interface.d.ts

@@ -0,0 +1,8 @@
+export interface RelationType {
+    id: string;
+    name: string;
+    nbRelation: number;
+    nbLink: number;
+    modificationDate: string;
+    deletable: boolean;
+}

package/lib/core/store/relation-types/relation-types.reducer.d.ts

@@ -0,0 +1,11 @@
+import { RelationType } from './relation-types.interface';
+export declare const relationTypesFeatureKey = "@pry/relation-types";
+export interface RelationTypeState {
+    relationsTypes: RelationType[];
+    selectedRelationType?: RelationType;
+    loading: boolean;
+    openModal: boolean;
+    openDeleteModale: boolean;
+}
+export declare const initialRelationTypeState: RelationTypeState;
+export declare const relationTypeReducer: import("@ngrx/store").ActionReducer<RelationTypeState, import("@ngrx/store").Action>;

package/lib/core/store/relation-types/relation-types.selectors.d.ts

@@ -0,0 +1,8 @@
+import * as fromRelationTypes from './relation-types.reducer';
+export declare const RelationTypesSelectors: {
+    feature: import("@ngrx/store").MemoizedSelector<object, fromRelationTypes.RelationTypeState, import("@ngrx/store").DefaultProjectorFn<fromRelationTypes.RelationTypeState>>;
+    relationsTypes: import("@ngrx/store").MemoizedSelector<object, import("@provoly/dashboard").RelationType[], (s1: fromRelationTypes.RelationTypeState) => import("@provoly/dashboard").RelationType[]>;
+    selectedRelationType: import("@ngrx/store").MemoizedSelector<object, import("@provoly/dashboard").RelationType | undefined, (s1: fromRelationTypes.RelationTypeState) => import("@provoly/dashboard").RelationType | undefined>;
+    openModal: import("@ngrx/store").MemoizedSelector<object, boolean, (s1: fromRelationTypes.RelationTypeState) => boolean>;
+    openDeleteModale: import("@ngrx/store").MemoizedSelector<object, boolean, (s1: fromRelationTypes.RelationTypeState) => boolean>;
+};

package/lib/core/store/relation-types/relation-types.service.d.ts

@@ -0,0 +1,17 @@
+import { HttpClient } from '@angular/common/http';
+import { Store } from '@ngrx/store';
+import { Observable } from 'rxjs';
+import { Relation } from '../../model/relation.interface';
+import { RelationType } from './relation-types.interface';
+import * as i0 from "@angular/core";
+export declare class RelationTypesService {
+    private store;
+    private httpClient;
+    constructor(store: Store, httpClient: HttpClient);
+    addRelationType(id: string, name: string): Observable<void>;
+    getRelationsTypes(): Observable<RelationType[]>;
+    deleteRelationType(id: string): Observable<void>;
+    createRelation(sources: string[], destination: string, relationType: string, inversion: boolean): Observable<Relation[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RelationTypesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RelationTypesService>;
+}

package/lib/core/store/search/lat-lon-to-geographic-field-transformation.function.d.ts

@@ -0,0 +1,2 @@
+import { ResultSet } from '../../model/result-set.interface';
+export declare const latLonToGeographicFieldTransformation: (latAttrName: string, lonAttrName: string, locAttrName: string, datasetIds?: string[]) => (id: string, result: ResultSet) => ResultSet;

package/lib/core/store/search/search.actions.d.ts

@@ -0,0 +1,33 @@
+import { ResultSet } from '../../model/result-set.interface';
+import { MonoClassSearchPayload } from '../../model/search-mono-class.model';
+import { FullTextSearchPayload, MultiClassSearchPayload } from '../../model/search-multi-class.model';
+export declare const SearchActions: {
+    search: import("@ngrx/store").ActionCreator<"[Search] search", (props: {
+        payload: MonoClassSearchPayload | MultiClassSearchPayload | FullTextSearchPayload;
+        id?: string | undefined;
+    }) => {
+        payload: MonoClassSearchPayload | MultiClassSearchPayload | FullTextSearchPayload;
+        id?: string | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[Search] search">>;
+    getDatasourceItems: import("@ngrx/store").ActionCreator<"[Search] (bus) search named", (props: {
+        id: string;
+    }) => {
+        id: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Search] (bus) search named">>;
+    searchSuccess: import("@ngrx/store").ActionCreator<"[Search Api] Search Success", (props: {
+        resultSet: ResultSet;
+        id?: string | undefined;
+        params?: string | undefined;
+    }) => {
+        resultSet: ResultSet;
+        id?: string | undefined;
+        params?: string | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[Search Api] Search Success">>;
+    searchFailure: import("@ngrx/store").ActionCreator<"[Search Api] Search Failure", (props: {
+        error: any;
+        id?: string | undefined;
+    }) => {
+        error: any;
+        id?: string | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[Search Api] Search Failure">>;
+};

package/lib/core/store/search/search.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_NAMED_QUERY_ID = "007";
+export declare const EXPLORE_NAMED_QUERY_ID = "008";

package/lib/core/store/search/search.effects.d.ts

@@ -0,0 +1,33 @@
+import { Actions } from '@ngrx/effects';
+import { Store } from '@ngrx/store';
+import { SearchService } from './search.service';
+import * as i0 from "@angular/core";
+export declare class SearchEffects {
+    private actions$;
+    private searchService;
+    private store;
+    constructor(actions$: Actions, searchService: SearchService, store: Store);
+    searchNamed$: import("rxjs").Observable<({
+        resultSet: import("@provoly/dashboard").ResultSet;
+        id?: string | undefined;
+        params?: string | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[Search Api] Search Success">) | ({
+        error: any;
+        id?: string | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[Search Api] Search Failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    search$: import("rxjs").Observable<({
+        resultSet: import("@provoly/dashboard").ResultSet;
+        id?: string | undefined;
+        params?: string | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[Search Api] Search Success">) | ({
+        error: any;
+        id?: string | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[Search Api] Search Failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    searchSuccess$: import("rxjs").Observable<{
+        id: string;
+        resultSet: import("@provoly/dashboard").ResultSet;
+        params?: string | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dashboard] (bus) received named resultSet">> & import("@ngrx/effects").CreateEffectMetadata;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchEffects>;
+}

package/lib/core/store/search/search.reducer.d.ts

@@ -0,0 +1,10 @@
+import { MonoClassSearchPayload } from '../../model/search-mono-class.model';
+import { FullTextSearchPayload, MultiClassSearchPayload } from '../../model/search-multi-class.model';
+export declare const searchFeatureKey = "@pry/search";
+export interface SearchState {
+    searchLoading: string[];
+    payload?: MonoClassSearchPayload | MultiClassSearchPayload | FullTextSearchPayload;
+    id?: string;
+}
+export declare const initialSearchState: SearchState;
+export declare const searchReducer: import("@ngrx/store").ActionReducer<SearchState, import("@ngrx/store").Action>;

package/lib/core/store/search/search.selectors.d.ts

@@ -0,0 +1,5 @@
+import * as fromSearch from './search.reducer';
+export declare const SearchSelectors: {
+    feature: import("@ngrx/store").MemoizedSelector<object, fromSearch.SearchState, import("@ngrx/store").DefaultProjectorFn<fromSearch.SearchState>>;
+    searchLoading: import("@ngrx/store").MemoizedSelector<object, string[], (s1: fromSearch.SearchState) => string[]>;
+};

package/lib/core/store/search/search.service.d.ts

@@ -0,0 +1,50 @@
+import { HttpClient } from '@angular/common/http';
+import { Store } from '@ngrx/store';
+import { Observable } from 'rxjs';
+import { FilterContext } from '../../model/filter.interface';
+import { ResultOrder } from '../../model/result-order.interface';
+import { ResultSet } from '../../model/result-set.interface';
+import { MonoClassSearchPayload } from '../../model/search-mono-class.model';
+import { FullTextSearchPayload, MultiClassSearchPayload } from '../../model/search-multi-class.model';
+import { ConfigState } from '../config/config.reducer';
+import { SearchState } from './search.reducer';
+import * as i0 from "@angular/core";
+export type ResultsetTransformation = (id: string, result: ResultSet) => ResultSet;
+export declare class SearchService {
+    private httpClient;
+    private store;
+    transformations: ResultsetTransformation[];
+    filters: {
+        [datasource: string]: FilterContext[];
+    };
+    constructor(httpClient: HttpClient, store: Store<ConfigState | SearchState>);
+    /**
+     * Request the result of a named query by its id
+     * @param id of the data source to fetch
+     * @param quickOrder if it has to be applied
+     */
+    getItems(id: string, quickOrder?: ResultOrder): Observable<ResultSet>;
+    getItemsSerializedParams(id: string, quickOrder: any): string;
+    getItemsFilter(id: string): string;
+    getItemsParams(quickOrder: ResultOrder | undefined): {
+        [key: string]: string;
+    };
+    /**
+     * Launch a search request (and saves it as current search)
+     * @param condition
+     */
+    search(condition: MonoClassSearchPayload | MultiClassSearchPayload | FullTextSearchPayload): Observable<ResultSet>;
+    /**
+     * Allows to add a transformation function when getting results from backend
+     * @param func
+     */
+    addTransformation(func: ResultsetTransformation): void;
+    /**
+     * Apply all transformation functions
+     * @param id
+     * @param rs
+     */
+    applyTransformations(id: string, rs: ResultSet): ResultSet;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchService>;
+}

package/lib/core/symbol/symbol.service.d.ts

@@ -0,0 +1,27 @@
+import { HttpClient } from '@angular/common/http';
+import { DomSanitizer, SafeUrl } from '@angular/platform-browser';
+import { Store } from '@ngrx/store';
+import { Style } from 'ol/style';
+import { Item } from '../model/item.interface';
+import { ImageService } from '../store/image/image.service';
+import * as i0 from "@angular/core";
+export declare class SymbolService {
+    private httpClient;
+    private store;
+    private sanitizer;
+    private imageService;
+    private definitions;
+    private classes;
+    constructor(httpClient: HttpClient, store: Store<any>, sanitizer: DomSanitizer, imageService: ImageService);
+    getSymbol(item: Item, borderColor?: string): Promise<HTMLCanvasElement>;
+    getSymbolOfClass(id: string): Promise<SafeUrl>;
+    downloadAsUrl(url: string): Promise<string>;
+    getSymbolAsIconStyle(item: Item, borderColor?: string): Promise<Style>;
+    cache: {
+        [url: string]: Promise<HTMLImageElement>;
+    };
+    downloadImage(url: string): Promise<HTMLImageElement>;
+    private matchRule;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SymbolService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SymbolService>;
+}

package/lib/core/toolbox/toolbox-manifest.service.d.ts

@@ -0,0 +1,21 @@
+import { Store } from '@ngrx/store';
+import { BehaviorSubject } from 'rxjs';
+import { SubscriptionnerDirective } from '../../dashboard/components/subscriptionner.directive';
+import { WidgetLayout, WidgetManifest } from '../model/manifest.interface';
+import * as i0 from "@angular/core";
+export declare const USE_CURRENT_RESULTSET = "use-current-resultset";
+export declare class ToolboxManifestService extends SubscriptionnerDirective {
+    private store;
+    initialManifests$: BehaviorSubject<{
+        [key: string]: WidgetManifest;
+    }>;
+    currentResultSet: string[];
+    constructor(store: Store<any>);
+    get(id: string, instanciate?: boolean): WidgetManifest;
+    set(id: string, manifest: WidgetManifest): void;
+    setAllLayouts(layout: WidgetLayout): void;
+    isModel(id: string): boolean;
+    dataTransfer($event: DragEvent, id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolboxManifestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToolboxManifestService>;
+}

package/lib/core/toolbox/toolbox-menu.service.d.ts

@@ -0,0 +1,45 @@
+import { Store } from '@ngrx/store';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { WidgetFactoryService } from '../../dashboard/components/widgets/widget-instanciator/widget-factory.service';
+import { PryVisibility } from '../components/share/share.model';
+import { Widget } from '../model/widget.interface';
+import { ToolboxManifestService } from './toolbox-manifest.service';
+import * as i0 from "@angular/core";
+export type WidgetDescriptionBase = {
+    icon: string;
+    label: string;
+};
+export type WidgetDescriptionMenu = WidgetDescriptionBase & {
+    opened: boolean;
+    sub: CatalogEntry[];
+};
+export type CatalogEntry = WidgetDescriptionBase & {
+    category?: string;
+    type: string;
+    description?: string;
+    isCustom?: boolean;
+    visibility?: PryVisibility;
+    cover?: boolean;
+};
+export declare const defaultMenuStructure: WidgetDescriptionMenu[];
+export declare class ToolboxMenuService {
+    private widgetFactoryService;
+    private toolboxManifestService;
+    private store;
+    _menuStructure$: BehaviorSubject<WidgetDescriptionMenu[]>;
+    menuStructure$: Observable<WidgetDescriptionMenu[]>;
+    menuList$: Observable<CatalogEntry[]>;
+    types$: Observable<{
+        icon: string;
+        label: string;
+        type: string;
+    }[]>;
+    constructor(widgetFactoryService: WidgetFactoryService, toolboxManifestService: ToolboxManifestService, store: Store);
+    addMenu(icon: string, label: string): void;
+    addWidget(menuLabel: string, icon: string, label: string, type: string): void;
+    setMenuStructure(structure: WidgetDescriptionMenu[]): void;
+    addToCatalog(widget: Widget, index: number): void;
+    isValidForCatalog(name: string): false;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolboxMenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToolboxMenuService>;
+}

package/lib/core/ws/websocket.service.d.ts

@@ -0,0 +1,26 @@
+import { Store } from '@ngrx/store';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export type wsMessage = {
+    type: string;
+    payload: any;
+    id: string;
+};
+export declare class WebsocketService {
+    private store;
+    private websocket?;
+    private _messages$;
+    private url?;
+    private delay;
+    private active;
+    private currentRetry;
+    constructor(store: Store<any>);
+    connect(currentDelay?: number): void;
+    sendMessage(type: string, payload: any): void;
+    messages$(type: string): Observable<wsMessage>;
+    retry(): void;
+    toggleActive(active?: boolean): void;
+    disconnect(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebsocketService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebsocketService>;
+}

package/lib/dashboard/action-bus/bus-action.interface.d.ts

@@ -0,0 +1,4 @@
+import { Action } from '@ngrx/store';
+export interface BusAction extends Action {
+    sender: string;
+}

package/lib/dashboard/action-bus/effect/action-bus.effects.d.ts

@@ -0,0 +1,13 @@
+import { Actions } from '@ngrx/effects';
+import { Store } from '@ngrx/store';
+import { BusService } from '../service/bus.service';
+import * as i0 from "@angular/core";
+export declare class ActionBusEffects {
+    private actions$;
+    private store;
+    private busService;
+    forwardOnBus$: import("rxjs").Observable<import("@ngrx/store").Action> & import("@ngrx/effects").CreateEffectMetadata;
+    constructor(actions$: Actions, store: Store<any>, busService: BusService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionBusEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActionBusEffects>;
+}

package/lib/dashboard/action-bus/service/bus.service.d.ts

@@ -0,0 +1,22 @@
+import { NgZone } from '@angular/core';
+import { Action, Store } from '@ngrx/store';
+import { TypedAction } from '@ngrx/store/src/models';
+import { BusAction } from '../bus-action.interface';
+import { ControlMessage, ControlMessageType } from './control-message.interface';
+import * as i0 from "@angular/core";
+export declare class BusService {
+    private store;
+    private zone;
+    sender: string;
+    dataChannel: BroadcastChannel;
+    controlChannel: BroadcastChannel;
+    buffer: Action[];
+    constructor(store: Store<any>, zone: NgZone);
+    postData(action: BusAction | Action, target?: string): void;
+    postControl(type: ControlMessageType, data: any): void;
+    manageControlMessage(msg: ControlMessage): void;
+    bufferUntilJoined(action: TypedAction<any>): void;
+    relaseBufferedActions(sender: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BusService>;
+}