@1oo4/miv 1.0.0

package/dist/Client/AuditTrail.js

@@ -0,0 +1,705 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditTrailHandler = exports.AuditTrailReport = exports.AuditTrailQueryPerObject = exports.ATVDateTime = exports.ATVByte = exports.ATVBinary = exports.ATVDouble = exports.ATVLong = exports.ATVString = exports.ATValue = exports.ATIRelationReassigned = exports.ATIChildReassigned = exports.ATIRelationDeleted = exports.ATIChildDeleted = exports.ATIRelationCreated = exports.ATIChildCreated = exports.AuditTrailItem = exports.AuditTrailQuery = exports.AuditTrailObjectInfo = void 0;
+const ErrorMessage_1 = require("../Communication/ErrorMessage");
+const Query_1 = require("../Communication/Query");
+const MIVConstants_1 = require("../MIVConstants");
+const MIVValueTypes_1 = require("../MIVValueTypes");
+class AuditTrailObjectInfo {
+    get Type() { return this._type_private_; }
+    ;
+    constructor(id, type, name) {
+        this.ID = id;
+        this.TypeID = type;
+        this.Name = name;
+        this.AllEvents = new Array();
+        this.Queries = new Array();
+        this.DisplayName = name;
+    }
+    static _deserialize_miv_(deser) {
+        const id = deser.ReadInt64();
+        if (id === undefined)
+            return undefined;
+        const type = deser.ReadUint16();
+        if (type === undefined)
+            return undefined;
+        const name = deser.ReadString();
+        if (name === undefined)
+            return undefined;
+        return new AuditTrailObjectInfo(id, type, name);
+    }
+    _newEvent_miv_(evt) {
+        this.AllEvents.push(evt);
+    }
+    _pack_miv_(client) {
+        this._type_private_ = client.TryGetType(this.TypeID);
+        if (this._type_private_ === undefined) {
+            this.DisplayTypeName = this.TypeID.toString();
+        }
+        else {
+            this.DisplayTypeName = this._type_private_.Name ?? this.TypeID.toString();
+        }
+        this.AllEvents.sort((x, y) => {
+            if (x.Query.AtUTC < y.Query.AtUTC) {
+                return 1;
+            }
+            else if (x.Query.AtUTC > y.Query.AtUTC) {
+                return -1;
+            }
+            else {
+                if (x.Query.ID < y.Query.ID) {
+                    return 1;
+                }
+                else if (x.Query.ID > y.Query.ID) {
+                    return -1;
+                }
+                else {
+                    return x.order - y.order;
+                }
+            }
+        });
+        let last = undefined;
+        for (let i = 0; i < this.AllEvents.length; i++) {
+            const evt = this.AllEvents[i];
+            if (last === undefined || last.Query != evt.Query) {
+                last = new AuditTrailQueryPerObject(evt.Query);
+                this.Queries.push(last);
+            }
+            last.Events.push(evt);
+        }
+    }
+}
+exports.AuditTrailObjectInfo = AuditTrailObjectInfo;
+class AuditTrailQuery {
+    constructor(id, by, atUTC) {
+        this.ID = id;
+        this.By = by;
+        this.AtUTC = atUTC;
+        this.Items = new Array();
+    }
+    static _deserialize_miv_(deser) {
+        const id = deser.ReadInt64();
+        if (id === undefined)
+            return undefined;
+        const by = deser.ReadInt64();
+        if (by === undefined)
+            return undefined;
+        const at = deser.ReadDateTimeUTC();
+        if (at === undefined)
+            return undefined;
+        return new AuditTrailQuery(id, by, at);
+    }
+    _newItem_miv_(i) {
+        this.Items.push(i);
+    }
+    _pack_miv_() {
+        this.Items.sort((x, y) => {
+            if (x.Query.AtUTC < y.Query.AtUTC) {
+                return 1;
+            }
+            else if (x.Query.AtUTC > y.Query.AtUTC) {
+                return -1;
+            }
+            else {
+                return x.order - y.order;
+            }
+        });
+    }
+    _packEvents_miv_(client) {
+        for (let i = 0; i < this.Items.length; i++) {
+            this.Items[i]._pack_miv_(client);
+        }
+    }
+}
+exports.AuditTrailQuery = AuditTrailQuery;
+class AuditTrailItem {
+    constructor(q) {
+        this.Query = q;
+    }
+    static _deserialize_miv_(q, deser, oFetcher) {
+        const kind = deser.ReadUint8();
+        if (kind === undefined)
+            return false;
+        switch (kind) {
+            case AuditTrailItem.KIND_CHILD_CREATED: return ATIChildCreated._deserializeChild_miv_(q, deser, oFetcher);
+            case AuditTrailItem.KIND_RELATION_CREATED: return ATIRelationCreated._deserializeRelation_miv_(q, deser, oFetcher);
+            case AuditTrailItem.KIND_CHILD_DELETED: return ATIChildDeleted._deserializeChild_miv_(q, deser, oFetcher);
+            case AuditTrailItem.KIND_RELATION_DELETED: return ATIRelationDeleted._deserializeRelation_miv_(q, deser, oFetcher);
+            case AuditTrailItem.KIND_CHILD_REASSIGNED: return ATIChildReassigned._deserializeChild_miv_(q, deser, oFetcher);
+            case AuditTrailItem.KIND_RELATION_REASSIGNED: return ATIRelationReassigned._deserializeRelation_miv_(q, deser, oFetcher);
+            default: return ATValue._deserializeValue_miv_(q, deser, kind, oFetcher);
+        }
+    }
+}
+exports.AuditTrailItem = AuditTrailItem;
+AuditTrailItem.KIND_CHILD_CREATED = 1;
+AuditTrailItem.KIND_RELATION_CREATED = 2;
+AuditTrailItem.KIND_CHILD_DELETED = 3;
+AuditTrailItem.KIND_RELATION_DELETED = 4;
+AuditTrailItem.KIND_CHILD_REASSIGNED = 5;
+AuditTrailItem.KIND_RELATION_REASSIGNED = 6;
+AuditTrailItem.KIND_STRING = 7;
+AuditTrailItem.KIND_LONG = 8;
+AuditTrailItem.KIND_DOUBLE = 9;
+AuditTrailItem.KIND_BINARY = 10;
+AuditTrailItem.KIND_BYTE = 11;
+AuditTrailItem.KIND_DATETIME = 12;
+AuditTrailItem.ORDER_OFFSET = 65536;
+class ATIChildCreated extends AuditTrailItem {
+    get ChildrenSet() { return this._set_miv_; }
+    constructor(q, parent, createdInfo, property) {
+        super(q);
+        this.Parent = parent;
+        this.CreatedInfo = createdInfo;
+        this.Property = property;
+        parent._newEvent_miv_(this);
+        createdInfo._newEvent_miv_(this);
+    }
+    _handledBy_miv_(h) {
+        return h.HandleChildCreated(this);
+    }
+    static _deserializeChild_miv_(q, deser, oFetcher) {
+        const parentID = deser.ReadInt64();
+        if (parentID === undefined)
+            return false;
+        const childID = deser.ReadInt64();
+        if (childID === undefined)
+            return false;
+        const property = deser.ReadUint16();
+        if (property === undefined)
+            return false;
+        const parent = oFetcher.get(parentID);
+        const child = oFetcher.get(childID);
+        if (parent !== undefined && child !== undefined) {
+            new ATIChildCreated(q, parent, child, property);
+        }
+        return true;
+    }
+    get order() {
+        return this.CreatedInfo.TypeID;
+    }
+    _pack_miv_(client) {
+        if (this.Parent.Type !== undefined && this.CreatedInfo.Type !== undefined) {
+            this._set_miv_ = this.Parent.Type.TryGetChildrenInfo(this.Property, this.CreatedInfo.Type);
+        }
+    }
+}
+exports.ATIChildCreated = ATIChildCreated;
+class ATIRelationCreated extends ATIChildCreated {
+    constructor(q, parent, createdInfo, property, target) {
+        super(q, parent, createdInfo, property);
+        this.Target = target;
+    }
+    _handledBy_miv_(h) {
+        return h.HandleRelationCreated(this);
+    }
+    static _deserializeRelation_miv_(q, deser, oFetcher) {
+        const parentID = deser.ReadInt64();
+        if (parentID === undefined)
+            return false;
+        const childID = deser.ReadInt64();
+        if (childID === undefined)
+            return false;
+        const property = deser.ReadUint16();
+        if (property === undefined)
+            return false;
+        const targetID = deser.ReadInt64();
+        if (targetID === undefined)
+            return false;
+        const parent = oFetcher.get(parentID);
+        const child = oFetcher.get(childID);
+        if (parent !== undefined && child !== undefined) {
+            const target = oFetcher.get(targetID);
+            new ATIRelationCreated(q, parent, child, property, target);
+        }
+        return true;
+    }
+    get order() {
+        return AuditTrailItem.ORDER_OFFSET + this.CreatedInfo.TypeID;
+    }
+}
+exports.ATIRelationCreated = ATIRelationCreated;
+class ATIChildDeleted extends AuditTrailItem {
+    get ChildrenSet() { return this._set_miv_; }
+    constructor(q, parent, deletedInfo, property) {
+        super(q);
+        this.Parent = parent;
+        this.DeletedInfo = deletedInfo;
+        this.Property = property;
+        parent._newEvent_miv_(this);
+        deletedInfo._newEvent_miv_(this);
+    }
+    _handledBy_miv_(h) {
+        return h.HandleChildDeleted(this);
+    }
+    static _deserializeChild_miv_(q, deser, oFetcher) {
+        const parentID = deser.ReadInt64();
+        if (parentID === undefined)
+            return false;
+        const childID = deser.ReadInt64();
+        if (childID === undefined)
+            return false;
+        const property = deser.ReadUint32();
+        if (property === undefined)
+            return false;
+        const parent = oFetcher.get(parentID);
+        const child = oFetcher.get(childID);
+        if (parent !== undefined && child !== undefined) {
+            new ATIChildDeleted(q, parent, child, property);
+        }
+        return true;
+    }
+    get order() {
+        return AuditTrailItem.ORDER_OFFSET * 9 + this.DeletedInfo.TypeID;
+    }
+    _pack_miv_(client) {
+        if (this.Parent.Type !== undefined && this.DeletedInfo.Type !== undefined) {
+            this._set_miv_ = this.Parent.Type.TryGetChildrenInfo(this.Property, this.DeletedInfo.Type);
+        }
+    }
+}
+exports.ATIChildDeleted = ATIChildDeleted;
+class ATIRelationDeleted extends ATIChildDeleted {
+    constructor(q, parent, deletedInfo, property, target) {
+        super(q, parent, deletedInfo, property);
+        this.Target = target;
+    }
+    _handledBy_miv_(h) {
+        return h.HandleRelationDeleted(this);
+    }
+    static _deserializeRelation_miv_(q, deser, oFetcher) {
+        const parentID = deser.ReadInt64();
+        if (parentID === undefined)
+            return false;
+        const childID = deser.ReadInt64();
+        if (childID === undefined)
+            return false;
+        const property = deser.ReadUint32();
+        if (property === undefined)
+            return false;
+        const targetID = deser.ReadInt64();
+        if (targetID === undefined)
+            return false;
+        const parent = oFetcher.get(parentID);
+        const child = oFetcher.get(childID);
+        if (parent !== undefined && child !== undefined) {
+            const target = oFetcher.get(targetID);
+            new ATIRelationDeleted(q, parent, child, property, target);
+        }
+        return true;
+    }
+    get order() {
+        return AuditTrailItem.ORDER_OFFSET * 10 + this.DeletedInfo.TypeID;
+    }
+}
+exports.ATIRelationDeleted = ATIRelationDeleted;
+class ATIChildReassigned extends AuditTrailItem {
+    get OldChildren() { return this._oldset_miv_; }
+    get NewChildren() { return this._newset_miv_; }
+    constructor(q, oldParent, oldProperty, newParent, newProperty, reassignedInfo) {
+        super(q);
+        this.OldParent = oldParent;
+        this.OldProperty = oldProperty;
+        this.NewParent = newParent;
+        this.NewProperty = newProperty;
+        this.ReassignedInfo = reassignedInfo;
+        oldParent._newEvent_miv_(this);
+        newParent._newEvent_miv_(this);
+        reassignedInfo._newEvent_miv_(this);
+    }
+    _handledBy_miv_(h) {
+        return h.HandleChildReassigned(this);
+    }
+    static _deserializeChild_miv_(q, deser, oFetcher) {
+        const oldParentID = deser.ReadInt64();
+        if (oldParentID === undefined)
+            return false;
+        const oldProperty = deser.ReadUint16();
+        if (oldProperty === undefined)
+            return false;
+        const newParentID = deser.ReadInt64();
+        if (newParentID === undefined)
+            return false;
+        const newProperty = deser.ReadUint16();
+        if (newProperty === undefined)
+            return false;
+        const childID = deser.ReadInt64();
+        if (childID === undefined)
+            return false;
+        const oldParent = oFetcher.get(oldParentID);
+        const newParent = oFetcher.get(newParentID);
+        const child = oFetcher.get(childID);
+        if (oldParent !== undefined && newParent !== undefined && child !== undefined) {
+            new ATIChildReassigned(q, oldParent, oldProperty, newParent, newProperty, child);
+        }
+        return true;
+    }
+    get order() {
+        return AuditTrailItem.ORDER_OFFSET * 11 + this.ReassignedInfo.TypeID;
+    }
+    _pack_miv_(client) {
+        if (this.ReassignedInfo.Type !== undefined) {
+            if (this.OldParent.Type !== undefined) {
+                this._oldset_miv_ = this.OldParent.Type.TryGetChildrenInfo(this.OldProperty, this.ReassignedInfo.Type);
+            }
+            if (this.NewParent.Type !== undefined) {
+                if (this.NewParent.Type == this.OldParent.Type && this.OldProperty == this.NewProperty) {
+                    this._newset_miv_ = this._oldset_miv_;
+                }
+                else {
+                    this._newset_miv_ = this.NewParent.Type.TryGetChildrenInfo(this.NewProperty, this.ReassignedInfo.Type);
+                }
+            }
+        }
+    }
+}
+exports.ATIChildReassigned = ATIChildReassigned;
+class ATIRelationReassigned extends ATIChildReassigned {
+    constructor(q, oldParent, oldProperty, newParent, newProperty, reassignedInfo, target) {
+        super(q, oldParent, oldProperty, newParent, newProperty, reassignedInfo);
+        this.Target = target;
+    }
+    _handledBy_miv_(h) {
+        return h.HandleRelationReassigned(this);
+    }
+    static _deserializeRelation_miv_(q, deser, oFetcher) {
+        const oldParentID = deser.ReadInt64();
+        if (oldParentID === undefined)
+            return false;
+        const oldProperty = deser.ReadUint16();
+        if (oldProperty === undefined)
+            return false;
+        const newParentID = deser.ReadInt64();
+        if (newParentID === undefined)
+            return false;
+        const newProperty = deser.ReadUint16();
+        if (newProperty === undefined)
+            return false;
+        const childID = deser.ReadInt64();
+        if (childID === undefined)
+            return false;
+        const targetID = deser.ReadInt64();
+        if (targetID === undefined)
+            return false;
+        const oldParent = oFetcher.get(oldParentID);
+        const newParent = oFetcher.get(newParentID);
+        const child = oFetcher.get(childID);
+        if (oldParent !== undefined && newParent !== undefined && child !== undefined) {
+            const target = oFetcher.get(targetID);
+            new ATIRelationReassigned(q, oldParent, oldProperty, newParent, newProperty, child, target);
+        }
+        return true;
+    }
+    get order() {
+        return AuditTrailItem.ORDER_OFFSET * 12 + this.ReassignedInfo.TypeID;
+    }
+}
+exports.ATIRelationReassigned = ATIRelationReassigned;
+class ATValue extends AuditTrailItem {
+    constructor(q, owner, property) {
+        super(q);
+        this.Owner = owner;
+        this.Property = property;
+        owner._newEvent_miv_(this);
+    }
+    static _deserializeValue_miv_(q, deser, kind, oFetcher) {
+        const ownerID = deser.ReadInt64();
+        if (ownerID === undefined)
+            return false;
+        const property = deser.ReadUint16();
+        if (property === undefined)
+            return false;
+        const owner = oFetcher.get(ownerID);
+        switch (kind) {
+            case AuditTrailItem.KIND_STRING: return ATVString._deserializeString_miv_(q, deser, owner, property);
+            case AuditTrailItem.KIND_LONG: return ATVLong._deserializeLong_miv_(q, deser, owner, property);
+            case AuditTrailItem.KIND_DOUBLE: return ATVDouble._deserializeDouble_miv_(q, deser, owner, property);
+            case AuditTrailItem.KIND_BINARY: return ATVBinary._deserializeBinary_miv_(q, deser, owner, property);
+            case AuditTrailItem.KIND_BYTE: return ATVByte._deserializeByte_miv_(q, deser, owner, property);
+            case AuditTrailItem.KIND_DATETIME: return ATVDateTime._deserializeDateTime_miv_(q, deser, owner, property);
+            default: return false;
+        }
+    }
+    _pack_miv_(client) {
+        this._info_miv_ = this.Owner.Type?.TryGetPropertyInfo(this.Property);
+    }
+}
+exports.ATValue = ATValue;
+class ATVString extends ATValue {
+    constructor(q, owner, property, value, oldValue) {
+        super(q, owner, property);
+        this.Value = value;
+        this.OldValue = oldValue;
+    }
+    _handledBy_miv_(h) {
+        return h.HandleString(this);
+    }
+    static _deserializeString_miv_(q, deser, owner, property) {
+        const value = deser.ReadString();
+        if (value === undefined)
+            return false;
+        const oldValue = deser.ReadString();
+        if (oldValue === undefined)
+            return false;
+        if (owner !== undefined) {
+            new ATVString(q, owner, property, value, oldValue);
+        }
+        return true;
+    }
+    get order() {
+        if (this.Property == MIVConstants_1.MIVConstants.PROPERTY_NAME)
+            return AuditTrailItem.ORDER_OFFSET * 2 + this.Owner.TypeID;
+        else
+            return AuditTrailItem.ORDER_OFFSET * 4 + this.Property;
+    }
+    GetKind() {
+        return MIVValueTypes_1.MIVValueTypes.STRING;
+    }
+}
+exports.ATVString = ATVString;
+class ATVLong extends ATValue {
+    constructor(q, owner, property, value, oldValue) {
+        super(q, owner, property);
+        this.Value = value;
+        this.OldValue = oldValue;
+    }
+    _handledBy_miv_(h) {
+        return h.HandleLong(this);
+    }
+    static _deserializeLong_miv_(q, deser, owner, property) {
+        const value = deser.ReadInt64();
+        if (value === undefined)
+            return false;
+        const oldValue = deser.ReadInt64();
+        if (oldValue === undefined)
+            return false;
+        if (owner !== undefined) {
+            new ATVLong(q, owner, property, value, oldValue);
+        }
+        return true;
+    }
+    get order() {
+        return AuditTrailItem.ORDER_OFFSET * 5 + this.Property;
+    }
+    GetKind() {
+        return MIVValueTypes_1.MIVValueTypes.LONG;
+    }
+}
+exports.ATVLong = ATVLong;
+class ATVDouble extends ATValue {
+    constructor(q, owner, property, value, oldValue) {
+        super(q, owner, property);
+        this.Value = value;
+        this.OldValue = oldValue;
+    }
+    _handledBy_miv_(h) {
+        return h.HandleDouble(this);
+    }
+    static _deserializeDouble_miv_(q, deser, owner, property) {
+        const value = deser.ReadFloat64();
+        if (value === undefined)
+            return false;
+        const oldValue = deser.ReadFloat64();
+        if (oldValue === undefined)
+            return false;
+        if (owner !== undefined) {
+            new ATVDouble(q, owner, property, value, oldValue);
+        }
+        return true;
+    }
+    get order() {
+        return AuditTrailItem.ORDER_OFFSET * 6 + this.Property;
+    }
+    GetKind() {
+        return MIVValueTypes_1.MIVValueTypes.DOUBLE;
+    }
+}
+exports.ATVDouble = ATVDouble;
+class ATVBinary extends ATValue {
+    constructor(q, owner, property, bytes, oldBytes) {
+        super(q, owner, property);
+        this.Bytes = bytes;
+        this.OldBytes = oldBytes;
+    }
+    _handledBy_miv_(h) {
+        return h.HandleBinary(this);
+    }
+    static _deserializeBinary_miv_(q, deser, owner, property) {
+        const bytes = deser.ReadInt32();
+        if (bytes === undefined)
+            return false;
+        const oldBytes = deser.ReadInt32();
+        if (oldBytes === undefined)
+            return false;
+        if (owner !== undefined) {
+            new ATVBinary(q, owner, property, bytes, oldBytes);
+        }
+        return true;
+    }
+    get order() {
+        return AuditTrailItem.ORDER_OFFSET * 8 + this.Property;
+    }
+    GetKind() {
+        return MIVValueTypes_1.MIVValueTypes.BINARY;
+    }
+}
+exports.ATVBinary = ATVBinary;
+class ATVByte extends ATValue {
+    constructor(q, owner, property, value, oldValue) {
+        super(q, owner, property);
+        this.Value = value;
+        this.OldValue = oldValue;
+    }
+    _handledBy_miv_(h) {
+        return h.HandleByte(this);
+    }
+    static _deserializeByte_miv_(q, deser, owner, property) {
+        const value = deser.ReadUint8();
+        if (value === undefined)
+            return false;
+        const oldValue = deser.ReadUint8();
+        if (oldValue === undefined)
+            return false;
+        if (owner !== undefined) {
+            new ATVByte(q, owner, property, value, oldValue);
+        }
+        return true;
+    }
+    get order() {
+        return AuditTrailItem.ORDER_OFFSET * 3 + this.Property;
+    }
+    GetKind() {
+        return MIVValueTypes_1.MIVValueTypes.BYTE;
+    }
+}
+exports.ATVByte = ATVByte;
+class ATVDateTime extends ATValue {
+    constructor(q, owner, property, valueUTC, oldValueUTC) {
+        super(q, owner, property);
+        this.ValueUTC = valueUTC;
+        this.OldValueUTC = oldValueUTC;
+    }
+    _handledBy_miv_(h) {
+        return h.HandleDateTime(this);
+    }
+    static _deserializeDateTime_miv_(q, deser, owner, property) {
+        const value = deser.ReadDateTimeUTC();
+        if (value === undefined)
+            return false;
+        const oldValue = deser.ReadDateTimeUTC();
+        if (oldValue === undefined)
+            return false;
+        if (owner !== undefined) {
+            new ATVDateTime(q, owner, property, value, oldValue);
+        }
+        return true;
+    }
+    get order() {
+        return AuditTrailItem.ORDER_OFFSET * 7 + this.Property;
+    }
+    GetKind() {
+        return MIVValueTypes_1.MIVValueTypes.DATETIME;
+    }
+}
+exports.ATVDateTime = ATVDateTime;
+class AuditTrailQueryPerObject {
+    constructor(query) {
+        this.Query = query;
+        this.Events = new Array();
+    }
+}
+exports.AuditTrailQueryPerObject = AuditTrailQueryPerObject;
+class AuditTrailReport {
+    constructor(error, objects, queries) {
+        this.Error = error;
+        this.AllObjects = objects;
+        this.Queries = queries;
+        this.ObjectsWithEvents = new Array();
+    }
+    static _makeError_miv_(error) {
+        return new AuditTrailReport(error, new Array(), new Array());
+    }
+    _pack_miv_(client) {
+        this.Queries.sort((x, y) => { if (x.AtUTC <= y.AtUTC)
+            return 1;
+        else
+            return -1; });
+        for (let i = 0; i < this.Queries.length; i++) {
+            this.Queries[i]._pack_miv_();
+        }
+        for (let i = 0; i < this.AllObjects.length; i++) {
+            const obj = this.AllObjects[i];
+            obj._pack_miv_(client);
+            if (obj.AllEvents.length > 0) {
+                this.ObjectsWithEvents.push(obj);
+            }
+        }
+        for (let i = 0; i < this.Queries.length; i++) {
+            this.Queries[i]._packEvents_miv_(client);
+        }
+    }
+    static _serializeAuditTrailQuery_miv_(ser, root, depth, fromUTC, allowTypes, types) {
+        ser.WriteUint8(Query_1.Query.KIND_AUDIT_TRAIL);
+        ser.WriteInt64(root);
+        ser.WriteInt32(depth);
+        ser.WriteDateTimeUTC(fromUTC);
+        if (allowTypes)
+            ser.WriteInt32(types.length);
+        else
+            ser.WriteInt32(-types.length);
+        for (let i = 0; i < types.length; i++) {
+            ser.WriteUint16(types[i]);
+        }
+    }
+    static _serializeAuditTrailByUserQuery_miv_(ser, ofUser, fromUTC) {
+        ser.WriteUint8(Query_1.Query.KIND_AUDIT_TRAIL_BY_USER);
+        ser.WriteInt64(ofUser);
+        ser.WriteDateTimeUTC(fromUTC);
+    }
+    static _deserialize_miv_(deser) {
+        const hasError = deser.ReadUint8();
+        if (hasError === undefined)
+            return undefined;
+        const error = hasError ? ErrorMessage_1.ErrorMessage._deserializeError_miv_(deser) : undefined;
+        if (hasError && error === undefined)
+            return undefined;
+        const oCount = deser.ReadInt32();
+        if (oCount === undefined)
+            return undefined;
+        const oFetcher = new Map();
+        for (let i = 0; i < oCount; i++) {
+            const x = AuditTrailObjectInfo._deserialize_miv_(deser);
+            if (x === undefined)
+                return undefined;
+            oFetcher.set(x.ID, x);
+        }
+        const qCount = deser.ReadInt32();
+        if (qCount === undefined)
+            return undefined;
+        const qArray = new Array();
+        for (let i = 0; i < qCount; i++) {
+            const x = AuditTrailQuery._deserialize_miv_(deser);
+            if (x === undefined)
+                return undefined;
+            qArray.push(x);
+            const iCount = deser.ReadInt32();
+            if (iCount === undefined)
+                return undefined;
+            for (let j = 0; j < iCount; j++) {
+                if (!AuditTrailItem._deserialize_miv_(x, deser, oFetcher))
+                    return undefined;
+            }
+        }
+        return new AuditTrailReport(error, Array.from(oFetcher.values()), qArray);
+    }
+}
+exports.AuditTrailReport = AuditTrailReport;
+class AuditTrailHandler {
+    constructor() {
+    }
+    Handle(item) {
+        return item._handledBy_miv_(this);
+    }
+}
+exports.AuditTrailHandler = AuditTrailHandler;
+//# sourceMappingURL=AuditTrail.js.map