@fivenet-app/gen 0.9.3-1

package/services/sync/sync.ts

@@ -0,0 +1,831 @@
+// @generated by protobuf-ts 2.9.4 with parameter optimize_speed,long_type_number,force_server_none
+// @generated from protobuf file "services/sync/sync.proto" (package "services.sync", syntax proto3)
+// @ts-nocheck
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { DataUserLocations } from "../../resources/sync/data";
+import { DataVehicles } from "../../resources/sync/data";
+import { DataUsers } from "../../resources/sync/data";
+import { DataLicenses } from "../../resources/sync/data";
+import { DataJobs } from "../../resources/sync/data";
+import { UserUpdate } from "../../resources/sync/activity";
+import { TimeclockEntry } from "../../resources/jobs/timeclock";
+import { JobsUserProps } from "../../resources/sync/activity";
+import { JobsUserActivity } from "../../resources/jobs/activity";
+import { UserProps } from "../../resources/sync/activity";
+import { UserActivity } from "../../resources/users/activity";
+import { Dispatch } from "../../resources/centrum/dispatches";
+import { UserOAuth2Conn } from "../../resources/sync/activity";
+import { DataStatus } from "../../resources/sync/data";
+/**
+ * @generated from protobuf message services.sync.GetStatusRequest
+ */
+export interface GetStatusRequest {
+}
+/**
+ * @generated from protobuf message services.sync.GetStatusResponse
+ */
+export interface GetStatusResponse {
+    /**
+     * @generated from protobuf field: resources.sync.DataStatus jobs = 1;
+     */
+    jobs?: DataStatus;
+    /**
+     * @generated from protobuf field: resources.sync.DataStatus licenses = 2;
+     */
+    licenses?: DataStatus;
+    /**
+     * @generated from protobuf field: resources.sync.DataStatus users = 3;
+     */
+    users?: DataStatus;
+    /**
+     * @generated from protobuf field: resources.sync.DataStatus vehicles = 4;
+     */
+    vehicles?: DataStatus;
+}
+/**
+ * @generated from protobuf message services.sync.AddActivityRequest
+ */
+export interface AddActivityRequest {
+    /**
+     * @generated from protobuf oneof: activity
+     */
+    activity: {
+        oneofKind: "userOauth2";
+        /**
+         * @generated from protobuf field: resources.sync.UserOAuth2Conn user_oauth2 = 1;
+         */
+        userOauth2: UserOAuth2Conn;
+    } | {
+        oneofKind: "dispatch";
+        /**
+         * @generated from protobuf field: resources.centrum.Dispatch dispatch = 2;
+         */
+        dispatch: Dispatch;
+    } | {
+        oneofKind: "userActivity";
+        /**
+         * User activity
+         *
+         * @generated from protobuf field: resources.users.UserActivity user_activity = 3;
+         */
+        userActivity: UserActivity;
+    } | {
+        oneofKind: "userProps";
+        /**
+         * Setting props will cause activity to be created automtically
+         *
+         * @generated from protobuf field: resources.sync.UserProps user_props = 4;
+         */
+        userProps: UserProps;
+    } | {
+        oneofKind: "jobsUserActivity";
+        /**
+         * Jobs user activity
+         *
+         * @generated from protobuf field: resources.jobs.JobsUserActivity jobs_user_activity = 5;
+         */
+        jobsUserActivity: JobsUserActivity;
+    } | {
+        oneofKind: "jobsUserProps";
+        /**
+         * Setting props will cause activity to be created automtically
+         *
+         * @generated from protobuf field: resources.sync.JobsUserProps jobs_user_props = 6;
+         */
+        jobsUserProps: JobsUserProps;
+    } | {
+        oneofKind: "jobsTimeclock";
+        /**
+         * Timeclock user entry
+         *
+         * @generated from protobuf field: resources.jobs.TimeclockEntry jobs_timeclock = 7;
+         */
+        jobsTimeclock: TimeclockEntry;
+    } | {
+        oneofKind: "userUpdate";
+        /**
+         * User/Char info updates that aren't tracked by activity (yet)
+         *
+         * @generated from protobuf field: resources.sync.UserUpdate user_update = 8;
+         */
+        userUpdate: UserUpdate;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message services.sync.AddActivityResponse
+ */
+export interface AddActivityResponse {
+    /**
+     * @generated from protobuf field: uint64 id = 1;
+     */
+    id: number;
+}
+/**
+ * @generated from protobuf message services.sync.RegisterAccountRequest
+ */
+export interface RegisterAccountRequest {
+    /**
+     * @generated from protobuf field: string identifier = 1;
+     */
+    identifier: string;
+    /**
+     * @generated from protobuf field: bool reset_token = 2;
+     */
+    resetToken: boolean;
+    /**
+     * @generated from protobuf field: optional int32 last_char_id = 3;
+     */
+    lastCharId?: number;
+}
+/**
+ * @generated from protobuf message services.sync.RegisterAccountResponse
+ */
+export interface RegisterAccountResponse {
+    /**
+     * @generated from protobuf field: optional string reg_token = 1;
+     */
+    regToken?: string;
+    /**
+     * @generated from protobuf field: optional uint64 account_id = 2;
+     */
+    accountId?: number;
+    /**
+     * @generated from protobuf field: optional string username = 3;
+     */
+    username?: string;
+}
+/**
+ * @generated from protobuf message services.sync.SendDataRequest
+ */
+export interface SendDataRequest {
+    /**
+     * @generated from protobuf oneof: data
+     */
+    data: {
+        oneofKind: "jobs";
+        /**
+         * @generated from protobuf field: resources.sync.DataJobs jobs = 1;
+         */
+        jobs: DataJobs;
+    } | {
+        oneofKind: "licenses";
+        /**
+         * @generated from protobuf field: resources.sync.DataLicenses licenses = 2;
+         */
+        licenses: DataLicenses;
+    } | {
+        oneofKind: "users";
+        /**
+         * @generated from protobuf field: resources.sync.DataUsers users = 3;
+         */
+        users: DataUsers;
+    } | {
+        oneofKind: "vehicles";
+        /**
+         * @generated from protobuf field: resources.sync.DataVehicles vehicles = 4;
+         */
+        vehicles: DataVehicles;
+    } | {
+        oneofKind: "userLocations";
+        /**
+         * @generated from protobuf field: resources.sync.DataUserLocations user_locations = 5;
+         */
+        userLocations: DataUserLocations;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message services.sync.SendDataResponse
+ */
+export interface SendDataResponse {
+    /**
+     * @generated from protobuf field: int64 affected_rows = 1;
+     */
+    affectedRows: number;
+}
+/**
+ * @generated from protobuf message services.sync.StreamRequest
+ */
+export interface StreamRequest {
+}
+/**
+ * @generated from protobuf message services.sync.StreamResponse
+ */
+export interface StreamResponse {
+    /**
+     * @generated from protobuf field: int32 user_id = 1;
+     */
+    userId: number;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class GetStatusRequest$Type extends MessageType<GetStatusRequest> {
+    constructor() {
+        super("services.sync.GetStatusRequest", []);
+    }
+    create(value?: PartialMessage<GetStatusRequest>): GetStatusRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<GetStatusRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetStatusRequest): GetStatusRequest {
+        return target ?? this.create();
+    }
+    internalBinaryWrite(message: GetStatusRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.sync.GetStatusRequest
+ */
+export const GetStatusRequest = new GetStatusRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetStatusResponse$Type extends MessageType<GetStatusResponse> {
+    constructor() {
+        super("services.sync.GetStatusResponse", [
+            { no: 1, name: "jobs", kind: "message", T: () => DataStatus },
+            { no: 2, name: "licenses", kind: "message", T: () => DataStatus },
+            { no: 3, name: "users", kind: "message", T: () => DataStatus },
+            { no: 4, name: "vehicles", kind: "message", T: () => DataStatus }
+        ]);
+    }
+    create(value?: PartialMessage<GetStatusResponse>): GetStatusResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<GetStatusResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetStatusResponse): GetStatusResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.sync.DataStatus jobs */ 1:
+                    message.jobs = DataStatus.internalBinaryRead(reader, reader.uint32(), options, message.jobs);
+                    break;
+                case /* resources.sync.DataStatus licenses */ 2:
+                    message.licenses = DataStatus.internalBinaryRead(reader, reader.uint32(), options, message.licenses);
+                    break;
+                case /* resources.sync.DataStatus users */ 3:
+                    message.users = DataStatus.internalBinaryRead(reader, reader.uint32(), options, message.users);
+                    break;
+                case /* resources.sync.DataStatus vehicles */ 4:
+                    message.vehicles = DataStatus.internalBinaryRead(reader, reader.uint32(), options, message.vehicles);
+                    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: GetStatusResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.sync.DataStatus jobs = 1; */
+        if (message.jobs)
+            DataStatus.internalBinaryWrite(message.jobs, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* resources.sync.DataStatus licenses = 2; */
+        if (message.licenses)
+            DataStatus.internalBinaryWrite(message.licenses, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* resources.sync.DataStatus users = 3; */
+        if (message.users)
+            DataStatus.internalBinaryWrite(message.users, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* resources.sync.DataStatus vehicles = 4; */
+        if (message.vehicles)
+            DataStatus.internalBinaryWrite(message.vehicles, writer.tag(4, 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 services.sync.GetStatusResponse
+ */
+export const GetStatusResponse = new GetStatusResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AddActivityRequest$Type extends MessageType<AddActivityRequest> {
+    constructor() {
+        super("services.sync.AddActivityRequest", [
+            { no: 1, name: "user_oauth2", kind: "message", oneof: "activity", T: () => UserOAuth2Conn },
+            { no: 2, name: "dispatch", kind: "message", oneof: "activity", T: () => Dispatch },
+            { no: 3, name: "user_activity", kind: "message", oneof: "activity", T: () => UserActivity },
+            { no: 4, name: "user_props", kind: "message", oneof: "activity", T: () => UserProps },
+            { no: 5, name: "jobs_user_activity", kind: "message", oneof: "activity", T: () => JobsUserActivity },
+            { no: 6, name: "jobs_user_props", kind: "message", oneof: "activity", T: () => JobsUserProps },
+            { no: 7, name: "jobs_timeclock", kind: "message", oneof: "activity", T: () => TimeclockEntry },
+            { no: 8, name: "user_update", kind: "message", oneof: "activity", T: () => UserUpdate }
+        ]);
+    }
+    create(value?: PartialMessage<AddActivityRequest>): AddActivityRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.activity = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<AddActivityRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AddActivityRequest): AddActivityRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.sync.UserOAuth2Conn user_oauth2 */ 1:
+                    message.activity = {
+                        oneofKind: "userOauth2",
+                        userOauth2: UserOAuth2Conn.internalBinaryRead(reader, reader.uint32(), options, (message.activity as any).userOauth2)
+                    };
+                    break;
+                case /* resources.centrum.Dispatch dispatch */ 2:
+                    message.activity = {
+                        oneofKind: "dispatch",
+                        dispatch: Dispatch.internalBinaryRead(reader, reader.uint32(), options, (message.activity as any).dispatch)
+                    };
+                    break;
+                case /* resources.users.UserActivity user_activity */ 3:
+                    message.activity = {
+                        oneofKind: "userActivity",
+                        userActivity: UserActivity.internalBinaryRead(reader, reader.uint32(), options, (message.activity as any).userActivity)
+                    };
+                    break;
+                case /* resources.sync.UserProps user_props */ 4:
+                    message.activity = {
+                        oneofKind: "userProps",
+                        userProps: UserProps.internalBinaryRead(reader, reader.uint32(), options, (message.activity as any).userProps)
+                    };
+                    break;
+                case /* resources.jobs.JobsUserActivity jobs_user_activity */ 5:
+                    message.activity = {
+                        oneofKind: "jobsUserActivity",
+                        jobsUserActivity: JobsUserActivity.internalBinaryRead(reader, reader.uint32(), options, (message.activity as any).jobsUserActivity)
+                    };
+                    break;
+                case /* resources.sync.JobsUserProps jobs_user_props */ 6:
+                    message.activity = {
+                        oneofKind: "jobsUserProps",
+                        jobsUserProps: JobsUserProps.internalBinaryRead(reader, reader.uint32(), options, (message.activity as any).jobsUserProps)
+                    };
+                    break;
+                case /* resources.jobs.TimeclockEntry jobs_timeclock */ 7:
+                    message.activity = {
+                        oneofKind: "jobsTimeclock",
+                        jobsTimeclock: TimeclockEntry.internalBinaryRead(reader, reader.uint32(), options, (message.activity as any).jobsTimeclock)
+                    };
+                    break;
+                case /* resources.sync.UserUpdate user_update */ 8:
+                    message.activity = {
+                        oneofKind: "userUpdate",
+                        userUpdate: UserUpdate.internalBinaryRead(reader, reader.uint32(), options, (message.activity as any).userUpdate)
+                    };
+                    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: AddActivityRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.sync.UserOAuth2Conn user_oauth2 = 1; */
+        if (message.activity.oneofKind === "userOauth2")
+            UserOAuth2Conn.internalBinaryWrite(message.activity.userOauth2, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* resources.centrum.Dispatch dispatch = 2; */
+        if (message.activity.oneofKind === "dispatch")
+            Dispatch.internalBinaryWrite(message.activity.dispatch, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* resources.users.UserActivity user_activity = 3; */
+        if (message.activity.oneofKind === "userActivity")
+            UserActivity.internalBinaryWrite(message.activity.userActivity, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* resources.sync.UserProps user_props = 4; */
+        if (message.activity.oneofKind === "userProps")
+            UserProps.internalBinaryWrite(message.activity.userProps, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* resources.jobs.JobsUserActivity jobs_user_activity = 5; */
+        if (message.activity.oneofKind === "jobsUserActivity")
+            JobsUserActivity.internalBinaryWrite(message.activity.jobsUserActivity, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* resources.sync.JobsUserProps jobs_user_props = 6; */
+        if (message.activity.oneofKind === "jobsUserProps")
+            JobsUserProps.internalBinaryWrite(message.activity.jobsUserProps, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* resources.jobs.TimeclockEntry jobs_timeclock = 7; */
+        if (message.activity.oneofKind === "jobsTimeclock")
+            TimeclockEntry.internalBinaryWrite(message.activity.jobsTimeclock, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* resources.sync.UserUpdate user_update = 8; */
+        if (message.activity.oneofKind === "userUpdate")
+            UserUpdate.internalBinaryWrite(message.activity.userUpdate, writer.tag(8, 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 services.sync.AddActivityRequest
+ */
+export const AddActivityRequest = new AddActivityRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AddActivityResponse$Type extends MessageType<AddActivityResponse> {
+    constructor() {
+        super("services.sync.AddActivityResponse", [
+            { no: 1, name: "id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 2 /*LongType.NUMBER*/ }
+        ]);
+    }
+    create(value?: PartialMessage<AddActivityResponse>): AddActivityResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = 0;
+        if (value !== undefined)
+            reflectionMergePartial<AddActivityResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AddActivityResponse): AddActivityResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint64 id */ 1:
+                    message.id = reader.uint64().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: AddActivityResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* uint64 id = 1; */
+        if (message.id !== 0)
+            writer.tag(1, WireType.Varint).uint64(message.id);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.sync.AddActivityResponse
+ */
+export const AddActivityResponse = new AddActivityResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RegisterAccountRequest$Type extends MessageType<RegisterAccountRequest> {
+    constructor() {
+        super("services.sync.RegisterAccountRequest", [
+            { no: 1, name: "identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { maxLen: "64" } } } },
+            { no: 2, name: "reset_token", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 3, name: "last_char_id", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/, options: { "validate.rules": { int32: { gt: 0 } } } }
+        ]);
+    }
+    create(value?: PartialMessage<RegisterAccountRequest>): RegisterAccountRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.identifier = "";
+        message.resetToken = false;
+        if (value !== undefined)
+            reflectionMergePartial<RegisterAccountRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RegisterAccountRequest): RegisterAccountRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string identifier */ 1:
+                    message.identifier = reader.string();
+                    break;
+                case /* bool reset_token */ 2:
+                    message.resetToken = reader.bool();
+                    break;
+                case /* optional int32 last_char_id */ 3:
+                    message.lastCharId = 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: RegisterAccountRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string identifier = 1; */
+        if (message.identifier !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.identifier);
+        /* bool reset_token = 2; */
+        if (message.resetToken !== false)
+            writer.tag(2, WireType.Varint).bool(message.resetToken);
+        /* optional int32 last_char_id = 3; */
+        if (message.lastCharId !== undefined)
+            writer.tag(3, WireType.Varint).int32(message.lastCharId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.sync.RegisterAccountRequest
+ */
+export const RegisterAccountRequest = new RegisterAccountRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RegisterAccountResponse$Type extends MessageType<RegisterAccountResponse> {
+    constructor() {
+        super("services.sync.RegisterAccountResponse", [
+            { no: 1, name: "reg_token", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { len: "6", pattern: "^[0-9]{6}$" } } } },
+            { no: 2, name: "account_id", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 3, name: "username", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<RegisterAccountResponse>): RegisterAccountResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<RegisterAccountResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RegisterAccountResponse): RegisterAccountResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional string reg_token */ 1:
+                    message.regToken = reader.string();
+                    break;
+                case /* optional uint64 account_id */ 2:
+                    message.accountId = reader.uint64().toNumber();
+                    break;
+                case /* optional string username */ 3:
+                    message.username = 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: RegisterAccountResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional string reg_token = 1; */
+        if (message.regToken !== undefined)
+            writer.tag(1, WireType.LengthDelimited).string(message.regToken);
+        /* optional uint64 account_id = 2; */
+        if (message.accountId !== undefined)
+            writer.tag(2, WireType.Varint).uint64(message.accountId);
+        /* optional string username = 3; */
+        if (message.username !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.username);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.sync.RegisterAccountResponse
+ */
+export const RegisterAccountResponse = new RegisterAccountResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SendDataRequest$Type extends MessageType<SendDataRequest> {
+    constructor() {
+        super("services.sync.SendDataRequest", [
+            { no: 1, name: "jobs", kind: "message", oneof: "data", T: () => DataJobs },
+            { no: 2, name: "licenses", kind: "message", oneof: "data", T: () => DataLicenses },
+            { no: 3, name: "users", kind: "message", oneof: "data", T: () => DataUsers },
+            { no: 4, name: "vehicles", kind: "message", oneof: "data", T: () => DataVehicles },
+            { no: 5, name: "user_locations", kind: "message", oneof: "data", T: () => DataUserLocations }
+        ]);
+    }
+    create(value?: PartialMessage<SendDataRequest>): SendDataRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.data = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<SendDataRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SendDataRequest): SendDataRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.sync.DataJobs jobs */ 1:
+                    message.data = {
+                        oneofKind: "jobs",
+                        jobs: DataJobs.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).jobs)
+                    };
+                    break;
+                case /* resources.sync.DataLicenses licenses */ 2:
+                    message.data = {
+                        oneofKind: "licenses",
+                        licenses: DataLicenses.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).licenses)
+                    };
+                    break;
+                case /* resources.sync.DataUsers users */ 3:
+                    message.data = {
+                        oneofKind: "users",
+                        users: DataUsers.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).users)
+                    };
+                    break;
+                case /* resources.sync.DataVehicles vehicles */ 4:
+                    message.data = {
+                        oneofKind: "vehicles",
+                        vehicles: DataVehicles.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).vehicles)
+                    };
+                    break;
+                case /* resources.sync.DataUserLocations user_locations */ 5:
+                    message.data = {
+                        oneofKind: "userLocations",
+                        userLocations: DataUserLocations.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).userLocations)
+                    };
+                    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: SendDataRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.sync.DataJobs jobs = 1; */
+        if (message.data.oneofKind === "jobs")
+            DataJobs.internalBinaryWrite(message.data.jobs, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* resources.sync.DataLicenses licenses = 2; */
+        if (message.data.oneofKind === "licenses")
+            DataLicenses.internalBinaryWrite(message.data.licenses, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* resources.sync.DataUsers users = 3; */
+        if (message.data.oneofKind === "users")
+            DataUsers.internalBinaryWrite(message.data.users, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* resources.sync.DataVehicles vehicles = 4; */
+        if (message.data.oneofKind === "vehicles")
+            DataVehicles.internalBinaryWrite(message.data.vehicles, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* resources.sync.DataUserLocations user_locations = 5; */
+        if (message.data.oneofKind === "userLocations")
+            DataUserLocations.internalBinaryWrite(message.data.userLocations, writer.tag(5, 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 services.sync.SendDataRequest
+ */
+export const SendDataRequest = new SendDataRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SendDataResponse$Type extends MessageType<SendDataResponse> {
+    constructor() {
+        super("services.sync.SendDataResponse", [
+            { no: 1, name: "affected_rows", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ }
+        ]);
+    }
+    create(value?: PartialMessage<SendDataResponse>): SendDataResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.affectedRows = 0;
+        if (value !== undefined)
+            reflectionMergePartial<SendDataResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SendDataResponse): SendDataResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 affected_rows */ 1:
+                    message.affectedRows = 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: SendDataResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 affected_rows = 1; */
+        if (message.affectedRows !== 0)
+            writer.tag(1, WireType.Varint).int64(message.affectedRows);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.sync.SendDataResponse
+ */
+export const SendDataResponse = new SendDataResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamRequest$Type extends MessageType<StreamRequest> {
+    constructor() {
+        super("services.sync.StreamRequest", []);
+    }
+    create(value?: PartialMessage<StreamRequest>): StreamRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<StreamRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamRequest): StreamRequest {
+        return target ?? this.create();
+    }
+    internalBinaryWrite(message: StreamRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.sync.StreamRequest
+ */
+export const StreamRequest = new StreamRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamResponse$Type extends MessageType<StreamResponse> {
+    constructor() {
+        super("services.sync.StreamResponse", [
+            { no: 1, name: "user_id", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
+        ]);
+    }
+    create(value?: PartialMessage<StreamResponse>): StreamResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.userId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<StreamResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamResponse): StreamResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int32 user_id */ 1:
+                    message.userId = 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: StreamResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int32 user_id = 1; */
+        if (message.userId !== 0)
+            writer.tag(1, WireType.Varint).int32(message.userId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.sync.StreamResponse
+ */
+export const StreamResponse = new StreamResponse$Type();
+/**
+ * @generated ServiceType for protobuf service services.sync.SyncService
+ */
+export const SyncService = new ServiceType("services.sync.SyncService", [
+    { name: "GetStatus", options: {}, I: GetStatusRequest, O: GetStatusResponse },
+    { name: "AddActivity", options: {}, I: AddActivityRequest, O: AddActivityResponse },
+    { name: "RegisterAccount", options: {}, I: RegisterAccountRequest, O: RegisterAccountResponse },
+    { name: "SendData", options: {}, I: SendDataRequest, O: SendDataResponse },
+    { name: "Stream", serverStreaming: true, options: {}, I: StreamRequest, O: StreamResponse }
+]);