@1oo4/miv 1.0.0

package/dist/src/Communication/ErrorMessage.js

@@ -0,0 +1,943 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateErrorMessage = exports.DataTooLarge = exports.PropertyAccessDenied = exports.InvalidCustomReadRequest = exports.PasswordChangeRequired = exports.TooManyRequests = exports.CumulativeRequestsTooLong = exports.RequestTooLong = exports.ConnectionLost = exports.ExceptionErrorMessage = exports.TextualErrorMessage = exports.LoadExcess = exports.InvalidCredentials = exports.ObjectAccessDenied = exports.UnexpectedErrorMessage = exports.UserManagementError = exports.UnloadedChildren = exports.MultipleValues = exports.MultipleRelation = exports.MultipleReassignment = exports.ForbiddenProperty = exports.DeletedAndModified = exports.BeyondMaxDepth = exports.RootReassignment = exports.RootDeletion = exports.RootCopy = exports.InvalidCustomWriteRequest = exports.InvalidTemporaryID = exports.InvalidFlags = exports.InvalidCopyReference = exports.InvalidCopyID = exports.RelationReassignment = exports.RelationBlocking = exports.ReassignmentLoop = exports.NotChild = exports.ForbiddenWrite = exports.ExistingRelationDifferentType = exports.DuplicateUserLogin = exports.BeyondMaxNewChildren = exports.InvalidWriteErrorMessage = exports.RegularWriteErrorMessage = exports.ErroneousWriteErrorMessage = exports.WriteErrorMessage = exports.RegularWriteErrorMessageHandlerDefault = exports.RegularWriteErrorMessageHandler = exports.WriteErrorMessageHandlerDefault = exports.WriteErrorMessageHandler = exports.ErrorMessageHandlerDefault = exports.ErrorMessageHandler = exports.ErrorMessage = void 0;
+exports.CustomErrorMessage = void 0;
+class ErrorMessage {
+    constructor() {
+    }
+    static _deserializeError_miv_(deser) {
+        const errorKind = deser.ReadUint8();
+        if (errorKind === undefined)
+            return undefined;
+        switch (errorKind) {
+            case ErrorMessage.OBJECT_ACCESS_DENIED: return ObjectAccessDenied._deserialize_miv_(deser);
+            case ErrorMessage.UNEXPECTED: return UnexpectedErrorMessage._deserialize_miv_(deser);
+            case ErrorMessage.INVALID_CREDENTIALS: return InvalidCredentials._deserialize_miv_(deser);
+            case ErrorMessage.LOAD_EXCESS: return LoadExcess._deserialize_miv_(deser);
+            case ErrorMessage.TEXTUAL: return TextualErrorMessage._deserialize_miv_(deser);
+            case ErrorMessage.CONNECTION_LOST: return ConnectionLost._deserialize_miv_(deser);
+            case ErrorMessage.REQUEST_TOO_LONG: return RequestTooLong._deserialize_miv_(deser);
+            case ErrorMessage.CUMULATIVE_REQUESTS_TOO_LONG: return CumulativeRequestsTooLong._deserialize_miv_(deser);
+            case ErrorMessage.TOO_MANY_REQUESTS: return TooManyRequests._deserialize_miv_(deser);
+            case ErrorMessage.AGGREGATE: return AggregateErrorMessage._deserialize_miv_(deser);
+            case ErrorMessage.CUSTOM: return CustomErrorMessage._deserialize_miv_(deser);
+            case ErrorMessage.PASSWORD_CHANGE_REQUIRED: return PasswordChangeRequired._deserialize_miv_(deser);
+            case ErrorMessage.INVALID_CUSTOM_READ: return InvalidCustomReadRequest._deserialize_miv_(deser);
+            case ErrorMessage.PROPERTY_ACCESS_DENIED: return PropertyAccessDenied._deserialize_miv_(deser);
+            case ErrorMessage.EXCEPTION: return ExceptionErrorMessage._deserialize_miv_(deser);
+            case ErrorMessage.U_FORBIDDEN: return ForbiddenWrite._deserialize_miv_(deser);
+            case ErrorMessage.U_RELATION_BLOCKING: return RelationBlocking._deserialize_miv_(deser);
+            case ErrorMessage.U_EXISTING_RELATION: return ExistingRelationDifferentType._deserialize_miv_(deser);
+            case ErrorMessage.U_BEYOND_MAX_NEW_CHILDREN: return BeyondMaxNewChildren._deserialize_miv_(deser);
+            case ErrorMessage.U_UNLOADED: return UnloadedChildren._deserialize_miv_(deser);
+            case ErrorMessage.U_DELETED_AND_MODIFIED: return DeletedAndModified._deserialize_miv_(deser);
+            case ErrorMessage.U_MULTI_VALUES: return MultipleValues._deserialize_miv_(deser);
+            case ErrorMessage.U_MULTI_REASSIGN: return MultipleReassignment._deserialize_miv_(deser);
+            case ErrorMessage.U_MULTI_RELATION: return MultipleRelation._deserialize_miv_(deser);
+            case ErrorMessage.U_REASSIGN_LOOP: return ReassignmentLoop._deserialize_miv_(deser);
+            case ErrorMessage.U_BEYOND_MAX_DEPTH: return BeyondMaxDepth._deserialize_miv_(deser);
+            case ErrorMessage.U_RELATION_REASSIGNMENT: return RelationReassignment._deserialize_miv_(deser);
+            case ErrorMessage.U_NOT_CHILD: return NotChild._deserialize_miv_(deser);
+            case ErrorMessage.U_INVALID_FLAGS: return InvalidFlags._deserialize_miv_(deser);
+            case ErrorMessage.U_INVALID_TEMPID: return InvalidTemporaryID._deserialize_miv_(deser);
+            case ErrorMessage.U_INVALID_COPY_ID: return InvalidCopyID._deserialize_miv_(deser);
+            case ErrorMessage.U_INVALID_COPY_REF: return InvalidCopyReference._deserialize_miv_(deser);
+            case ErrorMessage.U_ROOT_COPY: return RootCopy._deserialize_miv_(deser);
+            case ErrorMessage.U_ROOT_DELETION: return RootDeletion._deserialize_miv_(deser);
+            case ErrorMessage.U_ROOT_REASSIGN: return RootReassignment._deserialize_miv_(deser);
+            case ErrorMessage.U_USER: return UserManagementError._deserialize_miv_(deser);
+            case ErrorMessage.U_DUPLICATE_LOGIN: return DuplicateUserLogin._deserialize_miv_(deser);
+            case ErrorMessage.U_FORBIDDEN_PROPERTY: return ForbiddenProperty._deserialize_miv_(deser);
+            case ErrorMessage.U_DATA_TOO_LARGE: return DataTooLarge._deserialize_miv_(deser);
+            case ErrorMessage.U_INVALID_CUSTOM_WRITE: return InvalidCustomWriteRequest._deserialize_miv_(deser);
+            default:
+                return undefined;
+        }
+    }
+}
+exports.ErrorMessage = ErrorMessage;
+ErrorMessage.UNEXPECTED = 1;
+ErrorMessage.OBJECT_ACCESS_DENIED = 2;
+ErrorMessage.INVALID_CREDENTIALS = 3;
+ErrorMessage.LOAD_EXCESS = 4;
+ErrorMessage.TEXTUAL = 5;
+ErrorMessage.U_BEYOND_MAX_DEPTH = 6;
+ErrorMessage.U_BEYOND_MAX_NEW_CHILDREN = 7;
+ErrorMessage.U_DELETED_AND_MODIFIED = 8;
+ErrorMessage.U_EXISTING_RELATION = 9;
+ErrorMessage.U_FORBIDDEN = 10;
+ErrorMessage.U_INVALID_COPY_ID = 11;
+ErrorMessage.U_INVALID_COPY_REF = 12;
+ErrorMessage.U_INVALID_FLAGS = 13;
+ErrorMessage.U_INVALID_TEMPID = 14;
+ErrorMessage.U_MULTI_REASSIGN = 15;
+ErrorMessage.U_MULTI_RELATION = 16;
+ErrorMessage.U_MULTI_VALUES = 17;
+ErrorMessage.U_NOT_CHILD = 18;
+ErrorMessage.U_REASSIGN_LOOP = 19;
+ErrorMessage.U_RELATION_BLOCKING = 20;
+ErrorMessage.U_RELATION_REASSIGNMENT = 21;
+ErrorMessage.U_ROOT_COPY = 22;
+ErrorMessage.U_ROOT_DELETION = 23;
+ErrorMessage.U_ROOT_REASSIGN = 24;
+ErrorMessage.U_UNLOADED = 25;
+ErrorMessage.U_USER = 26;
+ErrorMessage.U_DUPLICATE_LOGIN = 27;
+ErrorMessage.U_FORBIDDEN_PROPERTY = 28;
+ErrorMessage.U_DATA_TOO_LARGE = 29;
+ErrorMessage.U_INVALID_CUSTOM_WRITE = 30;
+ErrorMessage.INVALID_CUSTOM_READ = 31;
+ErrorMessage.PROPERTY_ACCESS_DENIED = 32;
+ErrorMessage.CONNECTION_LOST = 33;
+ErrorMessage.PASSWORD_CHANGE_REQUIRED = 34;
+ErrorMessage.REQUEST_TOO_LONG = 35;
+ErrorMessage.CUMULATIVE_REQUESTS_TOO_LONG = 36;
+ErrorMessage.TOO_MANY_REQUESTS = 37;
+ErrorMessage.AGGREGATE = 38;
+ErrorMessage.CUSTOM = 39;
+ErrorMessage.EXCEPTION = 40;
+class ErrorMessageHandler {
+    constructor() {
+    }
+    Handle(msg) {
+        return msg._handledBy_miv_(this);
+    }
+}
+exports.ErrorMessageHandler = ErrorMessageHandler;
+class ErrorMessageHandlerDefault extends ErrorMessageHandler {
+    constructor() {
+        super();
+    }
+    HandleAggregate(msg) { return this.Default(msg); }
+    HandleConnectionLost(msg) { return this.Default(msg); }
+    HandleCustom(msg) { return this.Default(msg); }
+    HandleInvalidCredentials(msg) { return this.Default(msg); }
+    HandlePasswordChangeRequired(msg) { return this.Default(msg); }
+    HandleInvalidCustomRead(msg) { return this.Default(msg); }
+    HandleLoadExcess(msg) { return this.Default(msg); }
+    HandleObjectAccessDenied(msg) { return this.Default(msg); }
+    HandlePropertyAccessDenied(msg) { return this.Default(msg); }
+    HandleRequestTooLong(msg) { return this.Default(msg); }
+    HandleCumulativeRequestsTooLong(msg) { return this.Default(msg); }
+    HandleTextual(msg) { return this.Default(msg); }
+    HandleException(msg) { return this.Default(msg); }
+    HandleTooManyRequests(msg) { return this.Default(msg); }
+    HandleUnexpected(msg) { return this.Default(msg); }
+    HandleWrite(msg) { return this.Default(msg); }
+}
+exports.ErrorMessageHandlerDefault = ErrorMessageHandlerDefault;
+class WriteErrorMessageHandler {
+    constructor() {
+    }
+    Handle(msg) {
+        msg._writeHandledBy_miv_(this);
+    }
+}
+exports.WriteErrorMessageHandler = WriteErrorMessageHandler;
+class WriteErrorMessageHandlerDefault extends WriteErrorMessageHandler {
+    constructor() {
+        super();
+    }
+    HandleBeyondMaxDepth(msg) { return this.Default(msg); }
+    HandleBeyondMaxNewChildren(msg) { return this.Default(msg); }
+    HandleDeletedAndModified(msg) { return this.Default(msg); }
+    HandleDuplicateUserLogin(msg) { return this.Default(msg); }
+    HandleExistingRelationDifferentType(msg) { return this.Default(msg); }
+    HandleForbiddenProperty(msg) { return this.Default(msg); }
+    HandleForbiddenWrite(msg) { return this.Default(msg); }
+    HandleInvalidCopyID(msg) { return this.Default(msg); }
+    HandleInvalidCopyReference(msg) { return this.Default(msg); }
+    HandleInvalidFlags(msg) { return this.Default(msg); }
+    HandleInvalidTemporaryID(msg) { return this.Default(msg); }
+    HandleInvalidCustomWrite(msg) { return this.Default(msg); }
+    HandleMultipleReassignment(msg) { return this.Default(msg); }
+    HandleMultipleRelation(msg) { return this.Default(msg); }
+    HandleMultipleValues(msg) { return this.Default(msg); }
+    HandleNotChild(msg) { return this.Default(msg); }
+    HandleReassignmentLoop(msg) { return this.Default(msg); }
+    HandleRelationBlocking(msg) { return this.Default(msg); }
+    HandleRelationReassignment(msg) { return this.Default(msg); }
+    HandleRootCopy(msg) { return this.Default(msg); }
+    HandleRootDeletion(msg) { return this.Default(msg); }
+    HandleRootReassignment(msg) { return this.Default(msg); }
+    HandleUnloadedChildren(msg) { return this.Default(msg); }
+    HandleUser(msg) { return this.Default(msg); }
+    HandleDataTooLarge(msg) { return this.Default(msg); }
+}
+exports.WriteErrorMessageHandlerDefault = WriteErrorMessageHandlerDefault;
+class RegularWriteErrorMessageHandler extends WriteErrorMessageHandler {
+    constructor() {
+        super();
+    }
+    HandleBeyondMaxDepth(msg) { return this.HandleErroneousQuery(msg); }
+    HandleDeletedAndModified(msg) { return this.HandleErroneousQuery(msg); }
+    HandleForbiddenProperty(msg) { return this.HandleErroneousQuery(msg); }
+    HandleInvalidCopyID(msg) { return this.HandleInvalidQuery(msg); }
+    HandleInvalidCopyReference(msg) { return this.HandleInvalidQuery(msg); }
+    HandleInvalidFlags(msg) { return this.HandleInvalidQuery(msg); }
+    HandleInvalidTemporaryID(msg) { return this.HandleInvalidQuery(msg); }
+    HandleInvalidCustomWrite(msg) { return this.HandleInvalidQuery(msg); }
+    HandleMultipleReassignment(msg) { return this.HandleErroneousQuery(msg); }
+    HandleMultipleRelation(msg) { return this.HandleErroneousQuery(msg); }
+    HandleMultipleValues(msg) { return this.HandleErroneousQuery(msg); }
+    HandleRelationReassignment(msg) { return this.HandleErroneousQuery(msg); }
+    HandleRootCopy(msg) { return this.HandleInvalidQuery(msg); }
+    HandleRootDeletion(msg) { return this.HandleInvalidQuery(msg); }
+    HandleRootReassignment(msg) { return this.HandleInvalidQuery(msg); }
+    HandleUnloadedChildren(msg) { return this.HandleErroneousQuery(msg); }
+    HandleUser(msg) { return this.HandleErroneousQuery(msg); }
+}
+exports.RegularWriteErrorMessageHandler = RegularWriteErrorMessageHandler;
+class RegularWriteErrorMessageHandlerDefault extends RegularWriteErrorMessageHandler {
+    constructor() {
+        super();
+    }
+    HandleBeyondMaxNewChildren(msg) { return this.Default(msg); }
+    HandleDataTooLarge(msg) { return this.Default(msg); }
+    HandleDuplicateUserLogin(msg) { return this.Default(msg); }
+    HandleExistingRelationDifferentType(msg) { return this.Default(msg); }
+    HandleForbiddenWrite(msg) { return this.Default(msg); }
+    HandleNotChild(msg) { return this.Default(msg); }
+    HandleReassignmentLoop(msg) { return this.Default(msg); }
+    HandleRelationBlocking(msg) { return this.Default(msg); }
+}
+exports.RegularWriteErrorMessageHandlerDefault = RegularWriteErrorMessageHandlerDefault;
+class WriteErrorMessage extends ErrorMessage {
+    constructor() {
+        super();
+    }
+    _handledBy_miv_(h) {
+        return h.HandleWrite(this);
+    }
+}
+exports.WriteErrorMessage = WriteErrorMessage;
+class ErroneousWriteErrorMessage extends WriteErrorMessage {
+    constructor() {
+        super();
+    }
+    get IsRegular() { return false; }
+    get IsErroneous() { return true; }
+    get IsInvalid() { return false; }
+}
+exports.ErroneousWriteErrorMessage = ErroneousWriteErrorMessage;
+class RegularWriteErrorMessage extends WriteErrorMessage {
+    constructor() {
+        super();
+    }
+    get IsRegular() { return true; }
+    get IsErroneous() { return false; }
+    get IsInvalid() { return false; }
+}
+exports.RegularWriteErrorMessage = RegularWriteErrorMessage;
+class InvalidWriteErrorMessage extends WriteErrorMessage {
+    constructor() {
+        super();
+    }
+    get IsRegular() { return false; }
+    get IsErroneous() { return false; }
+    get IsInvalid() { return true; }
+}
+exports.InvalidWriteErrorMessage = InvalidWriteErrorMessage;
+class BeyondMaxNewChildren extends RegularWriteErrorMessage {
+    constructor(max) {
+        super();
+        this.Max = max;
+    }
+    static _deserialize_miv_(deser) {
+        const max = deser.ReadInt32();
+        if (max === undefined)
+            return undefined;
+        return new BeyondMaxNewChildren(max);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleBeyondMaxNewChildren(this);
+    }
+}
+exports.BeyondMaxNewChildren = BeyondMaxNewChildren;
+class DuplicateUserLogin extends RegularWriteErrorMessage {
+    constructor(login) {
+        super();
+        this.Login = login;
+    }
+    static _deserialize_miv_(deser) {
+        const login = deser.ReadString();
+        if (login === undefined)
+            return undefined;
+        return new DuplicateUserLogin(login);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleDuplicateUserLogin(this);
+    }
+}
+exports.DuplicateUserLogin = DuplicateUserLogin;
+class ExistingRelationDifferentType extends RegularWriteErrorMessage {
+    constructor(from, to, property, type) {
+        super();
+        this.From = from;
+        this.To = to;
+        this.Property = property;
+        this.Type = type;
+    }
+    static _deserialize_miv_(deser) {
+        const from = deser.ReadInt64();
+        if (from === undefined)
+            return undefined;
+        const to = deser.ReadInt64();
+        if (to === undefined)
+            return undefined;
+        const property = deser.ReadUint32();
+        if (property === undefined)
+            return undefined;
+        const type = deser.ReadUint32();
+        if (type === undefined)
+            return undefined;
+        return new ExistingRelationDifferentType(from, to, property, type);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleExistingRelationDifferentType(this);
+    }
+}
+exports.ExistingRelationDifferentType = ExistingRelationDifferentType;
+class ForbiddenWrite extends RegularWriteErrorMessage {
+    constructor() {
+        super();
+    }
+    static _deserialize_miv_(deser) {
+        return ForbiddenWrite.SINGLETON;
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleForbiddenWrite(this);
+    }
+}
+exports.ForbiddenWrite = ForbiddenWrite;
+ForbiddenWrite.SINGLETON = new ForbiddenWrite();
+class NotChild extends RegularWriteErrorMessage {
+    constructor(parent, child) {
+        super();
+        this.Parent = parent;
+        this.Child = child;
+    }
+    static _deserialize_miv_(deser) {
+        const parent = deser.ReadInt64();
+        if (parent === undefined)
+            return undefined;
+        const child = deser.ReadInt64();
+        if (child === undefined)
+            return undefined;
+        return new NotChild(parent, child);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleNotChild(this);
+    }
+}
+exports.NotChild = NotChild;
+class ReassignmentLoop extends RegularWriteErrorMessage {
+    constructor(child) {
+        super();
+        this.ReassignedChild = child;
+    }
+    static _deserialize_miv_(deser) {
+        const child = deser.ReadInt64();
+        if (child === undefined)
+            return undefined;
+        return new ReassignmentLoop(child);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleReassignmentLoop(this);
+    }
+}
+exports.ReassignmentLoop = ReassignmentLoop;
+class RelationBlocking extends RegularWriteErrorMessage {
+    constructor(target, type) {
+        super();
+        this.TargetID = target;
+        this.TargetType = type;
+    }
+    static _deserialize_miv_(deser) {
+        const target = deser.ReadInt64();
+        if (target === undefined)
+            return undefined;
+        const type = deser.ReadUint16();
+        if (type === undefined)
+            return undefined;
+        return new RelationBlocking(target, type);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleRelationBlocking(this);
+    }
+}
+exports.RelationBlocking = RelationBlocking;
+class RelationReassignment extends RegularWriteErrorMessage {
+    constructor(id) {
+        super();
+        this.ReassignedRelationID = id;
+    }
+    static _deserialize_miv_(deser) {
+        const id = deser.ReadInt64();
+        if (id === undefined)
+            return undefined;
+        return new RelationReassignment(id);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleRelationReassignment(this);
+    }
+}
+exports.RelationReassignment = RelationReassignment;
+class InvalidCopyID extends InvalidWriteErrorMessage {
+    constructor(id) {
+        super();
+        this.Copy = id;
+    }
+    static _deserialize_miv_(deser) {
+        const id = deser.ReadInt64();
+        if (id === undefined)
+            return undefined;
+        return new InvalidCopyID(id);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleInvalidCopyID(this);
+    }
+}
+exports.InvalidCopyID = InvalidCopyID;
+class InvalidCopyReference extends InvalidWriteErrorMessage {
+    constructor(id, r) {
+        super();
+        this.CopyID = id;
+        this.Ref = r;
+    }
+    static _deserialize_miv_(deser) {
+        const id = deser.ReadInt64();
+        if (id === undefined)
+            return undefined;
+        const r = deser.ReadInt64();
+        if (r === undefined)
+            return undefined;
+        return new InvalidCopyReference(id, r);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleInvalidCopyReference(this);
+    }
+}
+exports.InvalidCopyReference = InvalidCopyReference;
+class InvalidFlags extends InvalidWriteErrorMessage {
+    constructor(owner, p) {
+        super();
+        this.Owner = owner;
+        this.Property = p;
+    }
+    static _deserialize_miv_(deser) {
+        const owner = deser.ReadInt64();
+        if (owner === undefined)
+            return undefined;
+        const p = deser.ReadUint32();
+        if (p === undefined)
+            return undefined;
+        return new InvalidFlags(owner, p);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleInvalidFlags(this);
+    }
+}
+exports.InvalidFlags = InvalidFlags;
+class InvalidTemporaryID extends InvalidWriteErrorMessage {
+    constructor(id) {
+        super();
+        this.ID = id;
+    }
+    static _deserialize_miv_(deser) {
+        const id = deser.ReadInt64();
+        if (id === undefined)
+            return undefined;
+        return new InvalidTemporaryID(id);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleInvalidTemporaryID(this);
+    }
+}
+exports.InvalidTemporaryID = InvalidTemporaryID;
+class InvalidCustomWriteRequest extends InvalidWriteErrorMessage {
+    constructor() {
+        super();
+    }
+    static _deserialize_miv_(deser) {
+        return InvalidCustomWriteRequest.SINGLETON;
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleInvalidCustomWrite(this);
+    }
+}
+exports.InvalidCustomWriteRequest = InvalidCustomWriteRequest;
+InvalidCustomWriteRequest.SINGLETON = new InvalidCustomWriteRequest();
+class RootCopy extends InvalidWriteErrorMessage {
+    constructor(id) {
+        super();
+        this.ID = id;
+    }
+    static _deserialize_miv_(deser) {
+        const id = deser.ReadInt64();
+        if (id === undefined)
+            return undefined;
+        return new RootCopy(id);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleRootCopy(this);
+    }
+}
+exports.RootCopy = RootCopy;
+class RootDeletion extends InvalidWriteErrorMessage {
+    constructor(id) {
+        super();
+        this.ID = id;
+    }
+    static _deserialize_miv_(deser) {
+        const id = deser.ReadInt64();
+        if (id === undefined)
+            return undefined;
+        return new RootDeletion(id);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleRootDeletion(this);
+    }
+}
+exports.RootDeletion = RootDeletion;
+class RootReassignment extends InvalidWriteErrorMessage {
+    constructor(id) {
+        super();
+        this.ID = id;
+    }
+    static _deserialize_miv_(deser) {
+        const id = deser.ReadInt64();
+        if (id === undefined)
+            return undefined;
+        return new RootReassignment(id);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleRootReassignment(this);
+    }
+}
+exports.RootReassignment = RootReassignment;
+class BeyondMaxDepth extends ErroneousWriteErrorMessage {
+    constructor(id) {
+        super();
+        this.ID = id;
+    }
+    static _deserialize_miv_(deser) {
+        const id = deser.ReadInt64();
+        if (id === undefined)
+            return undefined;
+        return new BeyondMaxDepth(id);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleBeyondMaxDepth(this);
+    }
+}
+exports.BeyondMaxDepth = BeyondMaxDepth;
+class DeletedAndModified extends ErroneousWriteErrorMessage {
+    constructor(id) {
+        super();
+        this.Child = id;
+    }
+    static _deserialize_miv_(deser) {
+        const id = deser.ReadInt64();
+        if (id === undefined)
+            return undefined;
+        return new DeletedAndModified(id);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleDeletedAndModified(this);
+    }
+}
+exports.DeletedAndModified = DeletedAndModified;
+class ForbiddenProperty extends ErroneousWriteErrorMessage {
+    constructor(property) {
+        super();
+        this.Property = property;
+    }
+    static _deserialize_miv_(deser) {
+        const property = deser.ReadUint32();
+        if (property === undefined)
+            return undefined;
+        return new ForbiddenProperty(property);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleForbiddenProperty(this);
+    }
+}
+exports.ForbiddenProperty = ForbiddenProperty;
+class MultipleReassignment extends ErroneousWriteErrorMessage {
+    constructor(id) {
+        super();
+        this.Child = id;
+    }
+    static _deserialize_miv_(deser) {
+        const id = deser.ReadInt64();
+        if (id === undefined)
+            return undefined;
+        return new MultipleReassignment(id);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleMultipleReassignment(this);
+    }
+}
+exports.MultipleReassignment = MultipleReassignment;
+class MultipleRelation extends ErroneousWriteErrorMessage {
+    constructor(from, property, to) {
+        super();
+        this.From = from;
+        this.Property = property;
+        this.To = to;
+    }
+    static _deserialize_miv_(deser) {
+        const from = deser.ReadInt64();
+        if (from === undefined)
+            return undefined;
+        const property = deser.ReadUint32();
+        if (property === undefined)
+            return undefined;
+        const to = deser.ReadInt64();
+        if (to === undefined)
+            return undefined;
+        return new MultipleRelation(from, property, to);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleMultipleRelation(this);
+    }
+}
+exports.MultipleRelation = MultipleRelation;
+class MultipleValues extends ErroneousWriteErrorMessage {
+    constructor(owner, property) {
+        super();
+        this.ObjectID = owner;
+        this.Property = property;
+    }
+    static _deserialize_miv_(deser) {
+        const owner = deser.ReadInt64();
+        if (owner === undefined)
+            return undefined;
+        const property = deser.ReadUint32();
+        if (property === undefined)
+            return undefined;
+        return new MultipleValues(owner, property);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleMultipleValues(this);
+    }
+}
+exports.MultipleValues = MultipleValues;
+class UnloadedChildren extends ErroneousWriteErrorMessage {
+    constructor(id) {
+        super();
+        this.Parent = id;
+    }
+    static _deserialize_miv_(deser) {
+        const id = deser.ReadInt64();
+        if (id === undefined)
+            return undefined;
+        return new UnloadedChildren(id);
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleUnloadedChildren(this);
+    }
+}
+exports.UnloadedChildren = UnloadedChildren;
+class UserManagementError extends ErroneousWriteErrorMessage {
+    constructor() {
+        super();
+    }
+    static _deserialize_miv_(deser) {
+        return UserManagementError.SINGLETON;
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleUser(this);
+    }
+}
+exports.UserManagementError = UserManagementError;
+UserManagementError.SINGLETON = new UserManagementError();
+class UnexpectedErrorMessage extends ErrorMessage {
+    constructor() {
+        super();
+    }
+    static _deserialize_miv_(deser) {
+        return UnexpectedErrorMessage.SINGLETON;
+    }
+    _handledBy_miv_(h) {
+        return h.HandleUnexpected(this);
+    }
+}
+exports.UnexpectedErrorMessage = UnexpectedErrorMessage;
+UnexpectedErrorMessage.SINGLETON = new UnexpectedErrorMessage();
+class ObjectAccessDenied extends ErrorMessage {
+    constructor(id) {
+        super();
+        this.ID = id;
+    }
+    static _deserialize_miv_(deser) {
+        const id = deser.ReadInt64();
+        if (id === undefined)
+            return undefined;
+        return new ObjectAccessDenied(id);
+    }
+    _handledBy_miv_(h) {
+        return h.HandleObjectAccessDenied(this);
+    }
+}
+exports.ObjectAccessDenied = ObjectAccessDenied;
+class InvalidCredentials extends ErrorMessage {
+    constructor() {
+        super();
+    }
+    static _deserialize_miv_(deser) {
+        return InvalidCredentials.SINGLETON;
+    }
+    _handledBy_miv_(h) {
+        return h.HandleInvalidCredentials(this);
+    }
+}
+exports.InvalidCredentials = InvalidCredentials;
+InvalidCredentials.SINGLETON = new InvalidCredentials();
+class LoadExcess extends ErrorMessage {
+    constructor(currentLoad, maxLoad, loading) {
+        super();
+        this.CurrentLoad = currentLoad;
+        this.MaxLoad = maxLoad;
+        this.Loading = loading;
+    }
+    static _deserialize_miv_(deser) {
+        const currentLoad = deser.ReadInt32();
+        if (currentLoad === undefined)
+            return undefined;
+        const maxLoad = deser.ReadInt32();
+        if (maxLoad === undefined)
+            return undefined;
+        const loading = deser.ReadInt32();
+        if (loading === undefined)
+            return undefined;
+        return new LoadExcess(currentLoad, maxLoad, loading);
+    }
+    _handledBy_miv_(h) {
+        return h.HandleLoadExcess(this);
+    }
+}
+exports.LoadExcess = LoadExcess;
+class TextualErrorMessage extends ErrorMessage {
+    constructor(text) {
+        super();
+        this.Text = text;
+    }
+    static _deserialize_miv_(deser) {
+        const txt = deser.ReadString();
+        if (txt === undefined)
+            return undefined;
+        return new TextualErrorMessage(txt);
+    }
+    _handledBy_miv_(h) {
+        return h.HandleTextual(this);
+    }
+}
+exports.TextualErrorMessage = TextualErrorMessage;
+class ExceptionErrorMessage extends ErrorMessage {
+    constructor(text) {
+        super();
+        this.ExceptionDescription = text;
+    }
+    static _deserialize_miv_(deser) {
+        const txt = deser.ReadString();
+        if (txt === undefined)
+            return undefined;
+        return new ExceptionErrorMessage(txt);
+    }
+    _handledBy_miv_(h) {
+        return h.HandleException(this);
+    }
+}
+exports.ExceptionErrorMessage = ExceptionErrorMessage;
+class ConnectionLost extends ErrorMessage {
+    constructor() {
+        super();
+    }
+    static _deserialize_miv_(deser) {
+        return ConnectionLost.SINGLETON;
+    }
+    _handledBy_miv_(h) {
+        return h.HandleConnectionLost(this);
+    }
+}
+exports.ConnectionLost = ConnectionLost;
+ConnectionLost.SINGLETON = new ConnectionLost();
+class RequestTooLong extends ErrorMessage {
+    constructor() {
+        super();
+    }
+    static _deserialize_miv_(deser) {
+        return RequestTooLong.SINGLETON;
+    }
+    _handledBy_miv_(h) {
+        return h.HandleRequestTooLong(this);
+    }
+}
+exports.RequestTooLong = RequestTooLong;
+RequestTooLong.SINGLETON = new RequestTooLong();
+class CumulativeRequestsTooLong extends ErrorMessage {
+    constructor(maxLength, maxPeriodMilliseconds) {
+        super();
+        this.MaxLength = maxLength;
+        this.MaxPeriodMilliseconds = maxPeriodMilliseconds;
+    }
+    static _deserialize_miv_(deser) {
+        const maxLength = deser.ReadUint64();
+        if (maxLength === undefined)
+            return undefined;
+        const maxPeriodMilliseconds = deser.ReadInt64();
+        if (maxPeriodMilliseconds === undefined)
+            return undefined;
+        return new CumulativeRequestsTooLong(maxLength, maxPeriodMilliseconds);
+    }
+    _handledBy_miv_(h) {
+        return h.HandleCumulativeRequestsTooLong(this);
+    }
+}
+exports.CumulativeRequestsTooLong = CumulativeRequestsTooLong;
+class TooManyRequests extends ErrorMessage {
+    constructor(maxCount, maxPeriodMilliseconds) {
+        super();
+        this.MaxCount = maxCount;
+        this.MaxPeriodMilliseconds = maxPeriodMilliseconds;
+    }
+    static _deserialize_miv_(deser) {
+        const maxCount = deser.ReadUint32();
+        if (maxCount === undefined)
+            return undefined;
+        const maxPeriodMilliseconds = deser.ReadInt64();
+        if (maxPeriodMilliseconds === undefined)
+            return undefined;
+        return new TooManyRequests(maxCount, maxPeriodMilliseconds);
+    }
+    _handledBy_miv_(h) {
+        return h.HandleTooManyRequests(this);
+    }
+}
+exports.TooManyRequests = TooManyRequests;
+class PasswordChangeRequired extends ErrorMessage {
+    constructor() {
+        super();
+    }
+    static _deserialize_miv_(deser) {
+        return PasswordChangeRequired.SINGLETON;
+    }
+    _handledBy_miv_(h) {
+        return h.HandlePasswordChangeRequired(this);
+    }
+}
+exports.PasswordChangeRequired = PasswordChangeRequired;
+PasswordChangeRequired.SINGLETON = new PasswordChangeRequired();
+class InvalidCustomReadRequest extends ErrorMessage {
+    constructor() {
+        super();
+    }
+    static _deserialize_miv_(deser) {
+        return InvalidCustomReadRequest.SINGLETON;
+    }
+    _handledBy_miv_(h) {
+        return h.HandleInvalidCustomRead(this);
+    }
+}
+exports.InvalidCustomReadRequest = InvalidCustomReadRequest;
+InvalidCustomReadRequest.SINGLETON = new InvalidCustomReadRequest();
+class PropertyAccessDenied extends ErrorMessage {
+    constructor(owner, property) {
+        super();
+        this.Owner = owner;
+        this.Property = property;
+    }
+    static _deserialize_miv_(deser) {
+        const owner = deser.ReadInt64();
+        if (owner === undefined)
+            return undefined;
+        const prop = deser.ReadUint16();
+        if (prop === undefined)
+            return undefined;
+        return new PropertyAccessDenied(owner, prop);
+    }
+    _handledBy_miv_(h) {
+        return h.HandlePropertyAccessDenied(this);
+    }
+}
+exports.PropertyAccessDenied = PropertyAccessDenied;
+class DataTooLarge extends RegularWriteErrorMessage {
+    constructor() {
+        super();
+    }
+    static _deserialize_miv_(deser) {
+        return DataTooLarge.SINGLETON;
+    }
+    _writeHandledBy_miv_(h) {
+        return h.HandleDataTooLarge(this);
+    }
+}
+exports.DataTooLarge = DataTooLarge;
+DataTooLarge.SINGLETON = new DataTooLarge();
+class AggregateErrorMessage extends ErrorMessage {
+    constructor(errors) {
+        super();
+        this.Errors = errors;
+    }
+    static _deserialize_miv_(deser) {
+        const count = deser.ReadInt32();
+        if (count === undefined)
+            return undefined;
+        const errors = new Array(count);
+        for (let i = 0; i < count; i++) {
+            const e = ErrorMessage._deserializeError_miv_(deser);
+            if (e === undefined)
+                return undefined;
+            errors[i] = e;
+        }
+        return new AggregateErrorMessage(errors);
+    }
+    _handledBy_miv_(h) {
+        return h.HandleAggregate(this);
+    }
+    static CreateFromList(list) {
+        if (list === undefined || list.length <= 0)
+            return undefined;
+        if (list.length == 1)
+            return list[0].error;
+        const agg = new Array(list.length);
+        for (let i = 0; i < list.length; i++) {
+            agg[i] = list[i].error;
+        }
+        return new AggregateErrorMessage(agg);
+    }
+}
+exports.AggregateErrorMessage = AggregateErrorMessage;
+class CustomErrorMessage extends ErrorMessage {
+    constructor(code, data) {
+        super();
+        if (ArrayBuffer.length > 65536) {
+            throw new Error("data must have a max length of 65536");
+        }
+        this.Code = code;
+        this.Data = data;
+    }
+    static _deserialize_miv_(deser) {
+        const code = deser.ReadUint8();
+        if (code === undefined)
+            return undefined;
+        const count = deser.ReadInt32();
+        if (count === undefined)
+            return undefined;
+        const data = new Uint8Array(new ArrayBuffer(count));
+        for (let i = 0; i < count; i++) {
+            const e = deser.ReadUint8();
+            if (e === undefined)
+                return undefined;
+            data[i] = e;
+        }
+        return new CustomErrorMessage(code, data.buffer);
+    }
+    _handledBy_miv_(h) {
+        return h.HandleCustom(this);
+    }
+}
+exports.CustomErrorMessage = CustomErrorMessage;
+//# sourceMappingURL=ErrorMessage.js.map