@sideline/domain 0.10.0 → 0.12.0

package/dist/dts/models/Event.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Event.d.ts","sourceRoot":"","sources":["../../../src/models/Event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAMhC,eAAO,MAAM,OAAO,+CAA8C,CAAC;AACnE,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAC;AAE1C,eAAO,MAAM,SAAS,mFAOrB,CAAC;AACF,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAC;AAE9C,eAAO,MAAM,WAAW,yCAAwC,CAAC;AACjE,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElD,qBAAa,KAAM,SAAQ,UAgBzB;CAAG"}
+{"version":3,"file":"Event.d.ts","sourceRoot":"","sources":["../../../src/models/Event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAOhC,eAAO,MAAM,OAAO,+CAA8C,CAAC;AACnE,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAC;AAE1C,eAAO,MAAM,SAAS,mFAOrB,CAAC;AACF,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAC;AAE9C,eAAO,MAAM,WAAW,yCAAwC,CAAC;AACjE,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElD,qBAAa,KAAM,SAAQ,UAkBzB;CAAG"}

package/dist/dts/models/EventRsvp.d.ts

@@ -26,12 +26,12 @@ declare const EventRsvp_base: import("@effect/experimental/VariantSchema").Class
     readonly created_at: import("effect/DateTime").Utc;
 } & {
     readonly updated_at: import("effect/DateTime").Utc;
+} & {
+    readonly team_member_id: string & import("effect/Brand").Brand<"TeamMemberId">;
 } & {
     readonly message: import("effect/Option").Option<string>;
 } & {
     readonly event_id: string & import("effect/Brand").Brand<"EventId">;
-} & {
-    readonly team_member_id: string & import("effect/Brand").Brand<"TeamMemberId">;
 } & {
     readonly response: "yes" | "no" | "maybe";
 }, Schema.Struct.Encoded<import("@effect/experimental/VariantSchema").ExtractFields<"select", {
@@ -48,12 +48,12 @@ declare const EventRsvp_base: import("@effect/experimental/VariantSchema").Class
     readonly created_at: import("effect/DateTime").Utc;
 } & {
     readonly updated_at: import("effect/DateTime").Utc;
+} & {
+    readonly team_member_id: string & import("effect/Brand").Brand<"TeamMemberId">;
 } & {
     readonly message: import("effect/Option").Option<string>;
 } & {
     readonly event_id: string & import("effect/Brand").Brand<"EventId">;
-} & {
-    readonly team_member_id: string & import("effect/Brand").Brand<"TeamMemberId">;
 } & {
     readonly response: "yes" | "no" | "maybe";
 }> & {

package/dist/dts/models/EventSeries.d.ts

@@ -23,6 +23,8 @@ declare const EventSeries_base: import("@effect/experimental/VariantSchema").Cla
     readonly days_of_week: Schema.filter<Schema.filter<Schema.Array$<Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">>>>;
     readonly start_date: typeof Schema.DateFromSelf;
     readonly end_date: Schema.OptionFromNullOr<typeof Schema.DateFromSelf>;
+    readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+    readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
     readonly status: import("@effect/experimental/VariantSchema").Field<{
         readonly select: Schema.Literal<["active", "cancelled"]>;
         readonly insert: Schema.Literal<["active", "cancelled"]>;
@@ -46,6 +48,8 @@ declare const EventSeries_base: import("@effect/experimental/VariantSchema").Cla
     readonly days_of_week: Schema.filter<Schema.filter<Schema.Array$<Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">>>>;
     readonly start_date: typeof Schema.DateFromSelf;
     readonly end_date: Schema.OptionFromNullOr<typeof Schema.DateFromSelf>;
+    readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+    readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
     readonly status: import("@effect/experimental/VariantSchema").Field<{
         readonly select: Schema.Literal<["active", "cancelled"]>;
         readonly insert: Schema.Literal<["active", "cancelled"]>;
@@ -68,6 +72,10 @@ declare const EventSeries_base: import("@effect/experimental/VariantSchema").Cla
     readonly team_id: string & import("effect/Brand").Brand<"TeamId">;
 } & {
     readonly status: "active" | "cancelled";
+} & {
+    readonly owner_group_id: import("effect/Option").Option<string & import("effect/Brand").Brand<"GroupId">>;
+} & {
+    readonly member_group_id: import("effect/Option").Option<string & import("effect/Brand").Brand<"GroupId">>;
 } & {
     readonly description: import("effect/Option").Option<string>;
 } & {
@@ -101,6 +109,8 @@ declare const EventSeries_base: import("@effect/experimental/VariantSchema").Cla
     readonly days_of_week: Schema.filter<Schema.filter<Schema.Array$<Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">>>>;
     readonly start_date: typeof Schema.DateFromSelf;
     readonly end_date: Schema.OptionFromNullOr<typeof Schema.DateFromSelf>;
+    readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+    readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
     readonly status: import("@effect/experimental/VariantSchema").Field<{
         readonly select: Schema.Literal<["active", "cancelled"]>;
         readonly insert: Schema.Literal<["active", "cancelled"]>;
@@ -123,6 +133,10 @@ declare const EventSeries_base: import("@effect/experimental/VariantSchema").Cla
     readonly team_id: string & import("effect/Brand").Brand<"TeamId">;
 } & {
     readonly status: "active" | "cancelled";
+} & {
+    readonly owner_group_id: import("effect/Option").Option<string & import("effect/Brand").Brand<"GroupId">>;
+} & {
+    readonly member_group_id: import("effect/Option").Option<string & import("effect/Brand").Brand<"GroupId">>;
 } & {
     readonly description: import("effect/Option").Option<string>;
 } & {
@@ -157,6 +171,8 @@ declare const EventSeries_base: import("@effect/experimental/VariantSchema").Cla
         readonly days_of_week: Schema.filter<Schema.filter<Schema.Array$<Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">>>>;
         readonly start_date: typeof Schema.DateFromSelf;
         readonly end_date: Schema.OptionFromNullOr<typeof Schema.DateFromSelf>;
+        readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
         readonly status: Schema.Literal<["active", "cancelled"]>;
         readonly created_by: Schema.brand<typeof Schema.String, "TeamMemberId">;
         readonly created_at: Model.DateTimeFromDate;
@@ -174,6 +190,8 @@ declare const EventSeries_base: import("@effect/experimental/VariantSchema").Cla
         readonly days_of_week: Schema.filter<Schema.filter<Schema.Array$<Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">>>>;
         readonly start_date: typeof Schema.DateFromSelf;
         readonly end_date: Schema.OptionFromNullOr<typeof Schema.DateFromSelf>;
+        readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
         readonly status: Schema.Literal<["active", "cancelled"]>;
         readonly created_by: Schema.brand<typeof Schema.String, "TeamMemberId">;
         readonly created_at: import("@effect/experimental/VariantSchema").Overrideable<import("effect/DateTime").Utc, Date, never>;
@@ -192,6 +210,8 @@ declare const EventSeries_base: import("@effect/experimental/VariantSchema").Cla
         readonly days_of_week: Schema.filter<Schema.filter<Schema.Array$<Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">>>>;
         readonly start_date: typeof Schema.DateFromSelf;
         readonly end_date: Schema.OptionFromNullOr<typeof Schema.DateFromSelf>;
+        readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
         readonly created_by: Schema.brand<typeof Schema.String, "TeamMemberId">;
         readonly updated_at: import("@effect/experimental/VariantSchema").Overrideable<import("effect/DateTime").Utc, Date, never>;
     }>;
@@ -208,6 +228,8 @@ declare const EventSeries_base: import("@effect/experimental/VariantSchema").Cla
         readonly days_of_week: Schema.filter<Schema.filter<Schema.Array$<Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">>>>;
         readonly start_date: typeof Schema.DateFromSelf;
         readonly end_date: Schema.OptionFromNullOr<typeof Schema.DateFromSelf>;
+        readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
         readonly status: Schema.Literal<["active", "cancelled"]>;
         readonly created_by: Schema.brand<typeof Schema.String, "TeamMemberId">;
         readonly created_at: typeof Schema.DateTimeUtc;
@@ -225,6 +247,8 @@ declare const EventSeries_base: import("@effect/experimental/VariantSchema").Cla
         readonly days_of_week: Schema.filter<Schema.filter<Schema.Array$<Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">>>>;
         readonly start_date: typeof Schema.DateFromSelf;
         readonly end_date: Schema.OptionFromNullOr<typeof Schema.DateFromSelf>;
+        readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
         readonly status: Schema.Literal<["active", "cancelled"]>;
         readonly created_by: Schema.brand<typeof Schema.String, "TeamMemberId">;
     }>;
@@ -240,6 +264,8 @@ declare const EventSeries_base: import("@effect/experimental/VariantSchema").Cla
         readonly days_of_week: Schema.filter<Schema.filter<Schema.Array$<Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">>>>;
         readonly start_date: typeof Schema.DateFromSelf;
         readonly end_date: Schema.OptionFromNullOr<typeof Schema.DateFromSelf>;
+        readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
         readonly status: Schema.Literal<["active", "cancelled"]>;
         readonly created_by: Schema.brand<typeof Schema.String, "TeamMemberId">;
     }>;

package/dist/dts/models/EventSeries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EventSeries.d.ts","sourceRoot":"","sources":["../../../src/models/EventSeries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAKhC,eAAO,MAAM,aAAa,qDAAoD,CAAC;AAC/E,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAC;AAEtD,eAAO,MAAM,mBAAmB,wCAAuC,CAAC;AACxE,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAC;AAElE,eAAO,MAAM,SAAS,6DAAmE,CAAC;AAC1F,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAC;AAE9C,eAAO,MAAM,UAAU,0GAAuE,CAAC;AAC/F,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAC;AAEhD,eAAO,MAAM,iBAAiB,yCAAwC,CAAC;AACvE,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9D,qBAAa,WAAY,SAAQ,gBAiB/B;CAAG"}
+{"version":3,"file":"EventSeries.d.ts","sourceRoot":"","sources":["../../../src/models/EventSeries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAMhC,eAAO,MAAM,aAAa,qDAAoD,CAAC;AAC/E,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAC;AAEtD,eAAO,MAAM,mBAAmB,wCAAuC,CAAC;AACxE,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAC;AAElE,eAAO,MAAM,SAAS,6DAAmE,CAAC;AAC1F,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAC;AAE9C,eAAO,MAAM,UAAU,0GAAuE,CAAC;AAC/F,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAC;AAEhD,eAAO,MAAM,iBAAiB,yCAAwC,CAAC;AACvE,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9D,qBAAa,WAAY,SAAQ,gBAmB/B;CAAG"}

package/dist/dts/models/RoleSyncEvent.d.ts

@@ -40,10 +40,10 @@ declare const RoleSyncEvent_base: import("@effect/experimental/VariantSchema").C
     readonly role_id: string & import("effect/Brand").Brand<"RoleId">;
 } & {
     readonly error: import("effect/Option").Option<string>;
-} & {
-    readonly event_type: "role_assigned" | "role_unassigned" | "role_created" | "role_deleted";
 } & {
     readonly team_member_id: import("effect/Option").Option<string & import("effect/Brand").Brand<"TeamMemberId">>;
+} & {
+    readonly event_type: "role_assigned" | "role_unassigned" | "role_created" | "role_deleted";
 } & {
     readonly discord_user_id: import("effect/Option").Option<string>;
 } & {
@@ -74,10 +74,10 @@ declare const RoleSyncEvent_base: import("@effect/experimental/VariantSchema").C
     readonly role_id: string & import("effect/Brand").Brand<"RoleId">;
 } & {
     readonly error: import("effect/Option").Option<string>;
-} & {
-    readonly event_type: "role_assigned" | "role_unassigned" | "role_created" | "role_deleted";
 } & {
     readonly team_member_id: import("effect/Option").Option<string & import("effect/Brand").Brand<"TeamMemberId">>;
+} & {
+    readonly event_type: "role_assigned" | "role_unassigned" | "role_created" | "role_deleted";
 } & {
     readonly discord_user_id: import("effect/Option").Option<string>;
 } & {

package/dist/dts/models/TrainingType.d.ts

@@ -6,13 +6,15 @@ declare const TrainingType_base: import("@effect/experimental/VariantSchema").Cl
     readonly id: Model.Generated<Schema.brand<typeof Schema.String, "TrainingTypeId">>;
     readonly team_id: Schema.brand<typeof Schema.String, "TeamId">;
     readonly name: typeof Schema.String;
-    readonly group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+    readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+    readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
     readonly created_at: Model.DateTimeInsertFromDate;
 }, import("@effect/experimental/VariantSchema").ExtractFields<"select", {
     readonly id: Model.Generated<Schema.brand<typeof Schema.String, "TrainingTypeId">>;
     readonly team_id: Schema.brand<typeof Schema.String, "TeamId">;
     readonly name: typeof Schema.String;
-    readonly group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+    readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+    readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
     readonly created_at: Model.DateTimeInsertFromDate;
 }, true>, {
     readonly name: string;
@@ -23,12 +25,15 @@ declare const TrainingType_base: import("@effect/experimental/VariantSchema").Cl
 } & {
     readonly team_id: string & import("effect/Brand").Brand<"TeamId">;
 } & {
-    readonly group_id: import("effect/Option").Option<string & import("effect/Brand").Brand<"GroupId">>;
+    readonly owner_group_id: import("effect/Option").Option<string & import("effect/Brand").Brand<"GroupId">>;
+} & {
+    readonly member_group_id: import("effect/Option").Option<string & import("effect/Brand").Brand<"GroupId">>;
 }, Schema.Struct.Encoded<import("@effect/experimental/VariantSchema").ExtractFields<"select", {
     readonly id: Model.Generated<Schema.brand<typeof Schema.String, "TrainingTypeId">>;
     readonly team_id: Schema.brand<typeof Schema.String, "TeamId">;
     readonly name: typeof Schema.String;
-    readonly group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+    readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+    readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
     readonly created_at: Model.DateTimeInsertFromDate;
 }, true>>, never, {
     readonly name: string;
@@ -39,43 +44,51 @@ declare const TrainingType_base: import("@effect/experimental/VariantSchema").Cl
 } & {
     readonly team_id: string & import("effect/Brand").Brand<"TeamId">;
 } & {
-    readonly group_id: import("effect/Option").Option<string & import("effect/Brand").Brand<"GroupId">>;
+    readonly owner_group_id: import("effect/Option").Option<string & import("effect/Brand").Brand<"GroupId">>;
+} & {
+    readonly member_group_id: import("effect/Option").Option<string & import("effect/Brand").Brand<"GroupId">>;
 }> & {
     readonly select: Schema.Struct<{
         readonly id: Schema.brand<typeof Schema.String, "TrainingTypeId">;
         readonly team_id: Schema.brand<typeof Schema.String, "TeamId">;
         readonly name: typeof Schema.String;
-        readonly group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
         readonly created_at: Model.DateTimeFromDate;
     }>;
     readonly insert: Schema.Struct<{
         readonly team_id: Schema.brand<typeof Schema.String, "TeamId">;
         readonly name: typeof Schema.String;
-        readonly group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
         readonly created_at: import("@effect/experimental/VariantSchema").Overrideable<import("effect/DateTime").Utc, Date, never>;
     }>;
     readonly update: Schema.Struct<{
         readonly id: Schema.brand<typeof Schema.String, "TrainingTypeId">;
         readonly team_id: Schema.brand<typeof Schema.String, "TeamId">;
         readonly name: typeof Schema.String;
-        readonly group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
     }>;
     readonly json: Schema.Struct<{
         readonly id: Schema.brand<typeof Schema.String, "TrainingTypeId">;
         readonly team_id: Schema.brand<typeof Schema.String, "TeamId">;
         readonly name: typeof Schema.String;
-        readonly group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
         readonly created_at: typeof Schema.DateTimeUtc;
     }>;
     readonly jsonCreate: Schema.Struct<{
         readonly team_id: Schema.brand<typeof Schema.String, "TeamId">;
         readonly name: typeof Schema.String;
-        readonly group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
     }>;
     readonly jsonUpdate: Schema.Struct<{
         readonly team_id: Schema.brand<typeof Schema.String, "TeamId">;
         readonly name: typeof Schema.String;
-        readonly group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly owner_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
+        readonly member_group_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "GroupId">>;
     }>;
 };
 export declare class TrainingType extends TrainingType_base {

package/dist/dts/models/TrainingType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TrainingType.d.ts","sourceRoot":"","sources":["../../../src/models/TrainingType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIhC,eAAO,MAAM,cAAc,sDAAqD,CAAC;AACjF,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAExD,qBAAa,YAAa,SAAQ,iBAMhC;CAAG"}
+{"version":3,"file":"TrainingType.d.ts","sourceRoot":"","sources":["../../../src/models/TrainingType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIhC,eAAO,MAAM,cAAc,sDAAqD,CAAC;AACjF,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAExD,qBAAa,YAAa,SAAQ,iBAOhC;CAAG"}

package/dist/dts/rpc/SyncRpcs.d.ts

@@ -1,5 +1,14 @@
 import { RpcGroup } from '@effect/rpc';
-declare const SyncRpcs_base: RpcGroup.RpcGroup<import("@effect/rpc/Rpc").Rpc<"Channel/GetUnprocessedEvents", import("effect/Schema").Struct<{
+declare const SyncRpcs_base: RpcGroup.RpcGroup<import("@effect/rpc/Rpc").Rpc<"Activity/LogActivity", import("effect/Schema").Struct<{
+    guild_id: import("effect/Schema").brand<typeof import("effect/Schema").String, "Snowflake">;
+    discord_user_id: import("effect/Schema").brand<typeof import("effect/Schema").String, "Snowflake">;
+    activity_type: typeof import("effect/Schema").String;
+    duration_minutes: import("effect/Schema").OptionFromNullOr<import("effect/Schema").filter<typeof import("effect/Schema").Int>>;
+    note: import("effect/Schema").OptionFromNullOr<typeof import("effect/Schema").String>;
+}>, typeof import("./activity/ActivityRpcModels.js").LogActivityResult, import("effect/Schema").Union<[typeof import("./activity/ActivityRpcModels.js").ActivityMemberNotFound, typeof import("./activity/ActivityRpcModels.js").ActivityGuildNotFound]>, never> | import("@effect/rpc/Rpc").Rpc<"Activity/GetStats", import("effect/Schema").Struct<{
+    guild_id: import("effect/Schema").brand<typeof import("effect/Schema").String, "Snowflake">;
+    discord_user_id: import("effect/Schema").brand<typeof import("effect/Schema").String, "Snowflake">;
+}>, typeof import("./activity/ActivityRpcModels.js").GetStatsResult, import("effect/Schema").Union<[typeof import("./activity/ActivityRpcModels.js").ActivityMemberNotFound, typeof import("./activity/ActivityRpcModels.js").ActivityGuildNotFound]>, never> | import("@effect/rpc/Rpc").Rpc<"Channel/GetUnprocessedEvents", import("effect/Schema").Struct<{
     limit: typeof import("effect/Schema").Number;
 }>, import("effect/Schema").Array$<import("effect/Schema").Union<[typeof import("./channel/ChannelRpcEvents.js").ChannelCreatedEvent, typeof import("./channel/ChannelRpcEvents.js").ChannelDeletedEvent, typeof import("./channel/ChannelRpcEvents.js").ChannelMemberAddedEvent, typeof import("./channel/ChannelRpcEvents.js").ChannelMemberRemovedEvent]>>, typeof import("effect/Schema").Never, never> | import("@effect/rpc/Rpc").Rpc<"Channel/MarkEventProcessed", import("effect/Schema").Struct<{
     id: import("effect/Schema").brand<typeof import("effect/Schema").String, "ChannelSyncEventId">;
@@ -36,7 +45,7 @@ declare const SyncRpcs_base: RpcGroup.RpcGroup<import("@effect/rpc/Rpc").Rpc<"Ch
     discord_user_id: import("effect/Schema").brand<typeof import("effect/Schema").String, "Snowflake">;
     response: import("effect/Schema").Literal<["yes", "no", "maybe"]>;
     message: import("effect/Schema").OptionFromNullOr<typeof import("effect/Schema").String>;
-}>, typeof import("./event/EventRpcModels.js").RsvpCountsResult, import("effect/Schema").Union<[typeof import("./event/EventRpcModels.js").RsvpMemberNotFound, typeof import("./event/EventRpcModels.js").RsvpDeadlinePassed, typeof import("./event/EventRpcModels.js").RsvpEventNotFound]>, never> | import("@effect/rpc/Rpc").Rpc<"Event/GetRsvpCounts", import("effect/Schema").Struct<{
+}>, typeof import("./event/EventRpcModels.js").RsvpCountsResult, import("effect/Schema").Union<[typeof import("./event/EventRpcModels.js").RsvpMemberNotFound, typeof import("./event/EventRpcModels.js").RsvpDeadlinePassed, typeof import("./event/EventRpcModels.js").RsvpEventNotFound, typeof import("./event/EventRpcModels.js").RsvpNotGroupMember]>, never> | import("@effect/rpc/Rpc").Rpc<"Event/GetRsvpCounts", import("effect/Schema").Struct<{
     event_id: import("effect/Schema").brand<typeof import("effect/Schema").String, "EventId">;
 }>, typeof import("./event/EventRpcModels.js").RsvpCountsResult, typeof import("effect/Schema").Never, never> | import("@effect/rpc/Rpc").Rpc<"Event/GetEventEmbedInfo", import("effect/Schema").Struct<{
     event_id: import("effect/Schema").brand<typeof import("effect/Schema").String, "EventId">;
@@ -52,7 +61,9 @@ declare const SyncRpcs_base: RpcGroup.RpcGroup<import("@effect/rpc/Rpc").Rpc<"Ch
     guild_id: import("effect/Schema").brand<typeof import("effect/Schema").String, "Snowflake">;
     offset: typeof import("effect/Schema").Number;
     limit: typeof import("effect/Schema").Number;
-}>, typeof import("./event/EventRpcModels.js").GuildEventListResult, typeof import("./event/EventRpcModels.js").GuildNotFound, never> | import("@effect/rpc/Rpc").Rpc<"Event/CreateEvent", import("effect/Schema").Struct<{
+}>, typeof import("./event/EventRpcModels.js").GuildEventListResult, typeof import("./event/EventRpcModels.js").GuildNotFound, never> | import("@effect/rpc/Rpc").Rpc<"Event/GetTrainingTypesByGuild", import("effect/Schema").Struct<{
+    guild_id: import("effect/Schema").brand<typeof import("effect/Schema").String, "Snowflake">;
+}>, import("effect/Schema").Array$<typeof import("./event/EventRpcModels.js").TrainingTypeChoice>, typeof import("effect/Schema").Never, never> | import("@effect/rpc/Rpc").Rpc<"Event/CreateEvent", import("effect/Schema").Struct<{
     guild_id: import("effect/Schema").brand<typeof import("effect/Schema").String, "Snowflake">;
     discord_user_id: import("effect/Schema").brand<typeof import("effect/Schema").String, "Snowflake">;
     event_type: import("effect/Schema").Literal<["training", "match", "tournament", "meeting", "social", "other"]>;
@@ -61,6 +72,7 @@ declare const SyncRpcs_base: RpcGroup.RpcGroup<import("@effect/rpc/Rpc").Rpc<"Ch
     end_at: import("effect/Schema").OptionFromNullOr<typeof import("effect/Schema").String>;
     location: import("effect/Schema").OptionFromNullOr<typeof import("effect/Schema").String>;
     description: import("effect/Schema").OptionFromNullOr<typeof import("effect/Schema").String>;
+    training_type_id: import("effect/Schema").OptionFromNullOr<import("effect/Schema").brand<typeof import("effect/Schema").String, "TrainingTypeId">>;
 }>, typeof import("./event/EventRpcModels.js").CreateEventResult, import("effect/Schema").Union<[typeof import("./event/EventRpcModels.js").CreateEventNotMember, typeof import("./event/EventRpcModels.js").CreateEventForbidden, typeof import("./event/EventRpcModels.js").CreateEventInvalidDate]>, never> | import("@effect/rpc/Rpc").Rpc<"Guild/RegisterGuild", import("effect/Schema").Struct<{
     guild_id: import("effect/Schema").brand<typeof import("effect/Schema").String, "Snowflake">;
     guild_name: typeof import("effect/Schema").String;

package/dist/dts/rpc/SyncRpcs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SyncRpcs.d.ts","sourceRoot":"","sources":["../../../src/rpc/SyncRpcs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMvC,qBAAa,QAAS,SAAQ,aAK7B;CAAG"}
+{"version":3,"file":"SyncRpcs.d.ts","sourceRoot":"","sources":["../../../src/rpc/SyncRpcs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOvC,qBAAa,QAAS,SAAQ,aAM7B;CAAG"}

package/dist/dts/rpc/activity/ActivityRpcGroup.d.ts

@@ -0,0 +1,14 @@
+import { Rpc, RpcGroup } from '@effect/rpc';
+import { Schema } from 'effect';
+import { ActivityGuildNotFound, ActivityMemberNotFound, GetStatsResult, LogActivityResult } from './ActivityRpcModels.js';
+export declare const ActivityRpcGroup: RpcGroup.RpcGroup<Rpc.Rpc<"Activity/LogActivity", Schema.Struct<{
+    guild_id: Schema.brand<typeof Schema.String, "Snowflake">;
+    discord_user_id: Schema.brand<typeof Schema.String, "Snowflake">;
+    activity_type: typeof Schema.String;
+    duration_minutes: Schema.OptionFromNullOr<Schema.filter<typeof Schema.Int>>;
+    note: Schema.OptionFromNullOr<typeof Schema.String>;
+}>, typeof LogActivityResult, Schema.Union<[typeof ActivityMemberNotFound, typeof ActivityGuildNotFound]>, never> | Rpc.Rpc<"Activity/GetStats", Schema.Struct<{
+    guild_id: Schema.brand<typeof Schema.String, "Snowflake">;
+    discord_user_id: Schema.brand<typeof Schema.String, "Snowflake">;
+}>, typeof GetStatsResult, Schema.Union<[typeof ActivityMemberNotFound, typeof ActivityGuildNotFound]>, never>>;
+//# sourceMappingURL=ActivityRpcGroup.d.ts.map

package/dist/dts/rpc/activity/ActivityRpcGroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivityRpcGroup.d.ts","sourceRoot":"","sources":["../../../../src/rpc/activity/ActivityRpcGroup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,cAAc,EACd,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAEhC,eAAO,MAAM,gBAAgB;;;;;;;;;+GAoBR,CAAC"}

package/dist/dts/rpc/activity/ActivityRpcModels.d.ts

@@ -0,0 +1,67 @@
+import { Schema } from 'effect';
+declare const LogActivityResult_base: Schema.Class<LogActivityResult, {
+    id: Schema.brand<typeof Schema.String, "ActivityLogId">;
+    activity_type_id: typeof Schema.String;
+    logged_at: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    id: Schema.brand<typeof Schema.String, "ActivityLogId">;
+    activity_type_id: typeof Schema.String;
+    logged_at: typeof Schema.String;
+}>, never, {
+    readonly id: string & import("effect/Brand").Brand<"ActivityLogId">;
+} & {
+    readonly activity_type_id: string;
+} & {
+    readonly logged_at: string;
+}, {}, {}>;
+export declare class LogActivityResult extends LogActivityResult_base {
+}
+declare const ActivityMemberNotFound_base: Schema.TaggedErrorClass<ActivityMemberNotFound, "ActivityMemberNotFound", {
+    readonly _tag: Schema.tag<"ActivityMemberNotFound">;
+}>;
+export declare class ActivityMemberNotFound extends ActivityMemberNotFound_base {
+}
+declare const ActivityGuildNotFound_base: Schema.TaggedErrorClass<ActivityGuildNotFound, "ActivityGuildNotFound", {
+    readonly _tag: Schema.tag<"ActivityGuildNotFound">;
+}>;
+export declare class ActivityGuildNotFound extends ActivityGuildNotFound_base {
+}
+declare const GetStatsResult_base: Schema.Class<GetStatsResult, {
+    current_streak: typeof Schema.Int;
+    longest_streak: typeof Schema.Int;
+    total_activities: typeof Schema.Int;
+    total_duration_minutes: typeof Schema.Int;
+    counts: Schema.Array$<Schema.Struct<{
+        activity_type_id: typeof Schema.String;
+        activity_type_name: typeof Schema.String;
+        count: typeof Schema.Int;
+    }>>;
+}, Schema.Struct.Encoded<{
+    current_streak: typeof Schema.Int;
+    longest_streak: typeof Schema.Int;
+    total_activities: typeof Schema.Int;
+    total_duration_minutes: typeof Schema.Int;
+    counts: Schema.Array$<Schema.Struct<{
+        activity_type_id: typeof Schema.String;
+        activity_type_name: typeof Schema.String;
+        count: typeof Schema.Int;
+    }>>;
+}>, never, {
+    readonly counts: readonly {
+        readonly activity_type_id: string;
+        readonly count: number;
+        readonly activity_type_name: string;
+    }[];
+} & {
+    readonly current_streak: number;
+} & {
+    readonly longest_streak: number;
+} & {
+    readonly total_activities: number;
+} & {
+    readonly total_duration_minutes: number;
+}, {}, {}>;
+export declare class GetStatsResult extends GetStatsResult_base {
+}
+export {};
+//# sourceMappingURL=ActivityRpcModels.d.ts.map

package/dist/dts/rpc/activity/ActivityRpcModels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivityRpcModels.d.ts","sourceRoot":"","sources":["../../../../src/rpc/activity/ActivityRpcModels.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;;;;;;;;;;;;;;;;AAGhC,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG;;;;AAEL,qBAAa,sBAAuB,SAAQ,2BAG3C;CAAG;;;;AAEJ,qBAAa,qBAAsB,SAAQ,0BAG1C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEJ,qBAAa,cAAe,SAAQ,mBAYlC;CAAG"}

package/dist/dts/rpc/event/EventRpcGroup.d.ts

@@ -1,6 +1,6 @@
 import { Rpc, RpcGroup } from '@effect/rpc';
 import { Schema } from 'effect';
-import { ChannelEventEntry, CreateEventForbidden, CreateEventInvalidDate, CreateEventNotMember, CreateEventResult, EventDiscordMessage, EventEmbedInfo, GuildEventListResult, GuildNotFound, RsvpAttendeesResult, RsvpCountsResult, RsvpDeadlinePassed, RsvpEventNotFound, RsvpMemberNotFound, RsvpReminderSummary } from './EventRpcModels.js';
+import { ChannelEventEntry, CreateEventForbidden, CreateEventInvalidDate, CreateEventNotMember, CreateEventResult, EventDiscordMessage, EventEmbedInfo, GuildEventListResult, GuildNotFound, RsvpAttendeesResult, RsvpCountsResult, RsvpDeadlinePassed, RsvpEventNotFound, RsvpMemberNotFound, RsvpNotGroupMember, RsvpReminderSummary, TrainingTypeChoice } from './EventRpcModels.js';
 export declare const EventRpcGroup: RpcGroup.RpcGroup<Rpc.Rpc<"Event/GetUnprocessedEvents", Schema.Struct<{
     limit: typeof Schema.Number;
 }>, Schema.Array$<Schema.Union<[typeof import("./EventRpcEvents.js").EventCreatedEvent, typeof import("./EventRpcEvents.js").EventUpdatedEvent, typeof import("./EventRpcEvents.js").EventCancelledEvent, typeof import("./EventRpcEvents.js").RsvpReminderEvent]>>, typeof Schema.Never, never> | Rpc.Rpc<"Event/MarkEventProcessed", Schema.Struct<{
@@ -20,7 +20,7 @@ export declare const EventRpcGroup: RpcGroup.RpcGroup<Rpc.Rpc<"Event/GetUnproces
     discord_user_id: Schema.brand<typeof Schema.String, "Snowflake">;
     response: Schema.Literal<["yes", "no", "maybe"]>;
     message: Schema.OptionFromNullOr<typeof Schema.String>;
-}>, typeof RsvpCountsResult, Schema.Union<[typeof RsvpMemberNotFound, typeof RsvpDeadlinePassed, typeof RsvpEventNotFound]>, never> | Rpc.Rpc<"Event/GetRsvpCounts", Schema.Struct<{
+}>, typeof RsvpCountsResult, Schema.Union<[typeof RsvpMemberNotFound, typeof RsvpDeadlinePassed, typeof RsvpEventNotFound, typeof RsvpNotGroupMember]>, never> | Rpc.Rpc<"Event/GetRsvpCounts", Schema.Struct<{
     event_id: Schema.brand<typeof Schema.String, "EventId">;
 }>, typeof RsvpCountsResult, typeof Schema.Never, never> | Rpc.Rpc<"Event/GetEventEmbedInfo", Schema.Struct<{
     event_id: Schema.brand<typeof Schema.String, "EventId">;
@@ -36,7 +36,9 @@ export declare const EventRpcGroup: RpcGroup.RpcGroup<Rpc.Rpc<"Event/GetUnproces
     guild_id: Schema.brand<typeof Schema.String, "Snowflake">;
     offset: typeof Schema.Number;
     limit: typeof Schema.Number;
-}>, typeof GuildEventListResult, typeof GuildNotFound, never> | Rpc.Rpc<"Event/CreateEvent", Schema.Struct<{
+}>, typeof GuildEventListResult, typeof GuildNotFound, never> | Rpc.Rpc<"Event/GetTrainingTypesByGuild", Schema.Struct<{
+    guild_id: Schema.brand<typeof Schema.String, "Snowflake">;
+}>, Schema.Array$<typeof TrainingTypeChoice>, typeof Schema.Never, never> | Rpc.Rpc<"Event/CreateEvent", Schema.Struct<{
     guild_id: Schema.brand<typeof Schema.String, "Snowflake">;
     discord_user_id: Schema.brand<typeof Schema.String, "Snowflake">;
     event_type: Schema.Literal<["training", "match", "tournament", "meeting", "social", "other"]>;
@@ -45,5 +47,6 @@ export declare const EventRpcGroup: RpcGroup.RpcGroup<Rpc.Rpc<"Event/GetUnproces
     end_at: Schema.OptionFromNullOr<typeof Schema.String>;
     location: Schema.OptionFromNullOr<typeof Schema.String>;
     description: Schema.OptionFromNullOr<typeof Schema.String>;
+    training_type_id: Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>;
 }>, typeof CreateEventResult, Schema.Union<[typeof CreateEventNotMember, typeof CreateEventForbidden, typeof CreateEventInvalidDate]>, never>>;
 //# sourceMappingURL=EventRpcGroup.d.ts.map

package/dist/dts/rpc/event/EventRpcGroup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EventRpcGroup.d.ts","sourceRoot":"","sources":["../../../../src/rpc/event/EventRpcGroup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,EACpB,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAE7B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8IA4ER,CAAC"}
+{"version":3,"file":"EventRpcGroup.d.ts","sourceRoot":"","sources":["../../../../src/rpc/event/EventRpcGroup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,EACpB,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,qBAAqB,CAAC;AAE7B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8IAsFR,CAAC"}

package/dist/dts/rpc/event/EventRpcModels.d.ts

@@ -122,6 +122,11 @@ declare const RsvpEventNotFound_base: Schema.TaggedErrorClass<RsvpEventNotFound,
 }>;
 export declare class RsvpEventNotFound extends RsvpEventNotFound_base {
 }
+declare const RsvpNotGroupMember_base: Schema.TaggedErrorClass<RsvpNotGroupMember, "RsvpNotGroupMember", {
+    readonly _tag: Schema.tag<"RsvpNotGroupMember">;
+}>;
+export declare class RsvpNotGroupMember extends RsvpNotGroupMember_base {
+}
 declare const CreateEventNotMember_base: Schema.TaggedErrorClass<CreateEventNotMember, "CreateEventNotMember", {
     readonly _tag: Schema.tag<"CreateEventNotMember">;
 }>;
@@ -285,5 +290,18 @@ declare const RsvpReminderSummary_base: Schema.Class<RsvpReminderSummary, {
 }, {}, {}>;
 export declare class RsvpReminderSummary extends RsvpReminderSummary_base {
 }
+declare const TrainingTypeChoice_base: Schema.Class<TrainingTypeChoice, {
+    id: Schema.brand<typeof Schema.String, "TrainingTypeId">;
+    name: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    id: Schema.brand<typeof Schema.String, "TrainingTypeId">;
+    name: typeof Schema.String;
+}>, never, {
+    readonly name: string;
+} & {
+    readonly id: string & import("effect/Brand").Brand<"TrainingTypeId">;
+}, {}, {}>;
+export declare class TrainingTypeChoice extends TrainingTypeChoice_base {
+}
 export {};
 //# sourceMappingURL=EventRpcModels.d.ts.map

package/dist/dts/rpc/event/EventRpcModels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EventRpcModels.d.ts","sourceRoot":"","sources":["../../../../src/rpc/event/EventRpcModels.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;;;;;;;;;;;;AAGhC,qBAAa,mBAAoB,SAAQ,wBAGvC;CAAG;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,cAAe,SAAQ,mBAOlC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAWrC;CAAG;;;;AAEL,qBAAa,kBAAmB,SAAQ,uBAGvC;CAAG;;;;AAEJ,qBAAa,kBAAmB,SAAQ,uBAGvC;CAAG;;;;AAEJ,qBAAa,iBAAkB,SAAQ,sBAGtC;CAAG;;;;AAEJ,qBAAa,oBAAqB,SAAQ,yBAGzC;CAAG;;;;AAEJ,qBAAa,oBAAqB,SAAQ,yBAGzC;CAAG;;;;AAEJ,qBAAa,sBAAuB,SAAQ,2BAG3C;CAAG;;;;;;;;;;;;AAEJ,qBAAa,iBAAkB,SAAQ,sBAGrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAUvC;CAAG;;;;;;;;;;;;;;;;AAEL,qBAAa,oBAAqB,SAAQ,yBAMxC;CAAG;;;;AAEL,qBAAa,aAAc,SAAQ,kBAAwD;CAAG;;;;;;;;;;;;;;;;;;;;AAE9F,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;;;;;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAGvC;CAAG;;;;;;;;;;;;;;;;AAEL,qBAAa,oBAAqB,SAAQ,yBAMxC;CAAG;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAKvC;CAAG"}
+{"version":3,"file":"EventRpcModels.d.ts","sourceRoot":"","sources":["../../../../src/rpc/event/EventRpcModels.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;;;;;;;;;;;;AAIhC,qBAAa,mBAAoB,SAAQ,wBAGvC;CAAG;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,cAAe,SAAQ,mBAOlC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAWrC;CAAG;;;;AAEL,qBAAa,kBAAmB,SAAQ,uBAGvC;CAAG;;;;AAEJ,qBAAa,kBAAmB,SAAQ,uBAGvC;CAAG;;;;AAEJ,qBAAa,iBAAkB,SAAQ,sBAGtC;CAAG;;;;AAEJ,qBAAa,kBAAmB,SAAQ,uBAGvC;CAAG;;;;AAEJ,qBAAa,oBAAqB,SAAQ,yBAGzC;CAAG;;;;AAEJ,qBAAa,oBAAqB,SAAQ,yBAGzC;CAAG;;;;AAEJ,qBAAa,sBAAuB,SAAQ,2BAG3C;CAAG;;;;;;;;;;;;AAEJ,qBAAa,iBAAkB,SAAQ,sBAGrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAUvC;CAAG;;;;;;;;;;;;;;;;AAEL,qBAAa,oBAAqB,SAAQ,yBAMxC;CAAG;;;;AAEL,qBAAa,aAAc,SAAQ,kBAAwD;CAAG;;;;;;;;;;;;;;;;;;;;AAE9F,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;;;;;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAGvC;CAAG;;;;;;;;;;;;;;;;AAEL,qBAAa,oBAAqB,SAAQ,yBAMxC;CAAG;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAKvC;CAAG;;;;;;;;;;;;AAEL,qBAAa,kBAAmB,SAAQ,uBAGtC;CAAG"}

package/dist/esm/api/ActivityLogApi.js

@@ -0,0 +1,108 @@
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '../api/Auth.js';
+import { ActivityLogId, ActivitySource } from '../models/ActivityLog.js';
+import { ActivityTypeId } from '../models/ActivityType.js';
+import { TeamId } from '../models/Team.js';
+import { TeamMemberId } from '../models/TeamMember.js';
+export class ActivityLogEntry extends /*#__PURE__*/Schema.Class('ActivityLogEntry')({
+  id: ActivityLogId,
+  activityTypeId: ActivityTypeId,
+  activityTypeName: Schema.String,
+  loggedAt: Schema.String,
+  durationMinutes: /*#__PURE__*/Schema.OptionFromNullOr(Schema.Int),
+  note: /*#__PURE__*/Schema.OptionFromNullOr(Schema.String),
+  source: ActivitySource
+}) {}
+export class ActivityLogListResponse extends /*#__PURE__*/Schema.Class('ActivityLogListResponse')({
+  logs: /*#__PURE__*/Schema.Array(ActivityLogEntry)
+}) {}
+export class CreateActivityLogRequest extends /*#__PURE__*/Schema.Class('CreateActivityLogRequest')({
+  activityTypeId: ActivityTypeId,
+  durationMinutes: /*#__PURE__*/Schema.OptionFromNullOr(/*#__PURE__*/Schema.Int.pipe(/*#__PURE__*/Schema.between(1, 1440))),
+  note: /*#__PURE__*/Schema.OptionFromNullOr(Schema.String)
+}) {}
+export class UpdateActivityLogRequest extends /*#__PURE__*/Schema.Class('UpdateActivityLogRequest')({
+  activityTypeId: /*#__PURE__*/Schema.optionalWith(ActivityTypeId, {
+    as: 'Option'
+  }),
+  durationMinutes: /*#__PURE__*/Schema.optionalWith(/*#__PURE__*/Schema.OptionFromNullOr(/*#__PURE__*/Schema.Int.pipe(/*#__PURE__*/Schema.between(1, 1440))), {
+    as: 'Option'
+  }),
+  note: /*#__PURE__*/Schema.optionalWith(/*#__PURE__*/Schema.OptionFromNullOr(Schema.String), {
+    as: 'Option'
+  })
+}) {}
+export class ActivityTypeEntry extends /*#__PURE__*/Schema.Class('ActivityTypeEntry')({
+  id: ActivityTypeId,
+  name: Schema.String,
+  slug: /*#__PURE__*/Schema.OptionFromNullOr(Schema.String)
+}) {}
+export class ActivityTypeListResponse extends /*#__PURE__*/Schema.Class('ActivityTypeListResponse')({
+  activityTypes: /*#__PURE__*/Schema.Array(ActivityTypeEntry)
+}) {}
+export class MemberNotFound extends /*#__PURE__*/Schema.TaggedError()('ActivityLogMemberNotFound', {}, /*#__PURE__*/HttpApiSchema.annotations({
+  status: 404
+})) {}
+export class Forbidden extends /*#__PURE__*/Schema.TaggedError()('ActivityLogForbidden', {}, /*#__PURE__*/HttpApiSchema.annotations({
+  status: 403
+})) {}
+export class LogNotFound extends /*#__PURE__*/Schema.TaggedError()('ActivityLogNotFound', {}, /*#__PURE__*/HttpApiSchema.annotations({
+  status: 404
+})) {}
+export class MemberInactive extends /*#__PURE__*/Schema.TaggedError()('ActivityLogMemberInactive', {}, /*#__PURE__*/HttpApiSchema.annotations({
+  status: 403
+})) {}
+export class AutoSourceForbidden extends /*#__PURE__*/Schema.TaggedError()('ActivityLogAutoSourceForbidden', {}, /*#__PURE__*/HttpApiSchema.annotations({
+  status: 403
+})) {}
+export class ActivityLogApiGroup extends /*#__PURE__*/HttpApiGroup.make('activityLog').add(HttpApiEndpoint.get('listLogs', '/teams/:teamId/members/:memberId/activity-logs').addSuccess(ActivityLogListResponse).addError(MemberNotFound, {
+  status: 404
+}).addError(Forbidden, {
+  status: 403
+}).setPath(Schema.Struct({
+  teamId: TeamId,
+  memberId: TeamMemberId
+})).middleware(AuthMiddleware)).add(HttpApiEndpoint.post('createLog', '/teams/:teamId/members/:memberId/activity-logs').addSuccess(ActivityLogEntry, {
+  status: 201
+}).addError(MemberNotFound, {
+  status: 404
+}).addError(Forbidden, {
+  status: 403
+}).addError(MemberInactive, {
+  status: 403
+}).setPath(Schema.Struct({
+  teamId: TeamId,
+  memberId: TeamMemberId
+})).setPayload(CreateActivityLogRequest).middleware(AuthMiddleware)).add(HttpApiEndpoint.patch('updateLog', '/teams/:teamId/members/:memberId/activity-logs/:logId').addSuccess(ActivityLogEntry).addError(LogNotFound, {
+  status: 404
+}).addError(Forbidden, {
+  status: 403
+}).addError(MemberInactive, {
+  status: 403
+}).addError(AutoSourceForbidden, {
+  status: 403
+}).setPath(Schema.Struct({
+  teamId: TeamId,
+  memberId: TeamMemberId,
+  logId: ActivityLogId
+})).setPayload(UpdateActivityLogRequest).middleware(AuthMiddleware)).add(HttpApiEndpoint.post('deleteLog', '/teams/:teamId/members/:memberId/activity-logs/:logId/delete').addSuccess(Schema.Void, {
+  status: 204
+}).addError(LogNotFound, {
+  status: 404
+}).addError(Forbidden, {
+  status: 403
+}).addError(MemberInactive, {
+  status: 403
+}).addError(AutoSourceForbidden, {
+  status: 403
+}).setPath(Schema.Struct({
+  teamId: TeamId,
+  memberId: TeamMemberId,
+  logId: ActivityLogId
+})).middleware(AuthMiddleware)).add(/*#__PURE__*/HttpApiEndpoint.get('listActivityTypes', '/teams/:teamId/activity-types').addSuccess(ActivityTypeListResponse).addError(Forbidden, {
+  status: 403
+}).setPath(Schema.Struct({
+  teamId: TeamId
+})).middleware(AuthMiddleware)) {}
+//# sourceMappingURL=ActivityLogApi.js.map