@wemake4u/form-player-se 1.0.39 → 1.0.40

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/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,18 @@
-import { ElementRef, AfterContentInit, OnDestroy, QueryList } from '@angular/core';
+import { ElementRef, AfterContentInit, OnDestroy, QueryList, DestroyRef } 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;
     register: any;
     componentRef: any;
     dynamicField?: IDynamicFieldsComponent;
     itemFields: QueryList<IDynamicFieldsComponent>;
-    constructor(el: ElementRef, registerService: RegisterService);
+    constructor(el: ElementRef, destroyRef: DestroyRef, registerService: RegisterService);
     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

@@ -420,6 +420,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;

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/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/status.service.d.ts

@@ -1,11 +1,15 @@
+import { DestroyRef } from '@angular/core';
 import { FormService } from './form.service';
 import { AbstractControl } from '@angular/forms';
 import { ProgrammabilityService } from '../services/programmability.service';
+import { SubscribeService } from '../services/subscribe.service';
 import * as i0 from "@angular/core";
 export declare class StatusService {
     private programmability;
     private formService;
-    constructor(programmability: ProgrammabilityService, formService: FormService);
+    private subscribeService;
+    private destroyRef;
+    constructor(programmability: ProgrammabilityService, formService: FormService, subscribeService: SubscribeService, destroyRef: DestroyRef);
     createCollection(): StatusCollection;
     addToCollection(collection: StatusCollection, control: AbstractControl): void;
     setupCollection(key: any, collection: StatusCollection): void;

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

@@ -0,0 +1,14 @@
+import { DestroyRef } from '@angular/core';
+import { AbstractControl } from '@angular/forms';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class SubscribeService {
+    get dispatchMode(): DispatchMode;
+    set dispatchMode(value: DispatchMode);
+    subscribeChanges<T>(observable$: Observable<T>, control: AbstractControl, initial: T, destroyRef: DestroyRef, callback: (() => void) | ((oldValue: T, newValue: T) => void), logFn?: (control: AbstractControl) => void): void;
+    private _dispatchMode;
+    private dispatch;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubscribeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SubscribeService>;
+}
+export type DispatchMode = 'sync' | 'async';

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

@@ -1,15 +1,18 @@
 import { ProgrammabilityService } from '../services/programmability.service';
-import { AbstractControl, FormGroup } from '@angular/forms';
+import { AbstractControl, FormGroup, ValidationErrors } from '@angular/forms';
 import { LanguageService } from '@wemake4u/interact';
 import * as i0 from "@angular/core";
 export declare class ValidationService {
     private languageService;
     private programmability;
     constructor(languageService: LanguageService, programmability: ProgrammabilityService);
-    suppress: boolean;
+    private _suppress;
+    set suppress(value: boolean);
+    get suppress(): boolean;
     createCollection(): ValidationCollection;
     addToCollection(collection: ValidationCollection, control: AbstractControl, formGroup: FormGroup, component: any): void;
     setupCollection(collection: ValidationCollection): void;
+    validateRequired(control: AbstractControl): ValidationErrors | null;
     private canAddToCollection;
     private getRules;
     private validateRules;

package/lib/utils/deepEqual.d.ts

@@ -0,0 +1 @@
+export declare function deepEqual(a: any, b: any, visited?: WeakMap<object, any>): boolean;

package/lib/utils/observable.d.ts

@@ -0,0 +1,2 @@
+import { Observable } from 'rxjs';
+export declare function subscribeOnce<T>(source$: Observable<T>, next: (value: T) => void): void;

package/lib/utils/proxy.d.ts

@@ -1,2 +1,4 @@
 export declare function bindFunction(fn: Function, context: any): any;
 export declare function toProxy(instance: any, seen?: WeakMap<object, any>): any;
+export declare function isProxy(value: any): boolean;
+export declare function getTarget(value: any): any;

package/lib/utils/resolveRefs.d.ts

@@ -0,0 +1,12 @@
+export interface RefContext {
+    parent: any;
+    key: string | number | null;
+    root: any;
+}
+export type RefResolver = (ref: string, ctx: RefContext) => any;
+export type AsyncRefResolver = (ref: string, ctx: RefContext) => Promise<any>;
+export interface ResolveRefsOptions {
+    mergeRef?: boolean;
+}
+export declare function resolveRefs<T>(input: T, resolver: RefResolver, options?: ResolveRefsOptions): T;
+export declare function resolveRefsAsync<T>(input: T, resolver: AsyncRefResolver, options?: ResolveRefsOptions): Promise<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wemake4u/form-player-se",
-  "version": "1.0.39",
+  "version": "1.0.40",
   "license": "MIT",
   "peerDependencies": {
     "@angular/cdk": "^18.2.0",

package/public-api.d.ts

@@ -1,6 +1,9 @@
 export * from './lib/dynamic-form/dynamic-form.component';
 export * from './lib/utils/toFormData';
 export * from './lib/utils/syncronize';
+export * from './lib/utils/resolveRefs';
+export * from './lib/utils/observable';
+export * from './lib/utils/deepEqual';
 export * from './lib/services/toast.service';
 export * from './lib/services/sanitize.service';
 export * from './lib/services/feel.service';
@@ -13,3 +16,4 @@ export * from './lib/services/form.service';
 export * from './lib/interact/confirmation';
 export * from './lib/interact/notification';
 export * from './lib/interact/prompt';
+export * from './lib/builtIn/builtIn';