import * as i0 from "@angular/core";
import { DestroyRef, InjectionToken, Injector, InputSignal, ModuleWithProviders, OnDestroy, OnInit, PipeTransform, Signal, TemplateRef, Type, ViewContainerRef, WritableSignal } from "@angular/core";
import * as i15 from "@smartsoft001/angular";
import { BaseComponent, DynamicComponentType, DynamicContentDirective, FormComponent, IButtonOptions, ICellPipe, IDetailsOptions, IFormOptions, IIconButtonOptions, IListOptions, IListPaginationOptions, IModelLabelOptions, IModelLabelProvider, IPageOptions, InputBaseComponent, InputOptions, ListMode, PaginationMode, SmartFormGroup, SmartPageVariant } from "@smartsoft001/angular";
import { IEntity } from "@smartsoft001/domain-core";
import { IFieldOptions, IModelFilter } from "@smartsoft001/models";
import * as i17 from "@angular/forms";
import { UntypedFormControl } from "@angular/forms";
import { TranslateService } from "@ngx-translate/core";
import { Action, ActionsSubject, State as State$1, Store } from "@ngrx/store";
import * as i18 from "@angular/common";
import * as i19 from "ng-dynamic-component";
import "reflect-metadata";
import { HttpClient } from "@angular/common/http";
import { Observable, Subscription } from "rxjs";
import * as i7 from "@angular/router";
export declare class ExportBaseComponent<T extends IEntity<string>> extends BaseComponent implements OnInit {
  private facade;
  private popoverService;
  private styleService;
  private elementRef;
  private injector;
  buttonExportCsvOptions: IButtonOptions;
  buttonExportXlsxOptions: IButtonOptions;
  ngOnInit(): void;
  private initButtonExportOptions;
  static ɵfac: i0.ɵɵFactoryDeclaration<ExportBaseComponent<any>, never>;
  static ɵdir: i0.ɵɵDirectiveDeclaration<ExportBaseComponent<any>, never, never, {}, {}, never, never, true, never>;
}
declare namespace export_component_d_exports {
  export { ExportComponent };
}
export declare class ExportComponent<T extends IEntity<string>> extends ExportBaseComponent<T> {
  static ɵfac: i0.ɵɵFactoryDeclaration<ExportComponent<any>, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<ExportComponent<any>, "smart-crud-export", never, {}, {}, never, never, true, never>;
}
export interface ICrudFilter {
  searchText?: string;
  sortBy?: string;
  sortDesc?: boolean;
  offset?: number;
  limit?: number;
  paginationMode?: PaginationMode;
  query?: Array<ICrudFilterQueryItem>;
}
export interface ICrudFilterQueryItem extends IModelFilter {
  key: string;
  value: any;
  type: '=' | '!=' | '>=' | '<=' | '<' | '>';
  hidden?: boolean;
}
export interface ICrudCreateManyOptions {
  mode: CrudCreateManyMode;
}
export interface ICrudListGroup {
  key: string;
  value: string;
  text: string;
  show?: boolean;
  changed?: boolean;
  children?: Array<ICrudListGroup>;
}
export type CrudCreateManyMode = 'default' | 'replace';
declare namespace filter_component_d_exports {
  export { FilterComponent };
}
export declare class FilterComponent {
  FieldType: typeof import("@smartsoft001/models").FieldTypeDef;
  item: import("@angular/core").InputSignal<IModelFilter | undefined>;
  filter: import("@angular/core").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>;
}
export 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<any>;
}
export 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>>;
  };
  cssClass?: string;
  variant?: SmartPageVariant;
  static ɵfac: i0.ɵɵFactoryDeclaration<CrudFullConfig<any>, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
export 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<any>;
}
declare class BaseComponent$1<T extends IEntity<string>> implements OnInit {
  protected facade: CrudFacade<any>;
  protected translateService: TranslateService;
  protected config: CrudConfig<any>;
  protected modelPossibilitiesProvider: import("@smartsoft001/crud-shell-angular").ICrudModelPossibilitiesProvider | null;
  protected injector: Injector;
  protected destroyRef: DestroyRef;
  private _model;
  /**
   * Local, mutation-free working copy of the last filter this component pushed
   * to `facade.read(...)`. The store-bound `filter()` input is frozen under
   * NgRx `strictStateImmutability`, so refresh/clear operate on a clone; the
   * read getters (`value`, `minValue`, `maxValue`, `hasValue`, …) prefer this
   * pending copy until the real store update flows back through the input.
   */
  private _pendingFilter;
  /** Snapshot of `filter()` that `_pendingFilter` was derived from. */
  private _pendingFilterSource;
  possibilities: Signal<{
    id: any;
    text: string;
  }[]>;
  readonly item: InputSignal<IModelFilter | undefined>;
  readonly filter: InputSignal<ICrudFilter | undefined>;
  /**
   * The filter the component should read from: the pending working copy when it
   * is still in sync with the current input, otherwise the raw input. Once the
   * store update arrives (a new `filter()` reference), the pending copy is
   * considered stale and the fresh input wins.
   */
  protected readonly effectiveFilter: Signal<ICrudFilter | undefined>;
  /**
   * OnPush-safe replacement for `@if (value)` in templates (partial GAP-19).
   * True when filter().query has a matching entry (key + type) with a
   * non-empty value.
   */
  readonly hasValue: Signal<boolean>;
  /**
   * OnPush-safe replacement for `@if (minValue)` in templates (partial
   * GAP-19). True when filter().query has a matching `>=` entry (range "from")
   * with a non-empty value.
   */
  readonly hasMinValue: Signal<boolean>;
  /**
   * OnPush-safe replacement for `@if (maxValue)` in templates (partial
   * GAP-19). True when filter().query has a matching `<=` entry (range "to")
   * with a non-empty value.
   */
  readonly hasMaxValue: Signal<boolean>;
  /** Lazily-built model instance used to derive field options/labels. */
  protected get model(): T;
  get value(): any;
  set value(val: any);
  get minValue(): any;
  set minValue(val: any);
  get maxValue(): any;
  set maxValue(val: any);
  get lang(): string;
  /**
   * Returns a filter object safe to mutate. The store-bound `filter()` input is
   * frozen under NgRx `strictStateImmutability`, so when (any part of) the
   * source is frozen we hand back a deep-enough clone — object + query array +
   * query entries — leaving the store untouched. When the source is a plain,
   * extensible object (no immutability checks active) we keep operating on it in
   * place so consumers that hold the same reference still observe the change.
   */
  private cloneFilter;
  /**
   * True when `filter` (and its query array + entries) can be mutated directly,
   * i.e. nothing is frozen.
   */
  private isMutationSafe;
  /**
   * Records the mutated clone as the pending working copy (so read getters
   * reflect it immediately) and dispatches it through the facade.
   */
  private commitFilter;
  refresh(val: any, type?: string | null): void;
  /**
   * Builds the `InputOptions` consumed by shared `smart-input-*` components for
   * a single reactive control. When `withPossibilities` is true (radio/select
   * style filters) the base `possibilities` signal is mapped into the
   * `{ id, text, checked }` shape the shared inputs expect; otherwise it is
   * omitted (text/flag filters do not need possibilities).
   */
  protected buildInputOptions(control: UntypedFormControl, withPossibilities?: boolean): InputOptions<any>;
  /**
   * Creates a reactive control bridged to the legacy filter state for a given
   * query slot: seeded from the current query value for that slot (`null` ->
   * `value` / `item.type`, `'>='` -> `minValue`, `'<='` -> `maxValue`), and
   * wired so every change re-runs the (debounced) `refresh` for that slot.
   */
  protected bindControl(type?: string | null): UntypedFormControl;
  /**
   * Creates a reactive control bridged to the default (`value` / `item.type`)
   * query slot.
   */
  protected bindValueControl(): UntypedFormControl;
  clear(): void;
  ngOnInit(): void;
  private initPossibilities;
  private hasQueryValue;
  private isArrayType;
  private refreshForArray;
  static ɵfac: i0.ɵɵFactoryDeclaration<BaseComponent$1<any>, never>;
  static ɵdir: i0.ɵɵDirectiveDeclaration<BaseComponent$1<any>, never, never, {
    "item": {
      "alias": "item";
      "required": false;
      "isSignal": true;
    };
    "filter": {
      "alias": "filter";
      "required": false;
      "isSignal": true;
    };
  }, {}, never, never, true, never>;
}
declare namespace date_component_d_exports {
  export { FilterDateComponent };
}
export declare class FilterDateComponent<T extends IEntity<string>> extends BaseComponent$1<T> {
  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 namespace date_with_edit_component_d_exports {
  export { FilterDateWithEditComponent };
}
export declare class FilterDateWithEditComponent<T extends IEntity<string>> extends FilterDateComponent<T> {
  advanced: WritableSignal<boolean>;
  toggleAdvanced(): 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 namespace date_time_component_d_exports {
  export { FilterDateTimeComponent };
}
export declare class FilterDateTimeComponent<T extends IEntity<string>> extends FilterDateComponent<T> {
  static ɵfac: i0.ɵɵFactoryDeclaration<FilterDateTimeComponent<any>, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<FilterDateTimeComponent<any>, "smart-crud-filter-date-time", never, {}, {}, never, never, true, never>;
}
declare namespace radio_component_d_exports {
  export { FilterRadioComponent };
}
export declare class FilterRadioComponent<T extends IEntity<string>> extends BaseComponent$1<T> implements OnInit {
  readonly inputOptions: WritableSignal<InputOptions<any> | undefined>;
  readonly fieldOptions: WritableSignal<IFieldOptions | undefined>;
  ngOnInit(): void;
  static ɵfac: i0.ɵɵFactoryDeclaration<FilterRadioComponent<any>, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<FilterRadioComponent<any>, "smart-crud-filter-radio", never, {}, {}, never, never, true, never>;
}
declare namespace text_component_d_exports {
  export { FilterTextComponent };
}
export declare class FilterTextComponent<T extends IEntity<string>> extends BaseComponent$1<T> implements OnInit {
  readonly inputOptions: WritableSignal<InputOptions<any> | undefined>;
  readonly fieldOptions: WritableSignal<IFieldOptions | undefined>;
  ngOnInit(): void;
  static ɵfac: i0.ɵɵFactoryDeclaration<FilterTextComponent<any>, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<FilterTextComponent<any>, "smart-crud-filter-text", never, {}, {}, never, never, true, never>;
}
declare namespace flag_component_d_exports {
  export { FilterFlagComponent };
}
export declare class FilterFlagComponent<T extends IEntity<string>> extends BaseComponent$1<T> implements OnInit {
  readonly inputOptions: WritableSignal<InputOptions<any> | undefined>;
  readonly fieldOptions: WritableSignal<IFieldOptions | undefined>;
  ngOnInit(): void;
  static ɵfac: i0.ɵɵFactoryDeclaration<FilterFlagComponent<any>, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<FilterFlagComponent<any>, "smart-crud-filter-flag", never, {}, {}, never, never, true, never>;
}
declare namespace check_component_d_exports {
  export { FilterCheckComponent };
}
export declare class FilterCheckComponent<T extends IEntity<string>> extends BaseComponent$1<T> implements OnInit {
  list: Signal<{
    value: any;
    isCheck: boolean;
  }[]>;
  readonly hasCheckedValues: Signal<boolean>;
  ngOnInit(): 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 namespace int_component_d_exports {
  export { FilterIntComponent };
}
export declare class FilterIntComponent<T extends IEntity<string>> extends BaseComponent$1<T> implements OnInit {
  readonly valueOptions: WritableSignal<InputOptions<any> | undefined>;
  readonly valueFieldOptions: WritableSignal<IFieldOptions | undefined>;
  readonly advanced: WritableSignal<boolean>;
  minControl: UntypedFormControl;
  maxControl: UntypedFormControl;
  get allowAdvanced(): boolean;
  ngOnInit(): 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>;
}
export declare class FiltersBaseComponent<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<FiltersBaseComponent<any>, never>;
  static ɵdir: i0.ɵɵDirectiveDeclaration<FiltersBaseComponent<any>, never, never, {
    "hideMenu": {
      "alias": "hideMenu";
      "required": false;
      "isSignal": true;
    };
  }, {}, never, never, true, never>;
}
declare namespace filters_component_d_exports {
  export { FiltersComponent };
}
/**
 * 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;
 */
export declare class FiltersComponent<T extends IEntity<string>> extends FiltersBaseComponent<T> {
  static ɵfac: i0.ɵɵFactoryDeclaration<FiltersComponent<any>, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<FiltersComponent<any>, "smart-crud-filters", never, {}, {}, never, never, true, never>;
}
declare namespace filters_config_component_d_exports {
  export { FiltersConfigComponent };
}
export 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>;
}
export declare class MultiselectBaseComponent<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<MultiselectBaseComponent<any>, never>;
  static ɵdir: i0.ɵɵDirectiveDeclaration<MultiselectBaseComponent<any>, never, never, {}, {}, never, never, true, never>;
}
declare namespace multiselect_component_d_exports {
  export { MultiselectComponent };
}
export declare class MultiselectComponent<T extends IEntity<string>> extends MultiselectBaseComponent<T> {
  static ɵfac: i0.ɵɵFactoryDeclaration<MultiselectComponent<any>, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<MultiselectComponent<any>, "smart-crud-multiselect", never, {}, {}, never, never, true, never>;
}
export declare class GroupBaseComponent<T extends IEntity<string>> extends BaseComponent implements OnInit, OnDestroy {
  private styleService;
  private elementRef;
  private groupService;
  private cd;
  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<GroupBaseComponent<any>, never>;
  static ɵdir: i0.ɵɵDirectiveDeclaration<GroupBaseComponent<any>, never, never, {
    "groups": {
      "alias": "groups";
      "required": false;
      "isSignal": true;
    };
    "listOptions": {
      "alias": "listOptions";
      "required": false;
      "isSignal": true;
    };
  }, {}, never, never, true, never>;
}
declare namespace group_component_d_exports {
  export { GroupComponent };
}
export declare class GroupComponent<T extends IEntity<string>> extends GroupBaseComponent<T> {
  static ɵfac: i0.ɵɵFactoryDeclaration<GroupComponent<any>, never>;
  static ɵcmp: i0.ɵɵComponentDeclaration<GroupComponent<any>, "smart-crud-group", never, {}, {}, never, never, true, never>;
}
declare namespace form_options_pipe_d_exports {
  export { FormOptionsPipe };
}
export 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 namespace pipes_module_d_exports {
  export { CrudPipesModule };
}
export 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 namespace components_module_d_exports {
  export { CrudComponentsModule };
}
export 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 i15.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 SocketService<T> {
  static ɵfac: i0.ɵɵFactoryDeclaration<SocketService<any>, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
declare class NotSocketService<T> {
  static ɵfac: i0.ɵɵFactoryDeclaration<NotSocketService<any>, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
export declare class CrudService<T extends IEntity<string>> {
  protected config: CrudConfig<any>;
  protected http: HttpClient;
  protected socket: SocketService<any> | null;
  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<any>;
}
export 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<any>;
}
export declare class CrudCoreModule<T extends IEntity<string>> {
  constructor(config: CrudConfig<T>, effects: CrudEffects<any>, store: Store<any>);
  static ɵfac: i0.ɵɵFactoryDeclaration<CrudCoreModule, never>;
  static ɵmod: i0.ɵɵNgModuleDeclaration<CrudCoreModule, never, [typeof i15.SharedModule, typeof CrudPipesModule, typeof i17.FormsModule, typeof i18.CommonModule, typeof CrudComponentsModule], [typeof CrudComponentsModule]>;
  static ɵinj: i0.ɵɵInjectorDeclaration<CrudCoreModule>;
}
export 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>, store: Store<any>);
  static ɵfac: i0.ɵɵFactoryDeclaration<CrudModule, never>;
  static ɵmod: i0.ɵɵNgModuleDeclaration<CrudModule, never, never, never>;
  static ɵinj: i0.ɵɵInjectorDeclaration<CrudModule>;
}
export interface ICrudModuleOptionsWithRoutng<T> {
  config: CrudFullConfig<T>;
  socket?: boolean;
  routing: true;
}
export interface ICrudModuleOptionsWithoutRoutng<T> {
  config: CrudConfig<T>;
  socket?: boolean;
  routing: false;
}
export declare abstract class CrudItemPageBaseComponent<T extends IEntity<string>> extends BaseComponent {
  config: CrudFullConfig<T>;
  facade: CrudFacade<any>;
  static smartType: DynamicComponentType;
  selected: Signal<T>;
  contentTpl: Signal<ViewContainerRef | undefined>;
  formComponents: Signal<readonly FormComponent<any>[]>;
  detailsOptions: import("@angular/core").InputSignal<IDetailsOptions<T> | undefined>;
  mode: import("@angular/core").InputSignal<string | undefined>;
  uniqueProvider: import("@angular/core").InputSignal<((values: Record<keyof T, any>) => Promise<boolean>) | undefined>;
  onPartialChange: import("@angular/core").OutputEmitterRef<Partial<T>>;
  onChange: import("@angular/core").OutputEmitterRef<T>;
  onValidChange: import("@angular/core").OutputEmitterRef<boolean>;
  constructor();
  /**
   * The reactive form of the first rendered `<smart-form>`, or `undefined`
   * until the form factory has built it. `FormComponent.form` is a getter over
   * a signal, so it always reports the group currently rendered; a method is
   * kept here so the page button handlers read that group at call time rather
   * than through a `computed` captured when the form did not exist yet.
   */
  getForm(): SmartFormGroup | undefined;
  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 namespace standard_component_d_exports$1 {
  export { ItemStandardComponent };
}
export 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 namespace item_component_d_exports {
  export { ItemComponent };
}
declare const ItemComponent_base: new () => import("@smartsoft001/angular").IDynamicComponent<CrudItemPageBaseComponent<any>>;
export 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> | undefined>;
  id: string;
  formValue: T;
  formValid: boolean;
  item: T;
  formPartialValue: Partial<T>;
  uniqueProvider: WritableSignal<((values: Record<keyof T, any>) => Promise<boolean>) | undefined>;
  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>;
}
export declare abstract class CrudListPageBaseComponent<T extends IEntity<string>> extends BaseComponent {
  config: CrudFullConfig<T>;
  static smartType: DynamicComponentType;
  contentTpl: import("@angular/core").Signal<ViewContainerRef | undefined>;
  listOptions: import("@angular/core").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 namespace list_component_d_exports {
  export { ListComponent };
}
declare const ListComponent_base: new () => import("@smartsoft001/angular").IDynamicComponent<CrudListPageBaseComponent<any>>;
export 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>;
  /**
   * The sort the list headers start from: the one of the first read (the
   * search filter, else `config.sort.default`). A header click reads again
   * through `provider.getData({ offset: 0, sortBy, sortDesc })`.
   */
  private getListSort;
  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 namespace standard_component_d_exports {
  export { ListStandardComponent };
}
export 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>;
}
export declare const PAGES: (typeof ItemStandardComponent | typeof ItemComponent | typeof ListStandardComponent | typeof ListComponent)[];
export declare class CrudFullModule<T extends IEntity<string>> {
  constructor(config: CrudConfig<T>, effects: CrudEffects<any>, store: Store<any>);
  static ɵfac: i0.ɵɵFactoryDeclaration<CrudFullModule, never>;
  static ɵmod: i0.ɵɵNgModuleDeclaration<CrudFullModule, never, [typeof ItemComponent, typeof ListComponent, typeof ListStandardComponent, typeof ItemStandardComponent, typeof i15.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>;
}
export declare class CrudListPaginationFactory<T extends IEntity<string>> {
  private readonly facade;
  private readonly injector;
  create(options: {
    mode?: PaginationMode;
    limit: number;
    provider: {
      getLinks(): any;
      getFilter(): ICrudFilter;
    };
  }): Promise<IListPaginationOptions>;
  static ɵfac: i0.ɵɵFactoryDeclaration<CrudListPaginationFactory<any>, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
export declare class PageService<T> {
  private authService;
  private config;
  checkPermissions(): void;
  static ɵfac: i0.ɵɵFactoryDeclaration<PageService<any>, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}
export 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<any>;
}
export declare const create: <T extends IEntity<string>>(entity: string, item: T) => Action & {
  item: T;
};
export declare const createSuccess: <T extends IEntity<string>>(entity: string, item: T) => Action & {
  item: T;
};
export declare const createFailure: <T extends IEntity<string>>(entity: string, item: T, error: any) => Action & {
  item: T;
  error: any;
};
export declare const createMany: <T extends IEntity<string>>(entity: string, data: {
  items: T[];
  options: ICrudCreateManyOptions;
}) => Action & {
  data: {
    items: T[];
    options: ICrudCreateManyOptions;
  };
};
export declare const createManySuccess: <T extends IEntity<string>>(entity: string, data: {
  items: T[];
  options: ICrudCreateManyOptions;
}) => Action & {
  data: {
    items: T[];
    options: ICrudCreateManyOptions;
  };
};
export declare const createManyFailure: <T extends IEntity<string>>(entity: string, data: {
  items: T[];
  options: ICrudCreateManyOptions;
}, error: any) => Action & {
  data: {
    items: T[];
    options: ICrudCreateManyOptions;
  };
  error: any;
};
export declare const read: (entity: string, filter?: ICrudFilter) => Action & {
  filter?: ICrudFilter;
};
export declare const readSuccess: <T extends IEntity<string>, F>(entity: string, filter: F, result: {
  data: T[];
  totalCount: number;
  links: any;
}) => Action & {
  result: {
    data: T[];
    totalCount: number;
    links: any;
  };
  filter: F;
};
export declare const readFailure: <F>(entity: string, filter: F, error: any) => Action & {
  filter: F;
  error: any;
};
export declare const clear: (entity: string) => Action;
export declare const exportList: (entity: string, filter: (ICrudFilter | null) | undefined, format: any) => Action & {
  filter: ICrudFilter;
  format: any;
};
export declare const exportListSuccess: <T extends IEntity<string>, F>(entity: string, filter: F) => Action & {
  filter: F;
};
export declare const exportListFailure: <F>(entity: string, filter: F, error: any) => Action & {
  filter: F;
  error: any;
};
export declare const select: (entity: string, id: string) => Action & {
  id: string;
};
export declare const selectSuccess: <T extends IEntity<string>, F>(entity: string, id: string, item: T) => Action & {
  id: string;
  item: T;
};
export declare const selectFailure: <F>(entity: string, id: string, error: any) => Action & {
  id: string;
  error: any;
};
export declare const unselect: (entity: string) => Action;
export declare const multiSelect: <T extends IEntity<string>>(entity: string, items: Array<T>) => Action & {
  items: Array<T>;
};
export declare const update: <T extends IEntity<string>>(entity: string, item: T) => Action & {
  item: T;
};
export declare const updateSuccess: <T extends IEntity<string>>(entity: string, item: T) => Action & {
  item: T;
};
export declare const updateFailure: <T extends IEntity<string>>(entity: string, item: T, error: any) => Action & {
  item: T;
  error: any;
};
export declare const updatePartial: <T extends IEntity<string>>(entity: string, item: Partial<T> & {
  id: string;
}) => Action & {
  item: Partial<T> & {
    id: string;
  };
};
export declare const updatePartialSuccess: <T extends IEntity<string>>(entity: string, item: Partial<T> & {
  id: string;
}) => Action & {
  item: Partial<T> & {
    id: string;
  };
};
export declare const updatePartialFailure: <T extends IEntity<string>>(entity: string, item: Partial<T> & {
  id: string;
}, error: any) => Action & {
  item: Partial<T> & {
    id: string;
  };
  error: any;
};
export declare const updatePartialMany: <T extends IEntity<string>>(entity: string, items: Partial<T> & {
  id: string;
}[]) => Action & {
  items: Partial<T> & {
    id: string;
  }[];
};
export declare const updatePartialManySuccess: <T extends IEntity<string>>(entity: string, items: Partial<T> & {
  id: string;
}[]) => Action & {
  items: Partial<T> & {
    id: string;
  }[];
};
export declare const updatePartialManyFailure: <T extends IEntity<string>>(entity: string, items: Partial<T> & {
  id: string;
}[], error: any) => Action & {
  items: Partial<T> & {
    id: string;
  }[];
  error: any;
};
export declare const deleteItem: (entity: string, id: string) => Action & {
  id: string;
};
export declare const deleteSuccess: (entity: string, id: string) => Action & {
  id: string;
};
export declare const deleteFailure: <F>(entity: string, id: string, error: any) => Action & {
  id: string;
  error: any;
};
export interface State<T extends IEntity<string>> {
  selected?: T;
  multiSelected?: Array<T>;
  list?: T[];
  totalCount?: number;
  filter?: ICrudFilter;
  links?: any;
  loaded: boolean;
  error?: string | null;
}
export declare const initialState: State<any>;
export 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;
};
export declare const getCrudState: (entity: string) => import("@ngrx/store").MemoizedSelector<object, any, import("@ngrx/store").DefaultProjectorFn<any>>;
export declare const getCrudSelected: (entity: string) => import("@ngrx/store").MemoizedSelector<object, any, (s1: any) => any>;
export declare const getCrudMultiSelected: (entity: string) => import("@ngrx/store").MemoizedSelector<object, any, (s1: any) => any>;
export declare const getCrudList: (entity: string) => import("@ngrx/store").MemoizedSelector<object, any, (s1: any) => any>;
export declare const getCrudTotalCount: (entity: string) => import("@ngrx/store").MemoizedSelector<object, any, (s1: any) => any>;
export declare const getCrudLinks: (entity: string) => import("@ngrx/store").MemoizedSelector<object, any, (s1: any) => any>;
export declare const getCrudLoaded: (entity: string) => import("@ngrx/store").MemoizedSelector<object, any, (s1: any) => any>;
export declare const getCrudFilter: (entity: string) => import("@ngrx/store").MemoizedSelector<object, any, (s1: any) => any>;
export declare const getCrudError: (entity: string) => import("@ngrx/store").MemoizedSelector<object, any, (s1: any) => any>;
/**
 * @deprecated - please, use IModelPossibilitiesProvider from @smartsoft001/angular
 */
export 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
 */
export declare const CRUD_MODEL_POSSIBILITIES_PROVIDER: InjectionToken<ICrudModelPossibilitiesProvider>;
export declare class CrudModelLabelProvider extends IModelLabelProvider {
  private translateService;
  private parent;
  get(options: IModelLabelOptions): Signal<string>;
  static ɵfac: i0.ɵɵFactoryDeclaration<CrudModelLabelProvider, never>;
  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
}