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 _ngrx_store from '@ngrx/store';
import { Store, ActionsSubject, State as State$1, Action } from '@ngrx/store';
import * as i17 from '@angular/forms';
import * as i18 from '@angular/common';
import * as i19 from 'ng-dynamic-component';
import { HttpClient } from '@angular/common/http';
import { Subscription, Observable } from 'rxjs';
import * as i7 from '@angular/router';

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 readonly store;
    private config;
    readonly loaded: Signal<boolean | undefined>;
    readonly loading: Signal<boolean>;
    readonly selected: Signal<T | undefined>;
    readonly multiSelected: Signal<T[] | undefined>;
    readonly list: Signal<T[] | undefined>;
    readonly filter: Signal<ICrudFilter | undefined>;
    readonly totalCount: Signal<number | undefined>;
    readonly links: Signal<any>;
    readonly error: Signal<any>;
    constructor(store: Store<any>, config: CrudConfig<T>);
    create(item: T): void;
    createMany(items: Array<T>, options: ICrudCreateManyOptions): void;
    read(filter?: ICrudFilter): void;
    clear(): void;
    select(id: string): void;
    unselect(): void;
    multiSelect(items: Array<T>): void;
    update(item: T): void;
    export(filter?: ICrudFilter, format?: string): void;
    updatePartial(item: Partial<T> & {
        id: string;
    }): void;
    updatePartialMany(items: (Partial<T> & {
        id: string;
    })[]): void;
    delete(id: string): void;
    private getStore;
    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> | null>;
    readonly listOptions: InputSignal<IListOptions<T> | null>;
    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 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 CrudEffects<T extends IEntity<string>> {
    private actions$;
    private service;
    private config;
    private store;
    private state;
    constructor(actions$: ActionsSubject, service: CrudService<T>, config: CrudConfig<T>, store: Store<any>, state: State$1<any>);
    init(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CrudEffects<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CrudEffects<any>>;
}

declare class CrudCoreModule<T extends IEntity<string>> {
    constructor(config: CrudConfig<T>, effects: CrudEffects<any>);
    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>>;
    constructor(config: CrudConfig<T>, effects: CrudEffects<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> | null | 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: WritableSignal<IPageOptions | null>;
    listOptions: WritableSignal<IListOptions<T> | null>;
    links: Signal<any>;
    filter: Signal<ICrudFilter | undefined>;
    topTpl: Signal<ViewContainerRef | undefined>;
    contentTpl: Signal<TemplateRef<any> | undefined>;
    dynamicContents: Signal<readonly DynamicContentDirective[]>;
    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>> {
    constructor(config: CrudConfig<T>, effects: CrudEffects<any>);
    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 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>;
}

interface State<T extends IEntity<string>> {
    selected?: T;
    multiSelected?: Array<T>;
    list?: T[];
    totalCount?: number;
    filter?: ICrudFilter;
    links?: any;
    loaded: boolean;
    error?: string | null;
}
declare const initialState: State<any>;
declare function getReducer(entity: string): (state: any, action: Action) => State<any> | {
    loaded: boolean;
    error: any;
    selected?: any;
    multiSelected?: any[] | undefined;
    list?: any[] | undefined;
    totalCount?: number;
    filter?: ICrudFilter;
    links?: any;
} | {
    loaded: boolean;
    filter: any;
    error: null;
    totalCount: null;
    links: null;
    selected?: any;
    multiSelected?: any[] | undefined;
    list?: any[] | undefined;
} | {
    loaded: boolean;
    list: any[];
    totalCount: any;
    links: any;
    error: null;
    selected?: any;
    multiSelected?: any[] | undefined;
    filter?: ICrudFilter;
};

declare const getCrudState: (entity: string) => _ngrx_store.MemoizedSelector<object, any, _ngrx_store.DefaultProjectorFn<any>>;
declare const getCrudSelected: (entity: string) => _ngrx_store.MemoizedSelector<object, any, (s1: any) => any>;
declare const getCrudMultiSelected: (entity: string) => _ngrx_store.MemoizedSelector<object, any, (s1: any) => any>;
declare const getCrudList: (entity: string) => _ngrx_store.MemoizedSelector<object, any, (s1: any) => any>;
declare const getCrudTotalCount: (entity: string) => _ngrx_store.MemoizedSelector<object, any, (s1: any) => any>;
declare const getCrudLinks: (entity: string) => _ngrx_store.MemoizedSelector<object, any, (s1: any) => any>;
declare const getCrudLoaded: (entity: string) => _ngrx_store.MemoizedSelector<object, any, (s1: any) => any>;
declare const getCrudFilter: (entity: string) => _ngrx_store.MemoizedSelector<object, any, (s1: any) => any>;
declare const getCrudError: (entity: string) => _ngrx_store.MemoizedSelector<object, any, (s1: any) => any>;

/**
 * @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, getCrudError, getCrudFilter, getCrudLinks, getCrudList, getCrudLoaded, getCrudMultiSelected, getCrudSelected, getCrudState, getCrudTotalCount, getReducer, initialState };
export type { CrudCreateManyMode, ICrudCreateManyOptions, ICrudFilter, ICrudFilterQueryItem, ICrudListGroup, ICrudModuleOptionsWithRoutng, ICrudModuleOptionsWithoutRoutng, State };