@1oo4/miv 1.0.0

package/dist/Client/MIVClient.js

@@ -0,0 +1,931 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIVClient = void 0;
+const ErrorMessage_1 = require("../Communication/ErrorMessage");
+const ChildAndRealtionData_1 = require("./Construction/ChildAndRealtionData");
+const MRelation_1 = require("./MRelation");
+const ChildUpdate_1 = require("./UpdateTools/ChildUpdate");
+const ClientTypes_1 = require("./Construction/ClientTypes");
+const PersistentList_1 = require("../Tools/PersistentList");
+const ModelUpdateAndCompute_1 = require("./UpdateTools/ModelUpdateAndCompute");
+const ViewUpdateAndCompute_1 = require("./UpdateTools/ViewUpdateAndCompute");
+const VListModif_1 = require("./VSets/FilterAndSort/VListModif");
+const UnloadQuery_1 = require("../Communication/UnloadQuery");
+const AccumulatorList_1 = require("../Tools/AccumulatorList");
+const QueryBuilder_1 = require("./QueryBuilder");
+const QueryInfo_1 = require("./QueryInfo");
+const MIVConstants_1 = require("../MIVConstants");
+const DataAnswer_1 = require("../Communication/DataAnswer");
+const Semaphore_1 = require("../Tools/Semaphore");
+const MIVDeserializer_1 = require("../Communication/Serialization/MIVDeserializer");
+const DateTimeProperty_1 = require("./Properties/DateTimeProperty");
+var SignStatus;
+(function (SignStatus) {
+    SignStatus[SignStatus["NONE"] = 0] = "NONE";
+    SignStatus[SignStatus["IN"] = 1] = "IN";
+    SignStatus[SignStatus["OUT"] = 2] = "OUT";
+})(SignStatus || (SignStatus = {}));
+class MIVClient {
+    get IsStarted() { return this._is_started_miv_; }
+    get UserID() { return this._user_id_miv_; }
+    get Error() { return this._error_miv_; }
+    get MustChangePassword() { return this._must_change_password_miv_; }
+    constructor(cs) {
+        this._is_started_miv_ = false;
+        this._user_id_miv_ = -1n;
+        this._semaLock_miv_ = new Semaphore_1.SemaphoreConcurrency();
+        this._token_lock_miv_ = MIVClient.TOKEN_BASE_miv_;
+        this._recursive_lock_miv_ = 0;
+        this._must_change_password_miv_ = false;
+        this._pageItemsList_miv_ = new AccumulatorList_1.AccumulatorList(1);
+        this.DefaultQueryHistory = false;
+        this._constructingDummy_miv_ = false;
+        this._roots_miv_ = new Array();
+        this._children_miv_ = new Map();
+        this._queries_miv_ = new Map();
+        this._cTypesFetcher_miv_ = new Map();
+        this._rTypesFetcher_miv_ = new Map();
+        this._loads_miv_ = new PersistentList_1.PersistentList(8);
+        this._cuCache_miv_ = new ChildUpdate_1.ChildUpdateCache(32);
+        this._newChildren_miv_ = new AccumulatorList_1.AccumulatorList(32);
+        this._destroyedChildren_miv_ = new AccumulatorList_1.AccumulatorList(32);
+        this._listsChanged_miv_ = new AccumulatorList_1.AccumulatorList(32);
+        this._childrenListsTMP_miv_ = new AccumulatorList_1.AccumulatorList(32);
+        this._targetsListsTMP_miv_ = new AccumulatorList_1.AccumulatorList(32);
+        this._queriesTMP_miv_ = new Map();
+        this._newRelations_miv_ = new AccumulatorList_1.AccumulatorList(32);
+        this._loadsList_miv_ = new AccumulatorList_1.AccumulatorList(2);
+        this._unloadIDList_miv_ = new AccumulatorList_1.AccumulatorList(2);
+        this._unloadCodeList_miv_ = new AccumulatorList_1.AccumulatorList(2);
+        this._objectsChangedForV_miv_ = new AccumulatorList_1.AccumulatorList(32);
+        this._fieldsChangedForV_miv_ = new AccumulatorList_1.AccumulatorList(32);
+        this._vWithModelUpdated_miv_ = new AccumulatorList_1.AccumulatorList(32);
+        this._vStatusChanged_miv_ = new AccumulatorList_1.AccumulatorList(32);
+        this._paginationsWithMaybeDestroyed_miv_ = new AccumulatorList_1.AccumulatorList(2);
+        this._vSetsToPreapare_miv_ = new PersistentList_1.PersistentList2(16);
+        this._vSetsUpdated_miv_ = new AccumulatorList_1.AccumulatorList(16);
+        this._vIndexChanged_miv_ = new AccumulatorList_1.AccumulatorList(16);
+        this._uwTriggered_miv_ = new AccumulatorList_1.AccumulatorList(2);
+        this._modifCache_miv_ = new VListModif_1.VListModifCache(16);
+        this._signing_miv_ = SignStatus.NONE;
+        this._connection_miv_ = cs;
+        this._cData_miv_ = new ChildAndRealtionData_1.ChildData(this);
+        this._rData_miv_ = new ChildAndRealtionData_1.RelationData(this);
+        this.GenericParentChildType = new ClientTypes_1.ClientGenericChildType(this);
+        this.GenericParentRelationType = new ClientTypes_1.ClientGenericRelationType(this);
+        this._dataUpdate_miv_ = new ModelUpdateAndCompute_1.ModelUpdate(this);
+        this._viewUpdate_miv_ = new ViewUpdateAndCompute_1.ViewUpdate(this);
+    }
+    _addRoot_miv_(r) {
+        if (r.ID == BigInt(MIVConstants_1.MIVConstants.SYSTEM_ROOT_ID) || r.Type.ID == MIVConstants_1.MIVConstants.SYSTEM_ROOT_TYPE) {
+            if (r.ID != BigInt(MIVConstants_1.MIVConstants.SYSTEM_ROOT_ID) || r.Type.ID != MIVConstants_1.MIVConstants.SYSTEM_ROOT_TYPE) {
+                throw new Error("the MRootSystem must have both its ID and Type match MIVConstances.SYSTEM_ROOT_ID and MIVConstants.SYSTEM_ROOT_TYPE.");
+            }
+            if (this._system_miv_ === undefined) {
+                this._system_miv_ = r;
+            }
+            else {
+                throw new Error("duplicate root");
+            }
+        }
+        this._roots_miv_.push(r);
+    }
+    RegisterChildType(typeID, cstr, name, parent, collection) {
+        if (this._cTypesFetcher_miv_.has(typeID)) {
+            throw new Error("A type with this ID is already registered.");
+        }
+        const result = new ClientTypes_1.ClientChildType(this, typeID, cstr, name, parent, collection);
+        this._cTypesFetcher_miv_.set(typeID, result);
+        return result;
+    }
+    RegisterRelationType(typeID, cstr, name, parent, collection) {
+        if (this._rTypesFetcher_miv_.has(typeID)) {
+            throw new Error("A type with this ID is already registered.");
+        }
+        const result = new ClientTypes_1.ClientRelationType(this, typeID, cstr, name, parent, collection);
+        this._rTypesFetcher_miv_.set(typeID, result);
+        return result;
+    }
+    async StartAsync(options) {
+        this._constructingObject_miv_ = undefined;
+        if (this._system_miv_ === undefined) {
+            throw new Error("missing system root");
+        }
+        const checkDuplicateID = new Set();
+        for (let i = 0; i < this._roots_miv_.length; i++) {
+            const r = this._roots_miv_[i];
+            if (checkDuplicateID.has(r.ID)) {
+                throw new Error("duplicate root ID " + r.ID);
+            }
+            else {
+                checkDuplicateID.add(r.ID);
+            }
+        }
+        this._constructingDummy_miv_ = true;
+        const nameCheck = new Set();
+        const idCheck = new Set();
+        for (let i = 0; i < this._roots_miv_.length; i++) {
+            const r = this._roots_miv_[i];
+            r.Type._initialize_miv_(r, nameCheck, idCheck);
+        }
+        for (let [tid, type] of this._cTypesFetcher_miv_) {
+            type._initializeChild_miv_(this._cData_miv_, nameCheck, idCheck);
+        }
+        for (let [tid, type] of this._rTypesFetcher_miv_) {
+            type._initializeRelation_miv_(this._rData_miv_, nameCheck, idCheck);
+        }
+        this._constructingDummy_miv_ = false;
+        let msg = await this._connection_miv_._startAsync_miv_(this);
+        if (msg !== undefined) {
+            return msg;
+        }
+        this._is_started_miv_ = true;
+        const token = await this.TakeLockAsync();
+        for (let i = 0; i < this._roots_miv_.length; i++) {
+            const r = this._roots_miv_[i];
+            if (!r._actuallyLoaded_miv_) {
+                r._falselyLoaded_miv_(r.InitialLoad, r.Type._filtersNotNull_miv_);
+            }
+        }
+        if (options !== undefined && options.login !== undefined) {
+            msg = await this.SignInAsync(options.login, options.password, undefined, token);
+            if (msg !== undefined)
+                return msg;
+            this._signing_miv_ = SignStatus.IN;
+        }
+        const forest = new Array();
+        for (let i = 0; i < this._roots_miv_.length; i++) {
+            const r = this._roots_miv_[i];
+            if (r._actuallyLoaded_miv_) {
+                forest.push({ root: r, filters: [r.InitialLoad] });
+            }
+        }
+        let errors;
+        if (forest.length > 0) {
+            errors = await this._loadForestArrayAsync_miv_(token, true, forest);
+        }
+        else {
+            errors = undefined;
+        }
+        this.ReleaseLock();
+        return ErrorMessage_1.AggregateErrorMessage.CreateFromList(errors);
+    }
+    _signActions_miv_(mu) {
+        if (this._system_miv_ !== undefined && this._signing_miv_ != SignStatus.NONE) {
+            mu.SetDefaultLong(this._system_miv_.CurrentUserID, this._user_id_miv_);
+            this._system_miv_._setCurrentUser_miv_(this._user_id_miv_, mu);
+            this._signing_miv_ = SignStatus.NONE;
+        }
+    }
+    async SignInAsync(login, password, virtualUpdate = undefined, lockToken = 0n) {
+        await this.TakeLockAsync(lockToken);
+        if (!this._connection_miv_._isActive_miv_) {
+            this.ReleaseLock();
+            return ErrorMessage_1.ConnectionLost.SINGLETON;
+        }
+        const data = await this._connection_miv_._signinAsync_miv_(login, password);
+        if (data._error_miv_ === undefined) {
+            let userID;
+            if (data._children_miv_._count_miv_ > 0) {
+                userID = data._children_miv_._list_miv_._get_miv_(0)._id_miv_;
+                this._login_miv_ = login;
+                this._password_miv_ = password;
+                this._update_on_login_miv_ = virtualUpdate;
+            }
+            else {
+                userID = -1n;
+            }
+            this._user_id_miv_ = userID;
+            this._signing_miv_ = SignStatus.IN;
+            await this._executeSingleDataMessage_miv_(data, virtualUpdate);
+            this._receiveAnswer_miv_(data._mustChangePassword_miv_);
+            this.ReleaseLock();
+            return undefined;
+        }
+        else {
+            this._receiveAnswer_miv_(data._mustChangePassword_miv_);
+            this.ReleaseLock();
+            return data._error_miv_;
+        }
+    }
+    async SignOutAsync(virtualUpdate = undefined, lockToken = 0n) {
+        this._login_miv_ = undefined;
+        this._password_miv_ = undefined;
+        lockToken = await this.TakeLockAsync(lockToken);
+        this._user_id_miv_ = -1n;
+        this._signing_miv_ = SignStatus.OUT;
+        if (virtualUpdate !== undefined)
+            await this._executeVirtualUpdateAsync_must_have_lock_miv_(virtualUpdate);
+        if (this._connection_miv_._isActive_miv_) {
+            await this._connection_miv_._signoutAsync_miv_();
+        }
+        this.ReleaseLock();
+    }
+    _receiveAnswer_miv_(mustChangePassword) {
+        if (mustChangePassword) {
+            if (!this._must_change_password_miv_) {
+                this._must_change_password_miv_ = true;
+                this.PasswordChangeRequired();
+            }
+        }
+        else {
+            if (this._must_change_password_miv_) {
+                this._must_change_password_miv_ = false;
+                this.PasswordChangeNotRequired();
+            }
+        }
+    }
+    PasswordChangeRequired() { }
+    PasswordChangeNotRequired() { }
+    Stop() {
+        this._connection_miv_._stop_miv_();
+        this._login_miv_ = undefined;
+        this._password_miv_ = undefined;
+    }
+    async _connectionLost_miv_() {
+        this._user_id_miv_ = -1n;
+        const cl = this.ConnectionLost();
+        if (cl.maxAttempts != 0) {
+            const token = await this.TakeLockAsync();
+            const msg = await this._tryReconnectAsync_miv_(cl.maxAttempts, cl.delayMilliseconds, true, token);
+            if (this._connection_miv_._isActive_miv_) {
+                this.ReleaseLock();
+                this.ExecuteViewUpdateOnUIThread();
+                this.ReconnectAttemptSuccessful(msg);
+            }
+            else {
+                this.ReleaseLock();
+                this.ReconnectAttemptsAllFailed(msg);
+            }
+        }
+    }
+    ConnectionLost() { return { maxAttempts: 4, delayMilliseconds: 2000 }; }
+    ;
+    ReconnectAttempt(attempt, maxAttempts, calledFromEnsure) { }
+    ReconnectAttemptSuccessful(error) { }
+    ReconnectAttemptFailed(attempt, maxAttempts, calledFromEnsure, error) { }
+    ReconnectAttemptsAllFailed(error) { }
+    async _tryReconnectAsync_miv_(maxAttempts, delayMilliseconds, calledFromLost, lockToken) {
+        if (maxAttempts == 0)
+            return ErrorMessage_1.ConnectionLost.SINGLETON;
+        let msg = undefined;
+        let i = 1;
+        while (maxAttempts < 0 || i <= maxAttempts) {
+            if (delayMilliseconds > 0 && (calledFromLost || i > 1)) {
+                await new Promise(f => setTimeout(f, delayMilliseconds));
+            }
+            this.ReconnectAttempt(i, maxAttempts, !calledFromLost);
+            msg = await this._connection_miv_._tryReconnectAsync_miv_();
+            if (msg === undefined) {
+                if (this._login_miv_ !== undefined) {
+                    msg = await this.SignInAsync(this._login_miv_, this._password_miv_, this._update_on_login_miv_, lockToken);
+                    if (msg !== undefined) {
+                        this._connection_miv_._stop_miv_();
+                        return msg;
+                    }
+                }
+                const toLoad = new Array();
+                for (let j = 0; j < this._loads_miv_._count_miv_; j++) {
+                    const root = this._loads_miv_._get_miv_(j);
+                    const filters = root._getActiveLoads_miv_();
+                    if (filters !== undefined && filters.length > 0)
+                        toLoad.push({ root: root._owner_miv_, filters: filters });
+                }
+                const errors = await this._loadForestArrayAsync_miv_(lockToken, false, toLoad);
+                msg = ErrorMessage_1.AggregateErrorMessage.CreateFromList(errors);
+                break;
+            }
+            else {
+                this.ReconnectAttemptFailed(i, maxAttempts, !calledFromLost, msg);
+                i++;
+            }
+        }
+        return msg;
+    }
+    async EnsureConnectionAsync(maxAttempts, delayMilliseconds, lockToken = 0n) {
+        lockToken = await this.TakeLockAsync(lockToken);
+        if (this._connection_miv_._isActive_miv_) {
+            this.ReleaseLock();
+            return undefined;
+        }
+        else {
+            const msg = await this._tryReconnectAsync_miv_(maxAttempts, delayMilliseconds, false, lockToken);
+            if (this._connection_miv_._isActive_miv_) {
+                this.ReleaseLock();
+                this.ExecuteViewUpdateOnUIThread();
+            }
+            else {
+                this.ReleaseLock();
+            }
+            return msg;
+        }
+    }
+    TryGetObject(id) {
+        const c = this._children_miv_.get(id);
+        if (c === undefined) {
+            for (let i = 0; i < this._roots_miv_.length; i++) {
+                const r = this._roots_miv_[i];
+                if (r.ID == id)
+                    return r;
+            }
+            return undefined;
+        }
+        else {
+            return c;
+        }
+    }
+    TryGetChild(id) {
+        return this._children_miv_.get(id);
+    }
+    TryGetType(id) {
+        let result = this._cTypesFetcher_miv_.get(id);
+        if (result !== undefined)
+            return result;
+        result = this._rTypesFetcher_miv_.get(id);
+        if (result !== undefined)
+            return result;
+        if (this._generic_relation_type_miv_ !== undefined && this._generic_relation_type_miv_.ID == id) {
+            return this._generic_relation_type_miv_;
+        }
+        for (let i = 0; i < this._roots_miv_.length; i++) {
+            const rt = this._roots_miv_[i].Type;
+            if (rt.ID == id)
+                return rt;
+        }
+        return undefined;
+    }
+    async TakeLockAsync(token = 0n) {
+        if (token == this._token_lock_miv_) {
+            this._recursive_lock_miv_++;
+            return token;
+        }
+        else {
+            await this._semaLock_miv_.WaitAsync();
+            this._token_lock_miv_++;
+            if (this._token_lock_miv_ <= MIVClient.TOKEN_BASE_miv_)
+                this._token_lock_miv_ = MIVClient.TOKEN_BASE_miv_;
+            return this._token_lock_miv_;
+        }
+    }
+    ReleaseLock() {
+        if (this._recursive_lock_miv_ > 0) {
+            this._recursive_lock_miv_--;
+        }
+        else {
+            this._semaLock_miv_.Release();
+        }
+    }
+    async BeginQueryAsync(lockToken = 0n) {
+        this._error_miv_ = undefined;
+        await this.TakeLockAsync(lockToken);
+        if (this._qb_miv_ === undefined) {
+            this._qb_miv_ = new QueryBuilder_1.QueryBuilder(this);
+            return this._qb_miv_;
+        }
+        else {
+            throw new Error("You cannot create several simultaneous QueryBuilder objects.");
+        }
+    }
+    _updateCanceled_miv_() {
+        this._qb_miv_ = undefined;
+        this.ReleaseLock();
+    }
+    _emptyOrFaultyUpdate_miv_() {
+        this._qb_miv_ = undefined;
+    }
+    async _executeUpdate_miv_(qb, uq) {
+        if (this._qb_miv_ === undefined) {
+            throw new Error("This query is canceled or already executed.");
+        }
+        if (!this._connection_miv_._isActive_miv_)
+            return new DataAnswer_1.DataAnswer(ErrorMessage_1.ConnectionLost.SINGLETON);
+        const ans = await this._connection_miv_._executeAsync_miv_(uq);
+        this._error_miv_ = ans._error_miv_;
+        qb._custom_result_miv_ = ans._customPayload_miv_;
+        if (ans._error_miv_ === undefined) {
+            await this._executeSingleDataMessage_miv_(ans, undefined);
+        }
+        this._receiveAnswer_miv_(ans._mustChangePassword_miv_);
+        this._qb_miv_ = undefined;
+        return ans;
+    }
+    async SignUpAsync(login, password, customPayload, virtualUpdate = undefined, lockToken = 0n) {
+        if (!this._connection_miv_._isActive_miv_)
+            return ErrorMessage_1.ConnectionLost.SINGLETON;
+        await this.TakeLockAsync(lockToken);
+        const ans = await this._connection_miv_._signupAsync_miv_(login, password, customPayload);
+        const msg = ans._error_miv_;
+        if (msg === undefined) {
+            if (ans._customPayload_miv_ !== undefined) {
+                const reader = new MIVDeserializer_1.MIVDeserializer(ans._customPayload_miv_, 0);
+                const uid = reader.ReadInt64();
+                if (uid !== undefined) {
+                    this._user_id_miv_ = uid;
+                }
+            }
+            this._login_miv_ = login;
+            this._password_miv_ = password;
+            this._signing_miv_ = SignStatus.IN;
+            this._update_on_login_miv_ = virtualUpdate;
+            await this._executeSingleDataMessage_miv_(ans, virtualUpdate);
+        }
+        this._receiveAnswer_miv_(ans._mustChangePassword_miv_);
+        this.ReleaseLock();
+        return msg;
+    }
+    LoadForestAsync(lockToken, ...roots) {
+        return this._loadForestAsync_client_required_miv_(lockToken, roots);
+    }
+    LoadForestArrayAsync(lockToken, roots) {
+        return this._loadForestAsync_client_required_miv_(lockToken, roots);
+    }
+    _loadForestAsync_client_required_miv_(lockToken, roots) {
+        if (roots === undefined || roots.length <= 0) {
+            return Promise.resolve(undefined);
+        }
+        else {
+            for (let i = 0; i < roots.length; i++) {
+                const x = roots[i];
+                const root = x.root;
+                const filters = x.filters;
+                const available = root.Type._filters_miv_;
+                if (available === undefined)
+                    throw new Error("This filter is not defined on this type.");
+                for (let j = 0; j < filters.length; j++) {
+                    const f = filters[j];
+                    const index = available._getFilterIndexFromFilter(f);
+                    if (index < 0)
+                        throw new Error("This filter is not defined on this type.");
+                }
+            }
+            return this._loadForestArrayAsync_miv_(lockToken, true, roots);
+        }
+    }
+    async _loadForestArrayAsync_miv_(lockToken, incrLoadCount, roots) {
+        if (roots.length <= 0)
+            return undefined;
+        await this.TakeLockAsync(lockToken);
+        let mustChangePassword = false;
+        const errors = new AccumulatorList_1.AccumulatorList(0);
+        for (let i = 0; i < roots.length; i++) {
+            const r = roots[i];
+            if (this._connection_miv_._isActive_miv_) {
+                const data = await this._connection_miv_._loadAsync_miv_(r.root.ID, r.filters);
+                this._must_change_password_miv_ = data._mustChangePassword_miv_;
+                if (data._error_miv_ === undefined) {
+                    r.root._loadedInForest_miv_(r.filters, incrLoadCount);
+                    this._executeDataMessageWithinSetOfMessages_miv_(data);
+                }
+                else {
+                    errors._add_miv_({ root: r.root, error: data._error_miv_ });
+                }
+            }
+            else {
+                errors._add_miv_({ root: r.root, error: ErrorMessage_1.ConnectionLost.SINGLETON });
+            }
+        }
+        await this._finalizeExecuteModel_miv_(undefined);
+        this._receiveAnswer_miv_(mustChangePassword);
+        let result;
+        if (errors._count_miv_ > 0) {
+            result = new Array(errors._count_miv_);
+            for (let i = 0; i < result.length; i++) {
+                result[i] = errors._get_miv_(i);
+            }
+        }
+        else {
+            result = undefined;
+        }
+        this.ReleaseLock();
+        return result;
+    }
+    async _loadModel_miv_(root, filter, filters) {
+        this._error_miv_ = undefined;
+        if (!this._connection_miv_._isActive_miv_)
+            return ErrorMessage_1.ConnectionLost.SINGLETON;
+        const data = await this._connection_miv_._loadAsync_miv_(root.ID, [filter]);
+        if (data._error_miv_ !== undefined) {
+            this._error_miv_ = data._error_miv_;
+            return data._error_miv_;
+        }
+        root._loadedSingle_miv_(filters, filter);
+        await this._executeSingleDataMessage_miv_(data, undefined);
+        this._receiveAnswer_miv_(data._mustChangePassword_miv_);
+        return undefined;
+    }
+    _executeUnload_miv_() {
+        return this._finalizeExecuteModel_miv_(undefined);
+    }
+    async _loadPagesAsync_miv_(pages, filter) {
+        this._error_miv_ = undefined;
+        if (!this._connection_miv_._isActive_miv_)
+            return ErrorMessage_1.ConnectionLost.SINGLETON;
+        const pagi = pages[0]._pagination_miv_;
+        for (let i = 0; i < pages.length; i++) {
+            const page = pages[i];
+            for (let j = 0; j < page._supportInternal_miv_._content_miv_._count_miv_; j++) {
+                this._pageItemsList_miv_._add_miv_(page._supportInternal_miv_._content_miv_._get_miv_(j).ID);
+            }
+        }
+        const data = await this._connection_miv_._loadPagesAsync_miv_(pagi.Owner.ID, filter, pagi.Code, pages, this._pageItemsList_miv_);
+        this._pageItemsList_miv_._clear_miv_(8, false);
+        if (data._error_miv_ !== undefined) {
+            this._error_miv_ = data._error_miv_;
+            return data._error_miv_;
+        }
+        await this._executeSingleDataMessage_miv_(data, undefined);
+        this._receiveAnswer_miv_(data._mustChangePassword_miv_);
+        return undefined;
+    }
+    async RunCustomReadQueryAsync(request, executeViewUpdate, virtualUpdate, lockToken = 0n) {
+        if (request.length <= 0) {
+            if (executeViewUpdate) {
+                await this.TakeLockAsync(lockToken);
+                this._executeVUpdate_do_not_release_lock_miv();
+                this.ReleaseLock();
+            }
+            return MIVClient.EMPTY_RESPONSE_PAYLOAD;
+        }
+        if (request.length > MIVClient.MAX_CUSTOM_READ_REQUEST_LENGTH) {
+            throw new Error("request.length is greater than MAX_CUSTOM_READ_REQUEST_LENGTH " + MIVClient.MAX_CUSTOM_READ_REQUEST_LENGTH);
+        }
+        await this.TakeLockAsync(lockToken);
+        this._error_miv_ = undefined;
+        const answer = await this._connection_miv_._customReadAsync_miv_(request);
+        let vUpdate;
+        if (virtualUpdate === undefined) {
+            vUpdate = undefined;
+        }
+        else {
+            vUpdate = x => virtualUpdate(answer._customPayload_miv_, x);
+        }
+        await this._executeSingleDataMessage_miv_(answer, vUpdate);
+        this._receiveAnswer_miv_(answer._mustChangePassword_miv_);
+        let result;
+        if (answer._error_miv_ === undefined) {
+            if (answer._customPayload_miv_ === undefined)
+                result = MIVClient.EMPTY_RESPONSE_PAYLOAD;
+            else
+                result = answer._customPayload_miv_;
+        }
+        else {
+            this._error_miv_ = answer._error_miv_;
+            result = answer._customPayload_miv_;
+        }
+        if (executeViewUpdate)
+            this._executeVUpdate_do_not_release_lock_miv();
+        this.ReleaseLock();
+        return result;
+    }
+    async _fetchBlobAsync_lock_already_taken_do_not_release_miv_(owner, property, knownBlobID) {
+        this._error_miv_ = undefined;
+        const answer = await this._connection_miv_._fetchBlobAsync_miv_(owner, property, knownBlobID);
+        await this._executeSingleDataMessage_miv_(answer, undefined);
+        this._receiveAnswer_miv_(answer._mustChangePassword_miv_);
+        if (answer._error_miv_ === undefined) {
+            return undefined;
+        }
+        else {
+            this._error_miv_ = answer._error_miv_;
+            return answer._error_miv_;
+        }
+    }
+    GetAuditTrailAsync(root, depth, fromLocal, lockToken = 0n) {
+        return this._getAuditTrailAsync_miv_(root, depth, fromLocal, lockToken, false);
+    }
+    GetAuditTrailAllowTypesAsync(root, depth, fromLocal, lockToken, ...args) {
+        return this._getAuditTrailAsync_miv_(root, depth, fromLocal, lockToken, true, ...args);
+    }
+    GetAuditTrailExcludeTypesAsync(root, depth, fromLocal, lockToken, ...args) {
+        return this._getAuditTrailAsync_miv_(root, depth, fromLocal, lockToken, false, ...args);
+    }
+    async _getAuditTrailAsync_miv_(root, depth, fromLocal, lockToken, allowTypes, ...args) {
+        const typesID = new Array();
+        if (args !== undefined && args.length > 0) {
+            for (let i = 0; i < args.length; i++) {
+                typesID.push(args[i].ID);
+            }
+        }
+        await this.TakeLockAsync(lockToken);
+        const result = await this._connection_miv_._getAuditTrailAsync_miv_(root.ID, depth, DateTimeProperty_1.DateTimeProperty.ToUTC(fromLocal), allowTypes, typesID);
+        result._pack_miv_(this);
+        this.ReleaseLock();
+        return result;
+    }
+    async GetAuditTrailByUserAsync(ofUser, fromLocal, lockToken) {
+        await this.TakeLockAsync(lockToken);
+        const result = await this._connection_miv_._getAuditTrailByUserAsync_miv_(ofUser.ID, DateTimeProperty_1.DateTimeProperty.ToUTC(fromLocal));
+        result._pack_miv_(this);
+        this.ReleaseLock();
+        return result;
+    }
+    async GetConnectionsLogAsync(fromLocal) {
+        await this.TakeLockAsync();
+        const result = await this._connection_miv_._getConnectionLog_miv_(DateTimeProperty_1.DateTimeProperty.ToUTC(fromLocal));
+        result._pack_miv_();
+        this.ReleaseLock();
+        return result;
+    }
+    _createChild_miv_(data, creation, assignment) {
+        const cct = this._cTypesFetcher_miv_.get(data._type_miv_);
+        if (cct === undefined)
+            return undefined;
+        this._cData_miv_._setup_miv_(cct, data._id_miv_, data._parent_miv_, data._property_miv_, data._index_miv_, data._paginationIndex_miv_, creation, assignment, data._copyOf_miv_);
+        const result = cct._create_miv_(this._cData_miv_);
+        this._constructingObject_miv_ = undefined;
+        return result;
+    }
+    _makeGenericRelation_miv_(data, creation, assignment, alreadySetup) {
+        if (this._generic_relation_type_miv_ === undefined) {
+            this._generic_relation_type_miv_ = new ClientTypes_1.ClientRelationType(this, MIVConstants_1.MIVConstants.TYPE_GENERIC_RELATION, x => new MRelation_1.MRelation(x), this.GenericParentRelationType.Name, this.GenericParentRelationType, false);
+            alreadySetup = false;
+            this._constructingDummy_miv_ = true;
+            this._rData_miv_._setupRelation_miv_(this._generic_relation_type_miv_, -1n, -1n, MIVConstants_1.MIVConstants.PROPERTY_ANY, 0, 0, undefined, undefined, -1n, -1n);
+            const dummy = new MRelation_1.MRelation(this._rData_miv_);
+            this._generic_relation_type_miv_._initializeGeneric_miv_(dummy, new Set(), new Set());
+            this._constructingDummy_miv_ = false;
+        }
+        if (alreadySetup) {
+            this._rData_miv_._setupGenericType_miv_(this._generic_relation_type_miv_);
+        }
+        else {
+            this._rData_miv_._setupRelation_miv_(this._generic_relation_type_miv_, data._id_miv_, data._parent_miv_, data._property_miv_, data._index_miv_, data._paginationIndex_miv_, creation, assignment, data._copyOf_miv_, data._target_miv_);
+        }
+        return new MRelation_1.MRelation(this._rData_miv_);
+    }
+    _createRelation_miv_(data, creation, assignment) {
+        const crt = this._rTypesFetcher_miv_.get(data._type_miv_);
+        let result;
+        if (crt === undefined) {
+            result = this._makeGenericRelation_miv_(data, creation, assignment, false);
+        }
+        else {
+            this._rData_miv_._setupRelation_miv_(crt, data._id_miv_, data._parent_miv_, data._property_miv_, data._index_miv_, data._paginationIndex_miv_, creation, assignment, data._copyOf_miv_, data._target_miv_);
+            result = crt._create_miv_(this._rData_miv_);
+            if (result === undefined) {
+                result = this._makeGenericRelation_miv_(data, creation, assignment, true);
+            }
+        }
+        this._constructingObject_miv_ = undefined;
+        return result;
+    }
+    async _receiveMessage(msg) {
+        const token = await this.TakeLockAsync();
+        await this._executeSingleDataMessage_miv_(msg, undefined);
+        if (msg._customPayload_miv_ !== undefined && msg._customPayload_miv_.byteLength > 0)
+            this.HandleBroadcast(msg._customPayload_miv_, token);
+        this.ReleaseLock();
+        this.ExecuteViewUpdateOnUIThread();
+    }
+    HandleBroadcast(payload, lockToken) { }
+    _manageObjectData_miv_(list, count) {
+        for (let i = 0; i < count; i++) {
+            const data = list._get_miv_(i);
+            const creation = this._getUpdateQuery_miv_(data._creation_miv_);
+            const assignment = this._getUpdateQuery_miv_(data._assignment_miv_);
+            let c = this._children_miv_.get(data._id_miv_);
+            if (c === undefined) {
+                c = data._createClient_miv_(this, assignment, creation);
+                if (c !== undefined) {
+                    this._children_miv_.set(data._id_miv_, c);
+                    this._newChildren_miv_._add_miv_(c);
+                }
+            }
+            else {
+                c._update_miv_(data, assignment);
+            }
+        }
+    }
+    _getUpdateQuery_miv_(id) {
+        let qi = this._queriesTMP_miv_.get(id);
+        if (qi === undefined) {
+            qi = this._queries_miv_.get(id);
+        }
+        return qi;
+    }
+    _executeDataMessageWithinSetOfMessages_miv_(msg) {
+        for (let i = 0; i < msg._queries_miv_._count_miv_; i++) {
+            const qd = msg._queries_miv_._list_miv_._get_miv_(i);
+            if (!this._queriesTMP_miv_.has(qd._id_miv_)) {
+                const existing = this._queries_miv_.get(qd._id_miv_);
+                if (existing === undefined) {
+                    const q = new QueryInfo_1.QueryInfo(qd._id_miv_, qd._by_miv_, qd._atUTC_miv_);
+                    this._queries_miv_.set(qd._id_miv_, q);
+                    this._queriesTMP_miv_.set(qd._id_miv_, q);
+                }
+                else {
+                    this._queriesTMP_miv_.set(qd._id_miv_, existing);
+                }
+            }
+        }
+        this._manageObjectData_miv_(msg._children_miv_._list_miv_, msg._children_miv_._count_miv_);
+        this._manageObjectData_miv_(msg._relations_miv_._list_miv_, msg._relations_miv_._count_miv_);
+        for (let i = 0; i < msg._deletions_miv_._count_miv_; i++) {
+            const c = this._children_miv_.get(msg._deletions_miv_._get_miv_(i));
+            if (c !== undefined) {
+                c._markForDestruction_miv_();
+            }
+        }
+        for (let i = 0; i < msg._cleared_miv_._count_miv_; i++) {
+            const v = msg._cleared_miv_._list_miv_._get_miv_(i);
+            this.TryGetObject(v._owner_miv_)?._clear_miv_(v._property_miv_);
+        }
+        for (let i = 0; i < msg._strings_miv_._count_miv_; i++) {
+            const v = msg._strings_miv_._list_miv_._get_miv_(i);
+            this.TryGetObject(v._owner_miv_)?._setString_miv_(v._value_miv_, v._property_miv_, this._getUpdateQuery_miv_(v._assignment_miv_));
+        }
+        for (let i = 0; i < msg._bytes_miv_._count_miv_; i++) {
+            const v = msg._bytes_miv_._list_miv_._get_miv_(i);
+            this.TryGetObject(v._owner_miv_)?._setByte_miv_(v._value_miv_, v._property_miv_, this._getUpdateQuery_miv_(v._assignment_miv_));
+        }
+        for (let i = 0; i < msg._doubles_miv_._count_miv_; i++) {
+            const v = msg._doubles_miv_._list_miv_._get_miv_(i);
+            this.TryGetObject(v._owner_miv_)?._setDouble_miv_(v._value_miv_, v._property_miv_, this._getUpdateQuery_miv_(v._assignment_miv_));
+        }
+        for (let i = 0; i < msg._longs_miv_._count_miv_; i++) {
+            const v = msg._longs_miv_._list_miv_._get_miv_(i);
+            this.TryGetObject(v._owner_miv_)?._setLong_miv_(v._value_miv_, v._property_miv_, this._getUpdateQuery_miv_(v._assignment_miv_));
+        }
+        for (let i = 0; i < msg._ulongs_miv_._count_miv_; i++) {
+            const v = msg._ulongs_miv_._list_miv_._get_miv_(i);
+            this.TryGetObject(v._owner_miv_)?._setUlong_miv_(v._value_miv_, v._property_miv_, this._getUpdateQuery_miv_(v._assignment_miv_));
+        }
+        for (let i = 0; i < msg._datims_miv_._count_miv_; i++) {
+            const v = msg._datims_miv_._list_miv_._get_miv_(i);
+            this.TryGetObject(v._owner_miv_)?._setDateTime_miv_(v._value_utc_miv_, v._property_miv_, this._getUpdateQuery_miv_(v._assignment_miv_));
+        }
+        for (let i = 0; i < msg._blobs_miv_._count_miv_; i++) {
+            const v = msg._blobs_miv_._list_miv_._get_miv_(i);
+            this.TryGetObject(v._owner_miv_)?._setBinary_miv_(v._blob_id_miv_, v._data_length_miv_, v._value_miv_, v._property_miv_, this._getUpdateQuery_miv_(v._assignment_miv_));
+        }
+        this._queriesTMP_miv_.clear();
+    }
+    _executeSingleDataMessage_miv_(msg, virtualUpdate) {
+        this._executeDataMessageWithinSetOfMessages_miv_(msg);
+        return this._finalizeExecuteModel_miv_(virtualUpdate);
+    }
+    _finalizeExecuteModel_miv_(virtualUpdate) {
+        for (let i = 0; i < this._newChildren_miv_._count_miv_; i++) {
+            const nc = this._newChildren_miv_._get_miv_(i);
+            const cu = nc._cUpdate_miv_;
+            const parent = this.TryGetObject(cu._newParentID_miv_);
+            if (parent !== undefined) {
+                cu._setupNewParentAsNewlyCreated_miv_(parent);
+                nc._setupNewParentAsNewlyCreated_miv_(parent);
+            }
+        }
+        this._newChildren_miv_._clear_miv_(256);
+        for (let i = 0; i < this._newRelations_miv_._count_miv_; i++) {
+            this._newRelations_miv_._get_miv_(i)._assignTarget_miv_();
+        }
+        for (let i = 0; i < this._cuCache_miv_._count_miv_; i++) {
+            const cu = this._cuCache_miv_._list_miv_._get_miv_(i);
+            if (!cu._validate_miv_())
+                cu._owner_miv_._markForDestruction_miv_();
+        }
+        for (let i = 0; i < this._newRelations_miv_._count_miv_; i++) {
+            this._newRelations_miv_._get_miv_(i)._validateTarget_miv_();
+        }
+        this._newRelations_miv_._clear_miv_(128);
+        for (let i = 0; i < this._cuCache_miv_._count_miv_; i++) {
+            this._cuCache_miv_._list_miv_._get_miv_(i)._executeDepthUpdate_miv_();
+        }
+        for (let i = 0; i < this._destroyedChildren_miv_._count_miv_; i++) {
+            const c = this._destroyedChildren_miv_._get_miv_(i)._owner_miv_;
+            this._children_miv_.delete(c.ID);
+            c._executeDestruction_miv_();
+        }
+        this._destroyedChildren_miv_._clear_miv_(128);
+        for (let i = 0; i < this._cuCache_miv_._count_miv_; i++) {
+            const cu = this._cuCache_miv_._list_miv_._get_miv_(i);
+            if (!cu._owner_miv_.IsDestroyed)
+                cu._owner_miv_._executeMovement_miv_(cu);
+        }
+        for (let i = 0; i < this._listsChanged_miv_._count_miv_; i++) {
+            this._listsChanged_miv_._get_miv_(i)._finalizeUpdate_miv_();
+        }
+        this._dataUpdate_miv_._executeAndReset_miv_(virtualUpdate);
+        for (let i = 0; i < this._listsChanged_miv_._count_miv_; i++) {
+            this._listsChanged_miv_._get_miv_(i)._clearUpdateMark_miv_();
+        }
+        this._listsChanged_miv_._clear_miv_(64);
+        this._cuCache_miv_._reset_miv_(256);
+        if (this._unloadIDList_miv_._count_miv_ > 0 && this._connection_miv_._isActive_miv_) {
+            const arrID = new Array(this._unloadIDList_miv_._count_miv_);
+            const arrCode = new Array(this._unloadCodeList_miv_._count_miv_);
+            for (let i = 0; i < arrID.length; i++) {
+                arrID[i] = this._unloadIDList_miv_._get_miv_(i);
+                arrCode[i] = this._unloadCodeList_miv_._get_miv_(i);
+            }
+            const uq = new UnloadQuery_1.UnloadQuery(arrID, arrCode);
+            this._unloadIDList_miv_._clear_miv_(8, false);
+            this._unloadCodeList_miv_._clear_miv_(8, false);
+            return this._connection_miv_._unloadAsync_miv_(uq);
+        }
+    }
+    _childDestroyed_miv_(c) {
+        this._children_miv_.delete(c.ID);
+    }
+    _protint_ModelUpdateCompleted_miv_() { this.ModelUpdateCompleted(this._dataUpdate_miv_); }
+    ModelUpdateCompleted(mc) { }
+    async ExecuteVirtualUpdateAsync(virtualUpdate, updateView, lockToken = 0n) {
+        await this.TakeLockAsync(lockToken);
+        await this._executeVirtualUpdateAsync_must_have_lock_miv_(virtualUpdate);
+        if (updateView)
+            this._executeVUpdate_do_not_release_lock_miv();
+        this.ReleaseLock();
+    }
+    _executeVirtualUpdateAsync_must_have_lock_miv_(virtualUpdate) {
+        return this._finalizeExecuteModel_miv_(virtualUpdate);
+    }
+    async ExecuteViewUpdateAsync(lockToken = 0n) {
+        await this.TakeLockAsync(lockToken);
+        this._executeVUpdate_do_not_release_lock_miv();
+        this.ReleaseLock();
+    }
+    ExecuteViewUpdateOnUIThread() {
+        this.ExecuteViewUpdateAsync();
+    }
+    _executeVUpdate_do_not_release_lock_miv() {
+        this._constructing_view_miv_ = undefined;
+        for (let i = 0; i < this._objectsChangedForV_miv_._count_miv_; i++) {
+            const o = this._objectsChangedForV_miv_._get_miv_(i);
+            for (let j = 0; j < o._views_miv_._count_miv_; j++) {
+                o._views_miv_._get_miv_(j)._modelUpdated_miv_();
+            }
+        }
+        while (this._vSetsToPreapare_miv_._count_miv_ > 0) {
+            do {
+                this._vSetsToPreapare_miv_._get_miv_(this._vSetsToPreapare_miv_._count_miv_ - 1)._prepareUpdate_miv_();
+            } while (this._vSetsToPreapare_miv_._count_miv_ > 0);
+            for (let i = 0; i < this._paginationsWithMaybeDestroyed_miv_._count_miv_; i++) {
+                this._paginationsWithMaybeDestroyed_miv_._get_miv_(i)._computeToDestroy_miv_();
+            }
+            this._paginationsWithMaybeDestroyed_miv_._clear_miv_(32);
+        }
+        for (let i = 0; i < this._vSetsUpdated_miv_._count_miv_; i++) {
+            this._vSetsUpdated_miv_._get_miv_(i)._computeUpdate_miv_();
+        }
+        for (let i = 0; i < this._vSetsUpdated_miv_._count_miv_; i++) {
+            this._vSetsUpdated_miv_._get_miv_(i)._executeUpdate_miv_(this._viewUpdate_miv_);
+        }
+        for (let i = 0; i < this._vWithModelUpdated_miv_._count_miv_; i++) {
+            this._vWithModelUpdated_miv_._get_miv_(i)._executeModelUpdated_miv_(this._viewUpdate_miv_);
+        }
+        for (let i = 0; i < this._vStatusChanged_miv_._count_miv_; i++) {
+            this._vStatusChanged_miv_._get_miv_(i)._executeStatusUpdate_miv_(this._viewUpdate_miv_);
+        }
+        for (let i = 0; i < this._fieldsChangedForV_miv_._count_miv_; i++) {
+            this._fieldsChangedForV_miv_._get_miv_(i)._executeVChanged_miv_(this._viewUpdate_miv_);
+        }
+        for (let i = 0; i < this._uwTriggered_miv_._count_miv_; i++) {
+            this._uwTriggered_miv_._get_miv_(i)._executeTriggered_miv_(this._viewUpdate_miv_);
+        }
+        for (let i = 0; i < this._vStatusChanged_miv_._count_miv_; i++) {
+            this._vStatusChanged_miv_._get_miv_(i)._clearStatusUpdate_miv_();
+        }
+        for (let i = 0; i < this._vIndexChanged_miv_._count_miv_; i++) {
+            this._vIndexChanged_miv_._get_miv_(i)._protint_IndexChanged_miv_(this._viewUpdate_miv_);
+        }
+        this._viewUpdate_miv_._executeAndReset_miv_();
+        for (let i = 0; i < this._objectsChangedForV_miv_._count_miv_; i++) {
+            this._objectsChangedForV_miv_._get_miv_(i)._clearVChangedMark_miv_();
+        }
+        this._objectsChangedForV_miv_._clear_miv_(128);
+        for (let i = 0; i < this._fieldsChangedForV_miv_._count_miv_; i++) {
+            this._fieldsChangedForV_miv_._get_miv_(i)._clearVChangedMark_miv_();
+        }
+        this._fieldsChangedForV_miv_._clear_miv_(256);
+        for (let i = 0; i < this._uwTriggered_miv_._count_miv_; i++) {
+            this._uwTriggered_miv_._get_miv_(i)._clearTriggerMark_miv_();
+        }
+        this._uwTriggered_miv_._clear_miv_(16);
+        this._vWithModelUpdated_miv_._clear_miv_(256);
+        this._vStatusChanged_miv_._clear_miv_(256);
+        this._vSetsUpdated_miv_._clear_miv_(128);
+        this._vIndexChanged_miv_._clear_miv_(128);
+    }
+    _protint_ViewUpdateCompleted_miv_(vc) { this.ViewUpdateCompleted(vc); }
+    ViewUpdateCompleted(vc) { }
+    _creatingVBound_miv_(vs) {
+        this._owner_set_miv_ = vs;
+    }
+    _vBoundCreating_miv_() {
+        if (this._owner_set_miv_ === undefined) {
+            this._constructing_view_miv_ = undefined;
+            throw new Error("you cannot create a VBoundObject outside of a VSet update");
+        }
+        else {
+            return this._owner_set_miv_;
+        }
+    }
+    _vBoundCreated_miv_() {
+        this._constructing_view_miv_ = undefined;
+        this._owner_set_miv_ = undefined;
+    }
+}
+exports.MIVClient = MIVClient;
+MIVClient.TOKEN_BASE_miv_ = 111n;
+MIVClient.EMPTY_RESPONSE_PAYLOAD = new ArrayBuffer(0);
+MIVClient.MAX_CUSTOM_READ_REQUEST_LENGTH = 32768;
+//# sourceMappingURL=MIVClient.js.map