@magic-xpa/engine 4.1201.1 → 4.1202.0

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

@@ -0,0 +1,4634 @@
+import { GuiFieldBase, ExpVal, TaskDefinitionId, GuiTaskBase, MgFormBase, MgControlBase, PropParentInterface, CommandType, FieldDef, FieldsTable as FieldsTable$1, GuiDataViewBase, IRecord, DataModificationTypes, ObjectReferencesCollection, ObjectReferenceBase, DcValues, ITask, KeyboardItem, LastFocusedVal, IGuiEventsManager, IMGDataTable, IEnvironment, Modifiers, PIC, EventsProcessor, GuiMgForm, GuiMgControl, DcValuesBuilderBase, IActionManager, NUM_TYPE, GuiExpressionEvaluator, DisplayConvertor, MgTimer, IFlowMonitorQueue } from '@magic-xpa/gui';
+import { StringBuilder, List, RefParam, IComparable, Dictionary, Stack, ApplicationException, Encoding, Exception, Hashtable } from '@magic-xpa/mscorelib';
+import { StorageAttribute, XmlParser, CallOperationMode, MgControlType, TableBehaviour, LnkEval_Cond, LnkMode, UniqueTskSort, ForceExit, Priority, ViewRefreshMode, Logger_LogLevels, Order } from '@magic-xpa/utils';
+import { Subject } from 'rxjs/internal/Subject';
+import { HttpClient, HttpHeaders, HttpResponse } from '@angular/common/http';
+import { Subject as Subject$1 } from 'rxjs';
+
+declare enum EventSubType {
+    Normal = 0,
+    CancelWithNoRollback = 1,
+    CancelIsQuit = 2,
+    RtRefreshViewUseCurrentRow = 3,
+    ExitDueToError = 4
+}
+declare enum ClientTargetedCommandType {
+    Abort = "A",
+    OpenURL = "P",
+    Verify = "V",
+    EnhancedVerify = "E",
+    Result = "S",
+    AddRange = "R",
+    ClientRefresh = "C",
+    AddLocate = "L",
+    AddSort = "T",
+    ResetRange = "G",
+    ResetLocate = "O",
+    ResetSort = "U"
+}
+
+interface IResultValue {
+    SetResultValue(result: string, type: StorageAttribute): void;
+}
+
+declare enum Recompute_RcmpBy {
+    CLIENT = "C",
+    SERVER_ON_CHANGE = "O"
+}
+declare class Recompute {
+    private _ctrlProps;
+    private _formProps;
+    private _isOwnerFld;
+    OwnerFld: FieldBase;
+    private _rcmpOrder;
+    private _subForms;
+    private _subFormsOnlyRecomp;
+    private _hasServerLinksRecomputes;
+    RcmpMode: Recompute_RcmpBy;
+    Task: Task;
+    constructor();
+    fillData(dataView: DataView, taskRef: Task, parser: XmlParser): void;
+    private initInnerObjects;
+    private AddRecomputeItem;
+    private fillLink;
+    private fillFldField;
+    private initElements;
+    execute(rec: Record): Promise<void>;
+    private RefreshSubforms;
+    private SetSubformsInRecompute;
+    private fldRcmp;
+    private buildSubFormList;
+    RemoveSubform(subformTask: Task): void;
+    AddSubform(subformTask: Task): void;
+    private recSuffixSubForms;
+    private checkRefreshSubForms;
+    private GetSubformsToRefresh;
+    private recPrefixSubForms;
+    notifyServerOnChange(): boolean;
+    isServerRcmp(): boolean;
+}
+
+declare abstract class FieldBase extends GuiFieldBase {
+    static CLEAR_FLAGS: boolean;
+    IsEventHandlerField: boolean;
+    abstract getValue(checkNullArithmetic: boolean): string;
+    abstract isNull(): boolean;
+    abstract takeValFromRec(): void;
+    abstract isParam(): boolean;
+    abstract isModified(): boolean;
+    updateDisplay(): Promise<void>;
+    abstract setHasZoomHandler(): void;
+    abstract setHasChangeEvent(): void;
+    abstract invalidate(forceInvalidate: boolean, clearFlags: boolean): void;
+    compute(recompute: boolean): Promise<void>;
+    setValueAndStartRecompute(val: string, isNullFld: boolean, recompute: boolean, setRecordUpdated: boolean, isArgUpdate: boolean, enforceVariableChange?: boolean): Promise<void>;
+    abstract get IsVirtual(): boolean;
+    abstract hasInitExp(): boolean;
+    abstract causeTableInvalidation(causeTableInvalidation: boolean): void;
+    abstract setRecompute(recompRef: Recompute): void;
+    abstract setRecomputed(): void;
+    abstract isInEvalProcess(): boolean;
+}
+
+declare class Argument {
+    private _exp;
+    private _fld;
+    private _skip;
+    private _type;
+    private _val;
+    private _valueAttr;
+    private _valueIsNull;
+    constructor();
+    constructor(field: FieldBase);
+    constructor(expVal: ExpVal);
+    constructor(srcArg: Argument);
+    private constructor_0;
+    private constructor_1;
+    private constructor_2;
+    constructor_3(srcArg: Argument): void;
+    Initialize(srcArg: Argument): Promise<void>;
+    fillData(arg: String, srcTask: Task): void;
+    buildXML(message: StringBuilder): void;
+    getType(): string;
+    getField(): FieldBase;
+    protected getExp(): Expression;
+    setValueToField(destFld: FieldBase): Promise<void>;
+    static convertArgs(value: string, srcAttr: StorageAttribute, expectedType: StorageAttribute): string;
+    getValue(expType: StorageAttribute, expSize: number): Promise<string>;
+    skipArg(): boolean;
+    fillDataByParams(paramValueAttr: StorageAttribute, paramValue: string, paramNull: boolean): void;
+    private static getEmptyValue;
+    FillFromString(argStr: string): void;
+}
+
+declare class Transaction {
+    private _transId;
+    private _afterTransRetry;
+    private _transBegin;
+    Opened: boolean;
+    OwnerTask: Task;
+    constructor(task: TaskBase, setTransId: string);
+    isOwner(task: Task): boolean;
+    close(): void;
+    open(): void;
+    isOpened(): boolean;
+    setAfterRetry(val: string): void;
+    getAfterRetry(): boolean;
+    getAfterRetry(recovery: string): boolean;
+    private getAfterRetry_0;
+    private getAfterRetry_1;
+    getLevel(): string;
+    setTransBegin(val: string): void;
+    getTransId(): string;
+    setOwnerTask(task: Task): void;
+}
+
+interface IClientCommand {
+}
+
+declare abstract class ReturnResultBase {
+    abstract get Success(): boolean;
+    abstract get ErrorDescription(): string;
+    InnerResult: ReturnResultBase;
+    abstract GetErrorId(): any;
+    constructor(innerResult: ReturnResultBase);
+    constructor();
+    private constructor_0;
+    private constructor_1;
+    static ErroNeedToBeHandled(): boolean;
+}
+
+declare class ReturnResult extends ReturnResultBase {
+    private errorDescription;
+    private success;
+    static SuccessfulResult: ReturnResult;
+    get Success(): boolean;
+    get ErrorDescription(): string;
+    ErrorId: string;
+    constructor();
+    constructor(errorDescriptionCode: string);
+    constructor(innerResult: ReturnResultBase);
+    constructor(errorDescription: string, innerResult: ReturnResultBase);
+    private constructor_00;
+    private constructor_01;
+    private constructor_02;
+    private constructor_03;
+    GetErrorId(): any;
+}
+
+declare class DataviewManagerBase {
+    Task: Task;
+    Transaction: Transaction;
+    constructor(task: Task);
+    Execute(command: IClientCommand): Promise<ReturnResult>;
+    GetDbViewRowIdx(): number;
+}
+
+declare abstract class TaskServiceBase {
+    abstract GetTaskTag(defaultValue: string): string;
+    static CreateFirstRecord(task: Task): void;
+    abstract GetDataviewManagerForVirtuals(task: Task): DataviewManagerBase;
+    PrepareTask(task: Task): ReturnResult;
+    static PreparePropOpenTaskWindow(task: Task): Promise<void>;
+    abstract GetEventTaskId(originalTaskId: string): string;
+    abstract ShouldEvaluatePropertyLocally(propId: number): boolean;
+    abstract InitTaskPrefixExecutedFlag(task: Task): void;
+    static Exit(task: Task, reversibleExit: boolean, subformDestination: boolean): Promise<void>;
+    abstract RemoveRecomputes(parentTask: Task): void;
+    GetOwnerTransactionTask(task: Task): Task;
+}
+
+declare class Operation {
+    private _condExp;
+    private _retainFocus;
+    private _waitExp;
+    private _syncData;
+    private _argList;
+    private _blockClose;
+    private _blockEnd;
+    private _buttons;
+    private _checkByServer;
+    private _cmdToServer;
+    private _display;
+    private _errLogAppend;
+    private _evtHandler;
+    private _execOnServer;
+    private _execOnClient;
+    private _exp;
+    private _field;
+    private _image;
+    private _incremental;
+    private _mode;
+    private _publicName;
+    private _returnVal;
+    private _rtEvt;
+    private _serverId;
+    private calledTaskDefinitionId;
+    private _subformCtrlName;
+    private _subtype;
+    private _task;
+    private _text;
+    private _title;
+    private _titleExp;
+    private _type;
+    private _undo;
+    private _isRoute;
+    private _routerPath;
+    private _subformExp;
+    private _originalRouterOutletName;
+    private _routeParams;
+    constructor();
+    get CalledTaskDefinitionId(): TaskDefinitionId;
+    OperCallMode: CallOperationMode;
+    set Task(value: Task);
+    get Task(): Task;
+    private Immediate;
+    fillData(taskRef: Task, evtHandler: EventHandler, parser: XmlParser): void;
+    private initInnerObjects;
+    private fillAttributes;
+    private initElements;
+    InitTaskDefinitionID(parser: XmlParser): void;
+    private SetTaskDefinitionId;
+    static InitField(valueStr: string, task: Task): Field;
+    execute(returnedFromServer: boolean, desiredRouteName?: string): Promise<boolean>;
+    private operCallParallel;
+    static callParallel(): void;
+    private getCondVal;
+    getType(): number;
+    getRouteParams(): List<any>;
+    getServerId(): number;
+    private operVerify;
+    static getButtons(buttonsID: string): number;
+    static getImage(imageID: string): number;
+    static setoperVerifyReturnValue(returnValue: number, returnVal: Field): Promise<void>;
+    private operBlock;
+    private operElse;
+    private operEvaluate;
+    private operUpdate;
+    private CanModify;
+    static operUpdateVectors(field: Field, vec: string): string;
+    private operRaiseEvent;
+    private operCall;
+    operServer(mprgCreator: Task): Promise<void>;
+    getBlockEnd(): number;
+    setBlockEnd(val: number): void;
+    getBlockClose(): number;
+    setBlockClose(val: number): void;
+    getTaskTag(): string;
+    getHandlerId(): string;
+    getEventHandler(): EventHandler;
+    getExecOnServer(): boolean;
+    setExecOnServer(val: boolean): void;
+    getExecOnClient(): boolean;
+    private canExecute;
+    private isOperationAllowedWhileExecutingDefaultRoute;
+    AddFlowDescription(buffer: StringBuilder): Promise<void>;
+    GetArgList(): ArgumentsList;
+    GetReturnValueField(): Field;
+    GetSubformControlName(): string;
+    toString(): string;
+    GetRuntimeEvent(): RunTimeEvent;
+}
+
+declare class OperationTable {
+    private _operations;
+    private _firstBlockOperIdx;
+    constructor();
+    fillData(taskRef: Task, evtHandler: EventHandler, parser: XmlParser): void;
+    private initInnerObjects;
+    getSize(): number;
+    getOperation(idx: number): Operation;
+    serverId2operIdx(id: number, startFrom: number): number;
+    serverId2FollowingOperIdx(id: number, startFrom: number): number;
+}
+
+declare class EventHandler {
+    private _enabledExp;
+    private _operationTab;
+    private _propagateExp;
+    private _isHandlerOnForm;
+    private _ctrl;
+    private _ctrlName;
+    private _dvLen;
+    private _dvPos;
+    private _evt;
+    private _handledByClient;
+    private _handlerFld;
+    private _hasParameters;
+    private _id;
+    private _level;
+    private _scope;
+    private _task;
+    private _taskMgdID;
+    private _defRouteName;
+    private _isExecutingDefaultRoute;
+    constructor();
+    getCtrlName(): string;
+    fillData(taskRef: Task, parser: XmlParser): void;
+    private initInnerObjects;
+    private initInnerElements;
+    private initElements;
+    calculateCtrlFromControlName(taskRef: Task): void;
+    isSpecificHandlerOf(rtEvt: RunTimeEvent): boolean;
+    isNonSpecificHandlerOf(rtEvt: RunTimeEvent): boolean;
+    isGlobalHandlerOf(rtEvt: RunTimeEvent): boolean;
+    isGlobalSpecificHandlerOf(rtEvt: RunTimeEvent): boolean;
+    execute(rtEvt: RunTimeEvent, returnedFromServer: boolean, enabledCndCheckedAndTrue: boolean): Promise<RetVals>;
+    isExecutingDefaultRoute(): boolean;
+    private executeOperations;
+    private getSignificantBlock;
+    private getStartBlockIdxByEnd;
+    private getStartBlockIdxByElse;
+    private getStartBlockIfIdxByOper;
+    getLevel(): string;
+    getEvent(): Event;
+    private isRouteHandler;
+    getDefaultRouteName(): string;
+    getId(): number;
+    isEnabled(): Promise<boolean>;
+    private resetLocalVariables;
+    private getArgValsFromFlds;
+    getTask(): Task;
+    argsMatch(Exp_params: ExpVal[]): boolean;
+    getOperationTab(): OperationTable;
+    getControlNameForControlHeader(): string;
+    getVarNameForVariableHeader(): string;
+    getEventHandlerInfo(): string;
+    toString(): string;
+}
+declare class RetVals {
+    BlockIfReturnedFromServer: boolean;
+    Enabled: boolean;
+    NextOperIdx: number;
+    Propagate: boolean;
+    ReturnedFromServer: boolean;
+    constructor(p: boolean, e: boolean);
+    constructor(operIdx: number, inReturnedFromServer: boolean, inBlockIfReturnedFromServer: boolean);
+    private constructor_0;
+    private constructor_1;
+}
+
+declare class HandlersTable {
+    private _handlers;
+    constructor();
+    fillData(taskRef: Task, parser: XmlParser): void;
+    private initInnerObjects;
+    add(handler: EventHandler): void;
+    remove(idx: number): void;
+    insertAfter(handler: EventHandler, idx: number): void;
+    getSize(): number;
+    getHandler(idx: number): EventHandler;
+    hasExpressionHandler(): boolean;
+    startTimers(mgd: MGData): void;
+    getTimersVector(): List<number>;
+}
+
+interface ICommandsTable {
+    fillData(parser: XmlParser): void;
+    buildXML(message: StringBuilder): void;
+    Add(cmd: IClientCommand): void;
+    Clear(): void;
+}
+
+declare class MGData {
+    private _expHandlers;
+    private _id;
+    private _parent;
+    private _mprgTab;
+    private _tasksTab;
+    private _timerHandlers;
+    private _timersStarted;
+    private forceModal;
+    CmdsToClient: ICommandsTable;
+    CmdsToServer: ICommandsTable;
+    IsModal: boolean;
+    IsAborting: boolean;
+    get ForceModal(): boolean;
+    constructor(toClient: ICommandsTable, toServer: ICommandsTable, id: number, parent: MGData, isModal: boolean);
+    constructor(toClient: ICommandsTable, toServer: ICommandsTable, id: number, parent: MGData, isModal: boolean, forceModal: boolean);
+    private constructor_0;
+    private constructor_1;
+    GetId(): number;
+    AlreadyMovedToFirstControl(): boolean;
+    StartTimers(): void;
+    fillData(openingTaskDetails: OpeningTaskDetails, parser: XmlParser): Promise<void>;
+    private initInnerObjects;
+    private insertDataView;
+    addTask(newTask: Task): void;
+    removeTask(task: Task): void;
+    getTasksCount(): number;
+    getTask(taskId: string): Task;
+    getTask(idx: number): Task;
+    private getTask_0;
+    private getTask_1;
+    buildXML(message: StringBuilder, serializeTasks: boolean): Promise<void>;
+    getFirstTask(): Task;
+    getMainProg(ctlIdx: number): Task;
+    getNextMainProg(ctlIdx: number): Task;
+    clientTransactionCacheExists(): boolean;
+    serverTransactionCacheExists(): boolean;
+    getTaskByTaskDefinitionID(taskDefinitionID: TaskDefinitionId): Task;
+    getTimerHandlers(): HandlersTable;
+    addTimerHandler(handler: EventHandler): void;
+    removeTimerHandler(task: Task): void;
+    removeExpressionHandler(task: Task): void;
+    getExpHandlers(): HandlersTable;
+    addExpHandler(handler: EventHandler, idx: number): void;
+    changeTimers(oldTimers: List<number>, newTimers: List<number>): void;
+    private fillEventsQueue;
+    private initEvents;
+    isMainWindow(): boolean;
+    getParentMGdata(): MGData;
+    abort(): void;
+    copyUnframedCmds(): void;
+    getValidAncestor(): MGData;
+    getMaxCtlIdx(): number;
+    fillGlobalParams(parser: XmlParser): void;
+}
+
+declare class RemoteDataviewManager extends DataviewManagerBase {
+    private _remoteDataViewCommandFactory;
+    constructor(task: Task);
+    Execute(command: IClientCommand): Promise<ReturnResult>;
+}
+
+declare class DataviewManager extends DataviewManagerBase {
+    RemoteDataviewManager: RemoteDataviewManager;
+    HasRemoteData: boolean;
+    private get TaskService();
+    get CurrentDataviewManager(): DataviewManagerBase;
+    private get VirtualDataviewManager();
+    constructor(task: Task);
+    Execute(command: IClientCommand): Promise<ReturnResult>;
+}
+
+declare class Sort {
+    fldIdx: number;
+    dir: boolean;
+}
+
+declare enum Task_SubformExecModeEnum {
+    NO_SUBFORM = -1,
+    SET_FOCUS = 0,
+    FIRST_TIME = 1,
+    REFRESH = 2
+}
+declare abstract class TaskBase extends GuiTaskBase {
+    IsTryingToStop: boolean;
+    DoSubformPrefixSuffix: boolean;
+    IsAfterRetryBeforeBuildXML: boolean;
+    TaskSuffixExecuted: boolean;
+    DataviewManager: DataviewManager;
+    IsOffline: boolean;
+    ResetRange: boolean;
+    UserRngs: List<UserRange>;
+    ResetLocate: boolean;
+    UserLocs: List<UserRange>;
+    ResetSort: boolean;
+    UserSorts: List<Sort>;
+    PreviouslyActiveTaskId: string;
+    protected _transactionFailed: boolean;
+    InEndTask: boolean;
+    InCtrlPrefix: boolean;
+    RetainFocus: boolean;
+    SubformExecMode: Task_SubformExecModeEnum;
+    TransactionErrorHandlingsRetry: Transaction;
+    ClosingFormUI: boolean;
+    AfterFirstRecordPrefix: boolean;
+    static ShouldNonInteractiveBeModal(): boolean;
+    abstract isDescendentOf(chkTask: TaskBase): boolean;
+    abstract get TaskService(): TaskServiceBase;
+    abstract getUserEvent(idx: number): Event;
+    abstract getExpById(id: number): Expression;
+    abstract setInRecordSuffix(bValue: boolean): boolean;
+    abstract getMGData(): MGData;
+    abstract ctl_itm_4_parent_vee(parent: number, vee: number): number;
+    abstract getAfterRetry(): boolean;
+    abstract getAfterRetry(recovery: string): boolean;
+    abstract setAfterRetry(val: string): void;
+    abstract setTransactionFailed(val: boolean): void;
+    abstract getOriginalTaskMode(): string;
+    abstract setOriginalTaskMode(originalTaskMode: string): void;
+    abstract setTryingToStop(val: boolean): void;
+    abstract resetExecEndTask(): void;
+    abstract getTriggeringTask(): TaskBase;
+    isCached(): Promise<boolean>;
+    abstract getLoopCounter(): number;
+    abstract getCounter(): number;
+    abstract buildXMLForRngs(message: StringBuilder, UserRanges: List<UserRange>, locate: boolean): void;
+    abstract buildXMLForSorts(message: StringBuilder): void;
+    abstract getTaskCache(): DvCache;
+    abstract isTableWithAbsolutesScrollbar(): boolean;
+    prepareCache(ignoreCurr: boolean): Promise<boolean>;
+    testAndSet(ignoreCurr: boolean): Promise<boolean>;
+    abstract setPreventRecordSuffix(val: boolean): void;
+    abstract transactionFailed(level: string): boolean;
+    abstract HasLoacte(): boolean;
+    abstract isTransactionOwner(): boolean;
+    abstract getParent(): TaskBase;
+    abstract getMgdID(): number;
+    SubformRefresh(subformTask: TaskBase, explicitSubformRefresh: boolean): Promise<void>;
+    abstract setExecEndTask(): void;
+    stop(): Promise<void>;
+    abstract abort(): void;
+    abstract enableCreateActs(val: boolean): void;
+    abstract cancelWasRaised(): boolean;
+    abstract setCancelWasRaised(val: boolean): void;
+    abstract pathContains(task: TaskBase): boolean;
+    abstract RecomputeFillData(parser: XmlParser): void;
+    abstract get ParentTask(): TaskBase;
+    abstract ShouldNonInteractiveChildBeModal(): boolean;
+    abstract setTransOwnerTask(): void;
+    abstract setDestinationSubform(destinationSubform: boolean): void;
+    abstract setIsDestinationCall(isDestinationCall: boolean): void;
+    abstract GetRealMainDisplayIndexOnDepth(mainDspIdx: number): number;
+    abstract getTaskDepth(byParentOrder: boolean): number;
+    abstract setEvalOldValues(bFlag: boolean): boolean;
+    abstract GetControlIDFromVarItem(item: number): number;
+    abstract GetControlFromControlID(controlID: number, parent: RefParam<number>): MgControl;
+    abstract pathToRoot(path: TaskBase[], byParentOrder: boolean): void;
+    abstract isFirstRecordCycle(Value_?: boolean): any;
+    abstract ctl_itm_2_parent_vee(itm: number): Field;
+    abstract queryTaskPath(): StringBuilder;
+    abstract getFieldByName(fldName: string): Field;
+    abstract getIndexOfFieldByName(fldName: string): number;
+    abstract isProgram(): boolean;
+    abstract getPublicName(): string;
+    abstract getExternalTaskId(): string;
+    abstract set Transaction(value: Transaction);
+    abstract get Transaction(): Transaction;
+    fillData(mgd: MGData, openingTaskDetails: OpeningTaskDetails): Promise<void>;
+    buildXML(message: StringBuilder): Promise<void>;
+}
+declare class UserRange {
+    veeIdx: number;
+    min: string;
+    max: string;
+    nullMax: boolean;
+    nullMin: boolean;
+    discardMax: boolean;
+    discardMin: boolean;
+}
+declare class OpeningTaskDetails {
+    CallingTask: TaskBase;
+    PathParentTask: TaskBase;
+    constructor();
+    constructor(callingTask: TaskBase, pathParentTask: TaskBase);
+    private constructor_0;
+    private constructor_1;
+}
+
+declare class ArgumentsList {
+    private _list;
+    RefreshOnString: string;
+    constructor();
+    constructor(Exp_params: ExpVal[]);
+    constructor(argument: Argument);
+    private constructor_0;
+    Initialize(srcArgs: ArgumentsList): Promise<void>;
+    private constructor_2;
+    private constructor_3;
+    fillList(valueStr: string, srcTask: TaskBase): void;
+    buildListFromParams(size: number, attrs: string, vals: string[], nulls: string): void;
+    buildXML(message: StringBuilder): void;
+    getSize(): number;
+    getArg(idx: number): Argument;
+    getArgValue(idx: number, expType: StorageAttribute, expSize: number): Promise<string>;
+    FillListFromString(argsString: string): void;
+    Add(argument: Argument): void;
+}
+
+declare class CreatedFormVector {
+    private _createdFormVec;
+    constructor();
+    add(mgForm: MgForm): void;
+    remove(mgForm: MgForm): void;
+    Count(): number;
+    Clear(): void;
+    get(index: number): MgForm;
+}
+
+declare class MgForm extends MgFormBase {
+    private static TIME_LIMIT;
+    IsMovingInView: boolean;
+    PrevDisplayLine: number;
+    RefreshAllRows: boolean;
+    IgnoreFirstRecordCycle: boolean;
+    MovedToFirstControl: boolean;
+    private _suffixDone;
+    private hiddenControlsIsnsList;
+    static _createdForms: CreatedFormVector;
+    private _transferringDataToGUI;
+    private isFetchingRecordsAhead;
+    constructor();
+    static get CreatedForms(): CreatedFormVector;
+    get InRestore(): boolean;
+    get TransferringDataToGUI(): boolean;
+    get shouldFetchRecordsAheadFromServer(): boolean;
+    FetchRecordsAheadFromServer(): Promise<void>;
+    private GetDataview;
+    moveInView(unit: string, direction: string): Promise<void>;
+    addRec(doSuffix: boolean, isCrelineAbove: boolean): Promise<void>;
+    delCurrRec(): Promise<void>;
+    cancelEdit(isActCancel: boolean, isQuitEvent: boolean): Promise<void>;
+    refreshOnExpressions(): Promise<void>;
+    removeRefsToCtrls(): void;
+    getCtrlByCtrlName(ctrlName: string): MgControl;
+    getSubFormCtrlByName(ctrlName: string): MgControl;
+    setSuffixDone(): void;
+    getDestinationRow(): number;
+    setSubFormCtrl(subFormCtrl: MgControl): void;
+    getSubFormCtrlForTask(taskId: string): MgControl;
+    removeRecordsAfterIdx(idx: number): void;
+    isRowValidated(idx: number): boolean;
+    transferDataToGui(): Promise<void>;
+    private checkAndCreateRowsEvent;
+    setRowData(desiredTopIndex: number, sendAll: boolean): Promise<void>;
+    private refreshRows;
+    getVisibleLine(): number;
+    bringRecordToPage(): Promise<void>;
+    invalidateTable(): void;
+    getPrevLine(line: number): number;
+    clearTableColumnSortMark(clearSortMark: boolean): void;
+    stopRowEditing(idx: number): Promise<void>;
+    startRowEditing(idx: number): Promise<void>;
+    getIsRowEditingFromGui(displayIndex: number): boolean;
+    RefreshDisplay(refreshType: string): Promise<boolean>;
+    RefreshUI(): void;
+    private refreshTable;
+    updateDisplayLineByDV(): void;
+    setCurrRowByDisplayLine(displayLine: number, doSuffix: boolean, ignoreCurrRec: boolean): Promise<void>;
+    private setCurrRowByRecIdx;
+    getLastValidRow(): number;
+    recordIdx2DisplayLine(recIdx: number): number;
+    displayLine2RecordIdx(displayLine: number): number;
+    restoreOldDisplayLine(displayLine: number): Promise<void>;
+    getTopIndexFromGUI(): number;
+    getCurrRecPosInForm(): number;
+    restoreBackup(oldDisplayLine: number, bkpRecord: Record): Promise<void>;
+    ConstructMgControl(): MgControlBase;
+    ConstructMgControl(type: MgControlType, task: TaskBase, parentControl: number): MgControlBase;
+    ConstructMgControl(type: MgControlType, parentMgForm: MgFormBase, parentControlIdx: number): MgControlBase;
+    private ConstructMgControl_0;
+    private ConstructMgControl_1;
+    private ConstructMgControl_2;
+    alreadyMovedToFirstControl(): boolean;
+    firstTableRefresh(): Promise<void>;
+    InsertTableItems(idx: number, count: number): void;
+    setTableItemsCount(removeAll: boolean): void;
+    InitTableControl(): void;
+    InitTableControl(dvSize: number, tableItemsCount: number, removeAll: boolean): void;
+    private InitTableControl_00;
+    private InitTableControl_01;
+    SetTableTopIndex(): void;
+    createForm(): Promise<void>;
+    UpdateStatusBar(): void;
+    initInnerObjects(foundTagName: string): boolean;
+    toString(): string;
+    GetHiddenControlListXML(): string;
+    ShouldBehaveAsModal(): boolean;
+    isTableWithPagination(): boolean;
+    isTableWithAbsoluteScrollbar(): boolean;
+    private SetRecordsBeforeCurrentView;
+    buildFormName(): string;
+    private fetchPrevChunkForCurrentPage;
+    getGuiRowidx(dvRowIdx: number): number;
+    getDvRowIdx(guiRowIdx: number): number;
+    moveToFirstParkabelControl(callByDestSubForm: boolean): Promise<void>;
+    private getValidParkableControl;
+    private getFirstParkableControlName;
+}
+
+declare class MgControl extends MgControlBase implements PropParentInterface {
+    private _focusedStopExecution;
+    private _inControlSuffix;
+    private _rtEvtTask;
+    private _subformTaskId;
+    private _subformTask;
+    IsInteractiveUpdate: boolean;
+    private refreshOnString;
+    SubformLoaded: boolean;
+    HasZoomHandler: boolean;
+    ArgList: ArgumentsList;
+    static ReturnToCtrl: MgControl;
+    private initialize;
+    constructor();
+    constructor(type: MgControlType);
+    constructor(type: MgControlType, task: TaskBase, parentControl: number);
+    constructor(type: MgControlType, parentMgForm: MgFormBase, parentControlIdx: number);
+    GetVarIndex(): number;
+    fillData(mgForm: MgFormBase, ditIdx: number, parser: XmlParser): Promise<void>;
+    SetAttribute(attribute: string, valueStr: string): boolean;
+    private GetArgumentList;
+    isDescendent(parentForm: MgForm): boolean;
+    refreshOnExpression(): Promise<void>;
+    invoke(): Promise<boolean>;
+    isParkable(checkEnabledAndVisible: boolean): Promise<boolean>;
+    getSubformTaskId(): string;
+    initSubformTask(): void;
+    getParentTable(): MgControl;
+    restoreOldValue(): Promise<void>;
+    setRtEvtTask(curTask: TaskBase): void;
+    getRtEvtTask(): TaskBase;
+    setSubformTaskId(taskId: string): void;
+    isFocusedStopExecution(): boolean;
+    setFocusedStopExecution(focusedStopExecution: boolean): void;
+    onTheSameSubFormControl(ctrl: MgControl): boolean;
+    onDiffForm(ctrl: MgControl): boolean;
+    isInControlSuffix(): boolean;
+    setInControlSuffix(inControlSuffix: boolean): void;
+    HasSelectProgram(): boolean;
+    useZoomHandler(): boolean;
+    updatePropertyLogicNesting(propId: number, commandType: CommandType, val: boolean, updateThis: boolean): Promise<void>;
+    private ShouldSetSubformInvisible;
+    updateSubformChildrenPropValue(propId: number, commandType: CommandType, val: boolean): Promise<void>;
+    Init(): void;
+    GetTableBehaviour(): TableBehaviour;
+    validateAndSetValue(NewValue: any, updateCtrl: boolean): Promise<boolean>;
+    private setValue;
+    getSubformTask(): TaskBase;
+    resetSubformTask(): void;
+    GetSubformMgForm(): MgFormBase;
+    IsTableWithAbsoluteScrollbar(): boolean;
+    static validReturnToCtrl(): boolean;
+    maySetValue(): boolean;
+    validateAndSetValueIfAllowed(NewValue: any, refreshDisplay: boolean): Promise<boolean>;
+}
+
+declare class Boundary {
+    private _cacheTableFldId;
+    private _max;
+    private _min;
+    private _retType;
+    private _size;
+    private _maxExpVal;
+    private _minExpVal;
+    DiscardMin: boolean;
+    DiscardMax: boolean;
+    MaxEqualsMin: boolean;
+    constructor(task: Task, minIdx: number, maxIdx: number, returnType: StorageAttribute, size: number);
+    constructor(task: Task, minIdx: number, maxIdx: number, returnType: StorageAttribute, size: number, cacheTableId: number);
+    private constructor_0;
+    private constructor_1;
+    hasMinExp(): boolean;
+    hasMaxExp(): boolean;
+    getExpType(): StorageAttribute;
+    getCacheTableFldId(): number;
+    compute(padValueWithMinMaxCharacters: boolean): Promise<void>;
+    checkRange(val: string, IsNull: boolean): boolean;
+    IsMaxEqualsMin(): boolean;
+    private WildCharExist;
+    toString(): string;
+}
+
+declare class Field extends FieldBase {
+    static LEAVE_FLAGS: boolean;
+    private static NUM0;
+    private static NUM1;
+    private _linkExp;
+    private _recompute;
+    CacheTableFldIdx: number;
+    private _causeTableInvalidation;
+    private _form;
+    private _hasChangeEvent;
+    private _hasZoomHandler;
+    private _inEvalProcess;
+    private _initExp;
+    private _invalidValue;
+    private _isLinkFld;
+    private _isVirtual;
+    private _dataviewHeaderId;
+    private _linkCreate;
+    Locate: Boundary;
+    Range: Boundary;
+    private _isParam;
+    private _isExposedRouteParam;
+    private _isExposedToClient;
+    private _prevIsNull;
+    private _prevValue;
+    private _tableName;
+    private _indexInTable;
+    private _virAsReal;
+    protected _val: string;
+    private modifiedAtLeastOnce;
+    private _isNull;
+    private _clearVectorType;
+    private _vectorType;
+    private static _variableChangeEvts;
+    constructor(dataview: DataView, id: number);
+    get VirAsReal(): boolean;
+    get IsVirtual(): boolean;
+    get IsExposedRouteParam(): boolean;
+    get IsExposedToClient(): boolean;
+    get IndexInTable(): number;
+    protected setAttribute(attribute: string, valueStr: string): boolean;
+    setRecompute(recompRef: Recompute): void;
+    RemoveSubformFromRecompute(subformTask: Task): void;
+    AddSubformRecompute(subformTask: Task): void;
+    SetControl(ctrl: MgControlBase): void;
+    compute(recompute: boolean): Promise<void>;
+    EvaluateInitExpression(result: RefParam<string>, isNullFld: RefParam<boolean>): Promise<void>;
+    getValue(checkNullArithmetic: boolean): string;
+    private isChanged;
+    takeValFromRec(): void;
+    getOriginalValue(): string;
+    isOriginalValueNull(): boolean;
+    getValueByRecIdx(idx: number): string;
+    getModifiedAtLeastOnce(): boolean;
+    isNullByRecIdx(idx: number): boolean;
+    isEqual(mgValue: string, isNullFld: boolean, type: StorageAttribute, recIdx: number): boolean;
+    getNewRecValue(clobberedOnly: boolean): string;
+    setValueAndStartRecompute(val: string, isNullFld: boolean, recompute: boolean, setRecordUpdated: boolean, isArgUpdate: boolean, enforceVariableChange?: boolean): Promise<void>;
+    private setValueAndStartRecompute_1;
+    private setValue;
+    UpdateNull(isNullFld: boolean, rec: Record): void;
+    setCellVecValue(idx: number, newVal: string, valIsNull: boolean): Promise<boolean>;
+    getVecCellValue(idx: number): string;
+    setRecomputed(): void;
+    invalidate(forceInvalidate: boolean, clearFlags: boolean): void;
+    getTableName(): String;
+    getName(): string;
+    isNull(): boolean;
+    PrevIsNull(): boolean;
+    isModified(): boolean;
+    setModified(): void;
+    setUpdated(): void;
+    isParam(): boolean;
+    isInEvalProcess(): boolean;
+    hasInitExp(): boolean;
+    isServerRcmp(): boolean;
+    getPicture(): string;
+    getDataviewHeaderId(): number;
+    get IsLinkField(): boolean;
+    getInitExpVal(res: RefParam<string>, isNull: RefParam<boolean>): Promise<void>;
+    setHasChangeEvent(): void;
+    private getHasChangeEvent;
+    setHasZoomHandler(): void;
+    getHasZoomHandler(): boolean;
+    isCauseTableInvalidation(): boolean;
+    causeTableInvalidation(causeTableInvalidation: boolean): void;
+    getValueForNull(checkNullArithmetic: boolean): string;
+    getCtrl(): MgControl;
+    updateDisplay(): Promise<void>;
+    getDispValue(): string;
+    get ShouldCheckRangeInCompute(): boolean;
+    IsForArgument(taskHasParameters: boolean): boolean;
+}
+
+declare class Key {
+    Columns: List<FieldDef>;
+    private _table;
+    private _id;
+    constructor(ownerTable: TableCache);
+    FillData(parser: XmlParser): void;
+    private FillAttributes;
+    private InitElements;
+    private InitInnerObjects;
+    GetKeyId(): number;
+}
+
+declare class FieldsTable extends FieldsTable$1 {
+    private _rmIdx;
+    private _rmSize;
+    private _serverRcmpDone;
+    constructor();
+    fillData(parser: XmlParser, dataview?: GuiDataViewBase): void;
+    private initFields;
+    initField(parser: XmlParser, dataview: GuiDataViewBase): FieldDef;
+    initField(parser: XmlParser): FieldDef;
+    private initField_0;
+    private initField_1;
+    getRMSize(): number;
+    getRMIdx(): number;
+    setRMPos(rms: number, idx: number): void;
+    getType(id: number): StorageAttribute;
+    invalidate(forceInvalidate: boolean, clearFlags: boolean): void;
+    takeValsFromRec(): void;
+    serverRcmpDone(): boolean;
+    setServerRcmp(val: boolean): void;
+    getLinkFields(lnkId: number): List<Field>;
+    resetRecomp(): void;
+}
+
+declare class TableCache {
+    private _keys;
+    private _records;
+    private _currSortDir;
+    private _currSortKey;
+    FldsTab: FieldsTable;
+    private _isLoaded;
+    private _tableIdent;
+    private _tableUId;
+    constructor(tableId: string);
+    SetTableIdent(ident: string): void;
+    FillData(): void;
+    private FillAttributes;
+    private InitInnerObjects;
+    GetTableUniqueId(): string;
+    GetTableCommonIdentifier(): string;
+    GetCurrSortKey(): number;
+    GetKeyById(keyId: number): Key;
+    private Load;
+    SortTable(sortKeyId: number, sortDir: string): Promise<void>;
+    Fetch(loc: List<Boundary>): Record;
+    private static validateRec;
+    protected ReverseVector(array: Object[]): void;
+}
+
+declare abstract class DataViewBase extends GuiDataViewBase {
+    abstract getCurrRec(): Record;
+    abstract getServerCurrRec(): Record;
+    abstract setChanged(val: boolean): void;
+    abstract getTask(): TaskBase;
+    abstract getForm(): MgForm;
+    abstract inRollback(): boolean;
+}
+
+declare class Record implements IComparable, IRecord {
+    static FLAG_NULL: number;
+    static FLAG_INVALID: number;
+    static FLAG_MODIFIED: number;
+    static FLAG_UPDATED: number;
+    static FLAG_CRSR_MODIFIED: number;
+    static FLAG_VALUE_NOT_PASSED: number;
+    static FLAG_MODIFIED_ATLEAST_ONCE: number;
+    protected _id: number;
+    protected dbViewRowIdx: number;
+    protected _mode: DataModificationTypes;
+    private _dcRefs;
+    _inCompute: boolean;
+    _inRecompute: boolean;
+    _newRec: boolean;
+    get InCompute(): boolean;
+    get InRecompute(): boolean;
+    protected static INCREASE: boolean;
+    protected static DECREASE: boolean;
+    protected _tableCache: TableCache;
+    protected _inDeleteProcess: boolean;
+    protected _addAfter: number;
+    protected _causeInvalidation: boolean;
+    protected _dbPosBase64Val: string;
+    protected _dataview: DataViewBase;
+    private _fieldsData;
+    protected _flags: Uint8Array;
+    protected _flagsHistory: Uint8Array;
+    protected _forceSaveOrg: boolean;
+    protected _hashKey: number;
+    protected _computed: boolean;
+    protected _lateCompute: boolean;
+    protected _linksFldsPos: string;
+    protected _modified: boolean;
+    protected _next: Record;
+    protected _prev: Record;
+    protected _sendToServer: boolean;
+    protected _updated: boolean;
+    InForceUpdate: boolean;
+    Synced: boolean;
+    ValueInBase64: boolean;
+    constructor(dvOrTableCache: DataViewBase | TableCache);
+    constructor(cId: number, dataview: DataViewBase);
+    constructor(Record: Record);
+    private constructor_0;
+    Initialize(): void;
+    private constructor_1;
+    get Modified(): boolean;
+    get Updated(): boolean;
+    get SendToServer(): boolean;
+    CompareTo(obj: Object): number;
+    getMode(): DataModificationTypes;
+    getId(): number;
+    isNewRec(): boolean;
+    private getFieldDataXML;
+    getFieldsTab(): FieldsTable;
+    setInitialFldVals(clobberedOnly: boolean, isNewRec: boolean): void;
+    setId(cId: number): void;
+    setDBViewRowIdx(rowId: number): void;
+    getDBViewRowIdx(): number;
+    fillData(parser: XmlParser): boolean;
+    protected initElements(tokensVector: List<string>): boolean;
+    protected peekIsCurrRec(tokensVector: List<string>): boolean;
+    fillFieldsData(fldValInBytes: Uint8Array, recFlags: string): void;
+    fillFieldsData(fldsVal: string, recFlags: string, isCurrRec: boolean): void;
+    private fillFieldsData_0;
+    private fillFieldsData_1;
+    fillDCRef(valueStr: string): void;
+    private buildFieldsData;
+    getXMLForValue(fldIdx: number, fldVal: string): string;
+    getFromFldIdx(isCurrRec: boolean): number;
+    getSizeFld(isCurrRec: boolean): number;
+    buildXML(message: StringBuilder, isCurrRec: boolean): void;
+    buildXML(message: StringBuilder, isCurrRec: boolean, forceBuild: boolean): void;
+    private buildXML_0;
+    protected buildXML_1(message: StringBuilder, isCurrRec: boolean, forceBuild: boolean): void;
+    protected setShrinkFlags(): void;
+    setShrinkFlag(fldIdx: number): void;
+    SetFieldValue(idx: number, isNull: boolean, value: string): void;
+    setFieldValue(fldIdx: number, mgVal: string, setRecordUpdated: boolean): void;
+    CheckMgValue(mgVal: string, isNull: boolean, fld: Field): string;
+    setModified(): void;
+    resetModified(): void;
+    setUpdated(): void;
+    resetUpdated(): void;
+    GetFieldValue(fldIdx: number): string;
+    replicate(): Record;
+    setSameAs(rec: Record, realOnly: boolean, rId: number): void;
+    setSameAs(rec: Record, realOnly: boolean): void;
+    private setSameAs_0;
+    private setSameAs_1;
+    IsNull(fldIdx: number): boolean;
+    isLinkInvalid(fldIdx: number): boolean;
+    isFldModified(fldIdx: number): boolean;
+    IsFldModifiedAtLeastOnce(fldIdx: number): boolean;
+    isFldUpdated(fldIdx: number): boolean;
+    setFlag(fldIdx: number, aFlag: number): void;
+    clearFlag(fldIdx: number, aFlags: number): void;
+    clearFlagsHistory(): void;
+    clearFlags(aFlags: number): void;
+    clearFlagsForRealOnly(aFlags: number): void;
+    clearHistoryFlag(fldIdx: number): void;
+    checkFlags(fldIdx: number): void;
+    restart(oldMode: DataModificationTypes): void;
+    setLateCompute(val: boolean): void;
+    lateCompute(): boolean;
+    setInDeleteProcess(val: boolean): void;
+    inDeleteProcess(): boolean;
+    removeRecFromDc(): void;
+    isSameRecData(rec: Record, currRec: boolean, checkOnlyParetOfDataview: boolean): boolean;
+    getUpdatedFields(): string;
+    fldValsEqual(rec: Record, fldIdx: number): boolean;
+    getHashKey(): number;
+    setNextRec(nextRec: Record): void;
+    setPrevRec(prevRec: Record): void;
+    getPrevRec(): Record;
+    getNextRec(): Record;
+    getDcRefs(): ObjectReferencesCollection;
+    setDcRefs(newDcRefs: ObjectReferencesCollection): void;
+    realModified(): boolean;
+    ToString(): string;
+    setSendToServer(val: boolean): void;
+    getRecSize(): number;
+    copyCrsrModifiedFlags(rec: Record): void;
+    getDbPosVal(): string;
+    buildLinksPosStr(): void;
+    setForceSaveOrg(val: boolean): void;
+    getForceSaveOrg(): boolean;
+    isCauseInvalidation(): boolean;
+    setCauseInvalidation(causeInvalidation: boolean): void;
+    isComputed(): boolean;
+    setComputed(val: boolean): void;
+    setInCompute(val: boolean): void;
+    setInRecompute(val: boolean): void;
+    setMode(newMode: DataModificationTypes): void;
+    clearMode(): void;
+    setOldRec(): void;
+    setNewRec(): void;
+    static serializeItemVal(itemVal: string, itemAttr: StorageAttribute, cellAttr: StorageAttribute, ToBase64: boolean): string;
+    SetDcValueId(): void;
+    resetDcValueId(): void;
+    AddDcValuesReference(controlId: number, dcValuesId: number): void;
+}
+declare class DcValuesReference extends ObjectReferenceBase {
+    ditIdx: number;
+    get DcValues(): DcValues;
+    constructor(controlId: number, referencedDcValues: DcValues);
+    Clone(): ObjectReferenceBase;
+    static Parse(couple: string, dcValuesOwner: DataViewBase): DcValuesReference;
+}
+
+declare const SET_DISPLAYLINE_BY_DV: number;
+declare class DataView extends DataViewBase {
+    private _cacheLruTimeStamp;
+    private _changed;
+    private _chunkSize;
+    private _computeBy;
+    private _currRecId;
+    private _currRecIdx;
+    private _dvPosValue;
+    private _firstDv;
+    private _flushUpdates;
+    private _hasMainTable;
+    private _insertAt;
+    set InsertAt(value: string);
+    get InsertAt(): string;
+    InLocalDataviewCommand: boolean;
+    private _lastCreatedRecId;
+    private _lastSessionCounter;
+    private _locateFirstRec;
+    private _modifiedRecordsTab;
+    private _oldTopRecIdx;
+    private _original;
+    private _pendingRecovery;
+    private _prevCurrRec;
+    private _recordsTab;
+    private _recovery;
+    private _rmIdx;
+    private _rmSize;
+    private _skipParsing;
+    private _topRecId;
+    private _topRecIdx;
+    private _topRecIdxModified;
+    private _transCleared;
+    private _unknownRcmp;
+    IsOneWayKey: boolean;
+    _includesFirst: boolean;
+    _includesLast: boolean;
+    _serverTransCacheEmpty: boolean;
+    private _currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER;
+    private get CurrRec();
+    private set CurrRec(value);
+    get FlushUpdates(): boolean;
+    get HasMainTable(): boolean;
+    DBViewSize: number;
+    taskModeFromCache: string;
+    get CurrentRecId(): number;
+    Dvcount: number;
+    TotalRecordsCount: number;
+    RecordsBeforeCurrentView: number;
+    get FirstRecord(): IRecord;
+    get LastRecord(): IRecord;
+    constructor(task: TaskBase);
+    constructor(DataView: DataView);
+    Init(): void;
+    IncludesFirst(): boolean;
+    get ServerTransactionCacheEmpty(): boolean;
+    IncludesLast(): boolean;
+    fillHeaderData(parser: XmlParser): void;
+    private initHeaderInnerObjects;
+    private getHeaderAttributes;
+    fillData(parser: XmlParser): Promise<void>;
+    private GetTransactionBegin;
+    private initInnerObjects;
+    private RecoveryRetry;
+    private UpdateDataviewAfterInsert;
+    private getAttributes;
+    SetOneWayKey(val: boolean): void;
+    SetIncludesLast(val: boolean): void;
+    SetIncludesFirst(val: boolean): void;
+    private fillDataDc;
+    AddDcValues(dcv: DcValues): void;
+    private fillExecStack;
+    private fillInnerExecStack;
+    private peekInvalidate;
+    getFieldByName(fldName: string): Field;
+    buildXML(message: StringBuilder): Promise<void>;
+    getCurrRec(): Record;
+    getPrevCurrRec(): Record;
+    getOriginalRec(): Record;
+    setCurrRec(id: number, compute: boolean): Promise<boolean>;
+    setCurrRecByIdx(newIdx: number, doSuffix: boolean, ignoreCurrRec: boolean, compute: boolean, newDisplayLine: number): Promise<void>;
+    currRecCompute(forceClientCompute: boolean): Promise<void>;
+    saveOriginal(): void;
+    fetchChunkFromServer(chunkId: string, doSuffix: boolean): Promise<void>;
+    FetchRecordsAheadFromServer(): Promise<void>;
+    recExists(recIdx: number): boolean;
+    checkFirst(locateFirst: number): boolean;
+    getCurrRecIdx(): number;
+    getCurrDBViewRowIdx(): number;
+    setTopRecIdx(newTopRecIdx: number): void;
+    getTopRecIdx(): number;
+    setTopRecIdxModified(val: boolean): void;
+    getChunkSize(): number;
+    restoreTopRecIdx(): void;
+    clear(): void;
+    private init;
+    computeSubForms(): Promise<void>;
+    private compute;
+    addRecord(doSuffix: boolean, ignoreCurrRec: boolean, isCrelineAbove: boolean): Promise<number>;
+    private addRecord_1;
+    removeCurrRec(): Promise<void>;
+    RemoveRecord(record: Record): void;
+    MoveToEmptyDataviewIfAllowed(): Promise<void>;
+    private calcLineToMove;
+    reset(): void;
+    cancelEdit(onlyReal: boolean, recomputeUnknowns: boolean): Promise<boolean>;
+    isEmpty(): boolean;
+    addCurrToModified(): Promise<void>;
+    addCurrToModified(setRecToOld: boolean): Promise<void>;
+    private addCurrToModified_0;
+    private addCurrToModified_1;
+    takeFldValsFromCurrRec(): void;
+    currEqualsPrev(fldList: number[]): boolean;
+    getTask(): TaskBase;
+    getForm(): MgForm;
+    modifiedRecordsNumber(): number;
+    getSize(): number;
+    computeByClient(): boolean;
+    recExistsById(id: number): boolean;
+    ParametersExist(iPos: number, iLen: number): boolean;
+    ParametersExist(): boolean;
+    private ParametersExist_0;
+    private ParametersExist_1;
+    recInModifiedTab(id: number): boolean;
+    setPrevCurrRec(): void;
+    setPrevCurrRec(rec: Record): void;
+    private setPrevCurrRec_0;
+    private setPrevCurrRec_1;
+    isPrevCurrRecNull(): boolean;
+    private execUnknownRcmps;
+    setTransCleared(): void;
+    processRecovery(): Promise<void>;
+    replicate(): DataView;
+    getDvPosValue(): number;
+    getFirstDv(): boolean;
+    ResetFirstDv(): void;
+    getCacheLRU(): number;
+    setCacheLRU(): void;
+    setSameAs(newDv: DataView): Promise<void>;
+    setChanged(val: boolean): void;
+    getChanged(): boolean;
+    getLocateFirstRec(): number;
+    setLocateFirstRec(newFirst: number): void;
+    getRecByIdx(idx: number): Record;
+    getServerCurrRec(): Record;
+    zeroServerCurrRec(): void;
+    inRollback(): boolean;
+    getRecIdx(id: number): number;
+    backupCurrent(): Record;
+    restoreCurrent(recBackup: Record): void;
+    GetCurrentRecId(): number;
+    DataviewBoundriesAreChanged(orgIncludesFirst: boolean, orgIncludesLast: boolean): boolean;
+    GetRouteParams(): List<any>;
+}
+
+declare class DvCache {
+    private _cacheTable;
+    private _deletedList;
+    private _task;
+    constructor(tsk: Task);
+    putInCache(repOfOriginal: DataView): boolean;
+    removeDvFromCache(DvPosValue: number, updateDel: boolean): boolean;
+    getDeletedListToXML(): string;
+    clearDeletedList(): void;
+    getCachedDataView(DvPosValue: number): DataView;
+    clearCache(): void;
+    isDeleted(dvPosVal: number): boolean;
+}
+
+declare enum CommandsProcessorBase_SessionStage {
+    HANDSHAKE = 1,
+    INITIAL = 2,
+    NORMAL = 3
+}
+declare enum CommandsProcessorBase_SendingInstruction {
+    NO_TASKS_OR_COMMANDS = 0,
+    ONLY_COMMANDS = 1,
+    TASKS_AND_COMMANDS = 2
+}
+declare abstract class CommandsProcessorBase {
+    _sessionCounter: number;
+    GetSessionCounter(): number;
+    StartSession(): Promise<boolean>;
+    Execute(sendingInstruction: CommandsProcessorBase_SendingInstruction): Promise<void>;
+    Execute(sendingInstruction: CommandsProcessorBase_SendingInstruction, sessionStage: CommandsProcessorBase_SessionStage, res: IResultValue): Promise<void>;
+    private Execute_0;
+    Execute_1(sendingInstruction: CommandsProcessorBase_SendingInstruction, sessionStage: CommandsProcessorBase_SessionStage, res: IResultValue): Promise<void>;
+    GetContent(requestedURL: string, useCache: boolean): Promise<ArrayBuffer>;
+    GetContentAsString(requestedURL: string, useCache: boolean): Promise<string>;
+    abstract SendMonitorOnly(): void;
+    static UnScramble(respBuf: string): string;
+}
+
+declare class TaskTransactionManager {
+    task: Task;
+    private get isClosingTopmostTask();
+    constructor(task: Task);
+    AllowTransaction(transBegin: string, forLocal: boolean): boolean;
+    PrepareTransactionProperties(transaction: Transaction, forLocal: boolean): void;
+    GetTransactionBeginValue(forLocal: boolean): string;
+    checkAndCommit(reversibleExit: boolean, level: string, isAbort: boolean): Promise<boolean>;
+    ExecuteLocalUpdatesCommand(): Promise<ReturnResult>;
+    checkAndCommitPerDataview(dataviewmanager: DataviewManagerBase, reversibleExit: boolean, level: string, oper: string, refResult: RefParam<ReturnResult>): Promise<boolean>;
+    HandelTransactionErrorHandlingsRetry(transBegin: string[]): void;
+}
+
+declare class SortCollection {
+    private _sortTab;
+    constructor();
+    fillData(parser: XmlParser): void;
+    initInnerObjects(parser: XmlParser, foundTagName: string): boolean;
+    private InitElements;
+    getSize(): number;
+    add(sort: Sort): void;
+}
+
+declare class YesNoExp {
+    private _exp;
+    private _val;
+    constructor(defaultVal: boolean);
+    setVal(task: Task, strVal: string): void;
+    getVal(): Promise<boolean>;
+    isServerExp(): boolean;
+}
+
+declare abstract class DataviewHeaderBase {
+    _cond: YesNoExp;
+    _task: Task;
+    Loc: List<Boundary>;
+    _dir: string;
+    _id: number;
+    _keyIdx: number;
+    private _retVal;
+    private returnfield;
+    _linkEvalCondition: LnkEval_Cond;
+    get ReturnField(): Field;
+    Mode: LnkMode;
+    LinkStartAfterField: number;
+    KeyExpression: number;
+    get IsMainSource(): boolean;
+    get Task(): Task;
+    get Fields(): List<Field>;
+    get Id(): number;
+    get LinkEvaluateCondition(): LnkEval_Cond;
+    constructor(task: Task);
+    SetAttributes(attributes: Dictionary<string>): void;
+    protected setAttribute(attribute: string, valueStr: string): void;
+    abstract SetReturnValue(ret: boolean, recompute: boolean): void;
+    getLinkedRecord(curRec: Record): Promise<boolean>;
+    InitLinkFields(currRec: IRecord): Promise<void>;
+}
+
+declare class DataviewHeaders {
+    private _dataviewHeaders;
+    private _task;
+    constructor(task: Task);
+    fillData(parser: XmlParser): void;
+    private initInnerObjects;
+    getDataviewHeaderById(linkId: number): DataviewHeaderBase;
+    buildDbPosString(): string;
+}
+
+declare class TasksTable {
+    private readonly _tasks;
+    static createNewtask: any;
+    constructor();
+    fillData(mgdata: MGData, openingTaskDetails: OpeningTaskDetails, parser: XmlParser): Promise<void>;
+    private initInnerObjects;
+    addTask(task: TaskBase): void;
+    removeTask(task: TaskBase): void;
+    getTask(tasktag: string): TaskBase;
+    getTask(idx: number): TaskBase;
+    private getTask_0;
+    private getTask_1;
+    getSize(): number;
+    buildXML(message: StringBuilder): Promise<void>;
+    setTaskAt(task: TaskBase, index: number): void;
+}
+
+declare class ExpTable {
+    private _exps;
+    fillData(task: Task, parser: XmlParser): void;
+    private initInnerObjects;
+    getExpById(id: number): Expression;
+    getExp(idx: number): Expression;
+    getSize(): number;
+}
+
+declare class UserEventsTable {
+    private _userEventsTab;
+    constructor();
+    fillData(tsk: Task, parser: XmlParser): void;
+    private initInnerObjects;
+    getEvent(idx: number): Event;
+    getSize(): number;
+}
+
+declare class FormsTable {
+    private _task;
+    private _parentForm;
+    _formsStringXml: List<string>;
+    get Count(): number;
+    get_Item(formDisplayIndex: number): string;
+    constructor(task: Task, parentForm: MgFormBase);
+    fillData(): Promise<void>;
+    InitFormFromXmlString(formDisplayIndex: number): void;
+    private initInnerObjects;
+    private PrepareMainDisplayForConnectedTask;
+}
+
+declare enum Task_Flow {
+    NONE = 0,
+    STEP = 1,
+    FAST = 2
+}
+declare enum Task_Direction {
+    BACK = -1,
+    NONE = 0,
+    FORE = 1
+}
+declare class Task extends TaskBase {
+    private _dvCache;
+    private _mgData;
+    private _aborting;
+    private _bExecEndTask;
+    private _isStarted;
+    private _evalOldValues;
+    private _inRecordSuffix;
+    private _cancelWasRaised;
+    private _counter;
+    private _currStartProgLevel;
+    private _destinationSubform;
+    private _enableZoomHandler;
+    private _firstRecordCycle;
+    private _originalTaskMode;
+    private _inCreateLine;
+    InSelect: boolean;
+    InStartProcess: boolean;
+    private _isDestinationCall;
+    private _knownToServer;
+    private _loopStack;
+    private allowRemoteCmdExecution;
+    DelayCommandExecution: boolean;
+    MainPrgCtlPath: string;
+    private _parentTask;
+    get ParentTask(): TaskBase;
+    ContextTask: Task;
+    private _triggeringTask;
+    PathParentTask: Task;
+    private _preventControlChange;
+    private _preventRecordSuffix;
+    private _taskPath;
+    private _tryingToCommit;
+    set TryingToCommit(value: boolean);
+    get TryingToCommit(): boolean;
+    private _useLoopStack;
+    private _inProcessingTopMostEndTaskSaved;
+    InHandleActCancel: boolean;
+    RuntimeSorts: SortCollection;
+    VewFirst: number;
+    dataViewContent: string;
+    PerformParentRecordPrefix: boolean;
+    ModeAsParent: boolean;
+    TaskTransactionManager: TaskTransactionManager;
+    ExecuteClientSubformRefresh: boolean;
+    InCommonHandlerBeforeRP: boolean;
+    private _taskService;
+    get TaskService(): TaskServiceBase;
+    static get CommandsProcessor(): CommandsProcessorBase;
+    private hasLocate;
+    private taskDefinitionId;
+    ArgumentsList: ArgumentsList;
+    get LogicalStudioParentTask(): Task;
+    get KnownToServer(): boolean;
+    ConfirmUpdateNo: boolean;
+    DataSynced: boolean;
+    UniqueSort: UniqueTskSort;
+    set Transaction(value: Transaction);
+    get Transaction(): Transaction;
+    RefreshOnVars: number[];
+    DvPosDescriptor: List<string[]>;
+    SubTasks: TasksTable;
+    ExpTab: ExpTable;
+    UserEvtTab: UserEventsTable;
+    DataviewHeadersTable: DataviewHeaders;
+    HandlersTab: HandlersTable;
+    _forms: FormsTable;
+    Name: string;
+    PublicName: string;
+    TaskSuffixExecuted: boolean;
+    get TaskDefinitionId(): TaskDefinitionId;
+    RetrunValueExp: number;
+    SubformControl: MgControl;
+    static StartProgLevel: number;
+    private static _idleTimerStarted;
+    static get IsBlockingBatch(): boolean;
+    constructor();
+    constructor(parent: Task);
+    private constructor_0;
+    Init(): void;
+    private constructor_1;
+    static CreateTask(): TaskBase;
+    isAborting(): boolean;
+    private buildTaskPath;
+    fillData(mgd: MGData, openingTaskDetails: OpeningTaskDetails): Promise<void>;
+    HandlePreviouslyActiveTaskId(): void;
+    HandleTriggerTask(): void;
+    FillTaskTables(taskTablesData: string): void;
+    FillTaskTables(): void;
+    private FillTaskTables_0;
+    fillAttributes(): void;
+    setAttribute(attribute: string, valueStr: string): boolean;
+    initInnerObjects(foundTagName: string, parentForm: MgFormBase): Promise<boolean>;
+    RecomputeFillData(parser: XmlParser): void;
+    private FillTaskTables_1;
+    private addExpHandlersToMGData;
+    SetRefreshOnVars(variables: string): void;
+    setDataSynced(synced: boolean): void;
+    getField(fldName: string): Field;
+    getExpById(id: number): Expression;
+    getExpObjectById(id: number): any;
+    GetExpressionStorage(expId: number): any;
+    CalculateExpression(expId: number, resType: StorageAttribute, length: number): Promise<string>;
+    insertRecordTable(invalidate: boolean, parser: XmlParser): Promise<void>;
+    getHandlersTab(): HandlersTable;
+    buildXML(message: StringBuilder): Promise<void>;
+    buildXMLForRngs(message: StringBuilder, UserRanges: List<UserRange>, locate: boolean): void;
+    buildXMLForSorts(message: StringBuilder): void;
+    getUserEvent(idx: number): Event;
+    private SetMoveToFirstControl;
+    Start(moveToFirstControl: boolean, callByDestSubForm: boolean): Promise<ITask>;
+    private InitializeExecution;
+    private InitializeForm;
+    private StartSubTasks;
+    private EnableActions;
+    ShowError(text: string): Promise<void>;
+    EndTaskOnError(result: ReturnResult, displayError: boolean): Promise<boolean>;
+    private Setup;
+    doFirstRecordCycle(): Promise<void>;
+    private CheckAndSetSubForm;
+    IsRoute(): boolean;
+    stop(): Promise<void>;
+    abort(): void;
+    hasSubTasks(): boolean;
+    getTaskDepth(byParentOrder: boolean): number;
+    private getTaskDepth_;
+    GetTaskAncestor(generation: number): ITask;
+    private getTaskAncestor_;
+    GetTaskDepth(): number;
+    pathContains(task: TaskBase): boolean;
+    SetContextTask(context: TaskBase): void;
+    GetContextTask(): ITask;
+    getTriggeringTask(): Task;
+    setLastParkedCtrl(ctrl: MgControlBase): void;
+    queryTaskPath(): StringBuilder;
+    ctl_itm_2_parent_vee(itm: number): Field;
+    GetControlIDFromVarItem(item: number): number;
+    GetControlFromControlID(controlID: number, parent: RefParam<number>): MgControl;
+    ctl_itm_4_parent_vee(parent: number, vee: number): number;
+    getIndOfParentInTaskTree(parent: number, taskTree: Task[]): number;
+    getFieldByName(fldName: string): Field;
+    private getFieldByName_;
+    getIndexOfFieldByName(fldName: string): number;
+    pathToRoot(path: Task[], byParentOrder: boolean): void;
+    private shouldBeRefreshed;
+    CheckRefreshSubTasks(): Promise<boolean>;
+    private GetSubTasks;
+    GetSubformsToRefresh(): Promise<List<Task>>;
+    ShouldRefreshSubformTask(subTask: Task): Promise<boolean>;
+    SetModeAsParent(parentMode: string): Promise<void>;
+    doSubformRecPrefixSuffix(): Promise<void>;
+    CleanDoSubformPrefixSuffix(): void;
+    mustConfirmInDeleteMode(): boolean;
+    addSubTask(subTask: Task): void;
+    removeSubTask(subTask: Task): void;
+    setTransactionFailed(val: boolean): void;
+    transactionFailed(level: string): boolean;
+    setAfterRetry(val: string): void;
+    getAfterRetry(): boolean;
+    getAfterRetry(recovery: string): boolean;
+    private getAfterRetry_0;
+    private getAfterRetry_1;
+    getExecEndTask(): boolean;
+    resetExecEndTask(): void;
+    setExecEndTask(): void;
+    evalEndCond(mode: string): Promise<boolean>;
+    setTryingToStop(val: boolean): void;
+    getInRecordSuffix(): boolean;
+    setInRecordSuffix(bValue: boolean): boolean;
+    setEvalOldValues(bFlag: boolean): boolean;
+    getEvalOldValues(): boolean;
+    endTask(reversibleExit: boolean, onlyDescs: boolean, dueToVerifyError: boolean, subformDestination?: boolean): Promise<boolean>;
+    private endTask_1;
+    private SetServerSideTaskSuffix;
+    private CheckIfClientOperationExistsInSubformTasks;
+    private CheckIfPendingTransactions;
+    private HandleTransactionInfo;
+    Exit(reversibleExit: boolean, subformDestination: boolean): Promise<void>;
+    private handleFinallyEndTask;
+    handleTaskSuffix(withSubTasks: boolean): Promise<boolean>;
+    setInCreateLine(inCreateLine: boolean): void;
+    getInCreateLine(): boolean;
+    handleEventOnSlaveTasks(internalEvtCode: number): Promise<Task>;
+    enableRecordActions(): Promise<void>;
+    isStarted(): boolean;
+    getSubTasks(): TasksTable;
+    refreshesOn(fldId: number): boolean;
+    private AbortTransaction;
+    setPreventRecordSuffix(val: boolean): void;
+    getPreventRecordSuffix(): boolean;
+    setPreventControlChange(val: boolean): void;
+    getPreventControlChange(): boolean;
+    resetKnownToServer(): void;
+    evaluateDescriptor(): number;
+    setDescriptor(newDesc: string): void;
+    getTaskCache(): DvCache;
+    prepareCache(ignoreCurr: boolean): Promise<boolean>;
+    testAndSet(ignoreCurr: boolean): Promise<boolean>;
+    private changeDv;
+    setOriginalTaskMode(originalTaskMode: string): void;
+    getOriginalTaskMode(): string;
+    isCached(): Promise<boolean>;
+    private locatePutInCache;
+    HasLoacte(): boolean;
+    private setRemoteTransaction;
+    setTransOwnerTask(): void;
+    getLoopCounter(): number;
+    enterLoop(): void;
+    leaveLoop(): void;
+    popLoopCounter(): number;
+    increaseLoopCounter(): void;
+    getLoopStackSize(): number;
+    setUseLoopStack(val: boolean): void;
+    getDataviewHeaders(): DataviewHeaders;
+    isFirstRecordCycle(Value_?: boolean): any;
+    private isFirstRecordCycle_0;
+    private isFirstRecordCycle_1;
+    getPublicName(): string;
+    isAllowEvents(): Promise<boolean>;
+    getExternalTaskId(): string;
+    isTransactionOwner(): boolean;
+    isTransactionOnLevel(level: string): boolean;
+    isProgram(): boolean;
+    enableModes(): Promise<void>;
+    setEnableZoomHandler(): void;
+    getEnableZoomHandler(): boolean;
+    isDestinationSubform(): boolean;
+    setDestinationSubform(destinationSubform: boolean): void;
+    getIsDestinationCall(): boolean;
+    setIsDestinationCall(isDestinationCall: boolean): void;
+    setCancelWasRaised(val: boolean): void;
+    cancelWasRaised(): boolean;
+    enableCreateActs(val: boolean): void;
+    setCreateDeleteActsEnableState(): Promise<void>;
+    setEmptyDataview(emptyDataview: boolean): void;
+    getName(): string;
+    emptyDataviewOpen(subformRefresh: boolean): Promise<void>;
+    emptyDataviewClose(): void;
+    SubformRefresh(subformTask: TaskBase, explicitSubformRefresh: boolean): Promise<void>;
+    ExecuteNestedRS(lastTask: Task): Promise<boolean>;
+    execSubformRecSuffix(newTask: Task): Promise<number>;
+    getCounter(): number;
+    increaseCounter(): void;
+    setCounter(cnt: number): void;
+    isCurrentStartProgLevel(): boolean;
+    static isMainProgramField(fieldStr: string): boolean;
+    getTaskInfo(): string;
+    toString(): string;
+    ConstructMgForm(alreadySetParentForm: RefParam<boolean>): MgFormBase;
+    getMgdID(): number;
+    getMGData(): MGData;
+    RefreshDisplay(): Promise<void>;
+    getFieldDisplayValue(fieldDef: FieldDef, value: RefParam<string>, isNull: RefParam<boolean>): void;
+    UpdateFieldValueAndStartRecompute(fieldDef: FieldDef, value: string, isNull: boolean): Promise<void>;
+    ShouldNonInteractiveChildBeModal(): boolean;
+    private ShouldChildBeModal;
+    getParent(): TaskBase;
+    isDescendentOf(chkTask: TaskBase): boolean;
+    GetSubformModalParentTask(): MgControl;
+    ShouldEvaluatePropertyLocally(propId: number): boolean;
+    EnsureValidForm(): void;
+    ComputeMainDisplay(): Promise<void>;
+    PrepareTaskForm(): Promise<ReturnResult>;
+    FormIsLegal(): boolean;
+    GetRealMainDisplayIndexOnDepth(mainDspIdx: number): number;
+    GetRealMainDisplayIndexOnCurrentTask(mainDspIdx: number): number;
+    GetAncestorTaskByTaskDefinitionId(findTaskDefinitionId: TaskDefinitionId): Task;
+    SetDataControlValuesReference(controlId: number, dcValuesId: number): void;
+    DisplayMessageToStatusBar(text: string): void;
+    isTableWithAbsolutesScrollbar(): boolean;
+    GetTaskDetails(): string;
+    static ProcessTaskURL(): Promise<void>;
+    private static getReflist;
+    static StartProgram(callByDestSubForm: boolean, moveToFirstControl: boolean): Promise<Task>;
+    static ExecuteComponentMainPrograms(callByDestSubForm: boolean, moveToFirstControl: boolean): Promise<Task>;
+    private static ExecuteMainProgram;
+    static OpenForms(callByDestSubForm: boolean): Promise<void>;
+    static DoFirstRecordCycle(): Promise<void>;
+    private static MoveToFirstControls;
+}
+
+declare class Expression implements IResultValue {
+    private _cmdToServer;
+    private _cmdsToServer;
+    private _computeBy;
+    private _expBytes;
+    private _id;
+    private _prevResType;
+    private _resultValue;
+    private _task;
+    private _type;
+    private _clientStorageAttribute;
+    constructor();
+    GetStorageAttribute(): StorageAttribute;
+    evaluateWithResultTypeAndLength(resType: StorageAttribute, length: number): Promise<string>;
+    DiscardCndRangeResult(): Promise<boolean>;
+    evaluateWithResType(resType: StorageAttribute): Promise<ExpVal>;
+    evaluateWithResLength(length: number): Promise<Expression_ReturnValue>;
+    fillData(taskRef: Task, parser: XmlParser): void;
+    private initElements;
+    private buildByteArray;
+    getId(): number;
+    private computedByClient;
+    computedByClientOnly(): boolean;
+    computedByServerOnly(): boolean;
+    getTask(): Task;
+    SetResultValue(result: string, type_: StorageAttribute): void;
+    toString(): string;
+}
+declare class Expression_ReturnValue {
+    mgVal: string;
+    type: StorageAttribute;
+    constructor(mgVal_: string, type_: StorageAttribute);
+}
+
+declare class Event {
+    private static _lastTimestamp;
+    Exp: Expression;
+    _forceExit: ForceExit;
+    kbdItm: KeyboardItem;
+    _paramAttrs: string;
+    _paramNulls: string;
+    _paramVals: string[];
+    _parameters: number;
+    private _returnExp;
+    _seconds: number;
+    _timestamp: number;
+    _type: string;
+    private _userDefinedFuncName;
+    private _userDefinedFuncNameHashCode;
+    private _userEvtDesc;
+    _userEvtIdx: number;
+    InternalEvent: number;
+    PublicName: string;
+    UserEvt: Event;
+    UserEvtTaskTag: string;
+    constructor();
+    private constructor_0;
+    protected constructor_1(evt: Event): void;
+    get ForceExit(): ForceExit;
+    fillData(xmlParser: XmlParser, taskRef: TaskBase): void;
+    private InitInnerObjects;
+    private initElements;
+    private InitUserData;
+    private InitTaskDefinitionId;
+    private SetTaskDefinitionId;
+    findUserEvent(): void;
+    equals(evt: Event): boolean;
+    setPublicName(): Promise<void>;
+    setInternal(code: number): void;
+    setExpression(expRef: Expression): void;
+    getExpression(): Expression;
+    private getUsrEvntDesc;
+    setSystem(keyboardItem: KeyboardItem): void;
+    setKeyboardItem(keyboardItem: KeyboardItem): void;
+    getType(): string;
+    setType(aType: string): void;
+    getInternalCode(): number;
+    getKbdItm(): KeyboardItem;
+    getKbdItmAlways(): KeyboardItem;
+    dataEventIsTrue(): Promise<boolean>;
+    getSeconds(): number;
+    getBrkLevel(): string;
+    getBrkLevel(flowMonitor: boolean): string;
+    private getBrkLevel_0;
+    private getBrkLevel_1;
+    static getInternalEvtDescription(internalEventCode: number): string;
+    getUserEventType(): string;
+    getSecondsOfUserEvent(): number;
+    getUserEvent(): Event;
+    private getKeyboardItemString;
+    private seconds2String;
+    private parseParamVal;
+    getParamNum(): number;
+    isControlHeader(): boolean;
+    isVariableHeader(): boolean;
+    AppendDescription(buffer: StringBuilder): void;
+    isNewInternalEvent(): boolean;
+    getNewInternalEventDescription(): string;
+    getEventType(): string;
+    getEventTypeString(): string;
+    setUserDefinedFuncName(name: string): void;
+    getUserDefinedFuncName(): string;
+    getUserDefinedFuncNameHashCode(): number;
+    getUserDefinedFuncRetExp(): number;
+    setTimestamp(): void;
+    getTimestamp(): number;
+    toString(): string;
+}
+
+declare abstract class RunTimeEventBase extends Event {
+    abstract getPriority(): Priority;
+}
+
+declare class RunTimeEvent extends RunTimeEventBase implements IComparable {
+    private _controlsList;
+    private _direction;
+    private _displayLine;
+    private _eventSubType;
+    private _actEnableList;
+    private _argList;
+    private _ctrl;
+    private _dotNetObject;
+    private _eventFld;
+    private _fromServer;
+    private _guiTriggeredEvent;
+    private _immediate;
+    private _isIdleTimer;
+    private _isRealRefresh;
+    private _mgdId;
+    private _routeParams;
+    private _mprgCreator;
+    private _priority;
+    private _produceClick;
+    private _reversibleExit;
+    private _selectionEnd;
+    private _selectionStart;
+    private _sendAll;
+    private _task;
+    private _taskTag;
+    private _val;
+    private _shouldHandleZoom;
+    set ShouldHandleZoom(value: boolean);
+    get ShouldHandleZoom(): boolean;
+    set Control(value: MgControlBase);
+    set DisplayLine(value: number);
+    get Control(): MgControlBase;
+    IgnoreSpecifiedControl: boolean;
+    LastFocusedVal: LastFocusedVal;
+    get ControlsList(): List<MgControlBase>;
+    get Direction(): number;
+    constructor(taskRef: TaskBase);
+    constructor(taskRef: TaskBase, ctrlRef: MgControlBase);
+    constructor(ctrlRef: MgControlBase);
+    constructor(ctrlRef: MgControlBase, guiTriggeredEvent: boolean);
+    constructor(ctrlRef: MgControlBase, guiTriggeredEvent: boolean, ignoreSpecifiedControl: boolean);
+    constructor(taskref: TaskBase, guiTriggeredEvent: boolean);
+    constructor(fldRef: GuiFieldBase);
+    constructor(ctrlRef: MgControlBase, line: number);
+    constructor(ctrlRef: MgControlBase, line: number, guiTriggeredEvent: boolean);
+    constructor(ctrlRef: MgControlBase, controlsList: List<MgControlBase>, guiTriggeredEvent: boolean);
+    constructor(ctrlRef: MgControlBase, direction: number, line: number);
+    constructor(ctrlRef: MgControlBase, columnHeader: string, x: number, y: number, width: number, height: number);
+    constructor(evt: Event, rtEvt: RunTimeEvent);
+    constructor(rtEvt: RunTimeEvent);
+    private constructor_5;
+    private constructor_6;
+    private constructor_7;
+    private constructor_8;
+    private constructor_9;
+    private constructor_10;
+    private constructor_11;
+    private constructor_12;
+    private constructor_13;
+    private constructor_14;
+    private constructor_15;
+    private constructor_16;
+    private constructor_17;
+    CompareTo(obj: any): number;
+    replicate(): RunTimeEvent;
+    private init;
+    convertParamsToArgs(): void;
+    getTask(): TaskBase;
+    setTask(taskRef: TaskBase): void;
+    setTimer(sec: number, mgdID: number, isIdle: boolean): void;
+    getDisplayLine(): number;
+    getMgdID(): number;
+    getBrkLevel(): string;
+    getBrkLevel(flowMonitor: boolean): string;
+    private getBrkLevel_00;
+    private getBrkLevel_01;
+    setCtrl(newCtrl: MgControlBase): void;
+    setNonReversibleExit(): void;
+    reversibleExit(): boolean;
+    buildXML(message: StringBuilder): void;
+    getArgList(): ArgumentsList;
+    setArgList(aArgList: ArgumentsList): boolean;
+    setRouteParamList(routeParams: List<any>): void;
+    getRouteParamList(): List<any>;
+    setImmediate(val: boolean): void;
+    isImmediate(): boolean;
+    setMainPrgCreator(src: TaskBase): void;
+    getMainPrgCreator(): TaskBase;
+    setIsRealRefresh(val: boolean): void;
+    getRefreshType(): boolean;
+    setFromServer(): void;
+    resetFromServer(): void;
+    isFromServer(): boolean;
+    isQuit(): boolean;
+    RollbackInCancel(): boolean;
+    ExitDueToError(): boolean;
+    RtViewRefreshUseCurrentRow(): boolean;
+    SetEventSubType(eventSubType: EventSubType): void;
+    getFld(): GuiFieldBase;
+    isGuiTriggeredEvent(): boolean;
+    getPriority(): Priority;
+    setPriority(priority: Priority): void;
+    isIdleTimer(): boolean;
+    getValue(): any;
+    setValue(val: any): void;
+    getStartSelection(): number;
+    getEndSelection(): number;
+    setEditParms(start: number, end: number, text: string): void;
+    isProduceClick(): boolean;
+    setProduceClick(produceClick: boolean): void;
+    getActEnableList(): number[];
+    isSendAll(): boolean;
+    setSendAll(sendAll: boolean): void;
+    isBlockedByModalWindow(activeWindowData: MGData): boolean;
+    toString(): string;
+}
+
+declare class ExecutionStackEntry {
+    TaskId: string;
+    HandlerId: string;
+    OperIdx: number;
+    constructor(intaskId: string, inhandlerId: string, inoperIdx: number);
+    Equals(obj: any): boolean;
+}
+
+declare class ExecutionStack {
+    private _execStack;
+    constructor();
+    constructor(inExecStack: ExecutionStack);
+    private constructor_0;
+    private constructor_1;
+    getStack(): Stack<ExecutionStackEntry>;
+    push(execEntry: ExecutionStackEntry): void;
+    push(taskId: string, handlerId: string, operIdx: number): void;
+    private push_0;
+    private push_1;
+    pop(): ExecutionStackEntry;
+    empty(): boolean;
+    clear(): void;
+    size(): number;
+    Equals(execStackCmp: any): boolean;
+    pushUpSideDown(inExecStack: ExecutionStack): void;
+    reverse(): void;
+    buildXML(message: StringBuilder): void;
+}
+
+declare class CompMainPrgTable {
+    private _ctlIdxTab;
+    fillData(parser: XmlParser): void;
+    private initElements;
+    private initCtlIdxTab;
+    getCtlIdx(idx: number): number;
+    getIndexOf(ctlIdx: number): number;
+    getSize(): number;
+}
+
+declare enum EventsAllowedType {
+    NONE = 0,
+    NON_INTERACTIVE = 1,
+    ALL = 2
+}
+interface IEventsManager extends IGuiEventsManager {
+    getMatchingAction(kbItm: KeyboardItem): number;
+    ignoreUnknownAbort(): boolean;
+    getLastRtEvent(): RunTimeEvent;
+    getNextOperIdx(oper: any, clearWhenFound: boolean): number;
+    pushExecStack(taskId: string, handlerId: string, operIdx: number): void;
+    performSubformClose(subformCtrl: MgControl): Promise<void>;
+    handleEvent(rtEvt: any, returnedFromServer: boolean): Promise<void>;
+    popExecStack(): ExecutionStackEntry;
+    addToTail(rtEvt: RunTimeEvent): void;
+    getExecStack(): ExecutionStack;
+    getCompMainPrgTab(): CompMainPrgTable;
+    handleInternalEventWithTask(itask: ITask, eventCode: number): Promise<void>;
+    getCurrField(): Field;
+    getCurrTask(): Task;
+    pushNewExecStacks(): void;
+    popNewExecStacks(): void;
+    GetStopExecutionFlag(): boolean;
+    getCurrCtrl(): MgControl;
+    setStopExecution(stop: boolean): void;
+    setStopExecution(stop: boolean, clearEventsOnStopExecution: ClearEventsOnStopExecution): void;
+    handleInternalEventWithTaskAndSubformRefresh(itask: ITask, eventCode: number, subformRefresh: boolean): Promise<void>;
+    reverseServerExecStack(): void;
+    pushServerExecStack(taskId: string, handlerId: string, operIdx: number): void;
+    isForceExitPreRecordUpdate(task: GuiTaskBase): boolean;
+    handleInternalEventWithTaskAndEventSubtype(task: GuiTaskBase, eventCode: number, eventSubType: EventSubType): Promise<void>;
+    handleInternalEventWithMgControlBase(ctrl: MgControlBase, eventCode: number): Promise<void>;
+    DoTaskLevelRecordSuffix(task: TaskBase, refDoSuffix: RefParam<boolean>): Promise<boolean>;
+    HandleNonParkableControls(itask: ITask): Promise<void>;
+    HandleParkabilityOnRowChange(itask: ITask): Promise<void>;
+    DoTaskLevelRecordPrefix(task: GuiTaskBase): Promise<void>;
+    getProcessingTopMostEndTask(): boolean;
+    handleNonReversibleEvent(task: GuiTaskBase, eventCode: number): Promise<void>;
+    handleEvents(baseMgData: MGData, eventsToHandleCnt: number): Promise<void>;
+    handleEvents(handlersTab: HandlersTable, rtEvt: RunTimeEvent): Promise<void>;
+    handleEvents(baseMgDataOrHandlersTab: any, eventsToHandleCntOrRtEvt: any): Promise<void>;
+    setEventScopeTrans(): void;
+    isEventScopeTrans(): boolean;
+    clearEventScope(): void;
+    addInternalEventWithItaskAndCode(itask: ITask, code: number): void;
+    setProcessingTopMostEndTask(inProcessingTopMostEndTask: boolean): void;
+    NonInteractiveEventsLoop(mgData: MGData, taskBase: GuiTaskBase): Promise<void>;
+    EventsLoop(mgData: MGData): Promise<void>;
+    setIgnoreUnknownAbort(val: boolean): void;
+    setCompMainPrgTab(compMainPrgTable: CompMainPrgTable): void;
+    ProcessAbortingError(ex: ApplicationException): Promise<void>;
+    getAllowEvents(): EventsAllowedType;
+    setAllowEvents(AllowEvents: EventsAllowedType): void;
+    setNonInteractiveAllowEvents(AllowEvents: boolean): void;
+    getPendingGuiEvent(): any;
+    setPendingGuiEvent(guiEvent: any): void;
+    checkAndSaveRouteEventIfCtxRemovedFromSrvr(rtEvent: any): void;
+    CheckAndShowSpinner(show: boolean): Promise<void>;
+    SpinnerStopped: Subject<number>;
+    getIsInViewRefresh(): boolean;
+    setIsInViewRefresh(inViewRefresh: boolean): void;
+}
+
+declare class CommandsTable implements ICommandsTable {
+    private _cmds;
+    private _iterationIdx;
+    constructor();
+    static createCommandsTable(): ICommandsTable;
+    fillData(parser: XmlParser): void;
+    private initInnerObjects;
+    Execute(res: IResultValue): Promise<void>;
+    private extractCmd;
+    getCmd(idx: number): IClientCommand;
+    buildXML(message: StringBuilder): void;
+    Add(cmd: IClientCommand): void;
+    Clear(): void;
+    ExtractCommand(commandIndex: number): IClientCommand;
+    clear(): void;
+    getSize(): number;
+}
+
+interface IMGDataCollection extends IMGDataTable {
+    currMgdID: number;
+    StartupMgData: MGData;
+    getMGData(idx: number): MGData;
+    getTaskIdById(taskId: string): string;
+    getSize(): number;
+    getMGData(idx: number): MGData;
+    startTasksIteration(): void;
+    getNextTask(): ITask;
+    GetTopMostForms(): List<MgFormBase>;
+    getCurrMGData(): MGData;
+    GetMGDataForStartupProgram(): MGData;
+    getTriggeredTasks(triggeringTask: TaskBase): List<TaskBase>;
+    getAvailableIdx(): number;
+    addMGData(mgd: MGData, idx: number, isStartup: boolean): void;
+    buildXML(message: StringBuilder, serializeTasks: boolean): void;
+    processRecovery(): void;
+    execRequestWithSubformRecordCycle(cmdsToServer: CommandsTable, cmdToServer: IClientCommand, exp: Expression): Promise<void>;
+}
+
+declare enum ParamParseResult {
+    OK = 0,// save the value as is
+    TOUPPER = 1,// convert the name to upper case, so it would be case insensitive
+    DELETE = 2,// remove the variable from the dictionary
+    FAILED = 3
+}
+
+interface IMirrorXML {
+    mirrorToXML(): string;
+    init(name: string, xmlParser: XmlParser, unescapeFlag?: boolean): ParamParseResult;
+}
+
+declare class PrmMap<TValue extends IMirrorXML> {
+    values: Dictionary<TValue>;
+    protected getvalue(s: string): TValue;
+    setValue(s: string, v: TValue): void;
+    remove(s: string): void;
+    constructor();
+}
+declare class MirrorPrmMap<TValue extends IMirrorXML> extends PrmMap<TValue> {
+    protected changes: List<string>;
+    protected mirroredID: string;
+    private type;
+    constructor(type: new () => TValue);
+    private new;
+    setValue(s: string, v: TValue, addToChanges?: boolean): void;
+    private setValue_0;
+    private setValue_1;
+    remove(s: string): void;
+    mirrorAllToXML(): string;
+    CheckIfSystemReservedParam(key: any): boolean;
+    mirrorToXML(): string;
+    fillData(parser: XmlParser): void;
+    RestoreParams(xml: string, unescapeFlag?: boolean): void;
+    mirrorFromXML(foundTagName: string, xmlParser: XmlParser, unescapeFlag?: boolean): boolean;
+    fillDataEntry(xmlParser: XmlParser, unescapeFlag?: boolean): void;
+}
+
+declare class MirrorString implements IMirrorXML {
+    private _reserved;
+    private _value;
+    constructor();
+    constructor(s: string);
+    private constructor_0;
+    private constructor_1;
+    mirrorToXML(): string;
+    init(name: String, xmlParser: XmlParser, unescapeFlag: boolean): ParamParseResult;
+    ToString(): string;
+    isReserved(): boolean;
+}
+
+declare class MirrorExpVal extends ExpVal implements IMirrorXML {
+    constructor();
+    constructor(val: ExpVal);
+    private constructor_2;
+    private constructor_3;
+    mirrorToXML(): string;
+    init(name: String, xmlParser: XmlParser): ParamParseResult;
+}
+declare class GlobalParams extends MirrorPrmMap<MirrorExpVal> {
+    static Instance: GlobalParams;
+    private constructor();
+    set(s: string, v: ExpVal): void;
+    get(s: string): MirrorExpVal;
+}
+
+interface ILanguageData {
+    getConstMessage(msgId: string): string;
+}
+
+declare class AccessHelper {
+    static eventsManager: IEventsManager;
+    static mgDataTable: IMGDataCollection;
+    static envParamsTable: MirrorPrmMap<MirrorString>;
+    static globalParams: MirrorPrmMap<MirrorExpVal>;
+    static languageData: ILanguageData;
+    static environment: IEnvironment;
+}
+declare enum ClearEventsOnStopExecution {
+    NONE = " ",
+    SERVER = "S",
+    ALL = "A"
+}
+
+interface IGuiEvent {
+    EventType: string;
+    TaskID: string;
+    ControlName: string;
+    Line: number;
+    PageSize: number;
+    Value: string;
+    RouterPath: string;
+    RouterOutletName: any;
+    RouterParams: List<any>;
+    modifiers: Modifiers;
+    keyCode: number;
+    externalValue: any;
+    param: any;
+    fromButton: boolean;
+}
+declare function getGuiEventObj(eventType: string, controlName: string, line: number, fromButton?: boolean): IGuiEvent;
+
+declare class ClientManager {
+    private static _instance;
+    private _globalUniqueSessionId;
+    private _buttonIsClicked;
+    static handlingFirstParkableControl: boolean;
+    private static _executionPropertiesFileName;
+    private static assetsURL;
+    static get Instance(): ClientManager;
+    AddEvent(guiEvent: IGuiEvent): void;
+    private handleNavigateInRowEvent;
+    ConfirmationClosed(res: number): void;
+    WorkThreadExecution(): Promise<void>;
+    WriteExecutionPropertiesToLog(): void;
+    constructor();
+    private InitGuiManager;
+    private InitCircularReferencesBypasses;
+    static Main(httpClient: HttpClient, args: Map<string, string>): void;
+    static StopExecution(): Promise<void>;
+    static StartExecution(httpClient: HttpClient): Promise<void>;
+    LoadExecutionProps(): Promise<boolean>;
+    GetGlobalUniqueSessionID(): string;
+    static GetControlPictureMask(taskId: string, controlName: string): PIC;
+    static UploadFileToServer(fileContent: any, serverFileName: string): any;
+    static DownloadFileFromServer(serverFileName: string): Promise<ArrayBuffer>;
+    static GetFormattedValue(taskId: string, controlName: string, value: any, rowId?: string): string;
+    static GetRangedValue(taskId: string, controlName: string, value: string): string;
+    static ValidateControlValue(taskId: string, controlName: string, value: any): string;
+    static GetFldRanges(taskId: string, controlName: string): string;
+    static TransCacheExists(): boolean;
+    RegisterDelegates(): void;
+    GetRuntimeCtxID(): string;
+    static TerminateContextUsingFetchAPI(): void;
+    static GetAssetsURL(): string;
+}
+
+declare class CommandsProcessorManager {
+    static GetCommandsProcessor(): CommandsProcessorBase;
+    static GetContent(requestedURL: string, useCache: boolean): Promise<ArrayBuffer>;
+    static GetContentString(requestedURL: string, useCache: boolean): Promise<string>;
+    static StartSession(): Promise<boolean>;
+}
+
+declare class ConstInterface {
+    static MG_TAG_CONTEXT: string;
+    static MG_TAG_ENV: string;
+    static MG_TAG_COMMAND: string;
+    static MG_TAG_LANGUAGE: string;
+    static MG_TAG_LANGUAGE_END: string;
+    static MG_TAG_CONSTMESSAGES: string;
+    static MG_TAG_CONSTMESSAGES_END: string;
+    static MG_TAG_CONSTMESSAGESCONTENT: string;
+    static MG_TAG_CONSTMESSAGESCONTENT_END: string;
+    static MG_TAG_MLS_FILE_URL: string;
+    static MG_TAG_MLS_FILE_URL_END: string;
+    static MG_TAG_MLS_CONTENT: string;
+    static MG_TAG_MLS_CONTENT_END: string;
+    static MG_TAG_COMPMAINPRG: string;
+    static MG_TAG_STARTUP_PROGRAM: string;
+    static MG_TAG_CONTEXT_ID: string;
+    static MG_TAG_SESSION_ID: string;
+    static MG_TAG_HTTP_COMMUNICATION_TIMEOUT: string;
+    static MG_TAG_TASKDEFINITION_IDS_URL: string;
+    static MG_TAG_OFFLINE_SNIPPETS_URL: string;
+    static MG_ATTR_ISSPECIFIC: string;
+    static MG_ATTR_IS_GUI_THREAD_EXECUTION: string;
+    static MG_ATTR_FULLNAME: string;
+    static MG_TAG_TASKURL: string;
+    static MG_TAG_EXPTABLE: string;
+    static MG_TAG_EXP: string;
+    static MG_TAG_DATAVIEW: string;
+    static MG_TAG_COMPLETE_DV: string;
+    static MG_TAG_REC: string;
+    static MG_TAG_FLD_END: string;
+    static MG_TAG_HANDLER: string;
+    static MG_TAG_EVENTHANDLERS: string;
+    static MG_TAG_EVENT: string;
+    static MG_TAG_OPER: string;
+    static MG_TAG_KBDMAP_URL: string;
+    static MG_TAG_KBDMAP: string;
+    static MG_TAG_USER_EVENTS: string;
+    static MG_TAG_USER_EVENTS_END: string;
+    static MG_TAG_EVENTS_QUEUE: string;
+    static MG_TAG_DC_VALS: string;
+    static MG_TAG_FLWMTR_CONFIG: string;
+    static MG_TAG_FLWMTR_MSG: string;
+    static MG_TAG_FLWMTR_ACT: string;
+    static MG_TAG_DEL_LIST: string;
+    static MG_TAG_LINKS: string;
+    static MG_TAG_LINKS_END: string;
+    static MG_TAG_LINK: string;
+    static MG_TAG_TASK_TABLES: string;
+    static MG_TAG_TASK_TABLES_END: string;
+    static MG_TAG_COLUMN: string;
+    static MG_TAG_SORT: string;
+    static MG_TAG_SORTS: string;
+    static MG_TAG_SORTS_END: string;
+    static MG_TAG_CACHED_TABLE: string;
+    static MG_TAG_CACHED_TABLE_END: string;
+    static MG_TAG_RECORDS: string;
+    static MG_TAG_RECORDS_END: string;
+    static MG_TAG_TASK_XML: string;
+    static MG_TAG_EXEC_STACK_ENTRY: string;
+    static MG_TAG_DBH_REAL_IDXS: string;
+    static MG_TAG_USER_DETAILS: string;
+    static MG_ATTR_OBJECT: string;
+    static MG_ATTR_ARGLIST: string;
+    static MG_ATTR_VIRTUAL: string;
+    static MG_ATTR_SUBFORM_TASK: string;
+    static MG_ATTR_PARAM: string;
+    static MG_ATTR_PARAMS: string;
+    static MG_ATTR_ROUTE_PARAMS: string;
+    static MG_ATTR_EXPOSED_ROUTE_PARAMS: string;
+    static MG_ATTR_EXPOSED_TO_CLIENT: string;
+    static MG_ATTR_PAR_ATTRS: string;
+    static MG_ATTR_VIR_AS_REAL: string;
+    static MG_ATTR_LNK_CREATE: string;
+    static MG_ATTR_RANGE: string;
+    static MG_ATTR_NULLVALUE: string;
+    static MG_ATTR_INIT: string;
+    static MG_ATTR_MODE: string;
+    static MG_ATTR_RECOMPUTEBY: string;
+    static MG_ATTR_HANDLEDBY: string;
+    static MG_ATTR_LEVEL: string;
+    static MG_ATTR_SECONDS: string;
+    static MG_ATTR_SCOPE: string;
+    static MG_ATTR_PROPAGATE: string;
+    static MG_ATTR_ENABLED: string;
+    static MG_ATTR_FLD: string;
+    static MG_ATTR_FIELDID: string;
+    static MG_ATTR_IGNORE_SUBFORM_RECOMPUTE: string;
+    static MG_ATTR_MAGICEVENT: string;
+    static MG_ATTR_FOCUSLIST: string;
+    static MG_ATTR_FOCUSTASK: string;
+    static MG_ATTR_TEXT: string;
+    static MG_ATTR_TITLE: string;
+    static MG_ATTR_TITLE_EXP: string;
+    static MG_ATTR_IMAGE: string;
+    static MG_ATTR_BUTTONS: string;
+    static MG_ATTR_RETURN_VAL: string;
+    static MG_ATTR_ERR_LOG_APPEND: string;
+    static MG_ATTR_EVENTTYPE: string;
+    static MG_ATTR_HOW: string;
+    static MG_ATTR_UNDO: string;
+    static MG_ATTR_CND: string;
+    static MG_ATTR_KEYCODE: string;
+    static MG_ATTR_MODIFIER: string;
+    static MG_ATTR_CURR_REC: string;
+    static MG_ATTR_LAST_REC_ID: string;
+    static MG_ATTR_OLD_FIRST_REC_ID: string;
+    static MG_ATTR_CURR_REC_POS_IN_FORM: string;
+    static MG_ATTR_DATEMODE: string;
+    static MG_ATTR_THOUSANDS: string;
+    static MG_ATTR_DECIMAL_SEPARATOR: string;
+    static MG_ATTR_DATE: string;
+    static MG_ATTR_TIME: string;
+    static MG_ATTR_LANGUAGE: string;
+    static MG_ATTR_MODAL: string;
+    static MG_ATTR_IS_ROUTE: string;
+    static MG_ATTR_TASK: string;
+    static MG_ATTR_INTERNALEVENT: string;
+    static MG_ATTR_VARIABLE: string;
+    static MG_ATTR_HANDLERID: string;
+    static MG_ATTR_ROLLBACK_TYPE: string;
+    static MG_ATTR_CENTURY: string;
+    static MG_ATTR_INCLUDE_FIRST: string;
+    static MG_ATTR_INCLUDE_LAST: string;
+    static MG_ATTR_IS_ONEWAY_KEY: string;
+    static MG_ATTR_INSERT_AT: string;
+    static MG_ATTR_DBVIEWSIZE: string;
+    static MG_ATTR_INVALIDATE: string;
+    static MG_ATTR_RMPOS: string;
+    static MG_ATTR_DISPLAY: string;
+    static MG_ATTR_SUBTYPE: string;
+    static MG_ATTR_ADD_AFTER: string;
+    static MG_ATTR_TOP_REC_ID: string;
+    static MG_ATTR_LOW_ID: string;
+    static MG_ATTR_OWNER: string;
+    static MG_ATTR_UPD_IN_QUERY: string;
+    static MG_ATTR_UPD_IN_QUERY_LOWER: string;
+    static MG_ATTR_CRE_IN_MODIFY: string;
+    static MG_ATTR_CRE_IN_MODIFY_LOWER: string;
+    static MG_ATTR_IDLETIME: string;
+    static MG_ATTR_WAIT: string;
+    static MG_ATTR_RETAIN_FOCUS: string;
+    static MG_ATTR_SYNC_DATA: string;
+    static MG_ATTR_SHOW: string;
+    static MG_ATTR_COMPONENT: string;
+    static MG_ATTR_PATH_PARENT_TASK: string;
+    static MG_ATTR_USER: string;
+    static MG_ATTR_FORCE_EXIT: string;
+    static MG_ATTR_PUBLIC: string;
+    static MG_ATTR_PRG_DESCRIPTION: string;
+    static MG_ATTR_TABLE_NAME: string;
+    static MG_ATTR_INDEX_IN_TABLE: string;
+    static MG_ATTR_CALLINGTASK: string;
+    static MG_ATTR_FLAGS: string;
+    static MG_ATTR_LNKEXP: string;
+    static MG_ATTR_MODIFIED: string;
+    static MG_ATTR_OPER: string;
+    static MG_ATTR_REFRESHON: string;
+    static MG_ATTR_TASKMODE: string;
+    static MG_ATTR_EMPTY_DATAVIEW: string;
+    static MG_ATTR_TASKLEVEL: string;
+    static MG_ATTR_TRANS_CLEARED: string;
+    static MG_ATTR_TRANS_STAT: string;
+    static MG_ATTR_SUBFORM_VISIBLE: string;
+    static MG_ATTR_ACK: string;
+    static MG_ATTR_COMPUTE_BY: string;
+    static MG_ATTR_CHUNK_SIZE: string;
+    static MG_ATTR_CHUNK_SIZE_EXPRESSION: string;
+    static MG_ATTR_HAS_MAIN_TBL: string;
+    static MG_ATTR_SERVER_ID: string;
+    static MG_ATTR_SUBFORM_CTRL: string;
+    static MG_ATTR_CHECK_BY_SERVER: string;
+    static MG_ATTR_OPER_IDX: string;
+    static MG_ATTR_EXP_IDX: string;
+    static MG_ATTR_EXP_TYPE: string;
+    static MG_ATTR_NULL: string;
+    static MG_ATTR_NULLS: string;
+    static MG_ATTR_DC_REFS: string;
+    static MG_ATTR_LINKED: string;
+    static MG_ATTR_DISP: string;
+    static MG_ATTR_REMOVE: string;
+    static MG_ATTR_DVPOS: string;
+    static MG_ATTR_SIGNIFICANT_NUM_SIZE: string;
+    static MG_ATTR_DEBUG_MODE: string;
+    static MG_ATTR_POINT_TRANSLATION: string;
+    static MG_ATTR_SPECIAL_EXITCTRL: string;
+    static MG_ATTR_DEFAULT_COLOR: string;
+    static MG_ATTR_DEFAULT_FOCUS_COLOR: string;
+    static MG_ATTR_DEFAULT_DISABLED_COLOR: string;
+    static MG_ATTR_CONTEXT_INACTIVITY_TIMEOUT: string;
+    static MG_ATTR_CLIENT_CONTEXT_INACTIVITY_TIMEOUT: string;
+    static MG_ATTR_CONTEXT_INACTIVITY_TIMEOUT_LOWER: string;
+    static MG_ATTR_CONTEXT_INACTIVITY_WARNING_TIME: string;
+    static MG_ATTR_CONTEXT_INACTIVITY_WARNING_TIME_LOWER: string;
+    static MG_ATTR_CONTEXT_UNLOAD_TIMEOUT: string;
+    static MG_ATTR_CONTEXT_UNLOAD_TIMEOUT_LOWER: string;
+    static MG_ATTR_TOOLTIP_TIMEOUT: string;
+    static MG_ATTR_WEBCLIENT_REINIT_SESSION: string;
+    static MG_ATTR_LOWHIGH: string;
+    static MG_ATTR_ACCESS_TEST: string;
+    static MG_ATTR_SPECIAL_TEXT_SIZE_FACTORING: string;
+    static MG_ATTR_SPECIAL_FLAT_EDIT_ON_CLASSIC_THEME: string;
+    static MG_ATTR_SPECIAL_LEGACY_TRIM_RANGE: string;
+    static MG_ATTR_SPECIAL_LEGACY_EMPTY_RANGE: string;
+    static MG_ATTR_ENCODING: string;
+    static MG_ATTR_SYSTEM: string;
+    static MG_ATTR_RECOVERY: string;
+    static MG_ATTR_REVERSIBLE: string;
+    static MG_ATTR_NEWID: string;
+    static MG_ATTR_MPRG_SOURCE: string;
+    static MG_ATTR_INVOKER_ID: string;
+    static MG_ATTR_TRANS_LEVEL: string;
+    static MG_ATTR_LEN: string;
+    static MG_ATTR_DESC: string;
+    static MG_ATTR_CLOSE_SUBFORM_ONLY: string;
+    static MG_ATTR_CHECK_ONLY: string;
+    static MG_ATTR_EXEC_ON_SERVER: string;
+    static MG_ATTR_EXEC_ON_CLIENT: string;
+    static MG_ATTR_USER_SORT: string;
+    static MG_TAG_USERNAME: string;
+    static MG_TAG_IS_LOGGED_IN: string;
+    static MG_TAG_PASSWORD: string;
+    static MG_TAG_ASSETS_URL: string;
+    static MG_ATTR_USERID: string;
+    static MG_ATTR_USERINFO: string;
+    static MG_ATTR_CPY_GLB_PRMS: string;
+    static MG_TAG_GLOBALPARAMS: string;
+    static MG_TAG_GLOBALPARAMSCHANGES: string;
+    static MG_ATTR_FILE_PATH: string;
+    static MG_TAG_CACHED_FILE: string;
+    static MG_ATTR_CACHE_URL: string;
+    static MG_TAG_PARAM: string;
+    static MG_ATTR_IME_AUTO_OFF: string;
+    static MG_ATTR_LOCAL_AS400SET: string;
+    static MG_ATTR_LOCAL_EXTRA_GENGO: string;
+    static MG_ATTR_LOCAL_FLAGS: string;
+    static MG_ATTR_SPEACIAL_ANSI_EXP: string;
+    static MG_ATTR_SPECIAL_IMMEDIATE_HANDLER_END: string;
+    static MG_ATTR_SPECIAL_SHOW_STATUSBAR_PANES: string;
+    static MG_ATTR_SPECIAL_ROUTE_TO_ROOT_PROG_ON_CONTEXT_RECREATION: string;
+    static MG_ATTR_SPECIAL_SPECIAL_EDIT_LEFT_ALIGN: string;
+    static MG_ATTR_SPEACIAL_SWF_CONTROL_NAME: string;
+    static MG_ATTR_SPECIAL_VAL_NEW_POLICY: string;
+    static MG_ATTR_OPER_CALLMODE: string;
+    static MG_ATTR_TASK_MAINLEVEL: string;
+    static MG_ATTR_OPER_METHODNAME: string;
+    static MG_ATTR_GUID: string;
+    static MG_ATTR_CONTROLS_PERSISTENCY_PATH: string;
+    static MG_ATTR_PROJDIR: string;
+    static MG_ATTR_TERMINAL: string;
+    static MG_TAG_ENV_PARAM_URL: string;
+    static MG_TAG_ENV_PARAM: string;
+    static MG_ATTR_HANDLER_ONFORM: string;
+    static MG_ATTR_DROP_USERFORMATS: string;
+    static MG_ATTR_CONTROL_NAME: string;
+    static MG_ATTR_SEARCH_STR: string;
+    static MG_TAG_HIDDEN_CONTOLS: string;
+    static MG_ATTR_ISNS: string;
+    static MG_ATTR_SPECIAL_CANCEL_ON_CREATE: string;
+    static MG_ATTR_TIME_SEPARATOR: string;
+    static MG_ATTR_IOTIMING: string;
+    static MG_ATTR_HTTP_TIMEOUT: string;
+    static MG_ATTR_USE_SIGNED_BROWSER_CLIENT: string;
+    static MG_ATTR_CLOSE_PRINTED_TABLES_IN_SUBTASKS: string;
+    static MG_ATTR_GENERIC_TEXT_PRINTING: string;
+    static MG_ATTR_HIGH_RESOLUTION_PRINT: string;
+    static MG_ATTR_MERGE_TRIM: string;
+    static MG_ATTR_ORIGINAL_IMAGE_LOAD: string;
+    static MG_ATTR_PRINT_DATA_TRIM: string;
+    static MG_ATTR_PSCRIPT_PRINT_NT: string;
+    static MG_ATTR_THOUSAND_SEPARATOR: string;
+    static MG_ATTR_RTF_BUFFER_SIZE: string;
+    static MG_ATTR_SPECIAL_CONV_ADD_SLASH: string;
+    static MG_ATTR_SPECIAL_FULL_EXPAND_PRINT: string;
+    static MG_ATTR_SPECIAL_FULL_TEXT: string;
+    static MG_ATTR_SPECIAL_LAST_LINE_PRINT: string;
+    static MG_ATTR_SPECIAL_PRINTER_OEM: string;
+    static MG_ATTR_RANGE_POP_TIME: string;
+    static MG_ATTR_TEMP_POP_TIME: string;
+    static MG_ATTR_EMBED_FONTS: string;
+    static MG_ATTR_BATCH_PAINT_TIME: string;
+    static MG_ATTR_ISAM_TRANSACTION: string;
+    static MG_ATTR_CENTER_SCREEN_IN_ONLINE: string;
+    static MG_ATTR_REPOSITION_AFTER_MODIFY: string;
+    static MG_ATTR_TASKFLW: string;
+    static MG_ATTR_RECOMP: string;
+    static MG_ATTR_FLWOP: string;
+    static MG_ATTR_END: string;
+    static MG_ATTR_INFO: string;
+    static MG_ATTR_KEY: string;
+    static MG_ATTR_KEY_EXP: string;
+    static MG_ATTR_NULL_FLAGS: string;
+    static MG_ATTR_DVPOS_VALUE: string;
+    static MG_ATTR_DVPOS_DEC: string;
+    static MG_ATTR_TRANS_ID: string;
+    static MG_ATTR_REALREFRESH: string;
+    static MG_ATTR_SUB_FORM_RCMP: string;
+    static MG_ATTR_HAS_LINK_RECOMPUTES: string;
+    static MG_ATTR_LOCATE_FIRST_ID: string;
+    static MG_ATTR_OFFSET: string;
+    static MG_ATTR_HAS_LOCATE: string;
+    static MG_ATTR_AS_PARENT: string;
+    static MG_ATTR_TASK_UNIQUE_SORT: string;
+    static MG_ATTR_TRANS_OWNER: string;
+    static MG_ATTR_CLOSE: string;
+    static MG_ATTR_TASK_COUNTER: string;
+    static MG_ATTR_LOOP_COUNTER: string;
+    static MG_ATTR_CHACHED_FLD_ID: string;
+    static MG_ATTR_LOCATE: string;
+    static MG_ATTR_LINK: string;
+    static MG_ATTR_IS_LINK_FIELD: string;
+    static MG_ATTR_CACHED_TABLE: string;
+    static MG_ATTR_TABLE_INDEX: string;
+    static MG_ATTR_LINK_EVAL_CONDITION: string;
+    static MG_ATTR_LINK_MODE: string;
+    static MG_ATTR_LINK_START: string;
+    static MG_ATTR_IDENT: string;
+    static MG_ATTR_DIR: string;
+    static MG_ATTR_COND: string;
+    static MG_ATTR_COND_RES: string;
+    static MG_ATTR_RET_VAL: string;
+    static MG_ATTR_DBPOS: string;
+    static MG_TAG_USR_DEF_FUC_RET_EXP_ID: string;
+    static MG_TAG_USR_DEF_FUC_RET_EXP_ATTR: string;
+    static MG_ATTR_DIRECTION: string;
+    static MG_ATTR_KEEP_USER_SORT: string;
+    static MG_TAG_DBHS: string;
+    static MG_TAG_DBHS_END: string;
+    static MG_TAG_DBH_DATA_IDS_URL: string;
+    static MG_TAG_FLD: string;
+    static MG_ATTR_STORAGE: string;
+    static MG_ATTR_PICTURE: string;
+    static MG_ATTR_NAME: string;
+    static MG_ATTR_FIELD_INDEX: string;
+    static MG_ATTR_MIN_VALUE: string;
+    static MG_ATTR_MAX_VALUE: string;
+    static MG_ATTR_NULL_MIN_VALUE: string;
+    static MG_ATTR_NULL_MAX_VALUE: string;
+    static MG_TAG_DATABASES_HEADER: string;
+    static MG_TAG_DATABASE_URL: string;
+    static BYTES_IN_CHAR: number;
+    static MG_OPER_VERIFY: number;
+    static MG_OPER_BLOCK: number;
+    static MG_OPER_LOOP: number;
+    static MG_OPER_ELSE: number;
+    static MG_OPER_ENDBLOCK: number;
+    static MG_OPER_CALL: number;
+    static MG_OPER_EVALUATE: number;
+    static MG_OPER_UPDATE: number;
+    static MG_OPER_USR_EXIT: number;
+    static MG_OPER_RAISE_EVENT: number;
+    static MG_OPER_SERVER: number;
+    static TRANS_COMMIT: string;
+    static TRANS_ABORT: string;
+    static EVENT_TYPE_SYSTEM: string;
+    static EVENT_TYPE_INTERNAL: string;
+    static EVENT_TYPE_TIMER: string;
+    static EVENT_TYPE_EXPRESSION: string;
+    static EVENT_TYPE_USER: string;
+    static EVENT_TYPE_PUBLIC: string;
+    static EVENT_TYPE_NONE: string;
+    static EVENT_TYPE_NOTINITED: string;
+    static EVENT_TYPE_USER_FUNC: string;
+    static BRK_LEVEL_TASK_PREFIX: string;
+    static BRK_LEVEL_TASK_SUFFIX: string;
+    static BRK_LEVEL_REC_PREFIX: string;
+    static BRK_LEVEL_REC_MAIN: string;
+    static BRK_LEVEL_REC_SUFFIX: string;
+    static BRK_LEVEL_CTRL_PREFIX: string;
+    static BRK_LEVEL_CTRL_SUFFIX: string;
+    static BRK_LEVEL_CTRL_VERIFICATION: string;
+    static BRK_LEVEL_HANDLER_INTERNAL: string;
+    static BRK_LEVEL_HANDLER_SYSTEM: string;
+    static BRK_LEVEL_HANDLER_TIMER: string;
+    static BRK_LEVEL_HANDLER_EXPRESSION: string;
+    static BRK_LEVEL_HANDLER_USER: string;
+    static BRK_LEVEL_USER_FUNCTION: string;
+    static BRK_LEVEL_VARIABLE: string;
+    static BRK_LEVEL_MAIN_PROG: string;
+    static BRK_LEVEL_SUBFORM: string;
+    static BRK_LEVEL_TASK_PREFIX_FM: string;
+    static BRK_LEVEL_TASK_SUFFIX_FM: string;
+    static BRK_LEVEL_REC_PREFIX_FM: string;
+    static BRK_LEVEL_REC_SUFFIX_FM: string;
+    static BRK_LEVEL_CTRL_PREFIX_FM: string;
+    static BRK_LEVEL_CTRL_SUFFIX_FM: string;
+    static BRK_LEVEL_VARIABLE_FM: string;
+    static BRK_LEVEL_CTRL_VERIFICATION_FM: string;
+    static BRK_LEVEL_HANDLER_INTERNAL_FM: string;
+    static BRK_LEVEL_HANDLER_SYSTEM_FM: string;
+    static BRK_LEVEL_HANDLER_TIMER_FM: string;
+    static BRK_LEVEL_HANDLER_EXPRESSION_FM: string;
+    static BRK_LEVEL_HANDLER_USER_FM: string;
+    static BRK_LEVEL_USER_FUNCTION_FM: string;
+    static TRANS_NONE: string;
+    static TRANS_RECORD_PREFIX: string;
+    static TRANS_TASK_PREFIX: string;
+    static RECOVERY_NONE: string;
+    static RECOVERY_ROLLBACK: string;
+    static RECOVERY_RETRY: string;
+    static FLW_VERIFY_MODE_ERROR: string;
+    static IMAGE_EXCLAMATION: string;
+    static IMAGE_CRITICAL: string;
+    static IMAGE_QUESTION: string;
+    static IMAGE_INFORMATION: string;
+    static BUTTONS_OK: string;
+    static BUTTONS_OK_CANCEL: string;
+    static BUTTONS_ABORT_RETRY_IGNORE: string;
+    static BUTTONS_YES_NO_CANCEL: string;
+    static BUTTONS_YES_NO: string;
+    static BUTTONS_RETRY_CANCEL: string;
+    static DISPLAY_BOX: string;
+    static DISPLAY_STATUS: string;
+    static END_COND_EVAL_BEFORE: string;
+    static END_COND_EVAL_AFTER: string;
+    static END_COND_EVAL_IMMIDIATE: string;
+    static ARG_TYPE_FIELD: string;
+    static ARG_TYPE_EXP: string;
+    static ARG_TYPE_VALUE: string;
+    static ARG_TYPE_SKIP: string;
+    static TOP_LEVEL_CONTAINER: number;
+    static REQ_ARG_ALPHA: string;
+    static REQ_ARG_UNICODE: string;
+    static REQ_ARG_NUMERIC: string;
+    static REQ_ARG_DOUBLE: string;
+    static REQ_ARG_LOGICAL: string;
+    static REQ_ARG_NULL: string;
+    static REQ_ARG_SEPARATOR: string;
+    static REQ_ARG_START: string;
+    static REQ_APP_NAME: string;
+    static REQ_ARGS: string;
+    static REQ_SKIP_AUTHENTICATION: string;
+    static RC_INDICATION_INITIAL: string;
+    static RC_INDICATION: string;
+    static UTF8TRANS: string;
+    static RC_TOKEN_CTX_ID: string;
+    static RC_TOKEN_SESSION_ID: string;
+    static RC_TOKEN_CTX_GROUP: string;
+    static RC_TOKEN_SESSION_COUNT: string;
+    static RC_TOKEN_DATA: string;
+    static RC_TOKEN_TARGET_FILE: string;
+    static WEBCLIENT_REINITIALIZE_REQUEST: string;
+    static MAIN_PROG_VIEW: string;
+    static GLOBAL_PARAM_LIST: string;
+    static ENV_VAR_LIST: string;
+    static LAST_EXCEPTION: string;
+    static CTX_REMOVED_FROM_SRVR: string;
+    static LAST_ROUTE_EVENT: string;
+    static LAST_ROUTE_EVENT_ARG_LIST: string;
+    static LAST_ROUTE_EVENT_SRC_TSK: string;
+    static IS_SESSION_REINITIALIZING: string;
+    static RC_AUTHENTICATION_REQUEST: string;
+    static V24_RIA_ERROR_PREFIX: string;
+    static SESSION_COUNTER_CLOSE_CTX_INDICATION: number;
+    static SERVER: string;
+    static CTX_GROUP: string;
+    static ERROR_STRING: string;
+    static USER_RANGES: string;
+    static USER_LOCATES: string;
+    static SORT: string;
+    static MIN_RNG: string;
+    static MAX_RNG: string;
+    static NULL_MIN_RNG: string;
+    static NULL_MAX_RNG: string;
+    static CLEAR_RANGE: string;
+    static CLEAR_LOCATES: string;
+    static CLEAR_SORTS: string;
+    static USER_RNG: string;
+    static MG_TAG_ENV_CHANGES: string;
+    static MG_ATTR_ENV_VALUE: string;
+    static MG_ATTR_ENV_WRITEINI: string;
+    static MG_ATTR_ENV_RESERVED: string;
+    static MG_ATTR_ENV_REMOVED: string;
+    static INI_SECTION_MAGIC_ENV_BRACKETS: string;
+    static INI_SECTION_LOGICAL_NAMES_BRACKETS: string;
+    static INI_SECTION_MAGIC_ENV: string;
+    static INI_SECTION_MAGIC_SYSTEMS: string;
+    static INI_SECTION_MAGIC_DBMS: string;
+    static INI_SECTION_MAGIC_SERVERS: string;
+    static INI_SECTION_MAGIC_COMMS: string;
+    static INI_SECTION_MAGIC_PRINTERS: string;
+    static INI_SECTION_MAGIC_SYSTEM_MENU: string;
+    static INI_SECTION_MAGIC_DATABASES: string;
+    static INI_SECTION_MAGIC_LANGUAGE: string;
+    static INI_SECTION_MAGIC_SERVICES: string;
+    static INI_SECTION_TOOLS_MENU: string;
+    static INITIAL_OFFLINE_TASK_TAG: number;
+    static ENABLE_COMMUNICATION_DIALOGS: string;
+    static MG_ATTR_VAL_ABORT: string;
+    static MG_ATTR_VAL_ENHANCED_VERIFY: string;
+    static MG_ATTR_VAL_OPENURL: string;
+    static MG_ATTR_VAL_RESULT: string;
+    static MG_ATTR_VAL_VERIFY: string;
+    static MG_ATTR_VAL_ADD_RANGE: string;
+    static MG_ATTR_VAL_ADD_LOCATE: string;
+    static MG_ATTR_VAL_ADD_SORT: string;
+    static MG_ATTR_VAL_RESET_RANGE: string;
+    static MG_ATTR_VAL_RESET_LOCATE: string;
+    static MG_ATTR_VAL_RESET_SORT: string;
+    static MG_ATTR_VAL_CLIENT_REFRESH: string;
+    static MG_ATTR_VAL_EVAL: string;
+    static MG_ATTR_VAL_EVENT: string;
+    static MG_ATTR_VAL_EXEC_OPER: string;
+    static MG_ATTR_VAL_QUERY: string;
+    static MG_ATTR_VAL_QUERY_CACHED_FILE: string;
+    static MG_ATTR_VAL_QUERY_GLOBAL_PARAMS: string;
+    static MG_ATTR_VAL_QUERY_TYPE: string;
+    static MG_ATTR_VAL_RECOMP: string;
+    static MG_ATTR_VAL_TRANS: string;
+    static MG_ATTR_VAL_UNLOAD: string;
+    static MG_ATTR_VAL_INIPUT_FORCE_WRITE: string;
+    static MG_ATTR_VAL_INIPUT_PARAM: string;
+    static MG_ATTR_ERROR_MESSAGE: string;
+    static MG_ATTR_VAL_TOTAL_RECORDS_COUNT: string;
+    static MG_ATTR_VAL_RECORDS_BEFORE_CURRENT_VIEW: string;
+    static MG_ATTR_VAL_SERVER_TRANS_CACHE_EMPTY: string;
+    static MG_ATTR_SPECIAL_ANSI_BLOB_CHECK_NULL: string;
+    static MG_ATTR_SPECIAL_TABLE_REDUCE_TITLE_HEIGHT: string;
+    static MG_ATTR_SPECIAL_DOTNET_ALLOW_ZERO_DATE: string;
+    static MG_ATTR_SPECIAL_REUSE_TABLE_EDITOR: string;
+    static MG_TAG_LAST_ROUTE: string;
+    static RC_TOKEN_CACHED_FILE: string;
+}
+
+declare let CurrentClientVersion: string;
+
+declare class FlowMonitorInterface {
+    static FLWMTR_START: number;
+    static FLWMTR_END: number;
+    static FLWMTR_PROPAGATE: number;
+    static FLWMTR_EVENT: number;
+    static FLWMTR_CHNG_MODE: number;
+    static FLWMTR_PREFIX: number;
+    static FLWMTR_SUFFIX: number;
+    static FLWMTR_CTRL_PREFIX: number;
+    static FLWMTR_CTRL_SUFFIX: number;
+    static FLWMTR_TSK_HANDLER: number;
+    static FLWMTR_RECOMP: number;
+    static FLWMTR_DATA_OPER: number;
+    static FLWMTR_VARCHG_VALUE: number;
+}
+
+declare abstract class IClientTargetedCommand implements IClientCommand {
+    abstract get IsBlocking(): any;
+    Frame: number;
+    TaskTag: string;
+    Obj: string;
+    shouldExecute: boolean;
+    get ShouldExecute(): boolean;
+    Execute(res: IResultValue): Promise<void>;
+    abstract HandleAttribute(attribute: string, value: string): void;
+}
+
+declare class GlobalCommandsManager {
+    static Instance: GlobalCommandsManager;
+    private constructor();
+    private _CommandsExecutedAfterTaskStarted;
+    private _cmdFrame;
+    private _unframedCmds;
+    getCommandsExecutedAfterTaskStarted(): List<IClientTargetedCommand>;
+    addCommandsExecutedAfterTaskStarted(cmd: IClientTargetedCommand): void;
+    removeCommandsExecutedAfterTaskStarted(cmd: IClientTargetedCommand): void;
+    add1toCmdFrame(): void;
+    getCmdFrame(): number;
+    addUnframedCmd(cmd: IClientCommand): void;
+    getUnframedCmds(): List<IClientCommand>;
+}
+
+declare class GuiEventsProcessor extends EventsProcessor {
+    RegisterSubclassHandlers(): void;
+    constructor();
+    private static processCtrlFocus;
+    private static processFocus;
+    private static processFocusOnNonMagicControl;
+    private static processMouseUp;
+    private static processDispose;
+    private static ProcessTimer;
+    private static processTableResize;
+    private static processGetRowsData;
+    private static OnNonParkableLastParkedCtrl;
+    private static processSelection;
+    processKeyDown(guiMgForm: GuiMgForm, guiMgCtrl: GuiMgControl, modifier: Modifiers, keyCode: number, start: number, end: number, text: string, isActChar: boolean, suggestedValue: string, handled: boolean): boolean;
+    private static peekEndOfWork;
+    private static getMainProgram;
+    private static GetRuntimeContext;
+    private static SaveLastClickedControlName;
+    private static SaveLastClickInfo;
+    private static IsLogonRTL;
+    private static ShowSessionStatistics;
+    private static ShouldAddEnterAsKeyEvent;
+}
+
+declare class GUIManager {
+    private static _instance;
+    static get Instance(): GUIManager;
+    execGuiCommandQueue(): void;
+    startTimer(mgData: MGData, seconds: number, isIdleTimer: boolean): void;
+    stopTimer(mgData: MGData, seconds: number, isIdleTimer: boolean): void;
+    abort(form: MgForm): void;
+    abort(): void;
+    private abort_0;
+    private abort_1;
+    MessageBox(title: string, msg: string, style: number): Promise<number>;
+    writeToMessageBox(titleId: string, msgId: string, style: number): Promise<number>;
+    confirm(msgId: string, style: number): Promise<number>;
+    confirm_bool(msgId: string): Promise<boolean>;
+}
+
+interface IServerConfig {
+    protocol: string;
+    server: string;
+    requester: string;
+    appname: string;
+    LogClientSequenceForActivityMonitor: boolean;
+    InternalLogLevel: string;
+    InternalLogSync: string;
+    DisplayGenericError: boolean;
+    FirstHTTPRequestTimeout: number;
+}
+
+declare class ServerConfig {
+    static Instance: ServerConfig;
+    private constructor();
+    private _executionProps;
+    private _protocol;
+    private _server;
+    private _httpReq;
+    private _appName;
+    private _serverUrl;
+    Init(obj: IServerConfig): void;
+    ShouldDisplayGenericError(): boolean;
+    setUsername(username: string): void;
+    setPassword(password: string): void;
+    setSkipAuthenticationDialog(value: boolean): void;
+    setGlobalParams(val: string): void;
+    getGlobalParams(): string;
+    getProtocol(): string;
+    getServer(): string;
+    getHttpReq(): string;
+    getAppName(): string;
+    getInternalLogLevel(): string;
+    setInternalLogLevel(value: string): void;
+    getInternalLogSync(): string;
+    getUsername(): string;
+    getPassword(): string;
+    getAssetsURL(): string;
+    getCtxGroup(): string;
+    setCtxGroup(CtxGroup: string): void;
+    getSkipAuthenticationDialog(): boolean;
+    GetFirstHttpRequestTimeout(): number;
+    GetExecutionProperty(propName: string): string;
+    getServerURL(): string;
+    IsLogonRTL(): boolean;
+}
+
+declare class MagicBridge {
+    static Initialize(httpClient: HttpClient, args: Map<string, string>): void;
+    static TerminateMagic(): Promise<void>;
+    static registerExecuteCommandsCallback(cb: any): void;
+    static registerInteractiveCallback(cb: any): void;
+    static insertEvent(guiEvent: IGuiEvent): void;
+    static GetControlPictureMask(taskId: string, controlName: string): any;
+    static UploadFileToServer(fileContent: any, serverFileName: string): any;
+    static DownloadFileFromServer(serverFileName: string): Promise<ArrayBuffer>;
+    static GetFormattedValue(taskId: string, controlName: string, value: any, rowId?: string): string;
+    static GetRangedValue(taskId: string, controlName: string, value: string): string;
+    static ValidateControlValue(taskId: string, controlName: string, value: any): string;
+    static GetFldRanges(taskId: string, controlName: string): string;
+    static TransCacheExists(): boolean;
+    static TerminateContextUsingFetchAPI(): void;
+}
+
+declare abstract class ClientOriginatedCommand implements IClientCommand {
+    abstract get CommandTypeAttribute(): string;
+    get ShouldSerialize(): boolean;
+    get ShouldSerializeRecords(): boolean;
+    SerializeCommandData(): string;
+    SerializeDataAfterCommand(): string;
+}
+
+interface ICommandTaskTag {
+    TaskTag: string;
+}
+
+declare abstract class ClientOriginatedCommandTaskTag extends ClientOriginatedCommand implements ICommandTaskTag {
+    TaskTag: string;
+    constructor();
+    get Task(): Task;
+}
+
+declare abstract class DataViewCommandBase {
+    DataviewManager: DataviewManagerBase;
+    Execute(): Promise<ReturnResultBase>;
+}
+
+interface IClientToServerCommandInfo {
+    getCommandInfo(): string;
+    getFieldsInfo?(): string;
+}
+
+declare enum DataViewCommandType {
+    Init = 0,
+    Clear = 1,
+    Prepare = 2,
+    FirstChunk = 3,
+    RecomputeUnit = 4,
+    ExecuteLocalUpdates = 5,
+    InitDataControlViews = 6,
+    OpenTransaction = 7,
+    CloseTransaction = 8,
+    SetTransactionState = 9,
+    AddUserRange = 10,
+    ResetUserRange = 11,
+    DbDisconnect = 12,
+    AddUserLocate = 13,
+    ResetUserLocate = 14,
+    AddUserSort = 15,
+    ResetUserSort = 16,
+    DataViewToDataSource = 17,
+    DbDelete = 18,
+    ControlItemsRefresh = 19,
+    SQLExecute = 20
+}
+declare class DataviewCommand extends ClientOriginatedCommandTaskTag {
+    CommandType: DataViewCommandType;
+    TaskTag: string;
+    get CommandTypeAttribute(): string;
+    SerializeCommandData(): string;
+    get ShouldSerialize(): boolean;
+    constructor();
+}
+
+declare class AddUserRangeDataviewCommand extends DataviewCommand {
+    Range: UserRange;
+    constructor();
+}
+
+declare class AddUserLocateDataViewCommand extends AddUserRangeDataviewCommand {
+    constructor();
+}
+
+declare class AddUserSortDataViewCommand extends DataviewCommand {
+    Sort: Sort;
+    constructor();
+}
+
+declare class EventCommand extends ClientOriginatedCommandTaskTag implements IClientToServerCommandInfo {
+    TaskTag: string;
+    MagicEvent: number;
+    ClientRecId: number;
+    get CommandTypeAttribute(): string;
+    get EventDescription(): string;
+    get Task(): Task;
+    get ShouldSerialize(): boolean;
+    constructor(magicEvent: number);
+    SerializeCommandData(): string;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class BrowserEscEventCommand extends EventCommand implements IClientToServerCommandInfo {
+    CloseSubformOnly: boolean;
+    constructor();
+    SerializeCommandData(): string;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare abstract class QueryCommand extends ClientOriginatedCommand {
+    get CommandTypeAttribute(): string;
+    get ShouldSerializeRecords(): boolean;
+    SerializeCommandData(): string;
+    abstract SerializeQueryCommandData(): string;
+    constructor();
+}
+
+declare class CachedFileQueryCommand extends QueryCommand {
+    text: string;
+    constructor(text: string);
+    /**
+     * Serializes the query command data
+     */
+    SerializeQueryCommandData(): string;
+}
+
+declare class ClientOriginatedCommandSerializer {
+    static Serialize(cmd: ClientOriginatedCommand, currMGData: MGData): string;
+    static SerializeRecords(currMGData: MGData): string;
+}
+
+declare class ColumnSortEventCommand extends EventCommand implements IClientToServerCommandInfo {
+    FldId: number;
+    DitIdx: number;
+    Direction: number;
+    constructor();
+    SerializeCommandData(): string;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare enum RollbackEventCommand_RollbackType {
+    NONE = " ",
+    CANCEL = "C",
+    ROLLBACK = "R"
+}
+declare class RollbackEventCommand extends EventCommand implements IClientToServerCommandInfo {
+    Rollback: RollbackEventCommand_RollbackType;
+    constructor();
+    SerializeCommandData(): string;
+    private getRollbackTypeString;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class SetTransactionStateDataviewCommand extends DataviewCommand {
+    TransactionIsOpen: boolean;
+    constructor();
+}
+
+declare class RefreshEventCommand extends EventCommand implements IClientToServerCommandInfo {
+    RefreshMode: ViewRefreshMode;
+    KeepUserSort: boolean;
+    CurrentRecordRow: number;
+    IsInternalRefresh: boolean;
+    constructor(magicEvent: number);
+    SerializeCommandData(): string;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class FetchDataControlValuesEventCommand extends EventCommand implements IClientToServerCommandInfo {
+    ControlName: string;
+    FilterData: string;
+    constructor();
+    SerializeCommandData(): string;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class SubformRefreshEventCommand extends RefreshEventCommand implements IClientToServerCommandInfo {
+    SubformTaskTag: string;
+    ExplicitSubformRefresh: boolean;
+    constructor();
+    SerializeCommandData(): string;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class IndexChangeEventCommand extends EventCommand implements IClientToServerCommandInfo {
+    KeyIndex: number;
+    constructor();
+    SerializeCommandData(): string;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class RefreshScreenEventCommand extends EventCommand implements IClientToServerCommandInfo {
+    TopRecIdx: number;
+    RefreshMode: ViewRefreshMode;
+    constructor();
+    SerializeCommandData(): string;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class SubformOpenEventCommand extends EventCommand implements IClientToServerCommandInfo {
+    DitIdx: number;
+    constructor();
+    SerializeCommandData(): string;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class ComputeEventCommand extends EventCommand implements IClientToServerCommandInfo {
+    Subforms: boolean;
+    constructor();
+    SerializeCommandData(): string;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class NonReversibleExitEventCommand extends EventCommand implements IClientToServerCommandInfo {
+    CloseSubformOnly: boolean;
+    constructor();
+    SerializeCommandData(): string;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class RecomputeCommand extends ClientOriginatedCommandTaskTag implements IClientToServerCommandInfo {
+    TaskTag: string;
+    FldId: number;
+    IgnoreSubformRecompute: boolean;
+    get CommandTypeAttribute(): string;
+    SerializeCommandData(): string;
+    constructor();
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class TransactionCommand extends ClientOriginatedCommandTaskTag implements IClientToServerCommandInfo {
+    TaskTag: string;
+    Oper: string;
+    ReversibleExit: boolean;
+    Level: string;
+    UpdatedFields: string;
+    get CommandTypeAttribute(): string;
+    SerializeCommandData(): string;
+    constructor();
+    getFieldsInfo(): string;
+    getCommandInfo(): string;
+}
+
+declare class UnloadCommand extends ClientOriginatedCommand implements IClientToServerCommandInfo {
+    get CommandTypeAttribute(): string;
+    constructor();
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class ExecOperCommand extends ClientOriginatedCommandTaskTag implements IClientToServerCommandInfo {
+    ExecutionStack: ExecutionStack;
+    TaskTag: string;
+    HandlerId: string;
+    OperIdx: number;
+    DitIdx: number;
+    Val: string;
+    MprgCreator: Task;
+    Operation: Operation;
+    CheckOnly: boolean;
+    get CommandTypeAttribute(): string;
+    constructor();
+    SerializeCommandData(): string;
+    SetExecutionStack(execStack: ExecutionStack): void;
+    SerializeDataAfterCommand(): string;
+    getCommandInfo(): string;
+    getTask(): Task;
+    getFieldsInfo(): string;
+}
+
+declare class EvaluateCommand extends ClientOriginatedCommandTaskTag implements IClientToServerCommandInfo {
+    TaskTag: string;
+    ExpIdx: number;
+    ExpType: StorageAttribute;
+    LengthExpVal: number;
+    MprgCreator: Task;
+    get CommandTypeAttribute(): string;
+    constructor();
+    SerializeCommandData(): string;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class GlobalParamsQueryCommand extends QueryCommand {
+    SerializeQueryCommandData(): string;
+    constructor();
+}
+
+declare class IniputForceWriteCommand extends ClientOriginatedCommand implements IClientToServerCommandInfo {
+    Text: string;
+    get CommandTypeAttribute(): string;
+    get ShouldSerializeRecords(): boolean;
+    SerializeCommandData(): string;
+    constructor();
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class ContextTerminationEventCommand extends EventCommand implements IClientToServerCommandInfo {
+    constructor();
+    SerializeCommandData(): string;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class ContextTimeoutResetCommand extends EventCommand implements IClientToServerCommandInfo {
+    constructor();
+    SerializeCommandData(): string;
+    getCommandInfo(): string;
+    getFieldsInfo(): string;
+}
+
+declare class ControlItemsRefreshCommand extends DataviewCommand {
+    Control: MgControlBase;
+    FilterData: string;
+    constructor();
+}
+
+declare class CommandFactory {
+    static CreateEventCommand(taskTag: string, magicEvent: number): EventCommand;
+    static CreateRollbackEventCommand(taskTag: string, rollbackType: RollbackEventCommand_RollbackType): RollbackEventCommand;
+    static CreateDataViewCommand(taskId: string, commandType: DataViewCommandType): DataviewCommand;
+    static CreateControlItemsRefreshCommand(taskId: string, control: MgControlBase, filterData: string): ControlItemsRefreshCommand;
+    static CreateAddUserRangeDataviewCommand(taskId: string, userRange: UserRange): AddUserRangeDataviewCommand;
+    static CreateAddUserSortDataviewCommand(taskId: string, sort: Sort): AddUserSortDataViewCommand;
+    static CreateAddUserLocateDataviewCommand(taskId: string, userRange: UserRange): AddUserLocateDataViewCommand;
+    static CreateSetTransactionStateDataviewCommand(taskId: string, transactionIsOpened: boolean): SetTransactionStateDataviewCommand;
+    static CreateInternalRefreshCommand(taskId: string, magicEvent: number, currentRecId: number, currentRow: number): RefreshEventCommand;
+    static CreateRealRefreshCommand(taskId: string, magicEvent: number, currentRow: number, argList: ArgumentsList, currentRecId: number): Promise<RefreshEventCommand>;
+    static CreatecFetchDataControlValuesCommand(taskTag: string, controlName: string, filterData: string): FetchDataControlValuesEventCommand;
+    static CreateSubformRefreshCommand(taskTag: string, subformTaskTag: string, explicitSubformRefresh: boolean): SubformRefreshEventCommand;
+    static CreateSubformOpenCommand(taskTag: string, subformDitIdx: number): SubformOpenEventCommand;
+    static CreateScreenRefreshCommand(taskTag: string, topRecIdx: number, clientRecId: number): RefreshScreenEventCommand;
+    static CreateColumnSortCommand(taskTag: string, direction: number, ditIdx: number, fieldId: number, recId: number): ColumnSortEventCommand;
+    static CreateIndexChangeCommand(taskTag: string, recId: number, argList: ArgumentsList): Promise<IndexChangeEventCommand>;
+    static CreateBrowserEscEventCommand(taskTag: string, closeSubformOnly: boolean): BrowserEscEventCommand;
+    static CreateComputeEventCommand(taskTag: string, subforms: boolean, clientRecId: number): ComputeEventCommand;
+    static CreateContextTerminationEventCommand(taskTag: string): ContextTerminationEventCommand;
+    static CreateContextTimeoutResetEventCommand(): ContextTimeoutResetCommand;
+    static CreateNonReversibleExitCommand(taskTag: string, closeSubformOnly: boolean): NonReversibleExitEventCommand;
+    static CreateRecomputeCommand(taskTag: string, fieldId: number, ignoreSubformRecompute: boolean): RecomputeCommand;
+    static CreateTransactionCommand(oper: string, taskTag: string, cReversibleExit: boolean, level: string, updatedFields: string): TransactionCommand;
+    static CreateUnloadCommand(): UnloadCommand;
+    static CreateExecOperCommand(taskTag: string, handlerId: string, operIdx: number, ditIdx: number, value: string): ExecOperCommand;
+    static CreateSelectProgramCommand(taskTag: string, handlerId: string, operIdx: number, ditIdx: number, value: string): ExecOperCommand;
+    static CreateEvaluateCommand(taskTag: string, expType: StorageAttribute, expIdx: number, expValLen: number, mprgCreator: Task): EvaluateCommand;
+    static CreateQueryGlobalParamsCommand(): GlobalParamsQueryCommand;
+    static CreateIniputForceWriteCommand(param: string): IniputForceWriteCommand;
+    static CreateQueryCachedFileCommand(cachedFileName: string): CachedFileQueryCommand;
+}
+
+declare class CommandSerializationHelper {
+    private message;
+    GetString(): string;
+    SerializeTaskTag(taskTag: string): void;
+    SerializeFldId(fldId: number): void;
+    SerializeDitIdx(ditIdx: number): void;
+    SerializeRouteParams(operation: Operation): void;
+    SerializeRefreshMode(refreshMode: ViewRefreshMode): void;
+    SerializeMagicEvent(magicEvent: number): void;
+    SerializeCloseSubformOnly(closeSubformOnly: boolean): void;
+    SerializeKeyIndex(keyIndex: number): void;
+    SerializeAttribute(attribute: string, value: string): void;
+    SerializeAttribute(attribute: string, value: number): void;
+    SerializeAttribute(attribute: string, value: string): void;
+    private SerializeAttribute_0;
+    private SerializeAttribute_1;
+    private SerializeAttribute_2;
+}
+
+declare class DataViewOutputCommand extends DataviewCommand {
+    Generation: number;
+    TaskVarNames: string;
+    DestinationDataSourceNumber: number;
+    DestinationDataSourceName: string;
+    DestinationColumns: string;
+    constructor(OutputCommandType: DataViewCommandType);
+}
+
+declare class SelectProgramCommand extends ExecOperCommand {
+    getCommandInfo(): string;
+    getTask(): Task;
+    getFieldsInfo(): string;
+}
+
+declare class WriteMessageToServerLogCommand extends EventCommand {
+    ErrorMessage: string;
+    constructor();
+    SerializeCommandData(): string;
+}
+
+declare abstract class ClientTargetedCommandBase extends IClientTargetedCommand implements IClientCommand {
+    get IsBlocking(): boolean;
+    Frame: number;
+    TaskTag: string;
+    Obj: string;
+    get ShouldExecute(): boolean;
+    Execute(res: IResultValue): Promise<void>;
+    HandleAttribute(attribute: string, value: string): void;
+}
+
+declare class AbortCommand extends ClientTargetedCommandBase {
+    private _transOwner;
+    constructor();
+    constructor(taskTag: string);
+    private constructor_0;
+    private constructor_1;
+    Execute(res: IResultValue): Promise<void>;
+    HandleAttribute(attribute: string, value: string): void;
+}
+
+declare class AddRangeCommand extends ClientTargetedCommandBase {
+    UserRange: UserRange;
+    constructor();
+    get ShouldExecute(): boolean;
+    Execute(res: IResultValue): Promise<void>;
+    HandleAttribute(attribute: string, value: string): void;
+}
+
+declare class AddLocateCommand extends AddRangeCommand {
+    Execute(res: IResultValue): Promise<void>;
+    constructor();
+}
+
+declare class AddSortCommand extends ClientTargetedCommandBase {
+    UserSort: Sort;
+    constructor();
+    Execute(res: IResultValue): Promise<void>;
+    HandleAttribute(attribute: string, value: string): void;
+}
+
+declare class ClientRefreshCommand extends ClientTargetedCommandBase {
+    static ClientIsInRollbackCommand: boolean;
+    constructor();
+    Execute(res: IResultValue): Promise<void>;
+}
+
+declare class VerifyCommand extends ClientTargetedCommandBase {
+    private _callingTaskTag;
+    _title: string;
+    private _errLogAppend;
+    private _text;
+    private _display;
+    private _mode;
+    constructor();
+    Execute(res: IResultValue): Promise<void>;
+    PrepareMessageBoxForDisplay(task: Task, mlsTransTitle: RefParam<string>, style: RefParam<number>): void;
+    ProcessMessageBoxResponse(task: Task, returnValue: number): void;
+    HandleAttribute(attribute: string, value: string): void;
+}
+
+declare class EnhancedVerifyCommand extends VerifyCommand {
+    private _buttonsID;
+    private _image;
+    private _returnValStr;
+    private _returnVal;
+    ProcessMessageBoxResponse(task: Task, returnValue: number): Promise<void>;
+    PrepareMessageBoxForDisplay(task: Task, mlsTransTitle: RefParam<string>, style: RefParam<number>): void;
+    HandleAttribute(attribute: string, value: string): void;
+    constructor();
+}
+
+declare class OpenURLCommand extends ClientTargetedCommandBase {
+    private _callingTaskTag;
+    private _pathParentTaskTag;
+    private _subformCtrlName;
+    private _ditIdx;
+    private _isModal;
+    private _transOwner;
+    private _newId;
+    private _forceModal;
+    private _key;
+    private _varList;
+    private _isRoute;
+    NewTaskXML: string;
+    static createNewCommandsTable: any;
+    constructor();
+    get IsBlocking(): boolean;
+    Execute(res: IResultValue): Promise<void>;
+    HandleAttribute(attribute: string, value: string): void;
+}
+
+declare class ResetLocateCommand extends ClientTargetedCommandBase {
+    constructor();
+    Execute(res: IResultValue): Promise<void>;
+}
+
+declare class ResetRangeCommand extends ClientTargetedCommandBase {
+    constructor();
+    Execute(res: IResultValue): Promise<void>;
+}
+
+declare class ResetSortCommand extends ClientTargetedCommandBase {
+    constructor();
+    Execute(res: IResultValue): Promise<void>;
+}
+
+declare class ResultCommand extends ClientTargetedCommandBase {
+    private _isNull;
+    private _attr;
+    private _val;
+    Execute(res: IResultValue): Promise<void>;
+    HandleAttribute(attribute: string, value: string): void;
+    constructor();
+}
+
+declare class XMLBasedCommandBuilder {
+    private newTaskXML;
+    constructor();
+    fillData(parser: XmlParser): IClientCommand;
+    private initElements;
+    private CreateCommand;
+    private getTaskXML;
+    private getType;
+}
+
+interface IConnectionStateManager {
+    ConnectionEstablished(): void;
+    ConnectionDropped(): void;
+}
+
+interface ICommunicationsFailureHandler {
+    ShouldRetryLastRequest: boolean;
+    ShowCommunicationErrors: boolean;
+    CommunicationFailed(url: string, failureException: Error): void;
+}
+
+declare class InteractiveCommunicationsFailureHandler implements ICommunicationsFailureHandler {
+    ShouldRetryLastRequest: boolean;
+    get ShowCommunicationErrors(): boolean;
+    CommunicationFailed(url: string, ex: Error): Promise<void>;
+}
+
+declare class DataSourceIdKey {
+}
+
+interface IRecordsTable {
+    GetSize(): number;
+    GetRecByIdx(idx: number): Record;
+    RemoveAll(): void;
+    getRecIdx(id: number): number;
+}
+
+declare enum RecordOutOfDataViewException_ExceptionType {
+    TOP = 0,
+    BOTTOM = 1,
+    REC_SUFFIX_FAILED = 2,
+    NONE = 3
+}
+declare class RecordOutOfDataViewException extends ApplicationException {
+    constructor(type: RecordOutOfDataViewException_ExceptionType);
+}
+
+declare class RecordsTable implements IRecordsTable {
+    static REC_NOT_FOUND: number;
+    private _useLinkedList;
+    private _hashTab;
+    private _initialCurrRecId;
+    private _records;
+    private _serverCurrRec;
+    InsertedRecordsCount: number;
+    constructor(withLinkedList: boolean);
+    constructor(recordTable: RecordsTable);
+    fillData(dataview: DataView, insertAt: string, parser: XmlParser): string;
+    InsertRecord(insertAt: string, record: Record): void;
+    buildXML(message: StringBuilder, skipCurrRec: boolean, currRecId: number): void;
+    getRecord(id: number): Record;
+    getRecIdx(id: number): number;
+    getRecByIdx(idx: number): Record;
+    removeAll(): void;
+    getSize(): number;
+    getInitialCurrRecId(): number;
+    addRecord(rec: Record): void;
+    private addRec;
+    insertRecord(rec: Record, idx: number): void;
+    removeRecord(recIdx: number): void;
+    removeRecord(rec: Record): void;
+    private removeRecord_0;
+    private removeRecord_1;
+    replicate(): RecordsTable;
+    getServerCurrRec(): Record;
+    zeroServerCurrRec(): void;
+    GetSize(): number;
+    GetRecByIdx(idx: number): Record;
+    RemoveAll(): void;
+}
+
+declare class XMLBasedDcValuesBuilder extends DcValuesBuilderBase {
+    private dcv;
+    private parser;
+    set SerializedDCVals(value: string);
+    constructor();
+    Build(): DcValues;
+    private InitDCValues;
+    protected ParseValues(valueStr: string, dataType: StorageAttribute): string[];
+}
+
+declare class Environment implements IEnvironment {
+    private _environments;
+    private _contextInactivityTimeout;
+    private _clientContextInactivityTimeout;
+    private _contextInactivityWarningTime;
+    private _toolitipTimeout;
+    private _contextUnloadTimeout;
+    private _canReplaceDecimalSeparator;
+    private _codePage;
+    private _dateSeparator;
+    private _decimalSeparator;
+    private _thousandsSeparator;
+    private _timeSeparator;
+    private _guid;
+    private _imeAutoOff;
+    private _language;
+    private _localAs400Set;
+    private _localExtraGengo;
+    private _localFlags;
+    private _lowHigh;
+    private _owner;
+    private _debugMode;
+    private _significantNumSize;
+    private _specialAnsiExpression;
+    private _specialImmediatehandlerEnd;
+    private _specialShowStatusBarPanes;
+    private _specialRouteToRootProgOnContextRecreation;
+    private _specialCancelOnCreate;
+    private _system;
+    private _terminal;
+    private _forwardSlash;
+    private _dropUserFormats;
+    private _webclientReinitSession;
+    private _specialValNewPolicy;
+    static Instance: Environment;
+    get Language(): string;
+    IgnoreReplaceDecimalSeparator: boolean;
+    get SpecialRestoreMaximizedForm(): boolean;
+    set ForwardSlashUsage(value: string);
+    get ForwardSlashUsage(): string;
+    fillData(parser: XmlParser): void;
+    fillData(tokensVector: List<string>): void;
+    fillData_0(parser: XmlParser): void;
+    private fillData_1;
+    fillFromUrl(tagName: string, parser: XmlParser): Promise<void>;
+    private getEnvDet;
+    GetDateMode(compIdx: number): string;
+    GetThousands(): string;
+    GetDecimal(): string;
+    setDecimalSeparator(value: string): void;
+    setThousandsSeparator(value: string): void;
+    setDateSeparator(value: string): void;
+    setTimeSeparator(value: string): void;
+    GetDate(): string;
+    getIdleTime(compIdx: number): number;
+    getOwner(): string;
+    GetTime(): string;
+    GetCentury(compIdx: number): number;
+    allowUpdateInQueryMode(compIdx: number): boolean;
+    allowCreateInModifyMode(compIdx: number): boolean;
+    GetSignificantNumSize(): number;
+    setSignificantNumSize(newSize: number): void;
+    getCodePage(): number;
+    GetEncoding(): Encoding;
+    getSystem(): string;
+    GetDebugLevel(): number;
+    CanReplaceDecimalSeparator(): boolean;
+    getClientContextInactivityTimeout(): number;
+    getContextInactivityTimeout(): number;
+    getContextInactivityWarningTime(): number;
+    getContextUnloadTimeout(): number;
+    GetTooltipTimeout(): number;
+    getLowHigh(): boolean;
+    GetImeAutoOff(): boolean;
+    GetLocalAs400Set(): boolean;
+    getLocalExtraGengo(): string;
+    GetLocalFlag(f: string): boolean;
+    getSpecialImmediateHandlerEnd(): boolean;
+    getSpecialAnsiExpression(): boolean;
+    getSpecialShowStatusBarPanes(): boolean;
+    getTerminal(): number;
+    getWebClientReinitSession(): string;
+    setWebClientReinitSession(session: string): void;
+    getSpecialRouteToRootProgOnContextRecreation(): boolean;
+    GetGUID(): string;
+    getProjDir(compIdx: number): string;
+    GetSpecialLogInternalExceptions(): boolean;
+    setOwner(val: string): void;
+    setDateMode(compIdx: number, val: string): void;
+    setCentury(compIdx: number, val: number): void;
+    setIdleTime(compIdx: number, val: number): void;
+    setAllowUpdateInQueryMode(compIdx: number, val: boolean): void;
+    setAllowCreateInModifyMode(compIdx: number, val: boolean): void;
+    setContextInactivityTimeout(val: number): void;
+    setContextInactivityWarningTime(val: number): void;
+    setContextUnloadTimeout(val: number): void;
+    setTerminal(val: number): void;
+    GetDropUserFormats(): string;
+    GetSpecialValNewPolicy(): boolean;
+    GetSpecialCancelOnCreate(): boolean;
+}
+declare class EnvironmentDetails {
+    private _createInModifyMode;
+    private _updateInQueryMode;
+    CompIdx: number;
+    DateMode: string;
+    Century: number;
+    IdleTime: number;
+    set UpdateInQueryMode(value: boolean);
+    set CreateInModifyMode(value: boolean);
+    ProjDir: string;
+    constructor();
+    allowUpdateInQueryMode(): boolean;
+    allowCreateInModifyMode(): boolean;
+}
+
+declare class EnvParamsTable extends MirrorPrmMap<MirrorString> {
+    static Instance: EnvParamsTable;
+    private constructor();
+    get(s: string): string;
+    getln(section: string, number: number): string;
+    private getFromEnvironment;
+    private getProcessedValue;
+    set(s: string, updateIni: boolean): Promise<boolean>;
+    private isReservedLogicalName;
+    private getAllowedSeparators;
+    private checkSetInEnvironment;
+    translate(logicalName: string): string;
+    private log;
+    private log_trans;
+}
+
+declare class LanguageData implements ILanguageData {
+    private _constMessages;
+    private _constMessagesContent;
+    private _constMessagesUrl;
+    private _mlsContent;
+    private _mlsFileUrl;
+    private _mlsStrings;
+    static Instance: LanguageData;
+    private constructor();
+    fillData(parser: XmlParser): Promise<void>;
+    private initInnerObjects;
+    getConstMessage(msgId: string): string;
+    private InitConstMessagesTable;
+    private fillConstMessagesTable;
+    private FillConstMessagesFromJSON;
+    translate(fromString: string): string;
+    fillMlsMessagesTable(): Promise<void>;
+}
+
+declare class ActionManager implements IActionManager {
+    static actEnabled: number[];
+    private static actNavigation;
+    private _actCount;
+    private _actState;
+    private _numerator;
+    constructor();
+    enable(act: number, enable: boolean): void;
+    isEnabled(act: number): boolean;
+    getActCount(act: number): number;
+    enableList(act: number[], enable: boolean, onlyIfChanged: boolean): void;
+    enableNavigationActions(enable: boolean): void;
+}
+
+declare class EventHandlerPosition {
+    private static PHASE_CONTROL_SPECIFIC;
+    private static PHASE_CONTROL_NON_SPECIFIC;
+    private static PHASE_GLOBAL;
+    private static PHASE_GLOBAL_SPECIFIC;
+    private _handlerIdx;
+    private _handlersTab;
+    private _orgPrevTask;
+    private _orgTask;
+    private _phase;
+    private _prevTask;
+    private _rtEvt;
+    private _task;
+    constructor();
+    init(rtEvent: RunTimeEvent): void;
+    getNext(evt: RunTimeEvent): EventHandler;
+    getNext(): EventHandler;
+    private getNext_0;
+    private getNext_1;
+    private setNextHandlerIdx;
+    private goUpTaskChain;
+    private getParentOrCompMainPrg;
+}
+
+declare class EventsManager implements IEventsManager {
+    private static REAL_ONLY;
+    private static MAX_OPER;
+    private static userGrantedForContextActivity;
+    private _eventsQueue;
+    private _execStack;
+    private _rtEvents;
+    private _serverExecStack;
+    private _allowEvents;
+    private _compMainPrgTab;
+    private _currCtrl;
+    private _currField;
+    private _currKbdItem;
+    private _endOfWork;
+    private _eventScope;
+    private _forceExit;
+    private _forceExitTask;
+    private _ignoreUnknownAbort;
+    private _initialized;
+    private _isHandlingForceExit;
+    private _isNonReversibleExit;
+    private _isInRecordFlushEvent;
+    private static clientInactivityTimerON;
+    private static clientContextInactivityTimerAborted;
+    private lastSavedRouteEvent;
+    private _stopExecution;
+    private _processingTopMostEndTask;
+    private _stopExecutionCtrl;
+    guiPendingEvent: any;
+    readonly KBI_DOWN: KeyboardItem;
+    readonly KBI_UP: KeyboardItem;
+    readonly confirmationDialogMsg: string;
+    readonly confirmationDialogTitle: string;
+    static Instance: EventsManager;
+    private _lastFailedFocusedControl;
+    private isSpinnerShown;
+    private isInViewRefresh;
+    SpinnerStopped: Subject$1<number>;
+    static clientBusyTimeStart: number;
+    private constructor();
+    getPendingGuiEvent(): any;
+    setPendingGuiEvent(guiEvent: any): void;
+    addToTail(rtEvt: RunTimeEvent): void;
+    AddKeyboardEvent(mgForm: MgFormBase, mgControl: MgControlBase, modifier: Modifiers, keyCode: number, start: number, end: number, text: string, isActChar: boolean, suggestedValue: string, code: number): void;
+    checkParkability(): Promise<void>;
+    HandleParkabilityOnRowChange(itask: ITask): Promise<void>;
+    HandleNonParkableControls(itask: ITask): Promise<void>;
+    handleEvent(rtEvt: RunTimeEvent, returnedFromServer: boolean): Promise<void>;
+    private simulateSelection;
+    handleInternalEventWithTask(itask: ITask, eventCode: number): Promise<void>;
+    handleInternalEventWithTaskAndSubformRefresh(itask: ITask, eventCode: number, subformRefresh: boolean): Promise<void>;
+    handleInternalEventWithMgControlBase(ctrl: MgControlBase, eventCode: number): Promise<void>;
+    GetStopExecutionFlag(): boolean;
+    private getStopExecutionCtrl;
+    Init(): void;
+    addInternalEventWithItaskAndCode(itask: ITask, code: number): void;
+    addInternalEventWithCtrlAndCode(ctrl: MgControlBase, code: number): void;
+    addInternalEventWithCtrlAndDisplayLineAndCode(ctrl: MgControlBase, DisplayLine: number, code: number): void;
+    addInternalEventWithCtrlAndCodeAndPriority(ctrl: MgControlBase, code: number, priority: Priority): void;
+    addGuiTriggeredEventWithTaskAndCodeAndOnMultiMark(itask: ITask, code: number): void;
+    addGuiTriggeredEventWithCtrlAndCodeAndLineAndModifier(ctrl: MgControlBase, code: number, line: number): void;
+    addGuiTriggeredEventWithTaskAndCodeAndLine(task: Task, code: number, line: number): void;
+    AddColumnClickEvent(columnCtrl: MgControlBase, direction: number, columnHeader: string): void;
+    AddRouteEvent(task: ITask, code: number, routerpath: string, routerOutletName: string, routeParams: List<any>): void;
+    AddRouterClosedEvent(task: Task): void;
+    AddLastSavedRouteEvent(srcTask: Task, args: ArgumentsList): void;
+    AddExternalValueEvent(ctrl: MgControl, value: any, refreshDisplay: boolean): void;
+    addGuiTriggeredEventWithCtrlAndCodeAndLine(ctrl: MgControlBase, code: number, line: number): void;
+    addGuiTriggeredEventWithCtrlAndLineAndCodeAndIsProductClick(ctrl: MgControlBase, code: number, line: number, isProduceClick: boolean): void;
+    addGuiTriggeredEventWithCtrlAndCodeAndList(ctrl: MgControlBase, code: number, list: List<MgControlBase>): void;
+    addGuiTriggeredEventWithTaskAndCode(task: ITask, code: number): void;
+    addGuiTriggeredEventTaskAndCodeAndRaisedBy(task: ITask, code: number): void;
+    private getEvent;
+    getForceExit(): ForceExit;
+    private setForceExit;
+    private getForceExitTask;
+    private setForceExitTask;
+    /**
+     * returns true if the EventsManager is currently handling a user event with
+     * Force Exit = 'Pre-Record Update'
+     */
+    isForceExitPreRecordUpdate(task: TaskBase): boolean;
+    ExecuteClientContextInactivityTimer(): Promise<void>;
+    CheckAndShowSpinner(show: boolean): Promise<void>;
+    EventsLoop(mgData: MGData): Promise<void>;
+    NonInteractiveEventsLoop(mgData: MGData, taskBase: TaskBase): Promise<void>;
+    handleEvents(baseMgData: MGData, eventsToHandleCnt: number): Promise<void>;
+    handleEvents(handlersTab: HandlersTable, rtEvt: RunTimeEvent): Promise<void>;
+    private handleEvents_0;
+    private handleStopExecution;
+    private handleForceExitBefore;
+    private handleForceExitAfter;
+    private handleEvents_1;
+    private handleKeyDown;
+    private handleSelection;
+    private handleMouseUp;
+    checkAndSaveRouteEventIfCtxRemovedFromSrvr(aRtEvt: any): void;
+    private handleFocus;
+    private HandleSubformModality;
+    private handleFocusOnNonMagicControl;
+    private HandleZoomIfNeeded;
+    private canGoToControl;
+    private handleTimer;
+    private handleContextInactivityAlert;
+    handleExpressionHandlers(): Promise<void>;
+    private handleResize;
+    private handleRowDataCurPage;
+    private handleTransferDataToGui;
+    private fetchRecordsAheadFromServer;
+    private handleEnableEvents;
+    private handleCtrlPrefix;
+    private commonHandlerBefore;
+    protected selectProg(ctrl: MgControl): Promise<boolean>;
+    private executeControlVerification;
+    private onActSelection;
+    private onSubformClose;
+    performSubformClose(subformCtrl: MgControl): Promise<void>;
+    private createEventArguments;
+    DoTaskLevelRecordSuffix(task: TaskBase, refDoSuffix: RefParam<boolean>): Promise<boolean>;
+    DoTaskLevelRecordPrefix(task: TaskBase): Promise<void>;
+    private commonHandler;
+    private HandleActEnterRowEditing;
+    private HandleStopRowEditing;
+    private OpenSubform;
+    private static HandleRollbackAction;
+    private HandleActCancel;
+    private static HandleCancelEdit;
+    private HandleActionDelline;
+    private handleRefreshEvents;
+    private gotoCreateMode;
+    private commonHandlerAfter;
+    handleNonReversibleEvent(task: TaskBase, eventCode: number): Promise<void>;
+    handleInternalEventWithTaskAndEventSubtype(task: TaskBase, eventCode: number, eventSubType: EventSubType): Promise<void>;
+    private handleInternalEventWithMgControl;
+    getCurrField(): Field;
+    getCurrCtrl(): MgControl;
+    getCurrTask(): Task;
+    setStopExecution(stop: boolean): void;
+    setStopExecution(stop: boolean, clearEventsOnStopExecution: ClearEventsOnStopExecution): void;
+    private setStopExecution_0;
+    private setStopExecution_1;
+    setStopExecutionCtrl(ctrl: MgControl): void;
+    private delCurrRec;
+    private updateConfirmed;
+    setCompMainPrgTab(compMainPrgTable: CompMainPrgTable): void;
+    setEndOfWork(endOfWork_: boolean): void;
+    getEndOfWork(): boolean;
+    getCompMainPrgTab(): CompMainPrgTable;
+    inNonReversibleExit(): boolean;
+    pushRtEvent(rtEvt: RunTimeEvent): void;
+    popRtEvent(): RunTimeEvent;
+    storeLastSavedRouteEventOnLocalStorage(): void;
+    restoreLastSavedRouteEventFromLocalStorage(): void;
+    getLastSavedRouteEvent(): RunTimeEvent;
+    setLastSavedRouteEvent(rtEvt: RunTimeEvent): void;
+    getLastRtEvent(): RunTimeEvent;
+    setIgnoreUnknownAbort(val: boolean): void;
+    ignoreUnknownAbort(): boolean;
+    failTaskOverlay(taskId: string, mgd: MGData): Promise<void>;
+    isEventScopeTrans(): boolean;
+    setEventScopeTrans(): void;
+    clearEventScope(): void;
+    GetEventTime(): number;
+    getMatchingAction(kbItm: KeyboardItem): number;
+    getExecStack(): ExecutionStack;
+    pushExecStack(taskId: string, handlerId: string, operIdx: number): void;
+    popExecStack(): ExecutionStackEntry;
+    pushNewExecStacks(): void;
+    popNewExecStacks(): void;
+    pushServerExecStack(taskId: string, handlerId: string, operIdx: number): void;
+    clearServerExecStack(): void;
+    reverseServerExecStack(): void;
+    getNextOperIdx(oper: Operation, clearWhenFound: boolean): number;
+    setProcessingTopMostEndTask(inProcessingTopMostEndTask: boolean): void;
+    getProcessingTopMostEndTask(): boolean;
+    setAllowEvents(AllowEvents: EventsAllowedType): void;
+    setNonInteractiveAllowEvents(AllowEvents: boolean): void;
+    getAllowEvents(): EventsAllowedType;
+    NoEventsAllowed(): boolean;
+    private handleCtrlModify;
+    private ActAllowed;
+    private commitRecord;
+    incLocateTimerCB(taskObj: any): void;
+    private static doSyncForSubformParent;
+    ProcessAbortingError(ex: ApplicationException): Promise<void>;
+    processHTMLContent(htmlContent: string): void;
+    ShowErrorInMessageBox(ex: ApplicationException): boolean;
+    getIsInViewRefresh(): boolean;
+    setIsInViewRefresh(inViewRefresh: boolean): void;
+}
+
+declare class ExpDesc {
+    Attr_: string;
+    Prec_: number;
+    ArgCount_: number;
+    ArgEvalCount_: number;
+    ArgAttr_: string;
+    RtfAsAlpha_: boolean;
+    constructor(Attr: string, Prec: number, ArgCount: number, ArgEvalCount: number, ArgAttr: string, RtfAsAlpha: boolean);
+}
+declare class ExpressionDict {
+    static expDesc: ExpDesc[];
+}
+
+declare class ExpressionEvaluator extends GuiExpressionEvaluator {
+    private static ASTERISK_CHR;
+    private static QUESTION_CHR;
+    static PARENT_LEN: number;
+    static SHORT_OBJECT_LEN: number;
+    static LONG_OBJECT_LEN: number;
+    private static MD5_ALGO_NUM;
+    private static SHA1_ALGO_NUM;
+    private static SHA2_ALGO_NUM;
+    private static _recursiveExpCalcCount;
+    private _charsToTrim;
+    private _expressionLocalJpn;
+    static ErrorToBeWrittenInServerLog: string;
+    constructor();
+    private getExpBasicValue;
+    static isBasicItem(opCode: number): boolean;
+    private static isVarArgList;
+    private execOperation;
+    private eval_op_ClientSessionSet;
+    private execExpression;
+    private DiscardCndRangeExpression;
+    static val_cmp_any(val1: ExpVal, val2: ExpVal): number;
+    static eval(exp: Int8Array, expectedType: StorageAttribute, task: TaskBase): Promise<ExpVal>;
+    static DiscardCndRangeResult(exp: Int8Array, task: TaskBase): Promise<boolean>;
+    private static set_a_pic;
+    private eval_op_range;
+    private eval_op_rep_1;
+    private static val_s_cpy;
+    private val_cpy;
+    private eval_op_ins;
+    private eval_op_del;
+    private eval_op_flip;
+    private eval_op_upper;
+    private eval_op_lower;
+    private eval_op_crc;
+    private static eval_crc_16;
+    private static LO_CHAR;
+    private static HI_CHAR;
+    static MK_SHRT(c1: number, c2: number): number;
+    static MK_LONG(c1: number, c2: number, c3: number, c4: number): number;
+    private eval_op_chkdgt;
+    private a_2_long;
+    private eval_op_soundx;
+    private static setAt;
+    private eval_op_hstr;
+    private static int_2_hex;
+    private static lib_a_fill;
+    private eval_op_hval;
+    private hex_2_long;
+    private eval_op_chr;
+    private eval_op_asc;
+    private eval_op_mstr;
+    private eval_op_mval;
+    private eval_op_dstr;
+    private eval_op_tstr;
+    private eval_op_dval;
+    private eval_op_tval;
+    private eval_op_day;
+    eval_op_month(resVal: ExpVal, val1: ExpVal): void;
+    private eval_op_year;
+    private eval_op_dow;
+    private eval_op_second;
+    private eval_op_minute;
+    private eval_op_hour;
+    eval_op_date_brk(resVal: ExpVal, val1: NUM_TYPE, typ: number): void;
+    private eval_op_time_brk;
+    private eval_op_addDateTime;
+    private eval_op_difdt;
+    private eval_op_ndow;
+    private eval_op_nmonth;
+    mul_add(num: NUM_TYPE, mul: number, add: number): NUM_TYPE;
+    private eval_op_cdow;
+    private eval_op_cmonth;
+    eval_op_date_str(resVal: ExpVal, val1: NUM_TYPE, format: string, displayConvertor: DisplayConvertor): void;
+    private eval_op_delay;
+    private eval_op_idle;
+    private eval_op_adddate;
+    private eval_op_addtime;
+    private eval_op_bom;
+    private eval_op_boy;
+    private eval_op_eom;
+    private eval_op_eoy;
+    private eval_op_strtok;
+    private eval_op_dbround;
+    private eval_op_varpic;
+    private eval_op_varattr;
+    private exp_null_val_get;
+    private exp_get_var;
+    private exp_get_var_0;
+    private eval_op_varmod;
+    private eval_op_varinp;
+    private eval_op_varname;
+    private eval_op_VarDisplayName;
+    private eval_op_controlItemRefresh;
+    private eval_op_VarControlID;
+    private eval_op_ControlItemsList;
+    private eval_op_ControlDisplayList;
+    private eval_op_viewmod;
+    private eval_op_level;
+    private eval_op_counter;
+    eval_op_emptyDataview(resVal: ExpVal, val1: ExpVal): void;
+    private eval_op_mainlevel;
+    private eval_op_maindisplay;
+    private eval_op_IsFirstRecordCycle;
+    private exp_is_default;
+    private eval_op_IsLoggedIn;
+    private eval_op_appname;
+    private eval_op_prog;
+    private eval_op_this;
+    private eval_op_stat;
+    private eval_op_subformExecMode;
+    private eval_op_varset;
+    private eval_op_like;
+    private static cutArray;
+    private eval_op_repstr;
+    private static arrToStr;
+    private static arrToStr_0;
+    private static arrToStr_1;
+    private static op_like_cmp;
+    private static op_like_map;
+    private exp_get_var_1;
+    private exp_get_indx;
+    getField(itm: number): Field;
+    private GetFieldOfContextTask;
+    private static trimStr;
+    static mgValsEqual(aVal: string, aIsNull: boolean, aDataType: StorageAttribute, bVal: string, bIsNull: boolean, bDataType: StorageAttribute): boolean;
+    private eval_op_translate;
+    private eval_op_astr;
+    private static eval_op_vecCellAttr;
+    private eval_op_vecGet;
+    private eval_op_vecSize;
+    private eval_op_vecSet;
+    private eval_op_strTokenCnt;
+    private eval_op_strTokenIdx;
+    private strTokenIndex;
+    private strTokenCount;
+    private eval_op_blobsize;
+    private eval_op_iscomponent;
+    private eval_op_ExecUserDefinedFunc;
+    private eval_op_publicName;
+    private eval_op_taskId;
+    private eval_op_dbviewsize;
+    private eval_op_dbviewrowidx;
+    private eval_op_MlsTrans;
+    private eval_op_StrBuild;
+    private eval_op_tsk_instance;
+    private eval_op_getParam;
+    private eval_op_setParam;
+    private eval_op_iniput;
+    private eval_op_iniget;
+    private eval_op_inigetln;
+    private eval_op_m;
+    private cst_code_trans_buf;
+    private eval_op_expcalc;
+    private eval_op_CndRange;
+    private eval_op_taskType;
+    private eval_op_terminal;
+    private eval_op_projectdir;
+    private static IsValidVector;
+    private static GetAttributeChar;
+    HandleControlGoto(ctrlTask: ITask, ctrl: MgControlBase, rowNo: number): boolean;
+    eval_op_set_title(resVal: ExpVal, title: ExpVal): void;
+    eval_op_is_row_editing(resVal: ExpVal, val1: ExpVal): void;
+    eval_op_control_select_program(expVal: ExpVal, resVal: ExpVal): Promise<void>;
+    eval_op_CallJS(task: ITask, methodName: string, expVal: ExpVal[], resVal: ExpVal): Promise<void>;
+    eval_op_set_cookie(cookieName: string, expVal: ExpVal[], resVal: ExpVal): any;
+    eval_op_get_cookie(cookieName: string, resVal: ExpVal): void;
+    eval_op_delete_cookie(cookieName: string, resVal: ExpVal): void;
+    eval_op_route_get(resVal: ExpVal): void;
+    private params2arguments;
+    private eval_op_Hash;
+    private toWordArray;
+}
+declare class NullValueException extends Exception {
+    private _attr;
+    constructor(attr: StorageAttribute);
+    getAttr(): StorageAttribute;
+}
+declare class ExpStrTracker {
+    private _expBytes;
+    private _lowHigh;
+    private _nullArithmetic;
+    private _isNull;
+    private _posIdx;
+    constructor(expBytes: Int8Array, nullArithmetic: boolean);
+    setNullResult(): void;
+    resetNullResult(): void;
+    isNull(): boolean;
+    get1ByteNumber(): number;
+    get2ByteNumber(): number;
+    get4ByteNumber(): number;
+    getString(len: number, updateIdx: boolean, isUnicode: boolean): string;
+    private skipOpFunctionPtr;
+    getOpCode(): number;
+    getVarIdx(): number;
+    getMagicNumber(len: number, updateIdx: boolean): NUM_TYPE;
+    skipOperator(): void;
+}
+
+declare class ExpressionLocalJpn {
+    static tableZen2Han: string[][];
+    static tableExceptZen2Han: string[][];
+    static tableHan2Zen: string[];
+    private _expressionEvaluator;
+    constructor(expressionEvaluator: ExpressionEvaluator);
+    eval_op_han(strVal: string): string;
+    eval_op_zens(strVal: string, mode: number): string;
+    eval_op_zimeread(): string;
+    eval_op_zkana(strVal: string, mode: number): string;
+    eval_op_jcdow(resVal: ExpVal, val1: NUM_TYPE, displayConvertor: DisplayConvertor): void;
+    eval_op_jmonth(resVal: ExpVal, val1: ExpVal): void;
+    eval_op_jndow(resVal: ExpVal, val1: ExpVal, displayConvertor: DisplayConvertor): void;
+    eval_op_jyear(resVal: ExpVal, val1: ExpVal): void;
+    eval_op_jgengo(resVal: ExpVal, val1: NUM_TYPE, val2: NUM_TYPE, displayConvertor: DisplayConvertor): void;
+}
+
+declare class HttpManager {
+    private static _instance;
+    static readonly DEFAULT_HTTP_COMMUNICATION_TIMEOUT: number;
+    static readonly DEFAULT_OFFLINE_HTTP_COMMUNICATION_TIMEOUT: number;
+    private _httpCommunicationTimeoutMS;
+    private _httpClientAsync;
+    private getHttpClient;
+    set HttpCommunicationTimeoutMS(value: number);
+    private static _nativeHttpClient;
+    static setNativeHttpClient(httpClient: HttpClient): void;
+    static GetInstance(): HttpManager;
+    private _isAbortingMagicEngine;
+    get IsAbortingMagicEngine(): boolean;
+    set IsAbortingMagicEngine(isAbortingMagicEngine: boolean);
+    private constructor();
+    private RegisterBasicDelegates;
+    GetHttpCommunicationTimeoutMS(): number;
+    SetCommunicationsFailureHandler(handler: ICommunicationsFailureHandler): void;
+    GetContent(requestedURL: string, requestContent: string | ArrayBuffer, requestContentType: string, useCache: boolean, isError: RefParam<boolean>): Promise<ArrayBuffer>;
+    private static CheckAndGetErrorResponse;
+    private static LogAccessToServer;
+    private static GetRequestContentLength;
+}
+
+declare enum RequestMethod {
+    Get = 0,
+    Post = 1,
+    Put = 2,
+    Delete = 3,
+    Options = 4,
+    Head = 5,
+    Patch = 6
+}
+declare abstract class HttpClientBase {
+    private _HTTPMaxURLLength;
+    CommunicationsFailureHandler: ICommunicationsFailureHandler;
+    constructor();
+    private DecideOnRequestMethod;
+    GetContent(requestURL: string, requestContent: any, requestContentType: string, useCache: boolean): Promise<ArrayBuffer>;
+    private ExecuteHttpRequest;
+    private LogRequestInfo;
+    private static HeadersToString;
+    abstract prepareRequest(): any;
+    abstract addHeaders(urlString: string, useCache: boolean, httpHeaders: HttpHeaders, clientID: string): HttpHeaders;
+    sendRequestToServer(httpMethod: RequestMethod, urlString: string, httpHeaders: HttpHeaders, requestContent: string, contentFromServer: RefParam<ArrayBuffer>): Promise<any>;
+    abstract logResponse(httpResponse: HttpResponse<ArrayBuffer>, clientID: string, urlString: string, contentFromServer: RefParam<any>, timeBeforeRequest: number): any;
+    abstract handleHttpErrorException(ex: any, urlString: string): any;
+    shouldRetry(httpCommunicationTimeoutMS: number, urlString: string, communicationsFailureHandler: ICommunicationsFailureHandler, ex: any, startTimeRef: RefParam<number>): Promise<boolean>;
+    abstract logAndThrowException(ex: any): any;
+    abstract logExecutionAttempts(executionAttempts: number): any;
+}
+
+declare class HttpClientAsync extends HttpClientBase {
+    private httpClient;
+    constructor(httpClient: HttpClient);
+    prepareRequest(): void;
+    addHeaders(urlString: string, useCache: boolean, httpHeaders: HttpHeaders, clientID: string): HttpHeaders;
+    sendRequestToServer(httpMethod: RequestMethod, urlString: string, httpHeaders: HttpHeaders, requestContent: string | ArrayBuffer, contentFromServer: RefParam<ArrayBuffer>): Promise<any>;
+    logResponse(httpResponse: HttpResponse<ArrayBuffer>, clientID: string, urlString: string, contentFromServer: RefParam<any>, timeBeforeRequest: number): void;
+    handleHttpErrorException(ex: any, urlString: string): void;
+    shouldRetry(httpCommunicationTimeoutMS: number, urlString: string, communicationsFailureHandler: ICommunicationsFailureHandler, ex: any, startTimeRef: RefParam<number>): Promise<boolean>;
+    logAndThrowException(ex: any): void;
+    logExecutionAttempts(executionAttempts: number): void;
+}
+
+declare class HttpClientEvents {
+    static GetHttpCommunicationTimeout_Event: () => number;
+    static GetExecutionProperty_Event: (propertyName: string) => string;
+    static GetGlobalUniqueSessionID_Event: () => string;
+    static ShouldDisplayGenericError_Event: () => boolean;
+    static GetRuntimeCtxID_Event: () => string;
+    static GetSessionCounter_Event: () => number;
+    static CheckAndSetSessionCounter_Event: (value: number) => void;
+    static ComputeAndLogRequestInfo_Event: (contentLength: number, roundTrip: number, isLoggingResponse: boolean) => void;
+    static GetHttpCommunicationTimeout(): number;
+    static GetExecutionProperty(propertyName: string): string;
+    static GetGlobalUniqueSessionID(): string;
+    static ShouldDisplayGenericError(): boolean;
+    static GetRuntimeCtxID(): string;
+    static GetSessionCounter(): number;
+    static CheckAndSetSessionCounter(value: number): void;
+    static ComputeAndLogRequestInfo(contentLength: number, roundTrip: number, isLoggingResponse: boolean): void;
+}
+
+declare class HttpClientSync extends HttpClientBase {
+    private httpRequest;
+    private headers;
+    constructor();
+    prepareRequest(): void;
+    addHeaders(urlString: string, useCache: boolean, httpHeaders: HttpHeaders, clientID: string): HttpHeaders;
+    sendRequestToServer(httpMethod: RequestMethod, urlString: string, httpHeaders: HttpHeaders, requestContent: string, contentFromServer: RefParam<ArrayBuffer>): Promise<any>;
+    logResponse(httpResponse: HttpResponse<ArrayBuffer>, clientID: string, urlString: string, contentFromServer: RefParam<any>, timeBeforeRequest: number): void;
+    handleHttpErrorException(ex: any, urlString: string): void;
+    shouldRetry(httpCommunicationTimeoutMS: number, urlString: string, communicationsFailureHandler: ICommunicationsFailureHandler, ex: any, startTimeRef: RefParam<number>): Promise<boolean>;
+    logAndThrowException(ex: any): void;
+    logExecutionAttempts(executionAttempts: number): void;
+}
+
+declare class HttpUtility {
+    static EncodingEnabled: boolean;
+    private static ASCIIGetString;
+    private static IntToHexCharCode;
+    private static IsSafe;
+    static UrlEncode(str: string, e: Encoding): string;
+    private static UrlEncodeToBytes;
+    private static UrlEncodeBytesToBytesInternal;
+}
+
+declare class RemoteDataViewCommandBase extends DataViewCommandBase {
+    Command: ClientOriginatedCommand;
+    protected Task: Task;
+    constructor(command: ClientOriginatedCommand);
+    Execute(): Promise<ReturnResultBase>;
+}
+
+declare class AddUserLocateRemoteDataViewCommand extends RemoteDataViewCommandBase {
+    private userRange;
+    constructor(command: AddUserLocateDataViewCommand);
+    Execute(): Promise<ReturnResultBase>;
+}
+
+declare class AddUserRangeRemoteDataViewCommand extends RemoteDataViewCommandBase {
+    private userRange;
+    constructor(command: AddUserRangeDataviewCommand);
+    Execute(): Promise<ReturnResultBase>;
+}
+
+declare class AddUserSortRemoteDataViewCommand extends RemoteDataViewCommandBase {
+    private sort;
+    constructor(command: AddUserSortDataViewCommand);
+    Execute(): Promise<ReturnResultBase>;
+}
+
+declare class RemoteCommandsProcessor extends CommandsProcessorBase {
+    static readonly RC_NO_CONTEXT_ID: string;
+    private static _instance;
+    static IsSessionReInitializing: boolean;
+    private static lastExceptionMessage;
+    private static InitialUrl;
+    private static readonly WEB_COMMUNICATION_PROTOCOL_VERSION;
+    private _lastRequestTime;
+    ServerUrl: string;
+    private static _shouldScrambleAndUnscrambleMessages;
+    SessionId: string;
+    DelayCommandExecution: boolean;
+    private _requestInfo;
+    serverFilesToClientFiles: Map<string, string>;
+    static GetInstance(): RemoteCommandsProcessor;
+    private constructor();
+    CheckAndSetSessionCounter(newSessionCounter: number): void;
+    ClearSessionCounter(): void;
+    private SetSessionCounter;
+    get GetLastRequestTime(): number;
+    ReStartSession(): Promise<void>;
+    StoreSessionReInitializingDataOnLocalStorage(): Promise<void>;
+    RestoreSessionReInitializingDataFromLocalStorage(key: string): string;
+    StartSession(): Promise<boolean>;
+    private PrepareAuthenticationUrl;
+    private ExecuteInitialRequest;
+    private GetTaskTree;
+    private UpdateRequestInfo;
+    private BuildXMLForMainProgramDataView;
+    Execute_1(sendingInstruction: CommandsProcessorBase_SendingInstruction, sessionStage: CommandsProcessorBase_SessionStage, res: IResultValue): Promise<void>;
+    private DispatchRequest;
+    DownloadFileFromServer(serverFileName: string): Promise<ArrayBuffer>;
+    fillCacheFilesMap(parser: XmlParser): void;
+    clearLocalStorage(): void;
+    private HandleErrorResponse;
+    private ArrayBufferToString;
+    private ExecuteRequest;
+    GetContentAsString(requestedURL: string, useCache: boolean, requestContent?: string, requestContentType?: string): Promise<string>;
+    GetContent(requestedURL: string, useCache: boolean, requestContent?: string, requestContentType?: string): Promise<ArrayBuffer>;
+    validateURL(url: string, sessionCounter: number, sessionId: string | null): string;
+    UploadFileToServer(fileContent: any, serverFileName: string): Promise<any>;
+    ClientActivated(): void;
+    private BuildUrlSuffix;
+    SendMonitorOnly(): Promise<void>;
+    private BuildMonitorMessage;
+    RegisterDelegates(): void;
+    ComputeAndLogRequestInfo(contentLength: number, roundTrip: number, isLoggingResponse: boolean): void;
+    static set ShouldScrambleAndUnscrambleMessages(value: boolean);
+    static get ShouldScrambleAndUnscrambleMessages(): boolean;
+    parseLogLevel(strLogLevel: string): Logger_LogLevels;
+    PrepareRequest(serializeTasks: boolean): Promise<string>;
+    ProcessResponse(response: string, currMgdID: number, openingTaskDetails: OpeningTaskDetails, res: IResultValue): Promise<void>;
+    ProcessRecovery(): Promise<void>;
+}
+
+declare class RemoteControlItemsRefreshCommand extends RemoteDataViewCommandBase {
+    private control;
+    filterData: string;
+    constructor(command: ControlItemsRefreshCommand);
+    Execute(): Promise<ReturnResultBase>;
+}
+
+declare class RemoteDataViewCommandFactory {
+    CreateDataViewCommand(command: ClientOriginatedCommand): RemoteDataViewCommandBase;
+    constructor();
+}
+
+declare class RemoteDataViewCommandUpdateNonModifiable extends RemoteDataViewCommandBase {
+    private get execOperCommand();
+    constructor(command: ExecOperCommand);
+    Execute(): Promise<ReturnResultBase>;
+}
+
+declare class DummyDataViewCommand extends RemoteDataViewCommandBase {
+    constructor(command: ClientOriginatedCommand);
+    Execute(): Promise<ReturnResultBase>;
+}
+
+declare class ResetUserLocateRemoteDataviewCommand extends RemoteDataViewCommandBase {
+    constructor(command: ClientOriginatedCommand);
+    Execute(): Promise<ReturnResultBase>;
+}
+
+declare class ResetUserRangeRemoteDataviewCommand extends RemoteDataViewCommandBase {
+    constructor(command: ClientOriginatedCommand);
+    Execute(): Promise<ReturnResultBase>;
+}
+
+declare class ResetUserSortRemoteDataviewCommand extends RemoteDataViewCommandBase {
+    constructor(command: ClientOriginatedCommand);
+    Execute(): Promise<ReturnResultBase>;
+}
+
+declare class ServerError extends ApplicationException {
+    static INF_NO_RESULT: number;
+    static ERR_CTX_NOT_FOUND: number;
+    static ERR_AUTHENTICATION: number;
+    static ERR_ACCESS_DENIED: number;
+    static ERR_WEBCLIENT_PROGRAM_RELOADED: number;
+    static ERR_EXECUTED_PROGRAM_CHANGED: number;
+    static ERR_THREAD_ABORTED: number;
+    private _code;
+    constructor(msg: string);
+    constructor(msg: string, code: number);
+    constructor(msg: string, innerException: Exception);
+    GetCode(): number;
+    GetMessage(): string;
+}
+
+declare class SetTransactionStateRemoteDataViewCommand extends RemoteDataViewCommandBase {
+    private get dataviewCommand();
+    constructor(command: SetTransactionStateDataviewCommand);
+    Execute(): Promise<ReturnResultBase>;
+}
+
+declare class DataviewHeaderFactory {
+    CreateDataviewHeaders(task: Task): DataviewHeaderBase;
+}
+
+declare class DataviewHeadersSaxHandler {
+    private _dataviewHeaders;
+    private _task;
+    private _dataviewHeadersFactory;
+    constructor(task: Task, dataviewHeaders: Hashtable<number, DataviewHeaderBase>, xmlData: string);
+    private FillFromJSON;
+}
+
+interface IDataSourceViewDefinition {
+    RecordsOrder: Order;
+    CanInsert: boolean;
+    CanDelete: boolean;
+}
+
+interface IDataviewHeader extends IDataSourceViewDefinition {
+    Id: number;
+    IsMainSource: boolean;
+    Mode: LnkMode;
+    LinkStartAfterField: number;
+    LinkEvaluateCondition: LnkEval_Cond;
+    EvaluateLinkCondition(): boolean;
+}
+
+declare class MGDataCollection implements IMGDataCollection {
+    private static _instance;
+    private _mgDataTab;
+    private _iteratorMgdIdx;
+    private _iteratorTaskIdx;
+    currMgdID: number;
+    StartupMgData: MGData;
+    private _lastRouteSentToServer;
+    constructor();
+    GetTaskByID(id: string): ITask;
+    static get Instance(): MGDataCollection;
+    addMGData(mgd: MGData, idx: number, isStartup: boolean): Promise<void>;
+    getMGData(idx: number): MGData;
+    getAvailableIdx(): number;
+    getMgDataIdx(mgd: MGData): number;
+    deleteMGDataTree(index: number): void;
+    getCurrMGData(): MGData;
+    GetMainProgByCtlIdx(contextIDOrCtlIdx: any, ctlIdx?: number): Task;
+    private GetMainProgByCtlIdx_0;
+    private GetMainProgByCtlIdx_1;
+    startTasksIteration(): void;
+    getNextTask(): ITask;
+    buildXML(message: StringBuilder, serializeTasks: boolean): Promise<void>;
+    getSize(): number;
+    processRecovery(): Promise<void>;
+    getTriggeredTasks(triggeringTask: Task): List<Task>;
+    GetTasks(p: (obj: Task) => boolean): List<Task>;
+    getTaskIdById(taskId: string): string;
+    GetTopMostForms(): List<MgFormBase>;
+    GetMGDataForStartupProgram(): MGData;
+    execRequestWithSubformRecordCycle(cmdsToServer: CommandsTable, cmdToServer: IClientCommand, exp: Expression): Promise<void>;
+    cleanDoSubformPrefixSuffix(): void;
+    execAllSubformRecordCycle(): Promise<void>;
+}
+
+declare class LastFocusedManager {
+    static Instance: LastFocusedManager;
+    private static _lastFocusedControls;
+    static LastFocusMgdID: number;
+    private _lastFocusedTasks;
+    LastActionTime: number;
+    Init(mgDataTable: MGDataCollection): void;
+    getCurrTask(): Task;
+    getLastFocusedTask(mgdID?: number): Task;
+    setLastFocusedTask(iTask: ITask): void;
+    clean(index: number): void;
+    static getLastFocusedControl(mgdID?: number): MgControl;
+    private static getLastFocusedControl_0;
+    private static getLastFocusedControl_1;
+    static deleteLastFocusedControlAt(index: number): void;
+    static setLastFocusedControlAt(ctrl: MgControlBase, currMgdID: number): void;
+    static setLastFocusedControl(task: TaskBase, mgControl: MgControlBase): void;
+}
+
+declare class RecomputeTable {
+    private fillAttributes;
+    fillData(parser: XmlParser): void;
+    fillData_1(dataView: DataView, task: Task, parser: XmlParser): void;
+    private initInnerObjects;
+}
+
+declare class RemoteDataviewHeader extends DataviewHeaderBase {
+    private _table;
+    private _lastFetchRecPos;
+    constructor(task: Task);
+    protected setAttribute(attribute: string, valueStr: string): void;
+    getLinkedRecord(curRec: Record): Promise<boolean>;
+    private copyLinkFldToRec;
+    private initRec;
+    getLastFetchedDbPos(): string;
+    SetReturnValue(ret: boolean, recompute: boolean): Promise<void>;
+}
+
+declare class ResultValue implements IResultValue {
+    Value: string;
+    Type: StorageAttribute;
+    SetResultValue(result: string, type: StorageAttribute): void;
+}
+
+declare class TableCacheManager {
+    private _tables;
+    static Instance: TableCacheManager;
+    private constructor();
+    GetTableById(tableUId: string): TableCache;
+    TableExists(tableUId: string): boolean;
+    InsertTable(table: TableCache): boolean;
+    LoadTable(tableUId: string): Promise<void>;
+}
+
+declare class UserDetails {
+    private static _instance;
+    UserName: string;
+    UserID: string;
+    UserInfo: string;
+    Password: string;
+    IsLoggedIn: boolean;
+    private setIsLoggedIn;
+    getIsLoggedIn(): boolean;
+    private setUserID;
+    static get Instance(): UserDetails;
+    constructor();
+    fillData(parser: XmlParser): void;
+    private initElements;
+}
+
+declare class RCTimer extends MgTimer {
+    private _mgData;
+    private _isIdle;
+    get TimerIntervalMiliSeconds(): number;
+    set IsIdleTimer(value: boolean);
+    get IsIdleTimer(): boolean;
+    constructor(mgData: MGData, milliseconds: number, isIdle: boolean);
+    GetMgdata(): MGData;
+    static StopTimer(mgData: MGData, milliseconds: number, isIdle: boolean): void;
+    static StopAll(mgData: MGData): void;
+}
+
+declare class RemoteTaskService extends TaskServiceBase {
+    constructor();
+    GetTaskTag(defaultValue: string): string;
+    GetDataviewManagerForVirtuals(task: Task): DataviewManagerBase;
+    PrepareTask(task: Task): ReturnResult;
+    GetEventTaskId(originalTaskId: string): string;
+    ShouldEvaluatePropertyLocally(propId: number): boolean;
+    InitTaskPrefixExecutedFlag(task: Task): void;
+    RemoveRecomputes(parentTask: Task): void;
+    GetOwnerTransactionTask(task: Task): Task;
+    static PreparePropMainDisplay(task: Task): Promise<ReturnResult>;
+}
+
+declare class ConstUtils {
+    static getStringOfOption(strOptions: string, options: string, selectedOption: string): string;
+}
+
+declare class CookieService {
+    static getCookies(cookieName: string): any;
+    static setCookie(name: string, value: string, expires?: number | Date, path?: any, domain?: any, secure?: any, sameSite?: any): boolean;
+    static encode_cookie(cookie_value: any): string;
+    static decode_cookie(coded_string: any): string;
+    static getCookie(cookieName: any): any;
+    static deleteCookie(cookieName: any): boolean;
+}
+
+declare class FlowMonitorQueue implements IFlowMonitorQueue {
+    private static _instance;
+    private static UNPRINTABLE_STR_LOG;
+    private static S_EVENT_STR1;
+    private static S_EVENT_STR2;
+    private static S_EVENT_PROPAGATED;
+    private static E_EVENT_STR;
+    private static S_RECPRF_STR;
+    private static E_RECPRF_STR;
+    private static S_RECSUF_STR;
+    private static E_RECSUF_STR;
+    private static S_TASKSUF_STR;
+    private static E_TASKSUF_STR;
+    private static S_TASKPRF_STR;
+    private static E_TASKPRF_STR;
+    private static S_CTRLPRF_STR;
+    private static E_CTRLPRF_STR;
+    private static S_CTRLSUF_STR;
+    private static E_CTRLSUF_STR;
+    private static S_HANDLER_STR;
+    private static E_HANDLER_STR;
+    private static S_CTRLVER_STR;
+    private static E_CTRLVER_STR;
+    private static RECOMP_STR;
+    private static S_VARIABLE_STR;
+    private static E_VARIABLE_STR;
+    private static VARIABLE_REASON_STR;
+    private static FLW_PERFIX;
+    private static ACT_TASK;
+    private static ACT_TASK_FLW;
+    private static ACT_RECOMPUTE;
+    private static ACT_FLW_OPER;
+    static LongTimePattern: string;
+    private _queue;
+    private _enabled;
+    private _isFlowOperation;
+    private _isRecompute;
+    private _isTask;
+    private _isTaskFlow;
+    private _isDataView;
+    ShouldSerialize: boolean;
+    static get Instance(): FlowMonitorQueue;
+    addTaskCngMode(newTaskMode: string, taskInfo: string): void;
+    fillData(parser: XmlParser): void;
+    private initElements;
+    buildXML(message: StringBuilder): void;
+    isEmpty(): boolean;
+    enable(value: boolean): boolean;
+    addTaskEvent(triggeredBy: string, state: number, taskInfo: string): void;
+    private appendVirtualsAndParameters;
+    addDataViewFlow(task: Task): void;
+    private getFieldData;
+    private PrepareDisplayString;
+    private padRight;
+    addTaskFlowRec(id: number, state: number, taskInfo: string): void;
+    addTaskFlowFld(id: number, fldName: string, state: number, taskInfo: string): void;
+    addTaskFlowCtrl(id: number, ctrlName: string, state: number, taskInfo: string): void;
+    addTaskFlowHandler(handlerId: string, state: number, taskInfo: string): void;
+    addRecompute(triggeredByVarName: string, taskInfo: string): void;
+    addFlowFieldOperation(oper: Operation, bExecuted: boolean, taskInfo: string): Promise<void>;
+    addFlowOperationUpdate(state: number, taskInfo: string): void;
+    addFlowVerifyInfo(info: string, taskInfo: string): void;
+    addFlowInvokeOsInfo(info: string, taskInfo: string): void;
+    private addFlowInfo;
+}
+
+declare class HeapSort {
+    private static left;
+    private static right;
+    static sort(array: IComparable[]): void;
+}
+
+interface MgBlockingQueue {
+    offer(o: any): boolean;
+    put(o: any): void;
+    waitForElement(): void;
+}
+
+declare class MgPriorityBlockingQueue implements MgBlockingQueue {
+    private _queue;
+    private _timeFirstEvent;
+    constructor();
+    private isBackgroundEvent;
+    offer(o: any): boolean;
+    put(o: any): void;
+    waitForElement(): Promise<void>;
+    GetTime(): number;
+    poll(): any;
+    peek(): any;
+    size(): number;
+    remainingCapacity(): number;
+    clear(): void;
+    isEmpty(): boolean;
+}
+
+declare class MgPriorityQueue {
+    private static DEFAULT_INITIAL_CAPACITY;
+    private _queue;
+    Size: number;
+    constructor();
+    offer(o: any): boolean;
+    peek(): any;
+    isEmpty(): boolean;
+    clear(): void;
+    poll(): any;
+    private fixUp;
+    private fixDown;
+}
+
+declare class Scrambler {
+    static ScramblingEnabled: boolean;
+    private static XML_MIN_RANDOM;
+    private static XML_MAX_RANDOM;
+    private static XML_ILLEGAL_RANDOM;
+    static Scramble(inVal: string): string;
+    private static LocateScramble;
+    private static RandomScramble;
+    static UnScramble(inVal: string, beginOffSet: number, endOffSet: number): string;
+}
+
+declare class UniqueIDUtils {
+    private static id;
+    static GetUniqueMachineID(): string;
+}
+
+export { AbortCommand, AccessHelper, ActionManager, AddLocateCommand, AddRangeCommand, AddSortCommand, AddUserLocateDataViewCommand, AddUserLocateRemoteDataViewCommand, AddUserRangeDataviewCommand, AddUserRangeRemoteDataViewCommand, AddUserSortDataViewCommand, AddUserSortRemoteDataViewCommand, Argument, ArgumentsList, Boundary, BrowserEscEventCommand, CachedFileQueryCommand, ClearEventsOnStopExecution, ClientManager, ClientOriginatedCommand, ClientOriginatedCommandSerializer, ClientOriginatedCommandTaskTag, ClientRefreshCommand, ClientTargetedCommandBase, ClientTargetedCommandType, ColumnSortEventCommand, CommandFactory, CommandSerializationHelper, CommandsProcessorBase, CommandsProcessorBase_SendingInstruction, CommandsProcessorBase_SessionStage, CommandsProcessorManager, CommandsTable, CompMainPrgTable, ComputeEventCommand, ConstInterface, ConstUtils, ContextTerminationEventCommand, ContextTimeoutResetCommand, ControlItemsRefreshCommand, CookieService, CreatedFormVector, CurrentClientVersion, DataSourceIdKey, DataView, DataViewBase, DataViewCommandBase, DataViewCommandType, DataViewOutputCommand, DataviewCommand, DataviewHeaderBase, DataviewHeaderFactory, DataviewHeaders, DataviewHeadersSaxHandler, DataviewManager, DataviewManagerBase, DcValuesReference, DummyDataViewCommand, DvCache, EnhancedVerifyCommand, EnvParamsTable, Environment, EnvironmentDetails, EvaluateCommand, Event, EventCommand, EventHandler, EventHandlerPosition, EventSubType, EventsAllowedType, EventsManager, ExecOperCommand, ExecutionStack, ExecutionStackEntry, ExpDesc, ExpStrTracker, ExpTable, Expression, ExpressionDict, ExpressionEvaluator, ExpressionLocalJpn, Expression_ReturnValue, FetchDataControlValuesEventCommand, Field, FieldBase, FieldsTable as FieldsTableExt, FlowMonitorInterface, FlowMonitorQueue, FormsTable, GUIManager, GlobalCommandsManager, GlobalParams, GlobalParamsQueryCommand, GuiEventsProcessor, HandlersTable, HeapSort, HttpClientAsync, HttpClientBase, HttpClientEvents, HttpClientSync, HttpManager, HttpUtility, IClientTargetedCommand, IndexChangeEventCommand, IniputForceWriteCommand, InteractiveCommunicationsFailureHandler, Key, LanguageData, LastFocusedManager, MGData, MGDataCollection, MagicBridge, MgControl, MgForm, MgPriorityBlockingQueue, MgPriorityQueue, MirrorExpVal, MirrorPrmMap, MirrorString, NonReversibleExitEventCommand, NullValueException, OpenURLCommand, OpeningTaskDetails, Operation, OperationTable, ParamParseResult, PrmMap, QueryCommand, RCTimer, Recompute, RecomputeCommand, RecomputeTable, Recompute_RcmpBy, Record, RecordOutOfDataViewException, RecordOutOfDataViewException_ExceptionType, RecordsTable, RefreshEventCommand, RefreshScreenEventCommand, RemoteCommandsProcessor, RemoteControlItemsRefreshCommand, RemoteDataViewCommandBase, RemoteDataViewCommandFactory, RemoteDataViewCommandUpdateNonModifiable, RemoteDataviewHeader, RemoteDataviewManager, RemoteTaskService, RequestMethod, ResetLocateCommand, ResetRangeCommand, ResetSortCommand, ResetUserLocateRemoteDataviewCommand, ResetUserRangeRemoteDataviewCommand, ResetUserSortRemoteDataviewCommand, ResultCommand, ResultValue, RetVals, ReturnResult, ReturnResultBase, RollbackEventCommand, RollbackEventCommand_RollbackType, RunTimeEvent, RunTimeEventBase, SET_DISPLAYLINE_BY_DV, Scrambler, SelectProgramCommand, ServerConfig, ServerError, SetTransactionStateDataviewCommand, SetTransactionStateRemoteDataViewCommand, Sort, SortCollection, SubformOpenEventCommand, SubformRefreshEventCommand, TableCache, TableCacheManager, Task, TaskBase, TaskServiceBase, TaskTransactionManager, Task_Direction, Task_Flow, Task_SubformExecModeEnum, TasksTable, Transaction, TransactionCommand, UniqueIDUtils, UnloadCommand, UserDetails, UserEventsTable, UserRange, VerifyCommand, WriteMessageToServerLogCommand, XMLBasedCommandBuilder, XMLBasedDcValuesBuilder, YesNoExp, getGuiEventObj };
+export type { IClientCommand, IClientToServerCommandInfo, ICommandTaskTag, ICommandsTable, ICommunicationsFailureHandler, IConnectionStateManager, IDataSourceViewDefinition, IDataviewHeader, IEventsManager, IGuiEvent, ILanguageData, IMGDataCollection, IMirrorXML, IRecordsTable, IResultValue, IServerConfig, MgBlockingQueue };