@lyxa.ai/marketing 1.0.51 → 1.0.53

package/dist/types/modules/tournament/statistics/statistics.validation.d.ts

@@ -9,6 +9,7 @@ export declare const GetUserTournamentStatsSchema: z.ZodObject<{
 }>;
 export declare const UserTournamentMatchViewSchema: z.ZodObject<{
     id: z.ZodString;
+    stage: z.ZodString;
     teams: z.ZodString;
     date: z.ZodNullable<z.ZodString>;
     prediction: z.ZodNullable<z.ZodString>;
@@ -21,6 +22,7 @@ export declare const UserTournamentMatchViewSchema: z.ZodObject<{
     id: string;
     result: "won" | "lost" | "pending" | null;
     teams: string;
+    stage: string;
     prediction: string | null;
     realScore: string | null;
 }, {
@@ -29,13 +31,14 @@ export declare const UserTournamentMatchViewSchema: z.ZodObject<{
     id: string;
     result: "won" | "lost" | "pending" | null;
     teams: string;
+    stage: string;
     prediction: string | null;
     realScore: string | null;
 }>;
 export declare const UserTournamentStatsSchema: z.ZodNullable<z.ZodObject<{
     name: z.ZodString;
     joinedAt: z.ZodNullable<z.ZodDate>;
-    selectedTeam: z.ZodObject<{
+    selectedTeam: z.ZodNullable<z.ZodObject<{
         name: z.ZodString;
         flag: z.ZodNullable<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
@@ -44,7 +47,7 @@ export declare const UserTournamentStatsSchema: z.ZodNullable<z.ZodObject<{
     }, {
         name: string;
         flag: string | null;
-    }>;
+    }>>;
     stats: z.ZodObject<{
         predictionsMade: z.ZodNumber;
         correctPredictions: z.ZodNumber;
@@ -60,6 +63,7 @@ export declare const UserTournamentStatsSchema: z.ZodNullable<z.ZodObject<{
     }>;
     matches: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
+        stage: z.ZodString;
         teams: z.ZodString;
         date: z.ZodNullable<z.ZodString>;
         prediction: z.ZodNullable<z.ZodString>;
@@ -72,6 +76,7 @@ export declare const UserTournamentStatsSchema: z.ZodNullable<z.ZodObject<{
         id: string;
         result: "won" | "lost" | "pending" | null;
         teams: string;
+        stage: string;
         prediction: string | null;
         realScore: string | null;
     }, {
@@ -80,6 +85,7 @@ export declare const UserTournamentStatsSchema: z.ZodNullable<z.ZodObject<{
         id: string;
         result: "won" | "lost" | "pending" | null;
         teams: string;
+        stage: string;
         prediction: string | null;
         realScore: string | null;
     }>, "many">;
@@ -97,13 +103,14 @@ export declare const UserTournamentStatsSchema: z.ZodNullable<z.ZodObject<{
         id: string;
         result: "won" | "lost" | "pending" | null;
         teams: string;
+        stage: string;
         prediction: string | null;
         realScore: string | null;
     }[];
     selectedTeam: {
         name: string;
         flag: string | null;
-    };
+    } | null;
 }, {
     name: string;
     joinedAt: Date | null;
@@ -118,13 +125,14 @@ export declare const UserTournamentStatsSchema: z.ZodNullable<z.ZodObject<{
         id: string;
         result: "won" | "lost" | "pending" | null;
         teams: string;
+        stage: string;
         prediction: string | null;
         realScore: string | null;
     }[];
     selectedTeam: {
         name: string;
         flag: string | null;
-    };
+    } | null;
 }>>;
 export declare const UserTournamentStatsResponseSchema: z.ZodObject<{
     success: z.ZodBoolean;
@@ -160,13 +168,14 @@ export declare const UserTournamentStatsResponseSchema: z.ZodObject<{
                 id: string;
                 result: "won" | "lost" | "pending" | null;
                 teams: string;
+                stage: string;
                 prediction: string | null;
                 realScore: string | null;
             }[];
             selectedTeam: {
                 name: string;
                 flag: string | null;
-            };
+            } | null;
         } | null, z.ZodTypeDef, {
             name: string;
             joinedAt: Date | null;
@@ -181,13 +190,14 @@ export declare const UserTournamentStatsResponseSchema: z.ZodObject<{
                 id: string;
                 result: "won" | "lost" | "pending" | null;
                 teams: string;
+                stage: string;
                 prediction: string | null;
                 realScore: string | null;
             }[];
             selectedTeam: {
                 name: string;
                 flag: string | null;
-            };
+            } | null;
         } | null>, "many">;
     }, "strip", z.ZodTypeAny, {
         documents: ({
@@ -204,13 +214,14 @@ export declare const UserTournamentStatsResponseSchema: z.ZodObject<{
                 id: string;
                 result: "won" | "lost" | "pending" | null;
                 teams: string;
+                stage: string;
                 prediction: string | null;
                 realScore: string | null;
             }[];
             selectedTeam: {
                 name: string;
                 flag: string | null;
-            };
+            } | null;
         } | null)[];
         metadata?: {
             page: number;
@@ -233,13 +244,14 @@ export declare const UserTournamentStatsResponseSchema: z.ZodObject<{
                 id: string;
                 result: "won" | "lost" | "pending" | null;
                 teams: string;
+                stage: string;
                 prediction: string | null;
                 realScore: string | null;
             }[];
             selectedTeam: {
                 name: string;
                 flag: string | null;
-            };
+            } | null;
         } | null)[];
         metadata?: {
             page: number;
@@ -261,13 +273,14 @@ export declare const UserTournamentStatsResponseSchema: z.ZodObject<{
             id: string;
             result: "won" | "lost" | "pending" | null;
             teams: string;
+            stage: string;
             prediction: string | null;
             realScore: string | null;
         }[];
         selectedTeam: {
             name: string;
             flag: string | null;
-        };
+        } | null;
     } | null, z.ZodTypeDef, {
         name: string;
         joinedAt: Date | null;
@@ -282,13 +295,14 @@ export declare const UserTournamentStatsResponseSchema: z.ZodObject<{
             id: string;
             result: "won" | "lost" | "pending" | null;
             teams: string;
+            stage: string;
             prediction: string | null;
             realScore: string | null;
         }[];
         selectedTeam: {
             name: string;
             flag: string | null;
-        };
+        } | null;
     } | null>]>>;
 }, "strip", z.ZodTypeAny, {
     message: string;
@@ -307,13 +321,14 @@ export declare const UserTournamentStatsResponseSchema: z.ZodObject<{
             id: string;
             result: "won" | "lost" | "pending" | null;
             teams: string;
+            stage: string;
             prediction: string | null;
             realScore: string | null;
         }[];
         selectedTeam: {
             name: string;
             flag: string | null;
-        };
+        } | null;
     } | {
         documents: ({
             name: string;
@@ -329,13 +344,14 @@ export declare const UserTournamentStatsResponseSchema: z.ZodObject<{
                 id: string;
                 result: "won" | "lost" | "pending" | null;
                 teams: string;
+                stage: string;
                 prediction: string | null;
                 realScore: string | null;
             }[];
             selectedTeam: {
                 name: string;
                 flag: string | null;
-            };
+            } | null;
         } | null)[];
         metadata?: {
             page: number;
@@ -361,13 +377,14 @@ export declare const UserTournamentStatsResponseSchema: z.ZodObject<{
             id: string;
             result: "won" | "lost" | "pending" | null;
             teams: string;
+            stage: string;
             prediction: string | null;
             realScore: string | null;
         }[];
         selectedTeam: {
             name: string;
             flag: string | null;
-        };
+        } | null;
     } | {
         documents: ({
             name: string;
@@ -383,13 +400,14 @@ export declare const UserTournamentStatsResponseSchema: z.ZodObject<{
                 id: string;
                 result: "won" | "lost" | "pending" | null;
                 teams: string;
+                stage: string;
                 prediction: string | null;
                 realScore: string | null;
             }[];
             selectedTeam: {
                 name: string;
                 flag: string | null;
-            };
+            } | null;
         } | null)[];
         metadata?: {
             page: number;

package/dist/types/modules/tournament/statistics/statistics.validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"statistics.validation.d.ts","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,GAAG,EAAiB,MAAM,2DAA2D,CAAC;AAG/F,eAAO,MAAM,4BAA4B;;;;;;EAEvC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;EAQxC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAe1B,CAAC;AAEb,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAkD,CAAC;AAEjG,MAAM,MAAM,8BAA8B,GAAG,GAAG,CAAC,OAAO,4BAA4B,CAAC,CAAC;AACtF,MAAM,MAAM,4BAA4B,GAAG,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC"}
+{"version":3,"file":"statistics.validation.d.ts","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,GAAG,EAAiB,MAAM,2DAA2D,CAAC;AAG/F,eAAO,MAAM,4BAA4B;;;;;;EAEvC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;EASxC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAe1B,CAAC;AAEb,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAkD,CAAC;AAEjG,MAAM,MAAM,8BAA8B,GAAG,GAAG,CAAC,OAAO,4BAA4B,CAAC,CAAC;AACtF,MAAM,MAAM,4BAA4B,GAAG,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/types/modules/tournament/sync/sync.repository.d.ts

@@ -0,0 +1,11 @@
+import { mongoose } from '@typegoose/typegoose';
+import { Tournament as Model } from '@lyxa.ai/core/dist/libraries/mongo/models';
+export declare class SyncRepository {
+    private model;
+    constructor();
+    findActiveTournament(): Promise<(Model & {
+        _id: mongoose.Types.ObjectId;
+    }) | null>;
+}
+export declare const syncRepository: SyncRepository;
+//# sourceMappingURL=sync.repository.d.ts.map

package/dist/types/modules/tournament/sync/sync.repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.repository.d.ts","sourceRoot":"/","sources":["modules/tournament/sync/sync.repository.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,UAAU,IAAI,KAAK,EAAmB,MAAM,2CAA2C,CAAC;AAGjG,qBACa,cAAc;IACvB,OAAO,CAAC,KAAK,CAAyB;;IAMhC,oBAAoB,IAAI,OAAO,CAAC,CAAC,KAAK,GAAG;QAAE,GAAG,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAA;KAAE,CAAC,GAAG,IAAI,CAAC;CAM3F;AAED,eAAO,MAAM,cAAc,gBAAgC,CAAC"}

package/dist/types/modules/tournament/sync/sync.router.d.ts

@@ -0,0 +1,27 @@
+export declare const syncRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("@lyxa.ai/core/dist/libraries/trpc/context").LyxaHTTPContext;
+    meta: object;
+    errorShape: {
+        message: string;
+        data: {
+            stack: undefined;
+            path: undefined;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+        };
+        stack: undefined;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    syncLiveScores: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+            message: string;
+            data: null | undefined;
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=sync.router.d.ts.map

package/dist/types/modules/tournament/sync/sync.router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.router.d.ts","sourceRoot":"/","sources":["modules/tournament/sync/sync.router.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;GAWrB,CAAC"}

package/dist/types/modules/tournament/sync/sync.service.d.ts

@@ -0,0 +1,9 @@
+export declare class SyncService {
+    private repository;
+    private scoreRepository;
+    private matchService;
+    constructor();
+    syncLiveScores(): Promise<void>;
+}
+export declare const syncService: SyncService;
+//# sourceMappingURL=sync.service.d.ts.map

package/dist/types/modules/tournament/sync/sync.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.service.d.ts","sourceRoot":"/","sources":["modules/tournament/sync/sync.service.ts"],"names":[],"mappings":"AAYA,qBACa,WAAW;IACpB,OAAO,CAAC,UAAU,CAAiB;IACnC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,YAAY,CAAe;;IAQtB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;CAkD/C;AAED,eAAO,MAAM,WAAW,aAA6B,CAAC"}

package/dist/types/modules/tournament/team/team.builder.d.ts

@@ -1,4 +1,6 @@
 import { mongoose } from '@typegoose/typegoose';
+import { TournamentParticipantOutputDTO } from '../participant/participant.validation';
+import { TournamentTeamOutputDTO } from './team.validation';
 interface TeamInput {
     name: string;
     picture?: string;
@@ -14,6 +16,8 @@ export declare class TeamBuilder {
         name: string;
         picture: string | undefined;
     }[];
+    static buildTeamPictureMap(teams: TournamentTeamOutputDTO[]): Map<string, string | undefined>;
+    static buildPredictionMap(predictions: TournamentParticipantOutputDTO['predictions']): Map<string, TournamentParticipantOutputDTO['predictions'][number]>;
 }
 export {};
 //# sourceMappingURL=team.builder.d.ts.map

package/dist/types/modules/tournament/team/team.builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"team.builder.d.ts","sourceRoot":"/","sources":["modules/tournament/team/team.builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,UAAU,SAAS;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,WAAW;IACpB,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS;;;;;IAQjC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE;;;;;CAGxC"}
+{"version":3,"file":"team.builder.d.ts","sourceRoot":"/","sources":["modules/tournament/team/team.builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAC,8BAA8B,EAAC,MAAM,uCAAuC,CAAC;AACrF,OAAO,EAAC,uBAAuB,EAAC,MAAM,mBAAmB,CAAC;AAE1D,UAAU,SAAS;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,WAAW;IACpB,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS;;;;;IAQjC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE;;;;;IAIrC,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,uBAAuB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAI7F,MAAM,CAAC,kBAAkB,CACrB,WAAW,EAAE,8BAA8B,CAAC,aAAa,CAAC,GAC3D,GAAG,CAAC,MAAM,EAAE,8BAA8B,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;CAGxE"}

package/dist/types/modules/tournament/team/team.repository.d.ts

@@ -4,6 +4,9 @@ export declare class TournamentTeamRepository {
     private model;
     constructor();
     findById(id: mongoose.Types.ObjectId): Promise<Model | null>;
+    findActive(): Promise<(Model & {
+        _id: mongoose.Types.ObjectId;
+    }) | null>;
     findByTeamId(teamId: mongoose.Types.ObjectId): Promise<Model | null>;
     addTeams(id: mongoose.Types.ObjectId, teams: object[]): Promise<Model | null>;
 }

package/dist/types/modules/tournament/team/team.repository.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"team.repository.d.ts","sourceRoot":"/","sources":["modules/tournament/team/team.repository.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,UAAU,IAAI,KAAK,EAAmB,MAAM,2CAA2C,CAAC;AAEjG,qBACa,wBAAwB;IACpC,OAAO,CAAC,KAAK,CAAyB;;IAMhC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAI5D,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAIpE,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;CAKnF;AAED,eAAO,MAAM,wBAAwB,0BAA0C,CAAC"}
+{"version":3,"file":"team.repository.d.ts","sourceRoot":"/","sources":["modules/tournament/team/team.repository.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,UAAU,IAAI,KAAK,EAAmB,MAAM,2CAA2C,CAAC;AAGjG,qBACa,wBAAwB;IACpC,OAAO,CAAC,KAAK,CAAyB;;IAMhC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAI5D,UAAU,IAAI,OAAO,CAAC,CAAC,KAAK,GAAG;QAAE,GAAG,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAA;KAAE,CAAC,GAAG,IAAI,CAAC;IAMxE,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAIpE,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;CAKnF;AAED,eAAO,MAAM,wBAAwB,0BAA0C,CAAC"}

package/dist/types/modules/tournament/team/team.router.d.ts

@@ -29,12 +29,12 @@ export declare const teamRouter: import("@trpc/server").TRPCBuiltRouter<{
             data?: {
                 status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                 name: string;
+                tag: string;
                 _id?: string | mongoose.Types.ObjectId | undefined;
                 createdAt?: Date | null | undefined;
                 startDate?: Date | null | undefined;
                 endDate?: Date | null | undefined;
                 updatedAt?: Date | null | undefined;
-                tag?: import("../tournament.types").TournamentTag | undefined;
                 reward?: {
                     type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
                 } | {
@@ -43,16 +43,25 @@ export declare const teamRouter: import("@trpc/server").TRPCBuiltRouter<{
                     couponNamePrefix?: string | undefined;
                     percentage?: number | undefined;
                 } | undefined;
+                notificationTemplates?: Partial<Record<import("@lyxa.ai/core/dist/utilities/enum").TournamentNotificationTag, {
+                    title: string;
+                    body: string;
+                }>> | undefined;
+                scheduledNotifications?: {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentNotificationTag;
+                    durationMins: number;
+                    target: import("@lyxa.ai/core/dist/utilities/enum").TournamentScheduledNotificationTarget;
+                }[] | undefined;
             } | {
                 documents: {
                     status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                     name: string;
+                    tag: string;
                     _id?: string | mongoose.Types.ObjectId | undefined;
                     createdAt?: Date | null | undefined;
                     startDate?: Date | null | undefined;
                     endDate?: Date | null | undefined;
                     updatedAt?: Date | null | undefined;
-                    tag?: import("../tournament.types").TournamentTag | undefined;
                     reward?: {
                         type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
                     } | {
@@ -61,6 +70,15 @@ export declare const teamRouter: import("@trpc/server").TRPCBuiltRouter<{
                         couponNamePrefix?: string | undefined;
                         percentage?: number | undefined;
                     } | undefined;
+                    notificationTemplates?: Partial<Record<import("@lyxa.ai/core/dist/utilities/enum").TournamentNotificationTag, {
+                        title: string;
+                        body: string;
+                    }>> | undefined;
+                    scheduledNotifications?: {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentNotificationTag;
+                        durationMins: number;
+                        target: import("@lyxa.ai/core/dist/utilities/enum").TournamentScheduledNotificationTarget;
+                    }[] | undefined;
                 }[];
                 metadata?: {
                     page: number;
@@ -74,7 +92,7 @@ export declare const teamRouter: import("@trpc/server").TRPCBuiltRouter<{
     }>;
     getAll: import("@trpc/server").TRPCQueryProcedure<{
         input: {
-            tournamentId: string | mongoose.Types.ObjectId;
+            tournamentId?: string | mongoose.Types.ObjectId | undefined;
         };
         output: {
             message: string;
@@ -116,7 +134,7 @@ export declare const teamRouter: import("@trpc/server").TRPCBuiltRouter<{
     getMatches: import("@trpc/server").TRPCQueryProcedure<{
         input: {
             tournamentId: string | mongoose.Types.ObjectId;
-            filter?: import("../tournament.types").MatchStatus | undefined;
+            filter?: import("@lyxa.ai/core/dist/utilities/enum").TournamentMatchStatus | undefined;
         };
         output: {
             message: string;
@@ -142,7 +160,7 @@ export declare const teamRouter: import("@trpc/server").TRPCBuiltRouter<{
                         team2: number | null;
                     };
                     stage: string;
-                    matchStatus: import("../tournament.types").MatchStatus;
+                    matchStatus: import("@lyxa.ai/core/dist/utilities/enum").TournamentMatchStatus;
                     prediction: {
                         score: {
                             team1: number | null;
@@ -180,7 +198,7 @@ export declare const teamRouter: import("@trpc/server").TRPCBuiltRouter<{
                             team2: number | null;
                         };
                         stage: string;
-                        matchStatus: import("../tournament.types").MatchStatus;
+                        matchStatus: import("@lyxa.ai/core/dist/utilities/enum").TournamentMatchStatus;
                         prediction: {
                             score: {
                                 team1: number | null;

package/dist/types/modules/tournament/team/team.router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"team.router.d.ts","sourceRoot":"/","sources":["modules/tournament/team/team.router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAgBhD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BrB,CAAC"}
+{"version":3,"file":"team.router.d.ts","sourceRoot":"/","sources":["modules/tournament/team/team.router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAgBhD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BrB,CAAC"}

package/dist/types/modules/tournament/team/team.service.d.ts

@@ -9,8 +9,9 @@ export declare class TeamService {
     private getMatchStatus;
     private applyStatusFilter;
     add(input: AddTournamentTeamsInputDTO): Promise<TournamentConfigOutputDTO>;
-    getAll(tournamentId: mongoose.Types.ObjectId): Promise<TournamentWithTeamsOutputDTO>;
+    getAll(tournamentId?: mongoose.Types.ObjectId): Promise<TournamentWithTeamsOutputDTO>;
     getMatches(userId: mongoose.Types.ObjectId, input: GetTeamMatchesInputDTO): Promise<TournamentWithMatchesOutputDTO>;
+    private enrichMatch;
 }
 export declare const teamService: TeamService;
 //# sourceMappingURL=team.service.d.ts.map

package/dist/types/modules/tournament/team/team.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"team.service.d.ts","sourceRoot":"/","sources":["modules/tournament/team/team.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,OAAO,EACH,0BAA0B,EAC1B,sBAAsB,EAEtB,8BAA8B,EAC9B,4BAA4B,EAC/B,MAAM,mBAAmB,CAAC;AAI3B,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAKxE,qBACa,WAAW;IACpB,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,kBAAkB,CAAqB;;IAO/C,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,iBAAiB;IAYZ,GAAG,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAU1E,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAcpF,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,8BAA8B,CAAC;CAyCnI;AAED,eAAO,MAAM,WAAW,aAA6B,CAAC"}
+{"version":3,"file":"team.service.d.ts","sourceRoot":"/","sources":["modules/tournament/team/team.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,OAAO,EACH,0BAA0B,EAC1B,sBAAsB,EAEtB,8BAA8B,EAC9B,4BAA4B,EAC/B,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAMxE,qBACa,WAAW;IACpB,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,kBAAkB,CAAqB;;IAO/C,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,iBAAiB;IAYZ,GAAG,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAU1E,MAAM,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAgBrF,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,8BAA8B,CAAC;IA2BhI,OAAO,CAAC,WAAW;CAkBtB;AAED,eAAO,MAAM,WAAW,aAA6B,CAAC"}

package/dist/types/modules/tournament/team/team.validation.d.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod';
 import { DTO } from '@lyxa.ai/core/dist/utilities/validation/global-validation';
-import { Status } from '@lyxa.ai/core/dist/utilities/enum';
-import { MatchStatus } from '../tournament.types';
+import { Status, TournamentMatchStatus } from '@lyxa.ai/core/dist/utilities/enum';
 export declare const AddTournamentTeamsSchema: z.ZodObject<{
     tournamentId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
     teams: z.ZodArray<z.ZodObject<{
@@ -28,22 +27,22 @@ export declare const AddTournamentTeamsSchema: z.ZodObject<{
     }[];
 }>;
 export declare const GetTournamentTeamsSchema: z.ZodObject<{
-    tournamentId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    tournamentId: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>>;
 }, "strip", z.ZodTypeAny, {
-    tournamentId: import("mongoose").Types.ObjectId;
+    tournamentId?: import("mongoose").Types.ObjectId | undefined;
 }, {
-    tournamentId: string | import("mongoose").Types.ObjectId;
+    tournamentId?: string | import("mongoose").Types.ObjectId | undefined;
 }>;
-export declare const TeamMatchFilterSchema: z.ZodNativeEnum<typeof MatchStatus>;
+export declare const TeamMatchFilterSchema: z.ZodNativeEnum<typeof TournamentMatchStatus>;
 export declare const GetTeamMatchesSchema: z.ZodObject<{
     tournamentId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
-    filter: z.ZodOptional<z.ZodNativeEnum<typeof MatchStatus>>;
+    filter: z.ZodOptional<z.ZodNativeEnum<typeof TournamentMatchStatus>>;
 }, "strip", z.ZodTypeAny, {
     tournamentId: import("mongoose").Types.ObjectId;
-    filter?: MatchStatus | undefined;
+    filter?: TournamentMatchStatus | undefined;
 }, {
     tournamentId: string | import("mongoose").Types.ObjectId;
-    filter?: MatchStatus | undefined;
+    filter?: TournamentMatchStatus | undefined;
 }>;
 declare const TournamentTeamSchema: z.ZodObject<{
     name: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
@@ -180,7 +179,7 @@ export declare const TournamentWithMatchesSchema: z.ZodObject<{
             succeeded: boolean | null;
         }>>;
         canPredict: z.ZodBoolean;
-        matchStatus: z.ZodNativeEnum<typeof MatchStatus>;
+        matchStatus: z.ZodNativeEnum<typeof TournamentMatchStatus>;
     }, "strip", z.ZodTypeAny, {
         _id: import("mongoose").Types.ObjectId;
         team1: {
@@ -198,7 +197,7 @@ export declare const TournamentWithMatchesSchema: z.ZodObject<{
             team2: number | null;
         };
         stage: string;
-        matchStatus: MatchStatus;
+        matchStatus: TournamentMatchStatus;
         prediction: {
             score: {
                 team1: number | null;
@@ -228,7 +227,7 @@ export declare const TournamentWithMatchesSchema: z.ZodObject<{
             team2: number | null;
         };
         stage: string;
-        matchStatus: MatchStatus;
+        matchStatus: TournamentMatchStatus;
         prediction: {
             score: {
                 team1: number | null;
@@ -263,7 +262,7 @@ export declare const TournamentWithMatchesSchema: z.ZodObject<{
             team2: number | null;
         };
         stage: string;
-        matchStatus: MatchStatus;
+        matchStatus: TournamentMatchStatus;
         prediction: {
             score: {
                 team1: number | null;
@@ -300,7 +299,7 @@ export declare const TournamentWithMatchesSchema: z.ZodObject<{
             team2: number | null;
         };
         stage: string;
-        matchStatus: MatchStatus;
+        matchStatus: TournamentMatchStatus;
         prediction: {
             score: {
                 team1: number | null;
@@ -634,7 +633,7 @@ export declare const TournamentWithMatchesResponseSchema: z.ZodObject<{
                     team2: number | null;
                 };
                 stage: string;
-                matchStatus: MatchStatus;
+                matchStatus: TournamentMatchStatus;
                 prediction: {
                     score: {
                         team1: number | null;
@@ -671,7 +670,7 @@ export declare const TournamentWithMatchesResponseSchema: z.ZodObject<{
                     team2: number | null;
                 };
                 stage: string;
-                matchStatus: MatchStatus;
+                matchStatus: TournamentMatchStatus;
                 prediction: {
                     score: {
                         team1: number | null;
@@ -710,7 +709,7 @@ export declare const TournamentWithMatchesResponseSchema: z.ZodObject<{
                     team2: number | null;
                 };
                 stage: string;
-                matchStatus: MatchStatus;
+                matchStatus: TournamentMatchStatus;
                 prediction: {
                     score: {
                         team1: number | null;
@@ -755,7 +754,7 @@ export declare const TournamentWithMatchesResponseSchema: z.ZodObject<{
                     team2: number | null;
                 };
                 stage: string;
-                matchStatus: MatchStatus;
+                matchStatus: TournamentMatchStatus;
                 prediction: {
                     score: {
                         team1: number | null;
@@ -799,7 +798,7 @@ export declare const TournamentWithMatchesResponseSchema: z.ZodObject<{
                 team2: number | null;
             };
             stage: string;
-            matchStatus: MatchStatus;
+            matchStatus: TournamentMatchStatus;
             prediction: {
                 score: {
                     team1: number | null;
@@ -836,7 +835,7 @@ export declare const TournamentWithMatchesResponseSchema: z.ZodObject<{
                 team2: number | null;
             };
             stage: string;
-            matchStatus: MatchStatus;
+            matchStatus: TournamentMatchStatus;
             prediction: {
                 score: {
                     team1: number | null;
@@ -877,7 +876,7 @@ export declare const TournamentWithMatchesResponseSchema: z.ZodObject<{
                 team2: number | null;
             };
             stage: string;
-            matchStatus: MatchStatus;
+            matchStatus: TournamentMatchStatus;
             prediction: {
                 score: {
                     team1: number | null;
@@ -915,7 +914,7 @@ export declare const TournamentWithMatchesResponseSchema: z.ZodObject<{
                     team2: number | null;
                 };
                 stage: string;
-                matchStatus: MatchStatus;
+                matchStatus: TournamentMatchStatus;
                 prediction: {
                     score: {
                         team1: number | null;
@@ -963,7 +962,7 @@ export declare const TournamentWithMatchesResponseSchema: z.ZodObject<{
                 team2: number | null;
             };
             stage: string;
-            matchStatus: MatchStatus;
+            matchStatus: TournamentMatchStatus;
             prediction: {
                 score: {
                     team1: number | null;
@@ -1001,7 +1000,7 @@ export declare const TournamentWithMatchesResponseSchema: z.ZodObject<{
                     team2: number | null;
                 };
                 stage: string;
-                matchStatus: MatchStatus;
+                matchStatus: TournamentMatchStatus;
                 prediction: {
                     score: {
                         team1: number | null;