@fivenet-app/gen 0.9.3-1 → 0.9.3-2

package/resources/users/activity.ts

@@ -10,6 +10,8 @@ import { UnknownFieldHandler } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
+import { CitizenLabel } from "./labels";
+import { License } from "./licenses";
 import { UserShort } from "./users";
 import { Timestamp } from "../timestamp/timestamp";
 /**
@@ -51,19 +53,230 @@ export interface UserActivity {
      */
     key: string; // @gotags: alias:"fivenet_user_activity.key"
     /**
-     * @generated from protobuf field: string old_value = 9;
+     * @sanitize
+     *
+     * @generated from protobuf field: string reason = 9;
+     */
+    reason: string; // @gotags: alias:"fivenet_user_activity.reason"
+    /**
+     * @generated from protobuf field: optional resources.users.UserActivityData data = 10;
+     */
+    data?: UserActivityData; // @gotags: alias:"fivenet_user_activity.data"
+    /**
+     * @generated from protobuf field: string old_value = 11;
      */
     oldValue: string; // @gotags: alias:"fivenet_user_activity.old_value"
     /**
-     * @generated from protobuf field: string new_value = 10;
+     * @generated from protobuf field: string new_value = 12;
      */
     newValue: string; // @gotags: alias:"fivenet_user_activity.new_value"
+}
+/**
+ * @generated from protobuf message resources.users.UserActivityData
+ */
+export interface UserActivityData {
     /**
-     * @sanitize
-     *
-     * @generated from protobuf field: string reason = 11;
+     * @generated from protobuf oneof: data
      */
-    reason: string; // @gotags: alias:"fivenet_user_activity.reason"
+    data: {
+        oneofKind: "nameChange";
+        /**
+         * @generated from protobuf field: resources.users.UserNameChange name_change = 1;
+         */
+        nameChange: UserNameChange;
+    } | {
+        oneofKind: "licensesChange";
+        /**
+         * @generated from protobuf field: resources.users.UserLicenseChange licenses_change = 2;
+         */
+        licensesChange: UserLicenseChange;
+    } | {
+        oneofKind: "wantedChange";
+        /**
+         * User Props
+         *
+         * @generated from protobuf field: resources.users.UserWantedChange wanted_change = 3;
+         */
+        wantedChange: UserWantedChange;
+    } | {
+        oneofKind: "trafficInfractionPointsChange";
+        /**
+         * @generated from protobuf field: resources.users.UserTrafficInfractionPointsChange traffic_infraction_points_change = 4;
+         */
+        trafficInfractionPointsChange: UserTrafficInfractionPointsChange;
+    } | {
+        oneofKind: "mugshotChange";
+        /**
+         * @generated from protobuf field: resources.users.UserMugshotChange mugshot_change = 5;
+         */
+        mugshotChange: UserMugshotChange;
+    } | {
+        oneofKind: "labelsChange";
+        /**
+         * @generated from protobuf field: resources.users.UserLabelsChange labels_change = 6;
+         */
+        labelsChange: UserLabelsChange;
+    } | {
+        oneofKind: "jobChange";
+        /**
+         * @generated from protobuf field: resources.users.UserJobChange job_change = 7;
+         */
+        jobChange: UserJobChange;
+    } | {
+        oneofKind: "documentRelation";
+        /**
+         * Docstore related
+         *
+         * @generated from protobuf field: resources.users.UserDocumentRelation document_relation = 8;
+         */
+        documentRelation: UserDocumentRelation;
+    } | {
+        oneofKind: "jailChange";
+        /**
+         * "Plugin" activities
+         *
+         * @generated from protobuf field: resources.users.UserJailChange jail_change = 9;
+         */
+        jailChange: UserJailChange;
+    } | {
+        oneofKind: "fineChange";
+        /**
+         * @generated from protobuf field: resources.users.UserFineChange fine_change = 10;
+         */
+        fineChange: UserFineChange;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message resources.users.UserNameChange
+ */
+export interface UserNameChange {
+    /**
+     * @generated from protobuf field: optional string firstname = 1;
+     */
+    firstname?: string;
+    /**
+     * @generated from protobuf field: optional string lastname = 2;
+     */
+    lastname?: string;
+}
+/**
+ * @generated from protobuf message resources.users.UserLicenseChange
+ */
+export interface UserLicenseChange {
+    /**
+     * @generated from protobuf field: repeated resources.users.License added = 1;
+     */
+    added: License[];
+    /**
+     * @generated from protobuf field: repeated resources.users.License removed = 2;
+     */
+    removed: License[];
+}
+/**
+ * @generated from protobuf message resources.users.UserWantedChange
+ */
+export interface UserWantedChange {
+    /**
+     * @generated from protobuf field: bool wanted = 1;
+     */
+    wanted: boolean;
+}
+/**
+ * @generated from protobuf message resources.users.UserTrafficInfractionPointsChange
+ */
+export interface UserTrafficInfractionPointsChange {
+    /**
+     * @generated from protobuf field: int32 old = 1;
+     */
+    old: number;
+    /**
+     * @generated from protobuf field: int32 new = 2;
+     */
+    new: number;
+}
+/**
+ * @generated from protobuf message resources.users.UserMugshotChange
+ */
+export interface UserMugshotChange {
+    /**
+     * @generated from protobuf field: string old = 1;
+     */
+    old: string;
+}
+/**
+ * @generated from protobuf message resources.users.UserLabelsChange
+ */
+export interface UserLabelsChange {
+    /**
+     * @generated from protobuf field: repeated resources.users.CitizenLabel added = 1;
+     */
+    added: CitizenLabel[];
+    /**
+     * @generated from protobuf field: repeated resources.users.CitizenLabel removed = 2;
+     */
+    removed: CitizenLabel[];
+}
+/**
+ * @generated from protobuf message resources.users.UserJobChange
+ */
+export interface UserJobChange {
+    /**
+     * @generated from protobuf field: optional string job = 1;
+     */
+    job?: string;
+    /**
+     * @generated from protobuf field: optional string job_label = 2;
+     */
+    jobLabel?: string;
+    /**
+     * @generated from protobuf field: optional int32 grade = 3;
+     */
+    grade?: number;
+    /**
+     * @generated from protobuf field: optional string grade_label = 4;
+     */
+    gradeLabel?: string;
+}
+/**
+ * @generated from protobuf message resources.users.UserDocumentRelation
+ */
+export interface UserDocumentRelation {
+    /**
+     * @generated from protobuf field: bool added = 1;
+     */
+    added: boolean;
+    /**
+     * @generated from protobuf field: uint64 document_id = 2 [jstype = JS_STRING];
+     */
+    documentId: string; // resources.documents.DocRelation relation = 3 [(validate.rules).enum.defined_only = true];
+}
+/**
+ * @generated from protobuf message resources.users.UserJailChange
+ */
+export interface UserJailChange {
+    /**
+     * @generated from protobuf field: int32 seconds = 1;
+     */
+    seconds: number;
+    /**
+     * @generated from protobuf field: bool admin = 2;
+     */
+    admin: boolean;
+    /**
+     * @generated from protobuf field: optional string location = 3;
+     */
+    location?: string;
+}
+/**
+ * @generated from protobuf message resources.users.UserFineChange
+ */
+export interface UserFineChange {
+    /**
+     * @generated from protobuf field: int64 amount = 1;
+     */
+    amount: number;
 }
 /**
  * @generated from protobuf enum resources.users.UserActivityType
@@ -84,7 +297,47 @@ export enum UserActivityType {
     /**
      * @generated from protobuf enum value: USER_ACTIVITY_TYPE_CREATED = 3;
      */
-    CREATED = 3
+    CREATED = 3,
+    /**
+     * @generated from protobuf enum value: USER_ACTIVITY_TYPE_NAME = 4;
+     */
+    NAME = 4,
+    /**
+     * @generated from protobuf enum value: USER_ACTIVITY_TYPE_LICENSES = 5;
+     */
+    LICENSES = 5,
+    /**
+     * @generated from protobuf enum value: USER_ACTIVITY_TYPE_WANTED = 6;
+     */
+    WANTED = 6,
+    /**
+     * @generated from protobuf enum value: USER_ACTIVITY_TYPE_TRAFFIC_INFRACTION_POINTS = 7;
+     */
+    TRAFFIC_INFRACTION_POINTS = 7,
+    /**
+     * @generated from protobuf enum value: USER_ACTIVITY_TYPE_MUGSHOT = 8;
+     */
+    MUGSHOT = 8,
+    /**
+     * @generated from protobuf enum value: USER_ACTIVITY_TYPE_LABELS = 9;
+     */
+    LABELS = 9,
+    /**
+     * @generated from protobuf enum value: USER_ACTIVITY_TYPE_JOB = 10;
+     */
+    JOB = 10,
+    /**
+     * @generated from protobuf enum value: USER_ACTIVITY_TYPE_DOCUMENT = 11;
+     */
+    DOCUMENT = 11,
+    /**
+     * @generated from protobuf enum value: USER_ACTIVITY_TYPE_JAIL = 12;
+     */
+    JAIL = 12,
+    /**
+     * @generated from protobuf enum value: USER_ACTIVITY_TYPE_FINE = 13;
+     */
+    FINE = 13
 }
 // @generated message type with reflection information, may provide speed optimized methods
 class UserActivity$Type extends MessageType<UserActivity> {
@@ -98,9 +351,10 @@ class UserActivity$Type extends MessageType<UserActivity> {
             { no: 6, name: "target_user_id", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
             { no: 7, name: "target_user", kind: "message", T: () => UserShort },
             { no: 8, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1", maxLen: "64" } } } },
-            { no: 9, name: "old_value", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { maxLen: "255" } } } },
-            { no: 10, name: "new_value", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { maxLen: "255" } } } },
-            { no: 11, name: "reason", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { maxLen: "255" } } } }
+            { no: 9, name: "reason", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { maxLen: "255" } } } },
+            { no: 10, name: "data", kind: "message", T: () => UserActivityData },
+            { no: 11, name: "old_value", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { maxLen: "255" } } } },
+            { no: 12, name: "new_value", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { maxLen: "255" } } } }
         ]);
     }
     create(value?: PartialMessage<UserActivity>): UserActivity {
@@ -109,9 +363,9 @@ class UserActivity$Type extends MessageType<UserActivity> {
         message.type = 0;
         message.targetUserId = 0;
         message.key = "";
+        message.reason = "";
         message.oldValue = "";
         message.newValue = "";
-        message.reason = "";
         if (value !== undefined)
             reflectionMergePartial<UserActivity>(this, message, value);
         return message;
@@ -145,15 +399,18 @@ class UserActivity$Type extends MessageType<UserActivity> {
                 case /* string key */ 8:
                     message.key = reader.string();
                     break;
-                case /* string old_value */ 9:
+                case /* string reason */ 9:
+                    message.reason = reader.string();
+                    break;
+                case /* optional resources.users.UserActivityData data */ 10:
+                    message.data = UserActivityData.internalBinaryRead(reader, reader.uint32(), options, message.data);
+                    break;
+                case /* string old_value */ 11:
                     message.oldValue = reader.string();
                     break;
-                case /* string new_value */ 10:
+                case /* string new_value */ 12:
                     message.newValue = reader.string();
                     break;
-                case /* string reason */ 11:
-                    message.reason = reader.string();
-                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === "throw")
@@ -190,15 +447,18 @@ class UserActivity$Type extends MessageType<UserActivity> {
         /* string key = 8; */
         if (message.key !== "")
             writer.tag(8, WireType.LengthDelimited).string(message.key);
-        /* string old_value = 9; */
+        /* string reason = 9; */
+        if (message.reason !== "")
+            writer.tag(9, WireType.LengthDelimited).string(message.reason);
+        /* optional resources.users.UserActivityData data = 10; */
+        if (message.data)
+            UserActivityData.internalBinaryWrite(message.data, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* string old_value = 11; */
         if (message.oldValue !== "")
-            writer.tag(9, WireType.LengthDelimited).string(message.oldValue);
-        /* string new_value = 10; */
+            writer.tag(11, WireType.LengthDelimited).string(message.oldValue);
+        /* string new_value = 12; */
         if (message.newValue !== "")
-            writer.tag(10, WireType.LengthDelimited).string(message.newValue);
-        /* string reason = 11; */
-        if (message.reason !== "")
-            writer.tag(11, WireType.LengthDelimited).string(message.reason);
+            writer.tag(12, WireType.LengthDelimited).string(message.newValue);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -209,3 +469,686 @@ class UserActivity$Type extends MessageType<UserActivity> {
  * @generated MessageType for protobuf message resources.users.UserActivity
  */
 export const UserActivity = new UserActivity$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UserActivityData$Type extends MessageType<UserActivityData> {
+    constructor() {
+        super("resources.users.UserActivityData", [
+            { no: 1, name: "name_change", kind: "message", oneof: "data", T: () => UserNameChange },
+            { no: 2, name: "licenses_change", kind: "message", oneof: "data", T: () => UserLicenseChange },
+            { no: 3, name: "wanted_change", kind: "message", oneof: "data", T: () => UserWantedChange },
+            { no: 4, name: "traffic_infraction_points_change", kind: "message", oneof: "data", T: () => UserTrafficInfractionPointsChange },
+            { no: 5, name: "mugshot_change", kind: "message", oneof: "data", T: () => UserMugshotChange },
+            { no: 6, name: "labels_change", kind: "message", oneof: "data", T: () => UserLabelsChange },
+            { no: 7, name: "job_change", kind: "message", oneof: "data", T: () => UserJobChange },
+            { no: 8, name: "document_relation", kind: "message", oneof: "data", T: () => UserDocumentRelation },
+            { no: 9, name: "jail_change", kind: "message", oneof: "data", T: () => UserJailChange },
+            { no: 10, name: "fine_change", kind: "message", oneof: "data", T: () => UserFineChange }
+        ]);
+    }
+    create(value?: PartialMessage<UserActivityData>): UserActivityData {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.data = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<UserActivityData>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UserActivityData): UserActivityData {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.users.UserNameChange name_change */ 1:
+                    message.data = {
+                        oneofKind: "nameChange",
+                        nameChange: UserNameChange.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).nameChange)
+                    };
+                    break;
+                case /* resources.users.UserLicenseChange licenses_change */ 2:
+                    message.data = {
+                        oneofKind: "licensesChange",
+                        licensesChange: UserLicenseChange.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).licensesChange)
+                    };
+                    break;
+                case /* resources.users.UserWantedChange wanted_change */ 3:
+                    message.data = {
+                        oneofKind: "wantedChange",
+                        wantedChange: UserWantedChange.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).wantedChange)
+                    };
+                    break;
+                case /* resources.users.UserTrafficInfractionPointsChange traffic_infraction_points_change */ 4:
+                    message.data = {
+                        oneofKind: "trafficInfractionPointsChange",
+                        trafficInfractionPointsChange: UserTrafficInfractionPointsChange.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).trafficInfractionPointsChange)
+                    };
+                    break;
+                case /* resources.users.UserMugshotChange mugshot_change */ 5:
+                    message.data = {
+                        oneofKind: "mugshotChange",
+                        mugshotChange: UserMugshotChange.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).mugshotChange)
+                    };
+                    break;
+                case /* resources.users.UserLabelsChange labels_change */ 6:
+                    message.data = {
+                        oneofKind: "labelsChange",
+                        labelsChange: UserLabelsChange.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).labelsChange)
+                    };
+                    break;
+                case /* resources.users.UserJobChange job_change */ 7:
+                    message.data = {
+                        oneofKind: "jobChange",
+                        jobChange: UserJobChange.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).jobChange)
+                    };
+                    break;
+                case /* resources.users.UserDocumentRelation document_relation */ 8:
+                    message.data = {
+                        oneofKind: "documentRelation",
+                        documentRelation: UserDocumentRelation.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).documentRelation)
+                    };
+                    break;
+                case /* resources.users.UserJailChange jail_change */ 9:
+                    message.data = {
+                        oneofKind: "jailChange",
+                        jailChange: UserJailChange.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).jailChange)
+                    };
+                    break;
+                case /* resources.users.UserFineChange fine_change */ 10:
+                    message.data = {
+                        oneofKind: "fineChange",
+                        fineChange: UserFineChange.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).fineChange)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: UserActivityData, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.users.UserNameChange name_change = 1; */
+        if (message.data.oneofKind === "nameChange")
+            UserNameChange.internalBinaryWrite(message.data.nameChange, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* resources.users.UserLicenseChange licenses_change = 2; */
+        if (message.data.oneofKind === "licensesChange")
+            UserLicenseChange.internalBinaryWrite(message.data.licensesChange, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* resources.users.UserWantedChange wanted_change = 3; */
+        if (message.data.oneofKind === "wantedChange")
+            UserWantedChange.internalBinaryWrite(message.data.wantedChange, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* resources.users.UserTrafficInfractionPointsChange traffic_infraction_points_change = 4; */
+        if (message.data.oneofKind === "trafficInfractionPointsChange")
+            UserTrafficInfractionPointsChange.internalBinaryWrite(message.data.trafficInfractionPointsChange, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* resources.users.UserMugshotChange mugshot_change = 5; */
+        if (message.data.oneofKind === "mugshotChange")
+            UserMugshotChange.internalBinaryWrite(message.data.mugshotChange, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* resources.users.UserLabelsChange labels_change = 6; */
+        if (message.data.oneofKind === "labelsChange")
+            UserLabelsChange.internalBinaryWrite(message.data.labelsChange, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* resources.users.UserJobChange job_change = 7; */
+        if (message.data.oneofKind === "jobChange")
+            UserJobChange.internalBinaryWrite(message.data.jobChange, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* resources.users.UserDocumentRelation document_relation = 8; */
+        if (message.data.oneofKind === "documentRelation")
+            UserDocumentRelation.internalBinaryWrite(message.data.documentRelation, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* resources.users.UserJailChange jail_change = 9; */
+        if (message.data.oneofKind === "jailChange")
+            UserJailChange.internalBinaryWrite(message.data.jailChange, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+        /* resources.users.UserFineChange fine_change = 10; */
+        if (message.data.oneofKind === "fineChange")
+            UserFineChange.internalBinaryWrite(message.data.fineChange, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.users.UserActivityData
+ */
+export const UserActivityData = new UserActivityData$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UserNameChange$Type extends MessageType<UserNameChange> {
+    constructor() {
+        super("resources.users.UserNameChange", [
+            { no: 1, name: "firstname", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "lastname", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<UserNameChange>): UserNameChange {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<UserNameChange>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UserNameChange): UserNameChange {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional string firstname */ 1:
+                    message.firstname = reader.string();
+                    break;
+                case /* optional string lastname */ 2:
+                    message.lastname = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: UserNameChange, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional string firstname = 1; */
+        if (message.firstname !== undefined)
+            writer.tag(1, WireType.LengthDelimited).string(message.firstname);
+        /* optional string lastname = 2; */
+        if (message.lastname !== undefined)
+            writer.tag(2, WireType.LengthDelimited).string(message.lastname);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.users.UserNameChange
+ */
+export const UserNameChange = new UserNameChange$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UserLicenseChange$Type extends MessageType<UserLicenseChange> {
+    constructor() {
+        super("resources.users.UserLicenseChange", [
+            { no: 1, name: "added", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => License },
+            { no: 2, name: "removed", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => License }
+        ]);
+    }
+    create(value?: PartialMessage<UserLicenseChange>): UserLicenseChange {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.added = [];
+        message.removed = [];
+        if (value !== undefined)
+            reflectionMergePartial<UserLicenseChange>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UserLicenseChange): UserLicenseChange {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated resources.users.License added */ 1:
+                    message.added.push(License.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated resources.users.License removed */ 2:
+                    message.removed.push(License.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: UserLicenseChange, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated resources.users.License added = 1; */
+        for (let i = 0; i < message.added.length; i++)
+            License.internalBinaryWrite(message.added[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated resources.users.License removed = 2; */
+        for (let i = 0; i < message.removed.length; i++)
+            License.internalBinaryWrite(message.removed[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.users.UserLicenseChange
+ */
+export const UserLicenseChange = new UserLicenseChange$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UserWantedChange$Type extends MessageType<UserWantedChange> {
+    constructor() {
+        super("resources.users.UserWantedChange", [
+            { no: 1, name: "wanted", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value?: PartialMessage<UserWantedChange>): UserWantedChange {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.wanted = false;
+        if (value !== undefined)
+            reflectionMergePartial<UserWantedChange>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UserWantedChange): UserWantedChange {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool wanted */ 1:
+                    message.wanted = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: UserWantedChange, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bool wanted = 1; */
+        if (message.wanted !== false)
+            writer.tag(1, WireType.Varint).bool(message.wanted);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.users.UserWantedChange
+ */
+export const UserWantedChange = new UserWantedChange$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UserTrafficInfractionPointsChange$Type extends MessageType<UserTrafficInfractionPointsChange> {
+    constructor() {
+        super("resources.users.UserTrafficInfractionPointsChange", [
+            { no: 1, name: "old", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 2, name: "new", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
+        ]);
+    }
+    create(value?: PartialMessage<UserTrafficInfractionPointsChange>): UserTrafficInfractionPointsChange {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.old = 0;
+        message.new = 0;
+        if (value !== undefined)
+            reflectionMergePartial<UserTrafficInfractionPointsChange>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UserTrafficInfractionPointsChange): UserTrafficInfractionPointsChange {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int32 old */ 1:
+                    message.old = reader.int32();
+                    break;
+                case /* int32 new */ 2:
+                    message.new = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: UserTrafficInfractionPointsChange, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int32 old = 1; */
+        if (message.old !== 0)
+            writer.tag(1, WireType.Varint).int32(message.old);
+        /* int32 new = 2; */
+        if (message.new !== 0)
+            writer.tag(2, WireType.Varint).int32(message.new);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.users.UserTrafficInfractionPointsChange
+ */
+export const UserTrafficInfractionPointsChange = new UserTrafficInfractionPointsChange$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UserMugshotChange$Type extends MessageType<UserMugshotChange> {
+    constructor() {
+        super("resources.users.UserMugshotChange", [
+            { no: 1, name: "old", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<UserMugshotChange>): UserMugshotChange {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.old = "";
+        if (value !== undefined)
+            reflectionMergePartial<UserMugshotChange>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UserMugshotChange): UserMugshotChange {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string old */ 1:
+                    message.old = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: UserMugshotChange, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string old = 1; */
+        if (message.old !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.old);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.users.UserMugshotChange
+ */
+export const UserMugshotChange = new UserMugshotChange$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UserLabelsChange$Type extends MessageType<UserLabelsChange> {
+    constructor() {
+        super("resources.users.UserLabelsChange", [
+            { no: 1, name: "added", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => CitizenLabel },
+            { no: 2, name: "removed", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => CitizenLabel }
+        ]);
+    }
+    create(value?: PartialMessage<UserLabelsChange>): UserLabelsChange {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.added = [];
+        message.removed = [];
+        if (value !== undefined)
+            reflectionMergePartial<UserLabelsChange>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UserLabelsChange): UserLabelsChange {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated resources.users.CitizenLabel added */ 1:
+                    message.added.push(CitizenLabel.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated resources.users.CitizenLabel removed */ 2:
+                    message.removed.push(CitizenLabel.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: UserLabelsChange, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated resources.users.CitizenLabel added = 1; */
+        for (let i = 0; i < message.added.length; i++)
+            CitizenLabel.internalBinaryWrite(message.added[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated resources.users.CitizenLabel removed = 2; */
+        for (let i = 0; i < message.removed.length; i++)
+            CitizenLabel.internalBinaryWrite(message.removed[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.users.UserLabelsChange
+ */
+export const UserLabelsChange = new UserLabelsChange$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UserJobChange$Type extends MessageType<UserJobChange> {
+    constructor() {
+        super("resources.users.UserJobChange", [
+            { no: 1, name: "job", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "job_label", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "grade", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ },
+            { no: 4, name: "grade_label", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<UserJobChange>): UserJobChange {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<UserJobChange>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UserJobChange): UserJobChange {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional string job */ 1:
+                    message.job = reader.string();
+                    break;
+                case /* optional string job_label */ 2:
+                    message.jobLabel = reader.string();
+                    break;
+                case /* optional int32 grade */ 3:
+                    message.grade = reader.int32();
+                    break;
+                case /* optional string grade_label */ 4:
+                    message.gradeLabel = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: UserJobChange, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional string job = 1; */
+        if (message.job !== undefined)
+            writer.tag(1, WireType.LengthDelimited).string(message.job);
+        /* optional string job_label = 2; */
+        if (message.jobLabel !== undefined)
+            writer.tag(2, WireType.LengthDelimited).string(message.jobLabel);
+        /* optional int32 grade = 3; */
+        if (message.grade !== undefined)
+            writer.tag(3, WireType.Varint).int32(message.grade);
+        /* optional string grade_label = 4; */
+        if (message.gradeLabel !== undefined)
+            writer.tag(4, WireType.LengthDelimited).string(message.gradeLabel);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.users.UserJobChange
+ */
+export const UserJobChange = new UserJobChange$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UserDocumentRelation$Type extends MessageType<UserDocumentRelation> {
+    constructor() {
+        super("resources.users.UserDocumentRelation", [
+            { no: 1, name: "added", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 2, name: "document_id", kind: "scalar", T: 4 /*ScalarType.UINT64*/ }
+        ]);
+    }
+    create(value?: PartialMessage<UserDocumentRelation>): UserDocumentRelation {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.added = false;
+        message.documentId = "0";
+        if (value !== undefined)
+            reflectionMergePartial<UserDocumentRelation>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UserDocumentRelation): UserDocumentRelation {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool added */ 1:
+                    message.added = reader.bool();
+                    break;
+                case /* uint64 document_id = 2 [jstype = JS_STRING];*/ 2:
+                    message.documentId = reader.uint64().toString();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: UserDocumentRelation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bool added = 1; */
+        if (message.added !== false)
+            writer.tag(1, WireType.Varint).bool(message.added);
+        /* uint64 document_id = 2 [jstype = JS_STRING]; */
+        if (message.documentId !== "0")
+            writer.tag(2, WireType.Varint).uint64(message.documentId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.users.UserDocumentRelation
+ */
+export const UserDocumentRelation = new UserDocumentRelation$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UserJailChange$Type extends MessageType<UserJailChange> {
+    constructor() {
+        super("resources.users.UserJailChange", [
+            { no: 1, name: "seconds", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 2, name: "admin", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 3, name: "location", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<UserJailChange>): UserJailChange {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.seconds = 0;
+        message.admin = false;
+        if (value !== undefined)
+            reflectionMergePartial<UserJailChange>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UserJailChange): UserJailChange {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int32 seconds */ 1:
+                    message.seconds = reader.int32();
+                    break;
+                case /* bool admin */ 2:
+                    message.admin = reader.bool();
+                    break;
+                case /* optional string location */ 3:
+                    message.location = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: UserJailChange, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int32 seconds = 1; */
+        if (message.seconds !== 0)
+            writer.tag(1, WireType.Varint).int32(message.seconds);
+        /* bool admin = 2; */
+        if (message.admin !== false)
+            writer.tag(2, WireType.Varint).bool(message.admin);
+        /* optional string location = 3; */
+        if (message.location !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.location);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.users.UserJailChange
+ */
+export const UserJailChange = new UserJailChange$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UserFineChange$Type extends MessageType<UserFineChange> {
+    constructor() {
+        super("resources.users.UserFineChange", [
+            { no: 1, name: "amount", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ }
+        ]);
+    }
+    create(value?: PartialMessage<UserFineChange>): UserFineChange {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.amount = 0;
+        if (value !== undefined)
+            reflectionMergePartial<UserFineChange>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UserFineChange): UserFineChange {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 amount */ 1:
+                    message.amount = reader.int64().toNumber();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: UserFineChange, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 amount = 1; */
+        if (message.amount !== 0)
+            writer.tag(1, WireType.Varint).int64(message.amount);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message resources.users.UserFineChange
+ */
+export const UserFineChange = new UserFineChange$Type();