@sideline/domain 0.1.1 → 0.2.0

package/dist/dts/api/Auth.d.ts

@@ -2,6 +2,27 @@ import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSecurity } fro
 import { Context, Schema } from 'effect';
 export { UserId } from '../models/User.js';
 export declare const MIN_AGE = 6;
+declare const UserTeam_base: Schema.Class<UserTeam, {
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    teamName: typeof Schema.String;
+    roleNames: Schema.Array$<typeof Schema.String>;
+    permissions: Schema.Array$<Schema.Literal<["team:manage", "team:invite", "roster:view", "roster:manage", "member:view", "member:edit", "member:remove", "role:view", "role:manage"]>>;
+}, Schema.Struct.Encoded<{
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    teamName: typeof Schema.String;
+    roleNames: Schema.Array$<typeof Schema.String>;
+    permissions: Schema.Array$<Schema.Literal<["team:manage", "team:invite", "roster:view", "roster:manage", "member:view", "member:edit", "member:remove", "role:view", "role:manage"]>>;
+}>, never, {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+} & {
+    readonly teamName: string;
+} & {
+    readonly roleNames: readonly string[];
+} & {
+    readonly permissions: readonly ("team:manage" | "team:invite" | "roster:view" | "roster:manage" | "member:view" | "member:edit" | "member:remove" | "role:view" | "role:manage")[];
+}, {}, {}>;
+export declare class UserTeam extends UserTeam_base {
+}
 declare const CurrentUser_base: Schema.Class<CurrentUser, {
     id: Schema.brand<typeof Schema.String, "UserId">;
     discordId: typeof Schema.String;
@@ -64,6 +85,15 @@ declare const UpdateLocaleRequest_base: Schema.Class<UpdateLocaleRequest, {
 }, {}, {}>;
 export declare class UpdateLocaleRequest extends UpdateLocaleRequest_base {
 }
+declare const CreateTeamRequest_base: Schema.Class<CreateTeamRequest, {
+    name: Schema.filter<Schema.filter<typeof Schema.String>>;
+}, Schema.Struct.Encoded<{
+    name: Schema.filter<Schema.filter<typeof Schema.String>>;
+}>, never, {
+    readonly name: string;
+}, {}, {}>;
+export declare class CreateTeamRequest extends CreateTeamRequest_base {
+}
 declare const CompleteProfileRequest_base: Schema.Class<CompleteProfileRequest, {
     name: typeof Schema.String;
     birthYear: Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>;
@@ -97,6 +127,35 @@ declare const CompleteProfileRequest_base: Schema.Class<CompleteProfileRequest,
 }, {}, {}>;
 export declare class CompleteProfileRequest extends CompleteProfileRequest_base {
 }
+declare const UpdateProfileRequest_base: Schema.Class<UpdateProfileRequest, {
+    name: Schema.NullOr<typeof Schema.String>;
+    birthYear: Schema.NullOr<Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>>;
+    gender: Schema.NullOr<Schema.Literal<["male", "female", "other"]>>;
+    jerseyNumber: Schema.NullOr<Schema.filter<Schema.filter<typeof Schema.Number>>>;
+    position: Schema.NullOr<Schema.Literal<["goalkeeper", "defender", "midfielder", "forward"]>>;
+    proficiency: Schema.NullOr<Schema.Literal<["beginner", "intermediate", "advanced", "pro"]>>;
+}, Schema.Struct.Encoded<{
+    name: Schema.NullOr<typeof Schema.String>;
+    birthYear: Schema.NullOr<Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>>;
+    gender: Schema.NullOr<Schema.Literal<["male", "female", "other"]>>;
+    jerseyNumber: Schema.NullOr<Schema.filter<Schema.filter<typeof Schema.Number>>>;
+    position: Schema.NullOr<Schema.Literal<["goalkeeper", "defender", "midfielder", "forward"]>>;
+    proficiency: Schema.NullOr<Schema.Literal<["beginner", "intermediate", "advanced", "pro"]>>;
+}>, never, {
+    readonly name: string | null;
+} & {
+    readonly gender: "male" | "female" | "other" | null;
+} & {
+    readonly position: "goalkeeper" | "defender" | "midfielder" | "forward" | null;
+} & {
+    readonly proficiency: "beginner" | "intermediate" | "advanced" | "pro" | null;
+} & {
+    readonly birthYear: number | null;
+} & {
+    readonly jerseyNumber: number | null;
+}, {}, {}>;
+export declare class UpdateProfileRequest extends UpdateProfileRequest_base {
+}
 declare const Unauthorized_base: Schema.TaggedErrorClass<Unauthorized, "Unauthorized", {
     readonly _tag: Schema.tag<"Unauthorized">;
 }>;
@@ -122,7 +181,7 @@ declare const AuthApiGroup_base: HttpApiGroup.HttpApiGroup<"auth", HttpApiEndpoi
     readonly code: import("effect/Option").Option<string>;
     readonly state: import("effect/Option").Option<string>;
     readonly error: import("effect/Option").Option<string>;
-}, never, never, void, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"me", "GET", never, never, never, never, CurrentUser, Unauthorized, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"completeProfile", "POST", never, never, CompleteProfileRequest, never, CurrentUser, Unauthorized, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"updateLocale", "PATCH", never, never, UpdateLocaleRequest, never, CurrentUser, Unauthorized, AuthMiddleware, never>, never, never, false>;
+}, never, never, void, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"me", "GET", never, never, never, never, CurrentUser, Unauthorized, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"completeProfile", "POST", never, never, CompleteProfileRequest, never, CurrentUser, Unauthorized, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"updateLocale", "PATCH", never, never, UpdateLocaleRequest, never, CurrentUser, Unauthorized, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"updateProfile", "PATCH", never, never, UpdateProfileRequest, never, CurrentUser, Unauthorized, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"myTeams", "GET", never, never, never, never, readonly UserTeam[], Unauthorized, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"createTeam", "POST", never, never, CreateTeamRequest, never, UserTeam, Unauthorized, AuthMiddleware, never>, never, never, false>;
 export declare class AuthApiGroup extends AuthApiGroup_base {
 }
 //# sourceMappingURL=Auth.d.ts.map

package/dist/dts/api/Auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Auth.d.ts","sourceRoot":"","sources":["../../../src/api/Auth.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,YAAY,EACZ,iBAAiB,EAEjB,eAAe,EAChB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGzC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,eAAO,MAAM,OAAO,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEzB,qBAAa,WAAY,SAAQ,gBAa/B;CAAG;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAEvC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,sBAAuB,SAAQ,2BAiB1C;CAAG;;;;AAEL,qBAAa,YAAa,SAAQ,iBAIjC;CAAG;;AAEJ,qBAAa,kBAAmB,SAAQ,uBAGrC;CAAG;;;;;;;;;;;;AAEN,qBAAa,cAAe,SAAQ,mBAIlC;CAAG;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAkChB;CAAG"}
+{"version":3,"file":"Auth.d.ts","sourceRoot":"","sources":["../../../src/api/Auth.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,YAAY,EACZ,iBAAiB,EAEjB,eAAe,EAChB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAKzC,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,eAAO,MAAM,OAAO,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;AAEzB,qBAAa,QAAS,SAAQ,aAK5B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAa/B;CAAG;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAEvC;CAAG;;;;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAErC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,sBAAuB,SAAQ,2BAiB1C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,oBAAqB,SAAQ,yBAiBxC;CAAG;;;;AAEL,qBAAa,YAAa,SAAQ,iBAIjC;CAAG;;AAEJ,qBAAa,kBAAmB,SAAQ,uBAGrC;CAAG;;;;;;;;;;;;AAEN,qBAAa,cAAe,SAAQ,mBAIlC;CAAG;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAsDhB;CAAG"}

package/dist/dts/api/Invite.d.ts

@@ -1,6 +1,6 @@
 import { HttpApiEndpoint, HttpApiGroup } from '@effect/platform';
 import { Schema } from 'effect';
-import { AuthMiddleware } from './Auth.js';
+import { AuthMiddleware } from '../api/Auth.js';
 declare const InviteInfo_base: Schema.Class<InviteInfo, {
     teamName: typeof Schema.String;
     teamId: Schema.brand<typeof Schema.String, "TeamId">;
@@ -10,28 +10,28 @@ declare const InviteInfo_base: Schema.Class<InviteInfo, {
     teamId: Schema.brand<typeof Schema.String, "TeamId">;
     code: typeof Schema.String;
 }>, never, {
-    readonly code: string;
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
 } & {
     readonly teamName: string;
 } & {
-    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly code: string;
 }, {}, {}>;
 export declare class InviteInfo extends InviteInfo_base {
 }
 declare const JoinResult_base: Schema.Class<JoinResult, {
     teamId: Schema.brand<typeof Schema.String, "TeamId">;
-    role: Schema.Literal<["admin", "member"]>;
+    roleNames: Schema.Array$<typeof Schema.String>;
     isProfileComplete: typeof Schema.Boolean;
 }, Schema.Struct.Encoded<{
     teamId: Schema.brand<typeof Schema.String, "TeamId">;
-    role: Schema.Literal<["admin", "member"]>;
+    roleNames: Schema.Array$<typeof Schema.String>;
     isProfileComplete: typeof Schema.Boolean;
 }>, never, {
-    readonly isProfileComplete: boolean;
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
 } & {
-    readonly role: "admin" | "member";
+    readonly roleNames: readonly string[];
 } & {
-    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly isProfileComplete: boolean;
 }, {}, {}>;
 export declare class JoinResult extends JoinResult_base {
 }
@@ -67,11 +67,11 @@ declare const InviteApiGroup_base: HttpApiGroup.HttpApiGroup<"invite", HttpApiEn
     readonly code: string;
 }, never, never, never, InviteInfo, InviteNotFound, never, never> | HttpApiEndpoint.HttpApiEndpoint<"joinViaInvite", "POST", {
     readonly code: string;
-}, never, never, never, JoinResult, import("./Auth.js").Unauthorized | InviteNotFound | AlreadyMember, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"regenerateInvite", "POST", {
+}, never, never, never, JoinResult, import("../api/Auth.js").Unauthorized | InviteNotFound | AlreadyMember, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"regenerateInvite", "POST", {
     readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
-}, never, never, never, InviteCode, import("./Auth.js").Unauthorized | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"disableInvite", "DELETE", {
+}, never, never, never, InviteCode, import("../api/Auth.js").Unauthorized | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"disableInvite", "DELETE", {
     readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
-}, never, never, never, void, import("./Auth.js").Unauthorized | Forbidden, AuthMiddleware, never>, never, never, false>;
+}, never, never, never, void, import("../api/Auth.js").Unauthorized | Forbidden, AuthMiddleware, never>, never, never, false>;
 export declare class InviteApiGroup extends InviteApiGroup_base {
 }
 export {};

package/dist/dts/api/Invite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Invite.d.ts","sourceRoot":"","sources":["../../../src/api/Invite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,YAAY,EAAiB,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;;;;;;;;;;;;;;;;AAE3C,qBAAa,UAAW,SAAQ,eAI9B;CAAG;;;;;;;;;;;;;;;;AAEL,qBAAa,UAAW,SAAQ,eAI9B;CAAG;;;;;;;;;;;;AAEL,qBAAa,UAAW,SAAQ,eAG9B;CAAG;;;;AAEL,qBAAa,cAAe,SAAQ,mBAInC;CAAG;;;;AAEJ,qBAAa,aAAc,SAAQ,kBAIlC;CAAG;;;;AAEJ,qBAAa,SAAU,SAAQ,cAI9B;CAAG;;;;;;;;;;AAEJ,qBAAa,cAAe,SAAQ,mBA4BjC;CAAG"}
+{"version":3,"file":"Invite.d.ts","sourceRoot":"","sources":["../../../src/api/Invite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,YAAY,EAAiB,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;AAG/C,qBAAa,UAAW,SAAQ,eAI9B;CAAG;;;;;;;;;;;;;;;;AAEL,qBAAa,UAAW,SAAQ,eAI9B;CAAG;;;;;;;;;;;;AAEL,qBAAa,UAAW,SAAQ,eAG9B;CAAG;;;;AAEL,qBAAa,cAAe,SAAQ,mBAInC;CAAG;;;;AAEJ,qBAAa,aAAc,SAAQ,kBAIlC;CAAG;;;;AAEJ,qBAAa,SAAU,SAAQ,cAI9B;CAAG;;;;;;;;;;AAEJ,qBAAa,cAAe,SAAQ,mBA4BjC;CAAG"}

package/dist/dts/api/NotificationApi.d.ts

@@ -0,0 +1,53 @@
+import { HttpApiEndpoint, HttpApiGroup } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '../api/Auth.js';
+declare const NotificationInfo_base: Schema.Class<NotificationInfo, {
+    notificationId: Schema.brand<typeof Schema.String, "NotificationId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    type: Schema.Literal<["age_role_assigned", "age_role_removed", "role_assigned", "role_removed"]>;
+    title: typeof Schema.String;
+    body: typeof Schema.String;
+    isRead: typeof Schema.Boolean;
+    createdAt: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    notificationId: Schema.brand<typeof Schema.String, "NotificationId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    type: Schema.Literal<["age_role_assigned", "age_role_removed", "role_assigned", "role_removed"]>;
+    title: typeof Schema.String;
+    body: typeof Schema.String;
+    isRead: typeof Schema.Boolean;
+    createdAt: typeof Schema.String;
+}>, never, {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+} & {
+    readonly type: "age_role_assigned" | "age_role_removed" | "role_assigned" | "role_removed";
+} & {
+    readonly title: string;
+} & {
+    readonly body: string;
+} & {
+    readonly notificationId: string & import("effect/Brand").Brand<"NotificationId">;
+} & {
+    readonly isRead: boolean;
+} & {
+    readonly createdAt: string;
+}, {}, {}>;
+export declare class NotificationInfo extends NotificationInfo_base {
+}
+declare const Forbidden_base: Schema.TaggedErrorClass<Forbidden, "NotificationForbidden", {
+    readonly _tag: Schema.tag<"NotificationForbidden">;
+}>;
+export declare class Forbidden extends Forbidden_base {
+}
+declare const NotificationNotFound_base: Schema.TaggedErrorClass<NotificationNotFound, "NotificationNotFound", {
+    readonly _tag: Schema.tag<"NotificationNotFound">;
+}>;
+export declare class NotificationNotFound extends NotificationNotFound_base {
+}
+declare const NotificationApiGroup_base: HttpApiGroup.HttpApiGroup<"notification", HttpApiEndpoint.HttpApiEndpoint<"listNotifications", "GET", never, never, never, never, readonly NotificationInfo[], import("../api/Auth.js").Unauthorized | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"markAsRead", "PATCH", {
+    readonly notificationId: string & import("effect/Brand").Brand<"NotificationId">;
+}, never, never, never, void, import("../api/Auth.js").Unauthorized | Forbidden | NotificationNotFound, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"markAllAsRead", "POST", never, never, never, never, void, import("../api/Auth.js").Unauthorized | Forbidden, AuthMiddleware, never>, never, never, false>;
+export declare class NotificationApiGroup extends NotificationApiGroup_base {
+}
+export {};
+//# sourceMappingURL=NotificationApi.d.ts.map

package/dist/dts/api/NotificationApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotificationApi.d.ts","sourceRoot":"","sources":["../../../src/api/NotificationApi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,YAAY,EAAiB,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAI/C,qBAAa,gBAAiB,SAAQ,qBAQpC;CAAG;;;;AAEL,qBAAa,SAAU,SAAQ,cAI9B;CAAG;;;;AAEJ,qBAAa,oBAAqB,SAAQ,yBAIzC;CAAG;;;;AAEJ,qBAAa,oBAAqB,SAAQ,yBAoBvC;CAAG"}

package/dist/dts/api/RoleApi.d.ts

@@ -0,0 +1,138 @@
+import { HttpApiEndpoint, HttpApiGroup } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '../api/Auth.js';
+declare const RoleInfo_base: Schema.Class<RoleInfo, {
+    roleId: Schema.brand<typeof Schema.String, "RoleId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    name: typeof Schema.String;
+    isBuiltIn: typeof Schema.Boolean;
+    permissionCount: typeof Schema.Number;
+}, Schema.Struct.Encoded<{
+    roleId: Schema.brand<typeof Schema.String, "RoleId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    name: typeof Schema.String;
+    isBuiltIn: typeof Schema.Boolean;
+    permissionCount: typeof Schema.Number;
+}>, never, {
+    readonly name: string;
+} & {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+} & {
+    readonly roleId: string & import("effect/Brand").Brand<"RoleId">;
+} & {
+    readonly isBuiltIn: boolean;
+} & {
+    readonly permissionCount: number;
+}, {}, {}>;
+export declare class RoleInfo extends RoleInfo_base {
+}
+declare const RoleDetail_base: Schema.Class<RoleDetail, {
+    roleId: Schema.brand<typeof Schema.String, "RoleId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    name: typeof Schema.String;
+    isBuiltIn: typeof Schema.Boolean;
+    permissions: Schema.Array$<Schema.Literal<["team:manage", "team:invite", "roster:view", "roster:manage", "member:view", "member:edit", "member:remove", "role:view", "role:manage"]>>;
+}, Schema.Struct.Encoded<{
+    roleId: Schema.brand<typeof Schema.String, "RoleId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    name: typeof Schema.String;
+    isBuiltIn: typeof Schema.Boolean;
+    permissions: Schema.Array$<Schema.Literal<["team:manage", "team:invite", "roster:view", "roster:manage", "member:view", "member:edit", "member:remove", "role:view", "role:manage"]>>;
+}>, never, {
+    readonly name: string;
+} & {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+} & {
+    readonly permissions: readonly ("team:manage" | "team:invite" | "roster:view" | "roster:manage" | "member:view" | "member:edit" | "member:remove" | "role:view" | "role:manage")[];
+} & {
+    readonly roleId: string & import("effect/Brand").Brand<"RoleId">;
+} & {
+    readonly isBuiltIn: boolean;
+}, {}, {}>;
+export declare class RoleDetail extends RoleDetail_base {
+}
+declare const CreateRoleRequest_base: Schema.Class<CreateRoleRequest, {
+    name: typeof Schema.NonEmptyString;
+    permissions: Schema.Array$<Schema.Literal<["team:manage", "team:invite", "roster:view", "roster:manage", "member:view", "member:edit", "member:remove", "role:view", "role:manage"]>>;
+}, Schema.Struct.Encoded<{
+    name: typeof Schema.NonEmptyString;
+    permissions: Schema.Array$<Schema.Literal<["team:manage", "team:invite", "roster:view", "roster:manage", "member:view", "member:edit", "member:remove", "role:view", "role:manage"]>>;
+}>, never, {
+    readonly name: string;
+} & {
+    readonly permissions: readonly ("team:manage" | "team:invite" | "roster:view" | "roster:manage" | "member:view" | "member:edit" | "member:remove" | "role:view" | "role:manage")[];
+}, {}, {}>;
+export declare class CreateRoleRequest extends CreateRoleRequest_base {
+}
+declare const UpdateRoleRequest_base: Schema.Class<UpdateRoleRequest, {
+    name: Schema.NullOr<typeof Schema.NonEmptyString>;
+    permissions: Schema.NullOr<Schema.Array$<Schema.Literal<["team:manage", "team:invite", "roster:view", "roster:manage", "member:view", "member:edit", "member:remove", "role:view", "role:manage"]>>>;
+}, Schema.Struct.Encoded<{
+    name: Schema.NullOr<typeof Schema.NonEmptyString>;
+    permissions: Schema.NullOr<Schema.Array$<Schema.Literal<["team:manage", "team:invite", "roster:view", "roster:manage", "member:view", "member:edit", "member:remove", "role:view", "role:manage"]>>>;
+}>, never, {
+    readonly name: string | null;
+} & {
+    readonly permissions: readonly ("team:manage" | "team:invite" | "roster:view" | "roster:manage" | "member:view" | "member:edit" | "member:remove" | "role:view" | "role:manage")[] | null;
+}, {}, {}>;
+export declare class UpdateRoleRequest extends UpdateRoleRequest_base {
+}
+declare const RoleNotFound_base: Schema.TaggedErrorClass<RoleNotFound, "RoleNotFound", {
+    readonly _tag: Schema.tag<"RoleNotFound">;
+}>;
+export declare class RoleNotFound extends RoleNotFound_base {
+}
+declare const Forbidden_base: Schema.TaggedErrorClass<Forbidden, "RoleForbidden", {
+    readonly _tag: Schema.tag<"RoleForbidden">;
+}>;
+export declare class Forbidden extends Forbidden_base {
+}
+declare const CannotModifyBuiltIn_base: Schema.TaggedErrorClass<CannotModifyBuiltIn, "CannotModifyBuiltIn", {
+    readonly _tag: Schema.tag<"CannotModifyBuiltIn">;
+}>;
+export declare class CannotModifyBuiltIn extends CannotModifyBuiltIn_base {
+}
+declare const AssignRoleRequest_base: Schema.Class<AssignRoleRequest, {
+    roleId: Schema.brand<typeof Schema.String, "RoleId">;
+}, Schema.Struct.Encoded<{
+    roleId: Schema.brand<typeof Schema.String, "RoleId">;
+}>, never, {
+    readonly roleId: string & import("effect/Brand").Brand<"RoleId">;
+}, {}, {}>;
+export declare class AssignRoleRequest extends AssignRoleRequest_base {
+}
+declare const MemberNotFound_base: Schema.TaggedErrorClass<MemberNotFound, "MemberNotFound", {
+    readonly _tag: Schema.tag<"MemberNotFound">;
+}>;
+export declare class MemberNotFound extends MemberNotFound_base {
+}
+declare const RoleInUse_base: Schema.TaggedErrorClass<RoleInUse, "RoleInUse", {
+    readonly _tag: Schema.tag<"RoleInUse">;
+}>;
+export declare class RoleInUse extends RoleInUse_base {
+}
+declare const RoleApiGroup_base: HttpApiGroup.HttpApiGroup<"role", HttpApiEndpoint.HttpApiEndpoint<"listRoles", "GET", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+}, never, never, never, readonly RoleInfo[], import("../api/Auth.js").Unauthorized | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"createRole", "POST", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+}, never, CreateRoleRequest, never, RoleDetail, import("../api/Auth.js").Unauthorized | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"getRole", "GET", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly roleId: string & import("effect/Brand").Brand<"RoleId">;
+}, never, never, never, RoleDetail, import("../api/Auth.js").Unauthorized | RoleNotFound | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"updateRole", "PATCH", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly roleId: string & import("effect/Brand").Brand<"RoleId">;
+}, never, UpdateRoleRequest, never, RoleDetail, import("../api/Auth.js").Unauthorized | RoleNotFound | Forbidden | CannotModifyBuiltIn, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"deleteRole", "DELETE", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly roleId: string & import("effect/Brand").Brand<"RoleId">;
+}, never, never, never, void, import("../api/Auth.js").Unauthorized | RoleNotFound | Forbidden | CannotModifyBuiltIn | RoleInUse, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"assignRole", "POST", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly memberId: string & import("effect/Brand").Brand<"TeamMemberId">;
+}, never, AssignRoleRequest, never, void, import("../api/Auth.js").Unauthorized | RoleNotFound | Forbidden | MemberNotFound, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"unassignRole", "DELETE", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly roleId: string & import("effect/Brand").Brand<"RoleId">;
+    readonly memberId: string & import("effect/Brand").Brand<"TeamMemberId">;
+}, never, never, never, void, import("../api/Auth.js").Unauthorized | RoleNotFound | Forbidden | MemberNotFound, AuthMiddleware, never>, never, never, false>;
+export declare class RoleApiGroup extends RoleApiGroup_base {
+}
+export {};
+//# sourceMappingURL=RoleApi.d.ts.map

package/dist/dts/api/RoleApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoleApi.d.ts","sourceRoot":"","sources":["../../../src/api/RoleApi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,YAAY,EAAiB,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AAK/C,qBAAa,QAAS,SAAQ,aAM5B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,UAAW,SAAQ,eAM9B;CAAG;;;;;;;;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAGrC;CAAG;;;;;;;;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAGrC;CAAG;;;;AAEL,qBAAa,YAAa,SAAQ,iBAIjC;CAAG;;;;AAEJ,qBAAa,SAAU,SAAQ,cAI9B;CAAG;;;;AAEJ,qBAAa,mBAAoB,SAAQ,wBAIxC;CAAG;;;;;;;;AAEJ,qBAAa,iBAAkB,SAAQ,sBAErC;CAAG;;;;AAEL,qBAAa,cAAe,SAAQ,mBAInC;CAAG;;;;AAEJ,qBAAa,SAAU,SAAQ,cAI9B;CAAG;;;;;;;;;;;;;;;;;;;;;;AAEJ,qBAAa,YAAa,SAAQ,iBA8D/B;CAAG"}

package/dist/dts/api/Roster.d.ts

@@ -0,0 +1,225 @@
+import { HttpApiEndpoint, HttpApiGroup } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '../api/Auth.js';
+declare const RosterPlayer_base: Schema.Class<RosterPlayer, {
+    memberId: Schema.brand<typeof Schema.String, "TeamMemberId">;
+    userId: Schema.brand<typeof Schema.String, "UserId">;
+    roleNames: Schema.Array$<typeof Schema.String>;
+    permissions: Schema.Array$<Schema.Literal<["team:manage", "team:invite", "roster:view", "roster:manage", "member:view", "member:edit", "member:remove", "role:view", "role:manage"]>>;
+    name: Schema.NullOr<typeof Schema.String>;
+    birthYear: Schema.NullOr<typeof Schema.Number>;
+    gender: Schema.NullOr<Schema.Literal<["male", "female", "other"]>>;
+    jerseyNumber: Schema.NullOr<typeof Schema.Number>;
+    position: Schema.NullOr<Schema.Literal<["goalkeeper", "defender", "midfielder", "forward"]>>;
+    proficiency: Schema.NullOr<Schema.Literal<["beginner", "intermediate", "advanced", "pro"]>>;
+    discordUsername: typeof Schema.String;
+    discordAvatar: Schema.NullOr<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    memberId: Schema.brand<typeof Schema.String, "TeamMemberId">;
+    userId: Schema.brand<typeof Schema.String, "UserId">;
+    roleNames: Schema.Array$<typeof Schema.String>;
+    permissions: Schema.Array$<Schema.Literal<["team:manage", "team:invite", "roster:view", "roster:manage", "member:view", "member:edit", "member:remove", "role:view", "role:manage"]>>;
+    name: Schema.NullOr<typeof Schema.String>;
+    birthYear: Schema.NullOr<typeof Schema.Number>;
+    gender: Schema.NullOr<Schema.Literal<["male", "female", "other"]>>;
+    jerseyNumber: Schema.NullOr<typeof Schema.Number>;
+    position: Schema.NullOr<Schema.Literal<["goalkeeper", "defender", "midfielder", "forward"]>>;
+    proficiency: Schema.NullOr<Schema.Literal<["beginner", "intermediate", "advanced", "pro"]>>;
+    discordUsername: typeof Schema.String;
+    discordAvatar: Schema.NullOr<typeof Schema.String>;
+}>, never, {
+    readonly name: string | null;
+} & {
+    readonly gender: "male" | "female" | "other" | null;
+} & {
+    readonly position: "goalkeeper" | "defender" | "midfielder" | "forward" | null;
+} & {
+    readonly proficiency: "beginner" | "intermediate" | "advanced" | "pro" | null;
+} & {
+    readonly roleNames: readonly string[];
+} & {
+    readonly permissions: readonly ("team:manage" | "team:invite" | "roster:view" | "roster:manage" | "member:view" | "member:edit" | "member:remove" | "role:view" | "role:manage")[];
+} & {
+    readonly discordUsername: string;
+} & {
+    readonly discordAvatar: string | null;
+} & {
+    readonly birthYear: number | null;
+} & {
+    readonly jerseyNumber: number | null;
+} & {
+    readonly memberId: string & import("effect/Brand").Brand<"TeamMemberId">;
+} & {
+    readonly userId: string & import("effect/Brand").Brand<"UserId">;
+}, {}, {}>;
+export declare class RosterPlayer extends RosterPlayer_base {
+}
+declare const UpdatePlayerRequest_base: Schema.Class<UpdatePlayerRequest, {
+    name: Schema.NullOr<typeof Schema.String>;
+    birthYear: Schema.NullOr<typeof Schema.Number>;
+    gender: Schema.NullOr<Schema.Literal<["male", "female", "other"]>>;
+    jerseyNumber: Schema.NullOr<typeof Schema.Number>;
+    position: Schema.NullOr<Schema.Literal<["goalkeeper", "defender", "midfielder", "forward"]>>;
+    proficiency: Schema.NullOr<Schema.Literal<["beginner", "intermediate", "advanced", "pro"]>>;
+}, Schema.Struct.Encoded<{
+    name: Schema.NullOr<typeof Schema.String>;
+    birthYear: Schema.NullOr<typeof Schema.Number>;
+    gender: Schema.NullOr<Schema.Literal<["male", "female", "other"]>>;
+    jerseyNumber: Schema.NullOr<typeof Schema.Number>;
+    position: Schema.NullOr<Schema.Literal<["goalkeeper", "defender", "midfielder", "forward"]>>;
+    proficiency: Schema.NullOr<Schema.Literal<["beginner", "intermediate", "advanced", "pro"]>>;
+}>, never, {
+    readonly name: string | null;
+} & {
+    readonly gender: "male" | "female" | "other" | null;
+} & {
+    readonly position: "goalkeeper" | "defender" | "midfielder" | "forward" | null;
+} & {
+    readonly proficiency: "beginner" | "intermediate" | "advanced" | "pro" | null;
+} & {
+    readonly birthYear: number | null;
+} & {
+    readonly jerseyNumber: number | null;
+}, {}, {}>;
+export declare class UpdatePlayerRequest extends UpdatePlayerRequest_base {
+}
+declare const PlayerNotFound_base: Schema.TaggedErrorClass<PlayerNotFound, "PlayerNotFound", {
+    readonly _tag: Schema.tag<"PlayerNotFound">;
+}>;
+export declare class PlayerNotFound extends PlayerNotFound_base {
+}
+declare const Forbidden_base: Schema.TaggedErrorClass<Forbidden, "Forbidden", {
+    readonly _tag: Schema.tag<"Forbidden">;
+}>;
+export declare class Forbidden extends Forbidden_base {
+}
+declare const RosterNotFound_base: Schema.TaggedErrorClass<RosterNotFound, "RosterNotFound", {
+    readonly _tag: Schema.tag<"RosterNotFound">;
+}>;
+export declare class RosterNotFound extends RosterNotFound_base {
+}
+declare const RosterInfo_base: Schema.Class<RosterInfo, {
+    rosterId: Schema.brand<typeof Schema.String, "RosterId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    name: typeof Schema.String;
+    active: typeof Schema.Boolean;
+    memberCount: typeof Schema.Number;
+    createdAt: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    rosterId: Schema.brand<typeof Schema.String, "RosterId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    name: typeof Schema.String;
+    active: typeof Schema.Boolean;
+    memberCount: typeof Schema.Number;
+    createdAt: typeof Schema.String;
+}>, never, {
+    readonly name: string;
+} & {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+} & {
+    readonly active: boolean;
+} & {
+    readonly createdAt: string;
+} & {
+    readonly rosterId: string & import("effect/Brand").Brand<"RosterId">;
+} & {
+    readonly memberCount: number;
+}, {}, {}>;
+export declare class RosterInfo extends RosterInfo_base {
+}
+declare const RosterDetail_base: Schema.Class<RosterDetail, {
+    rosterId: Schema.brand<typeof Schema.String, "RosterId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    name: typeof Schema.String;
+    active: typeof Schema.Boolean;
+    createdAt: typeof Schema.String;
+    members: Schema.Array$<typeof RosterPlayer>;
+}, Schema.Struct.Encoded<{
+    rosterId: Schema.brand<typeof Schema.String, "RosterId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    name: typeof Schema.String;
+    active: typeof Schema.Boolean;
+    createdAt: typeof Schema.String;
+    members: Schema.Array$<typeof RosterPlayer>;
+}>, never, {
+    readonly name: string;
+} & {
+    readonly members: readonly RosterPlayer[];
+} & {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+} & {
+    readonly active: boolean;
+} & {
+    readonly createdAt: string;
+} & {
+    readonly rosterId: string & import("effect/Brand").Brand<"RosterId">;
+}, {}, {}>;
+export declare class RosterDetail extends RosterDetail_base {
+}
+declare const CreateRosterRequest_base: Schema.Class<CreateRosterRequest, {
+    name: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    name: typeof Schema.String;
+}>, never, {
+    readonly name: string;
+}, {}, {}>;
+export declare class CreateRosterRequest extends CreateRosterRequest_base {
+}
+declare const UpdateRosterRequest_base: Schema.Class<UpdateRosterRequest, {
+    name: Schema.NullOr<typeof Schema.String>;
+    active: Schema.NullOr<typeof Schema.Boolean>;
+}, Schema.Struct.Encoded<{
+    name: Schema.NullOr<typeof Schema.String>;
+    active: Schema.NullOr<typeof Schema.Boolean>;
+}>, never, {
+    readonly name: string | null;
+} & {
+    readonly active: boolean | null;
+}, {}, {}>;
+export declare class UpdateRosterRequest extends UpdateRosterRequest_base {
+}
+declare const AddRosterMemberRequest_base: Schema.Class<AddRosterMemberRequest, {
+    memberId: Schema.brand<typeof Schema.String, "TeamMemberId">;
+}, Schema.Struct.Encoded<{
+    memberId: Schema.brand<typeof Schema.String, "TeamMemberId">;
+}>, never, {
+    readonly memberId: string & import("effect/Brand").Brand<"TeamMemberId">;
+}, {}, {}>;
+export declare class AddRosterMemberRequest extends AddRosterMemberRequest_base {
+}
+declare const RosterApiGroup_base: HttpApiGroup.HttpApiGroup<"roster", HttpApiEndpoint.HttpApiEndpoint<"listMembers", "GET", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+}, never, never, never, readonly RosterPlayer[], import("../api/Auth.js").Unauthorized | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"getMember", "GET", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly memberId: string & import("effect/Brand").Brand<"TeamMemberId">;
+}, never, never, never, RosterPlayer, import("../api/Auth.js").Unauthorized | PlayerNotFound | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"updateMember", "PATCH", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly memberId: string & import("effect/Brand").Brand<"TeamMemberId">;
+}, never, UpdatePlayerRequest, never, RosterPlayer, import("../api/Auth.js").Unauthorized | PlayerNotFound | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"deactivateMember", "DELETE", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly memberId: string & import("effect/Brand").Brand<"TeamMemberId">;
+}, never, never, never, void, import("../api/Auth.js").Unauthorized | PlayerNotFound | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"listRosters", "GET", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+}, never, never, never, readonly RosterInfo[], import("../api/Auth.js").Unauthorized | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"createRoster", "POST", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+}, never, CreateRosterRequest, never, RosterInfo, import("../api/Auth.js").Unauthorized | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"getRoster", "GET", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly rosterId: string & import("effect/Brand").Brand<"RosterId">;
+}, never, never, never, RosterDetail, import("../api/Auth.js").Unauthorized | Forbidden | RosterNotFound, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"updateRoster", "PATCH", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly rosterId: string & import("effect/Brand").Brand<"RosterId">;
+}, never, UpdateRosterRequest, never, RosterInfo, import("../api/Auth.js").Unauthorized | Forbidden | RosterNotFound, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"deleteRoster", "DELETE", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly rosterId: string & import("effect/Brand").Brand<"RosterId">;
+}, never, never, never, void, import("../api/Auth.js").Unauthorized | Forbidden | RosterNotFound, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"addRosterMember", "POST", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly rosterId: string & import("effect/Brand").Brand<"RosterId">;
+}, never, AddRosterMemberRequest, never, void, import("../api/Auth.js").Unauthorized | PlayerNotFound | Forbidden | RosterNotFound, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"removeRosterMember", "DELETE", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly memberId: string & import("effect/Brand").Brand<"TeamMemberId">;
+    readonly rosterId: string & import("effect/Brand").Brand<"RosterId">;
+}, never, never, never, void, import("../api/Auth.js").Unauthorized | PlayerNotFound | Forbidden | RosterNotFound, AuthMiddleware, never>, never, never, false>;
+export declare class RosterApiGroup extends RosterApiGroup_base {
+}
+export {};
+//# sourceMappingURL=Roster.d.ts.map

package/dist/dts/api/Roster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Roster.d.ts","sourceRoot":"","sources":["../../../src/api/Roster.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,YAAY,EAAiB,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAO/C,qBAAa,YAAa,SAAQ,iBAahC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAOvC;CAAG;;;;AAEL,qBAAa,cAAe,SAAQ,mBAInC;CAAG;;;;AAEJ,qBAAa,SAAU,SAAQ,cAI9B;CAAG;;;;AAEJ,qBAAa,cAAe,SAAQ,mBAInC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEJ,qBAAa,UAAW,SAAQ,eAO9B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAOhC;CAAG;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAEvC;CAAG;;;;;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAGvC;CAAG;;;;;;;;AAEL,qBAAa,sBAAuB,SAAQ,2BAI1C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,cAAe,SAAQ,mBA2FjC;CAAG"}