@provoly/dashboard 0.11.0

package/lib/core/store/data-source/data-source.actions.d.ts

@@ -0,0 +1,238 @@
+import { PryVisibility } from '../../components/share/share.model';
+import { Dataset, DatasetError } from '../../model/dataset.interface';
+import { MonoClassSearchPayload } from '../../model/search-mono-class.model';
+import { FullTextSearchPayload, MultiClassSearchPayload } from '../../model/search-multi-class.model';
+import { DatasetVersion, NamedQuery } from './data-source.model';
+export declare const DataSourceActions: {
+    load: import("@ngrx/store").ActionCreator<"[Datasource] load", () => import("@ngrx/store/src/models").TypedAction<"[Datasource] load">>;
+    namedQuery: {
+        load: import("@ngrx/store").ActionCreator<"[NamedQuery] load", () => import("@ngrx/store/src/models").TypedAction<"[NamedQuery] load">>;
+        loaded: import("@ngrx/store").ActionCreator<"[NamedQuery] loaded", (props: {
+            list: NamedQuery[];
+        }) => {
+            list: NamedQuery[];
+        } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] loaded">>;
+        failure: import("@ngrx/store").ActionCreator<"[NamedQuery] failure", (props: {
+            error: Error;
+        }) => {
+            error: Error;
+        } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] failure">>;
+        post: import("@ngrx/store").ActionCreator<"[NamedQuery] post", (props: {
+            name: string;
+            id?: string | undefined;
+            description?: string | undefined;
+            visibility?: PryVisibility | undefined;
+            payload: MonoClassSearchPayload | MultiClassSearchPayload | FullTextSearchPayload;
+            color?: string | undefined;
+            favorite: boolean;
+            isEdit: boolean;
+        }) => {
+            name: string;
+            id?: string | undefined;
+            description?: string | undefined;
+            visibility?: PryVisibility | undefined;
+            payload: MonoClassSearchPayload | MultiClassSearchPayload | FullTextSearchPayload;
+            color?: string | undefined;
+            favorite: boolean;
+            isEdit: boolean;
+        } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] post">>;
+        delete: import("@ngrx/store").ActionCreator<"[NamedQuery] delete", (props: {
+            id: string;
+        }) => {
+            id: string;
+        } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] delete">>;
+        addFavorite: import("@ngrx/store").ActionCreator<"[NamedQuery] add favorite", (props: {
+            id: string;
+        }) => {
+            id: string;
+        } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] add favorite">>;
+        deleteFavorite: import("@ngrx/store").ActionCreator<"[NamedQuery] delete favorite", (props: {
+            id: string;
+        }) => {
+            id: string;
+        } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] delete favorite">>;
+        edit: import("@ngrx/store").ActionCreator<"[NamedQuery] try to edit", (props: {
+            currentEdit: NamedQuery;
+            widgetIndex?: number | undefined;
+        }) => {
+            currentEdit: NamedQuery;
+            widgetIndex?: number | undefined;
+        } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] try to edit">>;
+        updateCurrentEdit: import("@ngrx/store").ActionCreator<"[NamedQuery] update edited named query", (props: {
+            currentEdit: Partial<NamedQuery>;
+        }) => {
+            currentEdit: Partial<NamedQuery>;
+        } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] update edited named query">>;
+        openEdit: import("@ngrx/store").ActionCreator<"[NamedQuery] edit", (props: {
+            currentEdit: NamedQuery;
+            widgetIndex?: number | undefined;
+        }) => {
+            currentEdit: NamedQuery;
+            widgetIndex?: number | undefined;
+        } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] edit">>;
+        stopEdit: import("@ngrx/store").ActionCreator<"[NamedQuery] delete edit", () => import("@ngrx/store/src/models").TypedAction<"[NamedQuery] delete edit">>;
+        openRename: import("@ngrx/store").ActionCreator<"[NamedQuery] rename", () => import("@ngrx/store/src/models").TypedAction<"[NamedQuery] rename">>;
+        stopRename: import("@ngrx/store").ActionCreator<"[NamedQuery] stop rename", () => import("@ngrx/store/src/models").TypedAction<"[NamedQuery] stop rename">>;
+    };
+    dataset: {
+        confirmDataSourceDeletion: import("@ngrx/store").ActionCreator<"[Datase] confirm deletion datasource", (props: {
+            name: string;
+            route: string;
+            addRoute: string;
+        }) => {
+            name: string;
+            route: string;
+            addRoute: string;
+        } & import("@ngrx/store/src/models").TypedAction<"[Datase] confirm deletion datasource">>;
+        loadDataset: import("@ngrx/store").ActionCreator<"[Dataset] load datasets", () => import("@ngrx/store/src/models").TypedAction<"[Dataset] load datasets">>;
+        loadedDataset: import("@ngrx/store").ActionCreator<"[Dataset] loaded datasets", (props: {
+            datasets: Dataset[];
+        }) => {
+            datasets: Dataset[];
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] loaded datasets">>;
+        failure: import("@ngrx/store").ActionCreator<"[Dataset] failure effect Dataset", (props: {
+            error: any;
+        }) => {
+            error: any;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] failure effect Dataset">>;
+        create: import("@ngrx/store").ActionCreator<"[Dataset] create Dataset", (props: {
+            dataset: Dataset;
+            route: string;
+        }) => {
+            dataset: Dataset;
+            route: string;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] create Dataset">>;
+        created: import("@ngrx/store").ActionCreator<"[Dataset] Datadef is created call to admin", (props: {
+            path: string;
+            params?: {
+                [p: string]: string;
+            } | undefined;
+        }) => {
+            path: string;
+            params?: {
+                [p: string]: string;
+            } | undefined;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Datadef is created call to admin">>;
+        update: import("@ngrx/store").ActionCreator<"[Dataset] update Dataset", (props: {
+            dataset: Dataset;
+            route: string;
+        }) => {
+            dataset: Dataset;
+            route: string;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] update Dataset">>;
+        updated: import("@ngrx/store").ActionCreator<"[Dataset] Dataset is updated call to admin", (props: {
+            path: string;
+            params?: {
+                [p: string]: string;
+            } | undefined;
+        }) => {
+            path: string;
+            params?: {
+                [p: string]: string;
+            } | undefined;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Dataset is updated call to admin">>;
+        delete: import("@ngrx/store").ActionCreator<"[Dataset] delete Dataset", (props: {
+            name: string;
+            route: string;
+            addRoute: string;
+        }) => {
+            name: string;
+            route: string;
+            addRoute: string;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] delete Dataset">>;
+        deleted: import("@ngrx/store").ActionCreator<"[Dataset] Dataset is deleted call to admin", (props: {
+            addRoute: string;
+        }) => {
+            addRoute: string;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Dataset is deleted call to admin">>;
+        unselectDataset: import("@ngrx/store").ActionCreator<"[Dataset] unselect Dataset", () => import("@ngrx/store/src/models").TypedAction<"[Dataset] unselect Dataset">>;
+        selectDataset: import("@ngrx/store").ActionCreator<"[Dataset] open Dataset details", (props: {
+            dataset: Dataset;
+        }) => {
+            dataset: Dataset;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] open Dataset details">>;
+        getDatasetById: import("@ngrx/store").ActionCreator<"[Dataset] Get Dataset by ID", (props: {
+            id: string;
+        }) => {
+            id: string;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Get Dataset by ID">>;
+        getDatasetByIdSuccess: import("@ngrx/store").ActionCreator<"[Dataset] Get Dataset by Id Success", (props: {
+            data: Dataset;
+        }) => {
+            data: Dataset;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Get Dataset by Id Success">>;
+        getDatasetByIdFailure: import("@ngrx/store").ActionCreator<"[Dataset] Get Dataset by Id Failure", (props: {
+            error: any;
+        }) => {
+            error: any;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Get Dataset by Id Failure">>;
+        openNewDataset: import("@ngrx/store").ActionCreator<"[Dataset] open new Dataset", (props: {
+            route: string;
+        }) => {
+            route: string;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] open new Dataset">>;
+        listVersions: import("@ngrx/store").ActionCreator<"[Dataset] Get Dataset versions", () => import("@ngrx/store/src/models").TypedAction<"[Dataset] Get Dataset versions">>;
+        listVersionsSuccess: import("@ngrx/store").ActionCreator<"[Dataset] Get Dataset versions Success", (props: {
+            versions: DatasetVersion[];
+        }) => {
+            versions: DatasetVersion[];
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Get Dataset versions Success">>;
+        listVersionsFailure: import("@ngrx/store").ActionCreator<"[Dataset] Get Dataset versions Failure", () => import("@ngrx/store/src/models").TypedAction<"[Dataset] Get Dataset versions Failure">>;
+        selectedDatasetVersion: import("@ngrx/store").ActionCreator<"[Dataset] Select Dataset version", (props: {
+            version: DatasetVersion;
+        }) => {
+            version: DatasetVersion;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Select Dataset version">>;
+        deactivateDatasetVersion: import("@ngrx/store").ActionCreator<"[Dataset] Deactivate dataset version", (props: {
+            datasetId: string;
+            versionId: string;
+        }) => {
+            datasetId: string;
+            versionId: string;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Deactivate dataset version">>;
+        deactivateDatasetVersionSuccess: import("@ngrx/store").ActionCreator<"[Dataset] Deactivate dataset version success", (props: {
+            datasetVersion: DatasetVersion;
+        }) => {
+            datasetVersion: DatasetVersion;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Deactivate dataset version success">>;
+        deactivateDatasetVersionFailure: import("@ngrx/store").ActionCreator<"[Dataset] Deactivate dataset version failure", (props: {
+            error: any;
+        }) => {
+            error: any;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Deactivate dataset version failure">>;
+        activateDatasetVersion: import("@ngrx/store").ActionCreator<"[Dataset] Activate dataset version", (props: {
+            datasetId: string;
+            versionId: string;
+        }) => {
+            datasetId: string;
+            versionId: string;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Activate dataset version">>;
+        activateDatasetVersionSuccess: import("@ngrx/store").ActionCreator<"[Dataset] Activate dataset version success", (props: {
+            datasetVersion: DatasetVersion;
+        }) => {
+            datasetVersion: DatasetVersion;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Activate dataset version success">>;
+        activateDatasetVersionFailure: import("@ngrx/store").ActionCreator<"[Dataset] Activate dataset version failure", (props: {
+            error: any;
+        }) => {
+            error: any;
+        } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Activate dataset version failure">>;
+        errors: {
+            getById: import("@ngrx/store").ActionCreator<"[Dataset.errors] get by id", (props: {
+                id: string;
+            }) => {
+                id: string;
+            } & import("@ngrx/store/src/models").TypedAction<"[Dataset.errors] get by id">>;
+            getByIdSuccess: import("@ngrx/store").ActionCreator<"[Dataset.errors] get by id Success", (props: {
+                errors: DatasetError[];
+            }) => {
+                errors: DatasetError[];
+            } & import("@ngrx/store/src/models").TypedAction<"[Dataset.errors] get by id Success">>;
+            getByIdFailure: import("@ngrx/store").ActionCreator<"[Dataset.errors] get by id Failure", (props: {
+                error: any;
+            }) => {
+                error: any;
+            } & import("@ngrx/store/src/models").TypedAction<"[Dataset.errors] get by id Failure">>;
+        };
+    };
+};

package/lib/core/store/data-source/data-source.effects.d.ts

@@ -0,0 +1,106 @@
+import { Actions } from '@ngrx/effects';
+import { Action, Store } from '@ngrx/store';
+import { PryDialogService } from '../../components/overlay/dialog.service';
+import { PrySnackbarService } from '../../components/snackbar/snackbar.service';
+import { PryI18nService } from '../../i18n/i18n.service';
+import { Dataset } from '../../model/dataset.interface';
+import { SearchService } from '../search/search.service';
+import { NamedQuery } from './data-source.model';
+import { DataSourceService } from './data-source.service';
+import * as i0 from "@angular/core";
+export declare class DataSourceEffects {
+    private actions$;
+    private searchService;
+    private dataSourceService;
+    private snackBar;
+    private translate;
+    private store;
+    private pryDialog;
+    private idNamedQuery?;
+    constructor(actions$: Actions, searchService: SearchService, dataSourceService: DataSourceService, snackBar: PrySnackbarService, translate: PryI18nService, store: Store, pryDialog: PryDialogService);
+    postNameQuery$: import("rxjs").Observable<Action | ({
+        error: Error;
+    } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    getNamedQuery$: import("rxjs").Observable<({
+        list: NamedQuery[];
+    } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] loaded">) | ({
+        error: Error;
+    } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    loaded$: import("rxjs").Observable<{
+        names: string[];
+    } & import("@ngrx/store/src/models").TypedAction<"[Dashboard] (bus) set available rs names">> & import("@ngrx/effects").CreateEffectMetadata;
+    deleteNamedQuery$: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[NamedQuery] load"> | ({
+        error: Error;
+    } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    addFavoriteNamedQuery$: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[NamedQuery] load"> | ({
+        error: Error;
+    } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    deleteFavoriteNamedQuery$: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[NamedQuery] load"> | ({
+        error: Error;
+    } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    tryEdit$: import("rxjs").Observable<({
+        error: Error;
+    } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] failure">) | ({
+        currentEdit: NamedQuery;
+        widgetIndex?: number | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] edit">)> & import("@ngrx/effects").CreateEffectMetadata;
+    updateWidgetAfterSave$: import("rxjs").Observable<{
+        manifest: import("@provoly/dashboard").WidgetManifest;
+        index: number;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dashboard] updating widget view">> & import("@ngrx/effects").CreateEffectMetadata;
+    loadedDataset$: import("rxjs").Observable<{
+        datasets: Dataset[];
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset] loaded datasets">> & import("@ngrx/effects").CreateEffectMetadata;
+    loadDataset$: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[NamedQuery] load"> | import("@ngrx/store/src/models").TypedAction<"[Dataset] load datasets">> & import("@ngrx/effects").CreateEffectMetadata;
+    createDataset$: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[Dataset] load datasets"> | import("@ngrx/store/src/models").TypedAction<"[Dataset] unselect Dataset"> | ({
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset] failure effect Dataset">) | ({
+        path: string;
+        params?: {
+            [p: string]: string;
+        } | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Datadef is created call to admin">)> & import("@ngrx/effects").CreateEffectMetadata;
+    updateDataset$: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[Dataset] load datasets"> | import("@ngrx/store/src/models").TypedAction<"[Dataset] unselect Dataset"> | ({
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset] failure effect Dataset">) | ({
+        path: string;
+        params?: {
+            [p: string]: string;
+        } | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Dataset is updated call to admin">)> & import("@ngrx/effects").CreateEffectMetadata;
+    deleteDataset$: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[Dataset] load datasets"> | import("@ngrx/store/src/models").TypedAction<"[Dataset] unselect Dataset"> | ({
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset] failure effect Dataset">) | ({
+        addRoute: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Dataset is deleted call to admin">)> & import("@ngrx/effects").CreateEffectMetadata;
+    getDatasetById$: import("rxjs").Observable<({
+        data: Dataset;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Get Dataset by Id Success">) | ({
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Get Dataset by Id Failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    listVersions$: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[Dataset] Get Dataset versions Failure"> | ({
+        versions: import("./data-source.model").DatasetVersion[];
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Get Dataset versions Success">)> & import("@ngrx/effects").CreateEffectMetadata;
+    confirmDatasourceDeletion$: import("rxjs").Observable<{
+        name: string;
+        route: string;
+        addRoute: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Datase] confirm deletion datasource">> & import("@ngrx/effects").CreateEffectMetadata;
+    deactivateDatasetVersion$: import("rxjs").Observable<({
+        datasetVersion: import("./data-source.model").DatasetVersion;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Deactivate dataset version success">) | ({
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Deactivate dataset version failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    activateDatasetVersion$: import("rxjs").Observable<({
+        datasetVersion: import("./data-source.model").DatasetVersion;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Activate dataset version success">) | ({
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset] Activate dataset version failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    errorsGetById$: import("rxjs").Observable<({
+        errors: import("../../model/dataset.interface").DatasetError[];
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset.errors] get by id Success">) | ({
+        error: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[Dataset.errors] get by id Failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataSourceEffects>;
+}

package/lib/core/store/data-source/data-source.model.d.ts

@@ -0,0 +1,32 @@
+import { PryVisibility } from '../../components/share/share.model';
+import { DatasetMetadata } from '../../model/admin-api.model';
+import { Dataset } from '../../model/dataset.interface';
+import { MonoClassSearchPayload } from '../../model/search-mono-class.model';
+import { FullTextSearchPayload, MultiClassSearchPayload } from '../../model/search-multi-class.model';
+export type DataSource = NamedQuery | Dataset;
+export interface NamedQuery extends DescriptionQuery {
+    sourceType: 'namedQuery';
+    id: string;
+    request: MonoClassSearchPayload | MultiClassSearchPayload | FullTextSearchPayload;
+    color?: string;
+    favorite?: boolean;
+    lastExecutionDate?: Date;
+    owner?: boolean;
+}
+export interface DescriptionQuery {
+    name: string;
+    description?: string;
+    visibility?: PryVisibility;
+    metadata?: DatasetMetadata[];
+}
+export interface DatasetVersion {
+    id: string;
+    dataset: string;
+    oClass: string;
+    lastModified: string;
+    available: boolean;
+    version: number;
+    state: string;
+    withFile: boolean;
+    metadata: any[];
+}

package/lib/core/store/data-source/data-source.reducer.d.ts

@@ -0,0 +1,21 @@
+import { Dataset, DatasetError } from '../../model/dataset.interface';
+import { DatasetVersion, NamedQuery } from './data-source.model';
+export declare const dataSourceFeatureKey = "@pry/datasources";
+export interface DataSourceState {
+    isLoading: boolean;
+    list: NamedQuery[];
+    currentEdit?: NamedQuery;
+    fromWidget?: {
+        widgetIndex: number;
+        editedQuery: string;
+    };
+    isRename: boolean;
+    datasets: Dataset[];
+    selectedDataset: Dataset | null;
+    error?: Error;
+    datasetVersions: DatasetVersion[];
+    selectedDatasetVersion: DatasetVersion | null;
+    errors: DatasetError[];
+}
+export declare const initialDataSourceState: DataSourceState;
+export declare const dataSourceReducer: import("@ngrx/store").ActionReducer<DataSourceState, import("@ngrx/store").Action>;

package/lib/core/store/data-source/data-source.selectors.d.ts

@@ -0,0 +1,31 @@
+import { MemoizedSelector } from '@ngrx/store';
+import { DatasetVersion, DataSource } from './data-source.model';
+import { DataSourceState } from './data-source.reducer';
+export declare const DataSourceSelectors: {
+    selectFeature: MemoizedSelector<object, DataSourceState, import("@ngrx/store").DefaultProjectorFn<DataSourceState>>;
+    getNamedQuery: MemoizedSelector<object, DataSourceState, (s1: DataSourceState) => DataSourceState>;
+    getAllNamedQuery: MemoizedSelector<object, import("./data-source.model").NamedQuery[], (s1: DataSourceState) => import("./data-source.model").NamedQuery[]>;
+    getNamedQuerySorted: MemoizedSelector<object, import("./data-source.model").NamedQuery[], (s1: DataSourceState) => import("./data-source.model").NamedQuery[]>;
+    editInProgress: MemoizedSelector<object, boolean, (s1: DataSourceState) => boolean>;
+    currentEditType: MemoizedSelector<object, import("@provoly/dashboard").NamedQueryTypes | undefined, (s1: DataSourceState) => import("@provoly/dashboard").NamedQueryTypes | undefined>;
+    currentEdit: MemoizedSelector<object, import("./data-source.model").NamedQuery | undefined, (s1: DataSourceState) => import("./data-source.model").NamedQuery | undefined>;
+    isRename: MemoizedSelector<object, boolean, (s1: DataSourceState) => boolean>;
+    editFromWidget: MemoizedSelector<object, {
+        widgetIndex: number;
+        editedQuery: string;
+    } | undefined, (s1: DataSourceState) => {
+        widgetIndex: number;
+        editedQuery: string;
+    } | undefined>;
+    datasets: MemoizedSelector<object, import("@provoly/dashboard").Dataset[], (s1: DataSourceState) => import("@provoly/dashboard").Dataset[]>;
+    errors: MemoizedSelector<object, Error | undefined, (s1: DataSourceState) => Error | undefined>;
+    isLoading: MemoizedSelector<object, boolean, (s1: DataSourceState) => boolean>;
+    getDataSources: MemoizedSelector<object, DataSource[], (s1: import("./data-source.model").NamedQuery[], s2: import("@provoly/dashboard").Dataset[]) => DataSource[]>;
+    getDataSourcesSorted: MemoizedSelector<object, DataSource[], (s1: import("./data-source.model").NamedQuery[], s2: import("@provoly/dashboard").Dataset[]) => DataSource[]>;
+    selectedDataset: MemoizedSelector<object, import("@provoly/dashboard").Dataset | null, (s1: DataSourceState) => import("@provoly/dashboard").Dataset | null>;
+    selectedDatasetMetadata: MemoizedSelector<object, import("@provoly/dashboard").DatasetMetadata[], (s1: DataSourceState) => import("@provoly/dashboard").DatasetMetadata[]>;
+    datasetVersions: MemoizedSelector<object, DatasetVersion[], (s1: DataSourceState) => DatasetVersion[]>;
+    selectedDatasetId: MemoizedSelector<object, string | undefined, (s1: DataSourceState) => string | undefined>;
+    matchingDatasetVersions: (datasetId: string) => MemoizedSelector<any, DatasetVersion[], import("@ngrx/store").DefaultProjectorFn<DatasetVersion[]>>;
+    datasetErrors: MemoizedSelector<object, import("@provoly/dashboard").DatasetError[], (s1: DataSourceState) => import("@provoly/dashboard").DatasetError[]>;
+};

package/lib/core/store/data-source/data-source.service.d.ts

@@ -0,0 +1,40 @@
+import { HttpClient } from '@angular/common/http';
+import { Store } from '@ngrx/store';
+import { Observable } from 'rxjs';
+import { PryI18nService } from '../../i18n/i18n.service';
+import { DatasetMetadata } from '../../model/admin-api.model';
+import { Dataset, DatasetError } from '../../model/dataset.interface';
+import { ConfigState } from '../config/config.reducer';
+import { DatasetVersion, NamedQuery } from './data-source.model';
+import { DataSourceState } from './data-source.reducer';
+import * as i0 from "@angular/core";
+export interface ResponseRequest {
+    data: {
+        success: boolean;
+    };
+}
+export declare class DataSourceService {
+    private store;
+    private httpClient;
+    private translateService;
+    constructor(store: Store<ConfigState | DataSourceState>, httpClient: HttpClient, translateService: PryI18nService);
+    get(): Observable<NamedQuery[]>;
+    post(namedQuery?: NamedQuery): Observable<ResponseRequest>;
+    delete(id: string): Observable<ResponseRequest>;
+    addFavorite(id: string): Observable<ResponseRequest>;
+    deleteFavorite(id: string): Observable<ResponseRequest>;
+    getDatasets(): Observable<Dataset[]>;
+    addDataset(dataset: Dataset): Observable<void>;
+    updateDataset(dataset: Dataset): Observable<void>;
+    deleteDataset(id: string): Observable<void>;
+    getDatasetById(id: string): Observable<Dataset>;
+    getDatasetMetadata(id: string): Observable<DatasetMetadata[]>;
+    addDatasetMetadata(datasetId: string, metadataId: string, value: any): Observable<void>;
+    deleteDatasetMetadata(datasetId: string, metadataId: string): Observable<void>;
+    getDatasetVersions(): Observable<DatasetVersion[]>;
+    retrieveErrors(id: string): Observable<DatasetError[]>;
+    deactivateDatasetVersion(versionId: string): Observable<DatasetVersion>;
+    activateDatasetVersion(versionId: string): Observable<DatasetVersion>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataSourceService>;
+}

package/lib/core/store/data-source/named-query-types.model.d.ts

@@ -0,0 +1,5 @@
+export declare enum NamedQueryTypes {
+    MONO_CLASS = "MONO_CLASS",
+    MULTI_CLASS = "MULTI_CLASS",
+    FULL_TEXT = "FULL_TEXT"
+}

package/lib/core/store/data-source/named-query-utils.d.ts

@@ -0,0 +1,6 @@
+import { MonoClassSearchPayload } from '../../model/search-mono-class.model';
+import { FullTextSearchPayload, MultiClassSearchPayload } from '../../model/search-multi-class.model';
+import { NamedQueryTypes } from './named-query-types.model';
+export declare class NamedQueryUtils {
+    static getTypeFromPayload(payload: MonoClassSearchPayload | MultiClassSearchPayload | FullTextSearchPayload | undefined): NamedQueryTypes | undefined;
+}

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

@@ -0,0 +1,14 @@
+import { Field } from './field.interface';
+export declare const FieldActions: {
+    load: import("@ngrx/store").ActionCreator<"[Field] Load Fields", () => import("@ngrx/store/src/models").TypedAction<"[Field] Load Fields">>;
+    loadSuccess: import("@ngrx/store").ActionCreator<"[Field Api] (bus) Load Fields Success", (props: {
+        fields: Field[];
+    }) => {
+        fields: Field[];
+    } & import("@ngrx/store/src/models").TypedAction<"[Field Api] (bus) Load Fields Success">>;
+    loadFailure: import("@ngrx/store").ActionCreator<"[Field Api] Load Fields Failure", (props: {
+        error: string;
+    }) => {
+        error: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Field Api] Load Fields Failure">>;
+};

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

@@ -0,0 +1,15 @@
+import { Actions } from '@ngrx/effects';
+import { FieldService } from './field.service';
+import * as i0 from "@angular/core";
+export declare class FieldEffects {
+    private actions$;
+    private fieldService;
+    loadFields$: import("rxjs").Observable<({
+        fields: import("@provoly/dashboard").Field[];
+    } & import("@ngrx/store/src/models").TypedAction<"[Field Api] (bus) Load Fields Success">) | ({
+        error: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Field Api] Load Fields Failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    constructor(actions$: Actions, fieldService: FieldService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FieldEffects>;
+}

package/lib/core/store/field/field.interface.d.ts

@@ -0,0 +1,21 @@
+export declare enum FieldType {
+    STRING = "string",
+    KEYWORD = "keyword",
+    INTEGER = "integer",
+    DECIMAL = "decimal",
+    INSTANT = "instant",
+    LONG = "long",
+    RAW = "raw",
+    POINT = "Point",
+    MULTIPOINT = "MultiPoint",
+    LINE = "LineString",
+    MULTILINE = "MultiLineString",
+    POLYGON = "Polygon",
+    MULTIPOLYGON = "MultiPolygon",
+    GEOMETRYCOLLECTION = "GeometryCollection"
+}
+export interface Field {
+    id: string;
+    name: string;
+    type: FieldType;
+}

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

@@ -0,0 +1,11 @@
+import { EntityAdapter, EntityState } from '@ngrx/entity';
+import { Action } from '@ngrx/store';
+import { Field } from './field.interface';
+export declare const fieldsFeatureKey = "@pry/model/fields";
+export interface FieldState extends EntityState<Field> {
+}
+export declare function sortByName(a: Field, b: Field): number;
+export declare const adapter: EntityAdapter<Field>;
+export declare const initialState: FieldState;
+export declare const selectIds: (state: EntityState<Field>) => string[] | number[], selectEntities: (state: EntityState<Field>) => import("@ngrx/entity").Dictionary<Field>, selectAll: (state: EntityState<Field>) => Field[], selectTotal: (state: EntityState<Field>) => number;
+export declare function fieldReducer(state: FieldState, action: Action): FieldState;

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

@@ -0,0 +1,7 @@
+import * as fromField from './field.reducer';
+export declare const FieldSelectors: {
+    feature: import("@ngrx/store").MemoizedSelector<object, fromField.FieldState, import("@ngrx/store").DefaultProjectorFn<fromField.FieldState>>;
+    entities: import("@ngrx/store").MemoizedSelector<object, import("@ngrx/entity").Dictionary<import("@provoly/dashboard").Field>, (s1: fromField.FieldState) => import("@ngrx/entity").Dictionary<import("@provoly/dashboard").Field>>;
+    fields: import("@ngrx/store").MemoizedSelector<object, import("@provoly/dashboard").Field[], (s1: fromField.FieldState) => import("@provoly/dashboard").Field[]>;
+    fieldById: (id: string) => any;
+};

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

@@ -0,0 +1,15 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Field } from './field.interface';
+import { Store } from '@ngrx/store';
+import * as i0 from "@angular/core";
+export declare class FieldService {
+    private httpClient;
+    private store;
+    constructor(httpClient: HttpClient, store: Store<any>);
+    getFields(): Observable<Array<Field>>;
+    saveField(field: Field): Observable<void>;
+    deleteField(id: string): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FieldService>;
+}

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

@@ -0,0 +1,32 @@
+export interface Image {
+    image: string;
+    type: string[];
+}
+export declare const ImageActions: {
+    load: import("@ngrx/store").ActionCreator<"[Image] Load Images", () => import("@ngrx/store/src/models").TypedAction<"[Image] Load Images">>;
+    loadSuccess: import("@ngrx/store").ActionCreator<"[Image] Load Images Success", (props: {
+        images: Image[];
+    }) => {
+        images: Image[];
+    } & import("@ngrx/store/src/models").TypedAction<"[Image] Load Images Success">>;
+    loadFailure: import("@ngrx/store").ActionCreator<"[Image] Load Images Failure", (props: {
+        error: string;
+    }) => {
+        error: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Image] Load Images Failure">>;
+    add: import("@ngrx/store").ActionCreator<"[Image] Add Image", (props: {
+        file: any;
+        mediaType: string;
+        imageType: string;
+    }) => {
+        file: any;
+        mediaType: string;
+        imageType: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Image] Add Image">>;
+    added: import("@ngrx/store").ActionCreator<"[Image] Added Image", (props: {
+        name: string;
+    }) => {
+        name: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Image] Added Image">>;
+    clearAdded: import("@ngrx/store").ActionCreator<"[Image] reset Added Image", () => import("@ngrx/store/src/models").TypedAction<"[Image] reset Added Image">>;
+};