@provoly/dashboard 0.11.0

package/search/search-mono-class/store/search-mono-class.actions.d.ts

@@ -0,0 +1,119 @@
+import { Attribute, ConditionType, DescriptionQuery, MonoClassSearchPayload, NormalizedCondition, OperatorType, OrderValue, ValueDataType } from '@provoly/dashboard';
+export declare const SearchMonoClassActions: {
+    save: import("@ngrx/store").ActionCreator<"[SearchMonoClass] save", (props: {
+        descriptionQuery: DescriptionQuery;
+        id?: string | undefined;
+    }) => {
+        descriptionQuery: DescriptionQuery;
+        id?: string | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] save">>;
+    search: import("@ngrx/store").ActionCreator<"[SearchMonoClass] launch Mono Class search", () => import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] launch Mono Class search">>;
+    load: import("@ngrx/store").ActionCreator<"[SearchMonoClass] launch Mono Class search", () => import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] launch Mono Class search">>;
+    saveMonoClassSearch: import("@ngrx/store").ActionCreator<"[SearchMonoClass] launch Mono Class search", () => import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] launch Mono Class search">>;
+    selectMonoClassSearch: import("@ngrx/store").ActionCreator<"[Condition] select mono class search", (props: {
+        classId: string;
+    }) => {
+        classId: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] select mono class search">>;
+    addFirstNormalizedCondition: import("@ngrx/store").ActionCreator<"[Condition] add first normalizedCondition ", (props: {
+        condition: NormalizedCondition;
+    }) => {
+        condition: NormalizedCondition;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] add first normalizedCondition ">>;
+    addNormalizedConditionAttributeForConditionId: import("@ngrx/store").ActionCreator<"[Condition] add normalizedCondition attribute ", (props: {
+        conditionId: string;
+        attribute: Attribute;
+    }) => {
+        conditionId: string;
+        attribute: Attribute;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] add normalizedCondition attribute ">>;
+    addNormalizedConditionComposedForConditionId: import("@ngrx/store").ActionCreator<"[Condition] add normalizedCondition composed ", (props: {
+        conditionId: string;
+    }) => {
+        conditionId: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] add normalizedCondition composed ">>;
+    addNormalizedConditionForConditionId: import("@ngrx/store").ActionCreator<"[Condition] add normalizedCondition for condition id", (props: {
+        conditionId: string;
+        condition: NormalizedCondition;
+    }) => {
+        conditionId: string;
+        condition: NormalizedCondition;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] add normalizedCondition for condition id">>;
+    updateNormalizedConditionOperatorForConditionId: import("@ngrx/store").ActionCreator<"[Condition] update normalizedCondition operator for condition id", (props: {
+        conditionId: string;
+        operator: OperatorType;
+    }) => {
+        conditionId: string;
+        operator: OperatorType;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] update normalizedCondition operator for condition id">>;
+    updateNormalizedConditionValueForConditionId: import("@ngrx/store").ActionCreator<"[Condition] update normalizedCondition value for condition id", (props: {
+        conditionId: string;
+        value: ValueDataType;
+        upperValue?: ValueDataType | undefined;
+    }) => {
+        conditionId: string;
+        value: ValueDataType;
+        upperValue?: ValueDataType | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] update normalizedCondition value for condition id">>;
+    updateNormalizedConditionTypeForConditionId: import("@ngrx/store").ActionCreator<"[Condition] update normalizedCondition type for condition id", (props: {
+        conditionId: string;
+        conditionType: ConditionType;
+    }) => {
+        conditionId: string;
+        conditionType: ConditionType;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] update normalizedCondition type for condition id">>;
+    deleteNormalizedConditionById: import("@ngrx/store").ActionCreator<"[Condition] delete normalizedCondition for condition id", (props: {
+        conditionId: string;
+    }) => {
+        conditionId: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] delete normalizedCondition for condition id">>;
+    deleteNormalizedCondition: import("@ngrx/store").ActionCreator<"[Condition] delete normalizedCondition", (props: {
+        condition: NormalizedCondition;
+    }) => {
+        condition: NormalizedCondition;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] delete normalizedCondition">>;
+    removeConditionFromComposed: import("@ngrx/store").ActionCreator<"[Condition] remove normalizedCondition id from parent composed", (props: {
+        parentId: string;
+        childrenId: string;
+    }) => {
+        parentId: string;
+        childrenId: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] remove normalizedCondition id from parent composed">>;
+    loadExistingConditions: import("@ngrx/store").ActionCreator<"[SearchMonoClass] load existing conditions", (props: {
+        payload: MonoClassSearchPayload;
+    }) => {
+        payload: MonoClassSearchPayload;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] load existing conditions">>;
+    addIdCondition: import("@ngrx/store").ActionCreator<"[SearchMonoClass] add id condition", (props: {
+        ids: string[];
+    }) => {
+        ids: string[];
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] add id condition">>;
+    addIdMaster: import("@ngrx/store").ActionCreator<"[SearchMonoClass] add id master", (props: {
+        id: string;
+    }) => {
+        id: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] add id master">>;
+    addEntities: import("@ngrx/store").ActionCreator<"[SearchMonoClass] add entities", (props: {
+        entities: {
+            [key: string]: NormalizedCondition;
+        };
+    }) => {
+        entities: {
+            [key: string]: NormalizedCondition;
+        };
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] add entities">>;
+    addIdClass: import("@ngrx/store").ActionCreator<"[SearchMonoClass] add id class", (props: {
+        id: string;
+    }) => {
+        id: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] add id class">>;
+    resetSearch: import("@ngrx/store").ActionCreator<"[SearchMonoClass] reset search", () => import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] reset search">>;
+    addOrder: import("@ngrx/store").ActionCreator<"[SearchMonoClass] add order", (props: {
+        attribute?: string | undefined;
+        asc?: OrderValue;
+    }) => {
+        attribute?: string | undefined;
+        asc?: OrderValue;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] add order">>;
+};

package/search/search-mono-class/store/search-mono-class.effects.d.ts

@@ -0,0 +1,64 @@
+import { Actions } from '@ngrx/effects';
+import { Action, Store } from '@ngrx/store';
+import { MonoClassSearchPayload, MultiClassSearchPayload, NormalizedCondition, OrderValue, SearchService } from '@provoly/dashboard';
+import { SearchMonoClassService } from './search-mono-class.service';
+import * as i0 from "@angular/core";
+export declare class SearchMonoClassEffects {
+    private actions$;
+    private searchService;
+    private searchMonoClassService;
+    private store;
+    constructor(actions$: Actions, searchService: SearchService, searchMonoClassService: SearchMonoClassService, store: Store<any>);
+    selectedMonoClass$: import("rxjs").Observable<{
+        condition: NormalizedCondition;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] add first normalizedCondition ">> & import("@ngrx/effects").CreateEffectMetadata;
+    addNormalizedConditionAttribute$: import("rxjs").Observable<{
+        conditionId: string;
+        condition: NormalizedCondition;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] add normalizedCondition for condition id">> & import("@ngrx/effects").CreateEffectMetadata;
+    addNormalizedConditionComposed$: import("rxjs").Observable<{
+        conditionId: string;
+        condition: NormalizedCondition;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] add normalizedCondition for condition id">> & import("@ngrx/effects").CreateEffectMetadata;
+    deleteNormalizedCondition$: import("rxjs").Observable<({
+        condition: NormalizedCondition;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] delete normalizedCondition">) | ({
+        parentId: string;
+        childrenId: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] remove normalizedCondition id from parent composed">) | ({
+        conditionId: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[Condition] delete normalizedCondition for condition id">)> & import("@ngrx/effects").CreateEffectMetadata;
+    actionMonoClassSearch$: import("rxjs").Observable<({
+        name: string;
+        id?: string | undefined;
+        description?: string | undefined;
+        visibility?: import("@provoly/dashboard").PryVisibility | undefined;
+        payload: MultiClassSearchPayload | MonoClassSearchPayload | import("@provoly/dashboard").FullTextSearchPayload;
+        color?: string | undefined;
+        favorite: boolean;
+        isEdit: boolean;
+    } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] post">) | ({
+        payload: MultiClassSearchPayload | MonoClassSearchPayload | import("@provoly/dashboard").FullTextSearchPayload;
+        id?: string | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[Search] search">)> & import("@ngrx/effects").CreateEffectMetadata;
+    loadExistingConditions$: import("rxjs").Observable<({
+        ids: string[];
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] add id condition">) | ({
+        id: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] add id master">) | ({
+        entities: {
+            [key: string]: NormalizedCondition;
+        };
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] add entities">) | ({
+        id: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] add id class">) | ({
+        attribute?: string | undefined;
+        asc?: OrderValue;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] add order">)> & import("@ngrx/effects").CreateEffectMetadata;
+    addEdit$: import("rxjs").Observable<Action | ({
+        error: Error;
+    } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] failure">)> & import("@ngrx/effects").CreateEffectMetadata;
+    stopEdit$: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] reset search"> | import("@ngrx/store/src/models").TypedAction<"[SearchMonoClass] reset search">> & import("@ngrx/effects").CreateEffectMetadata;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchMonoClassEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchMonoClassEffects>;
+}

package/search/search-mono-class/store/search-mono-class.reducer.d.ts

@@ -0,0 +1,10 @@
+import { MonoClassConditions, ResultOrder } from '@provoly/dashboard';
+export declare const searchMonoClassFeatureKey = "@pry/search/mono-class";
+export interface SearchMonoClassState {
+    loading: boolean;
+    monoClassConditions: MonoClassConditions;
+    monoClassId?: string;
+    order?: ResultOrder;
+}
+export declare const initialSearchMonoClassState: SearchMonoClassState;
+export declare const searchMonoClassReducer: import("@ngrx/store").ActionReducer<SearchMonoClassState, import("@ngrx/store").Action>;

package/search/search-mono-class/store/search-mono-class.selectors.d.ts

@@ -0,0 +1,13 @@
+import { Attribute, MonoClassConditions } from '@provoly/dashboard';
+import * as fromSearchMonoClass from './search-mono-class.reducer';
+export declare const SearchMonoClassSelectors: {
+    feature: import("@ngrx/store").MemoizedSelector<object, fromSearchMonoClass.SearchMonoClassState, import("@ngrx/store").DefaultProjectorFn<fromSearchMonoClass.SearchMonoClassState>>;
+    selectMonoClassIdSearch: import("@ngrx/store").MemoizedSelector<object, string | undefined, (s1: fromSearchMonoClass.SearchMonoClassState) => string | undefined>;
+    selectMonoClassAttributesSearch: import("@ngrx/store").MemoizedSelector<object, Attribute[], (s1: import("@ngrx/entity").Dictionary<import("@provoly/dashboard").Class>, s2: string | undefined) => Attribute[]>;
+    selectMonoClassSearchAttributeById: (attributeId: string) => import("@ngrx/store").MemoizedSelector<object, Attribute | undefined, (s1: Attribute[]) => Attribute | undefined>;
+    selectMonoClassConditions: import("@ngrx/store").MemoizedSelector<object, MonoClassConditions, (s1: fromSearchMonoClass.SearchMonoClassState) => MonoClassConditions>;
+    selectMonoClassConditionsById: (id: string) => import("@ngrx/store").MemoizedSelector<object, import("@provoly/dashboard").NormalizedCondition, (s1: MonoClassConditions) => import("@provoly/dashboard").NormalizedCondition>;
+    selectMonoClassConditionsMasterId: import("@ngrx/store").MemoizedSelector<object, string | null, (s1: MonoClassConditions) => string | null>;
+    searchMonoClassValid: import("@ngrx/store").MemoizedSelector<object, boolean, (s1: MonoClassConditions, s2: string | undefined) => boolean>;
+    order: import("@ngrx/store").MemoizedSelector<object, import("@provoly/dashboard").ResultOrder | undefined, (s1: fromSearchMonoClass.SearchMonoClassState) => import("@provoly/dashboard").ResultOrder | undefined>;
+};

package/search/search-mono-class/store/search-mono-class.service.d.ts

@@ -0,0 +1,20 @@
+import { Class, Condition, Field, MonoClassConditions, MonoClassSearchPayload, NormalizedCondition, ResultOrder } from '@provoly/dashboard';
+import * as i0 from "@angular/core";
+export declare class SearchMonoClassService {
+    initNormalizedConditionComposed(parentId: string | null): NormalizedCondition;
+    initNormalizedConditionAttribute(parentId: string, attributeId: string): NormalizedCondition;
+    buildMonoClassSearchPayloadForSearch(oClass: string, masterId: string, monoClassConditions: MonoClassConditions, order: ResultOrder | undefined): MonoClassSearchPayload;
+    private buildConditionFromMonoClassSearchCondition;
+    loadNormalizedConditions(cond: Condition, parentId: string, classes: Class[], fields: Field[], masterId?: string, sort?: {
+        attribute: string;
+        direction: string;
+    }): {
+        id: string;
+        conditions: NormalizedCondition[];
+        sort: ResultOrder | undefined;
+    };
+    getPatternForField(field: Field): string;
+    private getFieldFromAttribute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchMonoClassService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchMonoClassService>;
+}

package/search/search-multi-class/components/multi-class-condition/multi-class-condition.component.d.ts

@@ -0,0 +1,39 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
+import { AbstractControl, UntypedFormGroup } from '@angular/forms';
+import { Store } from '@ngrx/store';
+import { Class, Field, MultiClassCondition, OperatorOption } from '@provoly/dashboard';
+import { Observable } from 'rxjs';
+import { SearchMultiClassService } from '../../store/search-multi-class.service';
+import * as i0 from "@angular/core";
+export declare class MultiClassConditionComponent implements OnInit {
+    private store;
+    private service;
+    private overlay;
+    private viewContainerRef;
+    fieldSelectionTpl: TemplateRef<any>;
+    condition$: Observable<MultiClassCondition | undefined>;
+    classesLinked$: Observable<Class[]>;
+    field$: Observable<Field | undefined>;
+    classes$: Observable<Class[]>;
+    conditions$: Observable<MultiClassCondition[]>;
+    notLastCondition$: Observable<boolean>;
+    operators$: Observable<OperatorOption[]>;
+    set id(val: string);
+    private _id?;
+    opened: boolean;
+    private overlayRef?;
+    form: UntypedFormGroup;
+    get formValue(): AbstractControl | null;
+    constructor(store: Store<any>, service: SearchMultiClassService, overlay: Overlay, viewContainerRef: ViewContainerRef);
+    ngOnInit(): void;
+    onRemoveCondition(condition: MultiClassCondition): void;
+    toggleFieldSelection(): void;
+    openWithTemplate(): void;
+    onChangeField(condition: MultiClassCondition, field: string): void;
+    onCloseModal(): void;
+    onUpdateValue(condition: MultiClassCondition): void;
+    get hasTwoFields(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiClassConditionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiClassConditionComponent, "pry-multi-class-condition", never, { "id": { "alias": "id"; "required": false; }; }, {}, never, never, false, never>;
+}

package/search/search-multi-class/components/multi-class-field-selection/multi-class-field-selection.component.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { Class, Field, MultiClassCondition, MultiClassFieldSelection } from '@provoly/dashboard';
+import { Observable } from 'rxjs';
+import { SearchMultiClassService } from '../../store/search-multi-class.service';
+import * as i0 from "@angular/core";
+export declare class MultiClassFieldSelectionComponent {
+    private store;
+    private searchMultiClassService;
+    fields$: Observable<Field[]>;
+    classes$: Observable<Class[]>;
+    conditions$: Observable<MultiClassCondition[]>;
+    availableFields$: Observable<MultiClassFieldSelection[]>;
+    fieldSearch: string;
+    set conditionId(val: string | undefined);
+    get conditionId(): any;
+    private _conditionId?;
+    closeModal: EventEmitter<any>;
+    selectFieldChange: EventEmitter<string>;
+    constructor(store: Store<any>, searchMultiClassService: SearchMultiClassService);
+    private sortFields;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiClassFieldSelectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiClassFieldSelectionComponent, "pry-multi-class-field-selection", never, { "conditionId": { "alias": "conditionId"; "required": false; }; }, { "closeModal": "closeModal"; "selectFieldChange": "selectFieldChange"; }, never, never, false, never>;
+}

package/search/search-multi-class/components/search-multi-class/search-multi-class.component.d.ts

@@ -0,0 +1,15 @@
+import { Store } from '@ngrx/store';
+import { MultiClassCondition } from '@provoly/dashboard';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class PrySearchMultiClassComponent {
+    private store;
+    conditions$: Observable<MultiClassCondition[]>;
+    multiType$: Observable<'AND' | 'OR'>;
+    optionsOpen: boolean;
+    constructor(store: Store<any>);
+    onAddCondition(): void;
+    onChangeMultiType(evt: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrySearchMultiClassComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PrySearchMultiClassComponent, "pry-search-multi-class", never, {}, {}, never, never, false, never>;
+}

package/search/search-multi-class/store/search-multi-class.actions.d.ts

@@ -0,0 +1,65 @@
+import { DescriptionQuery, MultiClassCondition, MultiClassSearchPayload } from '@provoly/dashboard';
+export declare const SearchMultiClassActions: {
+    updateMultiType: import("@ngrx/store").ActionCreator<"[Search Multi class] update conditonnal type", (props: {
+        multiType: 'AND' | 'OR';
+    }) => {
+        multiType: 'AND' | 'OR';
+    } & import("@ngrx/store/src/models").TypedAction<"[Search Multi class] update conditonnal type">>;
+    addNewEmptyCondition: import("@ngrx/store").ActionCreator<"[SearchMultiClass] add empty condition", () => import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] add empty condition">>;
+    addMultiClassCondition: import("@ngrx/store").ActionCreator<"[SearchMultiClass] add multi class condition", (props: {
+        condition: MultiClassCondition;
+    }) => {
+        condition: MultiClassCondition;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] add multi class condition">>;
+    updateConditionField: import("@ngrx/store").ActionCreator<"[SearchMultiClass] update condition field", (props: {
+        conditionId: string;
+        field: string;
+    }) => {
+        conditionId: string;
+        field: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] update condition field">>;
+    updateCondition: import("@ngrx/store").ActionCreator<"[SearchMultiClass] update condition", (props: {
+        conditionId: string;
+        key: keyof MultiClassCondition;
+        value: any;
+        upperValue?: any;
+    }) => {
+        conditionId: string;
+        key: keyof MultiClassCondition;
+        value: any;
+        upperValue?: any;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] update condition">>;
+    updateConditionPattern: import("@ngrx/store").ActionCreator<"[SearchMultiClass] update condition pattern", (props: {
+        conditionId: string;
+        pattern: string;
+        isDate: boolean;
+    }) => {
+        conditionId: string;
+        pattern: string;
+        isDate: boolean;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] update condition pattern">>;
+    removeCondition: import("@ngrx/store").ActionCreator<"[SearchMultiClass] remove condition", (props: {
+        conditionId: string;
+    }) => {
+        conditionId: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] remove condition">>;
+    resetSearch: import("@ngrx/store").ActionCreator<"[SearchMultiClass] reset search", () => import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] reset search">>;
+    loadExistingConditions: import("@ngrx/store").ActionCreator<"[SearchMultiClass] load existing conditions", (props: {
+        payload: MultiClassSearchPayload;
+    }) => {
+        payload: MultiClassSearchPayload;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] load existing conditions">>;
+    updateConditions: import("@ngrx/store").ActionCreator<"[SearchMultiClass] update conditions", (props: {
+        conditions: MultiClassCondition[];
+    }) => {
+        conditions: MultiClassCondition[];
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] update conditions">>;
+    search: import("@ngrx/store").ActionCreator<"[SearchMultiClass] launch search", () => import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] launch search">>;
+    save: import("@ngrx/store").ActionCreator<"[SearchMultiClass] launch save", (props: {
+        descriptionQuery: DescriptionQuery;
+        id?: string | undefined;
+    }) => {
+        descriptionQuery: DescriptionQuery;
+        id?: string | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] launch save">>;
+};

package/search/search-multi-class/store/search-multi-class.effects.d.ts

@@ -0,0 +1,39 @@
+import { Actions } from '@ngrx/effects';
+import { Store } from '@ngrx/store';
+import { MultiClassCondition } from '@provoly/dashboard';
+import { SearchMultiClassService } from './search-multi-class.service';
+import * as i0 from "@angular/core";
+export declare class SearchMultiClassEffects {
+    private actions$;
+    private store;
+    private multiClassService;
+    constructor(actions$: Actions, store: Store<any>, multiClassService: SearchMultiClassService);
+    addCondition$: import("rxjs").Observable<{
+        condition: MultiClassCondition;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] add multi class condition">> & import("@ngrx/effects").CreateEffectMetadata;
+    updateConditionField$: import("rxjs").Observable<{
+        conditionId: string;
+        pattern: string;
+        isDate: boolean;
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] update condition pattern">> & import("@ngrx/effects").CreateEffectMetadata;
+    actionMultiClassSearch$: import("rxjs").Observable<({
+        name: string;
+        id?: string | undefined;
+        description?: string | undefined;
+        visibility?: import("@provoly/dashboard").PryVisibility | undefined;
+        payload: import("@provoly/dashboard").MultiClassSearchPayload | import("@provoly/dashboard").MonoClassSearchPayload | import("@provoly/dashboard").FullTextSearchPayload;
+        color?: string | undefined;
+        favorite: boolean;
+        isEdit: boolean;
+    } & import("@ngrx/store/src/models").TypedAction<"[NamedQuery] post">) | ({
+        payload: import("@provoly/dashboard").MultiClassSearchPayload | import("@provoly/dashboard").MonoClassSearchPayload | import("@provoly/dashboard").FullTextSearchPayload;
+        id?: string | undefined;
+    } & import("@ngrx/store/src/models").TypedAction<"[Search] search">)> & import("@ngrx/effects").CreateEffectMetadata;
+    loadExistingConditions$: import("rxjs").Observable<({
+        multiType: "AND" | "OR";
+    } & import("@ngrx/store/src/models").TypedAction<"[Search Multi class] update conditonnal type">) | ({
+        conditions: MultiClassCondition[];
+    } & import("@ngrx/store/src/models").TypedAction<"[SearchMultiClass] update conditions">)> & import("@ngrx/effects").CreateEffectMetadata;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchMultiClassEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchMultiClassEffects>;
+}

package/search/search-multi-class/store/search-multi-class.reducer.d.ts

@@ -0,0 +1,8 @@
+import { MultiClassCondition } from '@provoly/dashboard';
+export declare const searchMultiClassFeatureKey = "@pry/search/multi-class";
+export interface SearchMultiClassState {
+    multiType: 'AND' | 'OR';
+    conditions: MultiClassCondition[];
+}
+export declare const initialSearchState: SearchMultiClassState;
+export declare const searchMultiClassReducer: import("@ngrx/store").ActionReducer<SearchMultiClassState, import("@ngrx/store").Action>;

package/search/search-multi-class/store/search-multi-class.selectors.d.ts

@@ -0,0 +1,9 @@
+import { MultiClassCondition } from '@provoly/dashboard';
+import * as fromSearchMultiClass from './search-multi-class.reducer';
+export declare const SearchMultiClassSelectors: {
+    feature: import("@ngrx/store").MemoizedSelector<object, fromSearchMultiClass.SearchMultiClassState, import("@ngrx/store").DefaultProjectorFn<fromSearchMultiClass.SearchMultiClassState>>;
+    multiType: import("@ngrx/store").MemoizedSelector<object, "AND" | "OR", (s1: fromSearchMultiClass.SearchMultiClassState) => "AND" | "OR">;
+    conditions: import("@ngrx/store").MemoizedSelector<object, MultiClassCondition[], (s1: fromSearchMultiClass.SearchMultiClassState) => MultiClassCondition[]>;
+    getConditionById: (id: string) => import("@ngrx/store").MemoizedSelector<object, MultiClassCondition | undefined, (s1: MultiClassCondition[]) => MultiClassCondition | undefined>;
+    searchMultiClassValid: import("@ngrx/store").MemoizedSelector<object, boolean, (s1: MultiClassCondition[]) => boolean>;
+};

package/search/search-multi-class/store/search-multi-class.service.d.ts

@@ -0,0 +1,15 @@
+import { Class, Field, MultiClassCondition, MultiClassFieldSelection, MultiClassSearchPayload } from '@provoly/dashboard';
+import * as i0 from "@angular/core";
+export declare class SearchMultiClassService {
+    generateCondition(field?: string, operator?: string): MultiClassCondition;
+    getConditionsFromSearchPayload(payload: MultiClassSearchPayload, fields: Field[]): MultiClassCondition[];
+    buildConditionsToSearchPayload(conditions: MultiClassCondition[], classes: Class[], multiType: 'AND' | 'OR'): MultiClassSearchPayload;
+    getFieldsAvailable(conditions: MultiClassCondition[], classes: Class[], fields: Field[], excludedCondition?: string): MultiClassFieldSelection[];
+    getClassesForField(conditions: MultiClassCondition[], condition: MultiClassCondition | undefined, classes: Class[]): Class[];
+    getPatternForField(field: Field): string;
+    private getClassesIdsByConditions;
+    private getClassesIntersectFields;
+    private getSelectedFields;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchMultiClassService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchMultiClassService>;
+}

package/search/search-tools/search-tools.component.d.ts

@@ -0,0 +1,52 @@
+import { OnDestroy } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { ClassState, DataSourceState, FieldState, NamedQuery, NamedQueryTypes } from '@provoly/dashboard';
+import { Observable } from 'rxjs';
+import { SearchFulltextChange } from '../search-fulltext/search-fulltext/search-fulltext.component';
+import { SearchMultiClassState } from '../search-multi-class/store/search-multi-class.reducer';
+import * as i0 from "@angular/core";
+export declare class PrySearchToolsComponent implements OnDestroy {
+    private store;
+    class: boolean;
+    searchToolsClose: boolean;
+    searchMultiClassValid$: Observable<boolean>;
+    searchMonoClassValid$: Observable<boolean>;
+    loading$: Observable<boolean>;
+    isRename$: Observable<boolean>;
+    isSearchCriteria: boolean;
+    isSearchMono: boolean;
+    isSearchFullText: boolean;
+    isSearchFulltextValid: boolean;
+    isMoreList: boolean;
+    widgetType: string;
+    get isNewMono(): boolean;
+    get isEditMono$(): Observable<boolean>;
+    getIcon: {
+        [clazz: string]: string;
+    };
+    items: Observable<any[] | null>;
+    editInProgress$: Observable<boolean>;
+    currentEdit$: Observable<NamedQuery | undefined>;
+    currentEditType$: Observable<NamedQueryTypes | undefined>;
+    readonly FULL_TEXT = NamedQueryTypes.FULL_TEXT;
+    readonly MONO_CLASS = NamedQueryTypes.MONO_CLASS;
+    readonly MULTI_CLASS = NamedQueryTypes.MULTI_CLASS;
+    searchFulltextTemp?: SearchFulltextChange;
+    private sub;
+    constructor(store: Store<DataSourceState | SearchMultiClassState | FieldState | ClassState>);
+    ngOnDestroy(): void;
+    onSearchCriteria(): void;
+    onSearchTools(): void;
+    back(): void;
+    onMonoSearch(): void;
+    onChangeListView(isMoreList: boolean): void;
+    onSearchFulltextChange(payload: SearchFulltextChange): void;
+    onSearch(): void;
+    onChangePanel(): void;
+    private resizeScreen;
+    selectWidget($event: string): void;
+    reset(): void;
+    updateVisibility($event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrySearchToolsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PrySearchToolsComponent, "pry-search-tools", never, {}, {}, never, never, false, never>;
+}

package/search/search.module.d.ts

@@ -0,0 +1,37 @@
+import { PryI18nService } from '@provoly/dashboard';
+import * as i0 from "@angular/core";
+import * as i1 from "./search-mono-class/components/search-composed/search-composed.component";
+import * as i2 from "./search-mono-class/components/search-select-attribute/search-select-attribute.component";
+import * as i3 from "./search-mono-class/components/search-condition/search-condition.component";
+import * as i4 from "./components/save-query/save-query.component";
+import * as i5 from "./search-tools/search-tools.component";
+import * as i6 from "./search-home/search-home.component";
+import * as i7 from "./search-mono-class/components/search-mono-class/search-mono-class.component";
+import * as i8 from "./search-multi-class/components/multi-class-condition/multi-class-condition.component";
+import * as i9 from "./search-multi-class/components/search-multi-class/search-multi-class.component";
+import * as i10 from "./search-multi-class/components/multi-class-field-selection/multi-class-field-selection.component";
+import * as i11 from "./search-fulltext/search-fulltext/search-fulltext.component";
+import * as i12 from "./components/save-query-button/save-query-button.component";
+import * as i13 from "./components/edit-named-query/edit-named-query.component";
+import * as i14 from "./components/edit-named-query-modal/edit-named-query-modal.component";
+import * as i15 from "./components/choose-widget/choose-widget.component";
+import * as i16 from "./search-mono-class/components/search-order/search-order.component";
+import * as i17 from "./style/css.component";
+import * as i18 from "@angular/common";
+import * as i19 from "@provoly/dashboard";
+import * as i20 from "@ngrx/store";
+import * as i21 from "@ngrx/effects";
+import * as i22 from "@angular/forms";
+import * as i23 from "@angular/cdk/overlay";
+import * as i24 from "@angular/cdk/portal";
+import * as i25 from "@provoly/dashboard/components/filter";
+import * as i26 from "@provoly/dashboard/components/expand-panel";
+import * as i27 from "@provoly/dashboard/components/card";
+import * as i28 from "@provoly/dashboard/components/checkbox";
+export declare class PrySearchModule {
+    private pryTranslateService;
+    constructor(pryTranslateService: PryI18nService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrySearchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PrySearchModule, [typeof i1.PrySearchComposedComponent, typeof i2.PrySearchSelectAttributeComponent, typeof i3.PrySearchConditionComponent, typeof i4.PrySaveQueryComponent, typeof i5.PrySearchToolsComponent, typeof i6.PrySearchHomeComponent, typeof i7.PrySearchMonoClassComponent, typeof i4.PrySaveQueryComponent, typeof i8.MultiClassConditionComponent, typeof i9.PrySearchMultiClassComponent, typeof i10.MultiClassFieldSelectionComponent, typeof i11.PrySearchFulltextComponent, typeof i12.PrySaveQueryButtonComponent, typeof i13.EditNamedQueryComponent, typeof i14.EditNamedQueryModalComponent, typeof i15.ChooseWidgetComponent, typeof i16.PrySearchOrderComponent, typeof i17.PrySearchCssComponent], [typeof i18.CommonModule, typeof i19.PryCoreModule, typeof i20.StoreFeatureModule, typeof i20.StoreFeatureModule, typeof i21.EffectsFeatureModule, typeof i19.PryIconModule, typeof i22.FormsModule, typeof i22.ReactiveFormsModule, typeof i23.OverlayModule, typeof i24.PortalModule, typeof i19.PrySelectModule, typeof i19.PryToggleModule, typeof i19.PryOverlayModule, typeof i25.PryFilterModule, typeof i19.PryToggleModule, typeof i26.PryExpandPanelModule, typeof i27.PryCardModule, typeof i28.PryCheckboxModule, typeof i19.PryDashboardModule, typeof i19.PryShareModule, typeof i19.PryDatePickerModule, typeof i19.PryI18nModule], [typeof i5.PrySearchToolsComponent, typeof i11.PrySearchFulltextComponent, typeof i14.EditNamedQueryModalComponent, typeof i15.ChooseWidgetComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PrySearchModule>;
+}