@solidev/data 0.0.1-alpha.0

package/lib/messages/message.service.d.ts

@@ -0,0 +1,59 @@
+import { InjectionToken, NgZone } from "@angular/core";
+import { Observable, ReplaySubject } from "rxjs";
+import * as i0 from "@angular/core";
+export declare const enum TYPE {
+    SUCCESS = 0,
+    INFO = 1,
+    WARNING = 2,
+    DANGER = 3
+}
+export declare enum DEFAULT_TIMEOUTS {
+    SUCCESS = 3000,
+    INFO = 4000,
+    WARNING = 10000,
+    DANGER = 30000
+}
+export declare enum STATUS {
+    UNDISP = 0,
+    DISP = 1,
+    ACK = 2
+}
+export interface ISoundTypes {
+    [index: string]: string;
+}
+export declare const DATA_MESSAGE_SOUNDS: InjectionToken<ISoundTypes>;
+export declare class Message {
+    title: string;
+    type: TYPE;
+    message: string;
+    trace: any;
+    ttl: number;
+    status: string;
+    showTrace: boolean;
+    constructor(title: string, type?: TYPE, message?: string, trace?: any, ttl?: number);
+    get style(): string;
+    ack(): void;
+}
+export declare class DataMessageService {
+    ngZone: NgZone;
+    sounds: ISoundTypes;
+    _messages$: ReplaySubject<Message[]>;
+    private _messages;
+    private _timer;
+    private _subscription;
+    constructor(ngZone: NgZone, sounds: ISoundTypes);
+    get current(): Observable<Message[]>;
+    init(): void;
+    close(): void;
+    success(title: string, message?: string, trace?: any, timeout?: number): void;
+    info(title: string, message?: string, trace?: any, timeout?: number): void;
+    warning(title: string, message?: string, trace?: any, timeout?: number): void;
+    danger(title: string, message?: string, trace?: any, timeout?: number): void;
+    error(title: string, message?: string, trace?: any): void;
+    debug(title: string, message?: string, trace?: any): void;
+    ack(message: Message): void;
+    play(type?: string): void;
+    private _notify;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataMessageService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataMessageService>;
+}

package/lib/modellist/model-list-fields/model-list-field-header/model-list-field-header.component.d.ts

@@ -0,0 +1,15 @@
+import { ModelList } from '../../model-list.service';
+import { DataModel } from '../../../data/data-model';
+import { ModelListField } from '../model-list-fields';
+import * as i0 from "@angular/core";
+export declare class ModelListFieldHeaderComponent<T extends DataModel> {
+    list: ModelList<T>;
+    field: string;
+    sort?: boolean;
+    sortField?: string;
+    constructor();
+    disable(): void;
+    enable(f: ModelListField): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListFieldHeaderComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListFieldHeaderComponent<any>, "data-model-list-field-header", never, { "list": "list"; "field": "field"; "sort": "sort"; "sortField": "sortField"; }, {}, never, ["*"], true>;
+}

package/lib/modellist/model-list-fields/model-list-fields-selector/model-list-fields-selector.component.d.ts

@@ -0,0 +1,19 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { DataModel } from '../../../data/data-model';
+import { ModelList } from '../../model-list.service';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { NgbOffcanvas } from '@ng-bootstrap/ng-bootstrap';
+import { ModelListField } from '../model-list-fields';
+import * as i0 from "@angular/core";
+export declare class ModelListFieldsSelectorComponent<T extends DataModel> implements OnInit {
+    private _ofc;
+    list: ModelList<T>;
+    ofctpl: ElementRef<HTMLDivElement>;
+    constructor(_ofc: NgbOffcanvas);
+    ngOnInit(): void;
+    open(): void;
+    drop($event: CdkDragDrop<T, any>): void;
+    toggle(f: ModelListField): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListFieldsSelectorComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListFieldsSelectorComponent<any>, "data-model-list-fields-selector", never, { "list": "list"; }, {}, never, never, true>;
+}

package/lib/modellist/model-list-fields/model-list-fields.d.ts

@@ -0,0 +1,67 @@
+import { Observable } from 'rxjs';
+import { DataModel } from '../../data/data-model';
+import { Collection } from '../../data/data-collection';
+import { FieldsParams } from '../model-list.service';
+export interface ModelListField {
+    name: string;
+    label: string;
+    enabled: boolean;
+    allowed: boolean;
+    field: any;
+    position: number;
+}
+export declare class ModelListFields<T extends DataModel> {
+    private readonly __fields;
+    constructor(collection: Collection<T>, params?: FieldsParams);
+    private _fields;
+    get fields(): Observable<ModelListField[]>;
+    private _enabled;
+    get enabled(): string[];
+    private _output;
+    get output(): Observable<string[]>;
+    /**
+     * Enable a field by name. Position is optional.
+     *
+     * @param fname : name of field to be enabled
+     * @param  position : position (optional)
+     * @returns current enabled fields
+     */
+    enable(fname: string, position?: number): string[];
+    /**
+     * Disable a field by name.
+     *
+     * @param fname : name of field to be disabled
+     * @returns  current enabled fields
+     */
+    disable(fname: string): string[];
+    /**
+     * Move field `fname` before or after (depending on `position`) field `dest`.
+     *
+     * @param fname field to move
+     * @param position ("before" or "after")
+     * @param dest reference field
+     * @returns current enabled fields
+     */
+    move(fname: string, position: 'before' | 'after', dest?: string): string[];
+    /**
+     * Check if field with name `fname` is enabled.
+     *
+     * @param fname : name of field
+     * @returns  enabled (true) or disabled (false)
+     */
+    isEnabled(fname: string): boolean;
+    /**
+     * Get field by name
+     * @param fname : name of field
+     * @returns Model list field or null if not found
+     */
+    get(fname: string): ModelListField | null;
+    /**
+     * Get field by position
+     * @param pos : position of field
+     * @returns Model list field or null if not found
+     */
+    getAtPos(pos: number): ModelListField | null;
+    setPosition(fname: any, position: number): string[];
+    private _update;
+}

package/lib/modellist/model-list-filters/filters/filtertypes.d.ts

@@ -0,0 +1 @@
+export declare type FILTER_TYPE = 'autocomplete' | 'autocompletemulti' | 'datetime' | 'date' | 'datetimerange' | 'flags' | 'geodistance' | 'number' | 'select' | 'selectmulti' | 'text' | 'tree';

package/lib/modellist/model-list-filters/filters/model-list-autocomplete-filter/model-list-autocomplete-filter.component.d.ts

@@ -0,0 +1,30 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { ModelList } from '../../../model-list.service';
+import { ModelListAutocompleteFilter } from './model-list-autocomplete-filter';
+import { DataModel } from '../../../../data/data-model';
+import { Observable } from 'rxjs';
+import { UntypedFormControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class ModelListAutocompleteFilterComponent<T extends DataModel> implements OnInit, OnDestroy {
+    list: ModelList<any>;
+    filter: ModelListAutocompleteFilter<T>;
+    classes: string[] | string;
+    fc: UntypedFormControl;
+    search: (text$: Observable<string>) => Observable<T[]>;
+    display: (x: any) => any;
+    private _tpl;
+    private _subscription;
+    constructor();
+    ngOnInit(): void;
+    disable(): void;
+    ngOnDestroy(): void;
+    scrollAction($event: any): void;
+    private _setDisplay;
+    /**
+     * Display function. Uses descfield or desc tpl (lodash template using model fields).
+     */
+    private _display;
+    private _search;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListAutocompleteFilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListAutocompleteFilterComponent<any>, "data-model-list-autocomplete-filter", never, { "list": "list"; "filter": "filter"; "classes": "classes"; }, {}, never, never, true>;
+}

package/lib/modellist/model-list-filters/filters/model-list-autocomplete-filter/model-list-autocomplete-filter.d.ts

@@ -0,0 +1,22 @@
+import { ModelListFilter, ModelListFilterParams } from '../../model-list-filter';
+import { DataModel } from '../../../../data/data-model';
+import { Collection } from '../../../../data/data-collection';
+import { FilterData, Queryset } from '../../../../data/data-query';
+import { TplFun } from '../../../../dispedit/fkselect/fkselect.component';
+export interface ModelListAutocompleteParams<T extends DataModel> extends ModelListFilterParams {
+    collection?: Collection<T>;
+    queryset?: Queryset<T>;
+    searchparam?: string;
+    display?: string | TplFun<T>;
+    filter?: FilterData;
+    scroll?: boolean;
+}
+export declare class ModelListAutocompleteFilter<T extends DataModel> extends ModelListFilter implements ModelListAutocompleteParams<T> {
+    display?: string | TplFun<T>;
+    searchparam: string;
+    queryset: Queryset<T>;
+    collection?: Collection<T>;
+    filter: FilterData;
+    scroll: boolean;
+    constructor(params: ModelListAutocompleteParams<T>);
+}

package/lib/modellist/model-list-filters/filters/model-list-autocomplete-multi-filter/model-list-autocomplete-multi-filter.component.d.ts

@@ -0,0 +1,10 @@
+import { ModelListAutocompleteMultiFilter } from './model-list-autocomplete-multi-filter';
+import { DataModel } from '../../../../data/data-model';
+import { ModelListAutocompleteFilterComponent } from '../model-list-autocomplete-filter/model-list-autocomplete-filter.component';
+import * as i0 from "@angular/core";
+export declare class ModelListAutocompleteMultiFilterComponent<T extends DataModel> extends ModelListAutocompleteFilterComponent<T> {
+    filter: ModelListAutocompleteMultiFilter<T>;
+    unset(value: any, desc: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListAutocompleteMultiFilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListAutocompleteMultiFilterComponent<any>, "data-model-list-autocomplete-multi-filter", never, { "filter": "filter"; }, {}, never, never, true>;
+}

package/lib/modellist/model-list-filters/filters/model-list-autocomplete-multi-filter/model-list-autocomplete-multi-filter.d.ts

@@ -0,0 +1,8 @@
+import { ModelListAutocompleteFilter, ModelListAutocompleteParams } from '../model-list-autocomplete-filter/model-list-autocomplete-filter';
+import { DataModel } from '../../../../data/data-model';
+export interface ModelListAutocompleteMultiParams<T extends DataModel> extends ModelListAutocompleteParams<T> {
+}
+export declare class ModelListAutocompleteMultiFilter<T extends DataModel> extends ModelListAutocompleteFilter<T> {
+    multi: boolean;
+    constructor(params: ModelListAutocompleteMultiParams<T>);
+}

package/lib/modellist/model-list-filters/filters/model-list-date-filter/model-list-date-filter.component.d.ts

@@ -0,0 +1,15 @@
+import { ModelList } from '../../../model-list.service';
+import { ModelListDateFilter } from './model-list-date-filter';
+import { FormControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class ModelListDateFilterComponent {
+    list: ModelList<any>;
+    filter: ModelListDateFilter;
+    classes: string[] | string;
+    fc: FormControl<any>;
+    constructor();
+    ngOnInit(): void;
+    disable(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListDateFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListDateFilterComponent, "data-model-list-date-filter", never, { "list": "list"; "filter": "filter"; "classes": "classes"; }, {}, never, never, true>;
+}

package/lib/modellist/model-list-filters/filters/model-list-date-filter/model-list-date-filter.d.ts

@@ -0,0 +1,4 @@
+import { ModelListFilter, ModelListFilterParams } from '../../model-list-filter';
+export declare class ModelListDateFilter extends ModelListFilter {
+    constructor(params: ModelListFilterParams);
+}

package/lib/modellist/model-list-filters/filters/model-list-datetime-filter/model-list-datetime-filter.component.d.ts

@@ -0,0 +1,15 @@
+import { ModelList } from '../../../model-list.service';
+import { ModelListDatetimeFilter } from './model-list-datetime-filter';
+import { FormControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class ModelListDatetimeFilterComponent {
+    list: ModelList<any>;
+    filter: ModelListDatetimeFilter;
+    classes: string[] | string;
+    fc: FormControl<any>;
+    constructor();
+    ngOnInit(): void;
+    disable(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListDatetimeFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListDatetimeFilterComponent, "data-model-list-datetime-filter", never, { "list": "list"; "filter": "filter"; "classes": "classes"; }, {}, never, never, true>;
+}

package/lib/modellist/model-list-filters/filters/model-list-datetime-filter/model-list-datetime-filter.d.ts

@@ -0,0 +1,4 @@
+import { ModelListFilter, ModelListFilterParams } from "../../model-list-filter";
+export declare class ModelListDatetimeFilter extends ModelListFilter {
+    constructor(params: ModelListFilterParams);
+}

package/lib/modellist/model-list-filters/filters/model-list-datetimerange-filter/model-list-datetime-range-filter.component.d.ts

@@ -0,0 +1,11 @@
+import { ModelList } from '../../../model-list.service';
+import { ModelListDatetimerangeFilter } from './model-list-datetimerange-filter';
+import * as i0 from "@angular/core";
+export declare class ModelListDatetimeRangeFilterComponent {
+    list: ModelList<any>;
+    filter: ModelListDatetimerangeFilter;
+    classes: string[] | string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListDatetimeRangeFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListDatetimeRangeFilterComponent, "data-model-list-datetime-range-filter", never, { "list": "list"; "filter": "filter"; "classes": "classes"; }, {}, never, never, true>;
+}

package/lib/modellist/model-list-filters/filters/model-list-datetimerange-filter/model-list-datetimerange-filter.d.ts

@@ -0,0 +1,4 @@
+import { ModelListFilter, ModelListFilterParams } from "../../model-list-filter";
+export declare class ModelListDatetimerangeFilter extends ModelListFilter {
+    constructor(params: ModelListFilterParams);
+}

package/lib/modellist/model-list-filters/filters/model-list-flags-filter/model-list-flags-filter.component.d.ts

@@ -0,0 +1,11 @@
+import { ModelList } from '../../../model-list.service';
+import { ModelListFlagsFilter } from './model-list-flags-filter';
+import * as i0 from "@angular/core";
+export declare class ModelListFlagsFilterComponent {
+    list: ModelList<any>;
+    filter: ModelListFlagsFilter;
+    classes: string[] | string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListFlagsFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListFlagsFilterComponent, "data-model-list-flags-filter", never, { "list": "list"; "filter": "filter"; "classes": "classes"; }, {}, never, never, true>;
+}

package/lib/modellist/model-list-filters/filters/model-list-flags-filter/model-list-flags-filter.d.ts

@@ -0,0 +1,4 @@
+import { ModelListFilter, ModelListFilterParams } from "../../model-list-filter";
+export declare class ModelListFlagsFilter extends ModelListFilter {
+    constructor(params: ModelListFilterParams);
+}

package/lib/modellist/model-list-filters/filters/model-list-geodistance-filter/adapters/ban.d.ts

@@ -0,0 +1,35 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { GeoSearchResult } from '../model-list-geodistance-filter';
+export interface BanResults {
+    type: 'FeatureCollection';
+    version: string;
+    features: {
+        type: 'Feature';
+        geometry: {
+            type: 'Point';
+            coordinates: [number, number];
+        };
+        properties: {
+            label: string;
+            score: number;
+            id: string;
+            type: string;
+            name: string;
+            postcode: string;
+            citycode: string;
+            x: number;
+            y: number;
+            population: number;
+            city: string;
+            context: string;
+            importance: number;
+        };
+    }[];
+}
+export declare class BanAdapter {
+    private _http;
+    private _baseUrl;
+    constructor(_http: HttpClient, _baseUrl: string);
+    search(text: string): Observable<GeoSearchResult[]>;
+}

package/lib/modellist/model-list-filters/filters/model-list-geodistance-filter/model-list-geodistance-filter.component.d.ts

@@ -0,0 +1,25 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { ModelList } from '../../../model-list.service';
+import { GeoSearchResult, ModelListGeodistanceFilter } from './model-list-geodistance-filter';
+import { FormControl } from '@angular/forms';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ModelListGeodistanceFilterComponent implements OnInit, OnDestroy {
+    list: ModelList<any>;
+    filter: ModelListGeodistanceFilter;
+    classes: string[] | string;
+    fc: FormControl<any>;
+    fd: FormControl<string | null>;
+    search: (text$: Observable<string>) => Observable<GeoSearchResult[]>;
+    display: (x: GeoSearchResult) => any;
+    private _subscription;
+    constructor();
+    ngOnInit(): void;
+    disable(): void;
+    ngOnDestroy(): void;
+    private _display;
+    private _search;
+    scrollAction($event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListGeodistanceFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListGeodistanceFilterComponent, "data-model-list-geodistance-filter", never, { "list": "list"; "filter": "filter"; "classes": "classes"; }, {}, never, never, true>;
+}

package/lib/modellist/model-list-filters/filters/model-list-geodistance-filter/model-list-geodistance-filter.d.ts

@@ -0,0 +1,18 @@
+import { ModelListFilter, ModelListFilterParams } from '../../model-list-filter';
+import { Observable } from 'rxjs';
+export interface GeoSearchResult {
+    score: number;
+    label: string;
+    lat: number;
+    lng: number;
+}
+export interface ModelListGeodistanceFilterParams extends ModelListFilterParams {
+    geolocator: (pos: string) => Observable<GeoSearchResult[]>;
+    geomap?: (pos: [number, number], dist: number) => string;
+    scroll?: boolean;
+}
+export declare class ModelListGeodistanceFilter extends ModelListFilter implements ModelListGeodistanceFilterParams {
+    geolocator: (pos: string) => Observable<GeoSearchResult[]>;
+    scroll: boolean;
+    constructor(params: ModelListGeodistanceFilterParams);
+}

package/lib/modellist/model-list-filters/filters/model-list-number-filter/model-list-number-filter.component.d.ts

@@ -0,0 +1,17 @@
+import { OnInit } from '@angular/core';
+import { ModelList } from '../../../model-list.service';
+import { UntypedFormControl } from '@angular/forms';
+import { ModelListNumberFilter } from './model-list-number-filter';
+import * as i0 from "@angular/core";
+export declare class ModelListNumberFilterComponent implements OnInit {
+    list: ModelList<any>;
+    filter: ModelListNumberFilter;
+    classes: string[] | string;
+    fc: UntypedFormControl;
+    constructor();
+    ngOnInit(): void;
+    disable(): void;
+    selectOp(eq: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListNumberFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListNumberFilterComponent, "data-model-list-number-filter", never, { "list": "list"; "filter": "filter"; "classes": "classes"; }, {}, never, never, true>;
+}

package/lib/modellist/model-list-filters/filters/model-list-number-filter/model-list-number-filter.d.ts

@@ -0,0 +1,19 @@
+import { ModelListFilter, ModelListFilterParams } from '../../model-list-filter';
+import { FilterData } from '../../../../data/data-query';
+interface OperationDescriptor {
+    name: string;
+    label: string;
+    operator: string;
+}
+export declare const ModelListNumberOperations: OperationDescriptor[];
+export interface ModelListNumberFilterParams extends ModelListFilterParams {
+    operations?: string[];
+}
+export declare class ModelListNumberFilter extends ModelListFilter {
+    operator: OperationDescriptor;
+    operations: OperationDescriptor[];
+    constructor(params: ModelListNumberFilterParams);
+    setOperator(op: string): void;
+    updateFilter(filter: FilterData): void;
+}
+export {};

package/lib/modellist/model-list-filters/filters/model-list-select-filter/model-list-select-filter.component.d.ts

@@ -0,0 +1,17 @@
+import { OnInit } from '@angular/core';
+import { ModelList } from '../../../model-list.service';
+import { ModelListSelectFilter } from './model-list-select-filter';
+import { FormControl } from '@angular/forms';
+import { DataModel } from '../../../../data/data-model';
+import * as i0 from "@angular/core";
+export declare class ModelListSelectFilterComponent<T extends DataModel> implements OnInit {
+    list: ModelList<T>;
+    filter: ModelListSelectFilter<T>;
+    classes: string[] | string;
+    fc: FormControl<null>;
+    constructor();
+    ngOnInit(): void;
+    disable(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListSelectFilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListSelectFilterComponent<any>, "data-model-list-select-filter", never, { "list": "list"; "filter": "filter"; "classes": "classes"; }, {}, never, never, true>;
+}

package/lib/modellist/model-list-filters/filters/model-list-select-filter/model-list-select-filter.d.ts

@@ -0,0 +1,16 @@
+import { ModelListFilter, ModelListFilterParams } from '../../model-list-filter';
+import { IDispEditChoice } from '../../../../dispedit/dispedit/dispedit.constants';
+import { DataModel } from '../../../../data/data-model';
+import { DataModelType } from '../../../../data/data-collection';
+import { Observable } from 'rxjs';
+export interface ModelListSelectFilterParams<T extends DataModel> extends ModelListFilterParams {
+    choices?: IDispEditChoice[] | Observable<IDispEditChoice[]>;
+    model?: DataModelType<T>;
+    mfield?: string;
+}
+export declare class ModelListSelectFilter<T extends DataModel> extends ModelListFilter implements ModelListSelectFilterParams<T> {
+    choices: Observable<IDispEditChoice[]>;
+    model?: DataModelType<T>;
+    mfield?: string;
+    constructor(params: ModelListSelectFilterParams<T>);
+}

package/lib/modellist/model-list-filters/filters/model-list-select-multi-filter/model-list-select-multi-filter.component.d.ts

@@ -0,0 +1,17 @@
+import { ModelList } from '../../../model-list.service';
+import { ModelListSelectMultiFilter } from './model-list-select-multi-filter';
+import { FormControl } from '@angular/forms';
+import { DataModel } from '../../../../data/data-model';
+import * as i0 from "@angular/core";
+export declare class ModelListSelectMultiFilterComponent<T extends DataModel> {
+    list: ModelList<T>;
+    filter: ModelListSelectMultiFilter<T>;
+    classes: string[] | string;
+    fc: FormControl<null>;
+    constructor();
+    ngOnInit(): void;
+    unset(value: any, desc: string): void;
+    disable(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListSelectMultiFilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListSelectMultiFilterComponent<any>, "data-model-list-select-multi-filter", never, { "list": "list"; "filter": "filter"; "classes": "classes"; }, {}, never, never, true>;
+}

package/lib/modellist/model-list-filters/filters/model-list-select-multi-filter/model-list-select-multi-filter.d.ts

@@ -0,0 +1,6 @@
+import { ModelListSelectFilter, ModelListSelectFilterParams } from '../model-list-select-filter/model-list-select-filter';
+import { DataModel } from '../../../../data/data-model';
+export declare class ModelListSelectMultiFilter<T extends DataModel> extends ModelListSelectFilter<T> {
+    multi: boolean;
+    constructor(params: ModelListSelectFilterParams<T>);
+}

package/lib/modellist/model-list-filters/filters/model-list-text-filter/model-list-text-filter.component.d.ts

@@ -0,0 +1,16 @@
+import { OnInit } from '@angular/core';
+import { ModelList } from '../../../model-list.service';
+import { UntypedFormControl } from '@angular/forms';
+import { ModelListTextFilter } from './model-list-text-filter';
+import * as i0 from "@angular/core";
+export declare class ModelListTextFilterComponent implements OnInit {
+    list: ModelList<any>;
+    filter: ModelListTextFilter;
+    classes: string[] | string;
+    fc: UntypedFormControl;
+    constructor();
+    ngOnInit(): void;
+    disable(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListTextFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListTextFilterComponent, "data-model-list-text-filter", never, { "list": "list"; "filter": "filter"; "classes": "classes"; }, {}, never, never, true>;
+}

package/lib/modellist/model-list-filters/filters/model-list-text-filter/model-list-text-filter.d.ts

@@ -0,0 +1,4 @@
+import { ModelListFilter, ModelListFilterParams } from "../../model-list-filter";
+export declare class ModelListTextFilter extends ModelListFilter {
+    constructor(params: ModelListFilterParams);
+}

package/lib/modellist/model-list-filters/filters/model-list-tree-filter/model-list-tree-filter.component.d.ts

@@ -0,0 +1,11 @@
+import { ModelList } from '../../../model-list.service';
+import { ModelListTreeFilter } from './model-list-tree-filter';
+import * as i0 from "@angular/core";
+export declare class ModelListTreeFilterComponent {
+    list: ModelList<any>;
+    filter: ModelListTreeFilter;
+    classes: string[] | string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListTreeFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListTreeFilterComponent, "data-model-list-tree-filter", never, { "list": "list"; "filter": "filter"; "classes": "classes"; }, {}, never, never, true>;
+}

package/lib/modellist/model-list-filters/filters/model-list-tree-filter/model-list-tree-filter.d.ts

@@ -0,0 +1,4 @@
+import { ModelListFilter, ModelListFilterParams } from "../../model-list-filter";
+export declare class ModelListTreeFilter extends ModelListFilter {
+    constructor(params: ModelListFilterParams);
+}

package/lib/modellist/model-list-filters/model-list-filter.d.ts

@@ -0,0 +1,52 @@
+import { FilterData } from '../../data/data-query';
+import { Observable, ReplaySubject } from 'rxjs';
+import { FILTER_TYPE } from './filters/filtertypes';
+import { IDispEditChoice } from '../../dispedit/dispedit/dispedit.constants';
+export interface ModelListFilterParams {
+    name: string;
+    field: string;
+    label?: string;
+    help?: string;
+    value?: any;
+    desc?: any;
+    displayClasses?: string[] | string;
+}
+export declare class ModelListFilter implements ModelListFilterParams {
+    name: string;
+    field: string;
+    label: string;
+    help: string;
+    desc?: any;
+    type: FILTER_TYPE;
+    allowed: boolean;
+    enabled: boolean;
+    displayClasses?: string[] | string;
+    pristine: boolean;
+    multi: boolean;
+    /** Single current value */
+    protected _value: IDispEditChoice | null;
+    /** Multiple current value */
+    protected _mvalue: Map<string, string>;
+    /** Single current value observable */
+    protected _current: ReplaySubject<IDispEditChoice | null>;
+    /** Multiple current value observable */
+    protected _mcurrent: ReplaySubject<IDispEditChoice[]>;
+    constructor(params: ModelListFilterParams);
+    get mcurrent$(): Observable<IDispEditChoice[]>;
+    get current$(): Observable<IDispEditChoice | null>;
+    get valueChanges(): Observable<IDispEditChoice | IDispEditChoice[] | null>;
+    updateFilter(filter: FilterData): void;
+    clear(notify?: boolean): void;
+    set(value: any, desc: string, notify?: boolean): boolean;
+    unset(value: any, desc: string, notify?: boolean): boolean;
+    toggle(value: any, desc: string, notify?: boolean): boolean;
+    getValue(): string | number;
+    private mtoggle;
+    private mset;
+    private munset;
+    private stoggle;
+    private sset;
+    private sunset;
+    private getMultiValue;
+    private notify;
+}

package/lib/modellist/model-list-filters/model-list-filters/model-list-filters.component.d.ts

@@ -0,0 +1,9 @@
+import { ModelList } from '../../model-list.service';
+import * as i0 from "@angular/core";
+export declare class ModelListFiltersComponent {
+    list: ModelList<any>;
+    containerClasses: string[] | string;
+    itemClasses: string[] | string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListFiltersComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListFiltersComponent, "data-model-list-filters", never, { "list": "list"; "containerClasses": "containerClasses"; "itemClasses": "itemClasses"; }, {}, never, never, true>;
+}

package/lib/modellist/model-list-filters/model-list-filters-select/model-list-filters-select.component.d.ts

@@ -0,0 +1,13 @@
+import { ModelList } from '../../model-list.service';
+import { ModelListFilter } from '../model-list-filter';
+import * as i0 from "@angular/core";
+export declare class ModelListFiltersSelectComponent {
+    list: ModelList<any>;
+    containerClasses: string[] | string;
+    itemActiveClasses: string[] | string;
+    itemInactiveClasses: string[] | string;
+    constructor();
+    toggle(f: ModelListFilter): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListFiltersSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListFiltersSelectComponent, "data-model-list-filters-select", never, { "list": "list"; "containerClasses": "containerClasses"; "itemActiveClasses": "itemActiveClasses"; "itemInactiveClasses": "itemInactiveClasses"; }, {}, never, never, true>;
+}