@smartsoft001/crud-shell-angular 2.76.0 → 2.80.0

package/index.d.ts

@@ -0,0 +1,632 @@
+import * as i0 from '@angular/core';
+import { OnInit, Type, Signal, InputSignal, OnDestroy, WritableSignal, AfterContentInit, PipeTransform, ModuleWithProviders, ViewContainerRef, TemplateRef, InjectionToken } from '@angular/core';
+import * as _smartsoft001_angular from '@smartsoft001/angular';
+import { BaseComponent as BaseComponent$1, IButtonOptions, PaginationMode, ICellPipe, ListMode, IIconButtonOptions, InputBaseComponent, IListOptions, IFormOptions, DynamicComponentType, FormComponent, IDetailsOptions, IPageOptions, DynamicContentDirective, IListPaginationOptions } from '@smartsoft001/angular';
+import { IEntity } from '@smartsoft001/domain-core';
+import * as _smartsoft001_models from '@smartsoft001/models';
+import { IModelFilter } from '@smartsoft001/models';
+import { TranslateService } from '@ngx-translate/core';
+import * as i17 from '@angular/forms';
+import * as i18 from '@angular/common';
+import * as i19 from 'ng-dynamic-component';
+import { Subscription, Observable } from 'rxjs';
+import * as i7 from '@angular/router';
+import { HttpClient } from '@angular/common/http';
+
+declare class ExportComponent<T extends IEntity<string>> extends BaseComponent$1 implements OnInit {
+    private facade;
+    private popoverService;
+    private styleService;
+    private elementRef;
+    buttonExportCsvOptions: IButtonOptions;
+    buttonExportXlsxOptions: IButtonOptions;
+    ngOnInit(): void;
+    private initButtonExportOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExportComponent<any>, "smart-crud-export", never, {}, {}, never, never, true, never>;
+}
+
+interface ICrudFilter {
+    searchText?: string;
+    sortBy?: string;
+    sortDesc?: boolean;
+    offset?: number;
+    limit?: number;
+    paginationMode?: PaginationMode;
+    query?: Array<ICrudFilterQueryItem>;
+}
+interface ICrudFilterQueryItem extends IModelFilter {
+    key: string;
+    value: any;
+    type: '=' | '!=' | '>=' | '<=' | '<' | '>';
+    hidden?: boolean;
+}
+interface ICrudCreateManyOptions {
+    mode: CrudCreateManyMode;
+}
+interface ICrudListGroup {
+    key: string;
+    value: string;
+    text: string;
+    show?: boolean;
+    changed?: boolean;
+    children?: Array<ICrudListGroup>;
+}
+type CrudCreateManyMode = 'default' | 'replace';
+
+declare class FilterComponent {
+    FieldType: typeof _smartsoft001_models.FieldTypeDef;
+    item: i0.InputSignal<IModelFilter | undefined>;
+    filter: i0.InputSignal<ICrudFilter | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterComponent, "smart-crud-filter", never, { "item": { "alias": "item"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CrudConfig<T> {
+    apiUrl: string;
+    entity: string;
+    type?: any;
+    reducerFactory?: () => any;
+    baseQuery?: Array<ICrudFilterQueryItem>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrudConfig<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CrudConfig<any>>;
+}
+declare class CrudFullConfig<T> extends CrudConfig<T> {
+    title: string;
+    details?: boolean | {
+        cellPipe?: ICellPipe<T>;
+        components?: {
+            top?: any;
+            bottom?: any;
+        };
+    };
+    edit?: boolean | {
+        cellPipe?: ICellPipe<T>;
+        components?: {
+            top?: any;
+            bottom?: any;
+        };
+    };
+    add?: boolean | {
+        components?: {
+            top?: any;
+            bottom?: any;
+        };
+    };
+    remove?: boolean;
+    search?: boolean;
+    export?: boolean;
+    pagination?: {
+        limit: number;
+    };
+    sort?: boolean | {
+        default?: string;
+        defaultDesc?: boolean;
+    };
+    list?: {
+        cellPipe?: ICellPipe<T>;
+        components?: {
+            top?: any;
+            multi?: any;
+        };
+        mode?: ListMode;
+        paginationMode?: PaginationMode;
+        resetQuery?: 'beforeInit';
+        groups?: Array<ICrudListGroup>;
+    };
+    buttons?: Array<IIconButtonOptions>;
+    inputComponents?: {
+        [key: string]: Type<InputBaseComponent<T>>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrudFullConfig<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CrudFullConfig<any>>;
+}
+
+declare class CrudFacade<T extends IEntity<string>> {
+    private config;
+    private store;
+    loaded: Signal<boolean>;
+    loading: Signal<boolean>;
+    selected: Signal<T | undefined>;
+    multiSelected: Signal<T[] | undefined>;
+    list: Signal<T[] | undefined>;
+    filter: Signal<ICrudFilter | undefined>;
+    totalCount: Signal<number | undefined>;
+    links: Signal<any>;
+    error: Signal<any>;
+    constructor(config: CrudConfig<T>);
+    create(item: T): void;
+    createMany(items: Array<T>, options: ICrudCreateManyOptions): void;
+    read(filter?: ICrudFilter | null): void;
+    clear(): void;
+    select(id: string): void;
+    unselect(): void;
+    multiSelect(items: Array<T>): void;
+    update(item: T): void;
+    export(filter?: ICrudFilter | null, format?: string | null): void;
+    updatePartial(item: Partial<T> & {
+        id: string;
+    }): void;
+    updatePartialMany(items: (Partial<T> & {
+        id: string;
+    })[]): void;
+    delete(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrudFacade<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CrudFacade<any>>;
+}
+
+declare class BaseComponent<T extends IEntity<string>> implements OnInit {
+    protected facade: CrudFacade<any>;
+    protected translateService: TranslateService;
+    possibilities: Signal<{
+        id: any;
+        text: string;
+    }[]>;
+    readonly item: InputSignal<IModelFilter | undefined>;
+    readonly filter: InputSignal<ICrudFilter | undefined>;
+    get value(): any;
+    set value(val: any);
+    get minValue(): any;
+    set minValue(val: any);
+    get maxValue(): any;
+    set maxValue(val: any);
+    get lang(): string;
+    refresh(val: any, type?: string | null): void;
+    clear(): void;
+    ngOnInit(): void;
+    private initPossibilities;
+    private isArrayType;
+    private refreshForArray;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseComponent<any>, never, never, { "item": { "alias": "item"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FilterDateComponent<T extends IEntity<string>> extends BaseComponent<T> {
+    id: string;
+    get allowAdvanced(): boolean;
+    set customValue(val: any);
+    get customValue(): any;
+    set customMinValue(val: any);
+    get customMinValue(): any;
+    set customMaxValue(val: any);
+    get customMaxValue(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterDateComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterDateComponent<any>, "smart-crud-filter-date", never, {}, {}, never, never, true, never>;
+}
+
+declare class FilterDateWithEditComponent<T extends IEntity<string>> extends FilterDateComponent<T> implements OnInit, OnDestroy {
+    private _subscriptions;
+    advanced: WritableSignal<boolean>;
+    id: string;
+    toggleAdvanced(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterDateWithEditComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterDateWithEditComponent<any>, "smart-crud-filter-date-with-edit", never, {}, {}, never, never, true, never>;
+}
+
+declare class FilterDateTimeComponent<T extends IEntity<string>> extends FilterDateComponent<T> implements OnInit, OnDestroy {
+    private _subscriptions;
+    id: string;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterDateTimeComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterDateTimeComponent<any>, "smart-crud-filter-date-time", never, {}, {}, never, never, true, never>;
+}
+
+declare class FilterRadioComponent<T extends IEntity<string>> extends BaseComponent<T> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterRadioComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterRadioComponent<any>, "smart-crud-filter-radio", never, {}, {}, never, never, true, never>;
+}
+
+declare class FilterTextComponent<T extends IEntity<string>> extends BaseComponent<T> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterTextComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterTextComponent<any>, "smart-crud-filter-text", never, {}, {}, never, never, true, never>;
+}
+
+declare class FilterFlagComponent<T extends IEntity<string>> extends BaseComponent<T> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterFlagComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterFlagComponent<any>, "smart-crud-filter-flag", never, {}, {}, never, never, true, never>;
+}
+
+declare class FilterCheckComponent<T extends IEntity<string>> extends BaseComponent<T> implements AfterContentInit {
+    list: Signal<{
+        value: any;
+        isCheck: boolean;
+    }[]>;
+    ngAfterContentInit(): void;
+    onCheckChange(checked: boolean, entry: {
+        value: any;
+        isCheck: boolean;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterCheckComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterCheckComponent<any>, "smart-crud-filter-check", never, {}, {}, never, never, true, never>;
+}
+
+declare class FilterIntComponent<T extends IEntity<string>> extends BaseComponent<T> implements OnInit, OnDestroy {
+    private _subscriptions;
+    advanced: WritableSignal<boolean>;
+    get allowAdvanced(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    toggleAdvanced(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterIntComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterIntComponent<any>, "smart-crud-filter-int", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * This component is only to use in crud module
+ * @requires CrudModule
+ * @example
+ *
+ * html: <smart-crud-filters></smart-crud-filters>
+ *
+ * use on the model:
+ * @Model({
+    titleKey: 'body',
+    filters: [
+        {
+            label: 'testNegation',
+            key: 'body',
+            type: '!=',
+        },
+        {
+            label: 'fromDate',
+            key: 'createDate',
+            type: '<=',
+            fieldType: FieldType.dateWithEdit
+        },
+        {
+            label: 'select',
+            key: 'type',
+            type: '=',
+            fieldType: FieldType.radio,
+            possibilities$: of([
+                {
+                    id: 1, text: 'Test 1'
+                },
+                {
+                    id: 2, text: 'Test 2'
+                }
+            ])
+        }
+    ]
+})
+ *
+ * use on the field (list.filter property):
+ * @Field({
+        create: modifyMetdata,
+        update: {
+            ...modifyMetdata,
+            multi: true
+        },
+        type: FieldType.longText,
+        details: true,
+        list: {
+            order: 2,
+            filter: true
+        }
+    })
+ body: string;
+ */
+declare class FiltersComponent<T extends IEntity<string>> implements OnInit {
+    private menuService;
+    private config;
+    private facade;
+    private styleService;
+    private elementRef;
+    list: WritableSignal<Array<IModelFilter>>;
+    filter: Signal<ICrudFilter | undefined>;
+    /**
+     * Hide menu used only from MenuService
+     */
+    readonly hideMenu: InputSignal<boolean>;
+    onClose(): Promise<void>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FiltersComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FiltersComponent<any>, "smart-crud-filters", never, { "hideMenu": { "alias": "hideMenu"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FiltersConfigComponent implements OnInit {
+    private readonly facade;
+    private styleService;
+    private elementRef;
+    query: Signal<ICrudFilterQueryItem[]>;
+    onRemoveQuery(item: ICrudFilterQueryItem): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FiltersConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FiltersConfigComponent, "smart-crud-filters-config", never, {}, {}, never, never, true, never>;
+}
+
+declare class MultiselectComponent<T extends IEntity<string>> {
+    private facade;
+    config: CrudFullConfig<T>;
+    private menuService;
+    private _list;
+    private _changes;
+    item: T;
+    valid: boolean;
+    buttonOptions: IButtonOptions;
+    lock: boolean;
+    showForm: boolean;
+    list: Signal<T[]>;
+    constructor();
+    onClose(): Promise<void>;
+    onPartialChange(changes: Partial<T>, list: Array<T>): void;
+    onValidChange(valid: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiselectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiselectComponent<any>, "smart-crud-multiselect", never, {}, {}, never, never, true, never>;
+}
+
+declare class GroupComponent<T extends IEntity<string>> extends BaseComponent$1 implements OnInit, OnDestroy {
+    private styleService;
+    private elementRef;
+    private groupService;
+    readonly groups: InputSignal<Array<ICrudListGroup> | undefined>;
+    readonly listOptions: InputSignal<IListOptions<T> | undefined>;
+    change(val: boolean, item: ICrudListGroup, force?: boolean): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GroupComponent<any>, "smart-crud-group", never, { "groups": { "alias": "groups"; "required": false; "isSignal": true; }; "listOptions": { "alias": "listOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FormOptionsPipe<T extends IEntity<string>> implements PipeTransform {
+    private modelPossibilitiesProvider;
+    transform(item: T, mode: string, type: any, uniqueProvider?: (values: Record<keyof T, any>) => Promise<boolean>, inputComponents?: {
+        [key: string]: Type<InputBaseComponent<any>>;
+    }): IFormOptions<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormOptionsPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormOptionsPipe<any>, "smartFormOptions", true>;
+}
+
+declare class CrudPipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrudPipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CrudPipesModule, never, [typeof FormOptionsPipe], [typeof FormOptionsPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CrudPipesModule>;
+}
+
+declare class CrudComponentsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrudComponentsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CrudComponentsModule, never, [typeof ExportComponent, typeof FilterComponent, typeof FilterTextComponent, typeof FiltersConfigComponent, typeof FilterDateComponent, typeof FilterDateWithEditComponent, typeof FilterDateTimeComponent, typeof FilterRadioComponent, typeof FiltersComponent, typeof FilterFlagComponent, typeof FilterCheckComponent, typeof FilterIntComponent, typeof MultiselectComponent, typeof GroupComponent, typeof _smartsoft001_angular.SharedModule, typeof CrudPipesModule, typeof i17.FormsModule, typeof i18.CommonModule, typeof i19.DynamicIoModule], [typeof CrudPipesModule, typeof ExportComponent, typeof FilterComponent, typeof FilterTextComponent, typeof FiltersConfigComponent, typeof FilterDateComponent, typeof FilterDateWithEditComponent, typeof FilterDateTimeComponent, typeof FilterRadioComponent, typeof FiltersComponent, typeof FilterFlagComponent, typeof FilterCheckComponent, typeof FilterIntComponent, typeof MultiselectComponent, typeof GroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CrudComponentsModule>;
+}
+
+declare class CrudCoreModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrudCoreModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CrudCoreModule, never, [typeof _smartsoft001_angular.SharedModule, typeof CrudPipesModule, typeof i17.FormsModule, typeof i18.CommonModule, typeof CrudComponentsModule], [typeof CrudComponentsModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CrudCoreModule>;
+}
+declare class CrudModule<T extends IEntity<string>> {
+    static forFeature<T extends IEntity<string>>(options: ICrudModuleOptionsWithRoutng<T> | ICrudModuleOptionsWithoutRoutng<T>): ModuleWithProviders<CrudModule<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrudModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CrudModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CrudModule>;
+}
+interface ICrudModuleOptionsWithRoutng<T> {
+    config: CrudFullConfig<T>;
+    socket?: boolean;
+    routing: true;
+}
+interface ICrudModuleOptionsWithoutRoutng<T> {
+    config: CrudConfig<T>;
+    socket?: boolean;
+    routing: false;
+}
+
+declare abstract class CrudItemPageBaseComponent<T extends IEntity<string>> extends BaseComponent$1 {
+    config: CrudFullConfig<T>;
+    facade: CrudFacade<any>;
+    static smartType: DynamicComponentType;
+    selected: Signal<T>;
+    contentTpl: Signal<ViewContainerRef | undefined>;
+    formComponents: Signal<readonly FormComponent<any>[]>;
+    detailsOptions: i0.InputSignal<IDetailsOptions<T> | undefined>;
+    mode: i0.InputSignal<string | undefined>;
+    uniqueProvider: i0.InputSignal<((values: Record<keyof T, any>) => Promise<boolean>) | undefined>;
+    onPartialChange: i0.OutputEmitterRef<Partial<T>>;
+    onChange: i0.OutputEmitterRef<T>;
+    onValidChange: i0.OutputEmitterRef<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrudItemPageBaseComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CrudItemPageBaseComponent<any>, never, never, { "detailsOptions": { "alias": "detailsOptions"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "uniqueProvider": { "alias": "uniqueProvider"; "required": false; "isSignal": true; }; }, { "onPartialChange": "onPartialChange"; "onChange": "onChange"; "onValidChange": "onValidChange"; }, never, never, true, never>;
+}
+
+declare class ItemStandardComponent<T extends IEntity<string>> extends CrudItemPageBaseComponent<T> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemStandardComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ItemStandardComponent<any>, "smart-crud-item-standard-page", never, {}, {}, never, never, true, never>;
+}
+
+declare const ItemComponent_base: new () => _smartsoft001_angular.IDynamicComponent<CrudItemPageBaseComponent<any>>;
+declare class ItemComponent<T extends IEntity<string>> extends ItemComponent_base implements OnInit, OnDestroy {
+    private router;
+    private activeRoute;
+    private facade;
+    private service;
+    private dynamicComponentLoader;
+    private translateService;
+    config: CrudFullConfig<T>;
+    private location;
+    private cd;
+    private styleService;
+    private elementRef;
+    private toastService;
+    private pageService;
+    private detailsService;
+    private _mode;
+    pageOptions: WritableSignal<IPageOptions>;
+    detailsOptions: WritableSignal<IDetailsOptions<T>>;
+    id: string;
+    formValue: T;
+    formValid: boolean;
+    item: T;
+    formPartialValue: Partial<T>;
+    uniqueProvider: WritableSignal<(values: Record<keyof T, any>) => Promise<boolean>>;
+    set mode(val: string);
+    get mode(): string;
+    selected: Signal<T>;
+    standardComponents: Signal<readonly ItemStandardComponent<IEntity<string>>[]>;
+    contentTpl: Signal<TemplateRef<any> | undefined>;
+    topTpl: Signal<ViewContainerRef | undefined>;
+    bottomTpl: Signal<ViewContainerRef | undefined>;
+    dynamicContents: Signal<readonly DynamicContentDirective[]>;
+    subscription: Subscription;
+    constructor();
+    refreshProperties(): void;
+    ngOnInit(): Promise<void>;
+    ngOnDestroy(): void;
+    private generateComponents;
+    onPartialChange(val: Partial<T>): void;
+    onChange(val: T): void;
+    onValidChange(val: boolean): void;
+    private initPageOptions;
+    private getButtons;
+    private getTitle;
+    private removeParagraph;
+    private checkFirstInvalid;
+    private getInvalidFields;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ItemComponent<any>, "smart-crud-item-page", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare abstract class CrudListPageBaseComponent<T extends IEntity<string>> extends BaseComponent$1 {
+    config: CrudFullConfig<T>;
+    static smartType: DynamicComponentType;
+    contentTpl: i0.Signal<ViewContainerRef | undefined>;
+    listOptions: i0.InputSignal<IListOptions<T> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrudListPageBaseComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CrudListPageBaseComponent<any>, never, never, { "listOptions": { "alias": "listOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const ListComponent_base: new () => _smartsoft001_angular.IDynamicComponent<CrudListPageBaseComponent<any>>;
+declare class ListComponent<T extends IEntity<string>> extends ListComponent_base implements OnInit, OnDestroy {
+    private facade;
+    private router;
+    private dynamicComponentLoader;
+    private injector;
+    private cd;
+    private menuService;
+    private hardwareService;
+    private paginationFacade;
+    private pageService;
+    config: CrudFullConfig<T>;
+    private searchService;
+    private _cleanMultiSelected$;
+    pageOptions: Signal<IPageOptions>;
+    listOptions: WritableSignal<IListOptions<T>>;
+    links: {
+        next: any;
+        prev: any;
+    };
+    filter: Signal<ICrudFilter | undefined>;
+    topTpl: Signal<ViewContainerRef | undefined>;
+    contentTpl: Signal<TemplateRef<any> | undefined>;
+    dynamicContents: Signal<readonly DynamicContentDirective[]>;
+    constructor();
+    refreshProperties(): void;
+    ngOnInit(): Promise<void>;
+    private initCloseMenu;
+    private clear;
+    private getEndButtons;
+    private initTopComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListComponent<any>, "smart-crud-list-page", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ListStandardComponent<T extends IEntity<string>> extends CrudListPageBaseComponent<T> {
+    private readonly facade;
+    readonly config: CrudFullConfig<T>;
+    isSearch: Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListStandardComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListStandardComponent<any>, "smart-crud-list-standard-page", never, {}, {}, never, never, true, never>;
+}
+
+declare const PAGES: (typeof ItemStandardComponent | typeof ItemComponent | typeof ListStandardComponent | typeof ListComponent)[];
+declare class CrudFullModule<T extends IEntity<string>> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrudFullModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CrudFullModule, never, [typeof ItemComponent, typeof ListComponent, typeof ListStandardComponent, typeof ItemStandardComponent, typeof _smartsoft001_angular.SharedModule, typeof CrudPipesModule, typeof i7.RouterModule, typeof i17.FormsModule, typeof i18.CommonModule, typeof CrudComponentsModule], [typeof ItemComponent, typeof ListComponent, typeof ListStandardComponent, typeof ItemStandardComponent, typeof CrudComponentsModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CrudFullModule>;
+}
+
+declare class CrudListPaginationFactory<T extends IEntity<string>> {
+    private readonly facade;
+    create(options: {
+        mode?: PaginationMode;
+        limit: number;
+        provider: {
+            getLinks(): any;
+            getFilter(): ICrudFilter;
+        };
+    }): Promise<IListPaginationOptions>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrudListPaginationFactory<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CrudListPaginationFactory<any>>;
+}
+
+declare class CrudService<T extends IEntity<string>> {
+    protected config: CrudConfig<any>;
+    protected http: HttpClient;
+    protected _formatMap: {
+        csv: string;
+        xlsx: string;
+    };
+    create(item: T): Promise<string>;
+    createMany(items: Array<T>, options: ICrudCreateManyOptions): Promise<void>;
+    getById(id: string): Promise<T>;
+    getList<T>(filter?: ICrudFilter | null): Promise<{
+        data: T[];
+        totalCount: number;
+        links: any;
+    }>;
+    exportList(filter: (ICrudFilter | null) | undefined, format: 'csv' | 'xlsx'): Promise<void>;
+    update(item: T): Promise<void>;
+    updatePartial(item: Partial<T> & {
+        id: string;
+    }): Promise<void>;
+    updatePartialMany(items: (Partial<T> & {
+        id: string;
+    })[]): Promise<any>;
+    delete(id: string): Promise<void>;
+    protected getQuery(filter: ICrudFilter): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrudService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CrudService<any>>;
+}
+
+declare class PageService<T> {
+    private authService;
+    private config;
+    checkPermissions(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PageService<any>>;
+}
+
+declare class CrudSearchService {
+    private _filterSource;
+    private _enabledSource;
+    get filter(): Partial<ICrudFilter>;
+    get enabled(): boolean;
+    enabled$: Observable<boolean>;
+    filter$: Observable<Partial<ICrudFilter>>;
+    setFilter(val: Partial<ICrudFilter>): void;
+    setEnabled(val: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrudSearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CrudSearchService>;
+}
+
+/**
+ * @deprecated - please, use IModelPossibilitiesProvider from @smartsoft001/angular
+ */
+declare abstract class ICrudModelPossibilitiesProvider {
+    abstract get<T>(type: any): {
+        [key: string]: Observable<{
+            id: any;
+            text: string;
+        }[]>;
+    };
+}
+/**
+ * @deprecated - please, use MODEL_POSSIBILITIES_PROVIDER from @smartsoft001/angular
+ */
+declare const CRUD_MODEL_POSSIBILITIES_PROVIDER: InjectionToken<ICrudModelPossibilitiesProvider>;
+
+export { CRUD_MODEL_POSSIBILITIES_PROVIDER, CrudComponentsModule, CrudConfig, CrudCoreModule, CrudFacade, CrudFullConfig, CrudFullModule, CrudItemPageBaseComponent, CrudListPageBaseComponent, CrudListPaginationFactory, CrudModule, CrudPipesModule, CrudSearchService, CrudService, ExportComponent, FilterCheckComponent, FilterComponent, FilterDateComponent, FilterDateTimeComponent, FilterDateWithEditComponent, FilterFlagComponent, FilterIntComponent, FilterRadioComponent, FilterTextComponent, FiltersComponent, FiltersConfigComponent, FormOptionsPipe, GroupComponent, ICrudModelPossibilitiesProvider, ItemComponent, ItemStandardComponent, ListComponent, ListStandardComponent, MultiselectComponent, PAGES, PageService };
+export type { CrudCreateManyMode, ICrudCreateManyOptions, ICrudFilter, ICrudFilterQueryItem, ICrudListGroup, ICrudModuleOptionsWithRoutng, ICrudModuleOptionsWithoutRoutng };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartsoft001/crud-shell-angular",
-  "version": "2.76.0",
+  "version": "2.80.0",
   "description": "Utils and Angular components",
   "repository": {
     "type": "git",
@@ -17,5 +17,20 @@
     "url": "https://github.com/emiljuchnikowski/smartsoft/issues"
   },
   "homepage": "https://github.com/emiljuchnikowski/smartsoft#readme",
-  "peerDependencies": {}
-}
+  "peerDependencies": {},
+  "module": "fesm2022/smartsoft001-crud-shell-angular.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/smartsoft001-crud-shell-angular.mjs"
+    }
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}

package/.storybook/addons.js

@@ -1 +0,0 @@
-import '../../../../../.storybook/addons';

package/.storybook/config.js

@@ -1,5 +0,0 @@
-import { withKnobs } from '@storybook/addon-knobs';
-import { configure, addDecorator } from '@storybook/angular';
-
-addDecorator(withKnobs);
-configure(require.context('../src/lib', true, /\.stories\.(j|t)sx?$/), module);

package/.storybook/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "emitDecoratorMetadata": true
-  },
-  "exclude": ["../src/test.ts", "../**/*.spec.ts", "../**/*.test.ts"],
-  "include": ["../src/**/*"]
-}