@wemake4u/form-player 0.0.0-stage → 2.0.0

package/types/wemake4u-form-player.d.ts

@@ -0,0 +1,1630 @@
+import * as i0 from "@angular/core";
+import { ChangeDetectorRef, DestroyRef, ElementRef, EnvironmentInjector, EventEmitter, Injector, OnChanges, OnDestroy, OnInit, SimpleChanges, Type } from "@angular/core";
+import { ActivatedRoute, Params, Router } from "@angular/router";
+import { AbstractControl, AbstractControlOptions, AsyncValidatorFn, FormControlStatus, FormGroup, ValidationErrors, ValidatorFn } from "@angular/forms";
+import { Observable, Subject } from "rxjs";
+import { SirioButtonVariant, SirioDialogSize, SirioSidenavItem, SirioStep, SirioToastService } from "@wemake4u/form-controls";
+import { ConfirmationController, LanguageService, Message, MessageFactory, NotificationController, NotifyTypes, PromptController } from "@wemake4u/interact";
+import { DomSanitizer, SafeHtml, SafeResourceUrl } from "@angular/platform-browser";
+import { HttpClient } from "@angular/common/http";
+import { FilterModel, IGetRowsParams } from "ag-grid-community";
+declare class FormGroupEx<TControl extends { [K in keyof TControl]: AbstractControl<any>; }> extends FormGroup<TControl> {
+  constructor(controls: TControl, mode: FormGroupMode, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
+  getMode(): FormGroupMode;
+  isNull(): boolean;
+  setNull(): void;
+  setNotNull(): void;
+  private __isNull;
+  private sub?;
+  private mode;
+  private setNullValue;
+  private clearNullValue;
+  protected _updateValue(): void;
+}
+type FormGroupMode = 'default' | 'nullable';
+declare function isNullableGroup(control: AbstractControl): control is FormGroupEx<any>;
+export declare class GlobalService {
+  constructor();
+  clearProperties(): void;
+  setProperties(properties: Record<string, any>): void;
+  getProperties(): Record<string, any>;
+  getProperty(name: string, defaultValue?: any): any;
+  registerComponent(typeName: string, componentType: Type<any>): void;
+  getComponents(): Record<string, Type<any>>;
+  getComponent(typeName: string): Type<any> | null;
+  private properties;
+  private components;
+  static ɵfac: i0.ɵɵFactoryDeclaration<GlobalService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class FeelService {
+  private globalService;
+  constructor(globalService: GlobalService);
+  private _verbose;
+  get verbose(): boolean;
+  evalTemplate(template: string, context?: any): string;
+  evalExpression(expression: string, context?: Record<string, any>): any;
+  evalUnaryTest(expression: string, context?: Record<string, any>, input?: any): boolean | null;
+  isValidExpression(expression: string): boolean;
+  isValidUnaryTest(expression: string): boolean;
+  getDependencies(expression: string, context?: Record<string, any>): (string | string[])[];
+  getTemplateDependencies(expression: string, context?: Record<string, any>): (string | string[])[];
+  private findAncestor;
+  private findDescendant;
+  private findChild;
+  private findChildren;
+  private getFunctionName;
+  private getStatusDependencies;
+  private splitQuoted;
+  private logWarnings;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FeelService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+type Path = string | number | Array<string | number>;
+/** A path split into its segments (see normalizePath). */
+type PathSegments = (string | number)[];
+declare function normalizePath(path: Path): PathSegments;
+declare function matchPath(pathA: Path, pathB: Path): boolean;
+declare function stringifyPath(path: Path): string;
+declare function isIndexSegment(segment: string | number): boolean;
+export declare class ScopeService implements IEvaluatorProvider {
+  private parent;
+  constructor(parent: ScopeService | null);
+  private readonly injector;
+  private scope;
+  private readonly refreshSubject;
+  readonly onRefresh: Observable<Path>;
+  /** Paths requested with watch(), by key: watched again when the scope is replaced. */
+  private readonly requested;
+  /** Effects of the watched paths that go through signals, by key. */
+  private readonly watchers;
+  set(scope: Record<string, any> | null): void;
+  get(): Record<string, any> | null;
+  refresh(path?: Path): void;
+  refreshMany(...paths: Path[]): void;
+  /**
+   * Refreshes that concern the given path: the explicit ones (refresh(), setValue()) and, when the
+   * path goes through signals of the scope, the changes of those signals.
+   */
+  watch(path: Path): Observable<Path>;
+  setValue(path: Path, value: any): void;
+  getContext(): Record<string, any>;
+  /** Watches the last signal along the path (nothing to do when the path has none). */
+  private watchSignals;
+  private unwatchAll;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ScopeService, [{
+    optional: true;
+    skipSelf: true;
+  }]>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class Control {
+  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 {
+  constructor(context: ControlContext);
+  findControl(predicate: (control: Control) => boolean, firstOnly: boolean): Control[];
+}
+export declare class ItemControl extends ContainerControl {
+  readonly index: number;
+  constructor(context: ControlContext, index: number);
+}
+export interface ControlContext {
+  name: string;
+  path: string;
+  metadata: any;
+  componentRef: any;
+  elementRef: ElementRef;
+  injector: Injector;
+  destroyRef: DestroyRef;
+  register: () => RegisterService | undefined;
+}
+declare class RegisterService implements IEvaluatorProvider {
+  private parent;
+  constructor(parent: RegisterService | null);
+  private controls;
+  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;
+  findControl(predicate: (control: Control) => boolean, firstOnly?: boolean, parent?: boolean): Control[];
+  private castString;
+  private resolveParent;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RegisterService, [{
+    optional: true;
+    skipSelf: true;
+  }]>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+interface IdentityNode {
+  id: string;
+  index?: number;
+}
+export declare class ToastService implements IEvaluatorProvider {
+  private sirioToast;
+  private global;
+  constructor(sirioToast: SirioToastService, global: GlobalService);
+  private delayTime;
+  notifyInfo(message: string, title?: string, delay?: number): void;
+  notifySuccess(message: string, title?: string, delay?: number): void;
+  notifyWarning(message: string, title?: string, delay?: number): void;
+  notifyError(message: string, title?: string, delay?: number): void;
+  getContext(): Record<string, any>;
+  private notify;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare class MetadataService {
+  constructor();
+  setSchema(schema: any): void;
+  getSchema(): any;
+  setForms(forms: any[]): void;
+  getTemplateByName(name: string): any;
+  getForms(): any[];
+  getFormByName(name: string): any;
+  getFormIndexByName(name: string): number;
+  getFormNameByIndex(index: number): string | undefined;
+  private schema;
+  private forms;
+  private isValidFormIndex;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MetadataService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class DialogService implements IEvaluatorProvider {
+  private readonly dialogs;
+  openDialog(formSchema: any, options?: FormDialogOptions): void;
+  /** Closes the top dialog without a result (onResult is not called). */
+  closeDialog(): void;
+  alert(text: string, options?: DialogOptions): void;
+  info(text: string, options?: DialogOptions): void;
+  confirm(text: string, options?: DialogOptions): void;
+  show(text: string, options?: DialogOptions): void;
+  prompt(text: string, defaultValue?: string, options?: DialogOptions): void;
+  getContext(): Record<string, any>;
+  private showDialog;
+  private createTextSchema;
+  private createInputSchema;
+  private ensureClosable;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export type DialogTypes = 'info' | 'warning' | 'danger';
+export type DialogSizes = SirioDialogSize;
+export type ButtonColors = SirioButtonVariant;
+export interface DialogOptions {
+  type?: DialogTypes;
+  size?: DialogSizes;
+  title?: string;
+  isDrawer?: boolean;
+  closeButton?: boolean;
+  buttons?: DialogButtons;
+  customButtons?: CustomButton[];
+  keepOpen?: boolean;
+  onResult?: (result: DialogResult) => void;
+}
+export interface FormDialogOptions extends DialogOptions {
+  value?: any;
+  injector?: Injector;
+  showNav?: boolean;
+  showNavButton?: boolean;
+  showProgress?: boolean;
+  showFormTitle?: boolean;
+  /** role="alertdialog" (alert and confirm). */
+  alert?: boolean;
+}
+export interface DialogResult {
+  form: DynamicFormComponent;
+  setProperty: (name: string, value: unknown) => void;
+  action: DialogAction | string;
+  value?: any;
+}
+export interface CustomButton {
+  text: string;
+  color: ButtonColors;
+  action: string;
+}
+export type DialogAction = 'OK' | 'Cancel' | 'Yes' | 'No' | 'Confirm' | 'Close' | 'Abort' | 'Retry' | 'Ignore' | 'Try' | 'Continue';
+export type DialogButtons = 'OK' | 'OKCancel' | 'ConfirmCancel' | 'AbortRetryIgnore' | 'YesNoCancel' | 'YesNo' | 'RetryCancel' | 'CancelTryContinue' | 'Custom';
+interface OpenWindowFeatures {
+  width?: number;
+  height?: number;
+  left?: number;
+  top?: number;
+  toolbar?: boolean;
+  menubar?: boolean;
+  location?: boolean;
+  status?: boolean;
+  resizable?: boolean;
+  scrollbars?: boolean;
+  noopener?: boolean;
+  noreferrer?: boolean;
+  center?: boolean;
+  focus?: boolean;
+}
+type WindowTarget = '_blank' | '_self' | '_parent' | '_top' | string;
+declare function openWindow(url: string, target?: WindowTarget, features?: OpenWindowFeatures): Window | null;
+declare class FunctionService implements IEvaluatorProvider {
+  private metadata;
+  private dialog;
+  private injector;
+  constructor(metadata: MetadataService, dialog: DialogService, injector: Injector);
+  invokable(func: any): (...args: any[]) => any;
+  executeOnce<T>(observable: Observable<T>, callback: any): void;
+  asObservable<T>(value: T): Observable<T>;
+  setTimeout<T>(callback: any, delay: number): void;
+  openForm(template: string | object, options: DialogOptions): void;
+  openWindow(url: string, target?: WindowTarget, features?: OpenWindowFeatures): Window | null;
+  newGuid(): string;
+  range(from: number, to: number): number[];
+  hydrate<T = any>(value: T, deep?: boolean): T;
+  getContext(): Record<string, any>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FunctionService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+type ControlType = 'array' | 'group' | 'control';
+export type PatchPredicate = (control: AbstractControl, value: any) => boolean;
+export interface PatchOptions {
+  emitEvent?: boolean;
+  emitError?: boolean;
+  emitWarn?: boolean;
+  validateType?: boolean;
+  fallbackValue?: any;
+  strict: boolean;
+  canPatch?: PatchPredicate;
+}
+export interface PathOptions {
+  emitError?: boolean;
+  emitWarn?: boolean;
+  create?: boolean;
+  expected?: ControlType;
+  breakOnArray?: boolean;
+  breakOnNull?: boolean;
+}
+export interface EnumerateOptions {
+  expandArray?: boolean;
+  expandGroup?: boolean;
+  skipDisabled?: boolean;
+}
+export type ExpandOptions = Omit<EnumerateOptions, 'skipDisabled'>;
+export declare class FormService implements IEvaluatorProvider {
+  set(control: AbstractControl, path: Path, value: any, pathOptions?: PathOptions, patchOptions?: PatchOptions): boolean;
+  get(control: AbstractControl, path: Path, pathOptions?: PathOptions): any;
+  reset(control: AbstractControl, path: Path): any;
+  resetAll(control: AbstractControl, ...paths: string[]): void;
+  getControl(control: AbstractControl, path: Path, pathOptions?: PathOptions): AbstractControl | undefined;
+  prepend(control: AbstractControl, path: Path, value: any, pathOptions?: PathOptions, patchOptions?: PatchOptions): boolean;
+  append(control: AbstractControl, path: Path, value: any, pathOptions?: PathOptions, patchOptions?: PatchOptions): boolean;
+  insert(control: AbstractControl, path: Path, index: number, value: any, pathOptions?: PathOptions, patchOptions?: PatchOptions): boolean;
+  remove(control: AbstractControl, path: Path, index: number): boolean;
+  moveUp(control: AbstractControl, path: Path, index: number): boolean;
+  moveDown(control: AbstractControl, path: Path, index: number): boolean;
+  status(control: AbstractControl, path: Path, pathOptions?: PathOptions): FormControlStatus | undefined;
+  updateAllValueAndValidity(control: AbstractControl, emitEvent?: boolean): void;
+  getInvalidControls(control: AbstractControl): {
+    path: string;
+    control: AbstractControl;
+  }[];
+  patch(control: AbstractControl, value: any, options?: PatchOptions): void;
+  getPath(control: AbstractControl): (string | number)[];
+  getFullPath(control: AbstractControl): string;
+  waitForControl(formGroup: FormGroup, path: Path, pathOptions?: PathOptions): Observable<AbstractControl>;
+  statusChanges(control: AbstractControl, waitForPending?: () => void): Observable<FormControlStatus>;
+  buildControl(value: any): AbstractControl;
+  getContext(formGroup: any): Record<string, any>;
+  enumerateControls(source: AbstractControl | Iterable<AbstractControl>, options?: EnumerateOptions): Generator<AbstractControl>;
+  private applyPath;
+  private asObject;
+  private asArray;
+  private insertIntoArray;
+  private removeFromArray;
+  private createArrayItem;
+  private createControlFromValue;
+  private createControlFromArray;
+  private setUnknown;
+  private isUnknown;
+  private waitUntilSettled;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FormService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare class FormatterService implements IEvaluatorProvider {
+  constructor();
+  formatDate(isoDate: string | null | undefined, options?: Intl.DateTimeFormatOptions, locale?: string): string;
+  formatTime(isoDate: string | null | undefined, options?: Intl.DateTimeFormatOptions, locale?: string): string;
+  formatDateTime(isoDate: string | null | undefined, options?: Intl.DateTimeFormatOptions, locale?: string): string;
+  formatCurrency(value: number, currency?: string, locale?: string): string;
+  formatNumber(value: number, decimals?: number, locale?: string): string;
+  getContext(): Record<string, any>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FormatterService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare class JsonService implements IEvaluatorProvider {
+  constructor();
+  toJson(value: any, indent: boolean): string;
+  parseJson(value: any): any;
+  getContext(): Record<string, any>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<JsonService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare class WeakService {
+  constructor();
+  private cache;
+  exists(source: object, key: string): boolean;
+  call<T>(source: object, key: string, func: () => T, reusable?: ((value: T) => boolean) | null, store?: ((value: T) => any) | null, cacheable?: ((value: T) => boolean) | null): T;
+  invalidate(source: object, key: string): void;
+  invalidateAll(source: object): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WeakService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+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, emitWhenUnchanged?: boolean): void;
+  private _dispatchMode;
+  private dispatch;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SubscribeService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+type DispatchMode = 'sync' | 'async';
+declare class Notifier<T = void> {
+  private readonly subject;
+  readonly changes: Observable<T>;
+  notify(value: T): void;
+  complete(): void;
+}
+interface SessionChange<T = unknown> {
+  key: string;
+  value: T | null;
+  previousValue: T | null;
+}
+declare class SessionService {
+  private readonly storage;
+  private readonly changes;
+  get<T>(key: string): T | null;
+  set<T>(key: string, value: T): void;
+  remove(key: string): void;
+  watch(): Observable<SessionChange>;
+  private write;
+  private parse;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SessionService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare class ProgrammabilityService {
+  private feelService;
+  private weakService;
+  private toastService;
+  private dialogService;
+  private formatterService;
+  private jsonService;
+  private functionService;
+  private formService;
+  private globalService;
+  private subscribeService;
+  private session;
+  private destroyRef;
+  private register;
+  private scope;
+  constructor(feelService: FeelService, weakService: WeakService, toastService: ToastService, dialogService: DialogService, formatterService: FormatterService, jsonService: JsonService, functionService: FunctionService, formService: FormService, globalService: GlobalService, subscribeService: SubscribeService, session: SessionService, destroyRef: DestroyRef, register: RegisterService, scope: ScopeService);
+  readonly evaluationDone: Notifier<void>;
+  private predefinedFunctions;
+  private evaluatorProviders;
+  addEvaluatorProviders(evaluatorProvider: IEvaluatorProvider): void;
+  isExpression(text: string | null | undefined): boolean;
+  getExpression(text: string | null | undefined): string;
+  evaluateString(formGroup: FormGroup, value: string | null | undefined, options?: EvaluateOptions): string;
+  evaluateBoolean(formGroup: FormGroup, value: boolean | string | null | undefined, options?: EvaluateOptions): boolean | null;
+  evaluateNumber(formGroup: FormGroup, value: number | string | null | undefined, options?: EvaluateOptions): number | null;
+  evaluate(formGroup: FormGroup, value: string | null, options?: EvaluateOptions): any;
+  evaluateTemplate(formGroup: FormGroup, value: string | null, options?: EvaluateOptions): any;
+  evaluateUnary(formGroup: FormGroup, value: string | null, input: any, options?: EvaluateOptions): any;
+  invalidate(value: string | null): void;
+  invalidateAll(): void;
+  watch(formGroup: FormGroup, dependencies: (string | string[])[], callback: () => void, destroyRef?: DestroyRef): void;
+  getDependencies(formGroup: FormGroup, expression: string): (string | string[])[];
+  get verbose(): boolean;
+  get cacheable(): boolean;
+  private _verbose;
+  private _cacheable;
+  private onErrorHandler;
+  private Init;
+  private evalUnaryTest;
+  private evalExpression;
+  private evalTemplate;
+  private onError;
+  private getPredefinedFunctions;
+  private getFeelFunctions;
+  private getFormFunctions;
+  private getParentContext;
+  private getRootContext;
+  private getParent;
+  private getContext;
+  private watchingExpression;
+  private watchingTemplateExpression;
+  private watchingDependencies;
+  private invalidateExpression;
+  private invalidateAllExpression;
+  private processDependencies;
+  private getPath;
+  private readonly route;
+  private queryParams;
+  private readonly queryParams$;
+  private onQueryParamsChange;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ProgrammabilityService, [null, null, null, null, null, null, null, null, null, null, null, null, {
+    optional: true;
+  }, {
+    optional: true;
+  }]>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+interface IEvaluatorProvider {
+  getContext(scope?: any): Record<string, any>;
+}
+interface EvaluateOptions {
+  cacheable?: boolean;
+  ignoreDeps?: boolean;
+  cacheInvalidated?: () => void;
+  destroyRef?: DestroyRef;
+  invokeArgs?: any[];
+  hydrate?: boolean;
+  extendContext?: ExtendContextFn;
+  transform?: TransformFn;
+}
+type ExtendContextFn = () => Record<string, any>;
+type TransformFn<TIn = any, TOut = any> = (value: TIn) => TOut;
+declare class ValidationService {
+  private languageService;
+  private programmability;
+  constructor(languageService: LanguageService, programmability: ProgrammabilityService);
+  private requiredMode;
+  readonly validationDone: Notifier<void>;
+  private _suppress;
+  set suppress(value: boolean);
+  get suppress(): boolean;
+  createCollection(): ValidationCollection;
+  addToCollection(collection: ValidationCollection, control: AbstractControl, formGroup: FormGroup, component: any): void;
+  setupCollection(collection: ValidationCollection, destroyRef?: DestroyRef): void;
+  validateRequired(control: AbstractControl, currentValue: any): ValidationErrors | null;
+  isRequired(control: AbstractControl): boolean;
+  allowSilentError(): boolean;
+  isSilentError(control: AbstractControl | null | undefined): boolean;
+  hasSilentErrors(controls: Iterable<AbstractControl>): boolean;
+  revealSilentErrors(controls: Iterable<AbstractControl>): void;
+  countErrors(controls: Iterable<AbstractControl>, includeSilent?: boolean): number;
+  private canAddToCollection;
+  private getRules;
+  private validateRules;
+  private createValidator;
+  private createAsyncValidator;
+  private createRequiredValidator;
+  private markSilent;
+  private validationErrors;
+  private watchForValidation;
+  private logValidation;
+  private readonly nullObserver;
+  private get language();
+  private locale;
+  private requiredValidators;
+  private requiredValidator;
+  private requiredTrueValidator;
+  private isTrueValidator;
+  private isRequiredSatisfied;
+  private getRequiredMessage;
+  private shouldSkipValidation;
+  private resolveSkipValidation;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ValidationService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+interface ComponentContext {
+  component: any;
+  formGroup: FormGroup;
+}
+interface ValidationRule {
+  expression: string;
+  type: "validate" | "invalidate";
+  message: string;
+  async: boolean;
+}
+type ValidationCollection = Map<AbstractControl, ComponentContext>;
+declare class DisableService {
+  private programmability;
+  private formService;
+  constructor(programmability: ProgrammabilityService, formService: FormService);
+  createCollection(): DisableCollection;
+  addToCollection(collection: DisableCollection, control: AbstractControl, parentGroup: FormGroup, component: any): void;
+  setupCollection(collection: DisableCollection, destroyRef?: DestroyRef): void;
+  private selfDisabled;
+  private applyRule;
+  private canAddToCollection;
+  private getPath;
+  private normalize;
+  private isContainer;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DisableService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+interface DisableContext {
+  parentGroup: FormGroup;
+  component: any;
+}
+type DisableCollection = Map<AbstractControl, DisableContext>;
+declare class ComputeService {
+  private programmability;
+  private formService;
+  constructor(programmability: ProgrammabilityService, formService: FormService);
+  createCollection(): ComputeCollection;
+  addToCollection(collection: ComputeCollection, control: AbstractControl, parentGroup: FormGroup, component: any): void;
+  setupCollection(collection: ComputeCollection, destroyRef?: DestroyRef): void;
+  private canAddToCollection;
+  private applyExpression;
+  private getPath;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ComputeService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+interface ComputeContext {
+  parentGroup: FormGroup;
+  component: any;
+}
+type ComputeCollection = Map<AbstractControl, ComputeContext>;
+declare class StatusService {
+  private formService;
+  private subscribeService;
+  private validationService;
+  private destroyRef;
+  constructor(formService: FormService, subscribeService: SubscribeService, validationService: ValidationService, destroyRef: DestroyRef);
+  readonly statusDone: Notifier<void>;
+  createCollection(key?: any): StatusCollection;
+  addToCollection(collection: StatusCollection, control: AbstractControl, component: any): void;
+  setupCollection(collection: StatusCollection, destroyRef?: DestroyRef): void;
+  countErrors(key: any, includeSilent?: boolean): number;
+  enumerateControls(key: any, deep?: boolean): Generator<AbstractControl>;
+  private invalidMap;
+  private canAddToCollection;
+  private readonly enumerateOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StatusService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare class StatusCollection<TKey = any> {
+  key?: any | undefined;
+  constructor(key?: any | undefined);
+  readonly controls: Set<AbstractControl<any, any, any>>;
+  readonly children: Map<TKey, StatusCollection<TKey>>;
+  add(control: AbstractControl): this;
+  remove(control: AbstractControl): this;
+  has(control: AbstractControl): boolean;
+  clear(): void;
+  createCollection(key: TKey): StatusCollection<TKey>;
+  getCollection(key: TKey): StatusCollection<TKey> | undefined;
+  removeCollection(key: TKey): boolean;
+  getControls(deep?: boolean): IterableIterator<AbstractControl>;
+}
+declare class EventService {
+  private programmability;
+  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, destroyRef?: DestroyRef): void;
+  private processHandler;
+  static ɵfac: i0.ɵɵFactoryDeclaration<EventService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+interface EventContext {
+  component: any;
+  formGroup: FormGroup;
+}
+type EventCollection = Map<AbstractControl, EventContext>;
+declare class LifetimeService<TKey> implements OnDestroy {
+  private readonly environmentInjector;
+  private readonly injectors;
+  constructor(environmentInjector: EnvironmentInjector);
+  resolve(key: TKey): DestroyRef;
+  destroy(key: TKey): void;
+  ngOnDestroy(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LifetimeService<any>, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+interface BuildRowsOptions {
+  path?: string | null;
+  groupMode?: FormGroupMode;
+  statusSource?: any;
+  destroyRef?: DestroyRef;
+}
+declare class FormBuilderService {
+  private validationService;
+  private disableService;
+  private computeService;
+  private statusService;
+  private eventService;
+  private metadata;
+  private lifetime;
+  private destroyRef;
+  constructor(validationService: ValidationService, disableService: DisableService, computeService: ComputeService, statusService: StatusService, eventService: EventService, metadata: MetadataService, lifetime: LifetimeService<FormGroup>, destroyRef: DestroyRef);
+  buildForm(formGroup: FormGroup, forms: Array<any>, groupMode?: FormGroupMode): void;
+  /**
+   * Configures a FormGroup starting from an array of rows (each row exposes `components`).
+   * Rows are registered in the group located at `options.path`, relative to `formGroup`.
+   */
+  buildRows(formGroup: FormGroup, rows: Array<any>, options?: BuildRowsOptions): FormGroup;
+  private addRows;
+  private createCollections;
+  private setupCollections;
+  private hasValue;
+  private applyPath;
+  private splitPath;
+  private createFormGroup;
+  private addControls;
+  private isFormComponent;
+  private isContainerComponent;
+  private isComponentWithInput;
+  private isArrayComponent;
+  private getArrayItem;
+  private createFormArray;
+  private getContainers;
+  private getDefaultValue;
+  private getUpdateOn;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FormBuilderService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export type BrowserNavigation = 'none' | 'fragment' | 'queryParam';
+export declare class DynamicFormComponent implements OnInit, OnChanges, OnDestroy, IEvaluatorProvider {
+  private cdr;
+  private destroyRef;
+  private programmability;
+  private formBuilder;
+  private validationService;
+  private statusService;
+  private eventService;
+  private registerService;
+  private languageService;
+  private subscribeService;
+  private metadata;
+  private formService;
+  private dialog;
+  private injector;
+  private router;
+  private route;
+  private scope;
+  schema: any;
+  formGroup: FormGroup;
+  readOnly: boolean | null;
+  value: any;
+  strict: boolean;
+  showNav: boolean;
+  showNavButton: boolean;
+  showProgress: boolean;
+  showFormTitle: boolean;
+  progressStatus: boolean;
+  preventNavigationOnErrors: boolean;
+  browserNavigation: BrowserNavigation;
+  queryParamName: string;
+  navSize: 'normal' | 'small';
+  groupMode: FormGroupMode;
+  updateMode: 'changes' | 'submit';
+  valueChange: EventEmitter<any>;
+  initialized: EventEmitter<FormGroup<any>>;
+  activeNavChange: EventEmitter<any>;
+  formDiv: ElementRef<HTMLDivElement>;
+  constructor(cdr: ChangeDetectorRef, destroyRef: DestroyRef, programmability: ProgrammabilityService, formBuilder: FormBuilderService, validationService: ValidationService, statusService: StatusService, eventService: EventService, registerService: RegisterService, languageService: LanguageService, subscribeService: SubscribeService, metadata: MetadataService, formService: FormService, dialog: DialogService, injector: Injector, router: Router, route: ActivatedRoute, scope: ScopeService);
+  Texts: {
+    i18n: {
+      it: {
+        TypeToSearch: string;
+        Upload: string;
+        ScrollLeft: string;
+        ScrollRight: string;
+        AddItem: string;
+        RemoveItem: string;
+        PreviousSection: string;
+        NextSection: string;
+        Show: string;
+        Remove: string;
+        Close: string;
+        Confirm: string;
+        OK: string;
+        Cancel: string;
+        Abort: string;
+        Retry: string;
+        Ignore: string;
+        Yes: string;
+        No: string;
+        Try: string;
+        Continue: string;
+        Name: string;
+        Size: string;
+        Type: string;
+        Actions: string;
+        ReadMore: string;
+        ReadLess: string;
+        SelectAll: string;
+        ChooseOne: string;
+        True: string;
+        False: string;
+        Blank: string;
+        NotBlank: string;
+        Information: string;
+        InformationAbout: string;
+        OpenMenu: string;
+        CloseMenu: string;
+        LoadingFailed: string;
+        ConfirmDelete: string;
+        MoveUp: string;
+        MoveDown: string;
+        NoData: string;
+        RequiredField: string;
+        Errors: string;
+        PreviousElement: string;
+        NextElement: string;
+        Elements: string;
+        Element: string;
+        GoToElement: string;
+        ElementsNavigation: string;
+        Of: string;
+        Download: string;
+        Uploading: string;
+        Downloading: string;
+        Deleting: string;
+        Selected: string;
+        SelectedPlural: string;
+        SomethingWentWrong: string;
+        TimeoutOccurred: string;
+        GenericError: string;
+      };
+      en: {
+        TypeToSearch: string;
+        Upload: string;
+        ScrollLeft: string;
+        ScrollRight: string;
+        AddItem: string;
+        RemoveItem: string;
+        PreviousSection: string;
+        NextSection: string;
+        Show: string;
+        Remove: string;
+        Close: string;
+        Confirm: string;
+        OK: string;
+        Cancel: string;
+        Abort: string;
+        Retry: string;
+        Ignore: string;
+        Yes: string;
+        No: string;
+        Try: string;
+        Continue: string;
+        Name: string;
+        Size: string;
+        Type: string;
+        Actions: string;
+        ReadMore: string;
+        ReadLess: string;
+        SelectAll: string;
+        ChooseOne: string;
+        True: string;
+        False: string;
+        Blank: string;
+        NotBlank: string;
+        Information: string;
+        InformationAbout: string;
+        OpenMenu: string;
+        CloseMenu: string;
+        LoadingFailed: string;
+        ConfirmDelete: string;
+        MoveUp: string;
+        MoveDown: string;
+        NoData: string;
+        RequiredField: string;
+        Errors: string;
+        PreviousElement: string;
+        NextElement: string;
+        Elements: string;
+        Element: string;
+        GoToElement: string;
+        ElementsNavigation: string;
+        Of: string;
+        Download: string;
+        Uploading: string;
+        Downloading: string;
+        Deleting: string;
+        Selected: string;
+        SelectedPlural: string;
+        SomethingWentWrong: string;
+        TimeoutOccurred: string;
+        GenericError: string;
+      };
+      de: {
+        TypeToSearch: string;
+        Upload: string;
+        ScrollLeft: string;
+        ScrollRight: string;
+        AddItem: string;
+        RemoveItem: string;
+        PreviousSection: string;
+        NextSection: string;
+        Show: string;
+        Remove: string;
+        Close: string;
+        Confirm: string;
+        OK: string;
+        Cancel: string;
+        Abort: string;
+        Retry: string;
+        Ignore: string;
+        Yes: string;
+        No: string;
+        Try: string;
+        Continue: string;
+        Name: string;
+        Size: string;
+        Type: string;
+        Actions: string;
+        ReadMore: string;
+        ReadLess: string;
+        SelectAll: string;
+        ChooseOne: string;
+        True: string;
+        False: string;
+        Blank: string;
+        NotBlank: string;
+        Information: string;
+        InformationAbout: string;
+        OpenMenu: string;
+        CloseMenu: string;
+        LoadingFailed: string;
+        ConfirmDelete: string;
+        MoveUp: string;
+        MoveDown: string;
+        NoData: string;
+        RequiredField: string;
+        Errors: string;
+        PreviousElement: string;
+        NextElement: string;
+        Elements: string;
+        Element: string;
+        GoToElement: string;
+        ElementsNavigation: string;
+        Of: string;
+        Download: string;
+        Uploading: string;
+        Downloading: string;
+        Deleting: string;
+        Selected: string;
+        SelectedPlural: string;
+        SomethingWentWrong: string;
+        TimeoutOccurred: string;
+        GenericError: string;
+      };
+      fr: {
+        TypeToSearch: string;
+        Upload: string;
+        ScrollLeft: string;
+        ScrollRight: string;
+        AddItem: string;
+        RemoveItem: string;
+        PreviousSection: string;
+        NextSection: string;
+        Show: string;
+        Remove: string;
+        Close: string;
+        Confirm: string;
+        OK: string;
+        Cancel: string;
+        Abort: string;
+        Retry: string;
+        Ignore: string;
+        Yes: string;
+        No: string;
+        Try: string;
+        Continue: string;
+        Name: string;
+        Size: string;
+        Type: string;
+        Actions: string;
+        ReadMore: string;
+        ReadLess: string;
+        SelectAll: string;
+        ChooseOne: string;
+        True: string;
+        False: string;
+        Blank: string;
+        NotBlank: string;
+        Information: string;
+        InformationAbout: string;
+        OpenMenu: string;
+        CloseMenu: string;
+        LoadingFailed: string;
+        ConfirmDelete: string;
+        MoveUp: string;
+        MoveDown: string;
+        NoData: string;
+        RequiredField: string;
+        Errors: string;
+        PreviousElement: string;
+        NextElement: string;
+        Elements: string;
+        Element: string;
+        GoToElement: string;
+        ElementsNavigation: string;
+        Of: string;
+        Download: string;
+        Uploading: string;
+        Downloading: string;
+        Deleting: string;
+        Selected: string;
+        SelectedPlural: string;
+        SomethingWentWrong: string;
+        TimeoutOccurred: string;
+        GenericError: string;
+      };
+      es: {
+        TypeToSearch: string;
+        Upload: string;
+        ScrollLeft: string;
+        ScrollRight: string;
+        AddItem: string;
+        RemoveItem: string;
+        PreviousSection: string;
+        NextSection: string;
+        Show: string;
+        Remove: string;
+        Close: string;
+        Confirm: string;
+        OK: string;
+        Cancel: string;
+        Abort: string;
+        Retry: string;
+        Ignore: string;
+        Yes: string;
+        No: string;
+        Try: string;
+        Continue: string;
+        Name: string;
+        Size: string;
+        Type: string;
+        Actions: string;
+        ReadMore: string;
+        ReadLess: string;
+        SelectAll: string;
+        ChooseOne: string;
+        True: string;
+        False: string;
+        Blank: string;
+        NotBlank: string;
+        Information: string;
+        InformationAbout: string;
+        OpenMenu: string;
+        CloseMenu: string;
+        LoadingFailed: string;
+        ConfirmDelete: string;
+        MoveUp: string;
+        MoveDown: string;
+        NoData: string;
+        RequiredField: string;
+        Errors: string;
+        PreviousElement: string;
+        NextElement: string;
+        Elements: string;
+        Element: string;
+        GoToElement: string;
+        ElementsNavigation: string;
+        Of: string;
+        Download: string;
+        Uploading: string;
+        Downloading: string;
+        Deleting: string;
+        Selected: string;
+        SelectedPlural: string;
+        SomethingWentWrong: string;
+        TimeoutOccurred: string;
+        GenericError: string;
+      };
+      pt: {
+        TypeToSearch: string;
+        Upload: string;
+        ScrollLeft: string;
+        ScrollRight: string;
+        AddItem: string;
+        RemoveItem: string;
+        PreviousSection: string;
+        NextSection: string;
+        Show: string;
+        Remove: string;
+        Close: string;
+        Confirm: string;
+        OK: string;
+        Cancel: string;
+        Abort: string;
+        Retry: string;
+        Ignore: string;
+        Yes: string;
+        No: string;
+        Try: string;
+        Continue: string;
+        Name: string;
+        Size: string;
+        Type: string;
+        Actions: string;
+        ReadMore: string;
+        ReadLess: string;
+        SelectAll: string;
+        ChooseOne: string;
+        True: string;
+        False: string;
+        Blank: string;
+        NotBlank: string;
+        Information: string;
+        InformationAbout: string;
+        OpenMenu: string;
+        CloseMenu: string;
+        LoadingFailed: string;
+        ConfirmDelete: string;
+        MoveUp: string;
+        MoveDown: string;
+        NoData: string;
+        RequiredField: string;
+        Errors: string;
+        PreviousElement: string;
+        NextElement: string;
+        Elements: string;
+        Element: string;
+        GoToElement: string;
+        ElementsNavigation: string;
+        Of: string;
+        Download: string;
+        Uploading: string;
+        Downloading: string;
+        Deleting: string;
+        Selected: string;
+        SelectedPlural: string;
+        SomethingWentWrong: string;
+        TimeoutOccurred: string;
+        GenericError: string;
+      };
+    };
+    TypeToSearch: string;
+    Upload: string;
+    ScrollLeft: string;
+    ScrollRight: string;
+    AddItem: string;
+    RemoveItem: string;
+    PreviousSection: string;
+    NextSection: string;
+    Show: string;
+    Remove: string;
+    Close: string;
+    Confirm: string;
+    OK: string;
+    Cancel: string;
+    Abort: string;
+    Retry: string;
+    Ignore: string;
+    Yes: string;
+    No: string;
+    Try: string;
+    Continue: string;
+    Name: string;
+    Size: string;
+    Type: string;
+    Actions: string;
+    ReadMore: string;
+    ReadLess: string;
+    SelectAll: string;
+    ChooseOne: string;
+    True: string;
+    False: string;
+    Blank: string;
+    NotBlank: string;
+    Information: string;
+    InformationAbout: string;
+    OpenMenu: string;
+    CloseMenu: string;
+    LoadingFailed: string;
+    ConfirmDelete: string;
+    MoveUp: string;
+    MoveDown: string;
+    NoData: string;
+    RequiredField: string;
+    Errors: string;
+    PreviousElement: string;
+    NextElement: string;
+    Elements: string;
+    Element: string;
+    GoToElement: string;
+    ElementsNavigation: string;
+    Of: string;
+    Download: string;
+    Uploading: string;
+    Downloading: string;
+    Deleting: string;
+    Selected: string;
+    SelectedPlural: string;
+    SomethingWentWrong: string;
+    TimeoutOccurred: string;
+    GenericError: string;
+  };
+  ngOnInit(): void;
+  ngOnDestroy(): void;
+  ngOnChanges(changes: SimpleChanges): void;
+  get forms(): Array<any>;
+  locale(component: any, key: string): string;
+  canPrevious(): boolean;
+  goPrevious(): void;
+  canNext(): boolean;
+  goNext(): void;
+  goTo(formName: string, extraParams?: Params): void;
+  getControl(name: string): Control | null;
+  getControlAs<T extends Control>(name: string, type: new (...args: any[]) => T): T | null;
+  get activeNav(): number;
+  set activeNav(value: number);
+  getFormGroup(path: string | null): FormGroup;
+  getFormStatus(form: any, index: number): FormStatus;
+  countErrors(form: any): number;
+  /**
+   * Steps of the progress bar: one per enabled form, with the state of getFormStatus. The current form is the active
+   * step; a form "active" without being the current one (progressStatus false) stays selectable.
+   * The same object is returned while nothing changes (OnPush input of wm-sirio-stepper).
+   */
+  getProgress(): FormProgress | null;
+  private progressCache;
+  /**
+   * Entries of the side menu: one per enabled form (value = form index), disabled when the form is inactive, with
+   * the number of errors as red badge. The same objects are returned while nothing changes: wm-sirio-sidenav finds
+   * the current entry by identity.
+   */
+  getSidenavItems(): FormSidenav | null;
+  private sidenavCache;
+  activateForm(formIndex: number | undefined): void;
+  evaluateBoolean(value: boolean | string | null): boolean | null;
+  evaluateTemplate(value: string | null): string;
+  openForm(template: string, options: FormDialogOptions): void;
+  openDialog(formSchema: any, options: FormDialogOptions): void;
+  isChanged(): boolean;
+  isValid(): boolean;
+  getContext(): Record<string, any>;
+  submit(): boolean;
+  navigate(commands: any[], replaceUrl?: boolean, queryParams?: Params): void;
+  private valueChangesSubscription;
+  private _forms;
+  private _activeNav;
+  private defaultValue;
+  private urlSub?;
+  private initialQueryParams;
+  private currentQueryParams;
+  private listenToUrlChanges;
+  private unlistenToUrlChanges;
+  private selectUrlValue;
+  private requestNavigation;
+  private canNavigateTo;
+  private navigateToUrl;
+  private navigateFromUrl;
+  private applyNavigation;
+  private initQueryParams;
+  private buildQueryParams;
+  private toUrlValue;
+  private fromUrlValue;
+  private get urlKey();
+  private get language();
+  private onChangeSchema;
+  private onChangeValue;
+  private patchingValue;
+  private assignActivaNav;
+  private suspendValueChanges;
+  private registerHandlers;
+  private clearHandlers;
+  private emittedValues;
+  private isEmittedValue;
+  private emitValueChange;
+  private shouldEmit;
+  readonly refreshed: Subject<void>;
+  refresh(): void;
+  private getNext;
+  private getNextFrom;
+  private getPrevious;
+  private getPreviousFrom;
+  private getMaxNav;
+  private isFormActivable;
+  private isDisabled;
+  private isInactive;
+  private canActivate;
+  private hasPreviousErrors;
+  private clearControls;
+  private clearFormArrays;
+  private getCurrentForm;
+  private disableAutoFocus;
+  private autoFocus;
+  private canRevealErrors;
+  private hasPotentialNextForm;
+  hasSilentErrors(): boolean;
+  showSilentErrors(): void;
+  private hasActiveSilentErrors;
+  private showActiveSilentErrors;
+  private getSilentScope;
+  private getAllControls;
+  private getActiveControls;
+  private getFormByIndex;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormComponent, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, {
+    optional: true;
+  }]>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormComponent, "app-dynamic-form", never, {
+    "schema": {
+      "alias": "schema";
+      "required": false;
+    };
+    "formGroup": {
+      "alias": "formGroup";
+      "required": false;
+    };
+    "readOnly": {
+      "alias": "readOnly";
+      "required": false;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+    };
+    "strict": {
+      "alias": "strict";
+      "required": false;
+    };
+    "showNav": {
+      "alias": "showNav";
+      "required": false;
+    };
+    "showNavButton": {
+      "alias": "showNavButton";
+      "required": false;
+    };
+    "showProgress": {
+      "alias": "showProgress";
+      "required": false;
+    };
+    "showFormTitle": {
+      "alias": "showFormTitle";
+      "required": false;
+    };
+    "progressStatus": {
+      "alias": "progressStatus";
+      "required": false;
+    };
+    "preventNavigationOnErrors": {
+      "alias": "preventNavigationOnErrors";
+      "required": false;
+    };
+    "browserNavigation": {
+      "alias": "browserNavigation";
+      "required": false;
+    };
+    "queryParamName": {
+      "alias": "queryParamName";
+      "required": false;
+    };
+    "navSize": {
+      "alias": "navSize";
+      "required": false;
+    };
+    "groupMode": {
+      "alias": "groupMode";
+      "required": false;
+    };
+    "updateMode": {
+      "alias": "updateMode";
+      "required": false;
+    };
+    "activeNav": {
+      "alias": "activeNav";
+      "required": false;
+    };
+  }, {
+    "valueChange": "valueChange";
+    "initialized": "initialized";
+    "activeNavChange": "activeNavChange";
+  }, never, never, true, never>;
+}
+/** State of a form in the progress bar and in the side navigation. */
+type FormStatus = 'inactive' | 'active' | 'success' | 'error';
+/** Steps of the progress bar and the form of each step. */
+interface FormProgress {
+  steps: SirioStep[];
+  formIndexes: number[];
+  current: number;
+}
+/** Entries of the side menu and the current one. */
+interface FormSidenav {
+  items: SirioSidenavItem[];
+  active: SirioSidenavItem | null;
+}
+export declare function syncronize(target: any, source: any): any;
+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>;
+export declare function subscribeOnce<T>(source$: Observable<T>, next: (value: T) => void, error?: (err: any) => void, complete?: () => void): void;
+export declare function deepEqual(a: any, b: any, options?: {
+  handleCircular?: boolean;
+}, visited?: WeakMap<any, any>): boolean;
+export declare function navigateTo(router: Router, uri: string): void;
+export declare function parseRoute(uri: string): {
+  route: string;
+  queryParams: Record<string, string>;
+};
+export declare class SanitizeService {
+  private sanitizer;
+  constructor(sanitizer: DomSanitizer);
+  sanitizeHtml(html: string): string;
+  sanitizeSafeHtml(html: string): SafeHtml;
+  sanitizeSafeUrl(url: string): SafeResourceUrl;
+  toString(safeHtml: SafeHtml): string;
+  private sanitizeOption;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SanitizeService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class MarkdownService {
+  constructor();
+  toHtml(text: string): string;
+  /** Inline markdown only (bold, italic, links...): no block elements such as <p>. */
+  toInlineHtml(text: string): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MarkdownService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare class RestDataSource<T, T2 = T> {
+  private http;
+  private baseUrl;
+  private params;
+  private mapFn?;
+  constructor(http: HttpClient, baseUrl: string);
+  setParam(key: string, value: any): RestDataSource<T, T2>;
+  setParams(params: Record<string, any>): RestDataSource<T, T2>;
+  setMapFunction(mapFn: (data: T) => T2): RestDataSource<T, T2>;
+  getMapFunction(): ((data: T) => T2) | undefined;
+  getParam(key: string): any;
+  getParams(): Record<string, any>;
+  getData(): Observable<T2[]>;
+}
+interface IRowsSource {
+  getRows: (params: IGetRowsParams) => void;
+}
+interface IDataSource {
+  getData(params: Record<string, any>): Observable<any>;
+}
+export declare class DataService {
+  private http;
+  constructor(http: HttpClient);
+  queryOData(url: string): IRowsSource;
+  createRest(url: string): RestDataSource<any, any>;
+  createRest<T>(url: string): RestDataSource<T, T>;
+  createRest<T, T2>(url: string): RestDataSource<T, T2>;
+  private createOData;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DataService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+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<any>;
+}
+export declare class DefaultConfirmationController implements ConfirmationController {
+  private dialogService;
+  constructor(dialogService: DialogService);
+  confirm(message?: string, title?: string): Observable<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DefaultConfirmationController, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class DefaultNotificationController implements NotificationController {
+  private toast;
+  private global;
+  constructor(toast: ToastService, global: GlobalService);
+  private delayTime;
+  notify(type: NotifyTypes, message: string, title?: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DefaultNotificationController, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class DefaultPromptController implements PromptController {
+  private dialogService;
+  constructor(dialogService: DialogService);
+  prompt(message?: string, defaultValue?: string, title?: string): Observable<string | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DefaultPromptController, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class DefaultMessageFactory implements MessageFactory {
+  languageService: LanguageService;
+  constructor(languageService: LanguageService);
+  createError(err: any): Message;
+  private get language();
+  private locale;
+  private getTitleText;
+  private getTimeoutText;
+  private getDetailText;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DefaultMessageFactory, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+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;
+    }[];
+  }[];
+})[];
+export declare class FormControl extends ContainerControl {}
+export declare class TextFieldControl extends Control {
+  setRandomColor(): void;
+  focus(): void;
+  private getTextbox;
+  private getNativeInput;
+  private getRandomColor;
+}
+export declare class SelectControl extends Control {
+  focus(): void;
+  refresh(): void;
+  private getSelect;
+}
+export declare class TagListControl extends Control {
+  focus(): void;
+  refresh(): void;
+  private getSelect;
+}
+export declare class NumberControl extends Control {
+  focus(): void;
+  private getNumber;
+}
+export declare class DateControl extends Control {
+  focus(): void;
+  private getDate;
+}
+export declare class TimeControl extends Control {
+  focus(): void;
+  private getTime;
+}
+export declare class DateTimeControl extends Control {
+  focus(): void;
+  private getDateTime;
+}
+export declare class CheckBoxControl extends Control {
+  focus(): void;
+  private getCheckBox;
+}
+export declare class RadioControl extends Control {
+  focus(): void;
+  refresh(): void;
+  private getRadio;
+}
+export declare class CheckListControl extends Control {
+  focus(): void;
+  refresh(): void;
+  private getChecklist;
+}
+export declare class TextAreaControl extends Control {
+  focus(): void;
+  private getTextarea;
+}
+export declare class RangeControl extends Control {
+  focus(): void;
+  private getSlider;
+}
+export declare class FilePickerControl extends Control {
+  focus(): void;
+  private getFileUpload;
+}
+export declare class TextControl extends Control {}
+export declare class HtmlControl extends Control {}
+export declare class ImageControl extends Control {}
+export declare class TabControl extends ContainerControl {
+  canNext(): boolean;
+  goNext(): void;
+  canPrevious(): boolean;
+  goPrevious(): void;
+  /** Selects a tab (missing or disabled tabs are ignored). */
+  setActiveIndex(index: number): void;
+  onLoadState(): void;
+  onSaveState(): void;
+  private createState;
+  private get tab();
+}
+export declare class ChartControl extends Control {
+  private getChart;
+}
+export declare class AccordionControl extends ContainerControl {
+  /** Opens a section (missing, disabled or already open sections are ignored). */
+  openPanel(index: number): void;
+  onLoadState(): void;
+  onSaveState(): void;
+  private createState;
+  private get accordion();
+}
+export declare class DynamicListControl extends ContainerControl {}
+export declare class GroupControl extends ContainerControl {}
+export declare class TableControl extends Control {
+  setFilter(filter: FilterModel): void;
+  getFilter(): FilterModel;
+  clearFilter(): void;
+  getOrder(): OrderModel;
+  setOrder(order: OrderModel): 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;
+}
+export interface OrderModelItem {
+  colId: string;
+  sort: 'asc' | 'desc';
+}
+export interface OrderModel extends Array<OrderModelItem> {}
+export declare class ButtonControl extends Control {
+  /** The registered element is the native button (wmSirioButton of @wemake4u/form-controls). */
+  focus(): void;
+}
+export declare class SeparatorControl extends Control {}
+export declare class SpacerControl extends Control {}
+export declare class IFrameControl extends Control {}
+export declare class TooltipControl extends Control {}
+export declare class DisplayFieldControl extends Control {}
+export {};