@wemake4u/form-player-se 1.0.39 → 1.0.41

package/lib/builtIn/builtIn.d.ts

@@ -0,0 +1,32 @@
+export declare const builtIn: ({
+    name: string;
+    detail: string;
+    info: string;
+    entries: {
+        name: string;
+        type: string;
+        detail: string;
+        info: string;
+        params: ({
+            name: string;
+            type: string;
+            optional?: undefined;
+        } | {
+            name: string;
+            type: string;
+            optional: boolean;
+        })[];
+    }[];
+} | {
+    name: string;
+    entries: {
+        name: string;
+        type: string;
+        detail: string;
+        info: string;
+        params: {
+            name: string;
+            type: string;
+        }[];
+    }[];
+})[];

package/lib/components/setFilter/setFilter.component.d.ts

@@ -86,6 +86,7 @@ export declare class SetFilterComponent implements IFilterAngularComp {
     private setAll;
     private updateFilteredOptions;
     private resolvePath;
+    private getFilterType;
     static ɵfac: i0.ɵɵFactoryDeclaration<SetFilterComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<SetFilterComponent, "ng-component", never, {}, {}, never, never, true, never>;
 }

package/lib/controls/accordion.d.ts

@@ -1,4 +1,8 @@
 import { ContainerControl } from "./control";
 export declare class AccordionControl extends ContainerControl {
-    private getAccordion;
+    openPanel(index: number): void;
+    onLoadState(): void;
+    onSaveState(): void;
+    private createState;
+    private get accordion();
 }

package/lib/controls/control.d.ts

@@ -1,21 +1,40 @@
-import { ElementRef } from "@angular/core";
+import { ElementRef, Injector, DestroyRef } from "@angular/core";
 import { RegisterService } from "../services/register.service";
 export declare class Control {
-    readonly name: string;
-    private readonly metadata;
-    private readonly componentRef;
-    private readonly elementRef;
-    constructor(name: string, metadata: any, componentRef: any, elementRef: ElementRef);
-    getMetadata(): any;
-    getComponentRef(): any;
-    getElementRef(): ElementRef;
+    private readonly context;
+    constructor(context: ControlContext);
+    get name(): string;
+    protected getMetadata(): any;
+    protected getComponentRef(): any;
+    protected getElementRef(): ElementRef;
+    protected getInjector(): Injector;
+    protected getDestroyRef(): DestroyRef;
+    protected getRegister(): RegisterService | undefined;
+    protected onInit(): void;
+    protected onLoadState(): void;
+    protected onSaveState(): void;
+    protected onDestroy(): void;
+    protected getState<T = any>(): T | null;
+    protected setState(state: any): void;
+    protected clearState(): void;
+    private getId;
+    private State;
 }
 export declare class ContainerControl extends Control {
-    private register;
-    constructor(name: string, metadata: any, componentRef: any, elementRef: ElementRef, register: RegisterService | undefined);
+    constructor(context: ControlContext);
     findControl(predicate: (control: Control) => boolean, firstOnly: boolean): Control[];
 }
 export declare class ItemControl extends ContainerControl {
     readonly index: number;
-    constructor(name: string, index: number, metadata: any, componentRef: any, elementRef: ElementRef, register: RegisterService | undefined);
+    constructor(context: ControlContext, index: number);
+}
+export interface ControlContext {
+    name: string;
+    path: string;
+    metadata: any;
+    componentRef: any;
+    elementRef: ElementRef;
+    injector: Injector;
+    destroyRef: DestroyRef;
+    register?: RegisterService;
 }

package/lib/controls/factory.d.ts

@@ -1,4 +1,2 @@
-import { ElementRef } from '@angular/core';
-import { Control } from '../controls/control';
-import { RegisterService } from '../services/register.service';
-export declare function createControl(name: string, metadata: any, componentRef: any, elementRef: ElementRef, register: RegisterService | undefined): Control;
+import { Control, ControlContext } from '../controls/control';
+export declare function createControl(context: ControlContext): Control;

package/lib/controls/tab.d.ts

@@ -1,11 +1,14 @@
 import { ContainerControl } from "./control";
 export declare class TabControl extends ContainerControl {
-    readonly canNext: () => boolean;
-    readonly goNext: () => void;
-    readonly canPrevious: () => boolean;
-    readonly goPrevious: () => void;
-    readonly setActiveIndex: (index: number) => void;
-    private getTab;
+    canNext(): boolean;
+    goNext(): void;
+    canPrevious(): boolean;
+    goPrevious(): void;
+    setActiveIndex(index: number): void;
+    onLoadState(): void;
+    onSaveState(): void;
+    private createState;
+    private get tab();
     private getPreviousIndex;
     private getNextIndex;
 }

package/lib/controls/table.d.ts

@@ -1,8 +1,19 @@
 import { Control } from "./control";
+import { FilterModel } from 'ag-grid-community';
 export declare class TableControl extends Control {
-    readonly setFilter: (filter: any) => void;
-    readonly clearFilter: () => void;
-    readonly refresh: () => void;
-    readonly redraw: () => void;
-    private getGrid;
+    setFilter(filter: FilterModel): void;
+    getFilter(): FilterModel;
+    clearFilter(): void;
+    refresh(): void;
+    redraw(): void;
+    private currentState;
+    onLoadState(): void;
+    onSaveState(): void;
+    private createState;
+    private applyState;
+    private applyPagination;
+    private applyPageSize;
+    private applyPageNumber;
+    private get grid();
+    private paginationEnabled;
 }

package/lib/controls/textfield.d.ts

@@ -1,6 +1,6 @@
 import { Control } from "./control";
 export declare class TextFieldControl extends Control {
-    readonly setRandomColor: () => void;
+    setRandomColor(): void;
     private getInput;
     private getRandomColor;
 }

package/lib/directives/accordionpanel.directive.d.ts

@@ -1,7 +1,9 @@
+import { DestroyRef } from '@angular/core';
 import { SirioAccordionPanelComponent } from 'ngx-sirio-lib';
 import * as i0 from "@angular/core";
 export declare class AccordionPanelDirective {
-    constructor(panel: SirioAccordionPanelComponent);
-    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionPanelDirective, [{ host: true; }]>;
+    private destroyRef;
+    constructor(panel: SirioAccordionPanelComponent, destroyRef: DestroyRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionPanelDirective, [{ host: true; }, null]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionPanelDirective, "[accordionPanel]", never, {}, {}, never, never, true, never>;
 }

package/lib/directives/collapse.directive.d.ts

@@ -1,9 +1,12 @@
-import { ElementRef, Renderer2, OnChanges, SimpleChanges, OnDestroy } from '@angular/core';
+import { ElementRef, Renderer2, OnChanges, SimpleChanges, OnDestroy, DestroyRef } from '@angular/core';
+import { ListenerService } from '../services/listener.service';
 import { LanguageService } from '@wemake4u/interact';
 import * as i0 from "@angular/core";
 export declare class CollapseDirective implements OnChanges, OnDestroy {
     private el;
     private renderer;
+    private destroyRef;
+    private listenerService;
     private languageService;
     maxHeight: number | null;
     private currentHeight;
@@ -13,8 +16,7 @@ export declare class CollapseDirective implements OnChanges, OnDestroy {
     private viewInitialized;
     private timeoutFocusOut;
     private unlistenFocusOut;
-    private subscription;
-    constructor(el: ElementRef, renderer: Renderer2, languageService: LanguageService);
+    constructor(el: ElementRef, renderer: Renderer2, destroyRef: DestroyRef, listenerService: ListenerService, languageService: LanguageService);
     ngOnDestroy(): void;
     ngAfterViewInit(): void;
     ngOnChanges(changes: SimpleChanges): void;

package/lib/directives/datetime.directive.d.ts

@@ -1,16 +1,16 @@
-import { AfterViewInit, OnDestroy, Renderer2 } from '@angular/core';
+import { AfterViewInit, Renderer2, DestroyRef } from '@angular/core';
 import { ControlValueAccessor, NgControl } from '@angular/forms';
 import { SirioDatepickerComponent, SirioTimepickerComponent } from 'ngx-sirio-lib';
 import * as i0 from "@angular/core";
-export declare class DateTimeCoordinatorDirective implements ControlValueAccessor, AfterViewInit, OnDestroy {
+export declare class DateTimeCoordinatorDirective implements ControlValueAccessor, AfterViewInit {
+    private destroyRef;
+    constructor(destroyRef: DestroyRef);
     datePicker: SirioDatepickerComponent;
     timePicker: SirioTimepickerComponent;
     private onChange;
     private onTouched;
     private dateValue;
     private timeValue;
-    private destroy$;
-    ngOnDestroy(): void;
     ngAfterViewInit(): void;
     writeValue(value: any): void;
     setDisabledState(isDisabled: boolean): void;
@@ -20,14 +20,13 @@ export declare class DateTimeCoordinatorDirective implements ControlValueAccesso
     static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeCoordinatorDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DateTimeCoordinatorDirective, "[dateTimeCoordinator]", never, { "datePicker": { "alias": "datePicker"; "required": false; }; "timePicker": { "alias": "timePicker"; "required": false; }; }, {}, never, never, true, never>;
 }
-export declare class DateTimeValidationDirective implements AfterViewInit, OnDestroy {
+export declare class DateTimeValidationDirective implements AfterViewInit {
     private ngControl;
+    private destroyRef;
     private renderer;
     isWarning: boolean;
     showWhenValid: boolean;
-    private sub?;
-    constructor(ngControl: NgControl, renderer: Renderer2);
-    ngOnDestroy(): void;
+    constructor(ngControl: NgControl, destroyRef: DestroyRef, renderer: Renderer2);
     ngAfterViewInit(): void;
     private getCoordinator;
     private checkValidation;

package/lib/directives/dropdown.directive.d.ts

@@ -1,11 +1,14 @@
-import { AfterViewInit, OnDestroy, ElementRef, Renderer2 } from '@angular/core';
+import { AfterViewInit, OnDestroy, ElementRef, Renderer2, DestroyRef } from '@angular/core';
+import { ListenerService } from '../services/listener.service';
 import { SirioSelectComponent } from 'ngx-sirio-lib';
 import * as i0 from "@angular/core";
 export declare class DropdownDirective implements AfterViewInit, OnDestroy {
     private el;
     private renderer;
+    private listenerService;
+    private destroyRef;
     private sirioSelect;
-    constructor(el: ElementRef, renderer: Renderer2, sirioSelect: SirioSelectComponent);
+    constructor(el: ElementRef, renderer: Renderer2, listenerService: ListenerService, destroyRef: DestroyRef, sirioSelect: SirioSelectComponent);
     ngAfterViewInit(): void;
     ngOnInit(): void;
     ngOnDestroy(): void;
@@ -31,6 +34,6 @@ export declare class DropdownDirective implements AfterViewInit, OnDestroy {
     private scrollUp;
     private findPreviousVisibleOption;
     private findNextVisibleOption;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownDirective, [null, null, { host: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownDirective, [null, null, null, null, { host: true; }]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownDirective, "[dropdown]", never, {}, {}, never, never, true, never>;
 }

package/lib/directives/grid.directive.d.ts

@@ -1,5 +1,6 @@
 import { OnChanges, SimpleChanges } from '@angular/core';
 import { FormGroup } from '@angular/forms';
+import { DestroyRef } from '@angular/core';
 import { AgGridAngular } from 'ag-grid-angular';
 import { GridService } from '../services/grid.service';
 import { CacheContextService } from '../services/cache.service';
@@ -10,6 +11,7 @@ export declare class GridDirective implements OnChanges {
     private gridService;
     private cacheContext;
     private languageService;
+    private destroyRef;
     rowSource: any;
     columnDefs: any;
     selectable: boolean | null;
@@ -17,8 +19,7 @@ export declare class GridDirective implements OnChanges {
     suppressActions: boolean | null;
     formGroup: FormGroup;
     component: any;
-    private destroyRef;
-    constructor(grid: AgGridAngular, gridService: GridService, cacheContext: CacheContextService, languageService: LanguageService);
+    constructor(grid: AgGridAngular, gridService: GridService, cacheContext: CacheContextService, languageService: LanguageService, destroyRef: DestroyRef);
     ngOnChanges(changes: SimpleChanges): void;
     private gridApi;
     private isGridReady;
@@ -44,6 +45,6 @@ export declare class GridDirective implements OnChanges {
     private locale;
     private wrapObservable;
     private wrapRowsSource;
-    static ɵfac: i0.ɵɵFactoryDeclaration<GridDirective, [{ host: true; }, null, null, null]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridDirective, [{ host: true; }, null, null, null, null]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<GridDirective, "[rowSource], [columnDefs], [selectable], [multiSelect], [suppressActions]", never, { "rowSource": { "alias": "rowSource"; "required": false; }; "columnDefs": { "alias": "columnDefs"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "multiSelect": { "alias": "multiSelect"; "required": false; }; "suppressActions": { "alias": "suppressActions"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "component": { "alias": "register"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/directives/readonly.directive.d.ts

@@ -1,23 +1,22 @@
-import { OnChanges, SimpleChanges, ElementRef, Renderer2 } from '@angular/core';
+import { OnChanges, SimpleChanges, ElementRef, Renderer2, DestroyRef } from '@angular/core';
 import { NgControl } from '@angular/forms';
 import { GlobalService } from '../services/global.service';
 import * as i0 from "@angular/core";
 export declare class ReadOnlyDirective implements OnChanges {
     private ngControl;
     private global;
+    private destroyRef;
     private el;
     private renderer;
     readonly: boolean | null;
     placeholder: string | null;
     componentRef: any;
     properties: any;
-    constructor(ngControl: NgControl, global: GlobalService, el: ElementRef, renderer: Renderer2);
+    constructor(ngControl: NgControl, global: GlobalService, destroyRef: DestroyRef, el: ElementRef, renderer: Renderer2);
     private disableClass;
     private readonlyClass;
     private lightReadonlyClass;
-    private sub?;
     ngOnInit(): void;
-    ngOnDestroy(): void;
     ngOnChanges(changes: SimpleChanges): void;
     private apply;
     private toggleClass;

package/lib/directives/register.directive.d.ts

@@ -1,18 +1,19 @@
-import { ElementRef, AfterContentInit, OnDestroy, QueryList } from '@angular/core';
+import { ElementRef, AfterContentInit, OnDestroy, QueryList, DestroyRef, Injector } from '@angular/core';
 import { RegisterService } from '../services/register.service';
 import { IDynamicFieldsComponent } from '../dynamic-fields/dynamic-fields.interface';
 import * as i0 from "@angular/core";
 export declare class RegisterDirective implements AfterContentInit, OnDestroy {
     private el;
+    private destroyRef;
     private registerService;
+    private injector;
     register: any;
     componentRef: any;
     dynamicField?: IDynamicFieldsComponent;
     itemFields: QueryList<IDynamicFieldsComponent>;
-    constructor(el: ElementRef, registerService: RegisterService);
+    constructor(el: ElementRef, destroyRef: DestroyRef, registerService: RegisterService, injector: Injector);
     ngAfterContentInit(): void;
     ngOnDestroy(): void;
-    private destroy$;
     private registerControl;
     private unregisterControl;
     private getName;

package/lib/directives/required.directive.d.ts

@@ -0,0 +1,17 @@
+import { AfterViewInit, OnDestroy } from '@angular/core';
+import { SirioInputComponent } from 'ngx-sirio-lib';
+import { ValidationService } from '../services/validation.service';
+import * as i0 from "@angular/core";
+export declare class RequiredOnInputDirective implements AfterViewInit, OnDestroy {
+    private sirioInput;
+    private validationService;
+    required: any;
+    constructor(sirioInput: SirioInputComponent, validationService: ValidationService);
+    private removeListener?;
+    private wasEmpty;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    private isEmpty;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequiredOnInputDirective, [{ host: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RequiredOnInputDirective, "[requiredOnInput]", never, { "required": { "alias": "requiredOnInput"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/directives/tabcontrol.directive.d.ts

@@ -1,15 +1,14 @@
-import { OnInit, OnDestroy } from '@angular/core';
+import { OnInit, DestroyRef } from '@angular/core';
 import { SirioTabComponent } from 'ngx-sirio-lib';
 import * as i0 from "@angular/core";
-export declare class TabControlDirective implements OnInit, OnDestroy {
+export declare class TabControlDirective implements OnInit {
     private sirioTab;
-    constructor(sirioTab: SirioTabComponent);
+    private destroyRef;
+    constructor(sirioTab: SirioTabComponent, destroyRef: DestroyRef);
     ngOnInit(): void;
-    ngOnDestroy(): void;
-    private tabChangeSub;
     private HandleIndexChange;
     private validateIndex;
     private setFocus;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TabControlDirective, [{ host: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabControlDirective, [{ host: true; }, null]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TabControlDirective, "[tabControl]", never, {}, {}, never, never, true, never>;
 }

package/lib/dynamic-fields/dynamic-fields.component.d.ts

@@ -45,6 +45,8 @@ export declare class DynamicFieldsComponent implements OnInit, AfterViewInit, ID
     alignment: string;
     readOnly: boolean | null;
     recursionLevel: number;
+    identity: string;
+    identityIndex?: number;
     Texts: {
         i18n: {
             it: {
@@ -420,6 +422,7 @@ export declare class DynamicFieldsComponent implements OnInit, AfterViewInit, ID
         "horizontal-fill": boolean;
     };
     getLightView(component: any): string;
+    getPanels(component: any): Observable<any>;
     private noData;
     private get language();
     private getAlignmentRules;
@@ -430,5 +433,5 @@ export declare class DynamicFieldsComponent implements OnInit, AfterViewInit, ID
     private markForAutoFocus;
     private requireAutoFocus;
     static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFieldsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFieldsComponent, "app-dynamic-fields", never, { "form": { "alias": "form"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "alignment": { "alias": "alignment"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "recursionLevel": { "alias": "recursionLevel"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFieldsComponent, "app-dynamic-fields", never, { "form": { "alias": "form"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "alignment": { "alias": "alignment"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "recursionLevel": { "alias": "recursionLevel"; "required": false; }; "identity": { "alias": "identity"; "required": false; }; "identityIndex": { "alias": "identityIndex"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/dynamic-form/dynamic-form.component.d.ts

@@ -9,6 +9,7 @@ import { ComputeService } from '../services/compute.service';
 import { MetadataService } from '../services/metadata.service';
 import { FormService } from '../services/form.service';
 import { DialogService, FormDialogOptions } from '../services/dialog.service';
+import { SubscribeService } from '../services/subscribe.service';
 import { SirioStepperProgressBarComponent, SirioStepperProgressStatus, NgxSirioEvent } from 'ngx-sirio-lib';
 import { RegisterService } from '../services/register.service';
 import { Control } from '../controls/control';
@@ -24,6 +25,7 @@ export declare class DynamicFormComponent implements OnChanges, OnDestroy, IEval
     private eventService;
     private registerService;
     private languageService;
+    private subscribeService;
     private metadata;
     private formService;
     private dialog;
@@ -42,7 +44,7 @@ export declare class DynamicFormComponent implements OnChanges, OnDestroy, IEval
     initialized: EventEmitter<FormGroup<any>>;
     activeNavChange: EventEmitter<any>;
     formDiv: ElementRef<HTMLDivElement>;
-    constructor(fb: FormBuilder, programmability: ProgrammabilityService, validationService: ValidationService, disableService: DisableService, computeService: ComputeService, statusService: StatusService, eventService: EventService, registerService: RegisterService, languageService: LanguageService, metadata: MetadataService, formService: FormService, dialog: DialogService, injector: Injector);
+    constructor(fb: FormBuilder, programmability: ProgrammabilityService, validationService: ValidationService, disableService: DisableService, computeService: ComputeService, statusService: StatusService, eventService: EventService, registerService: RegisterService, languageService: LanguageService, subscribeService: SubscribeService, metadata: MetadataService, formService: FormService, dialog: DialogService, injector: Injector);
     Texts: {
         i18n: {
             it: {
@@ -382,6 +384,7 @@ export declare class DynamicFormComponent implements OnChanges, OnDestroy, IEval
     private get language();
     private onChangeSchema;
     private onChangeValue;
+    private patchingValue;
     private assignActivaNav;
     private suspendValueChanges;
     private registerHandlers;

package/lib/dynamic-host/dynamic-host.component.d.ts

@@ -1,21 +1,23 @@
-import { AfterViewInit, ViewContainerRef, Injector, ComponentRef, OnChanges, SimpleChanges, OnDestroy } from '@angular/core';
+import { AfterViewInit, ViewContainerRef, Injector, ComponentRef, OnChanges, SimpleChanges, OnDestroy, DestroyRef } from '@angular/core';
 import { FormGroup } from '@angular/forms';
 import { GlobalService } from '../services/global.service';
 import * as i0 from "@angular/core";
 export declare class DynamicHostComponent implements AfterViewInit, OnChanges, OnDestroy {
     private injector;
     private globalService;
+    private destroyRef;
     component: any;
     properties: Record<string, any> | null;
     formGroup: FormGroup;
     container: ViewContainerRef;
-    constructor(injector: Injector, globalService: GlobalService);
+    constructor(injector: Injector, globalService: GlobalService, destroyRef: DestroyRef);
     ngOnDestroy(): void;
     ngOnChanges(changes: SimpleChanges): void;
     ngAfterViewInit(): void;
     getComponentRef(): ComponentRef<any> | null;
     private componentRef;
     private statusSub;
+    private subscriptions;
     private isBindable;
     private setBinding;
     private setProperties;
@@ -23,6 +25,8 @@ export declare class DynamicHostComponent implements AfterViewInit, OnChanges, O
     private isControlValueAccessor;
     private resolveComponentType;
     private validProperties;
+    private isEmitter;
+    private isFunction;
     static ɵfac: i0.ɵɵFactoryDeclaration<DynamicHostComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DynamicHostComponent, "app-dynamic-host", never, { "component": { "alias": "register"; "required": false; }; "properties": { "alias": "properties"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/services/event.service.d.ts

@@ -1,10 +1,16 @@
+import { DestroyRef } from '@angular/core';
 import { ProgrammabilityService } from '../services/programmability.service';
+import { SubscribeService } from '../services/subscribe.service';
 import { AbstractControl, FormGroup } from '@angular/forms';
 import * as i0 from "@angular/core";
 export declare class EventService {
     private programmability;
-    constructor(programmability: ProgrammabilityService);
-    suppress: boolean;
+    private subscribeService;
+    private destroyRef;
+    constructor(programmability: ProgrammabilityService, subscribeService: SubscribeService, destroyRef: DestroyRef);
+    private _suppress;
+    set suppress(value: boolean);
+    get suppress(): boolean;
     createCollection(): EventCollection;
     addToCollection(collection: EventCollection, control: AbstractControl, formGroup: FormGroup, component: any): void;
     setupCollection(collection: EventCollection): void;

package/lib/services/listener.service.d.ts

@@ -0,0 +1,11 @@
+import { OnDestroy, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ListenerService implements OnDestroy {
+    private renderer;
+    constructor(renderer: Renderer2);
+    ngOnDestroy(): void;
+    private listeners;
+    listen(target: any, event: string, handler: (event: any) => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListenerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ListenerService>;
+}

package/lib/services/navigation.service.d.ts

@@ -0,0 +1,11 @@
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class NavigationService {
+    private router;
+    constructor(router: Router);
+    private _skipState;
+    get skipState(): boolean;
+    private shouldSkipState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationService>;
+}

package/lib/services/programmability.service.d.ts

@@ -1,5 +1,5 @@
-import { OnDestroy } from '@angular/core';
-import { AbstractControl, FormGroup } from '@angular/forms';
+import { DestroyRef } from '@angular/core';
+import { FormGroup } from '@angular/forms';
 import { FeelService } from '../services/feel.service';
 import { ScopeService } from '../services/scope.service';
 import { RegisterService } from '../services/register.service';
@@ -10,9 +10,9 @@ import { FormService } from './form.service';
 import { DialogService } from '../services/dialog.service';
 import { FormatterService } from '../services/formatter.service';
 import { WeakService } from '../services/weak.service';
-import { Observable } from "rxjs";
+import { SubscribeService } from '../services/subscribe.service';
 import * as i0 from "@angular/core";
-export declare class ProgrammabilityService implements OnDestroy {
+export declare class ProgrammabilityService {
     private feelService;
     private weakService;
     private toastService;
@@ -21,13 +21,13 @@ export declare class ProgrammabilityService implements OnDestroy {
     private functionService;
     private formService;
     private globalService;
+    private subscribeService;
+    private destroyRef;
     private register;
     private scope;
-    constructor(feelService: FeelService, weakService: WeakService, toastService: ToastService, dialogService: DialogService, formatterService: FormatterService, functionService: FunctionService, formService: FormService, globalService: GlobalService, register: RegisterService, scope: ScopeService);
+    constructor(feelService: FeelService, weakService: WeakService, toastService: ToastService, dialogService: DialogService, formatterService: FormatterService, functionService: FunctionService, formService: FormService, globalService: GlobalService, subscribeService: SubscribeService, destroyRef: DestroyRef, register: RegisterService, scope: ScopeService);
     private predefinedFunctions;
-    private destroy$;
     private evaluatorProviders;
-    ngOnDestroy(): void;
     addEvaluatorProviders(evaluatorProvider: IEvaluatorProvider): void;
     isExpression(text: string | null): boolean;
     getExpression(text: string | null): string;
@@ -40,7 +40,6 @@ export declare class ProgrammabilityService implements OnDestroy {
     invalidate(value: string | null): void;
     watch(formGroup: FormGroup, dependencies: (string | string[])[], callback: () => void): void;
     getDependencies(expression: string): (string | string[])[];
-    subscribeChanges<T>(observable$: Observable<T>, control: AbstractControl, initial: T, callback: (() => void) | ((oldValue: T, newValue: T) => void), logFn?: (control: AbstractControl) => void): void;
     get verbose(): boolean;
     get cacheable(): boolean;
     private _verbose;
@@ -64,7 +63,7 @@ export declare class ProgrammabilityService implements OnDestroy {
     private invalidateExpression;
     private processDependencies;
     private getPath;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ProgrammabilityService, [null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgrammabilityService, [null, null, null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ProgrammabilityService>;
 }
 export interface IEvaluatorProvider {

package/lib/services/register.service.d.ts

@@ -8,6 +8,11 @@ export declare class RegisterService implements IEvaluatorProvider {
     register(name: string, control: Control): void;
     unregister(name: string): void;
     unregisterAll(): void;
+    identify(id: string, index?: number): void;
+    getPath(): string;
+    private _path?;
+    private identityNode?;
+    private get identityChain();
     getContext(): Record<string, any>;
     getControl(name: string): Control | null;
     getControlAs<T extends Control>(name: string, type: new (...args: any[]) => T): T | null;
@@ -17,3 +22,7 @@ export declare class RegisterService implements IEvaluatorProvider {
     static ɵfac: i0.ɵɵFactoryDeclaration<RegisterService, [{ optional: true; skipSelf: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<RegisterService>;
 }
+export interface IdentityNode {
+    id: string;
+    index?: number;
+}

package/lib/services/state.service.d.ts

@@ -0,0 +1,14 @@
+import { NavigationService } from './navigation.service';
+import * as i0 from "@angular/core";
+export declare class StateService {
+    private navigation;
+    constructor(navigation: NavigationService);
+    private static readonly store;
+    private readonly prefix;
+    getState<T = any>(componentId: string): T | null;
+    setState(componentId: string, value: any): void;
+    clearState(componentId: string): void;
+    private buildKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StateService>;
+}