@magic-xpa/angular 4.1201.0-dev4121.306 → 4.1201.0-dev4121.308

package/types/magic-xpa-angular.d.ts

@@ -0,0 +1,2564 @@
+import { StorageAttribute, MagicProperties } from '@magic-xpa/utils';
+import { HtmlProperties, CustomValidator, GuiCommand, GuiInteractive, Styles, PIC } from '@magic-xpa/gui';
+import * as i0 from '@angular/core';
+import { NgModuleRef, ViewContainerRef, OnInit, Injector, Compiler, Component, InjectionToken, AfterViewInit, ElementRef, EventEmitter, ChangeDetectorRef, OnDestroy, Renderer2, TemplateRef, PipeTransform } from '@angular/core';
+import * as i31 from '@angular/forms';
+import { FormGroup, AbstractControl, ValidatorFn, FormControl, CheckboxControlValueAccessor, DefaultValueAccessor, ControlValueAccessor, Validator } from '@angular/forms';
+import { Subject, Subscription } from 'rxjs';
+import { MagicBridge, IGuiEvent } from '@magic-xpa/engine';
+import { HttpClient } from '@angular/common/http';
+import { List, RefParam } from '@magic-xpa/mscorelib';
+import * as i32 from '@angular/router';
+import { Router, ActivatedRoute } from '@angular/router';
+import { Title } from '@angular/platform-browser';
+import { MaskitoOptions } from '@maskito/core';
+import { Platform } from '@angular/cdk/platform';
+import * as i30 from '@angular/common';
+import { DatePipe } from '@angular/common';
+import * as i33 from 'ng-dynamic-component';
+import * as i34 from '@angular/cdk/drag-drop';
+import * as i35 from '@maskito/angular';
+import * as _angular_material_core from '@angular/material/core';
+import { NativeDateAdapter, DateAdapter } from '@angular/material/core';
+
+/**
+ * @ignore
+ */
+declare class ControlMetadata {
+    controlType: string;
+    dataType: StorageAttribute;
+    properties: Map<HtmlProperties, any>;
+    classesMap: Map<HtmlClasses, any>;
+    stylesMap: Map<HtmlClasses, any>;
+    removedClass: string;
+    classes: string;
+    rangeValidator: boolean;
+    userProperties: Map<string, any>;
+    customValidators: Map<string, CustomValidator>;
+    setClass(key: any, value: any): void;
+    setStyle(key: any, value: any): void;
+}
+/**
+ * @ignore
+ */
+declare class ControlsMetadata {
+    values: Map<string, string>;
+    ControlsProperties: Map<string, ControlMetadata>;
+    rowId: string;
+    isCreated: boolean;
+    isEditing: boolean;
+    get Values(): Map<string, string>;
+    getControlMetadata(controlId: string): ControlMetadata;
+    update(obj: any): void;
+    setValue(controlName: string, value: any): void;
+    getProperty(controlId: string, prop: HtmlProperties): any;
+    getValue(controlName: string): string;
+}
+/**
+ * @ignore
+ */
+declare class Records {
+    data: Map<number, ControlsMetadata>;
+    list: ControlsMetadata[];
+    includesFirst: boolean;
+    includesLast: boolean;
+    guiTopIndex: number;
+    recordsBeforeCurrentView: number;
+    isEmptyDataView: boolean;
+    sizeUpdated: boolean;
+    getRow(dvRowId: number): ControlsMetadata;
+    markRowAsCreated(guiRowId: number): void;
+    markRowAsNotCreated(guiRowId: number): void;
+    isRowCreated(guiRowId: number): boolean;
+    startRowEditing(guiRowId: number): void;
+    stopRowEditing(guiRowId: number): void;
+    isRowInRowEditing(guiRowId: string): boolean;
+    update(obj: any): void;
+    updateSize(len: number): void;
+    /**
+     * crears data for the first record
+     * @param template
+     */
+    clearFirstTableRecord(template: {
+        [id: string]: string;
+    }): void;
+    addRow(guiRowId: number): void;
+    createFirst(): void;
+    fromJson(data: string): void;
+    setGuiTopIndex(topIndex: number): void;
+    getGuiTopIndex(): number;
+}
+/**
+ * @ignore
+ */
+declare enum HtmlClasses {
+    Color = "color",
+    font = "font",
+    FocusColor = "focuscolor",
+    HintColor = "hintcolor"
+}
+
+/**
+ * @ignore
+ */
+declare class EngineMagicService {
+    magicBridge: typeof MagicBridge;
+    isStub: boolean;
+    isLoggedIn: boolean;
+    refreshDom: Subject<GuiCommand>;
+    interactiveCommands: Subject<GuiInteractive>;
+    startMagicEngine(httpClient: HttpClient, args: Map<string, string>): void;
+    terminateMagic(): Promise<void>;
+    insertEvent(guiEvent: IGuiEvent): void;
+    GetRangedValue(taskId: string, controlName: string, value: string): string;
+    GetControlPictureMask(taskId: string, controlName: string): any;
+    UploadFileToServer(fileContent: any, serverFileName: string): any;
+    DownloadFileFromServer(serverFileName: string): Promise<ArrayBuffer>;
+    GetFormattedValue(taskId: string, controlName: string, value: any, rowId?: string): any;
+    ValidateControlValue(taskId: string, controlName: string, value: any): string;
+    GetFldRanges(taskId: string, controlName: string): string;
+    saveData(data: string): void;
+    getIsLoggedIn(): boolean;
+    setIsLoggedIn(setIsLoggedIn: boolean): void;
+    TransCacheExists(): boolean;
+    TerminateContextUsingFetchAPI(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EngineMagicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EngineMagicService>;
+}
+
+interface ComponentData {
+    component: any;
+    moduleRef: NgModuleRef<any>;
+}
+interface ModuleData {
+    moduleName: string;
+    modulePath: string;
+}
+/**
+ * Manages the list of components in a project, and the project title
+ */
+declare class ComponentListMagicService {
+    /**
+     * Map of project components
+     */
+    components: Map<string, ComponentData>;
+    /**
+     * Map of project dialogs
+     */
+    dialogs: Map<string, any>;
+    lazyLoadModulesMap: any;
+    getData(name: string, mustHaveData: boolean): ComponentData;
+    /**
+     * Return a component according to name
+     * @param name Name of requested component
+     * @returns The requested component
+     */
+    getComponent(name: string, mustHaveData?: boolean): any;
+    addComponents(componentList: any, modulRef?: NgModuleRef<any>): void;
+    /**
+    * Return a component according to name
+    * @param name Name of requested component
+    * @returns The requested component
+    */
+    getModuleRef(name: string): NgModuleRef<any>;
+    /**
+     * Return the lazy load module details of the specified component
+     * @param name: Name of requested component
+     * @returns: lazy load module details
+     */
+    getLazyLoadModuleData(name: string): ModuleData;
+    /**
+       * Project title
+       */
+    title: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentListMagicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentListMagicService>;
+}
+
+/**
+ * @ignore
+ */
+declare class CommandsCollectorMagicService {
+    protected magic: EngineMagicService;
+    private count;
+    private commands;
+    private subscription;
+    constructor(magic: EngineMagicService);
+    startCollecting(): void;
+    stopCollecting(): void;
+    GetCommands(taskId: string): GuiCommand[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandsCollectorMagicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CommandsCollectorMagicService>;
+}
+
+/**
+ * @ignore
+ */
+interface SubformDefinition {
+    formName: string;
+    parameters: any;
+}
+/**
+ * @ignore
+ */
+interface RouteDefinition {
+    formName: string;
+    parameters: any;
+}
+interface IMagicViewContainerRef {
+    setViewContainerRef(vcRef: ViewContainerRef): any;
+}
+
+interface ISubformMagicService {
+    ExecuteRouteCommand(routeCommand: RouteCommand): any;
+}
+
+/**
+ * @ignore
+ */
+declare class RouteCommand {
+    callerMgSubformServiceRef: ISubformMagicService;
+    routerOutletName: string;
+    formName: string;
+    parameters: any;
+    routeParams: List<any>;
+}
+/**
+ * @ignore
+ */
+declare class RouterCommandsMagicService {
+    private pendingRouteCommands;
+    AddRouteCommand(routeCommand: RouteCommand): void;
+    ExecuteNextCommand(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouterCommandsMagicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RouterCommandsMagicService>;
+}
+
+/**
+ * Mock component, implements routing by connecting the requested URL with the appropriate Magic task
+ */
+declare class RouterContainerMagicComponent implements OnInit {
+    private activatedRoute;
+    protected router: Router;
+    protected magic: EngineMagicService;
+    private containerTaskService;
+    private viewContainerRef;
+    private componentList;
+    protected pendingCommandsCollector: CommandsCollectorMagicService;
+    protected routerCommandsMagicService: RouterCommandsMagicService;
+    private componentRef;
+    private parentMgSubformService;
+    private static lastRoute;
+    private routePath;
+    static get LastRoute(): string;
+    /**
+     *
+     * @param changeDetectorRef
+     * @param activatedRoute
+     * @param magic
+     * @param componentFactoryResolver
+     * @param viewContainerRef
+     * @param componentList
+     * @param pendingCommandsCollector
+     */
+    constructor(activatedRoute: ActivatedRoute, router: Router, magic: EngineMagicService, containerTaskService: TaskMagicService, viewContainerRef: ViewContainerRef, componentList: ComponentListMagicService, pendingCommandsCollector: CommandsCollectorMagicService, routerCommandsMagicService: RouterCommandsMagicService);
+    /**
+     * Initialization
+     */
+    ngOnInit(): void;
+    private insertRouteEvent;
+    initializeComponent(): void;
+    /**
+     * Cleanup
+     */
+    ngOnDestroy(): void;
+    getRouterPath(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouterContainerMagicComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RouterContainerMagicComponent, "magic-route-outlet", never, {}, {}, never, never, false, never>;
+}
+
+declare class MagicLazyLoaderService {
+    Load(path: string): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicLazyLoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MagicLazyLoaderService>;
+}
+
+/**
+ * Service for managing subforms and routing
+ */
+declare class SubformMagicService implements ISubformMagicService {
+    private task;
+    protected activatedRoute: ActivatedRoute;
+    protected componentList: ComponentListMagicService;
+    protected pendingCommandsCollector: CommandsCollectorMagicService;
+    protected router: Router;
+    protected routerCommandsMagicService: RouterCommandsMagicService;
+    private componentListMagicService;
+    private loader;
+    private injector;
+    private compiler;
+    subformsDict: {};
+    routesDict: {
+        [x: string]: string;
+    };
+    currentRouteDefinition: RouteDefinition;
+    static currentCallerMgSubformServiceRef: any;
+    static routerContainers: Array<RouterContainerMagicComponent>;
+    constructor(task: TaskMagicService, activatedRoute: ActivatedRoute, componentList: ComponentListMagicService, pendingCommandsCollector: CommandsCollectorMagicService, router: Router, routerCommandsMagicService: RouterCommandsMagicService, componentListMagicService: ComponentListMagicService, loader: MagicLazyLoaderService, injector: Injector, compiler: Compiler);
+    /**
+     * Finds and returns the component according to the subform name
+     * @param subformName
+     * @returns
+     */
+    mgGetComp(subformName: string): Component;
+    /**
+     * Returns the parameters of the subform
+     * @param subformName
+     * @returns
+     */
+    mgGetParameters(subformName: string): any;
+    /**
+     * @ignore
+     */
+    deleteSubformComp(subformControlName: string, formName: string): void;
+    /**
+     * @ignore
+     */
+    addSubformComp(subformControlName: string, formName: string, taskId: string, taskDescription: any, routerPath: string, params: List<any>, inDefaultOutlet: boolean): void;
+    /**
+     * Open the subform using a route command
+     */
+    ExecuteRouteCommand(routeCommand: RouteCommand): void;
+    private PerformRouterNavigate;
+    /**
+     * @ignore
+     */
+    init(): void;
+    /**
+     * @ignore
+     */
+    refreshView(): void;
+    static getRelativeRoute(sendActivatedRoute: ActivatedRoute): ActivatedRoute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubformMagicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SubformMagicService>;
+}
+
+/**
+ * Enables changing the browser title using Magic expression (SetTitle)
+ */
+declare class TitleMagicService {
+    protected titleService: Title;
+    /**
+     *
+     * @param titleService Angular's title-changing class
+     */
+    constructor(titleService: Title);
+    /**
+     * Set the new title of the window
+      * @param newTitle New title of the window
+     */
+    setTitle(newTitle: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TitleMagicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TitleMagicService>;
+}
+
+declare let COLOR_FILE_NAME: InjectionToken<string>;
+declare const MAGIC_FG_COLOR: number;
+declare const MAGIC_BG_COLOR: number;
+declare class MagicColorService {
+    private http;
+    colorFileName: string;
+    getColorFilePath(): string;
+    private colorsData;
+    private fileNotFound;
+    constructor(http: HttpClient, colorFile1?: string);
+    private getColorData;
+    private hexToRgba;
+    /**
+     * Returns the rgba value of specified color
+     * @returns : value in format rgba(128,128,128,1)
+     * @param : colorNumber -0 based index of color for which RGBA values are returned
+     * @param: colorType : 1-MAGIC_FG_COLOR, 2-MAGIC_BG_COLOR
+     */
+    getColor(colorIndex: number, colorType: number): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicColorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MagicColorService>;
+}
+
+/**
+ * Provides the UI with values calculated by the Magic WebClient
+ */
+declare class AccessorMagicService {
+    protected task: TaskMagicService;
+    protected magicColor: MagicColorService;
+    Logger: any;
+    readonly hhmm: MaskitoOptions;
+    readonly hhmmss: MaskitoOptions;
+    /**
+     * @ignore
+     */
+    constructor(task: TaskMagicService, magicColor: MagicColorService);
+    UploadFileToServer(fileContent: any, serverFileName: string): any;
+    DownloadFileFromServer(serverFileName: string): Promise<ArrayBuffer>;
+    /**
+     * Checks if the control is read-only
+     * @param controlId Id of control
+     * @returns Is the control not read-only
+     */
+    checkIsReadOnly(controlId: string): boolean;
+    /**
+     * Returns the text of the control
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns The text of the control
+     */
+    getText(controlId: string, rowId?: string): string;
+    /**
+     * Gets the text of the tab page
+     * @param controlId Id of control
+     * @param layer Id of tabpage
+     * @returns Text of tabpage
+     */
+    getTabpageText(controlId: string, layer: number): string;
+    /**
+     * Gets the image defined for the control
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns Image set on control
+     */
+    getImage(controlId: string, rowId?: string): string;
+    /**
+     * Returns whether an image is set for this control
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns returns true if control has an image set on it
+     */
+    isImageExists(controlId: string, rowId?: string): boolean;
+    /**
+     * Gets the CSS classes set on the control
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns The classes for this control
+     */
+    getClasses(controlId: string, rowId?: string): string;
+    /**
+     * Gets the CSS styles set on the control
+     * @param controlId Id of control
+     * @param styleName NAme of style requested
+     * @param rowId Id of row, if applicable
+     * @returns The style set on the control
+     */
+    getStyle(controlId: string, styleName: string, rowId?: string): string;
+    /**
+     * Returns whether a control is visible or not
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns Is the control visible or hidden
+     */
+    getVisible(controlId: string, rowId?: string): string;
+    /**
+     * Returns alpha mask of a control
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns alpha mask of the control
+     */
+    getAlphaMask(controlId: string, rowId?: string): string;
+    /**
+     * Returns object representing numeric picture
+     * @param picture string which is defined in magic
+     * @returns object representing numeric picture
+     */
+    getNumericPicture(picture: string): any;
+    /**
+     * Returns whether a control should have the "required" attribute set on it
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns
+     */
+    getMustInput(controlId: string, rowId?: string): string;
+    /**
+     * Returns whether a control is disabled
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns
+     */
+    isDisabled(controlId: string, rowId?: string): any;
+    /**
+     * @ignore
+     */
+    getProperty(controlId: string, prop: HtmlProperties, rowId?: string): any;
+    /**
+     * Returns the title (tooltip) text of the control
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns
+     */
+    getTitle(controlId: string, rowId?: string): string;
+    /**
+     * Returns the title (tooltip) text of the control
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns
+     */
+    getZoomButtonTitle(controlId: string, rowId?: string): string;
+    /**
+     * Gets the selection control's selected value
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns
+     */
+    getSelectedValue(controlId: string, rowId?: string): string;
+    /**
+     * Gets the place-holder text of the control
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns
+     */
+    getPlaceholder(controlId: string, rowId?: string): string;
+    /**
+     * Returns a type for input controls - should the control be a simple text or a password control
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns
+     */
+    getType(controlId: string, rowId?: string): string;
+    /**
+     * Returns the tab-index of the control
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns
+     */
+    getTabIndex(controlId: string, rowId?: string): number;
+    /**
+     * Returns the value of the control
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns
+     */
+    getValue(controlId: string, rowId?: string): any;
+    /**
+     * Returns the formatted value of the control
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns
+     */
+    getFormattedValue(controlId: string, rowId?: string): string;
+    /**
+     * Returns the Picture of the control
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns
+     */
+    getPicture(controlId: string, rowId?: string): string;
+    /**
+     * Returns the custom (user) properties of the control
+     * @param controlId Id of control
+     * @param propertyName Name of requested property
+     * @param rowId Id of row, if applicable
+     * @returns
+     */
+    getCustomProperty(controlId: string, propertyNameOrRowID?: string, rowId?: string): any;
+    getCustomProperty_1(controlId: string, propertyName: string, rowId?: string): any;
+    /**
+     * Gets the values of the items of a selection control
+     * @param id Id of control
+     * @param rowId Id of row, if applicable
+     * @returns
+     */
+    getItemListValues(id: string, rowId?: string): Array<{
+        index: number;
+        displayValue: string;
+    }>;
+    /**
+     * Gets the filtered items list based on the current value of the control
+     * @param controlId Id of control
+     * @param rowId Id of row, if applicable
+     * @returns
+     */
+    getFilteredList(controlId: string, rowId?: string): Array<{
+        index: number;
+        displayValue: string;
+    }>;
+    /**
+   * Gets the display value of the item from items of a selection control
+   * @param id Id of control
+   * @param rowId Id of row, if applicable
+   * @returns
+   */
+    getDisplayValue(id: any, rowId?: any): string;
+    /**
+     * Returns whether a tab page is selected or not
+     * @param  index of current option in iterarotr
+     * @param control Id of list control
+     * @returns
+     */ isOptionSelected(index: any, controlId: any): boolean;
+    /**
+     * Returns whether a tab page is selected or not - used for the tab buttons
+     * @param controlId Id of control
+     * @param  layer Id of the tab page
+     * @returns
+     */ isTabPageSelected(controlId: string, layer: number): boolean;
+    /**
+     * Returns whether a tab page layer is selected or not - used for the div which represents the tab page
+     * @param controlId Id of control
+     * @param  layer Id of the tab page
+     * @returns
+     */ isTabPageLayerSelected(controlId: string, layer: number): boolean;
+    /**
+     * Returns the index of the selected tab page
+     * @param controlId Id of control
+     * @returns
+     */
+    getTabSelectedIndex(controlId: string): any;
+    /**
+     * @ignore
+     */
+    ifRowCreated(row: any): boolean;
+    /**
+     * @ignore
+     */
+    getFormGroupByRow(id: string): FormGroup;
+    /**
+     * @ignore
+     */
+    isRowSelected(controlId: any, rowId?: any): boolean;
+    /**
+     * Returns whether a row is in edit state
+     * @param row
+     */
+    isRowInRowEditing(row?: any): boolean;
+    /**
+     * Returns whether a row is in edit state, use this method while control outside table control
+     * @param row
+     */
+    isCurrentInRowEditing(): boolean;
+    /**
+     * @ignore
+     */
+    guiTopIndex(): number;
+    /**
+     * @ignore
+     */
+    getErrMsg(id: string, rowId: string): string;
+    private getNumericFormatErrorString;
+    /**
+     * Sets a user-supplied value to the specified control
+     * @param controlName
+     * @param value
+     * @param refreshDisplay
+     */
+    setValueToControl(controlName: string, value: any, refreshDisplay?: boolean): void;
+    /**
+   * @ignore
+   */
+    isDataviewEmpty(): boolean;
+    /**
+     * simulates a click event on the specified control, for the Magic engine
+     * @param controlName
+     * @param rowId
+     */
+    simulateClick(controlName: string, rowId?: number): void;
+    /**
+     * Return Boolean TRUE if user logged in Else it will return FALSE
+     */
+    isLoggedIn(): boolean;
+    /**
+     * Returns JS object containing the records with all table fields.
+     */
+    GetFormRecords(): any;
+    /**
+     * SetCookie : set the cookie with specified name and value  in browser
+     * expires - expiration time
+     * path - path which much exists in order so that cookie is sent as header
+     * domain - specifies which hosts are allowed to receive the cookie
+     * secure - specifies if cookie is secure ( works only with HTTPS)
+     * sameSite - lets servers specify whether/when cookies are sent with cross-site requests
+     */
+    SetCookie(name: string, value: any, expires?: Date, path?: any, domain?: any, secure?: any, sameSite?: any): void;
+    /**
+     * GetCookie : get the cookie with specified name and value  in browser
+     */
+    GetCookie(name: string): any;
+    /**
+     * DeleteCookie : deletes the cookie
+     */
+    DeleteCookie(name: string): any;
+    /**
+    * get RGBA color from color file
+    */
+    getColor(colorNumber: number, colorType: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccessorMagicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AccessorMagicService>;
+}
+
+declare abstract class BaseMagicOverlayContainer {
+    /**
+     *
+     */
+    abstract ModalComp: any;
+    /**
+     *
+     */
+    abstract ModalCompParameters: any;
+    /**
+     *
+     */
+    abstract onClose: any;
+}
+
+/**
+ * Creates a modal window for Magic modal window components
+ */
+declare class MagicOverlayContainer extends BaseMagicOverlayContainer implements OnInit, AfterViewInit, IMagicViewContainerRef {
+    /**
+     * HTML to be displayed in the modal window
+     */
+    modalbodyViewContainerRef: ViewContainerRef;
+    /**
+     * Header of the modal window
+     */
+    headerElementRef: ElementRef;
+    /**
+     * Foreground of the modal window
+     */
+    foregroundElementRef: ElementRef;
+    /**
+     *
+     */
+    ModalComp: any;
+    /**
+     *
+     */
+    ModalCompParameters: any;
+    onClose: EventEmitter<void>;
+    /**
+     *
+     */
+    private componentRef;
+    private resizing;
+    private resizeDirection;
+    private originalWidth;
+    private originalHeight;
+    private originalMouseX;
+    private originalMouseY;
+    private isCenteredToWindow;
+    private static readonly minAllowedWidth;
+    private static readonly minAllowedHeight;
+    private _isRtl;
+    /**
+     *
+     */
+    constructor();
+    /**
+     *
+     */
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    setViewContainerRef(vcRef: ViewContainerRef): void;
+    /**
+     * Returns the form name
+     * @returns
+     */
+    getText(): any;
+    /**
+    * Returns boolean to indicate whether the text direction is right-to-left (RTL)
+    */
+    get isRtl(): boolean;
+    /**
+     * Returns CSS styles for the window
+     * @returns
+     */
+    getStyle(): {};
+    /**
+     * Returns the CSS styles for the client area
+     * @returns
+     */
+    getClientAreaStyles(): {};
+    /**
+     * Should the title bar be displayed
+     * @returns
+     */
+    getShowTitleBar(): any;
+    /**
+     *
+     */
+    OnClose(): void;
+    /**
+     * Handles click in the background window
+     */
+    OnBackgroundClick(): void;
+    /**
+     * Checks if the overlay component allows to be resized.
+     * @returns {boolean} True if the overlay is resizable, false otherwise.
+     */
+    IsResizable(): any;
+    /**
+     * Checks if the overlay component allows to be moved (dragged).
+     * @returns {boolean} True if the overlay is movable, false otherwise.
+     */
+    IsMovable(): any;
+    /**
+     * Initiates the resize process when a mousedown event occurs on a resize handle.
+     * Stores the initial state (dimensions, mouse position) and sets flags.
+     * @param {MouseEvent} event - The mousedown event triggering the resize.
+     * @param {'right' | 'bottom' | 'corner'} direction - Indicates which resize handle was activated.
+     */
+    onResizeStart(event: MouseEvent, direction: 'right' | 'left' | 'bottom' | 'corner'): void;
+    /**
+     * Handles the resizing logic as the mouse moves across the window.
+     * This listener is active globally on the window during a resize operation via @HostListener.
+     * Calculates and applies the new dimensions to the element based on mouse movement.
+     * @param {MouseEvent} event - The mousemove event passed by the HostListener.
+     */
+    onResize(event: MouseEvent): void;
+    /**
+     * Finalizes the resize operation when the mouse button is released anywhere on the window.
+     * Resets the resizing state flags. Triggered globally via @HostListener.
+     */
+    onResizeEnd(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicOverlayContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MagicOverlayContainer, "app-magic-overlay-container", never, { "ModalComp": { "alias": "ModalComp"; "required": false; }; "ModalCompParameters": { "alias": "ModalCompParameters"; "required": false; }; }, { "onClose": "onClose"; }, never, never, false, never>;
+}
+
+declare class OverlayContainerMagicProvider {
+    getComponent(): typeof MagicOverlayContainer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayContainerMagicProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayContainerMagicProvider>;
+}
+
+/**
+ * Service managing alert and confirmation windows
+ * This is Magic's default provider
+ */
+declare class ConfirmationComponentsMagicProvider {
+    /**
+     * Return true when use default javascript alert and confirmation or return false to provide custom components
+     *  @returns true is we want to use default javascript alert and confirmation
+     */
+    showDefaultConfirmations(): boolean;
+    /**
+     * Returns component that will replace javascript alert. The component will be used only if showDefaultConfirmations = false
+     *  @returns component that will replace javascript Alert
+     */
+    getAlertComponent(): any;
+    /**
+     * Returns component that will replace javascript confirmation box. The component will be used only if showDefaultConfirmations = false
+     *  @returns component that will replace javascript confirmation box
+     */
+    getConfirmtionComponent(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationComponentsMagicProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmationComponentsMagicProvider>;
+}
+
+/**
+ * Service managing overlay windows
+ */
+declare class OverlayWindowService {
+    protected componentList: ComponentListMagicService;
+    protected engineMagicService: EngineMagicService;
+    private magicLazyModuleLoader;
+    private injector;
+    private compiler;
+    private overlayContainerMagicProvider;
+    private confirmationComponentsMagicProvider;
+    constructor(componentList: ComponentListMagicService, engineMagicService: EngineMagicService, magicLazyModuleLoader: MagicLazyLoaderService, injector: Injector, compiler: Compiler, overlayContainerMagicProvider: OverlayContainerMagicProvider, confirmationComponentsMagicProvider: ConfirmationComponentsMagicProvider);
+    private overlayWindowsContainerViewRef;
+    private overlayWindowFocusManager;
+    private changeDetectorRef;
+    init(overlayWindowsContainerViewRef: ViewContainerRef, rootMagicElement: Element, changeDetectorRef: ChangeDetectorRef): void;
+    loadAndOpenModule(formName: string, taskId: string, taskDescription: string): void;
+    open(formName: string, taskId: string, taskDescription: string): void;
+    close(commandStr: string): void;
+    /**
+     * Open Confirmation box
+     * @param title title of the box
+     * @param msg message
+     * @param style Magic style
+     */
+    openConfirmationBox(title: string, msg: string, style: Styles): void;
+    /**
+     * This method is called on close of the confirmation
+     * @param style Magic style
+     * @param result
+     */
+    finishConfirmation(style: Styles, result: boolean): void;
+    /**
+     * creates a modal component. Can be used for overlay, message box or confirmation box
+     * @param parameters component's parameters
+     * @param component components to create
+     */
+    private createModalComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayWindowService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayWindowService>;
+}
+
+/**
+ * Main service to connect the UI with the Magic WebCLient
+ */
+declare class TaskMagicService {
+    protected magic: EngineMagicService;
+    private overlayWindowService;
+    /**
+     * Service to provide table-related functionalities
+     */
+    tableService: any;
+    /**
+     * Collection of data for all controls
+     */
+    Records: any;
+    /**
+     * FormGroup collection for line mode
+     */
+    formGroups: Array<FormGroup>;
+    /**
+     * FormGroup for all controls in screen mode
+     */
+    ScreenModeControls: FormGroup;
+    /**
+     * @ignore
+     */
+    refreshDom: Subject<GuiCommand>;
+    /**
+     * @ignore
+     */
+    subscribeRefreshDom: Subscription;
+    /**
+     * @ignore
+     */
+    detectChanges: Subject<any>;
+    /**
+     * @ignore
+     */
+    subscribeInteractiveCommands: Subscription;
+    /**
+     * @ignore
+     */
+    interactiveCommands: Subject<GuiInteractive>;
+    /**
+     * @ignore
+     * This event is emitted when the selected row in a table changes.
+     */
+    OnSelectedRowChanged: EventEmitter<string>;
+    /**
+     * @ignore
+     */
+    customPropertiesSubject: Subject<any>;
+    /**
+     * @ignore
+     */
+    recordsCountChangeSubject: Subject<any>;
+    mgLoadSubject: Subject<any>;
+    /**
+     * @ignore
+     */
+    template: {
+        [id: string]: string;
+    };
+    /**
+     * Service to provide subform-related functionalities
+     */
+    mgSubformService: SubformMagicService;
+    /**
+     * Service to provide the title-change functionality
+     */
+    mgTitleService: TitleMagicService;
+    /**
+     * Service which enables getting/setting values from/to the Magic WebClient engine
+     */
+    mgAccessorService: AccessorMagicService;
+    mgInputDateFormat: any;
+    /**
+     * @ignore
+     */
+    oldPageSize: number;
+    /**
+     *
+     * @param  magic
+     */
+    constructor(magic: EngineMagicService, overlayWindowService: OverlayWindowService);
+    /**
+    * returns true if used is logged in
+    * @returns
+    */
+    getIsLoggenIn(): boolean;
+    /**
+     * Id of task to which this service refers
+     */
+    _taskId: string;
+    /**
+     * returns the task Id
+     * @returns
+     */
+    get taskId(): string;
+    /**
+     * Sets the task Id
+     * @param value the task id to set
+     */
+    set taskId(value: string);
+    /**
+     * Returns the task's data in Screen mode
+     * @returns
+     */
+    get ScreenControlsData(): any;
+    /**
+     * @ignore
+     */
+    settemplate(value: any): void;
+    /**
+     * Builds the FormControl for each and every control
+     */
+    buildScreenModeControls(): void;
+    /**
+     * Is the control a table control
+     * @param id Id of the control
+     * @returns
+     */
+    isTableControl(id: string): boolean;
+    getMgInputDateFormat(): string;
+    /**
+     * Returns the FormControl of a control
+     * @param guiRowid Id of the requested row
+     * @param id Id of the control
+     * @returns
+     */
+    getFormControl(guiRowid: string, id: string): AbstractControl;
+    /**
+     * handle the change of text for input control inside table
+     * @param  guiRowId Id of the row for which the FormControls are built
+     * set the new value of the formcontrol
+     */
+    setInputTextValue(controlId: string, guiRowid: string, val: any): void;
+    /**
+     * Build the FormControls for a table row
+     * @param  guiRowId Id of the row for which the FormControls are built
+     */
+    buildTableRowControls(guiRowId: number): void;
+    /**
+     *
+     * @ignore
+     */
+    updateRecordsBeforeCurrentView(value: number): void;
+    /**
+     * @ignore
+     */
+    setIncludesFirst(value: boolean): void;
+    /**
+     * @ignore
+     */
+    setIncludesLast(value: boolean): void;
+    /**
+     * @ignore
+     */
+    markRowAsCreated(guiRowId: number): void;
+    /**
+     * @ignore
+     */
+    markRowAsNotCreated(guiRowId: number): void;
+    /**
+     * @ignore
+     */
+    startRowEditing(guiRowId: number): void;
+    /**
+     * @ignore
+     */
+    stopRowEditing(guiRowId: number): void;
+    /**
+     * @ignore
+     */
+    isRowInRowEditing(guiRowId: string): boolean;
+    /**
+     * @ignore
+     */
+    setIsEmptyDataView(isEmpty: boolean): void;
+    /**
+     * Initialize the service to work with the task
+     * @param taskId Id of the task
+     * @param taskDescription
+     */
+    initTask(taskId: any, taskDescription: any): void;
+    /**
+     * @ignore
+     */
+    refreshView(): void;
+    /**
+     * Insert an event to the Magic WebClient event queue
+     * @param guiEvent The event to insert
+     */
+    insertEvent(guiEvent: IGuiEvent): void;
+    /**
+     * @ignore
+     */
+    GetControlPictureMask(controlName: string): any;
+    /**
+     * @ignore
+     */
+    UploadFileToServer(fileContent: any, serverFileName: string): any;
+    DownloadFileFromServer(serverFileName: string): Promise<ArrayBuffer>;
+    /**
+     * Validates the control value, using the Magic WebClient
+     * @param controlName Id of validated control
+     * @param value value to be validated
+     * @returns If validation fails, returns error message, else returns null
+     */
+    ValidateControlValue(controlName: string, value: any): string;
+    /**
+     * @ignore
+     */
+    GetRangedValue(controlName: string, value: string): string;
+    /**
+     * @ignore
+     */
+    GetFldRanges(controlName: string): string;
+    /**
+     * returns the value of a property of the control
+     * @param controlId Id of control
+     * @param prop Property
+     * @param guiRowId Row Id, if applicable
+     * @returns Property value
+     */
+    getProperty(controlId: string, prop: HtmlProperties, guiRowId?: string): any;
+    /**
+     * @ignore
+     */
+    getPropertyStub(ControlsProperties: any, controlId: any, prop: any): any;
+    /**
+     * @ignore
+     */
+    getStyleStub(ControlsProperties: any, controlId: any, styleName: string): any;
+    /**
+     * Return the CSS classes used for this control
+     * @param controlId Id of control
+     * @param guiRowId Row Id, if applicable
+     * @returns String containing the classes currently defined for this control
+     */
+    getClasses(controlId: string, guiRowId?: string): string;
+    /**
+     * Return the value of a style used for a control
+     * @param controlId Id of control
+     * @param styleName Name of style
+     * @param guiRowId Row Id, if applicable
+     * @returns value of style of the control
+     */
+    getStyle(controlId: string, styleName: string, guiRowId?: string): string;
+    /**
+     * Return the value of a control
+     * @param controlId Id of control
+     * @param guiRowId Row Id, if applicable
+     * @returns value of the control
+     */
+    getValue(controlId: string, guiRowId?: string): any;
+    /**
+     * Return the formatted value of a control
+     * @param controlId Id of control
+     * @param guiRowId Row Id, if applicable
+     * @returns value of the control
+     */
+    getFormattedValue(controlName: string, val: any, rowId?: string): string;
+    /**
+     * Sets the value of a control
+     * @param controlId Id of control
+     * @param guiRowId Row Id, if applicable
+     * @param value Value to set
+     */
+    setValue(controlId: string, guiRowId: string, value: any): void;
+    /**
+     * @ignore
+     */
+    protected executeInteractiveCommand(guiInteractiveCommand: GuiInteractive): void;
+    /**
+     * @ignore
+     */
+    handleSetProperty(command: GuiCommand, isTableChild: boolean): void;
+    executeCommand(command: GuiCommand): void;
+    /**
+    custom validator
+    */
+    customValidator(rowid: string, id: string): ValidatorFn;
+    /**
+     * COnvert a value from Magic format to native format
+     * @param controlId Id of control
+     * @param  rowId Row Id, if applicable
+     * @param val Value to convert
+     * @returns Converted value
+     */
+    ConvertValToNative(controlId: string, rowId: number, val: any): any;
+    /**
+     * Convert a value from native to Magic format
+     * @param controlId Id of control
+     * @param  rowId Row Id, if applicable
+     * @param val Value to convert
+     * @returns Converted value
+     */
+    ConvertValFromNative(controlId: string, rowId: number, val: any): any;
+    /**
+     * Handle resize and also fetch chunk of records if having an empty view.
+     * @ignore
+     * @param pageSize : PageSize
+     * @param topGuiRowId : GuiRowId of first record in view.
+     */
+    resize(pageSize: number, topGuiRowId: number): void;
+    /**
+     * Fetches data for new table rows when scrolling done
+     */
+    onScrollDown(): void;
+    /**
+     * Sets the new browser window title
+     * @param newTitle New window title
+     */
+    setTitle(newTitle: string): void;
+    /**
+     * @ignore
+     */
+    getGuiRowId(dvRowId: number, isTableControl: boolean): number;
+    /**
+     *
+     * @ignore
+     */
+    getDvRowId(guiRowId: number): number;
+    /**
+     * Clean up the service when it is no longer needed
+     */
+    dispose(): void;
+    /**
+     * Handle the Combobox "change" event
+     * @param event  The event received from the UI
+     * @param idx Id of the control raising the event
+     * @param line Row Id, if applicable
+     */
+    onComboboxSelectionChanged(event: Event, idx: string, line: number): void;
+    /**
+     * Handle the Listbox "change" event
+     * @param  event The event received from the UI
+     * @param idx Id of the control raising the event
+     */
+    onListBoxSelectionChanged(event: Event, idx: string): void;
+    /**
+     * Handle the Checkbox "change" event
+     * @param  event The event received from the UI
+     * @param idx Id of the control raising the event
+     * @param  rowId Row Id, if applicable
+     */
+    onCheckChanged(event: Event, idx: string, rowId: number): void;
+    /**
+     * Handle tab selection change, caused by UI events
+     * @param idx Id of the control raising the event
+     * @param  layer Id of selected tabpage
+     */
+    mgOnTabSelectionChanged(idx: string, layer: number): void;
+    /**
+     * Handle the Radio button "change" event
+     * @param  event The event received from the UI
+     * @param idx Id of the control raising the event
+     */
+    mgOnRadioSelectionChanged(idx: string): void;
+    /**
+     * Inserts the "close" event to the magic WebClient event queue
+     */
+    close(): void;
+    /**
+     * @ignore
+     */
+    IsStub(): boolean;
+    /**
+     * @ignore
+     */
+    jsonData: string;
+    /**
+     * @ignore
+     */
+    saveData(data: string): void;
+    /**
+     * @ignore
+     */
+    createData(): void;
+    /**
+     * @ignore
+     */
+    loadStubData(stubData: any): void;
+    /**
+     * @ignore
+     */
+    loadData(): void;
+    /**
+     * @ignore
+     */
+    setStubValue(guiRowId: number, fc: FormControl, name: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskMagicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaskMagicService>;
+}
+
+/**
+ * Implements various table-related functionalities
+ */
+declare class TableMagicService {
+    protected componentList: ComponentListMagicService;
+    protected task: TaskMagicService;
+    selectedItem: any;
+    private chunkSize;
+    /**
+     *
+     * @param componentList Component-mapping service
+     * @param task Magic task service
+     */
+    constructor(componentList: ComponentListMagicService, task: TaskMagicService);
+    shouldOpenFieldTextEditor: boolean;
+    /**
+     * Refreshes the DataSource
+     */
+    refreshDataSource(): void;
+    /**
+     * Returns the table page size
+     * chunkSize as default value for non-paginated tables.
+     */
+    getPageSize(): number;
+    setChunkSize(size: number): void;
+    /**
+     * Returns max no of rows in the table.
+     */
+    getMaxRowsInTable(): number;
+    /**
+     * Selects the specified row
+     * @param rowId The row to select
+     */
+    selectRow(rowId: string): void;
+    getSelectedRow(): any;
+    /**
+     * Returns the selected row
+     */
+    selectedRow(): any;
+    /**
+     * Selects the specified page
+     * @param  pageId The page to select
+     */
+    selectPage(pageId: number): void;
+    /**
+     * Returns whether a dialog should be opened for the HTML element
+     * @param  element The HTML element for which a dialog may be needed
+     * @returns
+     */
+    OpenDialogForControl(element: HTMLElement): boolean;
+    /**
+     * Returns the dialog used to edit values
+     */
+    getDialog(): any;
+    /**
+     * Handles the table "scrolled" event
+     */
+    onScrollDown(): void;
+    /**
+     * To be overwitten in specific implelemtations
+     */
+    sortData(e: any): void;
+    /**
+     * To be overwitten in specific implelemtations
+     */
+    mgOnPaginateChange(e: any, changeSelectedRow?: boolean): void;
+    mgOptionChanged(e: any): void;
+    /**
+     * Change the number of lines in a table
+     * @param  size New number of lines in table
+     */
+    updateTableSize(size: number): void;
+    /**
+     * @ignore
+     */
+    setTableTopIndex(value: number): void;
+    /**
+     * @ignore
+     */
+    getTableTopIndex(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableMagicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableMagicService>;
+}
+
+/**
+ * Central place for adding the Magic services
+ */
+declare class MagicServices {
+    task: TaskMagicService;
+    subformService: SubformMagicService;
+    tableService: TableMagicService;
+    titleService: TitleMagicService;
+    mgAccessorService: AccessorMagicService;
+    /**
+     * @ignore
+     */
+    constructor(task: TaskMagicService, subformService: SubformMagicService, tableService: TableMagicService, titleService: TitleMagicService, mgAccessorService: AccessorMagicService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicServices, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MagicServices>;
+}
+
+/**
+ * Base component representing a Magic task
+ */
+declare class TaskBaseMagicComponent implements OnInit, OnDestroy, AfterViewInit {
+    protected ref: ChangeDetectorRef;
+    magicServices: MagicServices;
+    /**
+     * Id of task, used for initializing the task service
+     */
+    taskIdParam: string;
+    /**
+     * @ignore
+     */
+    taskDescription: string;
+    /**
+     * @ignore
+     */
+    magicProperties: typeof MagicProperties;
+    /**
+     *
+     * @param ref changes-detector object
+     * @param magicServices Access point for all Magic services
+     */
+    constructor(ref: ChangeDetectorRef, magicServices: MagicServices);
+    /**
+     * Returns the Magic task service
+     * @returns
+     */
+    get task(): TaskMagicService;
+    /**
+     * Returns the Magic subform service
+     * @returns
+     */
+    get mgSub(): SubformMagicService;
+    /**
+     * Returns the Magic table service
+     * @returns
+     */
+    get tableService(): TableMagicService;
+    /**
+     * Returns the Magic accessor service
+     * @returns
+     */
+    get mg(): AccessorMagicService;
+    /**
+     * Returns the task Id
+     * @returns
+     */
+    get taskId(): string;
+    /**
+     * Returns the FormGroup for screen-mode forms
+     * @returns
+     */
+    get screenFormGroup(): FormGroup;
+    /**
+     * Interface implementation
+     */
+    ngOnInit(): void;
+    /**
+     * @ignore
+     */
+    createFormControlsAccessor(formGroup: FormGroup): void;
+    /**
+     * @ignore
+     */
+    setInputDateFormat(): void;
+    /**
+     * This method is called when the value of any custom property is updated in Magic
+     * propertyName : name of property which is updated. The format is <controlname>~<propertyname>
+     * rowId : row number of the updated property for controls in table control (0 for controls outside table)
+     * value : updated value of the property
+     * @returns : void
+     * To use the method override it in your component and check the property name and write you code ..for eg
+     * if(propertyName == 'controlname~propertyName') {// your code}
+     *  else { // your code}
+     */
+    PropertyChanged(propertyName: string, rowId: number, value: any): void;
+    /**
+     * Records count change subject is subscribed to change in its value. This method will be called
+     * as the value of records count is received at from server.
+     * @returns : void
+     * To use the method override it in your component.
+     */
+    RecordsCountChanged(recordsCount: number): void;
+    /**
+     * This method will be called once engine informs UI about loading of first set of data is sent to client
+     * and client has reached its first idle time.
+     * @returns : void
+     * To use the method override it in your component.
+     */
+    mgOnLoad(): void;
+    /**
+     * Interface implementation
+     */
+    ngAfterViewInit(): void;
+    ngAfterContentChecked(): void;
+    /**
+     * Interface implementation
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskBaseMagicComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaskBaseMagicComponent, "task-magic", never, { "taskIdParam": { "alias": "taskIdParam"; "required": false; }; "taskDescription": { "alias": "taskDescription"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * @ignore
+ */
+declare class RowMagicDirective implements OnInit, OnDestroy {
+    protected _task: TaskMagicService;
+    protected element: ElementRef;
+    rowId: string;
+    /**
+     * The HTML element connected to this directive
+     */
+    protected htmlElement: HTMLElement;
+    /**
+     * @ignore
+     */
+    private rowChangedSubscriber;
+    constructor(_task: TaskMagicService, element: ElementRef);
+    /**
+     * Initializes this object
+     */
+    ngOnInit(): void;
+    private isInView;
+    /**
+     * Cleanup
+     */
+    ngOnDestroy(): void;
+    onClick($event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowMagicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RowMagicDirective, "[magicRow]", never, { "rowId": { "alias": "magicRow"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Connects HTML elements to the Magic Web Client engine
+ */
+declare class MagicDirective implements OnInit, OnDestroy {
+    protected _task: TaskMagicService;
+    protected element: ElementRef;
+    protected renderer: Renderer2;
+    protected vcRef: ViewContainerRef;
+    platform: Platform;
+    protected magicRow: RowMagicDirective;
+    set magic(val: any);
+    /**
+     * This flag is used when we only want to register to events, but do not want to execute commands sent from server
+     */
+    set eventsOnly(val: any);
+    /**
+     * pollTime: after which value will be sent to magic
+     */
+    pollTime: number;
+    /**
+     * Row id of the control, for when it is on a table
+     */
+    rowId: string;
+    /**
+     *
+     */
+    /**
+     * The HTML element connected to this directive
+     */
+    protected htmlElement: HTMLElement;
+    /**
+     * Magic's component handling this control
+     */
+    component: TaskBaseMagicComponent;
+    /**
+     * Collection of event handlers for this element
+     */
+    private eventHandlers;
+    /**
+     * Id of this element
+     */
+    id: string;
+    /**
+     * @ignore
+     */
+    protected selector: string;
+    /**
+     * @ignore
+     */
+    subscribeRefreshDom: Subscription;
+    private focusUnlistener;
+    eventsOnlyVal: boolean;
+    static opened: boolean;
+    static noOfAutoCompleteBoxesOpened: number;
+    subscribeInteractiveCommands: Subscription;
+    /**
+     *
+     * @param _task The task service
+     * @param element The element for which the directive is applied
+     * @param renderer Renderer for the element
+     * @param vcRef
+     * @param platform
+     * @param magicRow
+     */
+    constructor(_task: TaskMagicService, element: ElementRef, renderer: Renderer2, vcRef: ViewContainerRef, platform: Platform, magicRow: RowMagicDirective);
+    /**
+     * Get the task service
+     * @returns
+     */
+    get task(): TaskMagicService;
+    /**
+     * Register to the events this element may need to handle
+     */
+    protected regEvents(): void;
+    /**
+     * Handle focus event
+     */
+    private OnFocus;
+    /**
+     * Is the command's element the same as this directive's element
+     * @param command
+     * @returns true/false
+     */
+    IsSameElement(command: any): boolean;
+    /**
+     * Is the command's element the same as this directive's component
+     * @param command
+     * @returns true/false
+     */
+    private IsSameComponent;
+    /**
+     * @ignore
+     */
+    private regUpdatesUI;
+    /**
+     * Initializes this object
+     */
+    ngOnInit(): void;
+    /**
+     * Handles the commands received from the Magic WebClient engine
+     * @param command
+     */
+    handleCommand(command: GuiCommand): void;
+    /**
+     * handle the interactive commands like CallJS
+     */
+    handleInteractiveCommands(command: GuiInteractive): void;
+    /**
+     * Handle the Magic set-property command
+     * @param command
+     */
+    handleSetProperty(command: GuiCommand): void;
+    /**
+     * Cleanup
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicDirective, [null, null, null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MagicDirective, "[magic]", never, { "magic": { "alias": "magic"; "required": false; }; "eventsOnly": { "alias": "eventsOnly"; "required": false; }; "pollTime": { "alias": "pollTime"; "required": false; }; "rowId": { "alias": "rowId"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Directive for checkboxes, to handle the 'change' event
+ */
+declare class CheckboxMagicDirective {
+    protected magicDirective: MagicDirective;
+    private el;
+    protected task: TaskMagicService;
+    threeState: boolean;
+    private subscribeRefreshDom;
+    private isIndeterminate;
+    /**
+     * @ignore
+     */
+    constructor(magicDirective: MagicDirective, el: ElementRef, task: TaskMagicService);
+    /**
+     * Handles the Checkbox 'change' event - pass it to the Magic engine
+     */
+    onChange($event: any): void;
+    ngOnInit(): void;
+    private regUpdatesUI;
+    handleCommand(command: GuiCommand): void;
+    private handleThreeState;
+    /**
+     * Cleanup
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxMagicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CheckboxMagicDirective, "    input[type=checkbox][magic]:not([noFormControl])", never, { "threeState": { "alias": "threeState"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Directive for checkboxes which should not have a form control
+ */
+declare class CheckboxNoFormControlMagicDirective {
+    protected magicDirective: MagicDirective;
+    constructor(magicDirective: MagicDirective);
+    /**
+     * Handle the 'Checkbox' change event - pass it to the Magic engine
+     */
+    onChange($event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxNoFormControlMagicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CheckboxNoFormControlMagicDirective, "    input[type=checkbox][magic]:([noFormControl])       ", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * Directive for non-checkbox input controls which do not have a form control
+ */
+declare class InputNoFormControlMagicDirective {
+    protected magicDirective: MagicDirective;
+    constructor(magicDirective: MagicDirective);
+    /**
+     * Handles the 'change' event - pass it to the Magic engine
+     */
+    onChange($event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputNoFormControlMagicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputNoFormControlMagicDirective, "input[magic]:([noFormControl]):not([type=checkbox]),             textarea[magic]:([noFormControl]):not([type=checkbox])", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * Directive for comboboxes, to handle the 'change' event
+ */
+declare class ComboboxMagicDirective {
+    protected magicDirective: MagicDirective;
+    constructor(magicDirective: MagicDirective);
+    /**
+     * Handles the Combobox 'change' event - pass it to the Magic engine
+     */
+    onChange($event: any): void;
+    /**
+     * To refresh Combobox selection as per selected property.
+     */
+    onComboboxItemsListChanged(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxMagicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboboxMagicDirective, "select[magic]:not([multiple])", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * @ignore
+ */
+declare const CHECKBOX_VALUE_ACCESSOR: any;
+/**
+ * Value accessor for Checkbox without a FormControl
+ */
+declare class MagicCheckboxControlValueAccessor extends CheckboxControlValueAccessor {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicCheckboxControlValueAccessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MagicCheckboxControlValueAccessor, "      input[type=checkbox][magic]:not([formControlName]):not([no-form-control]),      input[type=checkbox][magic]:not([formControl]),      input[type=checkbox][magic]:not([ngModel])    ", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * @ignore
+ */
+declare const MAGIC_DEFAULT_VALUE_ACCESSOR: any;
+/**
+ * @ignore
+ */
+declare class MagicDefaultValueAccessor extends DefaultValueAccessor {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicDefaultValueAccessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MagicDefaultValueAccessor, "    input[magic]:not([type=checkbox]):not([formControlName]):not([no-form-control]),    textarea[magic]:not([formControlName]):not([noFormControl]):not([no-form-control])  ", ["magic"], {}, {}, never, never, false, never>;
+}
+
+declare const DATE_VALUE_ACCESSOR: any;
+/**
+ * The accessor for writing a value and listening to changes on a date input element
+ *
+ *  ### Example
+ *  `<input type="date" name="birthday" ngModel dateInput>`
+ *  OR
+ *  `<input type="date" formControlName="birthday" dateInput>`
+ */
+declare class DateValueAccessor implements ControlValueAccessor {
+    private renderer;
+    private elementRef;
+    protected magicDir: MagicDirective;
+    protected _task: TaskMagicService;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    onBlurEvent(event: any): void;
+    constructor(renderer: Renderer2, elementRef: ElementRef, magicDir: MagicDirective, _task: TaskMagicService);
+    /** Format year, if user enters 2 digits instead of 4 digits as per the century given in Magic.ini file */
+    formatDateWithCentury(userInput: string, century: number, control: AbstractControl): void;
+    /** Writes a new value to the element (model -> view) */
+    writeValue(value: Date): void;
+    /** Registers a callback function, called when value changes (view -> model) */
+    registerOnChange(fn: (_: any) => void): void;
+    /** Registers a callback function, called when the control is blurred */
+    registerOnTouched(fn: () => void): void;
+    /** Enables or disables the element when the control status changes */
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateValueAccessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DateValueAccessor, "[dateInput]", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * This is a base class for the magic alert components
+ */
+declare class BaseMagicAlertComponent {
+    /**
+     * title of the component
+     */
+    title: string;
+    /**
+     * message of the component
+     */
+    message: string;
+    /**
+     * onClose Event - to be raised when the component is closed
+  
+     */
+    onClose: EventEmitter<void>;
+    /**
+     * close magic alert
+     */
+    OnClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseMagicAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseMagicAlertComponent, "mg-base-alert", never, { "title": { "alias": "title"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, { "onClose": "onClose"; }, never, never, false, never>;
+}
+
+/***
+ * This is sample component for the alert message
+ */
+declare class MagicAlertComponent extends BaseMagicAlertComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MagicAlertComponent, "sample-magic-alert-component", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * This is a base class for the magic confirm components
+ */
+declare class BaseMagicConfirmComponent {
+    /**
+     * title of the component
+     */
+    title: string;
+    /**
+     * message of the component
+     */
+    message: string;
+    /**
+     * onClose Event - to be raised when the component is closed
+     * should pass true when OK is pressed and false when cancel is pressed
+     */
+    onClose: EventEmitter<boolean>;
+    /**
+     * raises close Event
+     * @param result true when OK is pressed and false when cancel is pressed
+     *
+     */
+    OnClose(result: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseMagicConfirmComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseMagicConfirmComponent, "mg-base-confirm", never, { "title": { "alias": "title"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, { "onClose": "onClose"; }, never, never, false, never>;
+}
+
+/***
+ * This is sample component for the confirmation box
+ */
+declare class MagicConfirmationBoxComponent extends BaseMagicConfirmComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicConfirmationBoxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MagicConfirmationBoxComponent, "sample-magic-confirmation-box", never, {}, {}, never, never, false, never>;
+}
+
+declare class MagicOverlayContainerWrapper implements IMagicViewContainerRef {
+    private componentListMagicService;
+    private magicLazyModuleLoader;
+    private injector;
+    private changeDetectorRef;
+    private compiler;
+    /**
+     *
+     */
+    Component: any;
+    /**
+     *
+     */
+    Parameters: any;
+    private OverlayTypeParam;
+    private onClose;
+    /**
+     * HTML to be displayed in the modal window
+     */
+    overlayContentViewContainerRef: ViewContainerRef;
+    overlayContainerWrapperElementRef: ElementRef;
+    /**
+     * @ignore
+     * contais data of allowed base components to use
+     */
+    static allowedBaseComps: Map<number, {
+        comp: any;
+        error: string;
+    }>;
+    /**
+     *
+     * @param componentFactoryResolver
+     */
+    constructor(componentListMagicService: ComponentListMagicService, magicLazyModuleLoader: MagicLazyLoaderService, injector: Injector, changeDetectorRef: ChangeDetectorRef, compiler: Compiler);
+    /**
+     *
+     */
+    ngOnInit(): void;
+    private loadComponent;
+    setViewContainerRef(vcRef: ViewContainerRef): void;
+    GetRootElement(): HTMLElement;
+    DetectChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicOverlayContainerWrapper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MagicOverlayContainerWrapper, "app-magic-overlay-container-wrapper", never, { "Component": { "alias": "Component"; "required": false; }; "Parameters": { "alias": "Parameters"; "required": false; }; "OverlayTypeParam": { "alias": "OverlayTypeParam"; "required": false; }; }, { "onClose": "onClose"; }, never, never, false, never>;
+}
+
+/**
+ * This service supports custom actions on magic exit
+ */
+declare class ExitMagicService {
+    /**
+     * Override this method to implement custom logic on magic exit
+     */
+    exitMagic(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExitMagicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExitMagicService>;
+}
+
+/**
+ * Root Magic component
+ */
+declare class MagicShellComponent implements AfterViewInit, IMagicViewContainerRef {
+    protected engineMagicService: EngineMagicService;
+    protected componentList: ComponentListMagicService;
+    protected changeDetectorRef: ChangeDetectorRef;
+    private titleService;
+    private overlayWindowService;
+    private httpClient;
+    private pendingCommandsCollector;
+    private route;
+    private router;
+    exitMagicService: ExitMagicService;
+    /**
+     * Root component to be displayed in the window
+     */
+    RootComponent: Component;
+    /**
+     * parameters for the Root Component
+     */
+    RootComponentParameters: any;
+    overlayWindowsContainerViewRef: ViewContainerRef;
+    rootMagicElementRef: ElementRef;
+    SpinnerTemplate: TemplateRef<any>;
+    showSpinner: boolean;
+    magicEngineTerminated: boolean;
+    /**
+     *
+     * @param magic Magic's service
+     * @param componentList Magic component list
+     * @param changeDetectorRef Changes detector
+     * @param titleService Title setting service
+     * @param httpClient The native httpClient instance
+     * @param exitMagicService Magic exit service
+     */
+    constructor(engineMagicService: EngineMagicService, componentList: ComponentListMagicService, changeDetectorRef: ChangeDetectorRef, titleService: Title, overlayWindowService: OverlayWindowService, httpClient: HttpClient, pendingCommandsCollector: CommandsCollectorMagicService, route: ActivatedRoute, router: Router, exitMagicService: ExitMagicService);
+    /**
+     * Before-unload event listener
+     * @param event
+     */
+    onBeforeUnload(event: any): string;
+    onUnload(event: any): void;
+    ngAfterViewInit(): void;
+    setViewContainerRef(vcRef: ViewContainerRef): void;
+    /**
+     * Initialization of Magic mechanisms
+     */
+    initialize(): void;
+    /**
+     * Set the title
+     */
+    setTitle(): void;
+    /**
+     * Set the component according to requested form
+     * @param formName Name of the form to open
+     * @param taskId Id of opening task
+     * @param taskDescription TODO
+     * @param isModal whether modal window is being opened
+     */
+    private setComponent;
+    /**
+     * @ignore
+     */
+    registerUICommands(): void;
+    /**
+     * Execute commands received from the Magic WebClient engine
+     * @param command
+     */
+    executeCommand(command: GuiCommand): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicShellComponent, [null, null, null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MagicShellComponent, "magic-root", never, { "SpinnerTemplate": { "alias": "SpinnerTemplate"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Represents a Magic subform
+ */
+declare class SubformMagicComponent {
+    private vcRef;
+    protected mgSub: SubformMagicService;
+    /**
+      * @ignore
+      */
+    id: string;
+    /**
+     * @ignore
+     */
+    set magic(val: any);
+    /**
+     * @ignore
+     */
+    component: TaskBaseMagicComponent;
+    /**
+     * @ignore
+     */
+    constructor(vcRef: ViewContainerRef, mgSub: SubformMagicService);
+    /**
+     * @ignore
+     */
+    get Component(): Component;
+    /**
+     * @ignore
+     */
+    get Parameters(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubformMagicComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SubformMagicComponent, "magic-subform", never, { "magic": { "alias": "magic"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Represents a Magic subform
+ */
+declare class ErrorMagicComponent {
+    protected _task: TaskMagicService;
+    mgService: AccessorMagicService;
+    protected changeDetectorRef: ChangeDetectorRef;
+    /**
+     * @ignore
+     */
+    id: string;
+    rowId: string;
+    /**
+     * @ignore
+     */
+    set magic(val: any);
+    set rowId1(val: any);
+    defaultDisplay: boolean;
+    set CustomContent(innerComponent: ElementRef);
+    /**
+     * @ignore
+     */
+    constructor(_task: TaskMagicService, mgService: AccessorMagicService, changeDetectorRef: ChangeDetectorRef);
+    /**
+     * returns true if the html element has no children
+     * @param element
+     */
+    isEmpty(element: HTMLElement): boolean;
+    /**
+     * @ignore
+     */
+    HasErrors(id: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorMagicComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorMagicComponent, "mgError", never, { "magic": { "alias": "magic"; "required": false; }; "rowId1": { "alias": "rowId"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+/**
+ * @ignore
+ */
+declare class NoControlMagicDirective extends MagicDirective {
+    set magic(val: any);
+    constructor(_task: TaskMagicService, element: ElementRef, renderer: Renderer2, vcRef: ViewContainerRef, platform: Platform, magicRow: RowMagicDirective);
+    regEvents(): void;
+    isTabControl(): boolean;
+    isRadio(): boolean;
+    handleCommand(command: GuiCommand): void;
+    handleSetProperty(command: GuiCommand): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoControlMagicDirective, [null, null, null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NoControlMagicDirective, "[magicnc]", never, { "magic": { "alias": "magicnc"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Perform Magic validation on input controls which hold alphanumeric strings
+ */
+declare class MgformatMagicDirective {
+    protected magicDir: MagicDirective;
+    protected _task: TaskMagicService;
+    datePasteFlag: boolean;
+    /**
+     * @ignore
+     */
+    constructor(magicDir: MagicDirective, _task: TaskMagicService);
+    ngAfterViewInit(): void;
+    /**
+     * @ignore
+     */
+    /**
+     * This can be used to set pattern
+     * On input, verifies the input matches the required mask
+     */
+    onFocusEvent($event: any): void;
+    onPaste(event: ClipboardEvent): void;
+    onInputEvent(event: any): void;
+    dateMasking(event: any): void;
+    /**
+     * @ignore
+     */
+    onChangeEvent(event: any): void;
+    onBlurEvent(event: any): void;
+    /** Format year, if user enters 2 digits instead of 4 digits as per the century given in Magic.ini file */
+    formatDateWithCentury(userInput: string, century: number, control: AbstractControl): void;
+    updateYear(day: number, month: string, year: number, separator: string, century: number, centuryVal: number, control: AbstractControl): void;
+    getDateSegments1(dateArray: any): any[];
+    getDateSegments2(dateArray: any): any[];
+    getDateSegments3(dateArray: any): any[];
+    getDateSegments4(dateArray: any): any[];
+    /**
+     * @ignore
+     */
+    calculatePattern(): void;
+    formatDate(pic: PIC): void;
+    /**
+     * @ignore
+     */
+    formatAlphaUnicode(control: AbstractControl): void;
+    /**
+     * @ignore
+     */
+    formatBoolean(control: AbstractControl): void;
+    /**
+     * @ignore
+     */
+    generatePattern(attribute: StorageAttribute, pic: PIC): string;
+    /**
+     * @ignore
+     */
+    generatePatternForNumber(pic: PIC): string;
+    /**
+     * @ignore
+     */
+    isPatternGenerationNeeded(attr: StorageAttribute, pic: PIC): boolean;
+    /**
+     * @ignore
+     */
+    generatePatternForAlpha(pic: PIC): string;
+    /**
+     * @ignore
+     */
+    getDirectiveCount(mask: string, idx: number, pattern: string, changeInPattern: RefParam<boolean>): number;
+    /**
+     * @ignore
+     */
+    IsPatternMatches(mask: string, pattern: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MgformatMagicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MgformatMagicDirective, "[mgFormat]", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * @ignore
+ */
+declare class Constants {
+    static readonly DATE_FMT = "dd/MMM/yyyy";
+}
+/**
+ * @ignore
+ */
+declare class DateMagicPipe extends DatePipe implements PipeTransform {
+    protected _task: TaskMagicService;
+    constructor(_task: TaskMagicService);
+    transform(value: any, controlId: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateMagicPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateMagicPipe, "magicDate", false>;
+}
+declare class MgDateFormatter {
+    ConvertMgDateFormatToAngular(mgDateMask: string): string;
+}
+
+/**
+ * @ignore
+ */
+declare class TimeMagicPipe extends DatePipe implements PipeTransform {
+    protected _task: TaskMagicService;
+    constructor(_task: TaskMagicService);
+    transform(value: any, controlId: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeMagicPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TimeMagicPipe, "magicTime", false>;
+}
+
+/**
+ * Validates the field range.
+ */
+declare class RangeValidatorMagicDirective implements Validator {
+    protected _task: TaskMagicService;
+    protected vcRef: ViewContainerRef;
+    /**
+     *
+     * @param _task The task service
+     * @param vcRef
+     */
+    constructor(_task: TaskMagicService, vcRef: ViewContainerRef);
+    /**
+     * Validation method
+     * @param c FormControl to validate
+     * @returns If validation fails, return error message, else returns null
+     */
+    validate(c: FormControl): {
+        rangevalidator: {
+            errorMsg: string;
+        };
+    };
+    /**
+     * @ignore
+     */
+    getControlName(c: FormControl): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangeValidatorMagicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RangeValidatorMagicDirective, "[rangevalidator] ", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * Responsible for connecting HTML elements to the Magic WebClient engine showing it is not Magic Control but a Dummy control which is used to notify only receeive focus event for now
+ */
+declare class NonMagicControlDirective implements OnInit {
+    protected _task: TaskMagicService;
+    protected element: ElementRef;
+    protected renderer: Renderer2;
+    protected vcRef: ViewContainerRef;
+    set magic(val: any);
+    /**
+     * The HTML element connected to this directive
+     */
+    protected htmlElement: HTMLElement;
+    /**
+     * Magic's component handling this control
+     */
+    component: TaskBaseMagicComponent;
+    /**
+     * Collection of event handlers for this element
+     */
+    private eventHandlers;
+    /**
+     * Id of this element
+     */
+    id: string;
+    /**
+     * @ignore
+     */
+    protected selector: string;
+    /**
+     * @ignore
+     */
+    subscribeRefreshDom: Subscription;
+    eventsOnlyVal: boolean;
+    /**
+     *
+     * @param _task The task service
+     * @param element The element for which the directive is applied
+     * @param renderer Renderer for the element
+     * @param vcRef
+     */
+    constructor(_task: TaskMagicService, element: ElementRef, renderer: Renderer2, vcRef: ViewContainerRef);
+    /**
+     * Get the task service
+     * @returns
+     */
+    get task(): TaskMagicService;
+    /**
+     * Register to the events this element may need to handle
+     */
+    protected regEvents(): void;
+    /**
+     * Handle focus event
+     */
+    private OnFocus;
+    /**
+     * Initialize this object
+     */
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NonMagicControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NonMagicControlDirective, "[NonMagicControl]", never, { "magic": { "alias": "NonMagicControl"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Directive for setting focus on element
+ */
+declare class MagicFocusDirective {
+    private hostElement;
+    constructor(hostElement: ElementRef);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicFocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MagicFocusDirective, "[magicFocus]", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * Directive for setting  ViewContainerRef on element
+ */
+declare class MagicViewContainerRef {
+    private vcRef;
+    constructor(vcRef: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicViewContainerRef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MagicViewContainerRef, "[magicViewContainerRef]", never, {}, {}, never, never, false, never>;
+}
+
+declare class Time24MagicPipe implements PipeTransform {
+    protected _task: TaskMagicService;
+    constructor(_task: TaskMagicService);
+    transform(value: any, controlId: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Time24MagicPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<Time24MagicPipe, "magicTime24", false>;
+}
+
+/**
+ * @ignore
+ */
+declare class MagicModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MagicModule, [typeof MagicDirective, typeof CheckboxMagicDirective, typeof CheckboxNoFormControlMagicDirective, typeof InputNoFormControlMagicDirective, typeof ComboboxMagicDirective, typeof RowMagicDirective, typeof MagicCheckboxControlValueAccessor, typeof MagicDefaultValueAccessor, typeof DateValueAccessor, typeof TaskBaseMagicComponent, typeof MagicOverlayContainer, typeof MagicAlertComponent, typeof MagicConfirmationBoxComponent, typeof BaseMagicAlertComponent, typeof BaseMagicConfirmComponent, typeof MagicOverlayContainerWrapper, typeof RouterContainerMagicComponent, typeof MagicShellComponent, typeof SubformMagicComponent, typeof ErrorMagicComponent, typeof NoControlMagicDirective, typeof MgformatMagicDirective, typeof DateMagicPipe, typeof TimeMagicPipe, typeof RangeValidatorMagicDirective, typeof NonMagicControlDirective, typeof MagicFocusDirective, typeof MagicViewContainerRef, typeof Time24MagicPipe], [typeof i30.CommonModule, typeof i31.FormsModule, typeof i31.ReactiveFormsModule, typeof i32.RouterModule, typeof i33.DynamicModule, typeof i34.CdkDragHandle, typeof i34.CdkDrag, typeof i34.DragDropModule], [typeof MagicDirective, typeof CheckboxMagicDirective, typeof CheckboxNoFormControlMagicDirective, typeof InputNoFormControlMagicDirective, typeof ComboboxMagicDirective, typeof RowMagicDirective, typeof MagicCheckboxControlValueAccessor, typeof MagicDefaultValueAccessor, typeof DateValueAccessor, typeof TaskBaseMagicComponent, typeof MagicOverlayContainer, typeof MagicAlertComponent, typeof MagicConfirmationBoxComponent, typeof BaseMagicAlertComponent, typeof BaseMagicConfirmComponent, typeof MagicOverlayContainerWrapper, typeof RouterContainerMagicComponent, typeof MagicShellComponent, typeof SubformMagicComponent, typeof ErrorMagicComponent, typeof NoControlMagicDirective, typeof MgformatMagicDirective, typeof DateMagicPipe, typeof TimeMagicPipe, typeof RangeValidatorMagicDirective, typeof NonMagicControlDirective, typeof MagicFocusDirective, typeof MagicViewContainerRef, typeof Time24MagicPipe, typeof i35.MaskitoModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MagicModule>;
+}
+
+declare const MG_FORMATS: {
+    parse: {
+        dateInput: {
+            month: string;
+            year: string;
+            day: string;
+        };
+    };
+    display: {
+        dateInput: string;
+        monthYearLabel: {
+            year: string;
+            month: string;
+        };
+        dateA11yLabel: {
+            year: string;
+            month: string;
+            day: string;
+        };
+        monthYearA11yLabel: {
+            year: string;
+            month: string;
+        };
+    };
+};
+declare class MgDateAdapter extends NativeDateAdapter {
+    protected task: TaskMagicService;
+    localeId: string;
+    mgdtfmt: string;
+    constructor(task: TaskMagicService, localeId: string);
+    parse(value: any): Date | null;
+    format(date: Date, displayFormat: Object): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MgDateAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MgDateAdapter>;
+}
+
+declare const matDateProviders: ({
+    provide: typeof DateAdapter;
+    useClass: typeof MgDateAdapter;
+    useValue?: undefined;
+} | {
+    provide: i0.InjectionToken<_angular_material_core.MatDateFormats>;
+    useValue: {
+        parse: {
+            dateInput: {
+                month: string;
+                year: string;
+                day: string;
+            };
+        };
+        display: {
+            dateInput: string;
+            monthYearLabel: {
+                year: string;
+                month: string;
+            };
+            dateA11yLabel: {
+                year: string;
+                month: string;
+                day: string;
+            };
+            monthYearA11yLabel: {
+                year: string;
+                month: string;
+            };
+        };
+    };
+    useClass?: undefined;
+})[];
+/**
+ * Magic service providers
+ */
+declare const basicMagicProviders: (typeof SubformMagicService | typeof TitleMagicService | typeof AccessorMagicService | typeof TaskMagicService | typeof MagicServices | ({
+    provide: typeof DateAdapter;
+    useClass: typeof MgDateAdapter;
+    useValue?: undefined;
+} | {
+    provide: i0.InjectionToken<_angular_material_core.MatDateFormats>;
+    useValue: {
+        parse: {
+            dateInput: {
+                month: string;
+                year: string;
+                day: string;
+            };
+        };
+        display: {
+            dateInput: string;
+            monthYearLabel: {
+                year: string;
+                month: string;
+            };
+            dateA11yLabel: {
+                year: string;
+                month: string;
+                day: string;
+            };
+            monthYearA11yLabel: {
+                year: string;
+                month: string;
+            };
+        };
+    };
+    useClass?: undefined;
+})[])[];
+declare const magicProviders: (typeof SubformMagicService | typeof TitleMagicService | typeof AccessorMagicService | typeof TaskMagicService | typeof TableMagicService | typeof MagicServices | ({
+    provide: typeof DateAdapter;
+    useClass: typeof MgDateAdapter;
+    useValue?: undefined;
+} | {
+    provide: i0.InjectionToken<_angular_material_core.MatDateFormats>;
+    useValue: {
+        parse: {
+            dateInput: {
+                month: string;
+                year: string;
+                day: string;
+            };
+        };
+        display: {
+            dateInput: string;
+            monthYearLabel: {
+                year: string;
+                month: string;
+            };
+            dateA11yLabel: {
+                year: string;
+                month: string;
+                day: string;
+            };
+            monthYearA11yLabel: {
+                year: string;
+                month: string;
+            };
+        };
+    };
+    useClass?: undefined;
+})[])[];
+
+/**
+ * @ignore
+ */
+declare class StylesMapManager {
+    static StylesMap: Map<string, any>;
+    static MagicPropertyToHtmlAttributeMap: Map<string, string>;
+    static magicValueGetStyle(styleName: string, magicValue: any): string;
+}
+
+/**
+ * @ignore
+ */
+declare class GuiInteractiveExecutor {
+    command: GuiInteractive;
+    component: TaskBaseMagicComponent;
+    task: TaskMagicService;
+    overlayService: OverlayWindowService;
+    Run(): void;
+    static executeInteractiveCommand(task: TaskMagicService, guiIntactiveCommand: GuiInteractive, overlayService: OverlayWindowService): void;
+    private onValue;
+    private onGetRowsInPage;
+    private onGetMaxRowsInPaginatedTable;
+    private OnMessageBox;
+    private OnOpenForm;
+    private OnSetTitle;
+    private OnRefreshPage;
+    private OnGetTopIndex;
+    private OnGetIsRowEditing;
+    private OnGetLastRoute;
+}
+
+/**
+ * Displays a message-box
+ */
+declare class confirmationBox {
+    /**
+     * @ignore
+     */
+    static isConfirmBox(style: Styles): Boolean;
+    /**
+     * Converts the result from the HTML window to the expected result type
+     * @param style Result received from HTML window
+     * @param okWasPressed Was the "OK" pressed
+     * @returns  MessageBox result type
+     */
+    static convertToExcpectedResultBox(style: Styles, okWasPressed: Boolean): Styles;
+    /**
+     * Show a message box as an HTML window
+     * @param title Title of the message box
+     * @param message Message that will be display in the message box
+     * @param style Style that include buttons \ Icons
+     * @returns MessageBox result
+     */
+    static showConfirmationBox(title: string, message: string, style: Styles): boolean;
+}
+
+/**
+ * @ignore
+ */
+declare class utils {
+    static getDistance(control: Element, x: number, y: number): number;
+    static getDimentions(el: any): {
+        x: number;
+        y: number;
+        width: any;
+        height: any;
+    };
+}
+
+/**
+ * @ignore
+ */
+declare class ModalFormDefinition {
+    taskId: string;
+    comp: any;
+    parameters: any;
+}
+
+/**
+ * Describes the behavior of a modal window
+ */
+interface MagicModalInterface {
+    /**
+     * Returns the X coordinate of the modal window
+     */
+    X(): any;
+    /**
+     * Returns the Y coordinate of the modal window
+     */
+    Y(): any;
+    /**
+     * Returns the width of modal window
+     */
+    Width(): string;
+    /**
+     * Returns the height of modal window
+     */
+    Height(): string;
+    /**
+     * Is the modal window centered relatively to the main window
+     */
+    IsCenteredToWindow(): any;
+    /**
+     * Returns the name of the form - title of the modal window
+     */
+    FormName(): any;
+    /**
+     * Should the title bar be displayed
+     */
+    ShowTitleBar(): any;
+    /**
+     * Should the modal window close when the user clicks on the background
+     */
+    ShouldCloseOnBackgroundClick(): any;
+    /**
+     * Is overlay window resizable
+     */
+    IsResizable(): any;
+    /**
+     * Is overlay window movable
+     */
+    IsMovable(): any;
+}
+
+export { AccessorMagicService, BaseMagicAlertComponent, BaseMagicConfirmComponent, BaseMagicOverlayContainer, CHECKBOX_VALUE_ACCESSOR, COLOR_FILE_NAME, CheckboxMagicDirective, CheckboxNoFormControlMagicDirective, ComboboxMagicDirective, CommandsCollectorMagicService, ComponentListMagicService, ConfirmationComponentsMagicProvider, Constants, ControlMetadata, ControlsMetadata, DATE_VALUE_ACCESSOR, DateMagicPipe, DateValueAccessor, EngineMagicService, ErrorMagicComponent, ExitMagicService, GuiInteractiveExecutor, HtmlClasses, InputNoFormControlMagicDirective, MAGIC_BG_COLOR, MAGIC_DEFAULT_VALUE_ACCESSOR, MAGIC_FG_COLOR, MG_FORMATS, MagicAlertComponent, MagicCheckboxControlValueAccessor, MagicColorService, MagicConfirmationBoxComponent, MagicDefaultValueAccessor, MagicDirective, MagicFocusDirective, MagicLazyLoaderService, MagicModule, MagicOverlayContainer, MagicOverlayContainerWrapper, MagicServices, MagicShellComponent, MagicViewContainerRef, MgDateAdapter, MgDateFormatter, MgformatMagicDirective, ModalFormDefinition, NoControlMagicDirective, NonMagicControlDirective, OverlayContainerMagicProvider, OverlayWindowService, RangeValidatorMagicDirective, Records, RouteCommand, RouterCommandsMagicService, RouterContainerMagicComponent, RowMagicDirective, StylesMapManager, SubformMagicComponent, SubformMagicService, TableMagicService, TaskBaseMagicComponent, TaskMagicService, Time24MagicPipe, TimeMagicPipe, TitleMagicService, basicMagicProviders, confirmationBox, magicProviders, matDateProviders, utils };
+export type { ComponentData, IMagicViewContainerRef, ISubformMagicService, MagicModalInterface, ModuleData, RouteDefinition, SubformDefinition };