@sideline/domain 0.4.0 → 0.6.0

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;AAKzC,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,eAAO,MAAM,OAAO,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;AAEzB,qBAAa,QAAS,SAAQ,aAK5B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAU/B;CAAG;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAEvC;CAAG;;;;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAErC;CAAG;;;;;;;;;;;;;;;;AAEL,qBAAa,sBAAuB,SAAQ,2BAY1C;CAAG;;;;;;;;;;;;;;;;AAEL,qBAAa,oBAAqB,SAAQ,yBAcxC;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"}
+{"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;AAMzC,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,eAAO,MAAM,OAAO,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;AAEzB,qBAAa,QAAS,SAAQ,aAK5B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAU/B;CAAG;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAEvC;CAAG;;;;;;;;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAGrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAMhC;CAAG;;;;;;;;;;;;;;;;AAEL,qBAAa,sBAAuB,SAAQ,2BAgB1C;CAAG;;;;;;;;;;;;;;;;AAEL,qBAAa,oBAAqB,SAAQ,yBAkBxC;CAAG;;;;AAEL,qBAAa,YAAa,SAAQ,iBAIjC;CAAG;;AAEJ,qBAAa,kBAAmB,SAAQ,uBAGrC;CAAG;;;;;;;;;;;;AAEN,qBAAa,cAAe,SAAQ,mBAIlC;CAAG;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBA4DhB;CAAG"}

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

@@ -0,0 +1,273 @@
+import { HttpApiEndpoint, HttpApiGroup } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '../api/Auth.js';
+declare const EventInfo_base: Schema.Class<EventInfo, {
+    eventId: Schema.brand<typeof Schema.String, "EventId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    title: typeof Schema.String;
+    eventType: Schema.Literal<["training", "match", "tournament", "meeting", "social", "other"]>;
+    trainingTypeName: Schema.NullOr<typeof Schema.String>;
+    startAt: typeof Schema.String;
+    endAt: Schema.NullOr<typeof Schema.String>;
+    location: Schema.NullOr<typeof Schema.String>;
+    status: Schema.Literal<["active", "cancelled"]>;
+    seriesId: Schema.NullOr<Schema.brand<typeof Schema.String, "EventSeriesId">>;
+}, Schema.Struct.Encoded<{
+    eventId: Schema.brand<typeof Schema.String, "EventId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    title: typeof Schema.String;
+    eventType: Schema.Literal<["training", "match", "tournament", "meeting", "social", "other"]>;
+    trainingTypeName: Schema.NullOr<typeof Schema.String>;
+    startAt: typeof Schema.String;
+    endAt: Schema.NullOr<typeof Schema.String>;
+    location: Schema.NullOr<typeof Schema.String>;
+    status: Schema.Literal<["active", "cancelled"]>;
+    seriesId: Schema.NullOr<Schema.brand<typeof Schema.String, "EventSeriesId">>;
+}>, never, {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+} & {
+    readonly status: "active" | "cancelled";
+} & {
+    readonly location: string | null;
+} & {
+    readonly title: string;
+} & {
+    readonly eventId: string & import("effect/Brand").Brand<"EventId">;
+} & {
+    readonly eventType: "other" | "training" | "match" | "tournament" | "meeting" | "social";
+} & {
+    readonly startAt: string;
+} & {
+    readonly trainingTypeName: string | null;
+} & {
+    readonly endAt: string | null;
+} & {
+    readonly seriesId: (string & import("effect/Brand").Brand<"EventSeriesId">) | null;
+}, {}, {}>;
+export declare class EventInfo extends EventInfo_base {
+}
+declare const EventDetail_base: Schema.Class<EventDetail, {
+    eventId: Schema.brand<typeof Schema.String, "EventId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    title: typeof Schema.String;
+    eventType: Schema.Literal<["training", "match", "tournament", "meeting", "social", "other"]>;
+    trainingTypeId: Schema.NullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>;
+    trainingTypeName: Schema.NullOr<typeof Schema.String>;
+    description: Schema.NullOr<typeof Schema.String>;
+    startAt: typeof Schema.String;
+    endAt: Schema.NullOr<typeof Schema.String>;
+    location: Schema.NullOr<typeof Schema.String>;
+    status: Schema.Literal<["active", "cancelled"]>;
+    createdByName: Schema.NullOr<typeof Schema.String>;
+    canEdit: typeof Schema.Boolean;
+    canCancel: typeof Schema.Boolean;
+    seriesId: Schema.NullOr<Schema.brand<typeof Schema.String, "EventSeriesId">>;
+    seriesModified: typeof Schema.Boolean;
+    discordChannelId: Schema.NullOr<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    eventId: Schema.brand<typeof Schema.String, "EventId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    title: typeof Schema.String;
+    eventType: Schema.Literal<["training", "match", "tournament", "meeting", "social", "other"]>;
+    trainingTypeId: Schema.NullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>;
+    trainingTypeName: Schema.NullOr<typeof Schema.String>;
+    description: Schema.NullOr<typeof Schema.String>;
+    startAt: typeof Schema.String;
+    endAt: Schema.NullOr<typeof Schema.String>;
+    location: Schema.NullOr<typeof Schema.String>;
+    status: Schema.Literal<["active", "cancelled"]>;
+    createdByName: Schema.NullOr<typeof Schema.String>;
+    canEdit: typeof Schema.Boolean;
+    canCancel: typeof Schema.Boolean;
+    seriesId: Schema.NullOr<Schema.brand<typeof Schema.String, "EventSeriesId">>;
+    seriesModified: typeof Schema.Boolean;
+    discordChannelId: Schema.NullOr<typeof Schema.String>;
+}>, never, {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+} & {
+    readonly status: "active" | "cancelled";
+} & {
+    readonly description: string | null;
+} & {
+    readonly location: string | null;
+} & {
+    readonly title: string;
+} & {
+    readonly eventId: string & import("effect/Brand").Brand<"EventId">;
+} & {
+    readonly eventType: "other" | "training" | "match" | "tournament" | "meeting" | "social";
+} & {
+    readonly startAt: string;
+} & {
+    readonly trainingTypeName: string | null;
+} & {
+    readonly endAt: string | null;
+} & {
+    readonly seriesId: (string & import("effect/Brand").Brand<"EventSeriesId">) | null;
+} & {
+    readonly canEdit: boolean;
+} & {
+    readonly canCancel: boolean;
+} & {
+    readonly seriesModified: boolean;
+} & {
+    readonly trainingTypeId: (string & import("effect/Brand").Brand<"TrainingTypeId">) | null;
+} & {
+    readonly createdByName: string | null;
+} & {
+    readonly discordChannelId: string | null;
+}, {}, {}>;
+export declare class EventDetail extends EventDetail_base {
+}
+declare const EventListResponse_base: Schema.Class<EventListResponse, {
+    canCreate: typeof Schema.Boolean;
+    events: Schema.Array$<typeof EventInfo>;
+}, Schema.Struct.Encoded<{
+    canCreate: typeof Schema.Boolean;
+    events: Schema.Array$<typeof EventInfo>;
+}>, never, {
+    readonly canCreate: boolean;
+} & {
+    readonly events: readonly EventInfo[];
+}, {}, {}>;
+export declare class EventListResponse extends EventListResponse_base {
+}
+declare const CreateEventRequest_base: Schema.Class<CreateEventRequest, {
+    title: typeof Schema.NonEmptyString;
+    eventType: Schema.Literal<["training", "match", "tournament", "meeting", "social", "other"]>;
+    trainingTypeId: Schema.NullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>;
+    description: Schema.NullOr<typeof Schema.String>;
+    startAt: typeof Schema.String;
+    endAt: Schema.NullOr<typeof Schema.String>;
+    location: Schema.NullOr<typeof Schema.String>;
+    discordChannelId: Schema.NullOr<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    title: typeof Schema.NonEmptyString;
+    eventType: Schema.Literal<["training", "match", "tournament", "meeting", "social", "other"]>;
+    trainingTypeId: Schema.NullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>;
+    description: Schema.NullOr<typeof Schema.String>;
+    startAt: typeof Schema.String;
+    endAt: Schema.NullOr<typeof Schema.String>;
+    location: Schema.NullOr<typeof Schema.String>;
+    discordChannelId: Schema.NullOr<typeof Schema.String>;
+}>, never, {
+    readonly description: string | null;
+} & {
+    readonly location: string | null;
+} & {
+    readonly title: string;
+} & {
+    readonly eventType: "other" | "training" | "match" | "tournament" | "meeting" | "social";
+} & {
+    readonly startAt: string;
+} & {
+    readonly endAt: string | null;
+} & {
+    readonly trainingTypeId: (string & import("effect/Brand").Brand<"TrainingTypeId">) | null;
+} & {
+    readonly discordChannelId: string | null;
+}, {}, {}>;
+export declare class CreateEventRequest extends CreateEventRequest_base {
+}
+declare const UpdateEventRequest_base: Schema.Class<UpdateEventRequest, {
+    title: Schema.optionalWith<typeof Schema.NonEmptyString, {
+        as: "Option";
+    }>;
+    eventType: Schema.optionalWith<Schema.Literal<["training", "match", "tournament", "meeting", "social", "other"]>, {
+        as: "Option";
+    }>;
+    trainingTypeId: Schema.optionalWith<Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>, {
+        as: "Option";
+    }>;
+    description: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+    startAt: Schema.optionalWith<typeof Schema.String, {
+        as: "Option";
+    }>;
+    endAt: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+    location: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+    discordChannelId: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+}, Schema.Struct.Encoded<{
+    title: Schema.optionalWith<typeof Schema.NonEmptyString, {
+        as: "Option";
+    }>;
+    eventType: Schema.optionalWith<Schema.Literal<["training", "match", "tournament", "meeting", "social", "other"]>, {
+        as: "Option";
+    }>;
+    trainingTypeId: Schema.optionalWith<Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>, {
+        as: "Option";
+    }>;
+    description: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+    startAt: Schema.optionalWith<typeof Schema.String, {
+        as: "Option";
+    }>;
+    endAt: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+    location: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+    discordChannelId: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+}>, never, {
+    readonly description: import("effect/Option").Option<import("effect/Option").Option<string>>;
+} & {
+    readonly location: import("effect/Option").Option<import("effect/Option").Option<string>>;
+} & {
+    readonly title: import("effect/Option").Option<string>;
+} & {
+    readonly eventType: import("effect/Option").Option<"other" | "training" | "match" | "tournament" | "meeting" | "social">;
+} & {
+    readonly startAt: import("effect/Option").Option<string>;
+} & {
+    readonly endAt: import("effect/Option").Option<import("effect/Option").Option<string>>;
+} & {
+    readonly trainingTypeId: import("effect/Option").Option<import("effect/Option").Option<string & import("effect/Brand").Brand<"TrainingTypeId">>>;
+} & {
+    readonly discordChannelId: import("effect/Option").Option<import("effect/Option").Option<string>>;
+}, {}, {}>;
+export declare class UpdateEventRequest extends UpdateEventRequest_base {
+}
+declare const EventNotFound_base: Schema.TaggedErrorClass<EventNotFound, "EventNotFound", {
+    readonly _tag: Schema.tag<"EventNotFound">;
+}>;
+export declare class EventNotFound extends EventNotFound_base {
+}
+declare const Forbidden_base: Schema.TaggedErrorClass<Forbidden, "EventForbidden", {
+    readonly _tag: Schema.tag<"EventForbidden">;
+}>;
+export declare class Forbidden extends Forbidden_base {
+}
+declare const EventCancelled_base: Schema.TaggedErrorClass<EventCancelled, "EventCancelled", {
+    readonly _tag: Schema.tag<"EventCancelled">;
+}>;
+export declare class EventCancelled extends EventCancelled_base {
+}
+declare const EventApiGroup_base: HttpApiGroup.HttpApiGroup<"event", HttpApiEndpoint.HttpApiEndpoint<"listEvents", "GET", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+}, never, never, never, EventListResponse, import("../api/Auth.js").Unauthorized | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"createEvent", "POST", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+}, never, CreateEventRequest, never, EventInfo, import("../api/Auth.js").Unauthorized | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"getEvent", "GET", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly eventId: string & import("effect/Brand").Brand<"EventId">;
+}, never, never, never, EventDetail, import("../api/Auth.js").Unauthorized | EventNotFound | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"updateEvent", "PATCH", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly eventId: string & import("effect/Brand").Brand<"EventId">;
+}, never, UpdateEventRequest, never, EventDetail, import("../api/Auth.js").Unauthorized | EventNotFound | Forbidden | EventCancelled, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"cancelEvent", "POST", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly eventId: string & import("effect/Brand").Brand<"EventId">;
+}, never, never, never, void, import("../api/Auth.js").Unauthorized | EventNotFound | Forbidden | EventCancelled, AuthMiddleware, never>, never, never, false>;
+export declare class EventApiGroup extends EventApiGroup_base {
+}
+export {};
+//# sourceMappingURL=EventApi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EventApi.d.ts","sourceRoot":"","sources":["../../../src/api/EventApi.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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAM/C,qBAAa,SAAU,SAAQ,cAW7B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAkB/B;CAAG;;;;;;;;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAGrC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,kBAAmB,SAAQ,uBAStC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,kBAAmB,SAAQ,uBAStC;CAAG;;;;AAEL,qBAAa,aAAc,SAAQ,kBAIlC;CAAG;;;;AAEJ,qBAAa,SAAU,SAAQ,cAI9B;CAAG;;;;AAEJ,qBAAa,cAAe,SAAQ,mBAInC;CAAG;;;;;;;;;;;;;;;AAEJ,qBAAa,aAAc,SAAQ,kBA0ChC;CAAG"}

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

@@ -0,0 +1,96 @@
+import { HttpApiEndpoint, HttpApiGroup } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '../api/Auth.js';
+declare const RsvpEntry_base: Schema.Class<RsvpEntry, {
+    teamMemberId: Schema.brand<typeof Schema.String, "TeamMemberId">;
+    memberName: Schema.NullOr<typeof Schema.String>;
+    response: Schema.Literal<["yes", "no", "maybe"]>;
+    message: Schema.NullOr<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    teamMemberId: Schema.brand<typeof Schema.String, "TeamMemberId">;
+    memberName: Schema.NullOr<typeof Schema.String>;
+    response: Schema.Literal<["yes", "no", "maybe"]>;
+    message: Schema.NullOr<typeof Schema.String>;
+}>, never, {
+    readonly memberName: string | null;
+} & {
+    readonly message: string | null;
+} & {
+    readonly response: "yes" | "no" | "maybe";
+} & {
+    readonly teamMemberId: string & import("effect/Brand").Brand<"TeamMemberId">;
+}, {}, {}>;
+export declare class RsvpEntry extends RsvpEntry_base {
+}
+declare const EventRsvpDetail_base: Schema.Class<EventRsvpDetail, {
+    myResponse: Schema.NullOr<Schema.Literal<["yes", "no", "maybe"]>>;
+    myMessage: Schema.NullOr<typeof Schema.String>;
+    rsvps: Schema.Array$<typeof RsvpEntry>;
+    yesCount: typeof Schema.Number;
+    noCount: typeof Schema.Number;
+    maybeCount: typeof Schema.Number;
+    canRsvp: typeof Schema.Boolean;
+}, Schema.Struct.Encoded<{
+    myResponse: Schema.NullOr<Schema.Literal<["yes", "no", "maybe"]>>;
+    myMessage: Schema.NullOr<typeof Schema.String>;
+    rsvps: Schema.Array$<typeof RsvpEntry>;
+    yesCount: typeof Schema.Number;
+    noCount: typeof Schema.Number;
+    maybeCount: typeof Schema.Number;
+    canRsvp: typeof Schema.Boolean;
+}>, never, {
+    readonly yesCount: number;
+} & {
+    readonly noCount: number;
+} & {
+    readonly maybeCount: number;
+} & {
+    readonly canRsvp: boolean;
+} & {
+    readonly myResponse: "yes" | "no" | "maybe" | null;
+} & {
+    readonly myMessage: string | null;
+} & {
+    readonly rsvps: readonly RsvpEntry[];
+}, {}, {}>;
+export declare class EventRsvpDetail extends EventRsvpDetail_base {
+}
+declare const SubmitRsvpRequest_base: Schema.Class<SubmitRsvpRequest, {
+    response: Schema.Literal<["yes", "no", "maybe"]>;
+    message: Schema.NullOr<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    response: Schema.Literal<["yes", "no", "maybe"]>;
+    message: Schema.NullOr<typeof Schema.String>;
+}>, never, {
+    readonly message: string | null;
+} & {
+    readonly response: "yes" | "no" | "maybe";
+}, {}, {}>;
+export declare class SubmitRsvpRequest extends SubmitRsvpRequest_base {
+}
+declare const EventNotFound_base: Schema.TaggedErrorClass<EventNotFound, "EventRsvpEventNotFound", {
+    readonly _tag: Schema.tag<"EventRsvpEventNotFound">;
+}>;
+export declare class EventNotFound extends EventNotFound_base {
+}
+declare const Forbidden_base: Schema.TaggedErrorClass<Forbidden, "EventRsvpForbidden", {
+    readonly _tag: Schema.tag<"EventRsvpForbidden">;
+}>;
+export declare class Forbidden extends Forbidden_base {
+}
+declare const RsvpDeadlinePassed_base: Schema.TaggedErrorClass<RsvpDeadlinePassed, "RsvpDeadlinePassed", {
+    readonly _tag: Schema.tag<"RsvpDeadlinePassed">;
+}>;
+export declare class RsvpDeadlinePassed extends RsvpDeadlinePassed_base {
+}
+declare const EventRsvpApiGroup_base: HttpApiGroup.HttpApiGroup<"eventRsvp", HttpApiEndpoint.HttpApiEndpoint<"getRsvps", "GET", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly eventId: string & import("effect/Brand").Brand<"EventId">;
+}, never, never, never, EventRsvpDetail, import("../api/Auth.js").Unauthorized | EventNotFound | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"submitRsvp", "PUT", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly eventId: string & import("effect/Brand").Brand<"EventId">;
+}, never, SubmitRsvpRequest, never, EventRsvpDetail, import("../api/Auth.js").Unauthorized | EventNotFound | Forbidden | RsvpDeadlinePassed, AuthMiddleware, never>, never, never, false>;
+export declare class EventRsvpApiGroup extends EventRsvpApiGroup_base {
+}
+export {};
+//# sourceMappingURL=EventRsvpApi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EventRsvpApi.d.ts","sourceRoot":"","sources":["../../../src/api/EventRsvpApi.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;;;;;;;;;;;;;;;;;;;;AAM/C,qBAAa,SAAU,SAAQ,cAK7B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,eAAgB,SAAQ,oBAQnC;CAAG;;;;;;;;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAGrC;CAAG;;;;AAEL,qBAAa,aAAc,SAAQ,kBAIlC;CAAG;;;;AAEJ,qBAAa,SAAU,SAAQ,cAI9B;CAAG;;;;AAEJ,qBAAa,kBAAmB,SAAQ,uBAIvC;CAAG;;;;;;;;AAEJ,qBAAa,iBAAkB,SAAQ,sBAkBpC;CAAG"}

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

@@ -0,0 +1,284 @@
+import { HttpApiEndpoint, HttpApiGroup } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '../api/Auth.js';
+import { Forbidden } from '../api/EventApi.js';
+declare const EventSeriesInfo_base: Schema.Class<EventSeriesInfo, {
+    seriesId: Schema.brand<typeof Schema.String, "EventSeriesId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    title: typeof Schema.String;
+    frequency: Schema.Literal<["weekly", "biweekly"]>;
+    dayOfWeek: Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">;
+    startDate: typeof Schema.String;
+    endDate: Schema.NullOr<typeof Schema.String>;
+    status: Schema.Literal<["active", "cancelled"]>;
+    trainingTypeId: Schema.NullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>;
+    trainingTypeName: Schema.NullOr<typeof Schema.String>;
+    startTime: typeof Schema.String;
+    endTime: Schema.NullOr<typeof Schema.String>;
+    location: Schema.NullOr<typeof Schema.String>;
+    discordChannelId: Schema.NullOr<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    seriesId: Schema.brand<typeof Schema.String, "EventSeriesId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    title: typeof Schema.String;
+    frequency: Schema.Literal<["weekly", "biweekly"]>;
+    dayOfWeek: Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">;
+    startDate: typeof Schema.String;
+    endDate: Schema.NullOr<typeof Schema.String>;
+    status: Schema.Literal<["active", "cancelled"]>;
+    trainingTypeId: Schema.NullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>;
+    trainingTypeName: Schema.NullOr<typeof Schema.String>;
+    startTime: typeof Schema.String;
+    endTime: Schema.NullOr<typeof Schema.String>;
+    location: Schema.NullOr<typeof Schema.String>;
+    discordChannelId: Schema.NullOr<typeof Schema.String>;
+}>, never, {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+} & {
+    readonly status: "active" | "cancelled";
+} & {
+    readonly location: string | null;
+} & {
+    readonly title: string;
+} & {
+    readonly frequency: "weekly" | "biweekly";
+} & {
+    readonly trainingTypeName: string | null;
+} & {
+    readonly seriesId: string & import("effect/Brand").Brand<"EventSeriesId">;
+} & {
+    readonly trainingTypeId: (string & import("effect/Brand").Brand<"TrainingTypeId">) | null;
+} & {
+    readonly discordChannelId: string | null;
+} & {
+    readonly dayOfWeek: number & import("effect/Brand").Brand<"DayOfWeek">;
+} & {
+    readonly startDate: string;
+} & {
+    readonly startTime: string;
+} & {
+    readonly endDate: string | null;
+} & {
+    readonly endTime: string | null;
+}, {}, {}>;
+export declare class EventSeriesInfo extends EventSeriesInfo_base {
+}
+declare const EventSeriesDetail_base: Schema.Class<EventSeriesDetail, {
+    seriesId: Schema.brand<typeof Schema.String, "EventSeriesId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    title: typeof Schema.String;
+    description: Schema.NullOr<typeof Schema.String>;
+    frequency: Schema.Literal<["weekly", "biweekly"]>;
+    dayOfWeek: Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">;
+    startDate: typeof Schema.String;
+    endDate: Schema.NullOr<typeof Schema.String>;
+    status: Schema.Literal<["active", "cancelled"]>;
+    trainingTypeId: Schema.NullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>;
+    trainingTypeName: Schema.NullOr<typeof Schema.String>;
+    startTime: typeof Schema.String;
+    endTime: Schema.NullOr<typeof Schema.String>;
+    location: Schema.NullOr<typeof Schema.String>;
+    discordChannelId: Schema.NullOr<typeof Schema.String>;
+    canEdit: typeof Schema.Boolean;
+    canCancel: typeof Schema.Boolean;
+}, Schema.Struct.Encoded<{
+    seriesId: Schema.brand<typeof Schema.String, "EventSeriesId">;
+    teamId: Schema.brand<typeof Schema.String, "TeamId">;
+    title: typeof Schema.String;
+    description: Schema.NullOr<typeof Schema.String>;
+    frequency: Schema.Literal<["weekly", "biweekly"]>;
+    dayOfWeek: Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">;
+    startDate: typeof Schema.String;
+    endDate: Schema.NullOr<typeof Schema.String>;
+    status: Schema.Literal<["active", "cancelled"]>;
+    trainingTypeId: Schema.NullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>;
+    trainingTypeName: Schema.NullOr<typeof Schema.String>;
+    startTime: typeof Schema.String;
+    endTime: Schema.NullOr<typeof Schema.String>;
+    location: Schema.NullOr<typeof Schema.String>;
+    discordChannelId: Schema.NullOr<typeof Schema.String>;
+    canEdit: typeof Schema.Boolean;
+    canCancel: typeof Schema.Boolean;
+}>, never, {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+} & {
+    readonly status: "active" | "cancelled";
+} & {
+    readonly description: string | null;
+} & {
+    readonly location: string | null;
+} & {
+    readonly title: string;
+} & {
+    readonly frequency: "weekly" | "biweekly";
+} & {
+    readonly trainingTypeName: string | null;
+} & {
+    readonly seriesId: string & import("effect/Brand").Brand<"EventSeriesId">;
+} & {
+    readonly canEdit: boolean;
+} & {
+    readonly canCancel: boolean;
+} & {
+    readonly trainingTypeId: (string & import("effect/Brand").Brand<"TrainingTypeId">) | null;
+} & {
+    readonly discordChannelId: string | null;
+} & {
+    readonly dayOfWeek: number & import("effect/Brand").Brand<"DayOfWeek">;
+} & {
+    readonly startDate: string;
+} & {
+    readonly startTime: string;
+} & {
+    readonly endDate: string | null;
+} & {
+    readonly endTime: string | null;
+}, {}, {}>;
+export declare class EventSeriesDetail extends EventSeriesDetail_base {
+}
+declare const CreateEventSeriesRequest_base: Schema.Class<CreateEventSeriesRequest, {
+    title: typeof Schema.NonEmptyString;
+    trainingTypeId: Schema.NullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>;
+    description: Schema.NullOr<typeof Schema.String>;
+    frequency: Schema.Literal<["weekly", "biweekly"]>;
+    dayOfWeek: Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">;
+    startDate: typeof Schema.String;
+    endDate: Schema.NullOr<typeof Schema.String>;
+    startTime: typeof Schema.String;
+    endTime: Schema.NullOr<typeof Schema.String>;
+    location: Schema.NullOr<typeof Schema.String>;
+    discordChannelId: Schema.NullOr<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+    title: typeof Schema.NonEmptyString;
+    trainingTypeId: Schema.NullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>;
+    description: Schema.NullOr<typeof Schema.String>;
+    frequency: Schema.Literal<["weekly", "biweekly"]>;
+    dayOfWeek: Schema.brand<Schema.filter<typeof Schema.Int>, "DayOfWeek">;
+    startDate: typeof Schema.String;
+    endDate: Schema.NullOr<typeof Schema.String>;
+    startTime: typeof Schema.String;
+    endTime: Schema.NullOr<typeof Schema.String>;
+    location: Schema.NullOr<typeof Schema.String>;
+    discordChannelId: Schema.NullOr<typeof Schema.String>;
+}>, never, {
+    readonly description: string | null;
+} & {
+    readonly location: string | null;
+} & {
+    readonly title: string;
+} & {
+    readonly frequency: "weekly" | "biweekly";
+} & {
+    readonly trainingTypeId: (string & import("effect/Brand").Brand<"TrainingTypeId">) | null;
+} & {
+    readonly discordChannelId: string | null;
+} & {
+    readonly dayOfWeek: number & import("effect/Brand").Brand<"DayOfWeek">;
+} & {
+    readonly startDate: string;
+} & {
+    readonly startTime: string;
+} & {
+    readonly endDate: string | null;
+} & {
+    readonly endTime: string | null;
+}, {}, {}>;
+export declare class CreateEventSeriesRequest extends CreateEventSeriesRequest_base {
+}
+declare const UpdateEventSeriesRequest_base: Schema.Class<UpdateEventSeriesRequest, {
+    title: Schema.optionalWith<typeof Schema.NonEmptyString, {
+        as: "Option";
+    }>;
+    trainingTypeId: Schema.optionalWith<Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>, {
+        as: "Option";
+    }>;
+    description: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+    startTime: Schema.optionalWith<typeof Schema.String, {
+        as: "Option";
+    }>;
+    endTime: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+    location: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+    endDate: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+    discordChannelId: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+}, Schema.Struct.Encoded<{
+    title: Schema.optionalWith<typeof Schema.NonEmptyString, {
+        as: "Option";
+    }>;
+    trainingTypeId: Schema.optionalWith<Schema.OptionFromNullOr<Schema.brand<typeof Schema.String, "TrainingTypeId">>, {
+        as: "Option";
+    }>;
+    description: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+    startTime: Schema.optionalWith<typeof Schema.String, {
+        as: "Option";
+    }>;
+    endTime: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+    location: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+    endDate: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+    discordChannelId: Schema.optionalWith<Schema.OptionFromNullOr<typeof Schema.String>, {
+        as: "Option";
+    }>;
+}>, never, {
+    readonly description: import("effect/Option").Option<import("effect/Option").Option<string>>;
+} & {
+    readonly location: import("effect/Option").Option<import("effect/Option").Option<string>>;
+} & {
+    readonly title: import("effect/Option").Option<string>;
+} & {
+    readonly trainingTypeId: import("effect/Option").Option<import("effect/Option").Option<string & import("effect/Brand").Brand<"TrainingTypeId">>>;
+} & {
+    readonly discordChannelId: import("effect/Option").Option<import("effect/Option").Option<string>>;
+} & {
+    readonly startTime: import("effect/Option").Option<string>;
+} & {
+    readonly endDate: import("effect/Option").Option<import("effect/Option").Option<string>>;
+} & {
+    readonly endTime: import("effect/Option").Option<import("effect/Option").Option<string>>;
+}, {}, {}>;
+export declare class UpdateEventSeriesRequest extends UpdateEventSeriesRequest_base {
+}
+declare const EventSeriesNotFound_base: Schema.TaggedErrorClass<EventSeriesNotFound, "EventSeriesNotFound", {
+    readonly _tag: Schema.tag<"EventSeriesNotFound">;
+}>;
+export declare class EventSeriesNotFound extends EventSeriesNotFound_base {
+}
+declare const EventSeriesCancelled_base: Schema.TaggedErrorClass<EventSeriesCancelled, "EventSeriesCancelled", {
+    readonly _tag: Schema.tag<"EventSeriesCancelled">;
+}>;
+export declare class EventSeriesCancelled extends EventSeriesCancelled_base {
+}
+declare const EventSeriesApiGroup_base: HttpApiGroup.HttpApiGroup<"eventSeries", HttpApiEndpoint.HttpApiEndpoint<"createEventSeries", "POST", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+}, never, CreateEventSeriesRequest, never, EventSeriesInfo, import("../api/Auth.js").Unauthorized | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"listEventSeries", "GET", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+}, never, never, never, readonly EventSeriesInfo[], import("../api/Auth.js").Unauthorized | Forbidden, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"getEventSeries", "GET", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly seriesId: string & import("effect/Brand").Brand<"EventSeriesId">;
+}, never, never, never, EventSeriesDetail, import("../api/Auth.js").Unauthorized | Forbidden | EventSeriesNotFound, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"updateEventSeries", "PATCH", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly seriesId: string & import("effect/Brand").Brand<"EventSeriesId">;
+}, never, UpdateEventSeriesRequest, never, EventSeriesDetail, import("../api/Auth.js").Unauthorized | Forbidden | EventSeriesNotFound | EventSeriesCancelled, AuthMiddleware, never> | HttpApiEndpoint.HttpApiEndpoint<"cancelEventSeries", "POST", {
+    readonly teamId: string & import("effect/Brand").Brand<"TeamId">;
+    readonly seriesId: string & import("effect/Brand").Brand<"EventSeriesId">;
+}, never, never, never, void, import("../api/Auth.js").Unauthorized | Forbidden | EventSeriesNotFound | EventSeriesCancelled, AuthMiddleware, never>, never, never, false>;
+export declare class EventSeriesApiGroup extends EventSeriesApiGroup_base {
+}
+export {};
+//# sourceMappingURL=EventSeriesApi.d.ts.map