@magic-xpa/angular 4.1100.0-dev4110.106 → 4.1100.0-dev4110.107

package/src/services/subform.magic.service.d.ts

@@ -0,0 +1,43 @@
+import { Compiler, Component, Injector } from '@angular/core';
+import { TaskMagicService } from './task.magics.service';
+import { List } from '@magic-xpa/mscorelib';
+import { ComponentListMagicService } from './component-list.magic.service';
+import { ActivatedRoute, Router } from '@angular/router';
+import { CommandsCollectorMagicService } from './commands-collector.magic.service';
+import { RouteDefinition } from '../interfaces/sub-form-definition.iterface';
+import { RouteCommand, RouterCommandsMagicService } from '../services/router-commands.magic.service';
+import { ISubformMagicService } from './ISubformMagicService';
+import { RouterContainerMagicComponent } from '../ui/router-container.magic.component';
+import { MagicLazyLoaderService } from './magic.lazy.loader.service';
+import * as i0 from "@angular/core";
+export 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);
+    mgGetComp(subformName: string): Component;
+    mgGetParameters(subformName: string): any;
+    deleteSubformComp(subformControlName: string, formName: string): void;
+    addSubformComp(subformControlName: string, formName: string, taskId: string, taskDescription: any, routerPath: string, params: List<any>, inDefaultOutlet: boolean): void;
+    ExecuteRouteCommand(routeCommand: RouteCommand): void;
+    private PerformRouterNavigate;
+    init(): void;
+    refreshView(): void;
+    static getRelativeRoute(sendActivatedRoute: ActivatedRoute): ActivatedRoute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubformMagicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SubformMagicService>;
+}

package/src/services/table.magic.service.d.ts

@@ -0,0 +1,30 @@
+import { TaskMagicService } from "./task.magics.service";
+import { ComponentListMagicService } from "./component-list.magic.service";
+import * as i0 from "@angular/core";
+export declare class TableMagicService {
+    protected componentList: ComponentListMagicService;
+    protected task: TaskMagicService;
+    selectedItem: any;
+    private chunkSize;
+    constructor(componentList: ComponentListMagicService, task: TaskMagicService);
+    shouldOpenFieldTextEditor: boolean;
+    refreshDataSource(): void;
+    getPageSize(): number;
+    setChunkSize(size: number): void;
+    getMaxRowsInTable(): number;
+    selectRow(rowId: string): void;
+    getSelectedRow(): any;
+    selectedRow(): any;
+    selectPage(pageId: number): void;
+    OpenDialogForControl(element: HTMLElement): boolean;
+    getDialog(): any;
+    onScrollDown(): void;
+    sortData(e: any): void;
+    mgOnPaginateChange(e: any, changeSelectedRow?: boolean): void;
+    mgOptionChanged(e: any): void;
+    updateTableSize(size: number): void;
+    setTableTopIndex(value: number): void;
+    getTableTopIndex(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableMagicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableMagicService>;
+}

package/src/services/task.magics.service.d.ts

@@ -0,0 +1,100 @@
+import { EventEmitter } from '@angular/core';
+import { AbstractControl, FormControl, FormGroup, ValidatorFn } from '@angular/forms';
+import { Subject, Subscription } from 'rxjs';
+import { EngineMagicService } from './engine.magic.service';
+import { GuiCommand, GuiInteractive, HtmlProperties } from '@magic-xpa/gui';
+import { IGuiEvent } from '@magic-xpa/engine';
+import { SubformMagicService } from './subform.magic.service';
+import { TitleMagicService } from './title.magic.service';
+import { AccessorMagicService } from './accessor.magic.service';
+import { OverlayWindowService } from './OverlayWindowService';
+import * as i0 from "@angular/core";
+export declare class TaskMagicService {
+    protected magic: EngineMagicService;
+    private overlayWindowService;
+    tableService: any;
+    Records: any;
+    formGroups: Array<FormGroup>;
+    ScreenModeControls: FormGroup;
+    refreshDom: Subject<GuiCommand>;
+    subscribeRefreshDom: Subscription;
+    detectChanges: Subject<any>;
+    subscribeInteractiveCommands: Subscription;
+    interactiveCommands: Subject<GuiInteractive>;
+    OnSelectedRowChanged: EventEmitter<string>;
+    customPropertiesSubject: Subject<any>;
+    recordsCountChangeSubject: Subject<any>;
+    mgLoadSubject: Subject<any>;
+    template: {
+        [id: string]: string;
+    };
+    mgSubformService: SubformMagicService;
+    mgTitleService: TitleMagicService;
+    mgAccessorService: AccessorMagicService;
+    mgInputDateFormat: any;
+    oldPageSize: number;
+    constructor(magic: EngineMagicService, overlayWindowService: OverlayWindowService);
+    getIsLoggenIn(): boolean;
+    _taskId: string;
+    get taskId(): string;
+    set taskId(value: string);
+    get ScreenControlsData(): any;
+    settemplate(value: any): void;
+    buildScreenModeControls(): void;
+    isTableControl(id: string): boolean;
+    getMgInputDateFormat(): string;
+    getFormControl(guiRowid: string, id: string): AbstractControl;
+    setInputTextValue(controlId: string, guiRowid: string, val: any): void;
+    buildTableRowControls(guiRowId: number): void;
+    updateRecordsBeforeCurrentView(value: number): void;
+    setIncludesFirst(value: boolean): void;
+    setIncludesLast(value: boolean): void;
+    markRowAsCreated(guiRowId: number): void;
+    markRowAsNotCreated(guiRowId: number): void;
+    startRowEditing(guiRowId: number): void;
+    stopRowEditing(guiRowId: number): void;
+    isRowInRowEditing(guiRowId: string): boolean;
+    setIsEmptyDataView(isEmpty: boolean): void;
+    initTask(taskId: any, taskDescription: any): void;
+    refreshView(): void;
+    insertEvent(guiEvent: IGuiEvent): void;
+    GetControlPictureMask(controlName: string): any;
+    ValidateControlValue(controlName: string, value: any): string;
+    GetRangedValue(controlName: string, value: string): string;
+    GetFldRanges(controlName: string): string;
+    getProperty(controlId: string, prop: HtmlProperties, guiRowId?: string): any;
+    getPropertyStub(ControlsProperties: any, controlId: any, prop: any): any;
+    getStyleStub(ControlsProperties: any, controlId: any, styleName: string): any;
+    getClasses(controlId: string, guiRowId?: string): string;
+    getStyle(controlId: string, styleName: string, guiRowId?: string): string;
+    getValue(controlId: string, guiRowId?: string): any;
+    getFormattedValue(controlName: string, val: any, rowId?: string): string;
+    setValue(controlId: string, guiRowId: string, value: any): void;
+    protected executeInteractiveCommand(guiInteractiveCommand: GuiInteractive): void;
+    handleSetProperty(command: GuiCommand, isTableChild: boolean): void;
+    executeCommand(command: GuiCommand): void;
+    customValidator(rowid: string, id: string): ValidatorFn;
+    ConvertValToNative(controlId: string, rowId: number, val: any): any;
+    ConvertValFromNative(controlId: string, rowId: number, val: any): any;
+    resize(pageSize: number, topGuiRowId: number): void;
+    onScrollDown(): void;
+    setTitle(newTitle: string): void;
+    getGuiRowId(dvRowId: number, isTableControl: boolean): number;
+    getDvRowId(guiRowId: number): number;
+    dispose(): void;
+    onComboboxSelectionChanged(event: Event, idx: string, line: number): void;
+    onListBoxSelectionChanged(event: Event, idx: string): void;
+    onCheckChanged(event: Event, idx: string, rowId: number): void;
+    mgOnTabSelectionChanged(idx: string, layer: number): void;
+    mgOnRadioSelectionChanged(idx: string): void;
+    close(): void;
+    IsStub(): boolean;
+    jsonData: string;
+    saveData(data: string): void;
+    createData(): void;
+    loadStubData(stubData: any): void;
+    loadData(): void;
+    setStubValue(guiRowId: number, fc: FormControl, name: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskMagicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaskMagicService>;
+}

package/src/services/title.magic.service.d.ts

@@ -0,0 +1,9 @@
+import { Title } from "@angular/platform-browser";
+import * as i0 from "@angular/core";
+export declare class TitleMagicService {
+    protected titleService: Title;
+    constructor(titleService: Title);
+    setTitle(newTitle: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TitleMagicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TitleMagicService>;
+}

package/src/ui/GuiInteractiveExecutor.d.ts

@@ -0,0 +1,22 @@
+import { GuiInteractive } from '@magic-xpa/gui';
+import { TaskBaseMagicComponent } from './task-base.magic.component';
+import { TaskMagicService } from '../services/task.magics.service';
+import { OverlayWindowService } from '../services/OverlayWindowService';
+export 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;
+}

package/src/ui/components/base-magic-alert.component.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class BaseMagicAlertComponent {
+    title: string;
+    message: string;
+    onClose: EventEmitter<void>;
+    OnClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseMagicAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseMagicAlertComponent, "mg-base-alert", never, { "title": "title"; "message": "message"; }, { "onClose": "onClose"; }, never, never, false, never>;
+}

package/src/ui/components/base-magic-confirm.component.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class BaseMagicConfirmComponent {
+    title: string;
+    message: string;
+    onClose: EventEmitter<boolean>;
+    OnClose(result: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseMagicConfirmComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseMagicConfirmComponent, "mg-base-alert", never, { "title": "title"; "message": "message"; }, { "onClose": "onClose"; }, never, never, false, never>;
+}

package/src/ui/components/magic-alert.component.d.ts

@@ -0,0 +1,6 @@
+import { BaseMagicAlertComponent } from './base-magic-alert.component';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/src/ui/components/magic-confirmation-box.component.d.ts

@@ -0,0 +1,6 @@
+import { BaseMagicConfirmComponent } from './base-magic-confirm.component';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/src/ui/directives/NonMagicControlDirective.d.ts

@@ -0,0 +1,26 @@
+import { ElementRef, OnInit, Renderer2, ViewContainerRef } from '@angular/core';
+import { TaskBaseMagicComponent } from '../task-base.magic.component';
+import { TaskMagicService } from '../../services/task.magics.service';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class NonMagicControlDirective implements OnInit {
+    protected _task: TaskMagicService;
+    protected element: ElementRef;
+    protected renderer: Renderer2;
+    protected vcRef: ViewContainerRef;
+    set magic(val: any);
+    protected htmlElement: HTMLElement;
+    component: TaskBaseMagicComponent;
+    private eventHandlers;
+    id: string;
+    protected selector: string;
+    subscribeRefreshDom: Subscription;
+    eventsOnlyVal: boolean;
+    constructor(_task: TaskMagicService, element: ElementRef, renderer: Renderer2, vcRef: ViewContainerRef);
+    get task(): TaskMagicService;
+    protected regEvents(): void;
+    private OnFocus;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NonMagicControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NonMagicControlDirective, "[NonMagicControl]", never, { "magic": "NonMagicControl"; }, {}, never, never, false, never>;
+}

package/src/ui/directives/magic/checkbox-noformcontrol.magic.directive.d.ts

@@ -0,0 +1,9 @@
+import { MagicDirective } from "../magic.directive";
+import * as i0 from "@angular/core";
+export declare class CheckboxNoFormControlMagicDirective {
+    protected magicDirective: MagicDirective;
+    constructor(magicDirective: MagicDirective);
+    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>;
+}

package/src/ui/directives/magic/checkbox.magic.directive.d.ts

@@ -0,0 +1,9 @@
+import { MagicDirective } from '../magic.directive';
+import * as i0 from "@angular/core";
+export declare class CheckboxMagicDirective {
+    protected magicDirective: MagicDirective;
+    constructor(magicDirective: MagicDirective);
+    onChange($event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxMagicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CheckboxMagicDirective, "    input[type=checkbox][magic]:not([noFormControl])", never, {}, {}, never, never, false, never>;
+}

package/src/ui/directives/magic/combobox.magic.directive.d.ts

@@ -0,0 +1,10 @@
+import { MagicDirective } from '../magic.directive';
+import * as i0 from "@angular/core";
+export declare class ComboboxMagicDirective {
+    protected magicDirective: MagicDirective;
+    constructor(magicDirective: MagicDirective);
+    onChange($event: any): void;
+    onComboboxItemsListChanged(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxMagicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboboxMagicDirective, "select[magic]:not([multiple])", never, {}, {}, never, never, false, never>;
+}

package/src/ui/directives/magic/form-controls/control-value-accessors/checkbox.cva.directive.d.ts

@@ -0,0 +1,7 @@
+import { CheckboxControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare const CHECKBOX_VALUE_ACCESSOR: any;
+export 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>;
+}

package/src/ui/directives/magic/form-controls/control-value-accessors/date.cva.directive.d.ts

@@ -0,0 +1,17 @@
+import { ElementRef, Renderer2 } from "@angular/core";
+import { ControlValueAccessor } from "@angular/forms";
+import * as i0 from "@angular/core";
+export declare const DATE_VALUE_ACCESSOR: any;
+export declare class DateValueAccessor implements ControlValueAccessor {
+    private renderer;
+    private elementRef;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    constructor(renderer: Renderer2, elementRef: ElementRef);
+    writeValue(value: Date): void;
+    registerOnChange(fn: (_: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateValueAccessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DateValueAccessor, "[dateInput]", never, {}, {}, never, never, false, never>;
+}

package/src/ui/directives/magic/form-controls/control-value-accessors/default.cva.directive.d.ts

@@ -0,0 +1,7 @@
+import { DefaultValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare const MAGIC_DEFAULT_VALUE_ACCESSOR: any;
+export 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>;
+}

package/src/ui/directives/magic/input.noformcontrol.magic.directive.d.ts

@@ -0,0 +1,9 @@
+import { MagicDirective } from '../magic.directive';
+import * as i0 from "@angular/core";
+export declare class InputNoFormControlMagicDirective {
+    protected magicDirective: MagicDirective;
+    constructor(magicDirective: MagicDirective);
+    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>;
+}

package/src/ui/directives/magic/nocontrol.magic.directive.d.ts

@@ -0,0 +1,18 @@
+import { ElementRef, Renderer2, ViewContainerRef } from '@angular/core';
+import { GuiCommand } from "@magic-xpa/gui";
+import { MagicDirective } from "../magic.directive";
+import { TaskMagicService } from "../../../services/task.magics.service";
+import { RowMagicDirective } from "./row.magic.directive";
+import { Platform } from "@angular/cdk/platform";
+import * as i0 from "@angular/core";
+export 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": "magicnc"; }, {}, never, never, false, never>;
+}

package/src/ui/directives/magic/row.magic.directive.d.ts

@@ -0,0 +1,17 @@
+import { ElementRef, OnDestroy, OnInit } from "@angular/core";
+import { TaskMagicService } from "../../../services/task.magics.service";
+import * as i0 from "@angular/core";
+export declare class RowMagicDirective implements OnInit, OnDestroy {
+    protected _task: TaskMagicService;
+    protected element: ElementRef;
+    rowId: string;
+    protected htmlElement: HTMLElement;
+    private rowChangedSubscriber;
+    constructor(_task: TaskMagicService, element: ElementRef);
+    ngOnInit(): void;
+    private isInView;
+    ngOnDestroy(): void;
+    onClick($event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowMagicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RowMagicDirective, "[magicRow]", never, { "rowId": "magicRow"; }, {}, never, never, false, never>;
+}

package/src/ui/directives/magic-focus.directive.d.ts

@@ -0,0 +1,9 @@
+import { ElementRef } from "@angular/core";
+import * as i0 from "@angular/core";
+export 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>;
+}

package/src/ui/directives/magic.directive.d.ts

@@ -0,0 +1,44 @@
+import { ElementRef, OnDestroy, OnInit, Renderer2, ViewContainerRef } from "@angular/core";
+import { GuiCommand, GuiInteractive } from "@magic-xpa/gui";
+import { TaskBaseMagicComponent } from "../task-base.magic.component";
+import { TaskMagicService } from "../../services/task.magics.service";
+import { RowMagicDirective } from "./magic/row.magic.directive";
+import { Subscription } from "rxjs";
+import { Platform } from "@angular/cdk/platform";
+import * as i0 from "@angular/core";
+export 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);
+    set eventsOnly(val: any);
+    rowId: string;
+    protected htmlElement: HTMLElement;
+    component: TaskBaseMagicComponent;
+    private eventHandlers;
+    id: string;
+    protected selector: string;
+    subscribeRefreshDom: Subscription;
+    private focusUnlistener;
+    eventsOnlyVal: boolean;
+    static opened: boolean;
+    static noOfAutoCompleteBoxesOpened: number;
+    subscribeInteractiveCommands: Subscription;
+    constructor(_task: TaskMagicService, element: ElementRef, renderer: Renderer2, vcRef: ViewContainerRef, platform: Platform, magicRow: RowMagicDirective);
+    get task(): TaskMagicService;
+    protected regEvents(): void;
+    private OnFocus;
+    IsSameElement(command: any): boolean;
+    private IsSameComponent;
+    private regUpdatesUI;
+    ngOnInit(): void;
+    handleCommand(command: GuiCommand): void;
+    handleInteractiveCommands(command: GuiInteractive): void;
+    handleSetProperty(command: GuiCommand): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicDirective, [null, null, null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MagicDirective, "[magic]", never, { "magic": "magic"; "eventsOnly": "eventsOnly"; "rowId": "rowId"; }, {}, never, never, false, never>;
+}

package/src/ui/directives/magicViewContainerRef.directive.d.ts

@@ -0,0 +1,8 @@
+import { ViewContainerRef } from "@angular/core";
+import * as i0 from "@angular/core";
+export 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>;
+}

package/src/ui/directives/mgformat.magic.directive.d.ts

@@ -0,0 +1,31 @@
+import { TaskMagicService } from '../../services/task.magics.service';
+import { RefParam } from '@magic-xpa/mscorelib';
+import { StorageAttribute } from '@magic-xpa/utils';
+import { MagicDirective } from './magic.directive';
+import { AbstractControl } from '@angular/forms';
+import { PIC } from '@magic-xpa/gui';
+import * as i0 from "@angular/core";
+export declare class MgformatMagicDirective {
+    protected magicDir: MagicDirective;
+    protected _task: TaskMagicService;
+    datePasteFlag: boolean;
+    constructor(magicDir: MagicDirective, _task: TaskMagicService);
+    ngAfterViewInit(): void;
+    onFocusEvent($event: any): void;
+    onPaste(event: ClipboardEvent): void;
+    onInputEvent(event: any): void;
+    dateMasking(event: any): void;
+    onChangeEvent($event: any): void;
+    calculatePattern(): void;
+    formatDate(pic: PIC): void;
+    formatAlphaUnicode(control: AbstractControl): void;
+    formatBoolean(control: AbstractControl): void;
+    generatePattern(attribute: StorageAttribute, pic: PIC): string;
+    generatePatternForNumber(pic: PIC): string;
+    isPatternGenerationNeeded(attr: StorageAttribute, pic: PIC): boolean;
+    generatePatternForAlpha(pic: PIC): string;
+    getDirectiveCount(mask: string, idx: number, pattern: string, changeInPattern: RefParam<boolean>): number;
+    IsPatternMatches(mask: string, pattern: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MgformatMagicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MgformatMagicDirective, "[mgFormat]", never, {}, {}, never, never, false, never>;
+}

package/src/ui/directives/range-validator.magic.directive.d.ts

@@ -0,0 +1,17 @@
+import { ViewContainerRef } from '@angular/core';
+import { FormControl, Validator } from '@angular/forms';
+import { TaskMagicService } from '../../services/task.magics.service';
+import * as i0 from "@angular/core";
+export declare class RangeValidatorMagicDirective implements Validator {
+    protected _task: TaskMagicService;
+    protected vcRef: ViewContainerRef;
+    constructor(_task: TaskMagicService, vcRef: ViewContainerRef);
+    validate(c: FormControl): {
+        rangevalidator: {
+            errorMsg: string;
+        };
+    };
+    getControlName(c: FormControl): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangeValidatorMagicDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RangeValidatorMagicDirective, "[rangevalidator] ", never, {}, {}, never, never, false, never>;
+}

package/src/ui/magic-confirmationBox.d.ts

@@ -0,0 +1,6 @@
+import { Styles } from "@magic-xpa/gui";
+export declare class confirmationBox {
+    static isConfirmBox(style: Styles): Boolean;
+    static convertToExcpectedResultBox(style: Styles, okWasPressed: Boolean): Styles;
+    static showConfirmationBox(title: string, message: string, style: Styles): boolean;
+}

package/src/ui/magic-modal/base-magic-overlay-container.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class BaseMagicOverlayContainer {
+    abstract ModalComp: any;
+    abstract ModalCompParameters: any;
+    abstract onClose: any;
+}

package/src/ui/magic-modal/magic-modal-form.d.ts

@@ -0,0 +1,5 @@
+export declare class ModalFormDefinition {
+    taskId: string;
+    comp: any;
+    parameters: any;
+}

package/src/ui/magic-modal/magic-modal-interface.d.ts

@@ -0,0 +1,10 @@
+export interface MagicModalInterface {
+    X(): any;
+    Y(): any;
+    Width(): string;
+    Height(): string;
+    IsCenteredToWindow(): any;
+    FormName(): any;
+    ShowTitleBar(): any;
+    ShouldCloseOnBackgroundClick(): any;
+}

package/src/ui/magic-modal/magic-overlay-container-wrapper.d.ts

@@ -0,0 +1,31 @@
+import { ViewContainerRef, ComponentFactoryResolver, ElementRef, Injector, ChangeDetectorRef, Compiler } from '@angular/core';
+import { ComponentListMagicService } from "../../services/component-list.magic.service";
+import { IMagicViewContainerRef } from "../../..";
+import { MagicLazyLoaderService } from '../../services/magic.lazy.loader.service';
+import * as i0 from "@angular/core";
+export declare class MagicOverlayContainerWrapper implements IMagicViewContainerRef {
+    private componentListMagicService;
+    private magicLazyModuleLoader;
+    private injector;
+    private componentFactoryResolver;
+    private changeDetectorRef;
+    private compiler;
+    Component: any;
+    Parameters: any;
+    private OverlayTypeParam;
+    private onClose;
+    overlayContentViewContainerRef: ViewContainerRef;
+    overlayContainerWrapperElementRef: ElementRef;
+    static allowedBaseComps: Map<number, {
+        comp: any;
+        error: string;
+    }>;
+    constructor(componentListMagicService: ComponentListMagicService, magicLazyModuleLoader: MagicLazyLoaderService, injector: Injector, componentFactoryResolver: ComponentFactoryResolver, 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": "Component"; "Parameters": "Parameters"; "OverlayTypeParam": "OverlayTypeParam"; }, { "onClose": "onClose"; }, never, never, false, never>;
+}

package/src/ui/magic-modal/magic-overlay-container.d.ts

@@ -0,0 +1,25 @@
+import { ComponentFactoryResolver, ElementRef, EventEmitter, OnInit, ViewContainerRef } from '@angular/core';
+import { BaseMagicOverlayContainer } from './base-magic-overlay-container';
+import { IMagicViewContainerRef } from '../../..';
+import * as i0 from "@angular/core";
+export declare class MagicOverlayContainer extends BaseMagicOverlayContainer implements OnInit, IMagicViewContainerRef {
+    private componentFactoryResolver;
+    modalbodyViewContainerRef: ViewContainerRef;
+    headerElementRef: ElementRef;
+    foregroundElementRef: ElementRef;
+    ModalComp: any;
+    ModalCompParameters: any;
+    onClose: EventEmitter<void>;
+    private componentRef;
+    constructor(componentFactoryResolver: ComponentFactoryResolver);
+    ngOnInit(): void;
+    setViewContainerRef(vcRef: ViewContainerRef): void;
+    getText(): any;
+    getStyle(): {};
+    getClientAreaStyles(): {};
+    getShowTitleBar(): any;
+    OnClose(): void;
+    OnBackgroundClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MagicOverlayContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MagicOverlayContainer, "app-magic-overlay-container", never, { "ModalComp": "ModalComp"; "ModalCompParameters": "ModalCompParameters"; }, { "onClose": "onClose"; }, never, never, false, never>;
+}