@fivenet-app/gen 2026.7.3 → 2026.8.5

package/services/jobs/groups.ts

@@ -2,8 +2,3603 @@
 // @generated from protobuf file "services/jobs/groups.proto" (package "services.jobs", syntax proto3)
 // tslint:disable
 // @ts-nocheck
+import { UploadFileResponse } from "../../resources/file/filestore";
+import { UploadFileRequest } from "../../resources/file/filestore";
 import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { GroupActivity } from "../../resources/jobs/groups/activity";
+import { Timestamp } from "../../resources/timestamp/timestamp";
+import { GroupActivityType } from "../../resources/jobs/groups/activity";
+import { GroupQualificationRule } from "../../resources/jobs/groups/group";
+import { GroupGradeRule } from "../../resources/jobs/groups/group";
+import { GroupExclusionReason } from "../../resources/jobs/groups/group";
+import { GroupLeader } from "../../resources/jobs/groups/group";
+import { GroupMemberExclusion } from "../../resources/jobs/groups/group";
+import { GroupManualMember } from "../../resources/jobs/groups/group";
+import { GroupRule } from "../../resources/jobs/groups/group";
+import { GroupResolvedMember } from "../../resources/jobs/groups/group";
+import { GroupMemberSource } from "../../resources/jobs/groups/group";
+import { GroupMembershipMode } from "../../resources/jobs/groups/group";
+import { Access } from "../../resources/access/access";
+import { Group } from "../../resources/jobs/groups/group";
+import { PaginationResponse } from "../../resources/common/database/database";
+import { GroupType } from "../../resources/jobs/groups/group";
+import { GroupState } from "../../resources/jobs/groups/group";
+import { Sort } from "../../resources/common/database/database";
+import { PaginationRequest } from "../../resources/common/database/database";
+/**
+ * @generated from protobuf message services.jobs.ListGroupsRequest
+ */
+export interface ListGroupsRequest {
+    /**
+     * @generated from protobuf field: resources.common.database.PaginationRequest pagination = 1
+     */
+    pagination?: PaginationRequest;
+    /**
+     * @generated from protobuf field: optional resources.common.database.Sort sort = 2
+     */
+    sort?: Sort;
+    /**
+     * Search params
+     *
+     * @generated from protobuf field: repeated resources.jobs.groups.GroupState states = 3
+     */
+    states: GroupState[];
+    /**
+     * @generated from protobuf field: optional string search = 4
+     */
+    search?: string;
+    /**
+     * @generated from protobuf field: bool include_counts = 5
+     */
+    includeCounts: boolean;
+    /**
+     * @generated from protobuf field: bool include_inactive = 6
+     */
+    includeInactive: boolean;
+    /**
+     * @generated from protobuf field: bool include_archived = 7
+     */
+    includeArchived: boolean;
+    /**
+     * @generated from protobuf field: repeated int32 group_ids = 8
+     */
+    groupIds: number[];
+    /**
+     * @generated from protobuf field: optional resources.jobs.groups.GroupType kind = 9
+     */
+    kind?: GroupType;
+}
+/**
+ * @generated from protobuf message services.jobs.ListGroupsResponse
+ */
+export interface ListGroupsResponse {
+    /**
+     * @generated from protobuf field: resources.common.database.PaginationResponse pagination = 1
+     */
+    pagination?: PaginationResponse;
+    /**
+     * @generated from protobuf field: repeated resources.jobs.groups.Group groups = 2
+     */
+    groups: Group[];
+}
+/**
+ * @generated from protobuf message services.jobs.GetGroupRequest
+ */
+export interface GetGroupRequest {
+    /**
+     * @generated from protobuf field: int64 id = 1
+     */
+    id: number;
+    /**
+     * @generated from protobuf field: bool include_archived = 2
+     */
+    includeArchived: boolean;
+}
+/**
+ * @generated from protobuf message services.jobs.GetGroupResponse
+ */
+export interface GetGroupResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 1
+     */
+    group?: Group;
+    /**
+     * @generated from protobuf field: optional resources.access.Access access = 2
+     */
+    access?: Access;
+}
+/**
+ * @generated from protobuf message services.jobs.CreateGroupRequest
+ */
+export interface CreateGroupRequest {
+    /**
+     * @generated from protobuf field: string job = 1
+     */
+    job: string;
+    /**
+     * @generated from protobuf field: string name = 2
+     */
+    name: string;
+    /**
+     * @generated from protobuf field: optional string description = 3
+     */
+    description?: string;
+    /**
+     * @generated from protobuf field: optional string short_name = 4
+     */
+    shortName?: string;
+    /**
+     * @generated from protobuf field: optional string color = 6
+     */
+    color?: string;
+    /**
+     * @generated from protobuf field: optional resources.jobs.groups.GroupType type = 7
+     */
+    type?: GroupType;
+    /**
+     * @generated from protobuf field: optional resources.jobs.groups.GroupMembershipMode membership_mode = 8
+     */
+    membershipMode?: GroupMembershipMode;
+    /**
+     * @generated from protobuf field: optional string sort_rank = 9
+     */
+    sortRank?: string;
+    /**
+     * @generated from protobuf field: repeated int32 leader_user_ids = 10
+     */
+    leaderUserIds: number[];
+    /**
+     * @generated from protobuf field: repeated int32 manual_member_user_ids = 11
+     */
+    manualMemberUserIds: number[];
+    /**
+     * @generated from protobuf field: repeated services.jobs.GroupRuleInput rules = 12
+     */
+    rules: GroupRuleInput[];
+    /**
+     * @generated from protobuf field: optional resources.access.Access access = 13
+     */
+    access?: Access;
+}
+/**
+ * @generated from protobuf message services.jobs.CreateGroupResponse
+ */
+export interface CreateGroupResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 1
+     */
+    group?: Group;
+}
+/**
+ * @generated from protobuf message services.jobs.UpdateGroupRequest
+ */
+export interface UpdateGroupRequest {
+    /**
+     * @generated from protobuf field: int64 id = 1
+     */
+    id: number;
+    /**
+     * @generated from protobuf field: optional string name = 2
+     */
+    name?: string;
+    /**
+     * @generated from protobuf field: optional string description = 3
+     */
+    description?: string;
+    /**
+     * @generated from protobuf field: optional string short_name = 4
+     */
+    shortName?: string;
+    /**
+     * @generated from protobuf field: optional string color = 6
+     */
+    color?: string;
+    /**
+     * @generated from protobuf field: optional resources.jobs.groups.GroupState state = 7
+     */
+    state?: GroupState;
+    /**
+     * @generated from protobuf field: optional resources.jobs.groups.GroupType type = 8
+     */
+    type?: GroupType;
+    /**
+     * @generated from protobuf field: optional resources.jobs.groups.GroupMembershipMode membership_mode = 9
+     */
+    membershipMode?: GroupMembershipMode;
+    /**
+     * @generated from protobuf field: optional string sort_rank = 10
+     */
+    sortRank?: string;
+    /**
+     * @generated from protobuf field: optional resources.access.Access access = 11
+     */
+    access?: Access;
+}
+/**
+ * @generated from protobuf message services.jobs.UpdateGroupResponse
+ */
+export interface UpdateGroupResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 1
+     */
+    group?: Group;
+}
+/**
+ * @generated from protobuf message services.jobs.ArchiveGroupRequest
+ */
+export interface ArchiveGroupRequest {
+    /**
+     * @generated from protobuf field: int64 id = 1
+     */
+    id: number;
+    /**
+     * @generated from protobuf field: optional string reason = 2
+     */
+    reason?: string;
+}
+/**
+ * @generated from protobuf message services.jobs.ArchiveGroupResponse
+ */
+export interface ArchiveGroupResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 1
+     */
+    group?: Group;
+}
+/**
+ * @generated from protobuf message services.jobs.RestoreGroupRequest
+ */
+export interface RestoreGroupRequest {
+    /**
+     * @generated from protobuf field: int64 id = 1
+     */
+    id: number;
+    /**
+     * @generated from protobuf field: optional string reason = 2
+     */
+    reason?: string;
+}
+/**
+ * @generated from protobuf message services.jobs.RestoreGroupResponse
+ */
+export interface RestoreGroupResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 1
+     */
+    group?: Group;
+}
+/**
+ * @generated from protobuf message services.jobs.DeleteGroupLogoRequest
+ */
+export interface DeleteGroupLogoRequest {
+    /**
+     * @generated from protobuf field: int64 id = 1
+     */
+    id: number;
+}
+/**
+ * @generated from protobuf message services.jobs.DeleteGroupLogoResponse
+ */
+export interface DeleteGroupLogoResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 1
+     */
+    group?: Group;
+}
+/**
+ * @generated from protobuf message services.jobs.ListGroupMembersRequest
+ */
+export interface ListGroupMembersRequest {
+    /**
+     * @generated from protobuf field: resources.common.database.PaginationRequest pagination = 1
+     */
+    pagination?: PaginationRequest;
+    /**
+     * @generated from protobuf field: optional resources.common.database.Sort sort = 2
+     */
+    sort?: Sort;
+    /**
+     * @generated from protobuf field: int64 group_id = 3
+     */
+    groupId: number;
+    /**
+     * @generated from protobuf field: optional string search = 4
+     */
+    search?: string;
+    /**
+     * @generated from protobuf field: bool include_excluded = 5
+     */
+    includeExcluded: boolean;
+    /**
+     * @generated from protobuf field: bool include_leaders = 6
+     */
+    includeLeaders: boolean;
+    /**
+     * @generated from protobuf field: bool include_reasons = 7
+     */
+    includeReasons: boolean;
+    /**
+     * @generated from protobuf field: repeated resources.jobs.groups.GroupMemberSource sources = 8
+     */
+    sources: GroupMemberSource[];
+}
+/**
+ * @generated from protobuf message services.jobs.ListGroupMembersResponse
+ */
+export interface ListGroupMembersResponse {
+    /**
+     * @generated from protobuf field: resources.common.database.PaginationResponse pagination = 1
+     */
+    pagination?: PaginationResponse;
+    /**
+     * @generated from protobuf field: repeated resources.jobs.groups.GroupResolvedMember members = 2
+     */
+    members: GroupResolvedMember[];
+}
+/**
+ * @generated from protobuf message services.jobs.ListGroupRulesRequest
+ */
+export interface ListGroupRulesRequest {
+    /**
+     * @generated from protobuf field: resources.common.database.PaginationRequest pagination = 1
+     */
+    pagination?: PaginationRequest;
+    /**
+     * @generated from protobuf field: int64 group_id = 2
+     */
+    groupId: number;
+}
+/**
+ * @generated from protobuf message services.jobs.ListGroupRulesResponse
+ */
+export interface ListGroupRulesResponse {
+    /**
+     * @generated from protobuf field: resources.common.database.PaginationResponse pagination = 1
+     */
+    pagination?: PaginationResponse;
+    /**
+     * @generated from protobuf field: repeated resources.jobs.groups.GroupRule rules = 2
+     */
+    rules: GroupRule[];
+}
+/**
+ * @generated from protobuf message services.jobs.ListGroupManualMembersRequest
+ */
+export interface ListGroupManualMembersRequest {
+    /**
+     * @generated from protobuf field: resources.common.database.PaginationRequest pagination = 1
+     */
+    pagination?: PaginationRequest;
+    /**
+     * @generated from protobuf field: int64 group_id = 2
+     */
+    groupId: number;
+    /**
+     * @generated from protobuf field: optional string search = 3
+     */
+    search?: string;
+}
+/**
+ * @generated from protobuf message services.jobs.ListGroupManualMembersResponse
+ */
+export interface ListGroupManualMembersResponse {
+    /**
+     * @generated from protobuf field: resources.common.database.PaginationResponse pagination = 1
+     */
+    pagination?: PaginationResponse;
+    /**
+     * @generated from protobuf field: repeated resources.jobs.groups.GroupManualMember manual_members = 2
+     */
+    manualMembers: GroupManualMember[];
+}
+/**
+ * @generated from protobuf message services.jobs.ListGroupMemberExclusionsRequest
+ */
+export interface ListGroupMemberExclusionsRequest {
+    /**
+     * @generated from protobuf field: resources.common.database.PaginationRequest pagination = 1
+     */
+    pagination?: PaginationRequest;
+    /**
+     * @generated from protobuf field: int64 group_id = 2
+     */
+    groupId: number;
+    /**
+     * @generated from protobuf field: optional string search = 3
+     */
+    search?: string;
+}
+/**
+ * @generated from protobuf message services.jobs.ListGroupMemberExclusionsResponse
+ */
+export interface ListGroupMemberExclusionsResponse {
+    /**
+     * @generated from protobuf field: resources.common.database.PaginationResponse pagination = 1
+     */
+    pagination?: PaginationResponse;
+    /**
+     * @generated from protobuf field: repeated resources.jobs.groups.GroupMemberExclusion exclusions = 2
+     */
+    exclusions: GroupMemberExclusion[];
+}
+/**
+ * @generated from protobuf message services.jobs.ListGroupLeadersRequest
+ */
+export interface ListGroupLeadersRequest {
+    /**
+     * @generated from protobuf field: resources.common.database.PaginationRequest pagination = 1
+     */
+    pagination?: PaginationRequest;
+    /**
+     * @generated from protobuf field: int64 group_id = 2
+     */
+    groupId: number;
+    /**
+     * @generated from protobuf field: optional string search = 3
+     */
+    search?: string;
+}
+/**
+ * @generated from protobuf message services.jobs.ListGroupLeadersResponse
+ */
+export interface ListGroupLeadersResponse {
+    /**
+     * @generated from protobuf field: resources.common.database.PaginationResponse pagination = 1
+     */
+    pagination?: PaginationResponse;
+    /**
+     * @generated from protobuf field: repeated resources.jobs.groups.GroupLeader leaders = 2
+     */
+    leaders: GroupLeader[];
+}
+/**
+ * @generated from protobuf message services.jobs.AddGroupMemberRequest
+ */
+export interface AddGroupMemberRequest {
+    /**
+     * @generated from protobuf field: int64 group_id = 1
+     */
+    groupId: number;
+    /**
+     * @generated from protobuf field: int32 user_id = 2
+     */
+    userId: number;
+    /**
+     * @generated from protobuf field: optional string reason = 3
+     */
+    reason?: string;
+}
+/**
+ * @generated from protobuf message services.jobs.AddGroupMemberResponse
+ */
+export interface AddGroupMemberResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.GroupManualMember member = 1
+     */
+    member?: GroupManualMember;
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 2
+     */
+    group?: Group;
+}
+/**
+ * @generated from protobuf message services.jobs.RemoveGroupMemberRequest
+ */
+export interface RemoveGroupMemberRequest {
+    /**
+     * @generated from protobuf field: int64 group_id = 1
+     */
+    groupId: number;
+    /**
+     * @generated from protobuf field: int32 user_id = 2
+     */
+    userId: number;
+    /**
+     * @generated from protobuf field: optional string reason = 3
+     */
+    reason?: string;
+}
+/**
+ * @generated from protobuf message services.jobs.RemoveGroupMemberResponse
+ */
+export interface RemoveGroupMemberResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 1
+     */
+    group?: Group;
+}
+/**
+ * @generated from protobuf message services.jobs.ExcludeGroupMemberRequest
+ */
+export interface ExcludeGroupMemberRequest {
+    /**
+     * @generated from protobuf field: int64 group_id = 1
+     */
+    groupId: number;
+    /**
+     * @generated from protobuf field: int32 user_id = 2
+     */
+    userId: number;
+    /**
+     * @generated from protobuf field: resources.jobs.groups.GroupExclusionReason reason_type = 3
+     */
+    reasonType: GroupExclusionReason;
+    /**
+     * @generated from protobuf field: optional string reason = 4
+     */
+    reason?: string;
+}
+/**
+ * @generated from protobuf message services.jobs.ExcludeGroupMemberResponse
+ */
+export interface ExcludeGroupMemberResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.GroupMemberExclusion exclusion = 1
+     */
+    exclusion?: GroupMemberExclusion;
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 2
+     */
+    group?: Group;
+}
+/**
+ * @generated from protobuf message services.jobs.RemoveGroupMemberExclusionRequest
+ */
+export interface RemoveGroupMemberExclusionRequest {
+    /**
+     * @generated from protobuf field: int64 group_id = 1
+     */
+    groupId: number;
+    /**
+     * @generated from protobuf field: int32 user_id = 2
+     */
+    userId: number;
+    /**
+     * @generated from protobuf field: optional string reason = 3
+     */
+    reason?: string;
+}
+/**
+ * @generated from protobuf message services.jobs.RemoveGroupMemberExclusionResponse
+ */
+export interface RemoveGroupMemberExclusionResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 1
+     */
+    group?: Group;
+}
+/**
+ * @generated from protobuf message services.jobs.AddGroupLeaderRequest
+ */
+export interface AddGroupLeaderRequest {
+    /**
+     * @generated from protobuf field: int64 group_id = 1
+     */
+    groupId: number;
+    /**
+     * @generated from protobuf field: int32 user_id = 2
+     */
+    userId: number;
+    /**
+     * @generated from protobuf field: optional string reason = 3
+     */
+    reason?: string;
+}
+/**
+ * @generated from protobuf message services.jobs.AddGroupLeaderResponse
+ */
+export interface AddGroupLeaderResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.GroupLeader leader = 1
+     */
+    leader?: GroupLeader;
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 2
+     */
+    group?: Group;
+}
+/**
+ * @generated from protobuf message services.jobs.RemoveGroupLeaderRequest
+ */
+export interface RemoveGroupLeaderRequest {
+    /**
+     * @generated from protobuf field: int64 group_id = 1
+     */
+    groupId: number;
+    /**
+     * @generated from protobuf field: int32 user_id = 2
+     */
+    userId: number;
+    /**
+     * @generated from protobuf field: optional string reason = 3
+     */
+    reason?: string;
+}
+/**
+ * @generated from protobuf message services.jobs.RemoveGroupLeaderResponse
+ */
+export interface RemoveGroupLeaderResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 1
+     */
+    group?: Group;
+}
+/**
+ * @generated from protobuf message services.jobs.GroupRuleInput
+ */
+export interface GroupRuleInput {
+    /**
+     * @generated from protobuf field: optional bool enabled = 1
+     */
+    enabled?: boolean;
+    /**
+     * @generated from protobuf oneof: rule
+     */
+    rule: {
+        oneofKind: "grade";
+        /**
+         * @generated from protobuf field: resources.jobs.groups.GroupGradeRule grade = 10
+         */
+        grade: GroupGradeRule;
+    } | {
+        oneofKind: "qualification";
+        /**
+         * @generated from protobuf field: resources.jobs.groups.GroupQualificationRule qualification = 11
+         */
+        qualification: GroupQualificationRule;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message services.jobs.CreateGroupRuleRequest
+ */
+export interface CreateGroupRuleRequest {
+    /**
+     * @generated from protobuf field: int64 group_id = 1
+     */
+    groupId: number;
+    /**
+     * @generated from protobuf field: services.jobs.GroupRuleInput rule = 2
+     */
+    rule?: GroupRuleInput;
+    /**
+     * @generated from protobuf field: optional string reason = 3
+     */
+    reason?: string;
+}
+/**
+ * @generated from protobuf message services.jobs.CreateGroupRuleResponse
+ */
+export interface CreateGroupRuleResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.GroupRule rule = 1
+     */
+    rule?: GroupRule;
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 2
+     */
+    group?: Group;
+}
+/**
+ * @generated from protobuf message services.jobs.UpdateGroupRuleRequest
+ */
+export interface UpdateGroupRuleRequest {
+    /**
+     * @generated from protobuf field: int64 group_id = 1
+     */
+    groupId: number;
+    /**
+     * @generated from protobuf field: int64 rule_id = 2
+     */
+    ruleId: number;
+    /**
+     * @generated from protobuf field: services.jobs.GroupRuleInput rule = 3
+     */
+    rule?: GroupRuleInput;
+    /**
+     * @generated from protobuf field: optional string reason = 4
+     */
+    reason?: string;
+}
+/**
+ * @generated from protobuf message services.jobs.UpdateGroupRuleResponse
+ */
+export interface UpdateGroupRuleResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.GroupRule rule = 1
+     */
+    rule?: GroupRule;
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 2
+     */
+    group?: Group;
+}
+/**
+ * @generated from protobuf message services.jobs.DeleteGroupRuleRequest
+ */
+export interface DeleteGroupRuleRequest {
+    /**
+     * @generated from protobuf field: int64 group_id = 1
+     */
+    groupId: number;
+    /**
+     * @generated from protobuf field: int64 rule_id = 2
+     */
+    ruleId: number;
+    /**
+     * @generated from protobuf field: optional string reason = 3
+     */
+    reason?: string;
+}
+/**
+ * @generated from protobuf message services.jobs.DeleteGroupRuleResponse
+ */
+export interface DeleteGroupRuleResponse {
+    /**
+     * @generated from protobuf field: resources.jobs.groups.Group group = 1
+     */
+    group?: Group;
+}
+/**
+ * @generated from protobuf message services.jobs.ListGroupActivityRequest
+ */
+export interface ListGroupActivityRequest {
+    /**
+     * @generated from protobuf field: optional resources.common.database.PaginationRequest pagination = 1
+     */
+    pagination?: PaginationRequest;
+    /**
+     * @generated from protobuf field: optional resources.common.database.Sort sort = 2
+     */
+    sort?: Sort;
+    /**
+     * @generated from protobuf field: int64 group_id = 3
+     */
+    groupId: number;
+    /**
+     * @generated from protobuf field: repeated resources.jobs.groups.GroupActivityType types = 4
+     */
+    types: GroupActivityType[];
+    /**
+     * @generated from protobuf field: optional int32 user_id = 5
+     */
+    userId?: number;
+    /**
+     * @generated from protobuf field: optional resources.timestamp.Timestamp from = 6
+     */
+    from?: Timestamp;
+    /**
+     * @generated from protobuf field: optional resources.timestamp.Timestamp to = 7
+     */
+    to?: Timestamp;
+}
+/**
+ * @generated from protobuf message services.jobs.ListGroupActivityResponse
+ */
+export interface ListGroupActivityResponse {
+    /**
+     * @generated from protobuf field: optional resources.common.database.PaginationResponse pagination = 1
+     */
+    pagination?: PaginationResponse;
+    /**
+     * @generated from protobuf field: repeated resources.jobs.groups.GroupActivity activity = 2
+     */
+    activity: GroupActivity[];
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class ListGroupsRequest$Type extends MessageType<ListGroupsRequest> {
+    constructor() {
+        super("services.jobs.ListGroupsRequest", [
+            { no: 1, name: "pagination", kind: "message", T: () => PaginationRequest, options: { "buf.validate.field": { required: true } } },
+            { no: 2, name: "sort", kind: "message", T: () => Sort },
+            { no: 3, name: "states", kind: "enum", repeat: 1 /*RepeatType.PACKED*/, T: () => ["resources.jobs.groups.GroupState", GroupState, "GROUP_STATE_"], options: { "buf.validate.field": { repeated: { maxItems: "3", items: { enum: { definedOnly: true } } } } } },
+            { no: 4, name: "search", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "include_counts", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 6, name: "include_inactive", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 7, name: "include_archived", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 8, name: "group_ids", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 5 /*ScalarType.INT32*/, options: { "buf.validate.field": { repeated: { maxItems: "10", items: { int32: { gt: 0 } } } } } },
+            { no: 9, name: "kind", kind: "enum", opt: true, T: () => ["resources.jobs.groups.GroupType", GroupType, "GROUP_TYPE_"], options: { "buf.validate.field": { enum: { definedOnly: true } } } }
+        ]);
+    }
+    create(value?: PartialMessage<ListGroupsRequest>): ListGroupsRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.states = [];
+        message.includeCounts = false;
+        message.includeInactive = false;
+        message.includeArchived = false;
+        message.groupIds = [];
+        if (value !== undefined)
+            reflectionMergePartial<ListGroupsRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListGroupsRequest): ListGroupsRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.common.database.PaginationRequest pagination */ 1:
+                    message.pagination = PaginationRequest.internalBinaryRead(reader, reader.uint32(), options, message.pagination);
+                    break;
+                case /* optional resources.common.database.Sort sort */ 2:
+                    message.sort = Sort.internalBinaryRead(reader, reader.uint32(), options, message.sort);
+                    break;
+                case /* repeated resources.jobs.groups.GroupState states */ 3:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.states.push(reader.int32());
+                    else
+                        message.states.push(reader.int32());
+                    break;
+                case /* optional string search */ 4:
+                    message.search = reader.string();
+                    break;
+                case /* bool include_counts */ 5:
+                    message.includeCounts = reader.bool();
+                    break;
+                case /* bool include_inactive */ 6:
+                    message.includeInactive = reader.bool();
+                    break;
+                case /* bool include_archived */ 7:
+                    message.includeArchived = reader.bool();
+                    break;
+                case /* repeated int32 group_ids */ 8:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.groupIds.push(reader.int32());
+                    else
+                        message.groupIds.push(reader.int32());
+                    break;
+                case /* optional resources.jobs.groups.GroupType kind */ 9:
+                    message.kind = 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: ListGroupsRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.common.database.PaginationRequest pagination = 1; */
+        if (message.pagination)
+            PaginationRequest.internalBinaryWrite(message.pagination, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* optional resources.common.database.Sort sort = 2; */
+        if (message.sort)
+            Sort.internalBinaryWrite(message.sort, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* repeated resources.jobs.groups.GroupState states = 3; */
+        if (message.states.length) {
+            writer.tag(3, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.states.length; i++)
+                writer.int32(message.states[i]);
+            writer.join();
+        }
+        /* optional string search = 4; */
+        if (message.search !== undefined)
+            writer.tag(4, WireType.LengthDelimited).string(message.search);
+        /* bool include_counts = 5; */
+        if (message.includeCounts !== false)
+            writer.tag(5, WireType.Varint).bool(message.includeCounts);
+        /* bool include_inactive = 6; */
+        if (message.includeInactive !== false)
+            writer.tag(6, WireType.Varint).bool(message.includeInactive);
+        /* bool include_archived = 7; */
+        if (message.includeArchived !== false)
+            writer.tag(7, WireType.Varint).bool(message.includeArchived);
+        /* repeated int32 group_ids = 8; */
+        if (message.groupIds.length) {
+            writer.tag(8, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.groupIds.length; i++)
+                writer.int32(message.groupIds[i]);
+            writer.join();
+        }
+        /* optional resources.jobs.groups.GroupType kind = 9; */
+        if (message.kind !== undefined)
+            writer.tag(9, WireType.Varint).int32(message.kind);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.ListGroupsRequest
+ */
+export const ListGroupsRequest = new ListGroupsRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListGroupsResponse$Type extends MessageType<ListGroupsResponse> {
+    constructor() {
+        super("services.jobs.ListGroupsResponse", [
+            { no: 1, name: "pagination", kind: "message", T: () => PaginationResponse, options: { "buf.validate.field": { required: true } } },
+            { no: 2, name: "groups", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Group, options: { "codegen.itemslen.enabled": true } }
+        ]);
+    }
+    create(value?: PartialMessage<ListGroupsResponse>): ListGroupsResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groups = [];
+        if (value !== undefined)
+            reflectionMergePartial<ListGroupsResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListGroupsResponse): ListGroupsResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.common.database.PaginationResponse pagination */ 1:
+                    message.pagination = PaginationResponse.internalBinaryRead(reader, reader.uint32(), options, message.pagination);
+                    break;
+                case /* repeated resources.jobs.groups.Group groups */ 2:
+                    message.groups.push(Group.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: ListGroupsResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.common.database.PaginationResponse pagination = 1; */
+        if (message.pagination)
+            PaginationResponse.internalBinaryWrite(message.pagination, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated resources.jobs.groups.Group groups = 2; */
+        for (let i = 0; i < message.groups.length; i++)
+            Group.internalBinaryWrite(message.groups[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 services.jobs.ListGroupsResponse
+ */
+export const ListGroupsResponse = new ListGroupsResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetGroupRequest$Type extends MessageType<GetGroupRequest> {
+    constructor() {
+        super("services.jobs.GetGroupRequest", [
+            { no: 1, name: "id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "include_archived", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value?: PartialMessage<GetGroupRequest>): GetGroupRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = 0;
+        message.includeArchived = false;
+        if (value !== undefined)
+            reflectionMergePartial<GetGroupRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetGroupRequest): GetGroupRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 id */ 1:
+                    message.id = reader.int64().toNumber();
+                    break;
+                case /* bool include_archived */ 2:
+                    message.includeArchived = 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: GetGroupRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 id = 1; */
+        if (message.id !== 0)
+            writer.tag(1, WireType.Varint).int64(message.id);
+        /* bool include_archived = 2; */
+        if (message.includeArchived !== false)
+            writer.tag(2, WireType.Varint).bool(message.includeArchived);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.GetGroupRequest
+ */
+export const GetGroupRequest = new GetGroupRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetGroupResponse$Type extends MessageType<GetGroupResponse> {
+    constructor() {
+        super("services.jobs.GetGroupResponse", [
+            { no: 1, name: "group", kind: "message", T: () => Group },
+            { no: 2, name: "access", kind: "message", T: () => Access }
+        ]);
+    }
+    create(value?: PartialMessage<GetGroupResponse>): GetGroupResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<GetGroupResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetGroupResponse): GetGroupResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.Group group */ 1:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    break;
+                case /* optional resources.access.Access access */ 2:
+                    message.access = Access.internalBinaryRead(reader, reader.uint32(), options, message.access);
+                    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: GetGroupResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.Group group = 1; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* optional resources.access.Access access = 2; */
+        if (message.access)
+            Access.internalBinaryWrite(message.access, 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 services.jobs.GetGroupResponse
+ */
+export const GetGroupResponse = new GetGroupResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CreateGroupRequest$Type extends MessageType<CreateGroupRequest> {
+    constructor() {
+        super("services.jobs.CreateGroupRequest", [
+            { no: 1, name: "job", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "buf.validate.field": { string: { maxLen: "20" } } } },
+            { no: 2, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "description", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "short_name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "color", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "type", kind: "enum", opt: true, T: () => ["resources.jobs.groups.GroupType", GroupType, "GROUP_TYPE_"], options: { "buf.validate.field": { enum: { definedOnly: true } } } },
+            { no: 8, name: "membership_mode", kind: "enum", opt: true, T: () => ["resources.jobs.groups.GroupMembershipMode", GroupMembershipMode, "GROUP_MEMBERSHIP_MODE_"], options: { "buf.validate.field": { enum: { definedOnly: true } } } },
+            { no: 9, name: "sort_rank", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/, options: { "buf.validate.field": { string: { maxLen: "32" } } } },
+            { no: 10, name: "leader_user_ids", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 5 /*ScalarType.INT32*/, options: { "buf.validate.field": { repeated: { maxItems: "20" } } } },
+            { no: 11, name: "manual_member_user_ids", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 5 /*ScalarType.INT32*/, options: { "buf.validate.field": { repeated: { maxItems: "100" } } } },
+            { no: 12, name: "rules", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GroupRuleInput, options: { "buf.validate.field": { repeated: { maxItems: "50" } } } },
+            { no: 13, name: "access", kind: "message", T: () => Access }
+        ]);
+    }
+    create(value?: PartialMessage<CreateGroupRequest>): CreateGroupRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.job = "";
+        message.name = "";
+        message.leaderUserIds = [];
+        message.manualMemberUserIds = [];
+        message.rules = [];
+        if (value !== undefined)
+            reflectionMergePartial<CreateGroupRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CreateGroupRequest): CreateGroupRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string job */ 1:
+                    message.job = reader.string();
+                    break;
+                case /* string name */ 2:
+                    message.name = reader.string();
+                    break;
+                case /* optional string description */ 3:
+                    message.description = reader.string();
+                    break;
+                case /* optional string short_name */ 4:
+                    message.shortName = reader.string();
+                    break;
+                case /* optional string color */ 6:
+                    message.color = reader.string();
+                    break;
+                case /* optional resources.jobs.groups.GroupType type */ 7:
+                    message.type = reader.int32();
+                    break;
+                case /* optional resources.jobs.groups.GroupMembershipMode membership_mode */ 8:
+                    message.membershipMode = reader.int32();
+                    break;
+                case /* optional string sort_rank */ 9:
+                    message.sortRank = reader.string();
+                    break;
+                case /* repeated int32 leader_user_ids */ 10:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.leaderUserIds.push(reader.int32());
+                    else
+                        message.leaderUserIds.push(reader.int32());
+                    break;
+                case /* repeated int32 manual_member_user_ids */ 11:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.manualMemberUserIds.push(reader.int32());
+                    else
+                        message.manualMemberUserIds.push(reader.int32());
+                    break;
+                case /* repeated services.jobs.GroupRuleInput rules */ 12:
+                    message.rules.push(GroupRuleInput.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* optional resources.access.Access access */ 13:
+                    message.access = Access.internalBinaryRead(reader, reader.uint32(), options, message.access);
+                    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: CreateGroupRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string job = 1; */
+        if (message.job !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.job);
+        /* string name = 2; */
+        if (message.name !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.name);
+        /* optional string description = 3; */
+        if (message.description !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.description);
+        /* optional string short_name = 4; */
+        if (message.shortName !== undefined)
+            writer.tag(4, WireType.LengthDelimited).string(message.shortName);
+        /* optional string color = 6; */
+        if (message.color !== undefined)
+            writer.tag(6, WireType.LengthDelimited).string(message.color);
+        /* optional resources.jobs.groups.GroupType type = 7; */
+        if (message.type !== undefined)
+            writer.tag(7, WireType.Varint).int32(message.type);
+        /* optional resources.jobs.groups.GroupMembershipMode membership_mode = 8; */
+        if (message.membershipMode !== undefined)
+            writer.tag(8, WireType.Varint).int32(message.membershipMode);
+        /* optional string sort_rank = 9; */
+        if (message.sortRank !== undefined)
+            writer.tag(9, WireType.LengthDelimited).string(message.sortRank);
+        /* repeated int32 leader_user_ids = 10; */
+        if (message.leaderUserIds.length) {
+            writer.tag(10, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.leaderUserIds.length; i++)
+                writer.int32(message.leaderUserIds[i]);
+            writer.join();
+        }
+        /* repeated int32 manual_member_user_ids = 11; */
+        if (message.manualMemberUserIds.length) {
+            writer.tag(11, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.manualMemberUserIds.length; i++)
+                writer.int32(message.manualMemberUserIds[i]);
+            writer.join();
+        }
+        /* repeated services.jobs.GroupRuleInput rules = 12; */
+        for (let i = 0; i < message.rules.length; i++)
+            GroupRuleInput.internalBinaryWrite(message.rules[i], writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+        /* optional resources.access.Access access = 13; */
+        if (message.access)
+            Access.internalBinaryWrite(message.access, writer.tag(13, 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.jobs.CreateGroupRequest
+ */
+export const CreateGroupRequest = new CreateGroupRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CreateGroupResponse$Type extends MessageType<CreateGroupResponse> {
+    constructor() {
+        super("services.jobs.CreateGroupResponse", [
+            { no: 1, name: "group", kind: "message", T: () => Group }
+        ]);
+    }
+    create(value?: PartialMessage<CreateGroupResponse>): CreateGroupResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<CreateGroupResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CreateGroupResponse): CreateGroupResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.Group group */ 1:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    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: CreateGroupResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.Group group = 1; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, writer.tag(1, 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.jobs.CreateGroupResponse
+ */
+export const CreateGroupResponse = new CreateGroupResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UpdateGroupRequest$Type extends MessageType<UpdateGroupRequest> {
+    constructor() {
+        super("services.jobs.UpdateGroupRequest", [
+            { no: 1, name: "id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "description", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "short_name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "color", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "state", kind: "enum", opt: true, T: () => ["resources.jobs.groups.GroupState", GroupState, "GROUP_STATE_"], options: { "buf.validate.field": { enum: { definedOnly: true } } } },
+            { no: 8, name: "type", kind: "enum", opt: true, T: () => ["resources.jobs.groups.GroupType", GroupType, "GROUP_TYPE_"], options: { "buf.validate.field": { enum: { definedOnly: true } } } },
+            { no: 9, name: "membership_mode", kind: "enum", opt: true, T: () => ["resources.jobs.groups.GroupMembershipMode", GroupMembershipMode, "GROUP_MEMBERSHIP_MODE_"], options: { "buf.validate.field": { enum: { definedOnly: true } } } },
+            { no: 10, name: "sort_rank", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/, options: { "buf.validate.field": { string: { maxLen: "32" } } } },
+            { no: 11, name: "access", kind: "message", T: () => Access }
+        ]);
+    }
+    create(value?: PartialMessage<UpdateGroupRequest>): UpdateGroupRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = 0;
+        if (value !== undefined)
+            reflectionMergePartial<UpdateGroupRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UpdateGroupRequest): UpdateGroupRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 id */ 1:
+                    message.id = reader.int64().toNumber();
+                    break;
+                case /* optional string name */ 2:
+                    message.name = reader.string();
+                    break;
+                case /* optional string description */ 3:
+                    message.description = reader.string();
+                    break;
+                case /* optional string short_name */ 4:
+                    message.shortName = reader.string();
+                    break;
+                case /* optional string color */ 6:
+                    message.color = reader.string();
+                    break;
+                case /* optional resources.jobs.groups.GroupState state */ 7:
+                    message.state = reader.int32();
+                    break;
+                case /* optional resources.jobs.groups.GroupType type */ 8:
+                    message.type = reader.int32();
+                    break;
+                case /* optional resources.jobs.groups.GroupMembershipMode membership_mode */ 9:
+                    message.membershipMode = reader.int32();
+                    break;
+                case /* optional string sort_rank */ 10:
+                    message.sortRank = reader.string();
+                    break;
+                case /* optional resources.access.Access access */ 11:
+                    message.access = Access.internalBinaryRead(reader, reader.uint32(), options, message.access);
+                    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: UpdateGroupRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 id = 1; */
+        if (message.id !== 0)
+            writer.tag(1, WireType.Varint).int64(message.id);
+        /* optional string name = 2; */
+        if (message.name !== undefined)
+            writer.tag(2, WireType.LengthDelimited).string(message.name);
+        /* optional string description = 3; */
+        if (message.description !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.description);
+        /* optional string short_name = 4; */
+        if (message.shortName !== undefined)
+            writer.tag(4, WireType.LengthDelimited).string(message.shortName);
+        /* optional string color = 6; */
+        if (message.color !== undefined)
+            writer.tag(6, WireType.LengthDelimited).string(message.color);
+        /* optional resources.jobs.groups.GroupState state = 7; */
+        if (message.state !== undefined)
+            writer.tag(7, WireType.Varint).int32(message.state);
+        /* optional resources.jobs.groups.GroupType type = 8; */
+        if (message.type !== undefined)
+            writer.tag(8, WireType.Varint).int32(message.type);
+        /* optional resources.jobs.groups.GroupMembershipMode membership_mode = 9; */
+        if (message.membershipMode !== undefined)
+            writer.tag(9, WireType.Varint).int32(message.membershipMode);
+        /* optional string sort_rank = 10; */
+        if (message.sortRank !== undefined)
+            writer.tag(10, WireType.LengthDelimited).string(message.sortRank);
+        /* optional resources.access.Access access = 11; */
+        if (message.access)
+            Access.internalBinaryWrite(message.access, writer.tag(11, 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.jobs.UpdateGroupRequest
+ */
+export const UpdateGroupRequest = new UpdateGroupRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UpdateGroupResponse$Type extends MessageType<UpdateGroupResponse> {
+    constructor() {
+        super("services.jobs.UpdateGroupResponse", [
+            { no: 1, name: "group", kind: "message", T: () => Group }
+        ]);
+    }
+    create(value?: PartialMessage<UpdateGroupResponse>): UpdateGroupResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<UpdateGroupResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UpdateGroupResponse): UpdateGroupResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.Group group */ 1:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    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: UpdateGroupResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.Group group = 1; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, writer.tag(1, 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.jobs.UpdateGroupResponse
+ */
+export const UpdateGroupResponse = new UpdateGroupResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ArchiveGroupRequest$Type extends MessageType<ArchiveGroupRequest> {
+    constructor() {
+        super("services.jobs.ArchiveGroupRequest", [
+            { no: 1, name: "id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "reason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ArchiveGroupRequest>): ArchiveGroupRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = 0;
+        if (value !== undefined)
+            reflectionMergePartial<ArchiveGroupRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ArchiveGroupRequest): ArchiveGroupRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 id */ 1:
+                    message.id = reader.int64().toNumber();
+                    break;
+                case /* optional string reason */ 2:
+                    message.reason = 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: ArchiveGroupRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 id = 1; */
+        if (message.id !== 0)
+            writer.tag(1, WireType.Varint).int64(message.id);
+        /* optional string reason = 2; */
+        if (message.reason !== undefined)
+            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.ArchiveGroupRequest
+ */
+export const ArchiveGroupRequest = new ArchiveGroupRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ArchiveGroupResponse$Type extends MessageType<ArchiveGroupResponse> {
+    constructor() {
+        super("services.jobs.ArchiveGroupResponse", [
+            { no: 1, name: "group", kind: "message", T: () => Group }
+        ]);
+    }
+    create(value?: PartialMessage<ArchiveGroupResponse>): ArchiveGroupResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<ArchiveGroupResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ArchiveGroupResponse): ArchiveGroupResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.Group group */ 1:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    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: ArchiveGroupResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.Group group = 1; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, writer.tag(1, 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.jobs.ArchiveGroupResponse
+ */
+export const ArchiveGroupResponse = new ArchiveGroupResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RestoreGroupRequest$Type extends MessageType<RestoreGroupRequest> {
+    constructor() {
+        super("services.jobs.RestoreGroupRequest", [
+            { no: 1, name: "id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "reason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<RestoreGroupRequest>): RestoreGroupRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = 0;
+        if (value !== undefined)
+            reflectionMergePartial<RestoreGroupRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RestoreGroupRequest): RestoreGroupRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 id */ 1:
+                    message.id = reader.int64().toNumber();
+                    break;
+                case /* optional string reason */ 2:
+                    message.reason = 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: RestoreGroupRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 id = 1; */
+        if (message.id !== 0)
+            writer.tag(1, WireType.Varint).int64(message.id);
+        /* optional string reason = 2; */
+        if (message.reason !== undefined)
+            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.RestoreGroupRequest
+ */
+export const RestoreGroupRequest = new RestoreGroupRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RestoreGroupResponse$Type extends MessageType<RestoreGroupResponse> {
+    constructor() {
+        super("services.jobs.RestoreGroupResponse", [
+            { no: 1, name: "group", kind: "message", T: () => Group }
+        ]);
+    }
+    create(value?: PartialMessage<RestoreGroupResponse>): RestoreGroupResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<RestoreGroupResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RestoreGroupResponse): RestoreGroupResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.Group group */ 1:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    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: RestoreGroupResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.Group group = 1; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, writer.tag(1, 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.jobs.RestoreGroupResponse
+ */
+export const RestoreGroupResponse = new RestoreGroupResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DeleteGroupLogoRequest$Type extends MessageType<DeleteGroupLogoRequest> {
+    constructor() {
+        super("services.jobs.DeleteGroupLogoRequest", [
+            { no: 1, name: "id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ }
+        ]);
+    }
+    create(value?: PartialMessage<DeleteGroupLogoRequest>): DeleteGroupLogoRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = 0;
+        if (value !== undefined)
+            reflectionMergePartial<DeleteGroupLogoRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteGroupLogoRequest): DeleteGroupLogoRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 id */ 1:
+                    message.id = 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: DeleteGroupLogoRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 id = 1; */
+        if (message.id !== 0)
+            writer.tag(1, WireType.Varint).int64(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.jobs.DeleteGroupLogoRequest
+ */
+export const DeleteGroupLogoRequest = new DeleteGroupLogoRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DeleteGroupLogoResponse$Type extends MessageType<DeleteGroupLogoResponse> {
+    constructor() {
+        super("services.jobs.DeleteGroupLogoResponse", [
+            { no: 1, name: "group", kind: "message", T: () => Group }
+        ]);
+    }
+    create(value?: PartialMessage<DeleteGroupLogoResponse>): DeleteGroupLogoResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<DeleteGroupLogoResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteGroupLogoResponse): DeleteGroupLogoResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.Group group */ 1:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    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: DeleteGroupLogoResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.Group group = 1; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, writer.tag(1, 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.jobs.DeleteGroupLogoResponse
+ */
+export const DeleteGroupLogoResponse = new DeleteGroupLogoResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListGroupMembersRequest$Type extends MessageType<ListGroupMembersRequest> {
+    constructor() {
+        super("services.jobs.ListGroupMembersRequest", [
+            { no: 1, name: "pagination", kind: "message", T: () => PaginationRequest, options: { "buf.validate.field": { required: true } } },
+            { no: 2, name: "sort", kind: "message", T: () => Sort },
+            { no: 3, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 4, name: "search", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "include_excluded", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 6, name: "include_leaders", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 7, name: "include_reasons", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 8, name: "sources", kind: "enum", repeat: 1 /*RepeatType.PACKED*/, T: () => ["resources.jobs.groups.GroupMemberSource", GroupMemberSource, "GROUP_MEMBER_SOURCE_"], options: { "buf.validate.field": { repeated: { maxItems: "3", items: { enum: { definedOnly: true } } } } } }
+        ]);
+    }
+    create(value?: PartialMessage<ListGroupMembersRequest>): ListGroupMembersRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        message.includeExcluded = false;
+        message.includeLeaders = false;
+        message.includeReasons = false;
+        message.sources = [];
+        if (value !== undefined)
+            reflectionMergePartial<ListGroupMembersRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListGroupMembersRequest): ListGroupMembersRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.common.database.PaginationRequest pagination */ 1:
+                    message.pagination = PaginationRequest.internalBinaryRead(reader, reader.uint32(), options, message.pagination);
+                    break;
+                case /* optional resources.common.database.Sort sort */ 2:
+                    message.sort = Sort.internalBinaryRead(reader, reader.uint32(), options, message.sort);
+                    break;
+                case /* int64 group_id */ 3:
+                    message.groupId = reader.int64().toNumber();
+                    break;
+                case /* optional string search */ 4:
+                    message.search = reader.string();
+                    break;
+                case /* bool include_excluded */ 5:
+                    message.includeExcluded = reader.bool();
+                    break;
+                case /* bool include_leaders */ 6:
+                    message.includeLeaders = reader.bool();
+                    break;
+                case /* bool include_reasons */ 7:
+                    message.includeReasons = reader.bool();
+                    break;
+                case /* repeated resources.jobs.groups.GroupMemberSource sources */ 8:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.sources.push(reader.int32());
+                    else
+                        message.sources.push(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: ListGroupMembersRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.common.database.PaginationRequest pagination = 1; */
+        if (message.pagination)
+            PaginationRequest.internalBinaryWrite(message.pagination, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* optional resources.common.database.Sort sort = 2; */
+        if (message.sort)
+            Sort.internalBinaryWrite(message.sort, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* int64 group_id = 3; */
+        if (message.groupId !== 0)
+            writer.tag(3, WireType.Varint).int64(message.groupId);
+        /* optional string search = 4; */
+        if (message.search !== undefined)
+            writer.tag(4, WireType.LengthDelimited).string(message.search);
+        /* bool include_excluded = 5; */
+        if (message.includeExcluded !== false)
+            writer.tag(5, WireType.Varint).bool(message.includeExcluded);
+        /* bool include_leaders = 6; */
+        if (message.includeLeaders !== false)
+            writer.tag(6, WireType.Varint).bool(message.includeLeaders);
+        /* bool include_reasons = 7; */
+        if (message.includeReasons !== false)
+            writer.tag(7, WireType.Varint).bool(message.includeReasons);
+        /* repeated resources.jobs.groups.GroupMemberSource sources = 8; */
+        if (message.sources.length) {
+            writer.tag(8, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.sources.length; i++)
+                writer.int32(message.sources[i]);
+            writer.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.jobs.ListGroupMembersRequest
+ */
+export const ListGroupMembersRequest = new ListGroupMembersRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListGroupMembersResponse$Type extends MessageType<ListGroupMembersResponse> {
+    constructor() {
+        super("services.jobs.ListGroupMembersResponse", [
+            { no: 1, name: "pagination", kind: "message", T: () => PaginationResponse, options: { "buf.validate.field": { required: true } } },
+            { no: 2, name: "members", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GroupResolvedMember, options: { "codegen.itemslen.enabled": true } }
+        ]);
+    }
+    create(value?: PartialMessage<ListGroupMembersResponse>): ListGroupMembersResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.members = [];
+        if (value !== undefined)
+            reflectionMergePartial<ListGroupMembersResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListGroupMembersResponse): ListGroupMembersResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.common.database.PaginationResponse pagination */ 1:
+                    message.pagination = PaginationResponse.internalBinaryRead(reader, reader.uint32(), options, message.pagination);
+                    break;
+                case /* repeated resources.jobs.groups.GroupResolvedMember members */ 2:
+                    message.members.push(GroupResolvedMember.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: ListGroupMembersResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.common.database.PaginationResponse pagination = 1; */
+        if (message.pagination)
+            PaginationResponse.internalBinaryWrite(message.pagination, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated resources.jobs.groups.GroupResolvedMember members = 2; */
+        for (let i = 0; i < message.members.length; i++)
+            GroupResolvedMember.internalBinaryWrite(message.members[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 services.jobs.ListGroupMembersResponse
+ */
+export const ListGroupMembersResponse = new ListGroupMembersResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListGroupRulesRequest$Type extends MessageType<ListGroupRulesRequest> {
+    constructor() {
+        super("services.jobs.ListGroupRulesRequest", [
+            { no: 1, name: "pagination", kind: "message", T: () => PaginationRequest, options: { "buf.validate.field": { required: true } } },
+            { no: 2, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ListGroupRulesRequest>): ListGroupRulesRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<ListGroupRulesRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListGroupRulesRequest): ListGroupRulesRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.common.database.PaginationRequest pagination */ 1:
+                    message.pagination = PaginationRequest.internalBinaryRead(reader, reader.uint32(), options, message.pagination);
+                    break;
+                case /* int64 group_id */ 2:
+                    message.groupId = 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: ListGroupRulesRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.common.database.PaginationRequest pagination = 1; */
+        if (message.pagination)
+            PaginationRequest.internalBinaryWrite(message.pagination, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* int64 group_id = 2; */
+        if (message.groupId !== 0)
+            writer.tag(2, WireType.Varint).int64(message.groupId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.ListGroupRulesRequest
+ */
+export const ListGroupRulesRequest = new ListGroupRulesRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListGroupRulesResponse$Type extends MessageType<ListGroupRulesResponse> {
+    constructor() {
+        super("services.jobs.ListGroupRulesResponse", [
+            { no: 1, name: "pagination", kind: "message", T: () => PaginationResponse, options: { "buf.validate.field": { required: true } } },
+            { no: 2, name: "rules", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GroupRule, options: { "codegen.itemslen.enabled": true } }
+        ]);
+    }
+    create(value?: PartialMessage<ListGroupRulesResponse>): ListGroupRulesResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.rules = [];
+        if (value !== undefined)
+            reflectionMergePartial<ListGroupRulesResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListGroupRulesResponse): ListGroupRulesResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.common.database.PaginationResponse pagination */ 1:
+                    message.pagination = PaginationResponse.internalBinaryRead(reader, reader.uint32(), options, message.pagination);
+                    break;
+                case /* repeated resources.jobs.groups.GroupRule rules */ 2:
+                    message.rules.push(GroupRule.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: ListGroupRulesResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.common.database.PaginationResponse pagination = 1; */
+        if (message.pagination)
+            PaginationResponse.internalBinaryWrite(message.pagination, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated resources.jobs.groups.GroupRule rules = 2; */
+        for (let i = 0; i < message.rules.length; i++)
+            GroupRule.internalBinaryWrite(message.rules[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 services.jobs.ListGroupRulesResponse
+ */
+export const ListGroupRulesResponse = new ListGroupRulesResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListGroupManualMembersRequest$Type extends MessageType<ListGroupManualMembersRequest> {
+    constructor() {
+        super("services.jobs.ListGroupManualMembersRequest", [
+            { no: 1, name: "pagination", kind: "message", T: () => PaginationRequest, options: { "buf.validate.field": { required: true } } },
+            { no: 2, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 3, name: "search", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ListGroupManualMembersRequest>): ListGroupManualMembersRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<ListGroupManualMembersRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListGroupManualMembersRequest): ListGroupManualMembersRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.common.database.PaginationRequest pagination */ 1:
+                    message.pagination = PaginationRequest.internalBinaryRead(reader, reader.uint32(), options, message.pagination);
+                    break;
+                case /* int64 group_id */ 2:
+                    message.groupId = reader.int64().toNumber();
+                    break;
+                case /* optional string search */ 3:
+                    message.search = 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: ListGroupManualMembersRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.common.database.PaginationRequest pagination = 1; */
+        if (message.pagination)
+            PaginationRequest.internalBinaryWrite(message.pagination, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* int64 group_id = 2; */
+        if (message.groupId !== 0)
+            writer.tag(2, WireType.Varint).int64(message.groupId);
+        /* optional string search = 3; */
+        if (message.search !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.search);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.ListGroupManualMembersRequest
+ */
+export const ListGroupManualMembersRequest = new ListGroupManualMembersRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListGroupManualMembersResponse$Type extends MessageType<ListGroupManualMembersResponse> {
+    constructor() {
+        super("services.jobs.ListGroupManualMembersResponse", [
+            { no: 1, name: "pagination", kind: "message", T: () => PaginationResponse, options: { "buf.validate.field": { required: true } } },
+            { no: 2, name: "manual_members", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GroupManualMember, options: { "codegen.itemslen.enabled": true } }
+        ]);
+    }
+    create(value?: PartialMessage<ListGroupManualMembersResponse>): ListGroupManualMembersResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.manualMembers = [];
+        if (value !== undefined)
+            reflectionMergePartial<ListGroupManualMembersResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListGroupManualMembersResponse): ListGroupManualMembersResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.common.database.PaginationResponse pagination */ 1:
+                    message.pagination = PaginationResponse.internalBinaryRead(reader, reader.uint32(), options, message.pagination);
+                    break;
+                case /* repeated resources.jobs.groups.GroupManualMember manual_members */ 2:
+                    message.manualMembers.push(GroupManualMember.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: ListGroupManualMembersResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.common.database.PaginationResponse pagination = 1; */
+        if (message.pagination)
+            PaginationResponse.internalBinaryWrite(message.pagination, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated resources.jobs.groups.GroupManualMember manual_members = 2; */
+        for (let i = 0; i < message.manualMembers.length; i++)
+            GroupManualMember.internalBinaryWrite(message.manualMembers[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 services.jobs.ListGroupManualMembersResponse
+ */
+export const ListGroupManualMembersResponse = new ListGroupManualMembersResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListGroupMemberExclusionsRequest$Type extends MessageType<ListGroupMemberExclusionsRequest> {
+    constructor() {
+        super("services.jobs.ListGroupMemberExclusionsRequest", [
+            { no: 1, name: "pagination", kind: "message", T: () => PaginationRequest, options: { "buf.validate.field": { required: true } } },
+            { no: 2, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 3, name: "search", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ListGroupMemberExclusionsRequest>): ListGroupMemberExclusionsRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<ListGroupMemberExclusionsRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListGroupMemberExclusionsRequest): ListGroupMemberExclusionsRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.common.database.PaginationRequest pagination */ 1:
+                    message.pagination = PaginationRequest.internalBinaryRead(reader, reader.uint32(), options, message.pagination);
+                    break;
+                case /* int64 group_id */ 2:
+                    message.groupId = reader.int64().toNumber();
+                    break;
+                case /* optional string search */ 3:
+                    message.search = 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: ListGroupMemberExclusionsRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.common.database.PaginationRequest pagination = 1; */
+        if (message.pagination)
+            PaginationRequest.internalBinaryWrite(message.pagination, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* int64 group_id = 2; */
+        if (message.groupId !== 0)
+            writer.tag(2, WireType.Varint).int64(message.groupId);
+        /* optional string search = 3; */
+        if (message.search !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.search);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.ListGroupMemberExclusionsRequest
+ */
+export const ListGroupMemberExclusionsRequest = new ListGroupMemberExclusionsRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListGroupMemberExclusionsResponse$Type extends MessageType<ListGroupMemberExclusionsResponse> {
+    constructor() {
+        super("services.jobs.ListGroupMemberExclusionsResponse", [
+            { no: 1, name: "pagination", kind: "message", T: () => PaginationResponse, options: { "buf.validate.field": { required: true } } },
+            { no: 2, name: "exclusions", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GroupMemberExclusion, options: { "codegen.itemslen.enabled": true } }
+        ]);
+    }
+    create(value?: PartialMessage<ListGroupMemberExclusionsResponse>): ListGroupMemberExclusionsResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.exclusions = [];
+        if (value !== undefined)
+            reflectionMergePartial<ListGroupMemberExclusionsResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListGroupMemberExclusionsResponse): ListGroupMemberExclusionsResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.common.database.PaginationResponse pagination */ 1:
+                    message.pagination = PaginationResponse.internalBinaryRead(reader, reader.uint32(), options, message.pagination);
+                    break;
+                case /* repeated resources.jobs.groups.GroupMemberExclusion exclusions */ 2:
+                    message.exclusions.push(GroupMemberExclusion.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: ListGroupMemberExclusionsResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.common.database.PaginationResponse pagination = 1; */
+        if (message.pagination)
+            PaginationResponse.internalBinaryWrite(message.pagination, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated resources.jobs.groups.GroupMemberExclusion exclusions = 2; */
+        for (let i = 0; i < message.exclusions.length; i++)
+            GroupMemberExclusion.internalBinaryWrite(message.exclusions[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 services.jobs.ListGroupMemberExclusionsResponse
+ */
+export const ListGroupMemberExclusionsResponse = new ListGroupMemberExclusionsResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListGroupLeadersRequest$Type extends MessageType<ListGroupLeadersRequest> {
+    constructor() {
+        super("services.jobs.ListGroupLeadersRequest", [
+            { no: 1, name: "pagination", kind: "message", T: () => PaginationRequest, options: { "buf.validate.field": { required: true } } },
+            { no: 2, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 3, name: "search", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ListGroupLeadersRequest>): ListGroupLeadersRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<ListGroupLeadersRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListGroupLeadersRequest): ListGroupLeadersRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.common.database.PaginationRequest pagination */ 1:
+                    message.pagination = PaginationRequest.internalBinaryRead(reader, reader.uint32(), options, message.pagination);
+                    break;
+                case /* int64 group_id */ 2:
+                    message.groupId = reader.int64().toNumber();
+                    break;
+                case /* optional string search */ 3:
+                    message.search = 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: ListGroupLeadersRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.common.database.PaginationRequest pagination = 1; */
+        if (message.pagination)
+            PaginationRequest.internalBinaryWrite(message.pagination, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* int64 group_id = 2; */
+        if (message.groupId !== 0)
+            writer.tag(2, WireType.Varint).int64(message.groupId);
+        /* optional string search = 3; */
+        if (message.search !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.search);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.ListGroupLeadersRequest
+ */
+export const ListGroupLeadersRequest = new ListGroupLeadersRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListGroupLeadersResponse$Type extends MessageType<ListGroupLeadersResponse> {
+    constructor() {
+        super("services.jobs.ListGroupLeadersResponse", [
+            { no: 1, name: "pagination", kind: "message", T: () => PaginationResponse, options: { "buf.validate.field": { required: true } } },
+            { no: 2, name: "leaders", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GroupLeader, options: { "codegen.itemslen.enabled": true } }
+        ]);
+    }
+    create(value?: PartialMessage<ListGroupLeadersResponse>): ListGroupLeadersResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.leaders = [];
+        if (value !== undefined)
+            reflectionMergePartial<ListGroupLeadersResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListGroupLeadersResponse): ListGroupLeadersResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.common.database.PaginationResponse pagination */ 1:
+                    message.pagination = PaginationResponse.internalBinaryRead(reader, reader.uint32(), options, message.pagination);
+                    break;
+                case /* repeated resources.jobs.groups.GroupLeader leaders */ 2:
+                    message.leaders.push(GroupLeader.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: ListGroupLeadersResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.common.database.PaginationResponse pagination = 1; */
+        if (message.pagination)
+            PaginationResponse.internalBinaryWrite(message.pagination, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated resources.jobs.groups.GroupLeader leaders = 2; */
+        for (let i = 0; i < message.leaders.length; i++)
+            GroupLeader.internalBinaryWrite(message.leaders[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 services.jobs.ListGroupLeadersResponse
+ */
+export const ListGroupLeadersResponse = new ListGroupLeadersResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AddGroupMemberRequest$Type extends MessageType<AddGroupMemberRequest> {
+    constructor() {
+        super("services.jobs.AddGroupMemberRequest", [
+            { no: 1, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "user_id", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "reason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<AddGroupMemberRequest>): AddGroupMemberRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        message.userId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<AddGroupMemberRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AddGroupMemberRequest): AddGroupMemberRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 group_id */ 1:
+                    message.groupId = reader.int64().toNumber();
+                    break;
+                case /* int32 user_id */ 2:
+                    message.userId = reader.int32();
+                    break;
+                case /* optional string reason */ 3:
+                    message.reason = 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: AddGroupMemberRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 group_id = 1; */
+        if (message.groupId !== 0)
+            writer.tag(1, WireType.Varint).int64(message.groupId);
+        /* int32 user_id = 2; */
+        if (message.userId !== 0)
+            writer.tag(2, WireType.Varint).int32(message.userId);
+        /* optional string reason = 3; */
+        if (message.reason !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.AddGroupMemberRequest
+ */
+export const AddGroupMemberRequest = new AddGroupMemberRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AddGroupMemberResponse$Type extends MessageType<AddGroupMemberResponse> {
+    constructor() {
+        super("services.jobs.AddGroupMemberResponse", [
+            { no: 1, name: "member", kind: "message", T: () => GroupManualMember },
+            { no: 2, name: "group", kind: "message", T: () => Group }
+        ]);
+    }
+    create(value?: PartialMessage<AddGroupMemberResponse>): AddGroupMemberResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<AddGroupMemberResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AddGroupMemberResponse): AddGroupMemberResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.GroupManualMember member */ 1:
+                    message.member = GroupManualMember.internalBinaryRead(reader, reader.uint32(), options, message.member);
+                    break;
+                case /* resources.jobs.groups.Group group */ 2:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    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: AddGroupMemberResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.GroupManualMember member = 1; */
+        if (message.member)
+            GroupManualMember.internalBinaryWrite(message.member, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* resources.jobs.groups.Group group = 2; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, 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 services.jobs.AddGroupMemberResponse
+ */
+export const AddGroupMemberResponse = new AddGroupMemberResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoveGroupMemberRequest$Type extends MessageType<RemoveGroupMemberRequest> {
+    constructor() {
+        super("services.jobs.RemoveGroupMemberRequest", [
+            { no: 1, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "user_id", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "reason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<RemoveGroupMemberRequest>): RemoveGroupMemberRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        message.userId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<RemoveGroupMemberRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RemoveGroupMemberRequest): RemoveGroupMemberRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 group_id */ 1:
+                    message.groupId = reader.int64().toNumber();
+                    break;
+                case /* int32 user_id */ 2:
+                    message.userId = reader.int32();
+                    break;
+                case /* optional string reason */ 3:
+                    message.reason = 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: RemoveGroupMemberRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 group_id = 1; */
+        if (message.groupId !== 0)
+            writer.tag(1, WireType.Varint).int64(message.groupId);
+        /* int32 user_id = 2; */
+        if (message.userId !== 0)
+            writer.tag(2, WireType.Varint).int32(message.userId);
+        /* optional string reason = 3; */
+        if (message.reason !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.RemoveGroupMemberRequest
+ */
+export const RemoveGroupMemberRequest = new RemoveGroupMemberRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoveGroupMemberResponse$Type extends MessageType<RemoveGroupMemberResponse> {
+    constructor() {
+        super("services.jobs.RemoveGroupMemberResponse", [
+            { no: 1, name: "group", kind: "message", T: () => Group }
+        ]);
+    }
+    create(value?: PartialMessage<RemoveGroupMemberResponse>): RemoveGroupMemberResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<RemoveGroupMemberResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RemoveGroupMemberResponse): RemoveGroupMemberResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.Group group */ 1:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    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: RemoveGroupMemberResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.Group group = 1; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, writer.tag(1, 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.jobs.RemoveGroupMemberResponse
+ */
+export const RemoveGroupMemberResponse = new RemoveGroupMemberResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExcludeGroupMemberRequest$Type extends MessageType<ExcludeGroupMemberRequest> {
+    constructor() {
+        super("services.jobs.ExcludeGroupMemberRequest", [
+            { no: 1, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "user_id", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "reason_type", kind: "enum", T: () => ["resources.jobs.groups.GroupExclusionReason", GroupExclusionReason, "GROUP_EXCLUSION_REASON_"], options: { "buf.validate.field": { enum: { definedOnly: true } } } },
+            { no: 4, name: "reason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ExcludeGroupMemberRequest>): ExcludeGroupMemberRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        message.userId = 0;
+        message.reasonType = 0;
+        if (value !== undefined)
+            reflectionMergePartial<ExcludeGroupMemberRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExcludeGroupMemberRequest): ExcludeGroupMemberRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 group_id */ 1:
+                    message.groupId = reader.int64().toNumber();
+                    break;
+                case /* int32 user_id */ 2:
+                    message.userId = reader.int32();
+                    break;
+                case /* resources.jobs.groups.GroupExclusionReason reason_type */ 3:
+                    message.reasonType = reader.int32();
+                    break;
+                case /* optional string reason */ 4:
+                    message.reason = 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: ExcludeGroupMemberRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 group_id = 1; */
+        if (message.groupId !== 0)
+            writer.tag(1, WireType.Varint).int64(message.groupId);
+        /* int32 user_id = 2; */
+        if (message.userId !== 0)
+            writer.tag(2, WireType.Varint).int32(message.userId);
+        /* resources.jobs.groups.GroupExclusionReason reason_type = 3; */
+        if (message.reasonType !== 0)
+            writer.tag(3, WireType.Varint).int32(message.reasonType);
+        /* optional string reason = 4; */
+        if (message.reason !== undefined)
+            writer.tag(4, WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.ExcludeGroupMemberRequest
+ */
+export const ExcludeGroupMemberRequest = new ExcludeGroupMemberRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExcludeGroupMemberResponse$Type extends MessageType<ExcludeGroupMemberResponse> {
+    constructor() {
+        super("services.jobs.ExcludeGroupMemberResponse", [
+            { no: 1, name: "exclusion", kind: "message", T: () => GroupMemberExclusion },
+            { no: 2, name: "group", kind: "message", T: () => Group }
+        ]);
+    }
+    create(value?: PartialMessage<ExcludeGroupMemberResponse>): ExcludeGroupMemberResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<ExcludeGroupMemberResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExcludeGroupMemberResponse): ExcludeGroupMemberResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.GroupMemberExclusion exclusion */ 1:
+                    message.exclusion = GroupMemberExclusion.internalBinaryRead(reader, reader.uint32(), options, message.exclusion);
+                    break;
+                case /* resources.jobs.groups.Group group */ 2:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    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: ExcludeGroupMemberResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.GroupMemberExclusion exclusion = 1; */
+        if (message.exclusion)
+            GroupMemberExclusion.internalBinaryWrite(message.exclusion, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* resources.jobs.groups.Group group = 2; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, 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 services.jobs.ExcludeGroupMemberResponse
+ */
+export const ExcludeGroupMemberResponse = new ExcludeGroupMemberResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoveGroupMemberExclusionRequest$Type extends MessageType<RemoveGroupMemberExclusionRequest> {
+    constructor() {
+        super("services.jobs.RemoveGroupMemberExclusionRequest", [
+            { no: 1, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "user_id", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "reason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<RemoveGroupMemberExclusionRequest>): RemoveGroupMemberExclusionRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        message.userId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<RemoveGroupMemberExclusionRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RemoveGroupMemberExclusionRequest): RemoveGroupMemberExclusionRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 group_id */ 1:
+                    message.groupId = reader.int64().toNumber();
+                    break;
+                case /* int32 user_id */ 2:
+                    message.userId = reader.int32();
+                    break;
+                case /* optional string reason */ 3:
+                    message.reason = 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: RemoveGroupMemberExclusionRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 group_id = 1; */
+        if (message.groupId !== 0)
+            writer.tag(1, WireType.Varint).int64(message.groupId);
+        /* int32 user_id = 2; */
+        if (message.userId !== 0)
+            writer.tag(2, WireType.Varint).int32(message.userId);
+        /* optional string reason = 3; */
+        if (message.reason !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.RemoveGroupMemberExclusionRequest
+ */
+export const RemoveGroupMemberExclusionRequest = new RemoveGroupMemberExclusionRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoveGroupMemberExclusionResponse$Type extends MessageType<RemoveGroupMemberExclusionResponse> {
+    constructor() {
+        super("services.jobs.RemoveGroupMemberExclusionResponse", [
+            { no: 1, name: "group", kind: "message", T: () => Group }
+        ]);
+    }
+    create(value?: PartialMessage<RemoveGroupMemberExclusionResponse>): RemoveGroupMemberExclusionResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<RemoveGroupMemberExclusionResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RemoveGroupMemberExclusionResponse): RemoveGroupMemberExclusionResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.Group group */ 1:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    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: RemoveGroupMemberExclusionResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.Group group = 1; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, writer.tag(1, 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.jobs.RemoveGroupMemberExclusionResponse
+ */
+export const RemoveGroupMemberExclusionResponse = new RemoveGroupMemberExclusionResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AddGroupLeaderRequest$Type extends MessageType<AddGroupLeaderRequest> {
+    constructor() {
+        super("services.jobs.AddGroupLeaderRequest", [
+            { no: 1, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "user_id", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "reason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<AddGroupLeaderRequest>): AddGroupLeaderRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        message.userId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<AddGroupLeaderRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AddGroupLeaderRequest): AddGroupLeaderRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 group_id */ 1:
+                    message.groupId = reader.int64().toNumber();
+                    break;
+                case /* int32 user_id */ 2:
+                    message.userId = reader.int32();
+                    break;
+                case /* optional string reason */ 3:
+                    message.reason = 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: AddGroupLeaderRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 group_id = 1; */
+        if (message.groupId !== 0)
+            writer.tag(1, WireType.Varint).int64(message.groupId);
+        /* int32 user_id = 2; */
+        if (message.userId !== 0)
+            writer.tag(2, WireType.Varint).int32(message.userId);
+        /* optional string reason = 3; */
+        if (message.reason !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.AddGroupLeaderRequest
+ */
+export const AddGroupLeaderRequest = new AddGroupLeaderRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AddGroupLeaderResponse$Type extends MessageType<AddGroupLeaderResponse> {
+    constructor() {
+        super("services.jobs.AddGroupLeaderResponse", [
+            { no: 1, name: "leader", kind: "message", T: () => GroupLeader },
+            { no: 2, name: "group", kind: "message", T: () => Group }
+        ]);
+    }
+    create(value?: PartialMessage<AddGroupLeaderResponse>): AddGroupLeaderResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<AddGroupLeaderResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AddGroupLeaderResponse): AddGroupLeaderResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.GroupLeader leader */ 1:
+                    message.leader = GroupLeader.internalBinaryRead(reader, reader.uint32(), options, message.leader);
+                    break;
+                case /* resources.jobs.groups.Group group */ 2:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    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: AddGroupLeaderResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.GroupLeader leader = 1; */
+        if (message.leader)
+            GroupLeader.internalBinaryWrite(message.leader, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* resources.jobs.groups.Group group = 2; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, 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 services.jobs.AddGroupLeaderResponse
+ */
+export const AddGroupLeaderResponse = new AddGroupLeaderResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoveGroupLeaderRequest$Type extends MessageType<RemoveGroupLeaderRequest> {
+    constructor() {
+        super("services.jobs.RemoveGroupLeaderRequest", [
+            { no: 1, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "user_id", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "reason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<RemoveGroupLeaderRequest>): RemoveGroupLeaderRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        message.userId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<RemoveGroupLeaderRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RemoveGroupLeaderRequest): RemoveGroupLeaderRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 group_id */ 1:
+                    message.groupId = reader.int64().toNumber();
+                    break;
+                case /* int32 user_id */ 2:
+                    message.userId = reader.int32();
+                    break;
+                case /* optional string reason */ 3:
+                    message.reason = 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: RemoveGroupLeaderRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 group_id = 1; */
+        if (message.groupId !== 0)
+            writer.tag(1, WireType.Varint).int64(message.groupId);
+        /* int32 user_id = 2; */
+        if (message.userId !== 0)
+            writer.tag(2, WireType.Varint).int32(message.userId);
+        /* optional string reason = 3; */
+        if (message.reason !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.RemoveGroupLeaderRequest
+ */
+export const RemoveGroupLeaderRequest = new RemoveGroupLeaderRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoveGroupLeaderResponse$Type extends MessageType<RemoveGroupLeaderResponse> {
+    constructor() {
+        super("services.jobs.RemoveGroupLeaderResponse", [
+            { no: 1, name: "group", kind: "message", T: () => Group }
+        ]);
+    }
+    create(value?: PartialMessage<RemoveGroupLeaderResponse>): RemoveGroupLeaderResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<RemoveGroupLeaderResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RemoveGroupLeaderResponse): RemoveGroupLeaderResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.Group group */ 1:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    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: RemoveGroupLeaderResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.Group group = 1; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, writer.tag(1, 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.jobs.RemoveGroupLeaderResponse
+ */
+export const RemoveGroupLeaderResponse = new RemoveGroupLeaderResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GroupRuleInput$Type extends MessageType<GroupRuleInput> {
+    constructor() {
+        super("services.jobs.GroupRuleInput", [
+            { no: 1, name: "enabled", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
+            { no: 10, name: "grade", kind: "message", oneof: "rule", T: () => GroupGradeRule },
+            { no: 11, name: "qualification", kind: "message", oneof: "rule", T: () => GroupQualificationRule }
+        ]);
+    }
+    create(value?: PartialMessage<GroupRuleInput>): GroupRuleInput {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.rule = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<GroupRuleInput>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GroupRuleInput): GroupRuleInput {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional bool enabled */ 1:
+                    message.enabled = reader.bool();
+                    break;
+                case /* resources.jobs.groups.GroupGradeRule grade */ 10:
+                    message.rule = {
+                        oneofKind: "grade",
+                        grade: GroupGradeRule.internalBinaryRead(reader, reader.uint32(), options, (message.rule as any).grade)
+                    };
+                    break;
+                case /* resources.jobs.groups.GroupQualificationRule qualification */ 11:
+                    message.rule = {
+                        oneofKind: "qualification",
+                        qualification: GroupQualificationRule.internalBinaryRead(reader, reader.uint32(), options, (message.rule as any).qualification)
+                    };
+                    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: GroupRuleInput, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional bool enabled = 1; */
+        if (message.enabled !== undefined)
+            writer.tag(1, WireType.Varint).bool(message.enabled);
+        /* resources.jobs.groups.GroupGradeRule grade = 10; */
+        if (message.rule.oneofKind === "grade")
+            GroupGradeRule.internalBinaryWrite(message.rule.grade, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* resources.jobs.groups.GroupQualificationRule qualification = 11; */
+        if (message.rule.oneofKind === "qualification")
+            GroupQualificationRule.internalBinaryWrite(message.rule.qualification, writer.tag(11, 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.jobs.GroupRuleInput
+ */
+export const GroupRuleInput = new GroupRuleInput$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CreateGroupRuleRequest$Type extends MessageType<CreateGroupRuleRequest> {
+    constructor() {
+        super("services.jobs.CreateGroupRuleRequest", [
+            { no: 1, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "rule", kind: "message", T: () => GroupRuleInput },
+            { no: 3, name: "reason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<CreateGroupRuleRequest>): CreateGroupRuleRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<CreateGroupRuleRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CreateGroupRuleRequest): CreateGroupRuleRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 group_id */ 1:
+                    message.groupId = reader.int64().toNumber();
+                    break;
+                case /* services.jobs.GroupRuleInput rule */ 2:
+                    message.rule = GroupRuleInput.internalBinaryRead(reader, reader.uint32(), options, message.rule);
+                    break;
+                case /* optional string reason */ 3:
+                    message.reason = 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: CreateGroupRuleRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 group_id = 1; */
+        if (message.groupId !== 0)
+            writer.tag(1, WireType.Varint).int64(message.groupId);
+        /* services.jobs.GroupRuleInput rule = 2; */
+        if (message.rule)
+            GroupRuleInput.internalBinaryWrite(message.rule, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* optional string reason = 3; */
+        if (message.reason !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.CreateGroupRuleRequest
+ */
+export const CreateGroupRuleRequest = new CreateGroupRuleRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CreateGroupRuleResponse$Type extends MessageType<CreateGroupRuleResponse> {
+    constructor() {
+        super("services.jobs.CreateGroupRuleResponse", [
+            { no: 1, name: "rule", kind: "message", T: () => GroupRule },
+            { no: 2, name: "group", kind: "message", T: () => Group }
+        ]);
+    }
+    create(value?: PartialMessage<CreateGroupRuleResponse>): CreateGroupRuleResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<CreateGroupRuleResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CreateGroupRuleResponse): CreateGroupRuleResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.GroupRule rule */ 1:
+                    message.rule = GroupRule.internalBinaryRead(reader, reader.uint32(), options, message.rule);
+                    break;
+                case /* resources.jobs.groups.Group group */ 2:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    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: CreateGroupRuleResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.GroupRule rule = 1; */
+        if (message.rule)
+            GroupRule.internalBinaryWrite(message.rule, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* resources.jobs.groups.Group group = 2; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, 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 services.jobs.CreateGroupRuleResponse
+ */
+export const CreateGroupRuleResponse = new CreateGroupRuleResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UpdateGroupRuleRequest$Type extends MessageType<UpdateGroupRuleRequest> {
+    constructor() {
+        super("services.jobs.UpdateGroupRuleRequest", [
+            { no: 1, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "rule_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 3, name: "rule", kind: "message", T: () => GroupRuleInput },
+            { no: 4, name: "reason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<UpdateGroupRuleRequest>): UpdateGroupRuleRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        message.ruleId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<UpdateGroupRuleRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UpdateGroupRuleRequest): UpdateGroupRuleRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 group_id */ 1:
+                    message.groupId = reader.int64().toNumber();
+                    break;
+                case /* int64 rule_id */ 2:
+                    message.ruleId = reader.int64().toNumber();
+                    break;
+                case /* services.jobs.GroupRuleInput rule */ 3:
+                    message.rule = GroupRuleInput.internalBinaryRead(reader, reader.uint32(), options, message.rule);
+                    break;
+                case /* optional string reason */ 4:
+                    message.reason = 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: UpdateGroupRuleRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 group_id = 1; */
+        if (message.groupId !== 0)
+            writer.tag(1, WireType.Varint).int64(message.groupId);
+        /* int64 rule_id = 2; */
+        if (message.ruleId !== 0)
+            writer.tag(2, WireType.Varint).int64(message.ruleId);
+        /* services.jobs.GroupRuleInput rule = 3; */
+        if (message.rule)
+            GroupRuleInput.internalBinaryWrite(message.rule, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* optional string reason = 4; */
+        if (message.reason !== undefined)
+            writer.tag(4, WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.UpdateGroupRuleRequest
+ */
+export const UpdateGroupRuleRequest = new UpdateGroupRuleRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UpdateGroupRuleResponse$Type extends MessageType<UpdateGroupRuleResponse> {
+    constructor() {
+        super("services.jobs.UpdateGroupRuleResponse", [
+            { no: 1, name: "rule", kind: "message", T: () => GroupRule },
+            { no: 2, name: "group", kind: "message", T: () => Group }
+        ]);
+    }
+    create(value?: PartialMessage<UpdateGroupRuleResponse>): UpdateGroupRuleResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<UpdateGroupRuleResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UpdateGroupRuleResponse): UpdateGroupRuleResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.GroupRule rule */ 1:
+                    message.rule = GroupRule.internalBinaryRead(reader, reader.uint32(), options, message.rule);
+                    break;
+                case /* resources.jobs.groups.Group group */ 2:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    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: UpdateGroupRuleResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.GroupRule rule = 1; */
+        if (message.rule)
+            GroupRule.internalBinaryWrite(message.rule, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* resources.jobs.groups.Group group = 2; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, 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 services.jobs.UpdateGroupRuleResponse
+ */
+export const UpdateGroupRuleResponse = new UpdateGroupRuleResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DeleteGroupRuleRequest$Type extends MessageType<DeleteGroupRuleRequest> {
+    constructor() {
+        super("services.jobs.DeleteGroupRuleRequest", [
+            { no: 1, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "rule_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 3, name: "reason", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<DeleteGroupRuleRequest>): DeleteGroupRuleRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        message.ruleId = 0;
+        if (value !== undefined)
+            reflectionMergePartial<DeleteGroupRuleRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteGroupRuleRequest): DeleteGroupRuleRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 group_id */ 1:
+                    message.groupId = reader.int64().toNumber();
+                    break;
+                case /* int64 rule_id */ 2:
+                    message.ruleId = reader.int64().toNumber();
+                    break;
+                case /* optional string reason */ 3:
+                    message.reason = 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: DeleteGroupRuleRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 group_id = 1; */
+        if (message.groupId !== 0)
+            writer.tag(1, WireType.Varint).int64(message.groupId);
+        /* int64 rule_id = 2; */
+        if (message.ruleId !== 0)
+            writer.tag(2, WireType.Varint).int64(message.ruleId);
+        /* optional string reason = 3; */
+        if (message.reason !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message services.jobs.DeleteGroupRuleRequest
+ */
+export const DeleteGroupRuleRequest = new DeleteGroupRuleRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DeleteGroupRuleResponse$Type extends MessageType<DeleteGroupRuleResponse> {
+    constructor() {
+        super("services.jobs.DeleteGroupRuleResponse", [
+            { no: 1, name: "group", kind: "message", T: () => Group }
+        ]);
+    }
+    create(value?: PartialMessage<DeleteGroupRuleResponse>): DeleteGroupRuleResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<DeleteGroupRuleResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteGroupRuleResponse): DeleteGroupRuleResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* resources.jobs.groups.Group group */ 1:
+                    message.group = Group.internalBinaryRead(reader, reader.uint32(), options, message.group);
+                    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: DeleteGroupRuleResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* resources.jobs.groups.Group group = 1; */
+        if (message.group)
+            Group.internalBinaryWrite(message.group, writer.tag(1, 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.jobs.DeleteGroupRuleResponse
+ */
+export const DeleteGroupRuleResponse = new DeleteGroupRuleResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListGroupActivityRequest$Type extends MessageType<ListGroupActivityRequest> {
+    constructor() {
+        super("services.jobs.ListGroupActivityRequest", [
+            { no: 1, name: "pagination", kind: "message", T: () => PaginationRequest, options: { "buf.validate.field": { required: true } } },
+            { no: 2, name: "sort", kind: "message", T: () => Sort },
+            { no: 3, name: "group_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 4, name: "types", kind: "enum", repeat: 1 /*RepeatType.PACKED*/, T: () => ["resources.jobs.groups.GroupActivityType", GroupActivityType, "GROUP_ACTIVITY_TYPE_"], options: { "buf.validate.field": { repeated: { maxItems: "14", items: { enum: { definedOnly: true } } } } } },
+            { no: 5, name: "user_id", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/, options: { "buf.validate.field": { int32: { gt: 0 } } } },
+            { no: 6, name: "from", kind: "message", T: () => Timestamp },
+            { no: 7, name: "to", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value?: PartialMessage<ListGroupActivityRequest>): ListGroupActivityRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.groupId = 0;
+        message.types = [];
+        if (value !== undefined)
+            reflectionMergePartial<ListGroupActivityRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListGroupActivityRequest): ListGroupActivityRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional resources.common.database.PaginationRequest pagination */ 1:
+                    message.pagination = PaginationRequest.internalBinaryRead(reader, reader.uint32(), options, message.pagination);
+                    break;
+                case /* optional resources.common.database.Sort sort */ 2:
+                    message.sort = Sort.internalBinaryRead(reader, reader.uint32(), options, message.sort);
+                    break;
+                case /* int64 group_id */ 3:
+                    message.groupId = reader.int64().toNumber();
+                    break;
+                case /* repeated resources.jobs.groups.GroupActivityType types */ 4:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.types.push(reader.int32());
+                    else
+                        message.types.push(reader.int32());
+                    break;
+                case /* optional int32 user_id */ 5:
+                    message.userId = reader.int32();
+                    break;
+                case /* optional resources.timestamp.Timestamp from */ 6:
+                    message.from = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.from);
+                    break;
+                case /* optional resources.timestamp.Timestamp to */ 7:
+                    message.to = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.to);
+                    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: ListGroupActivityRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional resources.common.database.PaginationRequest pagination = 1; */
+        if (message.pagination)
+            PaginationRequest.internalBinaryWrite(message.pagination, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* optional resources.common.database.Sort sort = 2; */
+        if (message.sort)
+            Sort.internalBinaryWrite(message.sort, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* int64 group_id = 3; */
+        if (message.groupId !== 0)
+            writer.tag(3, WireType.Varint).int64(message.groupId);
+        /* repeated resources.jobs.groups.GroupActivityType types = 4; */
+        if (message.types.length) {
+            writer.tag(4, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.types.length; i++)
+                writer.int32(message.types[i]);
+            writer.join();
+        }
+        /* optional int32 user_id = 5; */
+        if (message.userId !== undefined)
+            writer.tag(5, WireType.Varint).int32(message.userId);
+        /* optional resources.timestamp.Timestamp from = 6; */
+        if (message.from)
+            Timestamp.internalBinaryWrite(message.from, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* optional resources.timestamp.Timestamp to = 7; */
+        if (message.to)
+            Timestamp.internalBinaryWrite(message.to, writer.tag(7, 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.jobs.ListGroupActivityRequest
+ */
+export const ListGroupActivityRequest = new ListGroupActivityRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListGroupActivityResponse$Type extends MessageType<ListGroupActivityResponse> {
+    constructor() {
+        super("services.jobs.ListGroupActivityResponse", [
+            { no: 1, name: "pagination", kind: "message", T: () => PaginationResponse, options: { "buf.validate.field": { required: true } } },
+            { no: 2, name: "activity", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GroupActivity, options: { "codegen.itemslen.enabled": true } }
+        ]);
+    }
+    create(value?: PartialMessage<ListGroupActivityResponse>): ListGroupActivityResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.activity = [];
+        if (value !== undefined)
+            reflectionMergePartial<ListGroupActivityResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListGroupActivityResponse): ListGroupActivityResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional resources.common.database.PaginationResponse pagination */ 1:
+                    message.pagination = PaginationResponse.internalBinaryRead(reader, reader.uint32(), options, message.pagination);
+                    break;
+                case /* repeated resources.jobs.groups.GroupActivity activity */ 2:
+                    message.activity.push(GroupActivity.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: ListGroupActivityResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional resources.common.database.PaginationResponse pagination = 1; */
+        if (message.pagination)
+            PaginationResponse.internalBinaryWrite(message.pagination, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated resources.jobs.groups.GroupActivity activity = 2; */
+        for (let i = 0; i < message.activity.length; i++)
+            GroupActivity.internalBinaryWrite(message.activity[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 services.jobs.ListGroupActivityResponse
+ */
+export const ListGroupActivityResponse = new ListGroupActivityResponse$Type();
 /**
  * @generated ServiceType for protobuf service services.jobs.GroupsService
  */
-export const GroupsService = new ServiceType("services.jobs.GroupsService", [], { "codegen.perms.perms_svc": { order: 66, icon: "i-mdi-account-group-outline" } });
+export const GroupsService = new ServiceType("services.jobs.GroupsService", [
+    { name: "ListGroups", options: {}, I: ListGroupsRequest, O: ListGroupsResponse },
+    { name: "GetGroup", options: { "codegen.perms.perms": { enabled: true, name: "ListGroups" } }, I: GetGroupRequest, O: GetGroupResponse },
+    { name: "CreateGroup", options: { "codegen.perms.perms": { enabled: true } }, I: CreateGroupRequest, O: CreateGroupResponse },
+    { name: "UpdateGroup", options: { "codegen.perms.perms": { enabled: true, names: ["CreateGroup", "ListGroups"] } }, I: UpdateGroupRequest, O: UpdateGroupResponse },
+    { name: "ArchiveGroup", options: { "codegen.perms.perms": { enabled: true } }, I: ArchiveGroupRequest, O: ArchiveGroupResponse },
+    { name: "RestoreGroup", options: { "codegen.perms.perms": { enabled: true, name: "ArchiveGroup" } }, I: RestoreGroupRequest, O: RestoreGroupResponse },
+    { name: "UploadGroupLogo", clientStreaming: true, options: { "codegen.perms.perms": { enabled: true, names: ["CreateGroup", "ListGroups"] } }, I: UploadFileRequest, O: UploadFileResponse },
+    { name: "DeleteGroupLogo", options: { "codegen.perms.perms": { enabled: true, names: ["CreateGroup", "ListGroups"] } }, I: DeleteGroupLogoRequest, O: DeleteGroupLogoResponse },
+    { name: "ListGroupMembers", options: { "codegen.perms.perms": { enabled: true, name: "ListGroups" } }, I: ListGroupMembersRequest, O: ListGroupMembersResponse },
+    { name: "ListGroupManualMembers", options: { "codegen.perms.perms": { enabled: true, name: "ListGroups" } }, I: ListGroupManualMembersRequest, O: ListGroupManualMembersResponse },
+    { name: "ListGroupMemberExclusions", options: { "codegen.perms.perms": { enabled: true, name: "ListGroups" } }, I: ListGroupMemberExclusionsRequest, O: ListGroupMemberExclusionsResponse },
+    { name: "ListGroupLeaders", options: { "codegen.perms.perms": { enabled: true, name: "ListGroups" } }, I: ListGroupLeadersRequest, O: ListGroupLeadersResponse },
+    { name: "AddGroupMember", options: { "codegen.perms.perms": { enabled: true, names: ["CreateGroup", "ListGroups"] } }, I: AddGroupMemberRequest, O: AddGroupMemberResponse },
+    { name: "RemoveGroupMember", options: { "codegen.perms.perms": { enabled: true, names: ["CreateGroup", "ListGroups"] } }, I: RemoveGroupMemberRequest, O: RemoveGroupMemberResponse },
+    { name: "ExcludeGroupMember", options: { "codegen.perms.perms": { enabled: true, names: ["CreateGroup", "ListGroups"] } }, I: ExcludeGroupMemberRequest, O: ExcludeGroupMemberResponse },
+    { name: "RemoveGroupMemberExclusion", options: { "codegen.perms.perms": { enabled: true, names: ["CreateGroup", "ListGroups"] } }, I: RemoveGroupMemberExclusionRequest, O: RemoveGroupMemberExclusionResponse },
+    { name: "AddGroupLeader", options: { "codegen.perms.perms": { enabled: true, names: ["CreateGroup", "ListGroups"] } }, I: AddGroupLeaderRequest, O: AddGroupLeaderResponse },
+    { name: "RemoveGroupLeader", options: { "codegen.perms.perms": { enabled: true, names: ["CreateGroup", "ListGroups"] } }, I: RemoveGroupLeaderRequest, O: RemoveGroupLeaderResponse },
+    { name: "CreateGroupRule", options: { "codegen.perms.perms": { enabled: true, names: ["CreateGroup", "ListGroups"] } }, I: CreateGroupRuleRequest, O: CreateGroupRuleResponse },
+    { name: "ListGroupRules", options: { "codegen.perms.perms": { enabled: true, name: "ListGroups" } }, I: ListGroupRulesRequest, O: ListGroupRulesResponse },
+    { name: "UpdateGroupRule", options: { "codegen.perms.perms": { enabled: true, names: ["CreateGroup", "ListGroups"] } }, I: UpdateGroupRuleRequest, O: UpdateGroupRuleResponse },
+    { name: "DeleteGroupRule", options: { "codegen.perms.perms": { enabled: true, names: ["CreateGroup", "ListGroups"] } }, I: DeleteGroupRuleRequest, O: DeleteGroupRuleResponse },
+    { name: "ListGroupActivity", options: { "codegen.perms.perms": { enabled: true, name: "ListGroups" } }, I: ListGroupActivityRequest, O: ListGroupActivityResponse }
+], { "codegen.perms.perms_svc": { order: 66, icon: "i-mdi-account-group-outline" } });