@sideline/domain 0.10.0 → 0.12.0

package/src/api/EventApi.ts

@@ -5,6 +5,7 @@ import { AuthMiddleware } from '~/api/Auth.js';
 import { Snowflake } from '~/models/Discord.js';
 import { EventId, EventStatus, EventType } from '~/models/Event.js';
 import { EventSeriesId } from '~/models/EventSeries.js';
+import { GroupId } from '~/models/GroupModel.js';
 import { TeamId } from '~/models/Team.js';
 import { TrainingTypeId } from '~/models/TrainingType.js';
 
@@ -39,6 +40,10 @@ export class EventDetail extends Schema.Class<EventDetail>('EventDetail')({
   seriesId: Schema.OptionFromNullOr(EventSeriesId),
   seriesModified: Schema.Boolean,
   discordChannelId: Schema.OptionFromNullOr(Snowflake),
+  ownerGroupId: Schema.OptionFromNullOr(GroupId),
+  ownerGroupName: Schema.OptionFromNullOr(Schema.String),
+  memberGroupId: Schema.OptionFromNullOr(GroupId),
+  memberGroupName: Schema.OptionFromNullOr(Schema.String),
 }) {}
 
 export class EventListResponse extends Schema.Class<EventListResponse>('EventListResponse')({
@@ -55,6 +60,8 @@ export class CreateEventRequest extends Schema.Class<CreateEventRequest>('Create
   endAt: Schema.OptionFromNullOr(Schemas.DateTimeFromIsoString),
   location: Schema.OptionFromNullOr(Schema.String),
   discordChannelId: Schema.OptionFromNullOr(Snowflake),
+  ownerGroupId: Schema.OptionFromNullOr(GroupId),
+  memberGroupId: Schema.OptionFromNullOr(GroupId),
 }) {}
 
 export class UpdateEventRequest extends Schema.Class<UpdateEventRequest>('UpdateEventRequest')({
@@ -68,6 +75,8 @@ export class UpdateEventRequest extends Schema.Class<UpdateEventRequest>('Update
   }),
   location: Schema.optionalWith(Schema.OptionFromNullOr(Schema.String), { as: 'Option' }),
   discordChannelId: Schema.optionalWith(Schema.OptionFromNullOr(Snowflake), { as: 'Option' }),
+  ownerGroupId: Schema.optionalWith(Schema.OptionFromNullOr(GroupId), { as: 'Option' }),
+  memberGroupId: Schema.optionalWith(Schema.OptionFromNullOr(GroupId), { as: 'Option' }),
 }) {}
 
 export class EventNotFound extends Schema.TaggedError<EventNotFound>()(

package/src/api/EventRsvpApi.ts

@@ -71,7 +71,7 @@ export class EventRsvpApiGroup extends HttpApiGroup.make('eventRsvp')
   )
   .add(
     HttpApiEndpoint.put('submitRsvp', '/teams/:teamId/events/:eventId/rsvp')
-      .addSuccess(EventRsvpDetail)
+      .addSuccess(Schema.Void, { status: 204 })
       .addError(Forbidden, { status: 403 })
       .addError(EventNotFound, { status: 404 })
       .addError(RsvpDeadlinePassed, { status: 400 })

package/src/api/EventSeriesApi.ts

@@ -10,6 +10,7 @@ import {
   EventSeriesStatus,
   RecurrenceFrequency,
 } from '~/models/EventSeries.js';
+import { GroupId } from '~/models/GroupModel.js';
 import { TeamId } from '~/models/Team.js';
 import { TrainingTypeId } from '~/models/TrainingType.js';
 
@@ -28,6 +29,10 @@ export class EventSeriesInfo extends Schema.Class<EventSeriesInfo>('EventSeriesI
   endTime: Schema.OptionFromNullOr(Schema.String),
   location: Schema.OptionFromNullOr(Schema.String),
   discordChannelId: Schema.OptionFromNullOr(Snowflake),
+  ownerGroupId: Schema.OptionFromNullOr(GroupId),
+  ownerGroupName: Schema.OptionFromNullOr(Schema.String),
+  memberGroupId: Schema.OptionFromNullOr(GroupId),
+  memberGroupName: Schema.OptionFromNullOr(Schema.String),
 }) {}
 
 export class EventSeriesDetail extends Schema.Class<EventSeriesDetail>('EventSeriesDetail')({
@@ -46,6 +51,10 @@ export class EventSeriesDetail extends Schema.Class<EventSeriesDetail>('EventSer
   endTime: Schema.OptionFromNullOr(Schema.String),
   location: Schema.OptionFromNullOr(Schema.String),
   discordChannelId: Schema.OptionFromNullOr(Snowflake),
+  ownerGroupId: Schema.OptionFromNullOr(GroupId),
+  ownerGroupName: Schema.OptionFromNullOr(Schema.String),
+  memberGroupId: Schema.OptionFromNullOr(GroupId),
+  memberGroupName: Schema.OptionFromNullOr(Schema.String),
   canEdit: Schema.Boolean,
   canCancel: Schema.Boolean,
 }) {}
@@ -64,6 +73,8 @@ export class CreateEventSeriesRequest extends Schema.Class<CreateEventSeriesRequ
   endTime: Schema.OptionFromNullOr(Schema.String),
   location: Schema.OptionFromNullOr(Schema.String),
   discordChannelId: Schema.OptionFromNullOr(Snowflake),
+  ownerGroupId: Schema.OptionFromNullOr(GroupId),
+  memberGroupId: Schema.OptionFromNullOr(GroupId),
 }) {}
 
 export class UpdateEventSeriesRequest extends Schema.Class<UpdateEventSeriesRequest>(
@@ -80,6 +91,8 @@ export class UpdateEventSeriesRequest extends Schema.Class<UpdateEventSeriesRequ
     as: 'Option',
   }),
   discordChannelId: Schema.optionalWith(Schema.OptionFromNullOr(Snowflake), { as: 'Option' }),
+  ownerGroupId: Schema.optionalWith(Schema.OptionFromNullOr(GroupId), { as: 'Option' }),
+  memberGroupId: Schema.optionalWith(Schema.OptionFromNullOr(GroupId), { as: 'Option' }),
 }) {}
 
 export class EventSeriesNotFound extends Schema.TaggedError<EventSeriesNotFound>()(

package/src/api/RoleApi.ts

@@ -13,12 +13,18 @@ export class RoleInfo extends Schema.Class<RoleInfo>('RoleInfo')({
   permissionCount: Schema.Number,
 }) {}
 
+export class RoleListResponse extends Schema.Class<RoleListResponse>('RoleListResponse')({
+  canManage: Schema.Boolean,
+  roles: Schema.Array(RoleInfo),
+}) {}
+
 export class RoleDetail extends Schema.Class<RoleDetail>('RoleDetail')({
   roleId: RoleId,
   teamId: TeamId,
   name: Schema.String,
   isBuiltIn: Schema.Boolean,
   permissions: Schema.Array(Permission),
+  canManage: Schema.Boolean,
 }) {}
 
 export class CreateRoleRequest extends Schema.Class<CreateRoleRequest>('CreateRoleRequest')({
@@ -74,7 +80,7 @@ export class RoleNameAlreadyTaken extends Schema.TaggedError<RoleNameAlreadyTake
 export class RoleApiGroup extends HttpApiGroup.make('role')
   .add(
     HttpApiEndpoint.get('listRoles', '/teams/:teamId/roles')
-      .addSuccess(Schema.Array(RoleInfo))
+      .addSuccess(RoleListResponse)
       .addError(Forbidden, { status: 403 })
       .setPath(Schema.Struct({ teamId: TeamId }))
       .middleware(AuthMiddleware),

package/src/api/Roster.ts

@@ -55,6 +55,11 @@ export class RosterInfo extends Schema.Class<RosterInfo>('RosterInfo')({
   createdAt: Schema.String,
 }) {}
 
+export class RosterListResponse extends Schema.Class<RosterListResponse>('RosterListResponse')({
+  canManage: Schema.Boolean,
+  rosters: Schema.Array(RosterInfo),
+}) {}
+
 export class RosterDetail extends Schema.Class<RosterDetail>('RosterDetail')({
   rosterId: RosterId,
   teamId: TeamId,
@@ -62,6 +67,7 @@ export class RosterDetail extends Schema.Class<RosterDetail>('RosterDetail')({
   active: Schema.Boolean,
   createdAt: Schema.String,
   members: Schema.Array(RosterPlayer),
+  canManage: Schema.Boolean,
 }) {}
 
 export class CreateRosterRequest extends Schema.Class<CreateRosterRequest>('CreateRosterRequest')({
@@ -114,7 +120,7 @@ export class RosterApiGroup extends HttpApiGroup.make('roster')
   )
   .add(
     HttpApiEndpoint.get('listRosters', '/teams/:teamId/rosters')
-      .addSuccess(Schema.Array(RosterInfo))
+      .addSuccess(RosterListResponse)
       .addError(Forbidden, { status: 403 })
       .setPath(Schema.Struct({ teamId: TeamId }))
       .middleware(AuthMiddleware),

package/src/api/TrainingTypeApi.ts

@@ -10,15 +10,18 @@ export class TrainingTypeInfo extends Schema.Class<TrainingTypeInfo>('TrainingTy
   trainingTypeId: TrainingTypeId,
   teamId: TeamId,
   name: Schema.String,
-  groupName: Schema.OptionFromNullOr(Schema.String),
+  ownerGroupName: Schema.OptionFromNullOr(Schema.String),
+  memberGroupName: Schema.OptionFromNullOr(Schema.String),
 }) {}
 
 export class TrainingTypeDetail extends Schema.Class<TrainingTypeDetail>('TrainingTypeDetail')({
   trainingTypeId: TrainingTypeId,
   teamId: TeamId,
   name: Schema.String,
-  groupId: Schema.OptionFromNullOr(GroupId),
-  groupName: Schema.OptionFromNullOr(Schema.String),
+  ownerGroupId: Schema.OptionFromNullOr(GroupId),
+  ownerGroupName: Schema.OptionFromNullOr(Schema.String),
+  memberGroupId: Schema.OptionFromNullOr(GroupId),
+  memberGroupName: Schema.OptionFromNullOr(Schema.String),
   discordChannelId: Schema.OptionFromNullOr(Snowflake),
   canAdmin: Schema.Boolean,
 }) {}
@@ -34,7 +37,8 @@ export class CreateTrainingTypeRequest extends Schema.Class<CreateTrainingTypeRe
   'CreateTrainingTypeRequest',
 )({
   name: Schema.NonEmptyString,
-  groupId: Schema.OptionFromNullOr(GroupId),
+  ownerGroupId: Schema.OptionFromNullOr(GroupId),
+  memberGroupId: Schema.OptionFromNullOr(GroupId),
   discordChannelId: Schema.OptionFromNullOr(Snowflake),
 }) {}
 
@@ -42,6 +46,8 @@ export class UpdateTrainingTypeRequest extends Schema.Class<UpdateTrainingTypeRe
   'UpdateTrainingTypeRequest',
 )({
   name: Schema.NonEmptyString,
+  ownerGroupId: Schema.optionalWith(Schema.OptionFromNullOr(GroupId), { as: 'Option' }),
+  memberGroupId: Schema.optionalWith(Schema.OptionFromNullOr(GroupId), { as: 'Option' }),
   discordChannelId: Schema.optionalWith(Schema.OptionFromNullOr(Snowflake), { as: 'Option' }),
 }) {}
 

package/src/index.ts

@@ -1,5 +1,9 @@
 export * as ApiGroup from './ApiGroup.js';
 
+export * as ActivityLogApi from './api/ActivityLogApi.js';
+
+export * as ActivityStatsApi from './api/ActivityStatsApi.js';
+
 export * as AgeThresholdApi from './api/AgeThresholdApi.js';
 
 export * as Auth from './api/Auth.js';
@@ -26,6 +30,12 @@ export * as TeamSettingsApi from './api/TeamSettingsApi.js';
 
 export * as TrainingTypeApi from './api/TrainingTypeApi.js';
 
+export * as ActivityLog from './models/ActivityLog.js';
+
+export * as ActivityStats from './models/ActivityStats.js';
+
+export * as ActivityType from './models/ActivityType.js';
+
 export * as AgeThresholdRule from './models/AgeThresholdRule.js';
 
 export * as ChannelSyncEvent from './models/ChannelSyncEvent.js';
@@ -75,6 +85,8 @@ export * as TeamSettings from './models/TeamSettings.js';
 export * as TrainingType from './models/TrainingType.js';
 
 export * as User from './models/User.js';
+export * as ActivityRpcGroup from './rpc/activity/ActivityRpcGroup.js';
+export * as ActivityRpcModels from './rpc/activity/ActivityRpcModels.js';
 export * as ChannelRpcEvents from './rpc/channel/ChannelRpcEvents.js';
 export * as ChannelRpcGroup from './rpc/channel/ChannelRpcGroup.js';
 export * as ChannelRpcModels from './rpc/channel/ChannelRpcModels.js';

package/src/models/ActivityLog.ts

@@ -0,0 +1,21 @@
+import { Model } from '@effect/sql';
+import { Schema } from 'effect';
+import { ActivityTypeId } from '~/models/ActivityType.js';
+import { TeamMemberId } from '~/models/TeamMember.js';
+
+export const ActivityLogId = Schema.String.pipe(Schema.brand('ActivityLogId'));
+export type ActivityLogId = typeof ActivityLogId.Type;
+
+export const ActivitySource = Schema.Literal('manual', 'auto');
+export type ActivitySource = typeof ActivitySource.Type;
+
+export class ActivityLog extends Model.Class<ActivityLog>('ActivityLog')({
+  id: Model.Generated(ActivityLogId),
+  team_member_id: TeamMemberId,
+  activity_type_id: ActivityTypeId,
+  logged_at: Model.DateTimeInsertFromDate,
+  duration_minutes: Schema.OptionFromNullOr(Schema.Int.pipe(Schema.between(1, 1440))),
+  note: Schema.OptionFromNullOr(Schema.String),
+  source: ActivitySource,
+  created_at: Model.DateTimeInsertFromDate,
+}) {}

package/src/models/ActivityStats.ts

@@ -0,0 +1,131 @@
+import { Option } from 'effect';
+
+export interface StreakResult {
+  readonly currentStreak: number;
+  readonly longestStreak: number;
+}
+
+export interface StatsResult {
+  readonly currentStreak: number;
+  readonly longestStreak: number;
+  readonly totalActivities: number;
+  readonly totalDurationMinutes: number;
+  readonly counts: ReadonlyArray<{
+    readonly activityTypeId: string;
+    readonly activityTypeName: string;
+    readonly count: number;
+  }>;
+}
+
+/** Calculate current and longest streaks from a list of activity dates (ISO date strings like "2026-03-25"). */
+export const calculateStreaks = (dates: ReadonlyArray<string>, today: string): StreakResult => {
+  const uniqueDates = [...new Set(dates)].sort();
+  if (uniqueDates.length === 0) return { currentStreak: 0, longestStreak: 0 };
+
+  // Calculate longest streak by walking sorted dates forward
+  let longestStreak = 1;
+  let currentRun = 1;
+  for (let i = 1; i < uniqueDates.length; i++) {
+    const prev = uniqueDates[i - 1];
+    const curr = uniqueDates[i];
+    if (prev !== undefined && curr !== undefined && daysBetween(prev, curr) === 1) {
+      currentRun++;
+      longestStreak = Math.max(longestStreak, currentRun);
+    } else {
+      currentRun = 1;
+    }
+  }
+
+  // Calculate current streak: walk backwards from today or yesterday
+  const lastDate = uniqueDates[uniqueDates.length - 1];
+  if (lastDate === undefined) return { currentStreak: 0, longestStreak: 0 };
+  const gapFromToday = daysBetween(lastDate, today);
+
+  // If most recent activity is more than 1 day ago, current streak is 0
+  if (gapFromToday > 1) return { currentStreak: 0, longestStreak };
+
+  let currentStreak = 1;
+  for (let i = uniqueDates.length - 2; i >= 0; i--) {
+    const curr = uniqueDates[i];
+    const next = uniqueDates[i + 1];
+    if (curr !== undefined && next !== undefined && daysBetween(curr, next) === 1) {
+      currentStreak++;
+    } else {
+      break;
+    }
+  }
+
+  return { currentStreak, longestStreak };
+};
+
+/** Calculate full stats from activity rows. */
+export const calculateStats = (
+  rows: ReadonlyArray<{
+    readonly activity_type_id: string;
+    readonly activity_type_name: string;
+    readonly logged_at_date: string;
+    readonly duration_minutes: Option.Option<number>;
+  }>,
+  today: string,
+): StatsResult => {
+  if (rows.length === 0) {
+    return {
+      currentStreak: 0,
+      longestStreak: 0,
+      totalActivities: 0,
+      totalDurationMinutes: 0,
+      counts: [],
+    };
+  }
+
+  const dates = rows.map((r) => r.logged_at_date);
+  const { currentStreak, longestStreak } = calculateStreaks(dates, today);
+
+  let totalDurationMinutes = 0;
+  const countMap = new Map<string, { activityTypeName: string; count: number }>();
+
+  for (const row of rows) {
+    totalDurationMinutes += Option.getOrElse(row.duration_minutes, () => 0);
+    const existing = countMap.get(row.activity_type_id);
+    if (existing) {
+      existing.count++;
+    } else {
+      countMap.set(row.activity_type_id, { activityTypeName: row.activity_type_name, count: 1 });
+    }
+  }
+
+  const counts = Array.from(countMap.entries()).map(
+    ([activityTypeId, { activityTypeName, count }]) => ({
+      activityTypeId,
+      activityTypeName,
+      count,
+    }),
+  );
+
+  return {
+    currentStreak,
+    longestStreak,
+    totalActivities: rows.length,
+    totalDurationMinutes,
+    counts,
+  };
+};
+
+/** Returns today's date as an ISO string in the Europe/Prague timezone. */
+export const todayInPrague = (): string => {
+  const parts = new Intl.DateTimeFormat('en-CA', {
+    timeZone: 'Europe/Prague',
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+  }).formatToParts(new Date());
+
+  const get = (type: string) => parts.find((p) => p.type === type)?.value ?? '';
+  return `${get('year')}-${get('month')}-${get('day')}`;
+};
+
+/** Returns the number of days between two ISO date strings. Always positive. Inputs must be date-only strings (UTC midnight). */
+const daysBetween = (a: string, b: string): number => {
+  const msPerDay = 86400000;
+  return Math.round(Math.abs(new Date(b).getTime() - new Date(a).getTime()) / msPerDay);
+};

package/src/models/ActivityType.ts

@@ -0,0 +1,7 @@
+import { Schema } from 'effect';
+
+export const ActivityTypeId = Schema.String.pipe(Schema.brand('ActivityTypeId'));
+export type ActivityTypeId = typeof ActivityTypeId.Type;
+
+export const ActivityTypeSlug = Schema.Literal('gym', 'running', 'stretching', 'training');
+export type ActivityTypeSlug = typeof ActivityTypeSlug.Type;

package/src/models/Event.ts

@@ -2,6 +2,7 @@ import { Model } from '@effect/sql';
 import * as Schemas from '@sideline/effect-lib/Schemas';
 import { Schema } from 'effect';
 import { EventSeriesId } from '~/models/EventSeries.js';
+import { GroupId } from '~/models/GroupModel.js';
 import { TeamId } from '~/models/Team.js';
 import { TeamMemberId } from '~/models/TeamMember.js';
 import { TrainingTypeId } from '~/models/TrainingType.js';
@@ -32,6 +33,8 @@ export class Event extends Model.Class<Event>('Event')({
   start_at: Schemas.DateTimeFromDate,
   end_at: Schema.OptionFromNullOr(Schemas.DateTimeFromDate),
   location: Schema.OptionFromNullOr(Schema.String),
+  owner_group_id: Schema.OptionFromNullOr(GroupId),
+  member_group_id: Schema.OptionFromNullOr(GroupId),
   series_id: Schema.OptionFromNullOr(EventSeriesId),
   series_modified: Schema.Boolean,
   status: Model.FieldExcept('update')(EventStatus),

package/src/models/EventSeries.ts

@@ -1,5 +1,6 @@
 import { Model } from '@effect/sql';
 import { Schema } from 'effect';
+import { GroupId } from '~/models/GroupModel.js';
 import { TeamId } from '~/models/Team.js';
 import { TeamMemberId } from '~/models/TeamMember.js';
 import { TrainingTypeId } from '~/models/TrainingType.js';
@@ -32,6 +33,8 @@ export class EventSeries extends Model.Class<EventSeries>('EventSeries')({
   days_of_week: DaysOfWeek,
   start_date: Schema.DateFromSelf,
   end_date: Schema.OptionFromNullOr(Schema.DateFromSelf),
+  owner_group_id: Schema.OptionFromNullOr(GroupId),
+  member_group_id: Schema.OptionFromNullOr(GroupId),
   status: Model.FieldExcept('update')(EventSeriesStatus),
   created_by: TeamMemberId,
   created_at: Model.DateTimeInsertFromDate,

package/src/models/TrainingType.ts

@@ -10,6 +10,7 @@ export class TrainingType extends Model.Class<TrainingType>('TrainingType')({
   id: Model.Generated(TrainingTypeId),
   team_id: TeamId,
   name: Schema.String,
-  group_id: Schema.OptionFromNullOr(GroupId),
+  owner_group_id: Schema.OptionFromNullOr(GroupId),
+  member_group_id: Schema.OptionFromNullOr(GroupId),
   created_at: Model.DateTimeInsertFromDate,
 }) {}

package/src/rpc/SyncRpcs.ts

@@ -1,4 +1,5 @@
 import { RpcGroup } from '@effect/rpc';
+import { ActivityRpcGroup } from './activity/ActivityRpcGroup.js';
 import { ChannelRpcGroup } from './channel/ChannelRpcGroup.js';
 import { EventRpcGroup } from './event/EventRpcGroup.js';
 import { GuildRpcGroup } from './guild/GuildRpcGroup.js';
@@ -9,4 +10,5 @@ export class SyncRpcs extends RpcGroup.make().merge(
   ChannelRpcGroup,
   GuildRpcGroup,
   EventRpcGroup,
+  ActivityRpcGroup,
 ) {}

package/src/rpc/activity/ActivityRpcGroup.ts

@@ -0,0 +1,31 @@
+import { Rpc, RpcGroup } from '@effect/rpc';
+import { Schema } from 'effect';
+import { Discord } from '~/index.js';
+import {
+  ActivityGuildNotFound,
+  ActivityMemberNotFound,
+  GetStatsResult,
+  LogActivityResult,
+} from './ActivityRpcModels.js';
+
+export const ActivityRpcGroup = RpcGroup.make(
+  Rpc.make('LogActivity', {
+    payload: {
+      guild_id: Discord.Snowflake,
+      discord_user_id: Discord.Snowflake,
+      activity_type: Schema.String,
+      duration_minutes: Schema.OptionFromNullOr(Schema.Int.pipe(Schema.between(1, 1440))),
+      note: Schema.OptionFromNullOr(Schema.String),
+    },
+    success: LogActivityResult,
+    error: Schema.Union(ActivityMemberNotFound, ActivityGuildNotFound),
+  }),
+  Rpc.make('GetStats', {
+    payload: {
+      guild_id: Discord.Snowflake,
+      discord_user_id: Discord.Snowflake,
+    },
+    success: GetStatsResult,
+    error: Schema.Union(ActivityMemberNotFound, ActivityGuildNotFound),
+  }),
+).prefix('Activity/');

package/src/rpc/activity/ActivityRpcModels.ts

@@ -0,0 +1,32 @@
+import { Schema } from 'effect';
+import { ActivityLogId } from '~/models/ActivityLog.js';
+
+export class LogActivityResult extends Schema.Class<LogActivityResult>('LogActivityResult')({
+  id: ActivityLogId,
+  activity_type_id: Schema.String,
+  logged_at: Schema.String,
+}) {}
+
+export class ActivityMemberNotFound extends Schema.TaggedError<ActivityMemberNotFound>()(
+  'ActivityMemberNotFound',
+  {},
+) {}
+
+export class ActivityGuildNotFound extends Schema.TaggedError<ActivityGuildNotFound>()(
+  'ActivityGuildNotFound',
+  {},
+) {}
+
+export class GetStatsResult extends Schema.Class<GetStatsResult>('GetStatsResult')({
+  current_streak: Schema.Int,
+  longest_streak: Schema.Int,
+  total_activities: Schema.Int,
+  total_duration_minutes: Schema.Int,
+  counts: Schema.Array(
+    Schema.Struct({
+      activity_type_id: Schema.String,
+      activity_type_name: Schema.String,
+      count: Schema.Int,
+    }),
+  ),
+}) {}

package/src/rpc/event/EventRpcGroup.ts

@@ -1,6 +1,6 @@
 import { Rpc, RpcGroup } from '@effect/rpc';
 import { Schema } from 'effect';
-import { Discord, Event, EventRsvp, Team } from '~/index.js';
+import { Discord, Event, EventRsvp, Team, TrainingType } from '~/index.js';
 import { UnprocessedEventSyncEvent } from './EventRpcEvents.js';
 import {
   ChannelEventEntry,
@@ -17,7 +17,9 @@ import {
   RsvpDeadlinePassed,
   RsvpEventNotFound,
   RsvpMemberNotFound,
+  RsvpNotGroupMember,
   RsvpReminderSummary,
+  TrainingTypeChoice,
 } from './EventRpcModels.js';
 
 export const EventRpcGroup = RpcGroup.make(
@@ -51,7 +53,12 @@ export const EventRpcGroup = RpcGroup.make(
       message: Schema.OptionFromNullOr(Schema.String),
     },
     success: RsvpCountsResult,
-    error: Schema.Union(RsvpMemberNotFound, RsvpDeadlinePassed, RsvpEventNotFound),
+    error: Schema.Union(
+      RsvpMemberNotFound,
+      RsvpDeadlinePassed,
+      RsvpEventNotFound,
+      RsvpNotGroupMember,
+    ),
   }),
   Rpc.make('GetRsvpCounts', {
     payload: { event_id: Event.EventId },
@@ -82,6 +89,10 @@ export const EventRpcGroup = RpcGroup.make(
     success: GuildEventListResult,
     error: GuildNotFound,
   }),
+  Rpc.make('GetTrainingTypesByGuild', {
+    payload: { guild_id: Discord.Snowflake },
+    success: Schema.Array(TrainingTypeChoice),
+  }),
   Rpc.make('CreateEvent', {
     payload: {
       guild_id: Discord.Snowflake,
@@ -92,6 +103,7 @@ export const EventRpcGroup = RpcGroup.make(
       end_at: Schema.OptionFromNullOr(Schema.String),
       location: Schema.OptionFromNullOr(Schema.String),
       description: Schema.OptionFromNullOr(Schema.String),
+      training_type_id: Schema.OptionFromNullOr(TrainingType.TrainingTypeId),
     },
     success: CreateEventResult,
     error: Schema.Union(CreateEventNotMember, CreateEventForbidden, CreateEventInvalidDate),

package/src/rpc/event/EventRpcModels.ts

@@ -1,6 +1,7 @@
 import * as Schemas from '@sideline/effect-lib/Schemas';
 import { Schema } from 'effect';
 import { Snowflake } from '~/models/Discord.js';
+import { TrainingTypeId } from '~/models/TrainingType.js';
 
 export class EventDiscordMessage extends Schema.Class<EventDiscordMessage>('EventDiscordMessage')({
   discord_channel_id: Snowflake,
@@ -51,6 +52,11 @@ export class RsvpEventNotFound extends Schema.TaggedError<RsvpEventNotFound>()(
   {},
 ) {}
 
+export class RsvpNotGroupMember extends Schema.TaggedError<RsvpNotGroupMember>()(
+  'RsvpNotGroupMember',
+  {},
+) {}
+
 export class CreateEventNotMember extends Schema.TaggedError<CreateEventNotMember>()(
   'CreateEventNotMember',
   {},
@@ -119,3 +125,8 @@ export class RsvpReminderSummary extends Schema.Class<RsvpReminderSummary>('Rsvp
   maybeCount: Schema.Number,
   nonResponders: Schema.Array(NonResponderRpcEntry),
 }) {}
+
+export class TrainingTypeChoice extends Schema.Class<TrainingTypeChoice>('TrainingTypeChoice')({
+  id: TrainingTypeId,
+  name: Schema.String,
+}) {}