@mediusinc/mng-commons 6.2.0-rc.0 → 7.0.0-rc.0

package/tableview/api/index.d.ts

@@ -1,63 +1,2542 @@
-export * from './action/descriptors/action.descriptor';
-export * from './action/descriptors/action-descriptor.factory';
-export * from './action/descriptors/action-editor.descriptor';
-export * from './action/descriptors/action-editor-descriptor.factory';
-export * from './action/descriptors/action-link.descriptor';
-export * from './action/descriptors/action-link-descriptor.factory';
-export * from './action/descriptors/editor-action-descriptor.factory';
-export * from './action/descriptors/editor-action-editor-descriptor.factory';
-export * from './action/descriptors/table-action-descriptor.factory';
-export * from './action/descriptors/table-action-editor-descriptor.factory';
-export * from './action/helpers/data-provider-executors';
-export * from './action/models/execution/action-context.model';
-export * from './action/models/execution/action-context-validation.model';
-export * from './action/models/execution/action-execution-error.model';
-export * from './action/models/execution/action-instance.model';
-export * from './action/models/execution/action-instance-state.model';
-export * from './action/models/execution/view-container.model';
-export * from './action/models/action.type';
-export * from './action/models/action-component.model';
-export * from './action/models/action-confirmation.model';
-export * from './action/models/action-descriptor.types';
-export * from './action/models/action-editor.model';
-export * from './action/models/action-error.model';
-export * from './action/models/tableview-action-default-categories.model';
-export * from './action/services/tokens/data-language-dropdown.token';
-export * from './action/services/data-provider-executor.service';
-export * from './editor/data-providers/editor.data-provider';
-export * from './editor/data-providers/editor-data-provider.factory';
-export * from './editor/descriptors/wrappers/editor-descriptor-nested-object-wrapper';
-export * from './editor/descriptors/editor.descriptor';
-export * from './editor/descriptors/editor-descriptor.factory';
-export * from './editor/descriptors/field.descriptor';
-export * from './editor/descriptors/field-action.descriptor';
-export * from './editor/descriptors/field-base.descriptor';
-export * from './editor/descriptors/field-group.descriptor';
-export * from './editor/descriptors/field-lookup.descriptor';
-export * from './editor/descriptors/field-many.descriptor';
-export * from './editor/descriptors/field-validation.descriptor';
-export * from './editor/models/editor.model';
-export * from './editor/models/editor-fields.model';
-export * from './editor/models/field.model';
-export * from './editor/models/field-action-context.model';
-export * from './editor/models/field-validation.model';
-export * from './editor/models/form-editor.event';
-export * from './editor/models/form-editor.interface';
-export * from './editor/models/formly-custom-field.model';
-export * from './editor/models/formly-field.model';
-export * from './editor/models/formly-options.model';
-export * from './editor/models/radio.model';
-export * from './editor/models/field-image-preview.model';
-export * from './tableview/data-providers/tableview.data-provider';
-export * from './tableview/data-providers/tableview-data-provider.factory';
-export * from './tableview/descriptors/tableview.descriptor';
-export * from './tableview/descriptors/tableview-descriptor.factory';
-export * from './tableview/helpers/files-export';
-export * from './tableview/helpers/tableview-create';
-export * from './tableview/helpers/tableview-data-provider-descriptor-convert';
-export * from './tableview/helpers/tableview-default-actions';
-export * from './tableview/helpers/tableview-input-builder';
-export * from './tableview/models/tableview-descriptor-fields-manage-helper.type';
-export * from './tableview/models/tableview-descriptor-helper.type';
-export * from './tableview/models/tableview-input.model';
-export * from './tableview/models/tableview-route.model';
+import * as i0 from '@angular/core';
+import { InputSignal, OutputEmitterRef, Type, InputSignalWithTransform, WritableSignal, Injector, InjectionToken } from '@angular/core';
+import * as _mediusinc_mng_commons_core from '@mediusinc/mng-commons/core';
+import { IdType, ActionData, ActionParameters, GetterFn, StyleLevelEnum, ServiceClassType, ILookupDataProvider, ILookupDescriptor, LookupDataProviderLookupFnType, EnumValue, EnumConstantType, ItemOrObservable, ArrayItemType, ITableviewDescriptor, ITableDescriptor, CommonPropsObjType3, IEditorDescriptor, IDataProvider, Nullable, IActionDescriptor, APermissions, ClassType, ServiceClassOptType, Undefined, DataProviderInst, StyleSizeEnum, DataListResult, CommonsErrorBaseOptions, ACommonsErrorBase, ICommonsActionError, ClassFunctionKeysWithParamAndReturnType, ClassFunctionKeyParam1ObjKeyExtendsOfTargetType, CommonsRouteData } from '@mediusinc/mng-commons/core';
+import { IActionButtonDescriptor, InputTrimType, EmptyValueType } from '@mediusinc/mng-commons/form/api';
+import { EnumDescriptor, TypeDescriptor, ModelDescriptor, ModelDescriptorCreateOpts } from '@mediusinc/mng-commons/model';
+import { ToastMessageOptions, Confirmation } from 'primeng/api';
+import * as rxjs from 'rxjs';
+import { Observable, Subject } from 'rxjs';
+import { DynamicDialogRef } from 'primeng/dynamicdialog';
+import * as _mediusinc_mng_commons_table_api from '@mediusinc/mng-commons/table/api';
+import { TableDescriptorInst, ITableDataProvider, TableDataProviderGetAllFnType, IColumnsManageInterface, ColumnDescriptor, TableDynamicDescriptorInst, TableReloadEvent, TableDataProviderInst, TableDataProviderGetAllEagerFnType } from '@mediusinc/mng-commons/table/api';
+import { AbstractControl, FormGroup, FormControl, UntypedFormGroup } from '@angular/forms';
+import * as _ngx_formly_core from '@ngx-formly/core';
+import { FieldType, FormlyFieldConfig, FormlyFormOptions, FormlyFieldProps } from '@ngx-formly/core';
+import * as _mediusinc_mng_commons_filter from '@mediusinc/mng-commons/filter';
+import { FilterDescriptor, FilterDisplayTypeEnum } from '@mediusinc/mng-commons/filter';
+import * as _mediusinc_mng_commons_tableview_api from '@mediusinc/mng-commons/tableview/api';
+import { Params, QueryParamsHandling } from '@angular/router';
+import { HttpErrorResponse } from '@angular/common/http';
+import { TranslateService } from '@ngx-translate/core';
+
+interface IActionComponent<Item = any, Service = undefined> {
+    action: InputSignal<ActionDescriptorInst<Item, Service, any, any, any>>;
+    item: InputSignal<Item>;
+    itemId: InputSignal<IdType>;
+    actionData: InputSignal<ActionData>;
+    enabled: InputSignal<boolean>;
+    loading: InputSignal<boolean>;
+    trigger: OutputEmitterRef<ActionParameters<Item>>;
+}
+
+interface IActionEditorComponent {
+    closeWithUnsavedChangesConfirmation(callFromGuard: boolean): Observable<boolean>;
+}
+
+interface ActionExecutionError {
+    error: any;
+    dismissed: boolean;
+}
+
+/**
+ * States of action. Enums ending with "*Final" are supposed to be final.
+ */
+declare enum ActionInstanceStateEnum {
+    TriggerStart = 0,// action was triggered (click or direct)
+    TriggerEnd = 1,
+    ActivationStart = 2,// action activation started (direct, event or editor)
+    ActivationEnd = 3,// action activation ended
+    FetchStart = 4,// fetch started
+    FetchEnd = 5,// fetch ended
+    FetchError = 6,// fetch error
+    RunConfirmationStart = 7,// confirmation for run is started
+    RunConfirmationEndAccept = 8,// confirmation accepted
+    RunConfirmationEndReject = 9,// confirmation rejected
+    RunStart = 10,// action was run by calling main function
+    RunEnd = 11,// action run function executed
+    RunError = 12,// action run function executed with error
+    NextActionStart = 13,// next action started
+    NextActionEnd = 14,// next action finished
+    ErrorActionStart = 15,// error action started
+    ErrorActionEnd = 16,// error action finished
+    FinishSuccessFinal = 17,// action executed successfully
+    FinishErrorFinal = 18,// action executed with error
+    FinishDismissedFinal = 19,// action was dismissed by user
+    FinishSuccessReactivateFinal = 20,// action executed successfully, another instance will directly start from previous
+    FinishComponentDestroyFinal = 21,// action was dismissed by destroying component that was executing it
+    FinishRouteUntriggerStart = 22,
+    FinishRouteUntriggerEndFinal = 23,
+    FinishRouteUntriggerTimeoutFinal = 24
+}
+
+interface IActionInstance<Item, Service> {
+    instanceId: string;
+    instanceLongName: string;
+    action: ActionDescriptorInst<Item, any, any, any, any>;
+    createdDate: Date;
+    triggerParameters?: ActionParameters<Item>;
+    activationParameters?: ActionParameters<Item>;
+    state: ActionInstanceStateEnum;
+    state$: Observable<ActionInstanceStateEnum>;
+    isRunLoading$: Observable<boolean>;
+    execution$: Observable<Item | null | undefined>;
+    executionIsRunning$: Observable<boolean>;
+    result?: Item | null;
+    result$: Observable<Item | null | undefined>;
+    error?: ActionExecutionError;
+    error$: Observable<ActionExecutionError>;
+    activationDialogRef?: DynamicDialogRef;
+    activationEditorComponentRef?: IActionEditorComponent;
+    reactivationPreviousInstance?: IActionInstance<Item, Service>;
+    previousInstance?: IActionInstance<any, any>;
+    nextActionInstance?: IActionInstance<any, any>;
+    errorActionInstance?: IActionInstance<Item, Service>;
+    reactivationInstance?: IActionInstance<Item, Service>;
+    reactivationInstance$: Observable<IActionInstance<Item, Service>>;
+}
+
+type FieldValidationParamsType<Value, FormValue, ParentFormValue = undefined, Control extends AbstractControl = AbstractControl> = {
+    fieldFormControl: Value extends never ? undefined : Control;
+    form: FormGroup<{
+        [K in keyof FormValue]: AbstractControl<FormValue[K]>;
+    }>;
+    fieldComponent?: Value extends never ? undefined : FieldType<CommonsFormlyFieldConfig<Value, FormValue>>;
+    formComponent?: IFormEditorComponent<FormValue, ParentFormValue>;
+    fieldFormlyConfig: Value extends never ? undefined : CommonsFormlyFieldConfig<Value, FormValue, ParentFormValue>;
+};
+type FieldBaseValidator<Value, FormValue, ParentFormValue = undefined, Control extends AbstractControl = AbstractControl> = (params: FieldValidationParamsType<Value, FormValue, ParentFormValue, Control>) => boolean;
+type FieldValidator<Value, FormValue, ParentFormValue = undefined, Control extends AbstractControl = FormControl<Value>> = FieldBaseValidator<Value, FormValue, ParentFormValue, Control>;
+type FormValidator<Value, ParentValue = undefined, Control extends AbstractControl = FormGroup<{
+    [K in keyof Value]: AbstractControl<Value[K]>;
+}>> = FieldBaseValidator<never, Value, ParentValue, Control>;
+type FieldAsyncBaseValidator<Value, FormValue, ParentFormValue = undefined, Control extends AbstractControl = AbstractControl> = (params: FieldValidationParamsType<Value, FormValue, ParentFormValue, Control>) => Observable<boolean>;
+type FieldAsyncValidator<Value, FormValue, ParentFormValue = undefined, Control extends AbstractControl = FormControl<Value>> = FieldAsyncBaseValidator<Value, FormValue, ParentFormValue, Control>;
+type FormAsyncValidator<Value, ParentFormValue = undefined, Control extends AbstractControl = FormGroup<{
+    [K in keyof Value]: AbstractControl;
+}>> = FieldAsyncBaseValidator<never, Value, ParentFormValue, Control>;
+type FieldValidationMessage<Value, FormValue, ParentFormValue = undefined> = string | ((error: any, field: CommonsFormlyFieldConfig<Value, FormValue, ParentFormValue>) => string | Observable<string>);
+type FormValidationMessage<Value, ParentFormValue = undefined> = FieldValidationMessage<Value, Value, ParentFormValue>;
+
+declare enum FieldSizeEnum {
+    Small = 0,
+    Normal = 1,
+    Large = 2
+}
+declare enum FieldInputTypeEnum {
+    Hidden = 0,
+    Label = 1,
+    Text = 2,
+    Textarea = 3,
+    Number = 4,
+    Currency = 5,
+    Switch = 6,
+    Radio = 7,
+    Datepicker = 8,
+    Mask = 9,
+    File = 10,
+    ImageFile = 11,
+    ImageUrl = 12,
+    Custom = 13
+}
+declare enum FieldLookupTypeEnum {
+    Dropdown = 0,
+    Autocomplete = 1,
+    Dialog = 2,
+    Custom = 3
+}
+declare enum FieldManyToManyEditorTypeEnum {
+    DialogTableMultiselect = 0
+}
+declare enum FieldManyToManyEditorActionEnum {
+    Add = 0,
+    Delete = 1
+}
+declare enum FieldManyEditorTypeEnum {
+    DialogEditor = 0
+}
+declare enum FieldManyEditorActionEnum {
+    View = 0,
+    Add = 1,
+    Edit = 2,
+    Delete = 3
+}
+declare enum FieldGroupTypeEnum {
+    Tab = 0,
+    Fieldset = 1,
+    Logical = 2
+}
+type FieldConfig = object;
+interface FieldLookupConfig extends FieldConfig {
+    table?: {
+        captionComponent?: Type<any>;
+        columnActionComponent?: Type<any>;
+    };
+}
+
+type FieldValidationDescriptorOptsType<Property = string> = {
+    errorPath?: Property;
+};
+declare class FieldValidationDescriptor<FieldValue, EditorValue, ParentEditorModel = undefined> {
+    private readonly _name;
+    private readonly _validator?;
+    private readonly _message?;
+    private readonly _options?;
+    constructor(name: string, validator?: FieldBaseValidator<FieldValue, EditorValue, ParentEditorModel> | FieldAsyncBaseValidator<FieldValue, EditorValue, ParentEditorModel>, message?: FieldValidationMessage<FieldValue, EditorValue, ParentEditorModel>, options?: FieldValidationDescriptorOptsType);
+    get name(): string;
+    get validator(): FieldBaseValidator<FieldValue, EditorValue, ParentEditorModel> | FieldAsyncBaseValidator<FieldValue, EditorValue, ParentEditorModel> | undefined;
+    get message(): FieldValidationMessage<FieldValue, EditorValue, ParentEditorModel> | undefined;
+    get options(): FieldValidationDescriptorOptsType<string> | undefined;
+    copy(): FieldValidationDescriptor<FieldValue, EditorValue, ParentEditorModel>;
+}
+
+declare const fieldDescriptorEmptyLabelType = "_emptyLabel";
+declare abstract class AGenericFieldDescriptor {
+    protected _config: FieldConfig;
+    protected _formlyConfig: FormlyFieldConfig;
+    protected constructor();
+    get config(): object;
+    get formlyConfig(): FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
+        [additionalProperties: string]: any;
+    }>;
+    withConfig(config: FieldConfig): this;
+    withFormlyConfig(formlyConfig: FormlyFieldConfig): this;
+    /**
+     * Override toJSON implementation to prevent overflow with circular dependency.
+     * @ignore
+     */
+    protected toJSON(): string;
+}
+type FieldValidationOptsType = {
+    forceShowMessage?: boolean;
+};
+type FieldClassNameType = {
+    field?: string;
+    grid?: string;
+    wrapper?: string;
+    label?: string;
+    control?: string;
+    input?: string;
+};
+declare abstract class AFieldDescriptor<FieldModel, EditorModel, FieldValue = FieldModel, ParentEditorModel = undefined> extends AGenericFieldDescriptor {
+    /** @ignore */ protected readonly _property: string;
+    /** @ignore */ protected _label?: string | null;
+    /** @ignore */ protected _labelUseModelBase?: boolean;
+    /** @ignore */ protected _labelInfoTooltip?: string;
+    /** @ignore */ protected _labelInfoTooltipIcon?: string;
+    /** @ignore */ protected _placeholder?: string;
+    /** @ignore */ protected _helpText?: string;
+    /** @ignore */ protected _required: boolean;
+    /** @ignore */ protected _requiredHideLabelMarker: boolean;
+    /** @ignore */ protected _disabled: boolean;
+    /** @ignore */ protected _defaultValue?: FieldValue;
+    /** @ignore */ protected _getter?: GetterFn<FieldValue, EditorModel>;
+    /** @ignore */ protected _setter?: (item: EditorModel, value: FieldValue) => void;
+    /** @ignore */ protected _validations: Array<FieldValidationDescriptor<any, any, any>>;
+    /** @ignore */ protected _asyncValidations: Array<FieldValidationDescriptor<any, any, any>>;
+    /** @ignore */ protected _validationOpts: FieldValidationOptsType;
+    /** @ignore */ protected _requiredExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
+    /** @ignore */ protected _disabledExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
+    /** @ignore */ protected _hiddenExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>;
+    /** @ignore */ protected _hiddenResetOnHide?: boolean;
+    /** @ignore */ protected _updateOn: 'change' | 'blur' | 'submit';
+    /** @ignore */ protected _onInit?: CommonsFormlyHookFn<FieldValue, EditorModel>;
+    /** @ignore */ protected _onChanges?: CommonsFormlyHookFn<FieldValue, EditorModel>;
+    /** @ignore */ protected _afterContentInit?: CommonsFormlyHookFn<FieldValue, EditorModel>;
+    /** @ignore */ protected _afterViewInit?: CommonsFormlyHookFn<FieldValue, EditorModel>;
+    /** @ignore */ protected _onDestroy?: CommonsFormlyHookFn<FieldValue, EditorModel>;
+    /** @ignore */ protected _onValueChange?: (field: CommonsFormlyFieldConfig<FieldValue, EditorModel>, value: any) => void;
+    /** @ignore */ protected _className?: FieldClassNameType;
+    /** @ignore */ protected _size: FieldSizeEnum;
+    /** @ignore */ protected _isLocalized: boolean;
+    /** @ignore */ protected readonly _eventsSubject: Subject<FormFieldEvent<FieldValue, EditorModel, ParentEditorModel>>;
+    protected constructor(property: string);
+    get property(): string;
+    get label(): string | null | undefined;
+    get labelUseModelBase(): boolean | undefined;
+    get placeholder(): string | undefined;
+    get helpText(): string | undefined;
+    get labelInfoTooltip(): string | undefined;
+    get labelInfoTooltipIcon(): string | undefined;
+    get required(): boolean;
+    get requiredHideLabelMarker(): boolean;
+    get disabled(): boolean;
+    get defaultValue(): FieldValue | undefined;
+    get getter(): GetterFn<FieldValue, EditorModel> | undefined;
+    get setter(): ((item: EditorModel, value: FieldValue) => void) | undefined;
+    get validations(): FieldValidationDescriptor<any, any, any>[];
+    get asyncValidations(): FieldValidationDescriptor<any, any, any>[];
+    get validationOpts(): FieldValidationOptsType;
+    get requiredExpression(): string | Observable<boolean> | ((field?: FormlyFieldConfig) => boolean) | undefined;
+    get disabledExpression(): string | Observable<boolean> | ((field?: FormlyFieldConfig) => boolean) | undefined;
+    get hiddenExpression(): string | Observable<boolean> | ((field?: FormlyFieldConfig) => boolean) | undefined;
+    get hiddenResetOnHide(): boolean | undefined;
+    get updateOn(): "change" | "blur" | "submit";
+    get onInit(): CommonsFormlyHookFn<FieldValue, EditorModel> | undefined;
+    get onChanges(): CommonsFormlyHookFn<FieldValue, EditorModel> | undefined;
+    get afterContentInit(): CommonsFormlyHookFn<FieldValue, EditorModel> | undefined;
+    get afterViewInit(): CommonsFormlyHookFn<FieldValue, EditorModel> | undefined;
+    get onDestroy(): CommonsFormlyHookFn<FieldValue, EditorModel> | undefined;
+    get onValueChange(): ((field: CommonsFormlyFieldConfig<FieldValue, EditorModel>, value: any) => void) | undefined;
+    get className(): FieldClassNameType | undefined;
+    get size(): FieldSizeEnum;
+    get isSizeSmall(): boolean;
+    get isSizeLarge(): boolean;
+    get isLocalized(): boolean;
+    abstract copy(): AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>;
+    /**
+     * Set label for field.
+     * @param label Full label (i18n path or other string). If null, no label will be used.
+     * @param useModelBase If set to true, label will be appended to model's i18n base path.
+     */
+    withLabel(label: string | null, useModelBase?: boolean): this;
+    withEmptyLabel(): this;
+    withPlaceholder(placeholder: string): this;
+    withHelpText(helpText: string): this;
+    /**
+     * Sets the label tooltip and optionally a custom icon for the field.
+     *
+     * @param {string} tooltip - The tooltip text to be displayed.
+     * @param {string} [customIcon] - An optional custom icon to be used for the tooltip. If not provided, the default icon is used.
+     */
+    withLabelInfoTooltip(tooltip: string, customIcon?: string): this;
+    withRequired(required?: boolean, requiredExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>, hideLabelMarker?: boolean): this;
+    withDisabled(disabled?: boolean, disabledExpression?: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>): this;
+    withHidden(hiddenExpression: string | ((field?: FormlyFieldConfig) => boolean) | Observable<boolean>, resetOnHide?: boolean): this;
+    withUpdateOn(updateOn: 'change' | 'blur' | 'submit'): this;
+    withOnInit(onInit?: CommonsFormlyHookFn<FieldValue, EditorModel>): this;
+    withOnChanges(onChanges?: CommonsFormlyHookFn<FieldValue, EditorModel>): this;
+    withAfterContentInit(afterContentInit?: CommonsFormlyHookFn<FieldValue, EditorModel>): this;
+    withAfterViewInit(afterViewInit?: CommonsFormlyHookFn<FieldValue, EditorModel>): this;
+    withOnDestroy(onDestroy?: CommonsFormlyHookFn<FieldValue, EditorModel>): this;
+    withOnValueChange(onValueChange?: (field: CommonsFormlyFieldConfig<FieldValue, EditorModel>, value: FieldValue) => void): this;
+    withDefaultValue(defaultValue: FieldValue): this;
+    withGetter(fn?: GetterFn<FieldValue, EditorModel>): this;
+    withSetter(fn?: (item: EditorModel, value: FieldValue) => void): this;
+    withValidation<Value = FieldValue, EditorValue = EditorModel>(name: string, validator?: FieldValidator<Value, EditorValue, ParentEditorModel>, message?: FieldValidationMessage<Value, EditorValue, ParentEditorModel>): this;
+    removeValidation(name: string): this;
+    withAsyncValidation<Value = FieldValue, EditorValue = EditorModel>(name: string, asyncValidator?: FieldAsyncValidator<Value, EditorValue>, message?: FieldValidationMessage<Value, EditorValue>): this;
+    removeAsyncValidation(name: string): this;
+    withValidationOpts(validationOpts: FieldValidationOptsType): this;
+    withClassName(opts?: string | FieldClassNameType): this;
+    withSize(size?: FieldSizeEnum): this;
+    /**
+     * This function adds an icon with text Show all translations above the field and after clicking on it, it displays a new dialog with tableview.
+     * This new table view shows all available translations for specific property and allows editing it.
+     */
+    localized(): this;
+    nextEvent(type: FormFieldEventTypeEnum, component: FieldType<CommonsFormlyFieldConfig<FieldValue, EditorModel, any>>, data?: FormFieldEventData<FieldValue, EditorModel>): void;
+    get events$(): Observable<FormFieldEvent<FieldValue, EditorModel, ParentEditorModel>>;
+    protected copyFieldsTo(obj: AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>): void;
+}
+
+declare abstract class AFieldGroupDescriptor<EditorModel, ParentEditorModel = undefined> extends AGenericFieldDescriptor {
+    protected readonly _name: string;
+    protected readonly _default: boolean;
+    protected _title?: string | null;
+    protected _fields: AGenericFieldDescriptor[];
+    protected _validations: Array<FieldValidationDescriptor<any, any, any>>;
+    protected _validationOpts: FieldValidationOptsType;
+    protected _hiddenExpression?: string | ((field?: CommonsFormlyFieldConfig<EditorModel, EditorModel>) => boolean) | Observable<boolean>;
+    protected constructor(name: string);
+    removeField(property: string, filterFunction: (fields: AGenericFieldDescriptor[]) => AGenericFieldDescriptor[]): AGenericFieldDescriptor[];
+    get title(): string | null | undefined;
+    abstract get type(): FieldGroupTypeEnum;
+    abstract get fields(): AGenericFieldDescriptor[];
+    get validations(): FieldValidationDescriptor<any, any, any>[];
+    get validationOpts(): FieldValidationOptsType;
+    get name(): string;
+    get default(): boolean;
+    get hiddenExpression(): string | Observable<boolean> | ((field?: CommonsFormlyFieldConfig<EditorModel, EditorModel>) => boolean) | undefined;
+    abstract addField(field: AGenericFieldDescriptor): this;
+    abstract copy(): AFieldGroupDescriptor<EditorModel, ParentEditorModel>;
+    withTitle(title?: string | null): this;
+    withValidation<Value = EditorModel, ParentValue = ParentEditorModel>(name: string, validator?: FormValidator<Value, ParentValue>, message?: FormValidationMessage<Value, ParentValue>, opts?: FieldValidationDescriptorOptsType): this;
+    withValidationOpts(validationOpts: FieldValidationOptsType): this;
+    withHidden(hiddenExpression: string | ((field?: CommonsFormlyFieldConfig<EditorModel, EditorModel>) => boolean) | Observable<boolean>): this;
+}
+declare class FieldTabGroupDescriptor<EditorModel> extends AFieldGroupDescriptor<EditorModel> {
+    protected _fields: FieldGroupDescriptor<EditorModel>[];
+    constructor(name: string);
+    get type(): FieldGroupTypeEnum;
+    get fields(): Array<FieldGroupDescriptor<EditorModel>>;
+    addField(field: FieldGroupDescriptor<EditorModel>): this;
+    copy(skipFields?: boolean): FieldTabGroupDescriptor<EditorModel>;
+}
+type FieldGroupClassNameType = {
+    grid?: string;
+};
+declare class FieldGroupDescriptor<EditorModel, ParentEditorModel = undefined> extends AFieldGroupDescriptor<EditorModel, ParentEditorModel> {
+    private _type;
+    protected _className?: FieldGroupClassNameType;
+    constructor(name: string);
+    get type(): FieldGroupTypeEnum;
+    get fields(): Array<AFieldDescriptor<any, EditorModel>>;
+    /**
+     * Styling class name configurations for group.
+     */
+    get className(): FieldGroupClassNameType | undefined;
+    addField(field: AFieldDescriptor<any, EditorModel>): this;
+    asLogical(): this;
+    withClassName(opts?: string | FieldGroupClassNameType): this;
+    copy(skipFields?: boolean): FieldGroupDescriptor<EditorModel>;
+}
+
+type CommonsFormlyFormOptions<Item> = FormlyFormOptions & {
+    formState?: CommonsFormlyFormState<Item>;
+};
+type CommonsFormlyFormState<Item> = {
+    descriptor?: EditorDescriptorInst<Item>;
+    add?: boolean;
+    edit?: boolean;
+    disabled?: boolean;
+    disabled$?: Observable<boolean>;
+    submittedOn?: number;
+    [key: string]: any;
+};
+
+type CommonsFormlyFieldProps<Value = any, FormValue = any, ParentFormValue = any> = FormlyFieldProps & CommonsFormlyFieldAdditionalProps<Value, FormValue, ParentFormValue>;
+type CommonsFormlyValidation = FormlyFieldConfig['validators'];
+interface CommonsFormlyFieldConfig<Value = any, FormValue = any, ParentFormValue = any, Props = CommonsFormlyFieldProps<Value, FormValue, ParentFormValue>> extends FormlyFieldConfig<Props> {
+    props: Props;
+    readonly model?: Value;
+    /**
+     * The form options.
+     */
+    readonly options?: CommonsFormlyFormOptions<Value>;
+    /**
+     * The parent form.
+     */
+    readonly form?: FormGroup<{
+        [K in keyof FormValue]: AbstractControl<FormValue[K]>;
+    }>;
+    /**
+     * This is the [FormControl](https://angular.io/api/forms/FormControl) for the field.
+     * It provides you more control like running validators, calculating status, and resetting state.
+     */
+    readonly formControl?: FormControl<Value>;
+}
+type CommonsFormlyHookFn<T, ET> = (field: CommonsFormlyFieldConfig<T, ET>) => void;
+interface CommonsFormlyFieldAdditionalProps<Value, FormValue, ParentFormValue = any> {
+    descriptor?: AFieldDescriptor<Value, FormValue> | AFieldGroupDescriptor<FormValue> | AGenericFieldDescriptor;
+    editorDescriptor?: EditorDescriptorInst<FormValue, ParentFormValue>;
+    formEditorComponent?: IFormEditorComponent<FormValue, ParentFormValue>;
+    fieldComponent?: FieldType<CommonsFormlyFieldConfig<Value, FormValue>>;
+    required?: boolean;
+    hide?: boolean;
+    disabled?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    onValueChange?: (field: CommonsFormlyFieldConfig<Value, FormValue>, value: Value) => void;
+    [additionalProperties: string]: any;
+}
+
+interface FieldActionContext<EditorModel, ParentEditorModel = undefined> {
+    descriptor: FieldActionDescriptor<EditorModel>;
+    formEditorComponent: IFormEditorComponent<EditorModel, ParentEditorModel>;
+    formly: {
+        model: EditorModel;
+        formControl: FormControl<void>;
+        form: FormGroup<{
+            [K in keyof EditorModel]: AbstractControl<EditorModel[K]>;
+        }>;
+        options: CommonsFormlyFormOptions<EditorModel>;
+        props: CommonsFormlyFieldProps<void, EditorModel, ParentEditorModel>;
+        formState: CommonsFormlyFormState<EditorModel>;
+    };
+}
+interface FieldActionResult {
+    message?: FieldActionResultMessage;
+}
+interface FieldActionResultMessage {
+    content: string;
+    severity?: 'success' | 'warn' | 'error' | 'info' | 'secondary' | 'contrast';
+}
+
+type FieldActionRunFnType<EditorModel, ParentEditorModel = undefined> = (ctx: FieldActionContext<EditorModel, ParentEditorModel>) => void | FieldActionResult | Observable<FieldActionResult>;
+declare class FieldActionDescriptor<EditorModel, ParentEditorModel = undefined> extends AFieldDescriptor<void, EditorModel, void, ParentEditorModel> {
+    protected readonly _fieldActionName: string;
+    protected _button?: IActionButtonDescriptor;
+    protected _runFunction?: FieldActionRunFnType<EditorModel>;
+    private _wrappers;
+    constructor(property: string);
+    get button(): IActionButtonDescriptor | undefined;
+    get runFunction(): FieldActionRunFnType<EditorModel, undefined> | undefined;
+    get wrappers(): string[];
+    withButton(label?: string | null, icon?: string | null, level?: StyleLevelEnum): this;
+    withButtonOpts(button?: IActionButtonDescriptor): this;
+    withRunFunction(fn: FieldActionRunFnType<EditorModel>): this;
+    withWrappers(wrappers: string[]): this;
+    copy(): FieldActionDescriptor<EditorModel, ParentEditorModel>;
+}
+
+type FieldLookupDescriptorConstructorOptsType<EditorModel, Service, Sorts, Filters extends keyof any> = FieldLookupDescriptorCreateOptsProviderType<EditorModel, Service, Sorts, Filters> & {
+    optionsValueProperty?: string;
+};
+type FieldLookupDescriptorCreateOptsProviderType<FieldModel, Service, Sorts = keyof FieldModel, Filters extends keyof any = keyof FieldModel> = {
+    serviceType?: ServiceClassType<Service>;
+    dataProvider?: ILookupDataProvider<FieldModel, Service, Sorts, Filters>;
+};
+type FieldLookupProviderType<FieldModel, Service> = ServiceClassType<Service> | ILookupDataProvider<FieldModel, Service, any, any>;
+type FieldLookupAutocompleteOptsType = {
+    openOnFocus?: boolean;
+    inlineSearch?: boolean;
+    selectFirst?: boolean;
+    autoClear?: boolean;
+};
+declare const fieldLookupGetProviderCfgObj: <FieldModel, Service>(serviceOrDataProvider?: FieldLookupProviderType<FieldModel, Service>) => FieldLookupDescriptorCreateOptsProviderType<FieldModel, Service, keyof FieldModel, keyof FieldModel>;
+declare class FieldLookupDescriptor<FieldModel, EditorModel, Service = any, FieldValue = FieldModel, ParentEditorModel = undefined, Sorts = keyof FieldModel, Filters extends keyof any = keyof FieldModel> extends AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel> implements ILookupDescriptor<FieldModel, Service, Sorts, Filters> {
+    protected readonly _dataProvider: ILookupDataProvider<FieldModel, Service, Sorts, Filters>;
+    protected readonly _optionsValueProperty?: string;
+    protected _lookupType: FieldLookupTypeEnum;
+    protected _optionsLabelProperty?: string;
+    protected _optionsLabelTranslate: boolean;
+    protected _optionsDisabledProperty?: string;
+    protected _optionsTrackProperty?: string;
+    protected _dropdownClassName: string;
+    protected _autocompleteOpenOnFocus?: boolean;
+    protected _autocompleteInlineSearch?: boolean;
+    protected _autocompleteAutoClear?: boolean;
+    protected _autocompleteSelectFirst?: boolean;
+    protected _autocompleteInputTrim?: InputTrimType;
+    protected _dialogTableDescriptor?: TableDescriptorInst<FieldModel, any, any>;
+    protected _dialogTableDataProvider?: ITableDataProvider<FieldModel, any, any, any>;
+    protected _customComponentName?: string;
+    constructor(property: string, cfg?: FieldLookupDescriptorConstructorOptsType<FieldModel, Service, Sorts, Filters>);
+    get lookupType(): FieldLookupTypeEnum;
+    get optionsLabelProperty(): string | undefined;
+    get optionsLabelTranslate(): boolean;
+    get optionsValueProperty(): string | undefined;
+    get optionsDisabledProperty(): string | undefined;
+    get optionsTrackProperty(): string | undefined;
+    get dataProvider(): ILookupDataProvider<FieldModel, Service, Sorts, Filters>;
+    get autocompleteOpenOnFocus(): boolean | undefined;
+    get autocompleteInlineSearch(): boolean | undefined;
+    get autocompleteAutoClear(): boolean | undefined;
+    get autocompleteSelectFirst(): boolean | undefined;
+    get dropdownClassName(): string;
+    get dialogTableDescriptor(): TableDescriptorInst<FieldModel, any, any> | undefined;
+    get dialogTableDataProvider(): ITableDataProvider<FieldModel, any, any, any> | undefined;
+    get customComponentName(): string | undefined;
+    get trimOption(): InputTrimType | undefined;
+    withOptionsLabelProperty(property: keyof FieldModel, translate?: boolean): this;
+    withOptionsLabelPropertyUnsafe(property: string, translate?: boolean): this;
+    withOptionsDisabledProperty(property: keyof FieldModel): this;
+    withOptionsDisabledPropertyUnsafe(property: string): this;
+    withOptionsTrackProperty(property: keyof FieldModel): this;
+    withOptionsTrackPropertyUnsafe(property: string): this;
+    withLookup(lookup?: LookupDataProviderLookupFnType<FieldModel, Service, Sorts, Filters>): this;
+    withInputTrim(trimOption?: InputTrimType): this;
+    withConfig(config: FieldLookupConfig): this;
+    asAutocomplete(opts?: FieldLookupAutocompleteOptsType): this;
+    asDialog<Sorts = keyof FieldModel, Filters extends keyof any = keyof FieldModel>(lookupTableDescriptor: TableDescriptorInst<FieldModel, Sorts, Filters>, tableDataProvider?: ITableDataProvider<FieldModel, any, Sorts, Filters>): this;
+    asCustomComponent(customComponentName: string): this;
+    copy(): FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue, ParentEditorModel, Sorts, Filters>;
+}
+declare class FieldLookupEnumDescriptor<Enum, EditorModel, ParentEditorModel = undefined> extends FieldLookupDescriptor<EnumValue, EditorModel, undefined, EnumConstantType, ParentEditorModel, never, never> {
+    private readonly _enumModel;
+    private readonly _optionEnumValues;
+    private readonly _options;
+    constructor(property: string, enumModel: EnumDescriptor<Enum>, options?: Array<Enum>);
+    get enumModel(): EnumDescriptor<Enum>;
+    withDisabledOptions(...disabledOptions: Array<EnumConstantType>): this;
+    withDefaultValueEnum(defaultValue: EnumConstantType): this;
+    asAutocomplete(opts?: FieldLookupAutocompleteOptsType): this;
+    copy(): FieldLookupEnumDescriptor<Enum, EditorModel, ParentEditorModel>;
+}
+
+type FieldManyToManyEditorDescriptorConstructorOptsType<FieldModel, Service> = FieldManyToManyEditorDescriptorCreateOptsProviderType<FieldModel, Service>;
+type FieldManyToManyEditorDescriptorCreateOptsProviderType<FieldModel, Service> = {
+    lookupServiceType?: ServiceClassType<Service>;
+    lookupDataProvider?: ITableDataProvider<FieldModel, Service>;
+};
+type FieldManyToManyEditorProviderType<FieldModel, Service> = ServiceClassType<Service> | ITableDataProvider<FieldModel, Service>;
+declare const fieldManyToManyGetProviderCfgObj: <FieldModel, Service>(serviceOrDataProvider?: FieldManyToManyEditorProviderType<FieldModel, Service>) => FieldManyToManyEditorDescriptorCreateOptsProviderType<FieldModel, Service>;
+declare class FieldManyToManyEditorDescriptor<FieldModel, EditorModel, Service = any, FieldValue = FieldModel[], ParentEditorModel = undefined> extends AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel> {
+    private readonly _mainTableDescriptor;
+    private readonly _lookupTableDescriptor;
+    private readonly _lookupTableDataProvider;
+    private _fieldType;
+    private _actions;
+    private _hasLookupExcludeValues;
+    private _excludeFilterProperty;
+    private _excludeValueProperty;
+    constructor(property: string, mainTableDescriptor: TableDescriptorInst<FieldModel>, lookupTableDescriptor: TableDescriptorInst<FieldModel>, cfg?: FieldManyToManyEditorDescriptorConstructorOptsType<FieldModel, Service>);
+    get fieldType(): FieldManyToManyEditorTypeEnum;
+    get actions(): FieldManyToManyEditorActionEnum[];
+    get hasLookupExcludeValues(): boolean;
+    get excludeFilterProperty(): string;
+    get excludeValueProperty(): string;
+    get mainTableDescriptor(): TableDescriptorInst<FieldModel, keyof FieldModel, keyof FieldModel>;
+    get lookupTableDescriptor(): TableDescriptorInst<FieldModel, keyof FieldModel, keyof FieldModel>;
+    get lookupTableDataProvider(): ITableDataProvider<FieldModel, Service>;
+    withLookup(fn: TableDataProviderGetAllFnType<FieldModel, Service>): this;
+    withActions(actions?: Array<FieldManyToManyEditorActionEnum>): this;
+    withLookupExclude(filterProperty: keyof FieldModel, valueProperty: keyof FieldModel, hasLookupExclude?: boolean): this;
+    withLookupExcludeUnsafe(filterProperty: string, valueProperty: string, hasLookupExclude?: boolean): this;
+    copy(): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, Service, FieldValue, ParentEditorModel>;
+}
+declare class FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue = FieldModel[], ParentEditorModel = undefined> extends AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel> {
+    private readonly _tableviewDescriptor;
+    private _fieldType;
+    private _fieldActions;
+    private _actions;
+    constructor(property: string, tableviewDescriptor: TableviewDescriptorInst<FieldModel, any, any, EditorModel, FieldModel, FieldModel, FieldModel, FieldModel>);
+    get fieldType(): FieldManyEditorTypeEnum;
+    get fieldActions(): FieldManyEditorActionEnum[];
+    get actions(): ActionDescriptorInst<any, any, any, any, any>[];
+    get tableviewDescriptor(): TableviewDescriptorInst<FieldModel, any, any, EditorModel, FieldModel, FieldModel, FieldModel, FieldModel>;
+    get tableDescriptor(): TableDescriptorInst<FieldModel, any, any>;
+    get editorForCreate(): _mediusinc_mng_commons_tableview_api.EditorDescriptorInst<FieldModel, EditorModel>;
+    get editorForRead(): _mediusinc_mng_commons_tableview_api.EditorDescriptorInst<FieldModel, EditorModel>;
+    get editorForUpdate(): _mediusinc_mng_commons_tableview_api.EditorDescriptorInst<FieldModel, EditorModel>;
+    withFieldAction(action: FieldManyEditorActionEnum): this;
+    withFieldActions(actions: FieldManyEditorActionEnum[]): this;
+    withAction(action: ActionDescriptorInst<any>): this;
+    copy(): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>;
+}
+
+interface FieldImagePreviewComponent {
+    imageUrl: InputSignal<string>;
+}
+
+declare abstract class AFormlyCustomFieldComponent<Value, FormValue, ParentFormValue = undefined> extends FieldType<CommonsFormlyFieldConfig<Value, FormValue, ParentFormValue>> {
+    field: CommonsFormlyFieldConfig<Value, FormValue, ParentFormValue>;
+    _model: Value;
+    _form: FormGroup<{
+        [K in keyof FormValue]: AbstractControl<FormValue[K]>;
+    }>;
+    _options: CommonsFormlyFormOptions<FormValue>;
+    _key: string | number | (string | number)[];
+    _formControl: FormControl<Value>;
+    _props: CommonsFormlyFieldProps<Value, FormValue, ParentFormValue>;
+    _showError: boolean;
+    _id: string;
+    _formState: CommonsFormlyFormState<FormValue>;
+    get model(): Value;
+    get form(): FormGroup<{ [K in keyof FormValue]: AbstractControl<FormValue[K], FormValue[K], any>; }>;
+    get options(): CommonsFormlyFormOptions<FormValue>;
+    get key(): string | number | (string | number)[];
+    get formControl(): FormControl<Value>;
+    get props(): CommonsFormlyFieldProps<Value, FormValue, ParentFormValue>;
+    get showError(): boolean;
+    get id(): string;
+    get formState(): CommonsFormlyFormState<FormValue>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AFormlyCustomFieldComponent<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AFormlyCustomFieldComponent<any, any, any>, never, never, { "field": { "alias": "field"; "required": false; }; "_model": { "alias": "model"; "required": false; }; "_form": { "alias": "form"; "required": false; }; "_options": { "alias": "options"; "required": false; }; "_key": { "alias": "key"; "required": false; }; "_formControl": { "alias": "formControl"; "required": false; }; "_props": { "alias": "props"; "required": false; }; "_showError": { "alias": "showError"; "required": false; }; "_id": { "alias": "id"; "required": false; }; "_formState": { "alias": "formState"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface RadioValue<V = string | number | boolean> {
+    name?: string;
+    value: V;
+    title: string;
+    disabled?: boolean;
+}
+
+type FieldInputDescriptorType = string | string[] | number | boolean | Date | File | File[];
+type FieldInputOptsType = {
+    emptyValue?: EmptyValueType;
+};
+type FieldInpuTextBaseOptsType = {
+    trim?: InputTrimType;
+};
+type FieldInputTextOptsType = {
+    email?: boolean;
+} & FieldInputTextValidationOptsType & FieldInpuTextBaseOptsType & FieldInputOptsType;
+type FieldInputTextareaOptsType = {
+    rows?: number;
+} & FieldInputTextValidationOptsType & FieldInpuTextBaseOptsType & FieldInputOptsType;
+type FieldInputMaskOptsType = {
+    mask: string;
+    slotChar?: string;
+} & FieldInputOptsType;
+type FieldInputTextValidationOptsType = {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string | RegExp;
+};
+type FieldInputDatePickerDisplayOptsType = {
+    format?: string;
+    showTime?: boolean;
+    showSeconds?: boolean;
+};
+type FieldInputDateValidationOptsType<FieldValue, EditorModel, ParentEditorModel> = {
+    min?: Date | FieldInputDatePickerDynamicMinMaxFnType<FieldValue, EditorModel, ParentEditorModel>;
+    max?: Date | FieldInputDatePickerDynamicMinMaxFnType<FieldValue, EditorModel, ParentEditorModel>;
+};
+type FieldInputCurrencyOptsType<Property = string> = {
+    currencyProperty?: Property;
+    currency?: string;
+    currencyDisplay?: 'symbol' | 'code' | 'name';
+} & FieldInputNumberGroupingOptsType & FieldInputNumberFractionOptsType & FieldInputNumberValidationOptsType & FieldInputLocaleOptsType & FieldInputOptsType;
+type FieldInputNumberOptsType = FieldInputNumberGroupingOptsType & FieldInputNumberFractionOptsType & FieldInputNumberValidationOptsType & FieldInputLocaleOptsType & FieldInputNumberDisplayOptsType & FieldInputOptsType;
+type FieldInputNumberGroupingOptsType = {
+    groupSeparator?: boolean;
+};
+type FieldInputNumberValidationOptsType = {
+    min?: number;
+    max?: number;
+    step?: number;
+    autoCorrect?: boolean;
+};
+type FieldInputNumberFractionOptsType = {
+    minFractionDigits?: number;
+    maxFractionDigits?: number;
+};
+type FieldInputLocaleOptsType = {
+    locale?: string;
+};
+type FieldInputNumberDisplayOptsType = {
+    prefix?: string;
+    suffix?: string;
+};
+type FieldInputDatePickerOptsType<FieldValue, EditorModel, ParentEditorModel> = FieldInputDatePickerDisplayOptsType & FieldInputDateValidationOptsType<FieldValue, EditorModel, ParentEditorModel> & FieldDateOptsType;
+type FieldDateOptsType = {
+    asDateObj?: boolean;
+    utc?: boolean;
+    noTime?: boolean;
+    noTimeZone?: boolean;
+};
+type FieldInputFileOpts = {
+    multiple?: boolean;
+    maxFileSize?: number;
+    accept?: string;
+    onFileSelectHandlerFn?: FieldInputFileOnSelectHandlerFnType;
+    preview?: boolean;
+    previewAllowSvg?: boolean;
+    previewComponent?: Type<FieldImagePreviewComponent>;
+};
+type FieldInputImageUrlOpts = {
+    multiple?: boolean;
+    preview?: boolean;
+    inputVisibleOnDisabled?: boolean;
+    previewAllowSvg?: boolean;
+    previewComponent?: Type<FieldImagePreviewComponent>;
+};
+type FieldInputComponentOpts = {
+    fieldWrappers?: string[];
+    inputs?: Record<string, any>;
+};
+type FieldInputFileOnSelectHandlerFnType = (file: File[] | null, control: AbstractControl) => void;
+type FieldInputDatePickerDynamicMinMaxFnType<Value, FormValue, ParentFormValue> = (control: AbstractControl<Value>, field: CommonsFormlyFieldConfig<Value, FormValue, ParentFormValue>) => ItemOrObservable<Date | undefined>;
+declare class FieldInputDescriptor<EditorModel, FieldModel = FieldInputDescriptorType, FieldValue = FieldModel, ParentEditorModel = undefined> extends AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel> {
+    private _fieldType;
+    private _rows?;
+    private _numberMin?;
+    private _numberMax?;
+    private _numberStep?;
+    private _numberAutoCorrect?;
+    private _numberMinFractionDigits?;
+    private _numberMaxFractionDigits?;
+    private _numberUseGrouping;
+    private _locale?;
+    private _numberPrefix?;
+    private _numberSuffix?;
+    private _currency?;
+    private _currencyDisplay;
+    private _currencyFromProperty?;
+    private _radioOptions;
+    private _radioLabelClassName?;
+    private _datePickerFormat?;
+    private _datePickerMin?;
+    private _datePickerMax?;
+    private _datePickerShowTime?;
+    private _datePickerShowSeconds?;
+    private _datePickerValueUtc?;
+    private _datePickerValueNoTimezone?;
+    private _datePickerValueNoTime?;
+    private _datePickerValueAsDateObj?;
+    private _maxLength?;
+    private _minLength?;
+    private _pattern?;
+    private _validationEmail?;
+    private _textTrim?;
+    private _mask?;
+    private _slotChar?;
+    private _fileMultiple?;
+    private _fileMaxFileSize?;
+    private _fileAccept?;
+    private _fileOnSelectHandler?;
+    private _imagePreview?;
+    private _imageUrlInputHiddenOnDisabled?;
+    private _imagePreviewAllowSvg?;
+    private _imagePreviewComponent?;
+    private _customComponentType?;
+    private _customComponentInputs?;
+    private _customComponentWrappers?;
+    private _emptyValue?;
+    constructor(property: string);
+    /**
+     * converts field to given type with additional arguments
+     * @param fieldType field type enum
+     * @param args any additional arguments for field (optional)
+     */
+    asType(fieldType: FieldInputTypeEnum, ...args: any[]): this;
+    get fieldType(): FieldInputTypeEnum;
+    get rows(): number | undefined;
+    get numberMin(): number | undefined;
+    get numberMax(): number | undefined;
+    get numberStep(): number | undefined;
+    get numberAutoCorrect(): boolean | undefined;
+    get numberMinFractionDigits(): number | undefined;
+    get numberMaxFractionDigits(): number | undefined;
+    get numberUseGrouping(): boolean;
+    get numberPrefix(): string | undefined;
+    get numberSuffix(): string | undefined;
+    get radioOptions(): RadioValue<string | number | boolean>[];
+    get radioLabelClassName(): string | undefined;
+    get datePickerFormat(): string | undefined;
+    get datePickerMin(): Date | FieldInputDatePickerDynamicMinMaxFnType<FieldValue, EditorModel, ParentEditorModel> | undefined;
+    get datePickerMax(): Date | FieldInputDatePickerDynamicMinMaxFnType<FieldValue, EditorModel, ParentEditorModel> | undefined;
+    get datePickerShowTime(): boolean | undefined;
+    get datePickerShowSeconds(): boolean | undefined;
+    get datePickerValueUtc(): boolean | undefined;
+    get datePickerValueNoTimezone(): boolean | undefined;
+    get datePickerValueNoTime(): boolean | undefined;
+    get datePickerValueAsDateObj(): boolean | undefined;
+    get maxLength(): number | undefined;
+    get minLength(): number | undefined;
+    get pattern(): string | RegExp | undefined;
+    get textTrim(): InputTrimType | undefined;
+    get emptyValue(): EmptyValueType | undefined;
+    get validationEmail(): boolean | undefined;
+    get mask(): string | undefined;
+    get slotChar(): string | undefined;
+    get fileMultiple(): boolean | undefined;
+    get fileMaxFileSize(): number | undefined;
+    get fileAccept(): string | undefined;
+    get fileOnSelectHandler(): FieldInputFileOnSelectHandlerFnType | undefined;
+    get imagePreview(): boolean | undefined;
+    get imageUrlInputVisibleOnDisabled(): boolean | undefined;
+    get imagePreviewAllowSvg(): boolean | undefined;
+    get imagePreviewComponent(): Type<FieldImagePreviewComponent> | undefined;
+    get customComponentType(): Type<AFormlyCustomFieldComponent<FieldValue, EditorModel, ParentEditorModel>> | undefined;
+    get customComponentInputs(): Record<string, any> | undefined;
+    get customComponentWrappers(): string[] | undefined;
+    get locale(): string | undefined;
+    get currency(): string | undefined;
+    get currencyFromProperty(): string | undefined;
+    get currencyDisplay(): "symbol" | "code" | "name";
+    asHidden(): this;
+    asLabel(): this;
+    asText(opts?: FieldInputTextOptsType): this;
+    asTextarea(opts?: FieldInputTextareaOptsType): this;
+    asNumber(opts?: FieldInputNumberOptsType): this;
+    asCurrency(opts?: FieldInputCurrencyOptsType<keyof EditorModel>): this;
+    asCurrencyUnsafe(opts?: FieldInputCurrencyOptsType): this;
+    asSwitch(): this;
+    asRadio(options: Array<string | number | boolean>, optionsTitlePath?: string): this;
+    asRadioFromEnum<Enum>(enumModel: EnumDescriptor<Enum>, values?: Array<Enum>): this;
+    asDatePicker(opts?: FieldInputDatePickerOptsType<FieldValue, EditorModel, ParentEditorModel>): this;
+    asMask(opts?: FieldInputMaskOptsType): this;
+    asFile(opts?: FieldInputFileOpts): this;
+    asImageFile(opts?: FieldInputFileOpts): this;
+    asImageUrl(opts?: FieldInputImageUrlOpts): this;
+    asCustomComponent(component: Type<AFormlyCustomFieldComponent<FieldValue, EditorModel, ParentEditorModel>>, opts?: FieldInputComponentOpts): this;
+    withNumberValidation(opts?: FieldInputNumberValidationOptsType): this;
+    withLocale(locale?: string): this;
+    withNumberFractions(opts?: FieldInputNumberFractionOptsType): this;
+    withNumberGrouping(useGrouping?: boolean): this;
+    withNumberDisplay(opts?: FieldInputNumberDisplayOptsType): this;
+    withTextareaRows(rows?: number): this;
+    withTextValidation(opts?: FieldInputTextValidationOptsType): this;
+    /**
+     * Common options for text input element (i.e. value value trimming).
+     * @param opts
+     */
+    withTextCommonOpts(opts?: FieldInpuTextBaseOptsType): this;
+    /**
+     * Common options for input element (i.e. value on empty input).
+     * @param opts
+     */
+    withInputCommonOpts(opts?: FieldInputOptsType): this;
+    withDatePickerDisplay(opts?: FieldInputDatePickerDisplayOptsType): this;
+    withDateValidation(opts?: FieldInputDateValidationOptsType<FieldValue, EditorModel, ParentEditorModel>): this;
+    withRadioOptions(opts: {
+        labelClassName?: string;
+    }): this;
+    withDateValue(opts?: FieldDateOptsType): this;
+    withTextValidationEmail(email?: boolean): this;
+    withFileOnSelectHandler(fn?: FieldInputFileOnSelectHandlerFnType): this;
+    copy(): FieldInputDescriptor<EditorModel, FieldModel, FieldValue, ParentEditorModel>;
+}
+
+type FieldsManageAddFieldLookupOpts<FieldModel, Service> = {
+    type?: TypeDescriptor<FieldModel>;
+    serviceProvider?: FieldLookupProviderType<FieldModel, Service>;
+};
+interface IFieldsManageSafe<EditorModel, ParentEditorModel, GroupModel = EditorModel> {
+    removeField(property: keyof GroupModel): void;
+    addField<Property extends keyof GroupModel, FieldModel = NonNullable<GroupModel[Property]>, FieldValue = GroupModel[Property]>(property: Property): FieldInputDescriptor<EditorModel, FieldModel, FieldValue, ParentEditorModel>;
+    withFields(...properties: (keyof GroupModel)[]): this;
+    addFieldLookup<Property extends keyof GroupModel, Service = undefined, FieldModel extends NonNullable<GroupModel[Property]> = NonNullable<GroupModel[Property]>, FieldValue = GroupModel[Property]>(property: Property, opts?: FieldsManageAddFieldLookupOpts<FieldModel, Service>): FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue, ParentEditorModel>;
+    addFieldLookupEnum<Property extends keyof GroupModel, Enum extends NonNullable<GroupModel[Property]>>(property: Property, enumModel: EnumDescriptor<Enum>, options?: Array<Enum>): FieldLookupEnumDescriptor<Enum, EditorModel, ParentEditorModel>;
+    addFieldManyEditor<Property extends keyof GroupModel, FieldModel = ArrayItemType<GroupModel[Property]>, FieldValue = GroupModel[Property]>(property: Property, tableviewDescriptor: ITableviewDescriptor<FieldModel, any, any, EditorModel, FieldModel, FieldModel, FieldModel>): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>;
+    addFieldManyToManyEditor<Property extends keyof GroupModel, Service, FieldModel = ArrayItemType<GroupModel[Property]>, FieldValue = GroupModel[Property]>(property: Property, mainTableDescriptor: ITableDescriptor<FieldModel, any, any>, lookupTableDescriptor: ITableDescriptor<FieldModel, any, any>, lookupDataProvider: ITableDataProvider<FieldModel, Service>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, Service, FieldValue, ParentEditorModel>;
+    addFieldDescriptor<FieldModel, FieldValue = FieldModel>(field: AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>): this;
+}
+interface IFieldManageSafeWithGetField<EditorModel, ParentEditorModel, GroupModel = EditorModel> extends IFieldsManageSafe<EditorModel, ParentEditorModel, GroupModel> {
+    getField<Property extends keyof GroupModel, FieldModel = NonNullable<GroupModel[Property]>, FieldValue = GroupModel[Property]>(property: Property): AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel> | null;
+}
+interface IFieldsManage<EditorModel, ParentEditorModel> extends IFieldsManageSafe<EditorModel, ParentEditorModel> {
+    removeFieldUnsafe(property: string): void;
+    addFieldUnsafe<FieldModel = FieldInputDescriptorType, FieldValue = FieldModel>(property: string): FieldInputDescriptor<EditorModel, FieldModel, FieldValue, ParentEditorModel>;
+    addFieldAction(actionName: string): FieldActionDescriptor<EditorModel, ParentEditorModel>;
+    addFieldLookupUnsafe<FieldModel, Service = undefined, FieldValue = FieldModel>(property: string, opts?: FieldsManageAddFieldLookupOpts<FieldModel, Service>): FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue, ParentEditorModel>;
+    addFieldLookupEnumUnsafe<Enum = EnumConstantType>(property: string, enumModel: EnumDescriptor<Enum>, options?: Array<Enum>): FieldLookupEnumDescriptor<Enum, EditorModel, ParentEditorModel>;
+    addFieldManyEditorUnsafe<FieldModel, FieldValue = FieldModel[]>(property: string, tableviewDescriptor: ITableviewDescriptor<FieldModel, any, any, EditorModel, FieldModel, FieldModel, FieldModel>): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>;
+    addFieldManyToManyEditorUnsafe<FieldModel, Service, FieldValue = FieldModel[]>(property: string, mainTableDescriptor: ITableDescriptor<FieldModel, any, any>, lookupTableDescriptor: ITableDescriptor<FieldModel, any, any>, lookupDataProvider: ITableDataProvider<FieldModel, Service>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, Service, FieldValue, ParentEditorModel>;
+    withValidation<Value = EditorModel>(name: string, validator?: FormValidator<Value, ParentEditorModel>, message?: FormValidationMessage<Value, ParentEditorModel>, opts?: FieldValidationDescriptorOptsType<keyof EditorModel>): this;
+    withValidationUnsafe<Value = EditorModel>(name: string, validator?: FormValidator<Value, ParentEditorModel>, message?: FormValidationMessage<Value, ParentEditorModel>, opts?: FieldValidationDescriptorOptsType): this;
+}
+interface IFieldsManageWithGetField<EditorModel, ParentEditorModel> extends IFieldsManage<EditorModel, ParentEditorModel> {
+    getField<Property extends keyof EditorModel, FieldModel = NonNullable<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property): AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel> | null;
+    getFieldUnsafe<FieldModel, FieldValue = FieldModel>(property: string): AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel> | null;
+}
+
+declare enum TableviewEditorTypeEnum {
+    None = 0,
+    Details = 1,
+    Edit = 2,
+    Add = 3
+}
+declare const EDITOR_DEFAULT_GROUP_NAME = "_default";
+
+/**
+ * Helper type for cases when you need to custom define FieldsManageModel on TableviewDescriptorInst from only one model (single model).
+ */
+type TableviewDescriptorFieldsManageSingleType<TableviewModel> = CommonPropsObjType3<TableviewModel, TableviewModel, TableviewModel>;
+/**
+ * Helper type for cases when you need to custom define FieldsManageModel on TableviewDescriptorInst from only 3 models (multi model).
+ */
+type TableviewDescriptorFieldsManageMultiType<TableviewModel, AddModel, EditModel> = CommonPropsObjType3<TableviewModel, AddModel, EditModel>;
+
+type TableviewDescriptorInstConstructorOpts<TableModel, AddModel, EditModel> = {
+    tableModel?: ModelDescriptor<TableModel>;
+    addModel?: ModelDescriptor<AddModel>;
+    editModel?: ModelDescriptor<EditModel>;
+};
+declare class TableviewDescriptorInst<TableviewModel, Sorts = keyof TableviewModel, Filters = keyof TableviewModel, ParentEditorModel = undefined, TableModel = TableviewModel, AddModel = TableviewModel, EditModel = TableviewModel, FieldsManageModel = TableviewDescriptorFieldsManageMultiType<TableviewModel, AddModel, EditModel>> implements ITableviewDescriptor<TableviewModel, Sorts, Filters, ParentEditorModel, TableModel, AddModel, EditModel>, IColumnsManageInterface<TableModel, Sorts, Filters>, IFieldsManage<FieldsManageModel, ParentEditorModel> {
+    private readonly _model;
+    protected _table: TableDescriptorInst<TableModel, Sorts, Filters>;
+    protected _detailsEditor: EditorDescriptorInst<TableviewModel, ParentEditorModel>;
+    protected _addEditor: EditorDescriptorInst<AddModel, ParentEditorModel>;
+    protected _editEditor: EditorDescriptorInst<EditModel, ParentEditorModel>;
+    protected _isLocalized: boolean;
+    constructor(model: ModelDescriptor<TableviewModel>, opts?: TableviewDescriptorInstConstructorOpts<TableModel, AddModel, EditModel>);
+    get table(): TableDescriptorInst<TableModel, Sorts, Filters>;
+    get detailsEditor(): EditorDescriptorInst<TableviewModel, ParentEditorModel>;
+    get addEditor(): EditorDescriptorInst<AddModel, ParentEditorModel>;
+    get editEditor(): EditorDescriptorInst<EditModel, ParentEditorModel>;
+    get model(): ModelDescriptor<TableviewModel>;
+    isLocalized(): boolean;
+    withTableDescriptor(descriptor: TableDescriptorInst<TableModel, Sorts, Filters>): this;
+    withEditorDescriptors(descriptor: EditorDescriptorInst<TableviewModel, ParentEditorModel>): this;
+    withDetailsDescriptor(descriptor: EditorDescriptorInst<TableviewModel, ParentEditorModel>): this;
+    withAddDescriptor(descriptor: EditorDescriptorInst<AddModel, ParentEditorModel>): this;
+    withEditDescriptor(descriptor: EditorDescriptorInst<EditModel, ParentEditorModel>): this;
+    /**
+     * creates new copy of editor descriptor and makes it disabled
+     * usable in combination with this::withEditorDescriptors, where detailsDescriptor is made non-disabled
+     * @param type which editor type to set to disabled
+     */
+    withDisabledEditorDescriptor(type?: TableviewEditorTypeEnum): this;
+    withValidation<Value = TableviewModel>(name: string, expression: FormValidator<Value, ParentEditorModel>, message?: FormValidationMessage<Value, ParentEditorModel>, opts?: FieldValidationDescriptorOptsType<keyof FieldsManageModel>): this;
+    withValidationUnsafe<Value = TableviewModel>(name: string, expression: FormValidator<Value, ParentEditorModel>, message?: FormValidationMessage<Value, ParentEditorModel>, opts?: FieldValidationDescriptorOptsType): this;
+    getColumn<Property extends keyof TableModel, ColumnModel = NonNullable<TableModel[Property]>, ColumnValue = TableModel[Property]>(property: Property): ColumnDescriptor<ColumnModel, TableModel, ColumnValue> | null;
+    getColumnUnsafe<ColumnModel = any, ColumnValue = ColumnModel>(property: string): ColumnDescriptor<ColumnModel, TableModel, ColumnValue> | null;
+    removeColumn(property: keyof TableModel): void;
+    removeColumnUnsafe(property: string): void;
+    withColumn<ColumnModel, ColumnValue = ColumnModel>(column: ColumnDescriptor<ColumnModel, TableModel, ColumnValue>): this;
+    addColumn<Property extends keyof TableModel>(property: Property): ColumnDescriptor<NonNullable<TableModel[Property]>, TableModel, TableModel[Property]>;
+    addColumnEnum<PropertyKey extends keyof TableModel, Enum extends NonNullable<TableModel[PropertyKey]>>(property: PropertyKey, enumDesc: EnumDescriptor<Enum>): ColumnDescriptor<Enum, TableModel, TableModel[PropertyKey]>;
+    addColumnUnsafe<ColumnModel = any>(property: string): ColumnDescriptor<ColumnModel, TableModel>;
+    withColumns(...properties: (keyof TableModel)[]): this;
+    getSort(property: Sorts): _mediusinc_mng_commons_table_api.SortDescriptor<TableModel> | null;
+    getSortUnsafe(property: string): _mediusinc_mng_commons_table_api.SortDescriptor<TableModel> | null;
+    removeSort(property: Sorts): void;
+    removeSortUnsafe(property: string): void;
+    addSort(property: Sorts, isDefault?: boolean, ascending?: boolean): _mediusinc_mng_commons_table_api.SortDescriptor<TableModel>;
+    addSortUnsafe(property: string, isDefault?: boolean, ascending?: boolean): _mediusinc_mng_commons_table_api.SortDescriptor<TableModel>;
+    withSort(property: Sorts, isDefault?: boolean, ascending?: boolean): this;
+    withSortUnsafe(property: string, isDefault?: boolean, ascending?: boolean): this;
+    withDefaultSort(property: Sorts, ascending?: boolean, enabled?: boolean): this;
+    withDefaultSortUnsafe(property: string, ascending?: boolean, enabled?: boolean): this;
+    withSorts(...properties: Sorts[]): this;
+    withSortsUnsafe(...properties: string[]): this;
+    withDefaultSorts(...properties: Sorts[]): this;
+    withoutDefaultSorts(): this;
+    getFilter<FilterModel = Filters extends keyof TableModel ? NonNullable<TableModel[Filters]> : any>(property: Filters): FilterDescriptor<FilterModel, TableModel> | null;
+    getFilterUnsafe<FilterModel = any>(property: string): FilterDescriptor<FilterModel, TableModel> | null;
+    removeFilter(property: Filters): void;
+    removeFilterUnsafe(property: string): void;
+    addFilter<FilterModel = Filters extends keyof TableModel ? TableModel[Filters] : never>(property: Filters): FilterDescriptor<FilterModel, TableModel>;
+    addFilterUnsafe<FilterModel>(property: string): FilterDescriptor<FilterModel, TableModel>;
+    addFilterLookup<FilterModel = Filters extends keyof TableModel ? NonNullable<TableModel[Filters]> : never, Service = undefined>(property: Filters, provider?: ILookupDataProvider<FilterModel, Service, any, any>, optionsValueProperty?: keyof FilterModel): _mediusinc_mng_commons_filter.FilterLookupDescriptor<FilterModel, TableModel, Service, FilterModel, keyof FilterModel, keyof FilterModel>;
+    addFilterLookupUnsafe<FilterModel, Service = undefined>(property: string, provider?: ILookupDataProvider<FilterModel, Service, any, any>, optionsValueProperty?: string): _mediusinc_mng_commons_filter.FilterLookupDescriptor<FilterModel, TableModel, Service, FilterModel, keyof FilterModel, keyof FilterModel>;
+    addFilterLookupEnum<Enum>(property: Filters, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>): _mediusinc_mng_commons_filter.FilterLookupEnumDescriptor<Enum, unknown>;
+    addFilterLookupEnumUnsafe<Enum = EnumConstantType>(property: string, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>): _mediusinc_mng_commons_filter.FilterLookupEnumDescriptor<Enum, unknown>;
+    addFilterFromColumn<Property extends keyof TableModel, FilterModel = NonNullable<TableModel[Property]>>(property: Extract<Filters, Property>, displayType?: FilterDisplayTypeEnum, forceSimple?: boolean): FilterDescriptor<FilterModel, TableModel>;
+    withFiltersFromColumns(...properties: Extract<Filters, keyof TableModel>[]): this;
+    withFiltersFromColumnsUnsafe(...properties: string[]): this;
+    addFilterFromColumnUnsafe(property: string, displayType?: FilterDisplayTypeEnum, forceSimple?: boolean): FilterDescriptor<any, TableModel>;
+    withFilter<FilterModel>(property: Filters, filter: FilterDescriptor<FilterModel, TableModel>): this;
+    withFilterUnsafe<FilterModel>(filter: FilterDescriptor<FilterModel, TableModel>): this;
+    removeField(property: keyof FieldsManageModel): void;
+    removeFieldUnsafe(property: string): void;
+    addFieldDescriptor<FieldModel, FieldValue = FieldModel>(field: AFieldDescriptor<FieldModel, FieldsManageModel, FieldValue, ParentEditorModel>): this;
+    addField<Property extends keyof FieldsManageModel, FieldModel = NonNullable<FieldsManageModel[Property]>, FieldValue = FieldsManageModel[Property]>(property: Property): FieldInputDescriptor<FieldsManageModel, FieldModel, FieldValue, ParentEditorModel>;
+    addFieldUnsafe<FieldModel = FieldInputDescriptorType, FieldValue = FieldModel>(property: string): FieldInputDescriptor<FieldsManageModel, FieldModel, FieldValue, ParentEditorModel>;
+    withFields(...properties: (keyof FieldsManageModel)[]): this;
+    addFieldAction(actionName: string): FieldActionDescriptor<FieldsManageModel, ParentEditorModel>;
+    private addFieldToEditAndAdd;
+    /**
+     * Adds lookup field.
+     *
+     * @param {Property} property - The property key of the editor.
+     * @param {FieldsManageAddFieldLookupOpts<LookupModel, Service>} opts - Optional parameters configuring type and/or service provider.
+     * @typeparam Property - The property key of the EditorModel.
+     * @typeparam LookupModel - The field model type, defaults to the non-nullable type of the editor's property.
+     * @typeparam Service - Service used for data provider.
+     * @typeparam FieldValue - The value type of field on editor.
+     *
+     * @returns {FieldLookupDescriptor<LookupModel, FieldsManageModel, Service, FieldValue>} - The field lookup descriptor.
+     */
+    addFieldLookup<Property extends keyof FieldsManageModel, Service = undefined, LookupModel extends NonNullable<FieldsManageModel[Property]> = NonNullable<FieldsManageModel[Property]>, FieldValue = FieldsManageModel[Property]>(property: Property, opts?: FieldsManageAddFieldLookupOpts<LookupModel, Service>): FieldLookupDescriptor<LookupModel, FieldsManageModel, Service, FieldValue, ParentEditorModel, keyof LookupModel, keyof LookupModel>;
+    /**
+     * [UNSAFE] Adds lookup field.
+     * This function is UNSAFE because property is not type-checked.
+     *
+     * @param {string} property Model property name.
+     * @param {FieldsManageAddFieldLookupOpts<LookupModel, Service>} opts - Optional parameters configuring type and/or service provider.
+     * @typeparam LookupModel - The field model type, defaults to the non-nullable type of the editor's property.
+     * @typeparam Service - Service used for data provider.
+     * @typeparam FieldValue - The value type of field on editor.
+     *
+     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue>} - The field lookup descriptor.
+     */
+    addFieldLookupUnsafe<LookupModel, Service = undefined, FieldValue = LookupModel>(property: string, opts?: FieldsManageAddFieldLookupOpts<LookupModel, Service>): FieldLookupDescriptor<LookupModel, FieldsManageModel, Service, FieldValue, ParentEditorModel>;
+    addFieldLookupEnum<Property extends keyof FieldsManageModel, Enum extends NonNullable<FieldsManageModel[Property]>>(property: Property, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>): FieldLookupEnumDescriptor<Enum, FieldsManageModel, ParentEditorModel>;
+    addFieldLookupEnumUnsafe<Enum = EnumConstantType>(property: string, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>): FieldLookupEnumDescriptor<Enum, FieldsManageModel, ParentEditorModel>;
+    addFieldManyEditor<Property extends keyof FieldsManageModel, FieldModel = ArrayItemType<FieldsManageModel[Property]>, FieldValue = FieldsManageModel[Property]>(property: Property, tableviewDescriptor: TableviewDescriptorInst<FieldModel, any, any, FieldsManageModel, FieldModel, FieldModel, FieldModel, FieldModel>): FieldManyEditorDescriptor<FieldModel, FieldsManageModel, FieldValue, ParentEditorModel>;
+    addFieldManyEditorUnsafe<FieldModel, FieldValue = FieldModel[]>(property: string, tableviewDescriptor: TableviewDescriptorInst<FieldModel, any, any, FieldsManageModel, FieldModel, FieldModel, FieldModel, FieldModel>): FieldManyEditorDescriptor<FieldModel, FieldsManageModel, FieldValue, ParentEditorModel>;
+    addFieldManyToManyEditor<Property extends keyof FieldsManageModel, Service, FieldModel = ArrayItemType<FieldsManageModel[Property]>, FieldValue = FieldsManageModel[Property]>(property: Property, mainTableDescriptor: TableDescriptorInst<FieldModel>, lookupTableDescriptor: TableDescriptorInst<FieldModel>, lookupDataProvider: ITableDataProvider<FieldModel, Service>): FieldManyToManyEditorDescriptor<FieldModel, FieldsManageModel, Service, FieldValue, ParentEditorModel>;
+    addFieldManyToManyEditorUnsafe<FieldModel, Service, FieldValue = FieldModel[]>(property: string, mainTableDescriptor: TableDescriptorInst<FieldModel>, lookupTableDescriptor: TableDescriptorInst<FieldModel>, lookupDataProvider: ITableDataProvider<FieldModel, Service>): FieldManyToManyEditorDescriptor<FieldModel, FieldsManageModel, Service, FieldValue, ParentEditorModel>;
+    withTabGroup(name: string, title?: string): this;
+    withFieldGroup(name: string, title?: string): this;
+    copy(): TableviewDescriptorInst<TableviewModel, Sorts, Filters, ParentEditorModel, TableModel, AddModel, EditModel, FieldsManageModel>;
+    localized<Property extends keyof TableviewModel, LocalizationModel = ArrayItemType<TableviewModel[Property]>>(property: Property, model: ModelDescriptor<LocalizationModel>, localeProperty: keyof LocalizationModel): this;
+    localizedUnsafe<LocalizationModel>(property: string, model: ModelDescriptor<LocalizationModel>, localeProperty: string): this;
+}
+declare class TableviewDynamicDescriptorInt extends TableviewDescriptorInst<any> {
+    protected _table: TableDynamicDescriptorInst;
+    constructor(model: ModelDescriptor<any>);
+    get table(): TableDynamicDescriptorInst;
+    /**
+     * sets custom table descriptor
+     * @param descriptor
+     */
+    withTableDescriptor(descriptor: TableDynamicDescriptorInst): this;
+    /**
+     * sets visibility hidden state to column with given property
+     * equals to be removing in auto and base tableview descriptor
+     * * @param property column's property
+     */
+    removeColumn(property: string): this;
+    withEntityForTranslations(i18nBaseKey: string): this;
+    /**
+     * creates deep copy of tableview object and its children
+     */
+    copy(): TableviewDynamicDescriptorInt;
+}
+
+/**
+ * @experimental
+ */
+declare class EditorDescriptorNestedObjectWrapper<EditorModel, ParentEditorModel, PropertyObjectModel> implements IFieldManageSafeWithGetField<EditorModel, ParentEditorModel, PropertyObjectModel> {
+    #private;
+    constructor(editor: IFieldsManageWithGetField<EditorModel, ParentEditorModel>, basePath: string);
+    nested<Property extends keyof PropertyObjectModel>(property: Property): EditorDescriptorNestedObjectWrapper<EditorModel, ParentEditorModel, NonNullable<PropertyObjectModel[Property]>>;
+    getNestedPropertyPath(p: keyof PropertyObjectModel): string;
+    getField<Property extends keyof PropertyObjectModel, FieldModel = NonNullable<PropertyObjectModel[Property]>, FieldValue = PropertyObjectModel[Property]>(property: Property): AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel> | null;
+    removeField(property: keyof PropertyObjectModel): void;
+    addField<PropertyField extends keyof PropertyObjectModel, FieldModel = NonNullable<PropertyObjectModel[PropertyField]>, FieldValue = PropertyObjectModel[PropertyField]>(property: PropertyField): _mediusinc_mng_commons_tableview_api.FieldInputDescriptor<EditorModel, FieldModel, FieldValue, ParentEditorModel>;
+    withFields(...properties: (keyof PropertyObjectModel)[]): this;
+    addFieldLookup<Property extends keyof PropertyObjectModel, Service = undefined, FieldModel extends NonNullable<PropertyObjectModel[Property]> = NonNullable<PropertyObjectModel[Property]>, FieldValue = PropertyObjectModel[Property]>(property: Property, opts?: FieldsManageAddFieldLookupOpts<FieldModel, Service>): _mediusinc_mng_commons_tableview_api.FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue, ParentEditorModel, keyof FieldModel, keyof FieldModel>;
+    addFieldLookupEnum<Property extends keyof PropertyObjectModel, Enum extends NonNullable<PropertyObjectModel[Property]>>(property: Property, enumModel: EnumDescriptor<Enum>, options?: Array<Enum>): FieldLookupEnumDescriptor<Enum, EditorModel, ParentEditorModel>;
+    addFieldManyEditor<Property extends keyof PropertyObjectModel, FieldModel = ArrayItemType<PropertyObjectModel[Property]>, FieldValue = PropertyObjectModel[Property]>(property: Property, tableviewDescriptor: ITableviewDescriptor<FieldModel, any, any, EditorModel, FieldModel, FieldModel, FieldModel>): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>;
+    addFieldManyToManyEditor<Property extends keyof PropertyObjectModel, Service, FieldModel = ArrayItemType<PropertyObjectModel[Property]>, FieldValue = PropertyObjectModel[Property]>(property: Property, mainTableDescriptor: ITableDescriptor<FieldModel, any, any>, lookupTableDescriptor: ITableDescriptor<FieldModel, any, any>, lookupDataProvider: ITableDataProvider<FieldModel, Service>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, Service, FieldValue, ParentEditorModel>;
+    addFieldDescriptor<FieldModel, FieldValue = FieldModel>(field: AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>): this;
+}
+
+declare class EditorDescriptorInst<EditorModel, ParentEditorModel = undefined> implements IEditorDescriptor<EditorModel, ParentEditorModel>, IFieldsManageWithGetField<EditorModel, ParentEditorModel> {
+    static readonly defaultGroupName = "_default";
+    /** @ignore */ protected readonly _model: ModelDescriptor<EditorModel>;
+    /** @ignore */ protected readonly _tableviewEditorType: TableviewEditorTypeEnum;
+    /** @ignore */ protected readonly _tabs: Array<FieldTabGroupDescriptor<EditorModel>>;
+    /** @ignore */ protected readonly _groups: Array<FieldGroupDescriptor<EditorModel, ParentEditorModel>>;
+    /** @ignore */ protected _fields: Array<AFieldDescriptor<any, EditorModel>>;
+    /** @ignore */ protected _currentTabGroup?: FieldTabGroupDescriptor<EditorModel>;
+    /** @ignore */ protected _currentGroup?: FieldGroupDescriptor<EditorModel>;
+    /** @ignore */ protected _autoSave?: boolean;
+    /** @ignore */ protected _autoSaveIdentifier?: string;
+    /** @ignore */ protected _autofocusOnField?: boolean;
+    /** @ignore */ protected _disabled: boolean;
+    /** @ignore */ protected _isLocalized: boolean;
+    /** @ignore */ protected _localizationLocaleProperty?: string;
+    /** @ignore */ protected _localizationModel?: ModelDescriptor<any>;
+    /** @ignore */ protected _localizationLocalizationProperty?: string;
+    /** @ignore */ protected readonly _eventsSubject: Subject<FormEvent<EditorModel, ParentEditorModel>>;
+    /**
+     * Creates new instance of editor descriptor.
+     * @param model Model descriptor.
+     * @param tableviewEditorType Type of editor in tableview (add, edit, view or none).
+     */
+    constructor(model: ModelDescriptor<EditorModel>, tableviewEditorType?: TableviewEditorTypeEnum);
+    /**
+     * Model descriptor for editor.
+     */
+    get model(): ModelDescriptor<EditorModel>;
+    /**
+     * Editor's tabs.
+     */
+    get tabs(): FieldTabGroupDescriptor<EditorModel>[];
+    /**
+     * Editor's fields.
+     */
+    get fields(): AFieldDescriptor<any, EditorModel, any, undefined>[];
+    /**
+     * Type of editor for tableview.
+     */
+    get tableviewEditorType(): TableviewEditorTypeEnum;
+    /**
+     * If editor is disabled.
+     */
+    get disabled(): boolean;
+    get isLocalized(): boolean;
+    get localizationLocaleProperty(): string | undefined;
+    get localizationLocalizationProperty(): string | undefined;
+    get localizationModel(): ModelDescriptor<any> | undefined;
+    get autoSave(): boolean | undefined;
+    get autoSaveIdentifier(): string | undefined;
+    get autofocusOnField(): boolean | undefined;
+    /**
+     * Dives into nested object to add fields from the nested object on property.
+     *
+     * @experimental
+     *
+     * @param property Model property name.
+     */
+    nested<Property extends keyof EditorModel>(property: Property): EditorDescriptorNestedObjectWrapper<EditorModel, ParentEditorModel, NonNullable<EditorModel[Property]>>;
+    /**
+     * Creates new tab group. Next added fields are added to newly created tab group.
+     * @param name Name of the group.
+     * @param title Title key for the tab.7@return Newly created group descriptor.
+     * @return Newly created group descriptor.
+     */
+    addTabGroup(name: string, title?: string): FieldTabGroupDescriptor<EditorModel>;
+    /**
+     * Creates new tab group. Next added fields are added to newly created tab group.
+     * @param name Name of the group.
+     * @param title Title key for the tab.7@return Newly created group descriptor.
+     */
+    withTabGroup(name: string, title?: string): this;
+    /**
+     * Gets group by its name (key).
+     * @param name Group's key.
+     */
+    getGroup(name: string | number): FieldGroupDescriptor<EditorModel> | null;
+    /**
+     * Creates new field group. Next added fields are added to newly created field group.
+     * @param name Name of the group.
+     * @param title Title key for the group.
+     * @return Newly created group descriptor.
+     */
+    addFieldGroup(name: string, title?: string | null): FieldGroupDescriptor<EditorModel>;
+    /**
+     * Creates new field group. Next added fields are added to newly created field group.
+     * @param name Name of the group.
+     * @param title Title key for the group.
+     */
+    withFieldGroup(name: string, title?: string): this;
+    /**
+     * Gets field by the model property name.
+     * @param property Model property name.
+     */
+    getField<Property extends keyof EditorModel, FieldModel = NonNullable<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property): AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel> | null;
+    /**
+     * Gets field by the model property name (UNSAFE).
+     * @param property Model property name.
+     */
+    getFieldUnsafe<FieldModel, FieldValue = FieldModel>(property: string): AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel> | null;
+    /**
+     * Removes field by the model property name.
+     * @param property Model property name.
+     */
+    removeField(property: keyof EditorModel): void;
+    /**
+     * Removes field by the model property name (UNSAFE).
+     * @param property Model property name.
+     */
+    removeFieldUnsafe(property: string): void;
+    /**
+     * Adds field by the descriptor.
+     * @param field Field descriptor.
+     */
+    addFieldDescriptor<FieldModel, FieldValue = FieldModel>(field: AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>): this;
+    /**
+     * Adds field by the model property name.
+     * @param property Model property name.
+     */
+    addField<Property extends keyof EditorModel, FieldModel = NonNullable<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property): FieldInputDescriptor<EditorModel, FieldModel, FieldValue, ParentEditorModel>;
+    /**
+     * Adds field by the model property name (UNSAFE). Property is not checked on editor model.
+     * Use {addField} for safe usage.
+     * @param property Model property name.
+     */
+    addFieldUnsafe<FieldModel = FieldInputDescriptorType, FieldValue = FieldModel>(property: string): FieldInputDescriptor<EditorModel, FieldModel, FieldValue, ParentEditorModel>;
+    withFields(...properties: (keyof EditorModel)[]): this;
+    addFieldAction(actionName: string): FieldActionDescriptor<EditorModel, ParentEditorModel>;
+    /**
+     * Adds lookup field.
+     *
+     * @param {Property} property - The property key of the editor.
+     * @param {FieldsManageAddFieldLookupOpts<LookupModel, Service>} opts - Optional parameters configuring type and/or service provider.
+     * @typeparam Property - The property key of the EditorModel.
+     * @typeparam LookupModel - The field model type, defaults to the non-nullable type of the editor's property.
+     * @typeparam Service - Service used for data provider.
+     * @typeparam FieldValue - The value type of field on editor.
+     *
+     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue>} - The field lookup descriptor.
+     */
+    addFieldLookup<Property extends keyof EditorModel, Service = undefined, LookupModel extends NonNullable<EditorModel[Property]> = NonNullable<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, opts?: FieldsManageAddFieldLookupOpts<LookupModel, Service>): FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue, ParentEditorModel, keyof LookupModel, keyof LookupModel>;
+    /**
+     * [UNSAFE] Adds lookup field.
+     * This function is UNSAFE because property is not type-checked.
+     *
+     * @param {string} property Model property name.
+     * @param {FieldsManageAddFieldLookupOpts<LookupModel, Service>} opts - Optional parameters configuring type and/or service provider.
+     * @typeparam LookupModel - The field model type, defaults to the non-nullable type of the editor's property.
+     * @typeparam Service - Service used for data provider.
+     * @typeparam FieldValue - The value type of field on editor.
+     *
+     * @returns {FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue>} - The field lookup descriptor.
+     */
+    addFieldLookupUnsafe<LookupModel, Service = undefined, FieldValue = LookupModel>(property: string, opts?: FieldsManageAddFieldLookupOpts<LookupModel, Service>): FieldLookupDescriptor<LookupModel, EditorModel, Service, FieldValue, ParentEditorModel, keyof LookupModel, keyof LookupModel>;
+    addFieldLookupEnum<Property extends keyof EditorModel, Enum extends NonNullable<EditorModel[Property]>>(property: keyof EditorModel, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>): FieldLookupEnumDescriptor<Enum, EditorModel, ParentEditorModel>;
+    /**
+     * Adds enum lookup field.
+     * @param property Model's property name.
+     * @param enumDesc Type of enum or enum descriptor.
+     * @param options Provides subset of enum's available constants.
+     */
+    addFieldLookupEnumUnsafe<Enum = EnumConstantType>(property: string, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>): FieldLookupEnumDescriptor<Enum, EditorModel, ParentEditorModel>;
+    /**
+     * Adds table/details/add/edit field for one-to-many (1:n) relations.
+     * @param property Model's property name.
+     * @param tableviewDescriptor Tableview descriptor for related model.
+     */
+    addFieldManyEditor<Property extends keyof EditorModel, FieldModel = ArrayItemType<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, tableviewDescriptor: TableviewDescriptorInst<FieldModel, any, any, EditorModel, FieldModel, FieldModel, FieldModel, FieldModel>): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>;
+    /**
+     * Adds table/details/add/edit field for one-to-many (1:n) relations (UNSAFE).
+     * @param property Model's property name.
+     * @param tableviewDescriptor Tableview descriptor for related model.
+     */
+    addFieldManyEditorUnsafe<FieldModel, FieldValue = FieldModel[]>(property: string, tableviewDescriptor: TableviewDescriptorInst<FieldModel, any, any, EditorModel, FieldModel, FieldModel, FieldModel, FieldModel>): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>;
+    addFieldManyToManyEditor<Property extends keyof EditorModel, ServiceType, FieldModel = ArrayItemType<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property, mainTableDescriptor: TableDescriptorInst<FieldModel, any, any>, lookupTableDescriptor: TableDescriptorInst<FieldModel, any, any>, lookupDataProvider: ITableDataProvider<FieldModel, ServiceType, any, any>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, ServiceType, FieldValue, ParentEditorModel>;
+    addFieldManyToManyEditorUnsafe<FieldModel, ServiceType, FieldValue = FieldModel[]>(property: string, mainTableDescriptor: TableDescriptorInst<FieldModel, any, any>, lookupTableDescriptor: TableDescriptorInst<FieldModel, any, any>, lookupDataProvider: ITableDataProvider<FieldModel, ServiceType, any, any>): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, ServiceType, FieldValue, ParentEditorModel>;
+    /**
+     * Disables field on editor.
+     * @param disabled
+     */
+    withDisabled(disabled?: boolean): this;
+    /**
+     * Adds group validator to editor.
+     * @param name Name of the validation.
+     * @param validator Field validator function.
+     * @param message Field validation message.
+     * @param opts Additional configuration for validation.
+     */
+    withValidation<Value = EditorModel>(name: string, validator?: FormValidator<Value, ParentEditorModel>, message?: FormValidationMessage<Value, ParentEditorModel>, opts?: FieldValidationDescriptorOptsType<keyof EditorModel>): this;
+    /**
+     * Adds group validator to editor.
+     * @param name Name of the validation.
+     * @param validator Field validator function.
+     * @param message Field validation message.
+     * @param opts Additional configuration for validation.
+     */
+    withValidationUnsafe<Value = EditorModel>(name: string, validator?: FormValidator<Value, ParentEditorModel>, message?: FormValidationMessage<Value, ParentEditorModel>, opts?: FieldValidationDescriptorOptsType): this;
+    withAutoSave(enabled?: boolean, autoSaveIdentifier?: string): this;
+    withAutofocusOnField(enabled?: boolean): this;
+    /**
+     * Creates a copy of editor descriptor object.
+     */
+    copy(): EditorDescriptorInst<EditorModel, ParentEditorModel>;
+    /**
+     * Created group from field group descriptor.
+     * @param fieldGroup Field group descriptor.
+     * @internal
+     */
+    createFieldGroupDescriptor(fieldGroup: FieldGroupDescriptor<EditorModel, ParentEditorModel>): this;
+    /**
+     * Creates tab group from tab group descriptor.
+     * @param tabGroup Tab group descriptor.
+     * @internal
+     */
+    protected createTabGroupDescriptor(tabGroup: FieldTabGroupDescriptor<EditorModel>): this;
+    /**
+     * Creates default field group.
+     * @internal
+     */
+    private createDefaultGroup;
+    /**
+     * Creates default tab group.
+     * @internal
+     */
+    private createDefaultTabGroup;
+    /**
+     * This function takes care of displaying correct/localized data in the editor
+     * @param property property that tells us where on the model are localizations accessible
+     * @param model Model for localizations
+     * @param localeProperty property by which we find the locale
+     */
+    localized<Property extends keyof EditorModel, LocalizationModel = ArrayItemType<EditorModel[Property]>>(property: Property, model: ModelDescriptor<LocalizationModel>, localeProperty: keyof LocalizationModel): this;
+    localizedUnsafe<LocalizationType>(property: string, model: ModelDescriptor<LocalizationType>, localeProperty: string): this;
+    nextEvent(type: FormEventTypeEnum, component: IFormEditorComponent<any, any>, data?: FormEventData<EditorModel>): void;
+    get events$(): rxjs.Observable<FormEvent<EditorModel, ParentEditorModel>>;
+}
+
+type FormEditorResetFormModelOpts = {
+    markAsPristine?: boolean;
+    onlySelf?: boolean;
+};
+type FormEditorSetFieldValueOpts = {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    emitModelToViewChange?: boolean;
+    emitViewToModelChange?: boolean;
+};
+type FormEditorPatchFieldValueOpts = {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+    emitModelToViewChange?: boolean;
+    emitViewToModelChange?: boolean;
+};
+type FormEditorResetFieldValueOpts = {
+    onlySelf?: boolean;
+    emitEvent?: boolean;
+};
+type FormEditorGetFormValueOpts = {
+    omitSetters?: boolean;
+};
+interface IFormEditorComponent<Item, ParentItem = any> {
+    get form(): FormGroup<{
+        [K in keyof Item]: AbstractControl<Item[K]>;
+    }>;
+    get formUnsafe(): UntypedFormGroup;
+    get formlyInitialItem(): any;
+    get formlyOptions(): FormlyFormOptions & CommonsFormlyFormOptions<Item>;
+    get formlyFields(): FormlyFieldConfig[];
+    get parent(): IFormEditorComponent<ParentItem> | undefined;
+    descriptor: InputSignal<EditorDescriptorInst<Item>>;
+    isFormDisabled: InputSignalWithTransform<boolean, unknown>;
+    formMessages: WritableSignal<ToastMessageOptions[]>;
+    submit(): void;
+    getFormValue(opts?: FormEditorGetFormValueOpts): Item;
+    resetFormModel(item?: Item, opts?: FormEditorResetFormModelOpts): void;
+    getField(key: keyof Item): AbstractControl | null;
+    getFieldUnsafe(key: string): AbstractControl | null;
+    setFieldValue<Property extends keyof Item>(key: Property, value: Item[Property], opts?: FormEditorSetFieldValueOpts): boolean;
+    setFieldValueUnsafe(key: string, value: any, opts?: FormEditorSetFieldValueOpts): boolean;
+    patchFieldValue<Property extends keyof Item>(key: Property, value: Item[Property], opts?: FormEditorPatchFieldValueOpts): boolean;
+    patchFieldValueUnsafe(key: string, value: any, opts?: FormEditorPatchFieldValueOpts): boolean;
+    resetFieldValue<Property extends keyof Item>(key: Property, value?: Item[Property], opts?: FormEditorResetFieldValueOpts): boolean;
+    resetFieldValueUnsafe(key: string, value?: any, opts?: FormEditorResetFieldValueOpts): boolean;
+}
+
+interface FormEditorSubmitEvent<Item> {
+    formItem: Item;
+    success: boolean;
+}
+declare enum FormFieldEventTypeEnum {
+    ComponentLifecycle = "ComponentLifecycle",
+    ValueChange = "ValueChange",
+    DataProvider = "DataProvider",
+    DialogLifecycle = "DialogLifecycle",
+    RowReorder = "RowReorder",
+    Other = "Other"
+}
+declare enum FormEventTypeEnum {
+    ComponentLifecycle = "ComponentLifecycle",
+    ValueChange = "ValueChange",
+    Submit = "Submit",
+    Other = "Other"
+}
+declare class FormFieldEventComponentSubtype {
+    static readonly ON_INIT = "Component.OnInit";
+    static readonly ON_VIEW_INIT = "Component.OnViewInit";
+    static readonly ON_CONTENT_INIT = "Component.OnContentInit";
+    static readonly ON_DESTROY = "Component.OnDestroy";
+}
+declare class FormFieldEventDialogSubtype {
+    static readonly VISIBILITY = "Dialog.Visibility";
+    static readonly TABLE_CAPTION_COMPONENT_INSTANCE = "Dialog.MngTable.CaptionComponentInstance";
+    static readonly TABLE_COLUMN_ACTIONS_COMPONENT_INSTANCE = "Dialog.MngTable.ColumnActionsComponentInstance";
+}
+interface FormFieldEventData<FieldModel, EditorModel> {
+    eventSubtype?: string;
+    value?: FieldModel;
+    formValue?: EditorModel;
+    [key: string]: any;
+}
+interface FormEventData<EditorModel> {
+    eventSubtype?: string;
+    value?: EditorModel;
+    submitValid?: boolean;
+    submitValue?: EditorModel;
+    [key: string]: any;
+}
+interface FormFieldEvent<FieldValue, FormValue, ParentFormValue = undefined> {
+    type: FormFieldEventTypeEnum;
+    fieldComponent?: FieldType<CommonsFormlyFieldConfig<FieldValue, FormValue, ParentFormValue>>;
+    formComponent?: IFormEditorComponent<FormValue, ParentFormValue>;
+    fieldFormControl: FormControl<FieldValue>;
+    form: FormGroup<{
+        [K in keyof FormValue]: AbstractControl<FormValue[K]>;
+    }>;
+    fieldFormlyConfig: CommonsFormlyFieldConfig<FieldValue, FormValue, ParentFormValue>;
+    data?: FormFieldEventData<FieldValue, FormValue>;
+}
+interface FormEvent<FormValue, ParentFormValue = undefined> {
+    type: FormEventTypeEnum;
+    formComponent?: IFormEditorComponent<FormValue, ParentFormValue>;
+    form: FormGroup<{
+        [K in keyof FormValue]: AbstractControl<FormValue[K]>;
+    }>;
+    data?: FormEventData<FormValue>;
+}
+interface EditorResetEvent<Item> {
+    emitEvent?: boolean;
+    fetch?: boolean;
+    item?: Item;
+    fields?: Partial<Item>;
+    data?: {
+        [key: string]: any;
+    };
+}
+
+interface IViewContainer<Item, Service, ActionInstance extends IActionInstance<Item, Service> = IActionInstance<Item, Service>> {
+    dataProvider: WritableSignal<IDataProvider<Item, Service> | undefined>;
+    routeTriggeredActionInstance: WritableSignal<ActionInstance | undefined>;
+    actions: WritableSignal<Array<ActionDescriptorInst<any>>>;
+    tableReload$: Observable<TableReloadEvent>;
+    editorReset$: Observable<EditorResetEvent<Item>>;
+    editorClose$: Observable<ViewContainerEditorCloseEvent<Item>>;
+    reloadTable(event?: TableReloadEvent): void;
+    resetEditor(event?: EditorResetEvent<Item> | undefined): void;
+    closeEditor(event?: ViewContainerEditorCloseEvent<Item>): void;
+}
+interface ViewContainerEditorCloseEvent<T> {
+    emitEvent?: boolean;
+    item?: T;
+}
+
+/**
+ * Class containing all main data for action to be executed in run/fetch/submit states.
+ */
+interface IActionContext<Item, ParametersItem, Service = undefined, Instance extends IActionInstance<Item, Service> = IActionInstance<Item, Service>, ViewContainer extends IViewContainer<Item, Service, Instance> = IViewContainer<Item, Service, Instance>> {
+    contextLongName: string;
+    instance: Instance;
+    parameters: ActionParameters<ParametersItem, ParametersItem, ParametersItem, ParametersItem>;
+    functionName: 'run' | 'fetch' | 'submit';
+    serviceInstance: Service;
+    dataProvider?: IDataProvider<Item, Service>;
+    viewContainer?: ViewContainer;
+    injector: Injector;
+    previousActionInstance?: IActionInstance<any, any>;
+    confirmation?: Confirmation;
+    notification?: ToastMessageOptions;
+    execution$: Observable<Item | null | undefined>;
+    executionIsRunning$: Observable<boolean>;
+}
+type IActionEditorContext<Item, ParentItem, ParametersItem, Service = undefined, Instance extends IActionInstance<Item, Service> = IActionInstance<Item, Service>, ViewContainer extends IViewContainer<Item, Service, Instance> = IViewContainer<Item, Service, Instance>> = IActionContext<Item, ParametersItem, Service, Instance, ViewContainer>;
+
+interface ActionConfirmation<Model, ParametersItem, Service> {
+    icon?: string | null;
+    title?: string | null;
+    message?: string | null;
+    acceptButton?: IActionButtonDescriptor;
+    rejectButton?: IActionButtonDescriptor | false;
+    closeOnEscape?: boolean;
+    closable?: boolean;
+    configMapFn?: ConfigurationConfigMapFn<ParametersItem>;
+    shouldShowFn?: ConfigurationShouldShowFn<Model, ParametersItem, Service>;
+}
+type ConfigurationConfigMapFn<Item> = (ctx: IActionContext<any, Item, any, any, any>, confirmConfig: Confirmation) => Confirmation;
+type ConfigurationShouldShowFn<Item, ParametersItem, Service> = (ctx: IActionContext<Item, ParametersItem, Service, any, any>) => boolean;
+
+/**
+ * Class containing all main data for action validations (enabled/visible) to be executed in validation states.
+ */
+interface ActionContextValidation<Item, ParametersItem, Service = undefined> {
+    descriptor: ActionDescriptorInst<Item, Service>;
+    parameters: ActionParameters<ParametersItem>;
+    serviceInstance: Service;
+    dataProvider?: IDataProvider<Item, Service>;
+}
+
+type ActionRunFnType<Item, Service = undefined, InputItem = Item, ReturnItem = Item, Return = ItemOrObservable<Nullable<ReturnItem>>> = (ctx: IActionContext<Item, InputItem, Service>) => Return;
+type ActionEditorRunFnType<Item, ParentItem, Service = undefined, InputItem = Item, ReturnItem = Item, Return = ItemOrObservable<Nullable<ReturnItem>>> = (ctx: IActionEditorContext<Item, ParentItem, InputItem, Service>) => Return;
+type ActionValidationFnType<Item, Service = undefined, InputItem = Item, Return = ItemOrObservable<boolean>> = (ctx: ActionContextValidation<Item, InputItem, Service>) => Return;
+type ActionNotificationType = {
+    title?: string;
+    message?: string;
+};
+
+declare enum ActionPositionEnum {
+    ToolbarLeft = 0,
+    ToolbarRight = 1,
+    TableHeader = 2,
+    RowInline = 3,
+    RowClick = 4,
+    FooterLeft = 5,
+    FooterRight = 6
+}
+declare enum ActionActivationTriggerEnum {
+    OnClick = 0,// action is triggered for activation on click
+    OnRoute = 1
+}
+declare enum ActionTypeEnum {
+    Direct = 0,// action is directly activated and executed
+    Editor = 1
+}
+declare enum ActionEditorSubmitTypeEnum {
+    Submit = 0,
+    Cancel = 1
+}
+
+type ActionDescriptorCreateOptsProviderType<Item, Service> = {
+    serviceType?: ServiceClassType<Service>;
+    dataProvider?: IDataProvider<Item, Service>;
+};
+type ActionDescriptorCreateOptsParentType = {
+    parentModel?: ModelDescriptor<any>;
+    parentProperty?: string;
+};
+type ActionDescriptorConstructorOptsType<Item, Service> = ActionDescriptorCreateOptsParentType & ActionDescriptorCreateOptsProviderType<Item, Service> & {
+    model?: ModelDescriptor<Item>;
+};
+type AfterRunActionType<RunReturnItem> = ActionDescriptorInst<any, any, RunReturnItem, any, undefined>;
+type OnErrorActionType<RunInputItem> = ActionDescriptorInst<any, any, RunInputItem, any, undefined>;
+declare class ActionDescriptorInst<Item, Service = any, RunInputItem = Item, RunReturnItem = Item, ValidationInputItem = RunInputItem> implements IActionDescriptor<Item, Service> {
+    protected readonly _model?: ModelDescriptor<Item>;
+    protected readonly _actionName: string;
+    protected readonly _actionNameLong: string;
+    protected readonly _parentModel?: ModelDescriptor<any>;
+    protected readonly _parentProperty?: string;
+    protected readonly _dataProvider?: IDataProvider<Item, Service>;
+    protected _i18nModelActionBaseKey?: string;
+    protected _type: ActionTypeEnum;
+    protected _activationTrigger: ActionActivationTriggerEnum;
+    protected _position: ActionPositionEnum;
+    protected _level: StyleLevelEnum;
+    private _positionTableviewCategories?;
+    protected _tableviewCategory?: string;
+    protected _routeUrl: string | null;
+    protected _runFunction?: ActionRunFnType<Item, Service, RunInputItem, RunReturnItem>;
+    protected _isVisibleFunction?: ActionValidationFnType<ValidationInputItem, Service>;
+    protected _isEnabledFunction?: ActionValidationFnType<ValidationInputItem, Service>;
+    protected _runConfirmation?: ActionConfirmation<Item, RunInputItem, Service>;
+    protected _runNotificationOnSuccess?: ActionNotificationType | boolean;
+    protected _runNotificationOnError?: ActionNotificationType | boolean;
+    protected _afterRunAction?: AfterRunActionType<RunReturnItem> | ((ctx: IActionContext<Item, RunInputItem, any, any>) => AfterRunActionType<RunReturnItem>);
+    protected _onRunErrorAction?: OnErrorActionType<RunInputItem> | ((ctx: IActionContext<Item, RunInputItem, any, any>) => OnErrorActionType<RunInputItem>);
+    protected _permissions?: APermissions;
+    protected _button?: IActionButtonDescriptor;
+    protected _hasItemsSelection: boolean;
+    protected _component?: Type<IActionComponent<Item>>;
+    protected _componentFromDi?: InjectionToken<Type<any>>;
+    protected _subactionsAsMenu: boolean;
+    protected _subactions: Array<ActionDescriptorInst<Item, any, RunInputItem, any>>;
+    constructor(actionName: string, cfg?: ActionDescriptorConstructorOptsType<Item, Service>);
+    get model(): ModelDescriptor<Item> | undefined;
+    get parentModel(): ModelDescriptor<any> | undefined;
+    get parentProperty(): string | undefined;
+    get i18nModelActionBaseKey(): string | undefined;
+    get type(): ActionTypeEnum;
+    get activationTrigger(): ActionActivationTriggerEnum;
+    get position(): ActionPositionEnum;
+    get routeUrl(): string | null;
+    get dataProvider(): IDataProvider<Item, Service> | undefined;
+    get hasRunFunction(): boolean;
+    get runFunction(): ActionRunFnType<Item, Service, RunInputItem, RunReturnItem>;
+    get isVisibleFunction(): ActionValidationFnType<ValidationInputItem, Service> | undefined;
+    get isEnabledFunction(): ActionValidationFnType<ValidationInputItem, Service> | undefined;
+    get actionName(): string;
+    get actionNameLong(): string;
+    get runConfirmation(): ActionConfirmation<Item, RunInputItem, Service> | undefined;
+    get runNotificationOnSuccess(): boolean | ActionNotificationType | undefined;
+    get runNotificationOnError(): boolean | ActionNotificationType | undefined;
+    get afterRunAction(): AfterRunActionType<RunReturnItem> | ((ctx: IActionContext<Item, RunInputItem, any, any>) => AfterRunActionType<RunReturnItem>) | undefined;
+    get onRunErrorAction(): OnErrorActionType<RunInputItem> | ((ctx: IActionContext<Item, RunInputItem, any, any>) => OnErrorActionType<RunInputItem>) | undefined;
+    get permissions(): APermissions | undefined;
+    get tableviewCategory(): string | undefined;
+    get hasItemsSelection(): boolean;
+    get button(): IActionButtonDescriptor | undefined;
+    get component(): Type<IActionComponent<Item, undefined>> | undefined;
+    get componentFromDi(): InjectionToken<Type<any>> | undefined;
+    get positionTableviewCategories(): string[] | undefined;
+    get subactionsAsMenu(): boolean;
+    get subactions(): ActionDescriptorInst<Item, any, RunInputItem, any, RunInputItem>[];
+    protected setI18nModelActionBaseKey(base?: string): void;
+    withRunFunction(fn: ActionRunFnType<Item, Service, RunInputItem, RunReturnItem>): this;
+    withIsVisibleFunction(fn?: ActionValidationFnType<ValidationInputItem, Service>): this;
+    withIsEnabledFunction(fn?: ActionValidationFnType<ValidationInputItem, Service>): this;
+    withRouteTrigger(routeUrl: string): this;
+    withPosition(position: ActionPositionEnum): this;
+    /**
+     * Creates confirmation action with default style based on action descriptor
+     */
+    withRunConfirmation(opts?: boolean | ActionConfirmation<Item, RunInputItem, Service>): this;
+    /**
+     * Override default notifications setup. Notifications can either be overridden with custom text or turned on/off.
+     *
+     * @param opts Provide config for texts or on/off flag for run success/error notifications.
+     */
+    withNotifications(opts?: {
+        runOnSuccess?: ActionNotificationType | boolean;
+        runOnError?: ActionNotificationType | boolean;
+    } | boolean): this;
+    withAfterRunAction(action?: AfterRunActionType<RunReturnItem> | ((ctx: IActionContext<Item, RunInputItem, any, any>) => AfterRunActionType<RunReturnItem>)): this;
+    withOnRunErrorAction(action?: OnErrorActionType<RunInputItem> | ((ctx: IActionContext<Item, RunInputItem, any, any>) => OnErrorActionType<RunInputItem>)): this;
+    withPermissions(permissions: APermissions): this;
+    withTableviewCategory(category: string): this;
+    withButtonOpts(button?: IActionButtonDescriptor): this;
+    withButton(label?: string | null, icon?: string | null, level?: StyleLevelEnum): this;
+    withItemsSelection(hasSelection?: boolean): this;
+    withComponent(component: Type<IActionComponent<Item>>): this;
+    withComponentFromDi(injectionToken: InjectionToken<Type<any>>): this;
+    withPositionTableviewCategories(positionTableviewCategories: string[]): this;
+    withI18nBase(base: ClassType<unknown> | string): this;
+    withSubactionsAsMenu(subactionsAsMenu?: boolean): this;
+    withSubactions(...subactions: Array<ActionDescriptorInst<Item, any, RunInputItem, any>>): this;
+    copyFieldsTo(descriptor: ActionDescriptorInst<Item, Service, RunInputItem, RunReturnItem, ValidationInputItem>): ActionDescriptorInst<Item, Service, RunInputItem, RunReturnItem, ValidationInputItem>;
+    copy(): ActionDescriptorInst<Item, Service, RunInputItem, RunReturnItem, ValidationInputItem>;
+}
+
+type ActionDescriptorCreateFromModelOptsType<RunInputType, RunReturnType, ValidationInput> = ActionDescriptorCreateOptsParentType & {
+    runInputType?: TypeDescriptor<RunInputType>;
+    runReturnType?: TypeDescriptor<RunReturnType>;
+    validationType?: TypeDescriptor<ValidationInput>;
+};
+type ActionDescriptorCreateOptsType<Model, Service, RunInputType, RunReturnType, ValidationInput> = ActionDescriptorCreateOptsParentType & {
+    model?: ModelDescriptor<Model>;
+    serviceProvider?: ActionProviderType<Model, Service>;
+    runInputType?: TypeDescriptor<RunInputType>;
+    runReturnType?: TypeDescriptor<RunReturnType>;
+    validationType?: TypeDescriptor<ValidationInput>;
+};
+type ActionProviderType<Model, Service> = ServiceClassType<Service> | IDataProvider<Model, Service>;
+declare const actionGetProviderCfgObj: <Model, Service>(serviceOrDataProvider?: ActionProviderType<Model, Service>) => ActionDescriptorCreateOptsProviderType<Model, Service>;
+/**
+ * Creates and returns an instance of ActionDescriptorInst, allowing customization of the action's behavior through configuration options.
+ *
+ * @param {string} actionName - The unique name of the action.
+ * @param {ActionDescriptorCreateFromModelOptsType<Model, Service, RunInput, RunResult, ValidationInput>} [opts] - Optional configuration object to define the action's behavior, including model, service provider and other.
+ * @return {ActionDescriptorInst<Model, Service, RunInput, RunResult, ValidationInput>} An instance of ActionDescriptorInst configured with the provided parameters.
+ */
+declare function action<Model, Service = undefined, RunInput = Model, RunResult = Model, ValidationInput = Model>(actionName: string, opts?: ActionDescriptorCreateOptsType<Model, Service, RunInput, RunResult, ValidationInput>): ActionDescriptorInst<Model, Service, RunInput, RunResult, ValidationInput>;
+
+type EditorDataProviderFetchFnType<Model = any, Service = undefined, Id = IdType, Return = ItemOrObservable<Model>> = (id: Id, service: Service, locale: string | undefined) => Return;
+type EditorDataProviderCreateFnType<CreateModel = any, Model = any, Service = undefined, Item = Undefined<CreateModel>, Return = ItemOrObservable<Undefined<Model>>> = (item: Item, service: Service) => Return;
+type EditorDataProviderUpdateFnType<UpdateModel = any, Model = any, Service = undefined, Id = IdType, Item = Undefined<UpdateModel>, Return = ItemOrObservable<Undefined<Model>>> = (id: Id, item: Item, service: Service) => Return;
+type EditorDataProviderDeleteFnType<Model = any, Service = undefined, Item = undefined, Id = IdType, Return = ItemOrObservable<Undefined<Model>>> = (id: Id, service: Service, item: Item) => Return;
+type EditorDataProviderFetchMapToFnType<FromModel, ToModel> = (item: FromModel) => ToModel;
+interface IEditorDataProviderFetch<Model, Service> {
+    fetch?: EditorDataProviderFetchFnType<Model, Service>;
+    withFetch(fn: EditorDataProviderFetchFnType<Model, Service>): this;
+}
+interface IEditorDataProviderCreate<CreateModel, Model, Service> {
+    create?: EditorDataProviderCreateFnType<CreateModel, Model, Service>;
+    withCreate(fn?: EditorDataProviderCreateFnType<CreateModel, Model, Service>): this;
+}
+interface IEditorDataProviderUpdate<UpdateModel, Model, Service> {
+    update?: EditorDataProviderUpdateFnType<UpdateModel, Model, Service>;
+    withUpdate(fn?: EditorDataProviderUpdateFnType<UpdateModel, Model, Service>): this;
+}
+interface IEditorDataProviderDelete<Model, Service> {
+    delete?: EditorDataProviderDeleteFnType<Model, Service, any>;
+    withDelete<Item = undefined>(fn?: EditorDataProviderDeleteFnType<Model, Service, Item>): this;
+}
+interface IEditorDataProviderFetchMapToCreate<Model, CreateModel> {
+    mapFetchItemToCreateItem?: EditorDataProviderFetchMapToFnType<Model, CreateModel>;
+    withMapFetchItemToCreateItem(fn?: EditorDataProviderFetchMapToFnType<Model, CreateModel>): this;
+}
+interface IEditorDataProviderFetchMapToUpdate<Model, UpdateModel> {
+    mapFetchItemToUpdateItem?: EditorDataProviderFetchMapToFnType<Model, UpdateModel>;
+    withMapFetchItemToUpdateItem(fn?: EditorDataProviderFetchMapToFnType<Model, UpdateModel>): this;
+}
+type IEditorDataProviderFnsType<Model, Service, CreateModel = Model, UpdateModel = Model, DeleteModel = Model> = IEditorDataProviderFetch<Model, Service> & IEditorDataProviderCreate<CreateModel, Model, Service> & IEditorDataProviderUpdate<UpdateModel, Model, Service> & IEditorDataProviderDelete<DeleteModel, Service> & IEditorDataProviderFetchMapToCreate<Model, CreateModel> & IEditorDataProviderFetchMapToUpdate<Model, UpdateModel>;
+interface IEditorDataProviderSupport<Model> {
+    get editorReset$(): Observable<EditorResetEvent<Model>>;
+    resetEditor(event?: EditorResetEvent<Model>): void;
+}
+type IEditorDataProvider<Model = any, Service = any, ServiceClass = ServiceClassOptType<Service>, CreateModel = Model, UpdateModel = Model> = IDataProvider<Model, Service, ServiceClass> & IEditorDataProviderFnsType<Model, Service, CreateModel, UpdateModel> & IEditorDataProviderSupport<Model>;
+declare class EditorDataProviderInst<Model, Service = any, ServiceClass = ServiceClassOptType<Service>, CreateModel = Model, UpdateModel = Model> extends DataProviderInst<Model, Service, ServiceClass> implements IEditorDataProvider<Model, Service, ServiceClass, CreateModel, UpdateModel> {
+    protected readonly _editorResetSubject: Subject<EditorResetEvent<Model>>;
+    protected _fetch?: EditorDataProviderFetchFnType<Model, Service>;
+    protected _create?: EditorDataProviderCreateFnType<CreateModel, Model, Service>;
+    protected _update?: EditorDataProviderUpdateFnType<UpdateModel, Model, Service>;
+    protected _delete?: EditorDataProviderDeleteFnType<Model, Service, any>;
+    protected _mapFetchItemToCreateItem?: EditorDataProviderFetchMapToFnType<Model, CreateModel>;
+    protected _mapFetchItemToUpdateItem?: EditorDataProviderFetchMapToFnType<Model, UpdateModel>;
+    constructor(serviceType: ServiceClass);
+    get fetch(): EditorDataProviderFetchFnType<Model, Service, IdType, ItemOrObservable<Model>> | undefined;
+    get create(): EditorDataProviderCreateFnType<CreateModel, Model, Service, Undefined<CreateModel>, ItemOrObservable<Undefined<Model>>> | undefined;
+    get update(): EditorDataProviderUpdateFnType<UpdateModel, Model, Service, IdType, Undefined<UpdateModel>, ItemOrObservable<Undefined<Model>>> | undefined;
+    get delete(): EditorDataProviderDeleteFnType<Model, Service, any, IdType, ItemOrObservable<Undefined<Model>>> | undefined;
+    get mapFetchItemToCreateItem(): EditorDataProviderFetchMapToFnType<Model, CreateModel> | undefined;
+    get mapFetchItemToUpdateItem(): EditorDataProviderFetchMapToFnType<Model, UpdateModel> | undefined;
+    get editorReset$(): Observable<EditorResetEvent<Model>>;
+    /**
+     * Sets the fetch function for the EditorDataProvider instance.
+     *
+     * @param {EditorDataProviderFetchFnType<Model, Service>} fn - The fetch function to be set.
+     * @returns {this} - The instance of the EditorDataProvider with the fetch function set.
+     *
+     * @typeparam Model The type of data this DataProvider will handle.
+     * @typeparam Service The type of service used by this DataProvider.
+     */
+    withFetch(fn: EditorDataProviderFetchFnType<Model, Service>): this;
+    /**
+     * Sets the create function for the EditorDataProvider.
+     *
+     * @param {EditorDataProviderCreateFnType<CreateModel, Model, Service>} fn - The function used for creating new items.
+     * @returns {this} - Returns the instance of the class.
+     *
+     * @typeparam Model The type of data this DataProvider will handle.
+     * @typeparam Service The type of service used by this DataProvider.
+     */
+    withCreate(fn?: EditorDataProviderCreateFnType<CreateModel, Model, Service>): this;
+    /**
+     * Sets the update function for the EditorDataProvider.
+     *
+     * @param {EditorDataProviderUpdateFnType<Model, Service>} fn - The update function to be set.
+     * @returns {this} - Returns the instance of the object calling this method.
+     *
+     * @typeparam Model The type of data this DataProvider will handle.
+     * @typeparam Service The type of service used by this DataProvider.
+     */
+    withUpdate(fn?: EditorDataProviderUpdateFnType<UpdateModel, Model, Service>): this;
+    /**
+     * Sets the delete function for the editor data provider.
+     *
+     * @param {EditorDataProviderDeleteFnType<Model, Service>} fn - The delete function to be set.
+     *
+     * @returns {this} - Returns the instance of the current class.
+     *
+     * @typeparam Model The type of data this DataProvider will handle.
+     * @typeparam Service The type of service used by this DataProvider.
+     */
+    withDelete<Item = undefined>(fn?: EditorDataProviderDeleteFnType<Model, Service, Item>): this;
+    /**
+     * Sets the function to map data from fetch function to create model.
+     *
+     * @param {EditorDataProviderFetchMapToFnType<Model, CreateModel>} fn - The map function to be set.
+     *
+     * @returns {this} - Returns the instance of the current class.
+     *
+     * @typeparam Model The type of data from fetch function to map from.
+     * @typeparam CreateModel The type of data to map to.
+     */
+    withMapFetchItemToCreateItem(fn?: EditorDataProviderFetchMapToFnType<Model, CreateModel>): this;
+    /**
+     * Sets the function to map data from fetch function to update model.
+     *
+     * @param {EditorDataProviderFetchMapToFnType<Model, UpdateModel>} fn - The map function to be set.
+     *
+     * @returns {this} - Returns the instance of the current class.
+     *
+     * @typeparam Model The type of data from fetch function to map from.
+     * @typeparam UpdateModel The type of data to map to.
+     */
+    withMapFetchItemToUpdateItem(fn?: EditorDataProviderFetchMapToFnType<Model, UpdateModel>): this;
+    resetEditor(event?: EditorResetEvent<Model>): void;
+}
+
+type ActionEditorDescriptorConstructorOptsType<Model, Service> = ActionDescriptorCreateOptsParentType & ActionEditorDescriptorCreateOptsProviderType<Model, Service> & {
+    model?: ModelDescriptor<Model>;
+    isTableviewMainEditor?: boolean;
+};
+type ActionEditorDescriptorCreateOptsProviderType<Model, Service> = {
+    serviceType?: ServiceClassType<Service>;
+    dataProvider?: IEditorDataProvider<Model, Service>;
+};
+declare class ActionEditorDescriptorInst<Item, Service = any, EditorItem = Item, FetchInputItem = Item, SubmitReturnItem = Item, ValidationInputItem = Item, ParentEditorItem = undefined> extends ActionDescriptorInst<Item, Service, EditorItem, SubmitReturnItem, ValidationInputItem> {
+    private readonly _editorDescriptor;
+    protected readonly _dataProvider?: IEditorDataProvider<Item, any>;
+    protected _editorActions: ActionDescriptorInst<any, any, EditorItem, any, EditorItem>[];
+    protected _editorTitle?: string | null;
+    protected _editorTitleParams?: any;
+    protected _fetchNotificationOnSuccess?: ActionNotificationType | boolean;
+    protected _fetchNotificationOnError?: ActionNotificationType | boolean;
+    protected _dialogSize: StyleSizeEnum;
+    protected _dialogClassName?: string;
+    protected _fetchFunction?: ActionEditorRunFnType<Item, ParentEditorItem, Service, FetchInputItem, EditorItem>;
+    protected _submitFunction?: ActionEditorRunFnType<Item, ParentEditorItem, Service, EditorItem, SubmitReturnItem>;
+    protected _editorComponent?: Type<any>;
+    protected _resubmitEnabled?: boolean;
+    protected _resubmitRefetch: boolean;
+    protected _unsavedChangesConfirmation: boolean;
+    constructor(editorDescriptor: EditorDescriptorInst<EditorItem, any>, actionName: string, cfg?: ActionEditorDescriptorConstructorOptsType<Item, Service>);
+    get editorTitle(): string | null | undefined;
+    get editorTitleParams(): any;
+    get editorDescriptor(): EditorDescriptorInst<EditorItem, ParentEditorItem>;
+    get dialogSize(): StyleSizeEnum;
+    get dialogClassName(): string | undefined;
+    get fetchNotificationOnSuccess(): boolean | ActionNotificationType | undefined;
+    get fetchNotificationOnError(): boolean | ActionNotificationType | undefined;
+    get dataProvider(): IEditorDataProvider<Item, any> | undefined;
+    get hasRunFunction(): boolean;
+    get runFunction(): ActionRunFnType<Item, Service, EditorItem, SubmitReturnItem>;
+    get hasFetchFunction(): boolean;
+    get fetchFunction(): ActionEditorRunFnType<Item, ParentEditorItem, Service, FetchInputItem, EditorItem> | undefined;
+    get hasSubmitFunction(): boolean;
+    get submitFunction(): ActionEditorRunFnType<Item, ParentEditorItem, Service, EditorItem, SubmitReturnItem> | undefined;
+    get editorActions(): ActionDescriptorInst<any, any, EditorItem, any, EditorItem>[];
+    get editorComponent(): Type<any> | undefined;
+    get resubmitEnabled(): boolean | undefined;
+    get resubmitRefetch(): boolean;
+    get unsavedChangesConfirmation(): boolean;
+    withEditorTitle(title: string | null, params?: any): this;
+    withDialogSize(size?: StyleSizeEnum): this;
+    withDialogClassName(className: string): this;
+    withRunFunction(fn: ActionEditorRunFnType<Item, ParentEditorItem, Service, EditorItem, SubmitReturnItem>): this;
+    withFetchFunction(fn: ActionEditorRunFnType<Item, ParentEditorItem, Service, FetchInputItem, EditorItem>): this;
+    withSubmitFunction(fn: ActionEditorRunFnType<Item, ParentEditorItem, Service, EditorItem, SubmitReturnItem>): this;
+    /**
+     * Override default notifications setup. Notifications can either be overridden with custom text or turned on/off.
+     *
+     * @param opts Provide config for texts or on/off flag for submit (is same as run) or fetch success/error notifications.
+     */
+    withNotifications(opts?: {
+        submitOnSuccess?: ActionNotificationType | boolean;
+        submitOnError?: ActionNotificationType | boolean;
+        runOnSuccess?: ActionNotificationType | boolean;
+        runOnError?: ActionNotificationType | boolean;
+        fetchOnSuccess?: ActionNotificationType | boolean;
+        fetchOnError?: ActionNotificationType | boolean;
+    } | boolean): this;
+    withEditorAction(action: ActionDescriptorInst<any, any, EditorItem, any, EditorItem>): this;
+    withEditorActions(actions: ActionDescriptorInst<any, any, EditorItem, any, EditorItem>[]): this;
+    withEditorComponent(editorComponent: Type<any>): this;
+    /**
+     * Enables or disables resubmit resubmit - this means the form will not exit after successful submission, but will instead remain open.
+     *
+     * @param {boolean} [enabled=true] - Specifies whether resubmit is enabled or disabled. Defaults to true if not provided.
+     * @param {boolean} [refetch=true] - Specifies whether the data should be refetched after resubmit. If not, the data in the form stays as is. Defaults to true if not provided.
+     *
+     * @returns {this} - Returns the current instance with the resubmit configuration updated.
+     */
+    withResubmit(enabled?: boolean, refetch?: boolean): this;
+    withUnsavedChangesConfirmation(unsavedChangesConfirmation?: boolean): this;
+    copyFieldsTo(descriptor: ActionEditorDescriptorInst<Item, Service, EditorItem, FetchInputItem, SubmitReturnItem, ValidationInputItem, ParentEditorItem>): ActionEditorDescriptorInst<Item, Service, EditorItem, FetchInputItem, SubmitReturnItem, ValidationInputItem, ParentEditorItem>;
+    copy(): ActionEditorDescriptorInst<Item, Service, EditorItem, FetchInputItem, SubmitReturnItem, ValidationInputItem, ParentEditorItem>;
+}
+declare class ActionEditorSubmitDescriptorInst<Model, EditorModel> extends ActionDescriptorInst<Model, undefined, EditorModel, EditorModel, EditorModel> {
+    private readonly _submitType;
+    constructor(editorActionName: string, editorActionModel: ModelDescriptor<Model> | undefined, submitType?: ActionEditorSubmitTypeEnum);
+    get submitType(): ActionEditorSubmitTypeEnum;
+    copy(): ActionEditorSubmitDescriptorInst<Model, EditorModel>;
+}
+/**
+ * creates primary action with primary button style
+ * @param editorAction
+ * @param submitType
+ */
+declare function actionEditorSubmit<Model, EditorModel>(editorAction: ActionEditorDescriptorInst<Model, any, EditorModel, any, any, any, any>, submitType?: ActionEditorSubmitTypeEnum): ActionEditorSubmitDescriptorInst<Model, EditorModel>;
+/**
+ * creates secondary button with text button style
+ * @param editorAction
+ * @param submitType
+ */
+declare function actionEditorCancel<Model, EditorModel>(editorAction: ActionEditorDescriptorInst<Model, any, EditorModel, any, any, any, any>, submitType?: ActionEditorSubmitTypeEnum): ActionEditorSubmitDescriptorInst<Model, EditorModel>;
+
+type ActionEditorProviderType<Model, Service> = ServiceClassType<Service> | IEditorDataProvider<Model, Service>;
+type ActionEditorDescriptorOptsType<Model, Service, FetchInput, SubmitReturn, ValidationInput> = ActionDescriptorCreateOptsParentType & {
+    model?: ModelDescriptor<Model>;
+    serviceProvider?: ActionEditorProviderType<Model, Service>;
+    fetchInputType?: TypeDescriptor<FetchInput>;
+    submitReturnType?: TypeDescriptor<SubmitReturn>;
+    validationType?: TypeDescriptor<ValidationInput>;
+};
+declare const actionEditorGetProviderCfgObj: <Model, Service>(serviceOrDataProvider?: ActionEditorProviderType<Model, Service>) => ActionEditorDescriptorCreateOptsProviderType<Model, Service>;
+/**
+ * Creates an ActionEditorDescriptorInst instance with the provided editor descriptor and options.
+ *
+ * @param {string} actionName - The name of the action to associate with the editor.
+ * @param {EditorDescriptorInst<EditorModel, any>} editor - The editor descriptor instance to be used.
+ * @param {ActionEditorDescriptorOptsType<Model, Service, FetchInput, SubmitReturn, ValidationInput>} [opts] - Optional configuration options for the ActionEditor.
+ * @return {ActionEditorDescriptorInst<Model, Service, EditorModel, FetchInput, SubmitReturn, ValidationInput>} An instance of ActionEditorDescriptor with the configured parameters.
+ */
+declare function actionEditor<EditorModel, Model = EditorModel, Service = undefined, FetchInput = Model, SubmitReturn = Model, ValidationInput = Model, ParentEditorItem = undefined>(actionName: string, editor: EditorDescriptorInst<EditorModel, ParentEditorItem>, opts?: ActionEditorDescriptorOptsType<Model, Service, FetchInput, SubmitReturn, ValidationInput>): ActionEditorDescriptorInst<Model, Service, EditorModel, FetchInput, SubmitReturn, ValidationInput, ParentEditorItem>;
+
+type ActionLinkDescriptorConstructorOpts<Model> = Omit<ActionDescriptorConstructorOptsType<Model, undefined>, 'serviceType' | 'dataProvider'>;
+declare class ActionLinkDescriptorInst<Item, ValidationInputItem = Item> extends ActionDescriptorInst<Item, undefined, undefined, undefined, ValidationInputItem> {
+    private _url;
+    private _pathSegments;
+    private _queryParams?;
+    private _queryParamsHandling?;
+    private _replaceUrl;
+    private _target;
+    private _isStyleLink;
+    constructor(actionName?: string, cfg?: ActionLinkDescriptorConstructorOpts<Item>);
+    get url(): string;
+    get pathSegments(): string[];
+    get queryParams(): Params | undefined;
+    get queryParamsHandling(): QueryParamsHandling | undefined;
+    get replaceUrl(): boolean;
+    get target(): string;
+    get isStyleLink(): boolean;
+    withHref(url: string): this;
+    withRouterLink(...pathSegments: string[]): this;
+    withQueryParams(queryParams: Params, queryParamsHandling?: QueryParamsHandling): this;
+    withReplaceUrl(replaceUrl?: boolean): this;
+    withTarget(target?: '_self' | '_blank'): this;
+    withStyleLink(isStyleLink: boolean): this;
+    copy(): ActionLinkDescriptorInst<Item, ValidationInputItem>;
+}
+
+type ActionLinkCreateOptsType<Model, ValidationInput> = ActionDescriptorCreateOptsParentType & {
+    model?: ModelDescriptor<Model>;
+    validationType?: TypeDescriptor<ValidationInput>;
+};
+/**
+ * Creates an instance of ActionLinkDescriptorInst with the provided action name and options.
+ *
+ * @param {string} actionName - The unique name of the action.
+ * @param {ActionLinkCreateOptsType<Model, ValidationInput>} [opts] - Optional parameters for configuring the action link, including the model and validation type.
+ * @return {ActionLinkDescriptorInst<Model, ValidationInput>} An instance of ActionLinkDescriptorInst initialized with the action name and options.
+ */
+declare function actionLink<Model = any, ValidationInput = Model>(actionName: string, opts?: ActionLinkCreateOptsType<Model, ValidationInput>): ActionLinkDescriptorInst<Model, ValidationInput>;
+/**
+ * Generates an ActionLinkDescriptorInst from the provided ActionDescriptorInst.
+ *
+ * @param {ActionDescriptorInst<Model, any, any, any, ValidationInput>} action - The action descriptor instance that serves as the basis for the action link.
+ * @return {ActionLinkDescriptorInst<Model, ValidationInput>} A newly created ActionLinkDescriptorInst configured with the provided action parameters.
+ */
+declare function actionLinkFromAction<Model, ValidationInput = Model>(action: ActionDescriptorInst<Model, any, any, any, ValidationInput>): ActionLinkDescriptorInst<Model, ValidationInput>;
+
+/**
+ * Defines an action to be positioned on a specified editor with editor-specific execution context.
+ *
+ * @param {string} actionName - The name identifying the action to be performed.
+ * @param {EditorDescriptorInst<EditorModel>} editor - The descriptor of the editor on which the action will be placed and executed.
+ * @param {Object} [opts] - Options for configuring the action behavior.
+ * @param {ModelDescriptor<Model>} [opts.model] - The model descriptor associated with the action.
+ * @param {ActionProviderType<Model, Service>} [opts.serviceProvider] - The service provider type for execution context.
+ * @param {ActionPositionEnum.FooterLeft | ActionPositionEnum.FooterRight | ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight} [opts.position] - The position of action on editor.
+ * @return {ActionDescriptorInst<Model, Service, EditorModel, Model, EditorModel>} - An instance representing the configured action descriptor for the specified editor and model.
+ */
+declare function actionOnEditor<Model, EditorModel, Service = undefined>(actionName: string, editor: EditorDescriptorInst<EditorModel, any>, opts?: {
+    model?: ModelDescriptor<Model>;
+    serviceProvider?: ActionProviderType<Model, Service>;
+    position?: ActionPositionEnum.FooterLeft | ActionPositionEnum.FooterRight | ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight;
+}): ActionDescriptorInst<Model, Service, EditorModel, Model, EditorModel>;
+
+/**
+ * Creates and returns an instance of `ActionEditorDescriptorInst` when positioned on another (parent) editor.
+ *
+ * @param {string} actionName - The name of the action associated with the editor.
+ * @param {EditorDescriptorInst<EditorModel, ParentEditor>} editor - The editor descriptor defining editor on action.
+ * @param {Object} [opts] - Optional parameters for configuring the action editor.
+ * @param {ModelDescriptor<Model>} [opts.model] - The descriptor for the model associated with the action.
+ * @param {ActionEditorProviderType<Model, Service>} [opts.serviceProvider] - The service provider type for the action editor.
+ * @param {ActionPositionEnum.FooterLeft | ActionPositionEnum.FooterRight | ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight} [opts.position] - The desired position of action on the editor.
+ * @return {ActionEditorDescriptorInst<Model, Service, EditorModel, ParentEditor, EditorModel, ParentEditor>} A configured instance of `ActionEditorDescriptorInst` representing the action editor.
+ */
+declare function actionEditorOnEditor<EditorModel, ParentEditor, Model = EditorModel, Service = undefined>(actionName: string, editor: EditorDescriptorInst<EditorModel, ParentEditor>, opts?: {
+    model?: ModelDescriptor<Model>;
+    serviceProvider?: ActionEditorProviderType<Model, Service>;
+    position?: ActionPositionEnum.FooterLeft | ActionPositionEnum.FooterRight | ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight;
+}): ActionEditorDescriptorInst<Model, Service, EditorModel, ParentEditor, EditorModel, ParentEditor, ParentEditor>;
+
+/**
+ * Defines an action to be positioned on a specified table with table row execution context.
+ *
+ * @param {string} actionName - The name identifying the action to be performed.
+ * @param {TableDescriptorInst<TableModel, any, any>} table - The descriptor of the table on which the action will be placed and executed.
+ * @param {Object} [opts] - Options for configuring the action behavior.
+ * @param {ModelDescriptor<Model>} [opts.model] - The model descriptor associated with the action.
+ * @param {ActionProviderType<Model, Service>} [opts.serviceProvider] - The service provider type for execution context.
+ * @param {ActionPositionEnum.RowInline | ActionPositionEnum.RowClick} [opts.position] - The position of action on table.
+ * @return {ActionDescriptorInst<Model, Service, TableModel, Model, TableModel>} - An instance representing the configured action descriptor for the specified table row and model.
+ */
+declare function actionOnTableRow<Model, TableModel, Service = undefined>(actionName: string, table: TableDescriptorInst<TableModel, any, any>, opts?: {
+    model?: ModelDescriptor<Model>;
+    serviceProvider?: ActionProviderType<Model, Service>;
+    position?: ActionPositionEnum.RowInline | ActionPositionEnum.RowClick;
+}): ActionDescriptorInst<Model, Service, TableModel, Model, TableModel>;
+/**
+ * Defines an action to be positioned on a specified table with table header or footer execution context.
+ *
+ * @param {string} actionName - The name identifying the action to be performed.
+ * @param {Object} [opts] - Options for configuring the action behavior.
+ * @param {ModelDescriptor<Model>} [opts.model] - The model descriptor associated with the action.
+ * @param {ActionProviderType<Model, Service>} [opts.serviceProvider] - The service provider type for execution context.
+ * @param {ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight | ActionPositionEnum.TableHeader} [opts.position] - The position of action on table.
+ * @return {ActionDescriptorInst<Model, Service, TableModel, Model, TableModel>} - An instance representing the configured action descriptor for the specified table top and model.
+ */
+declare function actionOnTableTop<Model, Service = undefined>(actionName: string, opts?: {
+    model?: ModelDescriptor<Model>;
+    serviceProvider?: ActionProviderType<Model, Service>;
+    position?: ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight | ActionPositionEnum.TableHeader;
+}): ActionDescriptorInst<Model, Service, undefined, Model, undefined>;
+
+/**
+ * Creates and returns an ActionEditorDescriptorInst for displaying editor action on table row.
+ *
+ * @param {string} actionName - The name of the action.
+ * @param {EditorDescriptorInst<EditorModel, any>} editor - The editor descriptor instance responsible for configuring the editor behavior.
+ * @param {TableDescriptorInst<TableModel, any, any>} table - The table descriptor instance representing the table on which the action is positioned.
+ * @param {Object} [opts] - Optional configurations for the action editor.
+ * @param {ModelDescriptor<Model>} [opts.model] - The model descriptor associated with the action editor.
+ * @param {ActionEditorProviderType<Model, Service>} [opts.serviceProvider] - The service provider for additional configurations or services for the action editor.
+ * @param {ActionPositionEnum.RowInline | ActionPositionEnum.RowClick} [opts.position] - The position where the action should be displayed on the table row.
+ * @return {ActionEditorDescriptorInst<Model, Service, EditorModel, TableModel, EditorModel, TableModel>} The configured action editor descriptor instance.
+ */
+declare function actionEditorOnTableRow<EditorModel, ParentEditorItem, TableModel, Model = EditorModel, Service = undefined>(actionName: string, editor: EditorDescriptorInst<EditorModel, ParentEditorItem>, table: TableDescriptorInst<TableModel, any, any>, opts?: {
+    model?: ModelDescriptor<Model>;
+    serviceProvider?: ActionEditorProviderType<Model, Service>;
+    position?: ActionPositionEnum.RowInline | ActionPositionEnum.RowClick;
+}): ActionEditorDescriptorInst<Model, Service, EditorModel, TableModel, EditorModel, TableModel, ParentEditorItem>;
+/**
+ * Creates and returns an action editor descriptor configured with the given parameters.
+ * This is used to define an action editor positioned relative to a table.
+ *
+ * @param {string} actionName - The name of the action.
+ * @param {EditorDescriptorInst<EditorModel, any>} editor - The editor descriptor instance responsible for configuring the editor behavior.
+ * @param {Object} [opts] - Optional configurations for the action editor.
+ * @param {ModelDescriptor<Model>} [opts.model] - The model descriptor associated with the action editor.
+ * @param {ActionEditorProviderType<Model, Service>} [opts.serviceProvider] - The service provider for additional configurations or services for the action editor.
+ * @param {ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight | ActionPositionEnum.TableHeader} [opts.position] - The position of the action on the table.
+ * @return {ActionEditorDescriptorInst<Model, Service, EditorModel, undefined, EditorModel, undefined>} The configured action editor descriptor instance.
+ */
+declare function actionEditorOnTableTop<EditorModel, ParentEditorItem, Model = EditorModel, Service = undefined>(actionName: string, editor: EditorDescriptorInst<EditorModel, ParentEditorItem>, opts?: {
+    model?: ModelDescriptor<Model>;
+    serviceProvider?: ActionEditorProviderType<Model, Service>;
+    position?: ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight | ActionPositionEnum.TableHeader;
+}): ActionEditorDescriptorInst<Model, Service, EditorModel, undefined, EditorModel, undefined, ParentEditorItem>;
+
+declare function runFnFromDataProviderOrFallback<Item, ParameterItem, Service, Return, FallbackReturn = Return>(ctx: IActionContext<Item, ParameterItem, Service>, fn: (ctx: IActionContext<Item, ParameterItem, Service>) => Observable<Return> | null, fallback: Observable<FallbackReturn>): Observable<Return | FallbackReturn>;
+declare function runFnFromDataProviderOrFail<Item, ParameterItem, Service, Return>(ctx: IActionContext<Item, ParameterItem, Service>, fn: (ctx: IActionContext<Item, ParameterItem, Service>) => Observable<Return> | null): Observable<Return>;
+declare function runGetAllFromDataProvider<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<DataListResult<Item>> | null;
+type RunFetchFromDataProviderOptsType = {
+    strict?: boolean;
+    reason?: RunFetchFromDataProviderReasonType;
+};
+type RunFetchFromDataProviderReasonType = 'create' | 'update' | 'fetch';
+declare function runFetchFromDataProvider<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, opts?: RunFetchFromDataProviderOptsType): Observable<Item> | null;
+declare function runCreateFromDataProvider<Item, ParameterItem, Service>(ctx: IActionContext<Item, ParameterItem, Service>): Observable<Nullable<Item>> | null;
+declare function runUpdateFromDataProvider<Item, ParameterItem, service>(ctx: IActionContext<Item, ParameterItem, service>): Observable<Nullable<Item>> | null;
+declare function runDeleteFromDataProvider<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<Nullable<Item>> | null;
+/**
+ * Gets service instance of data provider.
+ *
+ * @param injector Injector instance
+ * @param dataProvider Data provider instance.
+ */
+declare function getDataProviderService<Item, Service>(injector: Injector, dataProvider?: IDataProvider<Item, Service>): Service | null;
+
+interface CommonsActionErrorOptions extends CommonsErrorBaseOptions {
+    actionContext?: IActionContext<any, any, any>;
+    httpError?: HttpErrorResponse;
+}
+declare class CommonsActionError extends ACommonsErrorBase implements ICommonsActionError {
+    readonly type = "CommonsActionError";
+    readonly actionId: string;
+    readonly actionContext?: IActionContext<any, any>;
+    readonly httpError?: HttpErrorResponse;
+    constructor(message: string, actionName: string, options?: CommonsActionErrorOptions);
+}
+
+/**
+ * Default categories for tableview actions
+ */
+declare class TableviewActionDefaultCategories {
+    static readonly READ = "_defaultTwRead";
+    static readonly ADD = "_defaultTwAdd";
+    static readonly EDIT = "_defaultTwEdit";
+    static readonly DELETE = "_defaultTwDelete";
+    static readonly DETAILS = "_defaultTwDetails";
+}
+
+declare const DATA_LANGUAGE_DROPDOWN_COMPONENT_IT: InjectionToken<Type<any>>;
+
+declare abstract class DataProviderExecutor {
+    runGetAllOrFail<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<DataListResult<Item>>;
+    abstract runGetAll<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<DataListResult<Item>> | null;
+    abstract runGetAll<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: Observable<DataListResult<Item>>): Observable<DataListResult<Item>>;
+    abstract runGetAll<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: undefined): Observable<DataListResult<Item>> | null;
+    abstract runGetAll<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback?: Observable<DataListResult<Item>>): Observable<DataListResult<Item>> | null;
+    runFetchOrFail<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fetchReason?: RunFetchFromDataProviderReasonType): Observable<Item>;
+    abstract runFetch<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fetchReason?: RunFetchFromDataProviderReasonType): Observable<Item> | null;
+    abstract runFetch<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fetchReason: RunFetchFromDataProviderReasonType | undefined, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
+    abstract runFetch<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fetchReason: RunFetchFromDataProviderReasonType | undefined, fallback: undefined): Observable<Nullable<Item>> | null;
+    abstract runFetch<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fetchReason: RunFetchFromDataProviderReasonType | undefined, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
+    runCreateOrFail<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<Item>;
+    abstract runCreate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<Item> | null;
+    abstract runCreate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
+    abstract runCreate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: undefined): Observable<Nullable<Item>> | null;
+    abstract runCreate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
+    runUpdateOrFail<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<Item>;
+    abstract runUpdate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<Item> | null;
+    abstract runUpdate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
+    abstract runUpdate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: undefined): Observable<Nullable<Item>> | null;
+    abstract runUpdate<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
+    runDeleteOrFail<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<Item | null>;
+    abstract runDelete<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>): Observable<Nullable<Item>> | null;
+    abstract runDelete<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: Observable<Nullable<Item>>): Observable<Nullable<Item>>;
+    abstract runDelete<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback: undefined): Observable<Nullable<Item>> | null;
+    abstract runDelete<Item, ParametersItem, Service>(ctx: IActionContext<Item, ParametersItem, Service>, fallback?: Observable<Nullable<Item>>): Observable<Nullable<Item>> | null;
+    /**
+     * Gets service instance of data provider.
+     *
+     * @param injector Injector instance
+     * @param dataProvider Data provider instance.
+     */
+    getDataProviderService<Item, Service>(injector: Injector, dataProvider?: IDataProvider<Item, Service>): Service | null;
+}
+
+/**
+ * Creates and returns an instance of `EditorDataProviderInst` with the specified options for managing editor data.
+ *
+ * @param {Object} [opts] - The options object to configure the data provider.
+ * @param {TypeDescriptor<Model> | ModelDescriptor<Model>} [opts.type] - The descriptor defining the type of model.
+ * @param {ServiceClassType<Service>} [opts.service] - The service class type associated with the data provider.
+ * @param {TypeDescriptor<CreateModel> | ModelDescriptor<CreateModel>} [opts.createType] - The descriptor defining the create type.
+ * @param {TypeDescriptor<UpdateModel> | ModelDescriptor<UpdateModel>} [opts.updateType] - The descriptor defining the update type.
+ * @return {EditorDataProviderInst<Model, Service, ServiceClass, CreateModel, UpdateModel>} An instance of `EditorDataProviderInst` configured according to the provided options.
+ */
+declare function editorDataProvider<Model, Service = undefined, CreateModel = Model, UpdateModel = Model, ServiceClass = Service extends undefined ? undefined : ServiceClassType<Service>>(opts?: {
+    type?: TypeDescriptor<Model> | ModelDescriptor<Model>;
+    service?: ServiceClassType<Service>;
+    createType?: TypeDescriptor<CreateModel> | ModelDescriptor<Model>;
+    updateType?: TypeDescriptor<UpdateModel> | ModelDescriptor<Model>;
+}): EditorDataProviderInst<Model, Service, ServiceClass, CreateModel, UpdateModel>;
+
+type EditorDescriptorCreateBaseOptsType<ParentEditorModel> = {
+    tableviewEditorType?: TableviewEditorTypeEnum;
+    parentEditorType?: TypeDescriptor<ParentEditorModel> | ModelDescriptor<ParentEditorModel> | EditorDescriptorInst<ParentEditorModel, any>;
+};
+type EditorDescriptorCreateOptsType<EditorModel, ParentEditorModel> = ModelDescriptorCreateOpts<EditorModel> & EditorDescriptorCreateBaseOptsType<ParentEditorModel>;
+declare function editorDescriptor<EditorModel, ParentEditorModel = undefined>(): EditorDescriptorInst<EditorModel, ParentEditorModel>;
+declare function editorDescriptor<EditorModel, ParentEditorModel = undefined>(opts: EditorDescriptorCreateOptsType<EditorModel, ParentEditorModel>): EditorDescriptorInst<EditorModel, ParentEditorModel>;
+declare function editorDescriptor<EditorModel, ParentEditorModel = undefined>(model: ModelDescriptor<EditorModel>, opts?: EditorDescriptorCreateBaseOptsType<ParentEditorModel>): EditorDescriptorInst<EditorModel, ParentEditorModel>;
+
+type ITableviewDataProvider<Model = any, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model, ServiceClass = ServiceClassOptType<Service>, TableModel = Model, CreateModel = Model, UpdateModel = Model> = IEditorDataProvider<Model, Service, ServiceClass, CreateModel, UpdateModel> & ITableDataProvider<TableModel, Service, Sorts, Filters, ServiceClass>;
+declare class TableviewDataProviderInst<Model, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model, ServiceClass = ServiceClassOptType<Service>, TableModel = Model, CreateModel = Model, UpdateModel = Model> extends DataProviderInst<Model, Service, ServiceClass> implements ITableviewDataProvider<Model, Service, Sorts, Filters, ServiceClass, TableModel, CreateModel, UpdateModel>, IEditorDataProvider<Model, Service, ServiceClass, CreateModel, UpdateModel> {
+    protected readonly editorDataProvider: EditorDataProviderInst<Model, Service, ServiceClass, CreateModel, UpdateModel>;
+    protected readonly tableDataProvider: TableDataProviderInst<TableModel, Service, Sorts, Filters, ServiceClass>;
+    constructor(serviceType: ServiceClass);
+    get isLazy(): boolean;
+    get tableReload$(): rxjs.Observable<TableReloadEvent<Sorts, Filters>>;
+    get editorReset$(): rxjs.Observable<EditorResetEvent<Model>>;
+    get getAll(): TableDataProviderGetAllFnType<TableModel, Service, Sorts, Filters, _mediusinc_mng_commons_core.ItemOrObservable<_mediusinc_mng_commons_core.DataListResult<TableModel>>>;
+    get fetch(): EditorDataProviderFetchFnType<Model, Service, _mediusinc_mng_commons_core.IdType, _mediusinc_mng_commons_core.ItemOrObservable<Model>> | undefined;
+    get create(): EditorDataProviderCreateFnType<CreateModel, Model, Service, _mediusinc_mng_commons_core.Undefined<CreateModel>, _mediusinc_mng_commons_core.ItemOrObservable<_mediusinc_mng_commons_core.Undefined<Model>>> | undefined;
+    get update(): EditorDataProviderUpdateFnType<UpdateModel, Model, Service, _mediusinc_mng_commons_core.IdType, _mediusinc_mng_commons_core.Undefined<UpdateModel>, _mediusinc_mng_commons_core.ItemOrObservable<_mediusinc_mng_commons_core.Undefined<Model>>> | undefined;
+    get delete(): EditorDataProviderDeleteFnType<Model, Service, any, _mediusinc_mng_commons_core.IdType, _mediusinc_mng_commons_core.ItemOrObservable<_mediusinc_mng_commons_core.Undefined<Model>>> | undefined;
+    get mapFetchItemToCreateItem(): EditorDataProviderFetchMapToFnType<Model, CreateModel> | undefined;
+    get mapFetchItemToUpdateItem(): EditorDataProviderFetchMapToFnType<Model, UpdateModel> | undefined;
+    withGetAll(fn: TableDataProviderGetAllFnType<TableModel, Service, Sorts, Filters>): this;
+    withGetAllEagerly(fn: TableDataProviderGetAllEagerFnType<TableModel, Service>): this;
+    withFetch(fn: EditorDataProviderFetchFnType<Model, Service>): this;
+    withCreate(fn?: EditorDataProviderCreateFnType<CreateModel, Model, Service>): this;
+    withUpdate(fn?: EditorDataProviderUpdateFnType<UpdateModel, Model, Service>): this;
+    withDelete<Item = undefined>(fn?: EditorDataProviderDeleteFnType<Model, Service, Item>): this;
+    withMapFetchItemToCreateItem(fn?: EditorDataProviderFetchMapToFnType<Model, CreateModel>): this;
+    withMapFetchItemToUpdateItem(fn?: EditorDataProviderFetchMapToFnType<Model, UpdateModel>): this;
+    reloadTable(event?: TableReloadEvent<Sorts, Filters>): void;
+    resetEditor(event?: EditorResetEvent<Model>): void;
+}
+declare class DynamicTableviewDataProviderInst<Service = any, ServiceClass = ServiceClassOptType<Service>> extends TableviewDataProviderInst<any, Service, any, any, ServiceClass> {
+    constructor(serviceType: ServiceClass);
+}
+
+/**
+ * Creates and returns an instance of `TableviewDataProviderInst` with the specified options for managing tableview data.
+ *
+ * @param {Object} [opts] - The options object to configure the data provider.
+ * @param {TypeDescriptor<Model> | ModelDescriptor<Model>} [opts.type] - The descriptor defining the type of model.
+ * @param {ServiceClassType<Service>} [opts.service] - The service class type associated with the data provider.
+ * @param {TypeDescriptor<CreateModel> | ModelDescriptor<CreateModel>} [opts.filtersType] - The descriptor defining the filters type.
+ * @param {TypeDescriptor<UpdateModel> | ModelDescriptor<UpdateModel>} [opts.sortsType] - The descriptor defining the sorts type.
+ * @return {TableviewDataProviderInst<Model, Service, Sorts, Filters, ServiceClass, TableModel, CreateModel, UpdateModel>} An instance of `TableviewDataProviderInst` configured according to the provided options.
+ */
+declare function tableviewDataProvider<Model, Service = undefined, Sorts = keyof Model, Filters extends keyof any = keyof Model, TableModel = Model, CreateModel = Model, UpdateModel = Model, ServiceClass = Service extends undefined ? undefined : ServiceClassType<Service>>(opts?: {
+    type?: TypeDescriptor<Model> | ModelDescriptor<Model>;
+    service?: ServiceClassType<Service>;
+    tableType?: TypeDescriptor<TableModel> | ModelDescriptor<TableModel>;
+    createType?: TypeDescriptor<CreateModel> | ModelDescriptor<Model>;
+    updateType?: TypeDescriptor<UpdateModel> | ModelDescriptor<Model>;
+    filtersType?: TypeDescriptor<Filters> | ModelDescriptor<Filters>;
+    sortsType?: TypeDescriptor<Sorts> | ModelDescriptor<Sorts>;
+}): TableviewDataProviderInst<Model, Service, Sorts, Filters, ServiceClass, TableModel, CreateModel, UpdateModel>;
+declare function tableviewDynamicDataProvider(): DynamicTableviewDataProviderInst<undefined, undefined>;
+declare function tableviewDynamicDataProvider<Service>(serviceType: ServiceClassType<Service>): DynamicTableviewDataProviderInst<Service, ServiceClassType<Service>>;
+
+type TableviewDescriptorCreateSortsFiltersParentOptsType<Model, Sorts = keyof Model, Filters = keyof Model, ParentEditorModel = undefined> = {
+    filtersType?: TypeDescriptor<Filters> | ModelDescriptor<Filters>;
+    sortsType?: TypeDescriptor<Sorts> | ModelDescriptor<Filters>;
+    parentEditorType?: TypeDescriptor<ParentEditorModel> | ModelDescriptor<ParentEditorModel> | EditorDescriptorInst<ParentEditorModel, any> | TableviewDescriptorInst<ParentEditorModel, any, any, any, any, ParentEditorModel, ParentEditorModel, ParentEditorModel>;
+};
+type TableviewDescriptorCreateOptsType<Model, Sorts = keyof Model, Filters = keyof Model, ParentEditorModel = undefined> = TableviewDescriptorCreateSortsFiltersParentOptsType<Model, Sorts, Filters, ParentEditorModel>;
+type TableviewDescriptorCreateWithModelDescriptorOptsType<Model, Sorts = keyof Model, Filters = keyof Model, ParentEditorModel = undefined> = TableviewDescriptorCreateOptsType<Model, Sorts, Filters, ParentEditorModel> & ModelDescriptorCreateOpts<Model>;
+declare function tableviewDescriptor<Model, Sorts = keyof Model, Filters = keyof Model, ParentEditorModel = undefined, TableModel = Model>(): TableviewDescriptorInst<Model, Sorts, Filters, ParentEditorModel, TableModel, Model, Model, Model>;
+declare function tableviewDescriptor<Model, Sorts = keyof Model, Filters = keyof Model, ParentEditorModel = undefined, TableModel = Model>(opts: TableviewDescriptorCreateWithModelDescriptorOptsType<Model, Sorts, Filters, ParentEditorModel>): TableviewDescriptorInst<Model, Sorts, Filters, ParentEditorModel, TableModel, Model, Model, Model>;
+declare function tableviewDescriptor<Model, Sorts = keyof Model, Filters = keyof Model, ParentEditorModel = undefined, TableModel = Model>(opts: TableviewDescriptorCreateWithModelDescriptorOptsType<Model, Sorts, Filters, ParentEditorModel>): TableviewDescriptorInst<Model, Sorts, Filters, ParentEditorModel, TableModel, Model, Model, Model>;
+declare function tableviewDescriptor<Model, Sorts = keyof Model, Filters = keyof Model, ParentEditorModel = undefined, TableModel = Model>(model: ModelDescriptor<Model>, opts?: TableviewDescriptorCreateOptsType<Model, Sorts, Filters, ParentEditorModel>): TableviewDescriptorInst<Model, Sorts, Filters, ParentEditorModel, TableModel, Model, Model, Model>;
+type TableviewDescriptorMultiModelCreateOptsType<Model, Sorts = keyof Model, Filters = keyof Model, ParentEditorModel = undefined, TableModel = Model, AddModel = Model, EditModel = Model> = TableviewDescriptorCreateSortsFiltersParentOptsType<Model, Sorts, Filters, ParentEditorModel> & TableviewDescriptorInstConstructorOpts<TableModel, AddModel, EditModel>;
+type TableviewDescriptorCreateMultiModelWithModelDescriptorOptsType<Model, Sorts = keyof Model, Filters = keyof Model, ParentEditorModel = undefined, TableModel = Model, AddModel = Model, EditModel = Model> = TableviewDescriptorMultiModelCreateOptsType<Model, Sorts, Filters, ParentEditorModel, TableModel, AddModel, EditModel> & ModelDescriptorCreateOpts<Model>;
+declare function tableviewDescriptorMultiModel<Model, Sorts = keyof Model, Filters = keyof Model, ParentEditorModel = undefined, TableModel = Model, AddModel = Model, EditModel = Model>(): TableviewDescriptorInst<Model, Sorts, Filters, ParentEditorModel, TableModel, AddModel, EditModel, TableviewDescriptorFieldsManageMultiType<Model, AddModel, EditModel>>;
+declare function tableviewDescriptorMultiModel<Model, Sorts = keyof Model, Filters = keyof Model, ParentEditorModel = undefined, TableModel = Model, AddModel = Model, EditModel = Model>(opts: TableviewDescriptorCreateMultiModelWithModelDescriptorOptsType<Model, Sorts, Filters, ParentEditorModel, TableModel, AddModel, EditModel>): TableviewDescriptorInst<Model, Sorts, Filters, ParentEditorModel, TableModel, AddModel, EditModel>;
+declare function tableviewDescriptorMultiModel<Model, Sorts = keyof Model, Filters = keyof Model, ParentEditorModel = undefined, TableModel = Model, AddModel = Model, EditModel = Model>(opts: TableviewDescriptorCreateMultiModelWithModelDescriptorOptsType<Model, Sorts, Filters, ParentEditorModel, TableModel, AddModel, EditModel>): TableviewDescriptorInst<Model, Sorts, Filters, ParentEditorModel, TableModel, AddModel, EditModel>;
+declare function tableviewDescriptorMultiModel<Model, Sorts = keyof Model, Filters = keyof Model, ParentEditorModel = undefined, TableModel = Model, AddModel = Model, EditModel = Model>(model: ModelDescriptor<Model>, opts?: TableviewDescriptorMultiModelCreateOptsType<Model, Sorts, Filters, ParentEditorModel, TableModel, AddModel, EditModel>): TableviewDescriptorInst<Model, Sorts, Filters, ParentEditorModel, TableModel, AddModel, EditModel>;
+declare function tableviewDynamicDescriptor(modelOrOpts?: ModelDescriptor<any> | TableviewDescriptorCreateMultiModelWithModelDescriptorOptsType<any>): TableviewDynamicDescriptorInt;
+
+declare function convertDataToStringWithDelimiter(data: any[], delimiter: string, descriptor: TableviewDescriptorInst<any, any, any>, translate: TranslateService): string;
+declare function saveFileAs(blob: Blob, filename: string): void;
+
+interface TableviewInput<Model, Service, Sorts = keyof Model, Filters extends keyof any = keyof Model, TableModel = Model, AddModel = Model, EditModel = Model, Descriptor = TableviewDescriptorInst<Model, Sorts, Filters, undefined, TableModel, AddModel, EditModel>, DataProvider = ITableviewDataProvider<Model, Service, Sorts, Filters, any, TableModel, AddModel, EditModel>> {
+    descriptor: Descriptor;
+    dataProvider: DataProvider;
+    actions: ActionDescriptorInst<Model>[];
+}
+
+declare enum TableviewDefaultActionsEnum {
+    Details = 0,
+    Add = 1,
+    Edit = 2,
+    EditOnDetails = 3,
+    Delete = 4,
+    DeleteOnDetails = 5,
+    Refresh = 6,
+    Export = 7,
+    ExportJson = 8,
+    ExportCsv = 9,
+    LocalizationLanguageSelect = 10
+}
+declare function tableviewGetDefaultActions(): TableviewDefaultActionsEnum[];
+declare function tableviewCreateDefaultActions(tableview: TableviewDescriptorInst<any, any, any>, defaultActions?: TableviewDefaultActionsEnum[], defaultActionsOverrides?: Record<number, ActionDescriptorInst<any>>, injector?: Injector | null): Array<ActionDescriptorInst<any>>;
+declare function tableviewCreateDefaultAction(type: TableviewDefaultActionsEnum, tableview: TableviewDescriptorInst<any, any, any>, defaultActions?: TableviewDefaultActionsEnum[], defaultActionsOverrides?: Record<number, ActionDescriptorInst<any>>, injector?: Injector | null): ActionDescriptorInst<any> | null;
+declare const tableviewActionEditorDetailsActionName = "details";
+declare const tableviewActionEditorDetailsRoute = ":itemId";
+type TableviewActionDetailsOnTableOptsType<Model, TableModel, Service> = {
+    table?: TableDescriptorInst<TableModel>;
+    serviceProvider?: ActionEditorProviderType<Model, Service>;
+    injector?: Injector | null;
+    position?: ActionPositionEnum.RowInline | ActionPositionEnum.RowClick;
+};
+declare function tableviewActionDetailsOnTable<Model, TableModel, Service = undefined>(model: ModelDescriptor<Model>, descriptor: EditorDescriptorInst<Model>, opts?: TableviewActionDetailsOnTableOptsType<Model, TableModel, Service>): ActionEditorDescriptorInst<Model, Service, Model, TableModel, undefined, TableModel> | null;
+declare const tableviewActionEditorAddActionName = "add";
+declare const tableviewActionEditorAddRoute = "add";
+type ActionEditorProviderAddType<Model, AddModel, Service> = ServiceClassType<Service> | IEditorDataProvider<Model, Service, any, AddModel, any>;
+type TableviewActionAddOnTableOptsType<Model, AddModel, Service> = {
+    serviceProvider?: ActionEditorProviderAddType<Model, AddModel, Service>;
+    injector?: Injector | null;
+    position?: ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight;
+};
+declare function tableviewActionAddOnTable<Model, AddModel, Service = undefined>(model: ModelDescriptor<Model>, descriptor: EditorDescriptorInst<AddModel>, opts?: TableviewActionAddOnTableOptsType<Model, AddModel, Service>): ActionEditorDescriptorInst<Model, Service, AddModel, undefined, Model, undefined> | null;
+declare const tableviewActionEditorEditActionName = "edit";
+declare const tableviewActionEditorEditRoute = ":itemId/edit";
+type ActionEditorProviderEditType<Model, EditModel, Service> = ServiceClassType<Service> | IEditorDataProvider<Model, Service, any, any, EditModel>;
+type TableviewActionEditOnTableOptsType<Model, EditModel, TableModel, Service> = {
+    table?: TableDescriptorInst<TableModel, any, any>;
+    serviceProvider?: ActionEditorProviderEditType<Model, EditModel, Service>;
+    injector?: Injector | null;
+    position?: ActionPositionEnum.RowClick | ActionPositionEnum.RowInline;
+};
+declare function tableviewActionEditOnTable<Model, EditModel, TableModel, Service = undefined>(model: ModelDescriptor<Model>, descriptor: EditorDescriptorInst<EditModel>, opts?: TableviewActionEditOnTableOptsType<Model, EditModel, TableModel, Service>): ActionEditorDescriptorInst<Model, Service, EditModel, TableModel, Model, TableModel> | null;
+type TableviewActionEditOnDetailsOptsType = {
+    injector?: Injector | null;
+    position?: ActionPositionEnum.FooterLeft | ActionPositionEnum.FooterRight;
+};
+declare function tableviewActionEditOnDetails<Model>(model: ModelDescriptor<Model>, opts?: TableviewActionEditOnDetailsOptsType): ActionLinkDescriptorInst<Model> | null;
+declare const tableviewActionDeleteActionName = "delete";
+type TableviewActionDeleteOnTableOptsType<Model, TableModel, Service> = {
+    injector?: Injector | null;
+    table?: TableDescriptorInst<TableModel, any, any>;
+    serviceProvider?: ActionProviderType<Model, Service>;
+    position?: ActionPositionEnum.RowInline | ActionPositionEnum.RowClick;
+};
+declare function tableviewActionDeleteOnTable<Model, TableModel, Service = undefined>(model: ModelDescriptor<Model>, opts?: TableviewActionDeleteOnTableOptsType<Model, TableModel, Service>): ActionDescriptorInst<Model, Service, TableModel, Model, TableModel> | null;
+type TableviewActionDeleteOnDetailsOptsType<Model, Service> = {
+    injector?: Injector | null;
+    serviceProvider?: ActionProviderType<Model, Service>;
+    position?: ActionPositionEnum.RowInline | ActionPositionEnum.RowClick;
+};
+declare function tableviewActionDeleteOnDetails<Model, Service = undefined>(model: ModelDescriptor<Model>, opts?: TableviewActionDeleteOnDetailsOptsType<Model, Service>): ActionDescriptorInst<Model, Service, Model, Model, Model> | null;
+type TableviewActionExportOnTableOptsType = {
+    injector?: Injector | null;
+    defaultActions?: TableviewDefaultActionsEnum[];
+    position?: ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight;
+};
+declare function tableviewActionExportOnTable<Model>(descriptor: TableviewDescriptorInst<Model>, opts?: TableviewActionExportOnTableOptsType): ActionDescriptorInst<Model, undefined, undefined, undefined> | null;
+declare function tableviewActionExportJsonOnTable<Model>(descriptor: TableviewDescriptorInst<Model>, opts?: Omit<TableviewActionExportOnTableOptsType, 'defaultActions'>): ActionDescriptorInst<Model, undefined, undefined, undefined>;
+declare function tableviewActionExportCsvOnTable<Model>(descriptor: TableviewDescriptorInst<Model>, opts?: Omit<TableviewActionExportOnTableOptsType, 'defaultActions'>): ActionDescriptorInst<Model, undefined, undefined, undefined>;
+type TableviewActionRefreshOnTableOptsType = {
+    position?: ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight;
+};
+declare function tableviewActionRefreshOnTable<Model>(descriptor: ModelDescriptor<Model>, opts?: TableviewActionRefreshOnTableOptsType): ActionDescriptorInst<Model, undefined, undefined, undefined, undefined> | null;
+type TableviewLocalizationLangSelectOnTableActionOptsType = {
+    position?: ActionPositionEnum.ToolbarLeft | ActionPositionEnum.ToolbarRight;
+};
+declare function tableviewActionLocalizationLangSelectOnTable<Model>(descriptor: TableviewDescriptorInst<Model>, opts?: TableviewLocalizationLangSelectOnTableActionOptsType): ActionDescriptorInst<Model, undefined, undefined, undefined, undefined> | null;
+
+type TvBuilderSetterParamsType<Descriptor, DataProvider> = {
+    descriptor: Descriptor;
+    dataProvider: DataProvider;
+    injector: Injector;
+};
+type TvBuilderActionSetterFnType<ActionModel, ActionService, ActionInput, ActionResult, ValidationInput, Descriptor, DataProvider> = (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => Nullable<ActionDescriptorInst<ActionModel, ActionService, ActionInput, ActionResult, ValidationInput> | ActionEditorDescriptorInst<ActionModel, ActionService, any, ActionInput, ActionResult, ValidationInput>>;
+type TvBuilderDescriptorSetterFnType<Descriptor, DataProvider> = (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => Descriptor;
+type TvBuilderDataProviderSetterFnType<Descriptor, DataProvider> = (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => DataProvider;
+/**
+ * The `TableviewBuilder` class is used to build a tableview configuration.
+ * It allows you to set various options such as the descriptor, data provider,
+ * default actions, and custom actions for the tableview.
+ *
+ * @typeparam Model - The main model type.
+ * @typeparam Service - The API service type.
+ * @typeparam Descriptor - The descriptor type.
+ * @typeparam DataProvider - The data provider type.
+ * @typeparam Sorts - The sort type representing available sort keys.
+ * @typeparam Filters - The filter type representing available filter keys.
+ */
+declare class TableviewInputBuilder<Model, Service, Descriptor extends TableviewDescriptorInst<Model, Sorts, Filters, undefined, TableModel, AddModel, EditModel, FieldsModel>, DataProvider extends IDataProvider<Model, Service>, Sorts = keyof Model, Filters extends keyof any = keyof Model, TableModel = Model, AddModel = Model, EditModel = Model, FieldsModel = Model> {
+    private _descriptor;
+    private _dataProvider;
+    private readonly injector;
+    private defaultActions;
+    private readonly _customActions;
+    constructor(_descriptor: Descriptor, _dataProvider: DataProvider, injector: Injector);
+    private prepareSetterParams;
+    /**
+     * Sets a descriptor instead of the default one.
+     *
+     * @param {TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new descriptor. It should accept a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDescriptor(fn: TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>): this;
+    /**
+     * Adjusts the descriptor using the provided adjust function.
+     *
+     * @param {(descriptor: Descriptor) => void} adjustFn - The function used to adjust the descriptor. It accepts a single parameter of type `Descriptor`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjustDescriptor(adjustFn: (descriptor: Descriptor) => void): this;
+    /**
+     * Sets the data provider for the TvBuilder instance
+     *
+     * @param {TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * * @returns {this} - Returns the current instance of the builder.
+     */
+    withDataProvider(fn: TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>): this;
+    /**
+     * Adjusts the data provider using the provided adjust function.
+     *
+     * @param {(dataProvider: DataProvider) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `DataProvider`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjustDataProvider(adjustFn: (dataProvider: DataProvider) => void): this;
+    /**
+     * Adjusts the data provider and/or descriptor using the provided adjust function.
+     *
+     * @param {(params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjust(adjustFn: (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void): this;
+    /**
+     * Associates a fetch function for a data provider API service with the specified parameters.
+     *
+     * @param {ServiceFn} serviceFn The function from the service class that performs the fetch API call.
+     *                              Must be a key of the service with a parameter and return an Observable.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>} fnItemIdParamName The parameter name for itemId used as the key within the request object of fetch function on API service.
+     */
+    withDataServiceFetchFn<ServiceFn extends ClassFunctionKeysWithParamAndReturnType<Service, any, Observable<Model>>>(serviceFn: ServiceFn, itemIdParamName: ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>): this;
+    /**
+     * Associates a create function for a data provider API service with the specified parameters.
+     *
+     * @param {ServiceFn} serviceFn The function from the service class that performs the create API call.
+     *                              Must be a key of the service with a parameter and return an Observable.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, Undefined<EditModel>>} serviceFnItemParamName The parameter name for item used as the key within the request object of create function on API service.
+     * @param {EditorDataProviderFetchMapToFnType<Model, AddModel>} [mapFetchItem] Map function to transform model from fetch to form's add model.
+     */
+    withDataServiceCreateFn<ServiceFn extends ClassFunctionKeysWithParamAndReturnType<Service, any, Observable<any>>>(serviceFn: ServiceFn, serviceFnItemParamName: ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, AddModel>, mapFetchItem?: EditorDataProviderFetchMapToFnType<Model, AddModel>): this;
+    /**
+     * Associates an update function for a data provider API service with the specified parameters.
+     *
+     * @param {ServiceFn} serviceFn The function from the service class that performs the update API call.
+     *                              Must be a key of the service with a parameter and return an Observable.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, Undefined<EditModel>>} fnItemParamName The parameter name for item used as the key within the request object of update function on API service.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>} [fnItemIdParamName] The parameter name for itemId used as the key within the request object of update function on API service.
+     * @param {EditorDataProviderFetchMapToFnType<Model, EditModel>} [mapFetchItem] Map function to transform model from fetch to form' edit model.
+     */
+    withDataServiceUpdateFn<ServiceFn extends ClassFunctionKeysWithParamAndReturnType<Service, any, Observable<any>>>(serviceFn: ServiceFn, fnItemParamName: ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, EditModel>, fnItemIdParamName?: ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>, mapFetchItem?: EditorDataProviderFetchMapToFnType<Model, EditModel>): this;
+    /**
+     * Associates a delete function for a data provider API service with the specified parameters.
+     *
+     * @param {ServiceFn} serviceFn The function from the service class that performs the delete API call.
+     *                              Must be a key of the service with a parameter and return an Observable.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>} fnItemIdParamName The parameter name for itemId used as the key within the request object of delete function on API service.
+     */
+    withDataServiceDeleteFn<ServiceFn extends ClassFunctionKeysWithParamAndReturnType<Service, any, Observable<any>>>(serviceFn: ServiceFn, fnItemIdParamName: ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>): this;
+    /**
+     * Removes all the default tableview actions.
+     *
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withNoDefaultActions(): this;
+    /**
+     * Adds the default actions specified in parameters.
+     *
+     * @param {TableviewDefaultActionsEnum[]} types - The default actions to add.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDefaultActions(...types: TableviewDefaultActionsEnum[]): this;
+    /**
+     * Removes the default actions specified in parameters.
+     *
+     * @param {TableviewDefaultActionsEnum[]} types - The default actions to remove.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withoutDefaultActions(...types: TableviewDefaultActionsEnum[]): this;
+    /**
+     * Overrides the default action.
+     *
+     * @param {TableviewDefaultActionsEnum} type - The default actions to override.
+     * @param {TvBuilderActionSetterFnType<Model, ActionService , ActionRunInput, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDefaultActionOverride<ActionService = Service, ActionRunInput = Model, ActionRunResult = Model, ValidationInput = Model>(type: TableviewDefaultActionsEnum, fn: TvBuilderActionSetterFnType<Model, ActionService, ActionRunInput, ActionRunResult, ValidationInput, Descriptor, DataProvider>): this;
+    /**
+     * Adds a custom action.
+     *
+     * @deprecated Use on of {withActionOnTable}, {withActionOnDetailsEditor}, {withActionOnEditEditor} or {withActionOnAddEditor} instead.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunInput, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAction<ActionModel = Model, ActionService = Service, ActionRunInput = Model, ActionRunResult = Model, ValidationInput = Model>(fn: TvBuilderActionSetterFnType<ActionModel, ActionService, ActionRunInput, ActionRunResult, ValidationInput, Descriptor, DataProvider>): this;
+    /**
+     * Adds a custom action on table row or top (header or toolbar).
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withActionOnTable<ActionModel = Model, ActionService = Service, ActionInput extends TableModel | undefined = TableModel, ActionRunResult = Model>(fn: TvBuilderActionSetterFnType<ActionModel, ActionService, ActionInput, ActionRunResult, ActionInput, Descriptor, DataProvider>): this;
+    /**
+     * Adds a custom action on details editor.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withActionOnDetailsEditor<ActionModel = Model, ActionService = Service, ActionInput extends Model = Model, ActionResult = Model>(fn: TvBuilderActionSetterFnType<ActionModel, ActionService, ActionInput, ActionResult, ActionInput, Descriptor, DataProvider>): this;
+    /**
+     * Adds a custom action on edit editor.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withActionOnEditEditor<ActionModel = Model, ActionService = Service, ActionInput extends EditModel = EditModel, ActionResult = Model>(fn: TvBuilderActionSetterFnType<ActionModel, ActionService, ActionInput, ActionResult, ActionInput, Descriptor, DataProvider>): this;
+    /**
+     * Adds a custom action on add editor.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withActionOnAddEditor<ActionModel = Model, ActionService = Service, ActionInput extends AddModel = AddModel, ActionResult = Model>(fn: TvBuilderActionSetterFnType<ActionModel, ActionService, ActionInput, ActionResult, ActionInput, Descriptor, DataProvider>): this;
+    /**
+     * @internal
+     *
+     * Builds and returns an instance of ITableview.
+     * DO NOT CALL this within tableview create callback function!
+     *
+     * @return {TableviewInput<Model, Service, Sorts, Filters, TableModel, AddModel, EditModel, Descriptor, DataProvider>} - The built ITableview instance.
+     */
+    build(): TableviewInput<Model, Service, Sorts, Filters, TableModel, AddModel, EditModel, Descriptor, DataProvider>;
+}
+
+/**
+ * Creates a tableview with the given model, service.
+ *
+ * @param {ModelDescriptor<Model>} model - The model descriptor.
+ * @param {ServiceClassType<Service>} [opts.service] - The class type of the service.
+ * @param {TypeDescriptor<Sorts> | ModelDescriptor<Sorts>} [opts.sortsType] - Type of sorts
+ * @param {TypeDescriptor<Filters> | ModelDescriptor<Filters>} [opts.filtersType] - Type of filters.
+ * @param {(builder: TableviewBuilder) => void} [buildFn] - The optional callback function to customize the tableview using the prepared builder.
+ *
+ * @returns A tableview instance with descriptor, data provider and actions.
+ */
+declare function tableview<Model, Service = undefined, Sorts = keyof Model, Filters extends keyof any = keyof Model>(model: ModelDescriptor<Model>, opts?: {
+    service?: ServiceClassType<Service>;
+    sortsType?: TypeDescriptor<Sorts> | ModelDescriptor<Sorts>;
+    filtersType?: TypeDescriptor<Filters> | ModelDescriptor<Filters>;
+}, buildFn?: (builder: TableviewInputBuilder<Model, Service, TableviewDescriptorInst<Model, Sorts, Filters>, TableviewDataProviderInst<Model, Service, Sorts, Filters>, Sorts, Filters>) => void): _mediusinc_mng_commons_tableview_api.TableviewInput<Model, Service, Sorts, Filters, Model, Model, Model, TableviewDescriptorInst<Model, Sorts, Filters, undefined, Model, Model, Model, TableviewDescriptorFieldsManageMultiType<Model, Model, Model>>, TableviewDataProviderInst<Model, Service, Sorts, Filters, ServiceClassOptType<Service>, Model, Model, Model>>;
+type TableviewMultiModelOpts<Service, Sorts, Filters, TableModel, AddModel, EditModel> = {
+    service?: ServiceClassType<Service>;
+    sortsType?: TypeDescriptor<Sorts> | ModelDescriptor<Sorts>;
+    filtersType?: TypeDescriptor<Filters> | ModelDescriptor<Filters>;
+} & TableviewDescriptorInstConstructorOpts<TableModel, AddModel, EditModel>;
+declare function tableviewMultiModel<Model, Service = undefined, Sorts = keyof Model, Filters extends keyof any = keyof Model, TableModel = Model, AddModel = Model, EditModel = Model, FieldsModel = TableviewDescriptorFieldsManageMultiType<Model, AddModel, EditModel>>(model: ModelDescriptor<Model>, opts?: TableviewMultiModelOpts<Service, Sorts, Filters, TableModel, AddModel, EditModel>, buildFn?: (builder: TableviewInputBuilder<Model, Service, TableviewDescriptorInst<Model, Sorts, Filters, undefined, TableModel, AddModel, EditModel, FieldsModel>, TableviewDataProviderInst<Model, Service, Sorts, Filters, ServiceClassOptType<Service>, TableModel, AddModel, EditModel>, Sorts, Filters, TableModel, AddModel, EditModel, FieldsModel>) => void): _mediusinc_mng_commons_tableview_api.TableviewInput<Model, Service, Sorts, Filters, TableModel, AddModel, EditModel, TableviewDescriptorInst<Model, Sorts, Filters, undefined, TableModel, AddModel, EditModel, FieldsModel>, TableviewDataProviderInst<Model, Service, Sorts, Filters, ServiceClassOptType<Service>, TableModel, AddModel, EditModel>>;
+
+/**
+ * Creates a data provider for from descriptor. DO NOT use if the model is class, because the type (from model descriptor) will not be set in data provider.
+ *
+ * @param {TableviewDescriptorInst<Model, Sorts, Filters>} descriptor - The table descriptor.
+ *
+ * @return {TableviewDataProviderInst<Model, undefined, Sorts, Filters, undefined, undefined>} - The data provider for the table component.
+ */
+declare function tableviewDataProviderFromDescriptor<Model, Sorts = keyof Model, Filters extends keyof any = keyof Model, TableModel = Model, CreateModel = Model, UpdateModel = Model>(descriptor: TableviewDescriptorInst<Model, Sorts, Filters, any, TableModel, CreateModel, UpdateModel, any>): TableviewDataProviderInst<Model, undefined, Sorts, Filters, undefined, TableModel, CreateModel, UpdateModel>;
+/**
+ * Creates a data provider for from descriptor. DO NOT use if the model is class, because the type (from model descriptor) will not be set in data provider.
+ *
+ * @param {TableviewDescriptorInst<Model, Sorts, Filters>} descriptor - The table descriptor.
+ * @param {ServiceClassType<Service>} serviceClass - The service class type.
+ *
+ * @return {TableviewDataProviderInst<Model, Service, Sorts, Filters, undefined, ServiceClassType<Service>>} - The data provider for the table component.
+ */
+declare function tableviewDataProviderFromDescriptor<Model, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model, TableModel = Model, CreateModel = Model, UpdateModel = Model>(descriptor: TableviewDescriptorInst<Model, Sorts, Filters, any, TableModel, CreateModel, UpdateModel, any>, serviceClass: ServiceClassType<Service>): TableviewDataProviderInst<Model, Service, Sorts, Filters, ServiceClassType<Service>, TableModel, CreateModel, UpdateModel>;
+
+type TableviewDescriptorType<TableviewModel, Sorts = keyof TableviewModel, Filters = keyof TableviewModel, ParentEditorModel = undefined> = TableviewDescriptorInst<TableviewModel, Sorts, Filters, ParentEditorModel, TableviewModel, TableviewModel, TableviewModel, TableviewModel>;
+
+interface TableviewRouteData extends CommonsRouteData {
+    tableview?: {
+        descriptor: TableviewDescriptorInst<any, any, any, any>;
+        dataProvider: ITableviewDataProvider;
+        actions?: Array<ActionDescriptorInst<any>>;
+    };
+    tableviewPermissions?: {
+        [key: string]: APermissions;
+    };
+    tableviewActions?: {
+        hasAdd?: boolean;
+        hasEdit?: boolean;
+        hasDetails?: boolean;
+        hasDelete?: boolean;
+    };
+}
+
+export { AFieldDescriptor, AFieldGroupDescriptor, AFormlyCustomFieldComponent, AGenericFieldDescriptor, ActionActivationTriggerEnum, ActionDescriptorInst, ActionEditorDescriptorInst, ActionEditorSubmitDescriptorInst, ActionEditorSubmitTypeEnum, ActionInstanceStateEnum, ActionLinkDescriptorInst, ActionPositionEnum, ActionTypeEnum, CommonsActionError, DATA_LANGUAGE_DROPDOWN_COMPONENT_IT, DataProviderExecutor, DynamicTableviewDataProviderInst, EDITOR_DEFAULT_GROUP_NAME, EditorDataProviderInst, EditorDescriptorInst, EditorDescriptorNestedObjectWrapper, FieldActionDescriptor, FieldGroupDescriptor, FieldGroupTypeEnum, FieldInputDescriptor, FieldInputTypeEnum, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldLookupTypeEnum, FieldManyEditorActionEnum, FieldManyEditorDescriptor, FieldManyEditorTypeEnum, FieldManyToManyEditorActionEnum, FieldManyToManyEditorDescriptor, FieldManyToManyEditorTypeEnum, FieldSizeEnum, FieldTabGroupDescriptor, FieldValidationDescriptor, FormEventTypeEnum, FormFieldEventComponentSubtype, FormFieldEventDialogSubtype, FormFieldEventTypeEnum, TableviewActionDefaultCategories, TableviewDataProviderInst, TableviewDefaultActionsEnum, TableviewDescriptorInst, TableviewDynamicDescriptorInt, TableviewEditorTypeEnum, TableviewInputBuilder, action, actionEditor, actionEditorCancel, actionEditorGetProviderCfgObj, actionEditorOnEditor, actionEditorOnTableRow, actionEditorOnTableTop, actionEditorSubmit, actionGetProviderCfgObj, actionLink, actionLinkFromAction, actionOnEditor, actionOnTableRow, actionOnTableTop, convertDataToStringWithDelimiter, editorDataProvider, editorDescriptor, fieldDescriptorEmptyLabelType, fieldLookupGetProviderCfgObj, fieldManyToManyGetProviderCfgObj, getDataProviderService, runCreateFromDataProvider, runDeleteFromDataProvider, runFetchFromDataProvider, runFnFromDataProviderOrFail, runFnFromDataProviderOrFallback, runGetAllFromDataProvider, runUpdateFromDataProvider, saveFileAs, tableview, tableviewActionAddOnTable, tableviewActionDeleteActionName, tableviewActionDeleteOnDetails, tableviewActionDeleteOnTable, tableviewActionDetailsOnTable, tableviewActionEditOnDetails, tableviewActionEditOnTable, tableviewActionEditorAddActionName, tableviewActionEditorAddRoute, tableviewActionEditorDetailsActionName, tableviewActionEditorDetailsRoute, tableviewActionEditorEditActionName, tableviewActionEditorEditRoute, tableviewActionExportCsvOnTable, tableviewActionExportJsonOnTable, tableviewActionExportOnTable, tableviewActionLocalizationLangSelectOnTable, tableviewActionRefreshOnTable, tableviewCreateDefaultAction, tableviewCreateDefaultActions, tableviewDataProvider, tableviewDataProviderFromDescriptor, tableviewDescriptor, tableviewDescriptorMultiModel, tableviewDynamicDataProvider, tableviewDynamicDescriptor, tableviewGetDefaultActions, tableviewMultiModel };
+export type { ActionConfirmation, ActionContextValidation, ActionDescriptorConstructorOptsType, ActionDescriptorCreateFromModelOptsType, ActionDescriptorCreateOptsParentType, ActionDescriptorCreateOptsProviderType, ActionDescriptorCreateOptsType, ActionEditorDescriptorConstructorOptsType, ActionEditorDescriptorCreateOptsProviderType, ActionEditorDescriptorOptsType, ActionEditorProviderAddType, ActionEditorProviderEditType, ActionEditorProviderType, ActionEditorRunFnType, ActionExecutionError, ActionLinkDescriptorConstructorOpts, ActionNotificationType, ActionProviderType, ActionRunFnType, ActionValidationFnType, CommonsActionErrorOptions, CommonsFormlyFieldAdditionalProps, CommonsFormlyFieldConfig, CommonsFormlyFieldProps, CommonsFormlyFormOptions, CommonsFormlyFormState, CommonsFormlyHookFn, CommonsFormlyValidation, ConfigurationConfigMapFn, ConfigurationShouldShowFn, EditorDataProviderCreateFnType, EditorDataProviderDeleteFnType, EditorDataProviderFetchFnType, EditorDataProviderFetchMapToFnType, EditorDataProviderUpdateFnType, EditorDescriptorCreateBaseOptsType, EditorDescriptorCreateOptsType, EditorResetEvent, FieldActionContext, FieldActionResult, FieldActionResultMessage, FieldActionRunFnType, FieldAsyncBaseValidator, FieldAsyncValidator, FieldBaseValidator, FieldClassNameType, FieldConfig, FieldDateOptsType, FieldImagePreviewComponent, FieldInputComponentOpts, FieldInputCurrencyOptsType, FieldInputDatePickerDisplayOptsType, FieldInputDatePickerDynamicMinMaxFnType, FieldInputDatePickerOptsType, FieldInputDateValidationOptsType, FieldInputDescriptorType, FieldInputFileOnSelectHandlerFnType, FieldInputFileOpts, FieldInputImageUrlOpts, FieldInputLocaleOptsType, FieldInputMaskOptsType, FieldInputNumberDisplayOptsType, FieldInputNumberFractionOptsType, FieldInputNumberGroupingOptsType, FieldInputNumberOptsType, FieldInputNumberValidationOptsType, FieldInputTextOptsType, FieldInputTextValidationOptsType, FieldInputTextareaOptsType, FieldLookupAutocompleteOptsType, FieldLookupConfig, FieldLookupDescriptorConstructorOptsType, FieldLookupDescriptorCreateOptsProviderType, FieldLookupProviderType, FieldManyToManyEditorDescriptorConstructorOptsType, FieldManyToManyEditorDescriptorCreateOptsProviderType, FieldManyToManyEditorProviderType, FieldValidationDescriptorOptsType, FieldValidationMessage, FieldValidationOptsType, FieldValidationParamsType, FieldValidator, FieldsManageAddFieldLookupOpts, FormAsyncValidator, FormEditorGetFormValueOpts, FormEditorPatchFieldValueOpts, FormEditorResetFieldValueOpts, FormEditorResetFormModelOpts, FormEditorSetFieldValueOpts, FormEditorSubmitEvent, FormEvent, FormEventData, FormFieldEvent, FormFieldEventData, FormValidationMessage, FormValidator, IActionComponent, IActionContext, IActionEditorComponent, IActionEditorContext, IActionInstance, IEditorDataProvider, IEditorDataProviderCreate, IEditorDataProviderDelete, IEditorDataProviderFetch, IEditorDataProviderFetchMapToCreate, IEditorDataProviderFetchMapToUpdate, IEditorDataProviderFnsType, IEditorDataProviderSupport, IEditorDataProviderUpdate, IFieldManageSafeWithGetField, IFieldsManage, IFieldsManageSafe, IFieldsManageWithGetField, IFormEditorComponent, ITableviewDataProvider, IViewContainer, RadioValue, RunFetchFromDataProviderOptsType, RunFetchFromDataProviderReasonType, TableviewDescriptorCreateMultiModelWithModelDescriptorOptsType, TableviewDescriptorCreateOptsType, TableviewDescriptorCreateWithModelDescriptorOptsType, TableviewDescriptorFieldsManageMultiType, TableviewDescriptorFieldsManageSingleType, TableviewDescriptorInstConstructorOpts, TableviewDescriptorMultiModelCreateOptsType, TableviewDescriptorType, TableviewInput, TableviewRouteData, TvBuilderActionSetterFnType, TvBuilderDataProviderSetterFnType, TvBuilderDescriptorSetterFnType, TvBuilderSetterParamsType, ViewContainerEditorCloseEvent };