@lyxa.ai/marketing 1.0.49 → 1.0.50

package/dist/lib/modules/tournament/tournament.router.d.ts

@@ -35,7 +35,7 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                 name: string;
                 startDate: string | Date;
                 endDate: string | Date;
-                tag: string;
+                tag: import("./tournament.types").TournamentTag;
                 status?: import("@lyxa.ai/core/dist/utilities/enum").Status | undefined;
                 reward?: {
                     type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
@@ -52,12 +52,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                 data?: {
                     status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                     name: string;
-                    tag: string;
                     _id?: string | import("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;
                     } | {
@@ -70,12 +70,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                     documents: {
                         status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                         name: string;
-                        tag: string;
                         _id?: string | import("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;
                         } | {
@@ -103,12 +103,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                 data?: {
                     status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                     name: string;
-                    tag: string;
                     _id?: string | import("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;
                     } | {
@@ -120,12 +120,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                     documents: {
                         status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                         name: string;
-                        tag: string;
                         _id?: string | import("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;
                         } | {
@@ -154,12 +154,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                 data?: {
                     status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                     name: string;
-                    tag: string;
                     _id?: string | import("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;
                     } | {
@@ -172,12 +172,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                     documents: {
                         status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                         name: string;
-                        tag: string;
                         _id?: string | import("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;
                         } | {
@@ -204,7 +204,7 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                 name?: string | undefined;
                 startDate?: string | Date | undefined;
                 endDate?: string | Date | undefined;
-                tag?: string | undefined;
+                tag?: import("./tournament.types").TournamentTag | undefined;
                 reward?: {
                     type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
                 } | {
@@ -220,12 +220,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                 data?: {
                     status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                     name: string;
-                    tag: string;
                     _id?: string | import("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;
                     } | {
@@ -238,12 +238,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                     documents: {
                         status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                         name: string;
-                        tag: string;
                         _id?: string | import("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;
                         } | {
@@ -294,12 +294,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                 data?: {
                     status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                     name: string;
-                    tag: string;
                     _id?: string | import("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;
                     } | {
@@ -312,12 +312,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                     documents: {
                         status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                         name: string;
-                        tag: string;
                         _id?: string | import("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;
                         } | {
@@ -380,8 +380,8 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
         }>;
         getMatches: import("@trpc/server").TRPCQueryProcedure<{
             input: {
-                filter: "completed" | "upcoming";
                 tournamentId: string | import("mongoose").Types.ObjectId;
+                filter?: import("./tournament.types").MatchStatus | undefined;
             };
             output: {
                 message: string;
@@ -395,10 +395,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                         team1: {
                             name: string;
                             teamId: string | import("mongoose").Types.ObjectId;
+                            picture?: string | undefined;
                         };
                         team2: {
                             name: string;
                             teamId: string | import("mongoose").Types.ObjectId;
+                            picture?: string | undefined;
                         };
                         score: {
                             team1: number | null;
@@ -413,6 +415,7 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                             succeeded: boolean | null;
                         } | null;
                         canPredict: boolean;
+                        matchStatus: import("./tournament.types").MatchStatus;
                         endDate?: Date | null | undefined;
                         additionalTag?: string | undefined;
                         winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
@@ -430,10 +433,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                             team1: {
                                 name: string;
                                 teamId: string | import("mongoose").Types.ObjectId;
+                                picture?: string | undefined;
                             };
                             team2: {
                                 name: string;
                                 teamId: string | import("mongoose").Types.ObjectId;
+                                picture?: string | undefined;
                             };
                             score: {
                                 team1: number | null;
@@ -448,6 +453,7 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                                 succeeded: boolean | null;
                             } | null;
                             canPredict: boolean;
+                            matchStatus: import("./tournament.types").MatchStatus;
                             endDate?: Date | null | undefined;
                             additionalTag?: string | undefined;
                             winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
@@ -501,12 +507,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                 data?: {
                     status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                     name: string;
-                    tag: string;
                     _id?: string | import("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;
                     } | {
@@ -519,12 +525,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                     documents: {
                         status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                         name: string;
-                        tag: string;
                         _id?: string | import("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;
                         } | {
@@ -556,10 +562,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                     team1: {
                         name: string;
                         teamId: string | import("mongoose").Types.ObjectId;
+                        picture?: string | undefined;
                     };
                     team2: {
                         name: string;
                         teamId: string | import("mongoose").Types.ObjectId;
+                        picture?: string | undefined;
                     };
                     score: {
                         team1: number | null;
@@ -583,10 +591,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                         team1: {
                             name: string;
                             teamId: string | import("mongoose").Types.ObjectId;
+                            picture?: string | undefined;
                         };
                         team2: {
                             name: string;
                             teamId: string | import("mongoose").Types.ObjectId;
+                            picture?: string | undefined;
                         };
                         score: {
                             team1: number | null;
@@ -628,10 +638,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                     team1: {
                         name: string;
                         teamId: string | import("mongoose").Types.ObjectId;
+                        picture?: string | undefined;
                     };
                     team2: {
                         name: string;
                         teamId: string | import("mongoose").Types.ObjectId;
+                        picture?: string | undefined;
                     };
                     score: {
                         team1: number | null;
@@ -655,10 +667,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                         team1: {
                             name: string;
                             teamId: string | import("mongoose").Types.ObjectId;
+                            picture?: string | undefined;
                         };
                         team2: {
                             name: string;
                             teamId: string | import("mongoose").Types.ObjectId;
+                            picture?: string | undefined;
                         };
                         score: {
                             team1: number | null;
@@ -704,10 +718,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                     team1: {
                         name: string;
                         teamId: string | import("mongoose").Types.ObjectId;
+                        picture?: string | undefined;
                     };
                     team2: {
                         name: string;
                         teamId: string | import("mongoose").Types.ObjectId;
+                        picture?: string | undefined;
                     };
                     score: {
                         team1: number | null;
@@ -731,10 +747,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                         team1: {
                             name: string;
                             teamId: string | import("mongoose").Types.ObjectId;
+                            picture?: string | undefined;
                         };
                         team2: {
                             name: string;
                             teamId: string | import("mongoose").Types.ObjectId;
+                            picture?: string | undefined;
                         };
                         score: {
                             team1: number | null;
@@ -774,12 +792,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                 data?: {
                     status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                     name: string;
-                    tag: string;
                     _id?: string | import("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;
                     } | {
@@ -792,12 +810,12 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
                     documents: {
                         status: import("@lyxa.ai/core/dist/utilities/enum").Status;
                         name: string;
-                        tag: string;
                         _id?: string | import("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;
                         } | {
@@ -1051,6 +1069,207 @@ export declare const tournamentRouter: import("@trpc/server").TRPCBuiltRouter<{
             meta: object;
         }>;
     }>>;
+    statistics: 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<{
+        getActiveByUser: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                userId: string | import("mongoose").Types.ObjectId;
+            };
+            output: {
+                message: string;
+                success: boolean;
+                data?: {
+                    name: string;
+                    joinedAt: Date | null;
+                    stats: {
+                        predictionsMade: number;
+                        correctPredictions: number;
+                        couponsWon: number;
+                    };
+                    matches: {
+                        date: string | null;
+                        coupon: string | null;
+                        id: string;
+                        result: "won" | "lost" | "pending" | null;
+                        teams: string;
+                        prediction: string | null;
+                        realScore: string | null;
+                    }[];
+                    selectedTeam: {
+                        name: string;
+                        flag: string | null;
+                    };
+                } | {
+                    documents: ({
+                        name: string;
+                        joinedAt: Date | null;
+                        stats: {
+                            predictionsMade: number;
+                            correctPredictions: number;
+                            couponsWon: number;
+                        };
+                        matches: {
+                            date: string | null;
+                            coupon: string | null;
+                            id: string;
+                            result: "won" | "lost" | "pending" | null;
+                            teams: string;
+                            prediction: string | null;
+                            realScore: string | null;
+                        }[];
+                        selectedTeam: {
+                            name: string;
+                            flag: string | null;
+                        };
+                    } | null)[];
+                    metadata?: {
+                        page: number;
+                        size: number;
+                        totalElements: number;
+                        totalPages: number;
+                    } | undefined;
+                } | null | undefined;
+            };
+            meta: object;
+        }>;
+    }>>;
+    schedule: 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<{
+        dispatch: import("@trpc/server").TRPCMutationProcedure<{
+            input: void;
+            output: {
+                success: boolean;
+                message: string;
+                data: null | undefined;
+            };
+            meta: object;
+        }>;
+    }>>;
+    score: 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<{
+        updateMatchScore: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                tournamentId: string | import("mongoose").Types.ObjectId;
+                matchId: string | import("mongoose").Types.ObjectId;
+                teams: {
+                    score: number;
+                    teamId: string | import("mongoose").Types.ObjectId;
+                }[];
+            };
+            output: {
+                message: string;
+                success: boolean;
+                data?: {
+                    _id: string | import("mongoose").Types.ObjectId;
+                    team1: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                        picture?: string | undefined;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                        picture?: string | undefined;
+                    };
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    stage: string;
+                    endDate?: Date | null | undefined;
+                    additionalTag?: string | undefined;
+                    winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                    startingDate?: Date | null | undefined;
+                    prediction?: {
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        succeeded?: boolean | null | undefined;
+                    } | null | undefined;
+                } | {
+                    documents: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        team1: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                            picture?: string | undefined;
+                        };
+                        team2: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                            picture?: string | undefined;
+                        };
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        stage: string;
+                        endDate?: Date | null | undefined;
+                        additionalTag?: string | undefined;
+                        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                        startingDate?: Date | null | undefined;
+                        prediction?: {
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            succeeded?: boolean | null | undefined;
+                        } | null | undefined;
+                    }[];
+                    metadata?: {
+                        page: number;
+                        size: number;
+                        totalElements: number;
+                        totalPages: number;
+                    } | undefined;
+                } | undefined;
+            };
+            meta: object;
+        }>;
+    }>>;
     getActive: import("@trpc/server").TRPCQueryProcedure<{
         input: void;
         output: {

package/dist/lib/modules/tournament/tournament.router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tournament.router.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.router.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAa3B,CAAC"}
+{"version":3,"file":"tournament.router.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.router.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgB3B,CAAC"}

package/dist/lib/modules/tournament/tournament.router.js

@@ -9,6 +9,9 @@ const team_router_1 = require("./team/team.router");
 const match_router_1 = require("./match/match.router");
 const participant_router_1 = require("./participant/participant.router");
 const prediction_router_1 = require("./prediction/prediction.router");
+const statistics_router_1 = require("./statistics/statistics.router");
+const schedule_router_1 = require("./schedule/schedule.router");
+const score_router_1 = require("./score/score.router");
 const tournament_validation_1 = require("./tournament.validation");
 const tournament_service_1 = require("./tournament.service");
 exports.tournamentRouter = (0, trpc_1.createTRPCRouter)({
@@ -17,6 +20,9 @@ exports.tournamentRouter = (0, trpc_1.createTRPCRouter)({
     match: match_router_1.matchRouter,
     participant: participant_router_1.participantRouter,
     prediction: prediction_router_1.predictionRouter,
+    statistics: statistics_router_1.statisticsRouter,
+    schedule: schedule_router_1.scheduleRouter,
+    score: score_router_1.scoreRouter,
     getActive: trpc_1.publicProcedure.output(tournament_validation_1.ActiveTournamentResponseSchema).query(() => error_handler_1.ErrorHandler.wrapAsync(async () => {
         const result = await tournament_service_1.tournamentService.getActive();
         return (0, response_1.response)('Active tournament fetched successfully', result);

package/dist/lib/modules/tournament/tournament.router.js.map

@@ -1 +1 @@
-{"version":3,"file":"tournament.router.js","sourceRoot":"/","sources":["modules/tournament/tournament.router.ts"],"names":[],"mappings":";;;AAAA,4DAAoF;AACpF,8EAAwE;AACxE,oEAA+D;AAC/D,0DAAoD;AACpD,oDAA8C;AAC9C,uDAAiD;AACjD,yEAAmE;AACnE,sEAAgE;AAChE,mEAAuE;AACvE,6DAAkE;AAErD,QAAA,gBAAgB,GAAG,IAAA,uBAAgB,EAAC;IAChD,MAAM,EAAE,4BAAY;IACpB,IAAI,EAAE,wBAAU;IAChB,KAAK,EAAE,0BAAW;IAClB,WAAW,EAAE,sCAAiB;IAC9B,UAAU,EAAE,oCAAgB;IAE5B,SAAS,EAAE,sBAAe,CAAC,MAAM,CAAC,sDAA8B,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAC5E,4BAAY,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE;QACjC,MAAM,MAAM,GAAG,MAAM,sCAAO,CAAC,SAAS,EAAE,CAAC;QACzC,OAAO,IAAA,mBAAQ,EAAC,wCAAwC,EAAE,MAAM,CAAC,CAAC;IACnE,CAAC,CAAC,CACF;CACD,CAAC,CAAC","sourcesContent":["import {createTRPCRouter, publicProcedure} from '@lyxa.ai/core/dist/libraries/trpc';\nimport {ErrorHandler} from '@lyxa.ai/core/dist/utilities/error-handler';\nimport {response} from '@lyxa.ai/core/dist/utilities/response';\nimport {configRouter} from './config/config.router';\nimport {teamRouter} from './team/team.router';\nimport {matchRouter} from './match/match.router';\nimport {participantRouter} from './participant/participant.router';\nimport {predictionRouter} from './prediction/prediction.router';\nimport {ActiveTournamentResponseSchema} from './tournament.validation';\nimport {tournamentService as service} from './tournament.service';\n\nexport const tournamentRouter = createTRPCRouter({\n\tconfig: configRouter,\n\tteam: teamRouter,\n\tmatch: matchRouter,\n\tparticipant: participantRouter,\n\tprediction: predictionRouter,\n\n\tgetActive: publicProcedure.output(ActiveTournamentResponseSchema).query(() =>\n\t\tErrorHandler.wrapAsync(async () => {\n\t\t\tconst result = await service.getActive();\n\t\t\treturn response('Active tournament fetched successfully', result);\n\t\t})\n\t),\n});\n"]}
+{"version":3,"file":"tournament.router.js","sourceRoot":"/","sources":["modules/tournament/tournament.router.ts"],"names":[],"mappings":";;;AAAA,4DAAoF;AACpF,8EAAwE;AACxE,oEAA+D;AAC/D,0DAAoD;AACpD,oDAA8C;AAC9C,uDAAiD;AACjD,yEAAmE;AACnE,sEAAgE;AAChE,sEAAgE;AAChE,gEAA0D;AAC1D,uDAAiD;AACjD,mEAAuE;AACvE,6DAAkE;AAErD,QAAA,gBAAgB,GAAG,IAAA,uBAAgB,EAAC;IAChD,MAAM,EAAE,4BAAY;IACpB,IAAI,EAAE,wBAAU;IAChB,KAAK,EAAE,0BAAW;IAClB,WAAW,EAAE,sCAAiB;IAC9B,UAAU,EAAE,oCAAgB;IAC5B,UAAU,EAAE,oCAAgB;IAC5B,QAAQ,EAAE,gCAAc;IACxB,KAAK,EAAE,0BAAW;IAElB,SAAS,EAAE,sBAAe,CAAC,MAAM,CAAC,sDAA8B,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAC5E,4BAAY,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE;QACjC,MAAM,MAAM,GAAG,MAAM,sCAAO,CAAC,SAAS,EAAE,CAAC;QACzC,OAAO,IAAA,mBAAQ,EAAC,wCAAwC,EAAE,MAAM,CAAC,CAAC;IACnE,CAAC,CAAC,CACF;CACD,CAAC,CAAC","sourcesContent":["import {createTRPCRouter, publicProcedure} from '@lyxa.ai/core/dist/libraries/trpc';\nimport {ErrorHandler} from '@lyxa.ai/core/dist/utilities/error-handler';\nimport {response} from '@lyxa.ai/core/dist/utilities/response';\nimport {configRouter} from './config/config.router';\nimport {teamRouter} from './team/team.router';\nimport {matchRouter} from './match/match.router';\nimport {participantRouter} from './participant/participant.router';\nimport {predictionRouter} from './prediction/prediction.router';\nimport {statisticsRouter} from './statistics/statistics.router';\nimport {scheduleRouter} from './schedule/schedule.router';\nimport {scoreRouter} from './score/score.router';\nimport {ActiveTournamentResponseSchema} from './tournament.validation';\nimport {tournamentService as service} from './tournament.service';\n\nexport const tournamentRouter = createTRPCRouter({\n\tconfig: configRouter,\n\tteam: teamRouter,\n\tmatch: matchRouter,\n\tparticipant: participantRouter,\n\tprediction: predictionRouter,\n\tstatistics: statisticsRouter,\n\tschedule: scheduleRouter,\n\tscore: scoreRouter,\n\n\tgetActive: publicProcedure.output(ActiveTournamentResponseSchema).query(() =>\n\t\tErrorHandler.wrapAsync(async () => {\n\t\t\tconst result = await service.getActive();\n\t\t\treturn response('Active tournament fetched successfully', result);\n\t\t})\n\t),\n});\n"]}

package/dist/lib/modules/tournament/tournament.types.d.ts

@@ -0,0 +1,9 @@
+export declare enum TournamentTag {
+    FOOTBALL_WORLD_CUP = "world-cup"
+}
+export declare enum MatchStatus {
+    UPCOMING = "upcoming",
+    STARTED = "started",
+    ENDED = "ended"
+}
+//# sourceMappingURL=tournament.types.d.ts.map

package/dist/lib/modules/tournament/tournament.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tournament.types.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.types.ts"],"names":[],"mappings":"AAAA,oBAAY,aAAa;IACrB,kBAAkB,cAAc;CACnC;AAED,oBAAY,WAAW;IACnB,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,KAAK,UAAU;CAClB"}

package/dist/lib/modules/tournament/tournament.types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchStatus = exports.TournamentTag = void 0;
+var TournamentTag;
+(function (TournamentTag) {
+    TournamentTag["FOOTBALL_WORLD_CUP"] = "world-cup";
+})(TournamentTag || (exports.TournamentTag = TournamentTag = {}));
+var MatchStatus;
+(function (MatchStatus) {
+    MatchStatus["UPCOMING"] = "upcoming";
+    MatchStatus["STARTED"] = "started";
+    MatchStatus["ENDED"] = "ended";
+})(MatchStatus || (exports.MatchStatus = MatchStatus = {}));
+//# sourceMappingURL=tournament.types.js.map

package/dist/lib/modules/tournament/tournament.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tournament.types.js","sourceRoot":"/","sources":["modules/tournament/tournament.types.ts"],"names":[],"mappings":";;;AAAA,IAAY,aAEX;AAFD,WAAY,aAAa;IACrB,iDAAgC,CAAA;AACpC,CAAC,EAFW,aAAa,6BAAb,aAAa,QAExB;AAED,IAAY,WAIX;AAJD,WAAY,WAAW;IACnB,oCAAqB,CAAA;IACrB,kCAAmB,CAAA;IACnB,8BAAe,CAAA;AACnB,CAAC,EAJW,WAAW,2BAAX,WAAW,QAItB","sourcesContent":["export enum TournamentTag {\n    FOOTBALL_WORLD_CUP = 'world-cup',\n}\n\nexport enum MatchStatus {\n    UPCOMING = 'upcoming',\n    STARTED = 'started',\n    ENDED = 'ended',\n}\n"]}

package/dist/lib/modules/tournament/tournament.utils.d.ts

@@ -0,0 +1,2 @@
+export declare const utcNow: () => Date;
+//# sourceMappingURL=tournament.utils.d.ts.map

package/dist/lib/modules/tournament/tournament.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tournament.utils.d.ts","sourceRoot":"/","sources":["modules/tournament/tournament.utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM,QAAO,IAA4B,CAAC"}

package/dist/lib/modules/tournament/tournament.utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utcNow = void 0;
+const utcNow = () => new Date(Date.now());
+exports.utcNow = utcNow;
+//# sourceMappingURL=tournament.utils.js.map

package/dist/lib/modules/tournament/tournament.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tournament.utils.js","sourceRoot":"/","sources":["modules/tournament/tournament.utils.ts"],"names":[],"mappings":";;;AAAO,MAAM,MAAM,GAAG,GAAS,EAAE,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;AAA1C,QAAA,MAAM,UAAoC","sourcesContent":["export const utcNow = (): Date => new Date(Date.now());\n"]}