@lyxa.ai/marketing 1.0.49 → 1.0.50

package/dist/lib/modules/tournament/score/score.validation.d.ts

@@ -0,0 +1,375 @@
+import { z } from 'zod';
+import { DTO } from '@lyxa.ai/core/dist/utilities/validation/global-validation';
+export declare const UpdateMatchScoreSchema: 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>]>;
+    matchId: 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<{
+        teamId: 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>]>;
+        score: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        score: number;
+        teamId: import("mongoose").Types.ObjectId;
+    }, {
+        score: number;
+        teamId: string | import("mongoose").Types.ObjectId;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    tournamentId: import("mongoose").Types.ObjectId;
+    matchId: import("mongoose").Types.ObjectId;
+    teams: {
+        score: number;
+        teamId: import("mongoose").Types.ObjectId;
+    }[];
+}, {
+    tournamentId: string | import("mongoose").Types.ObjectId;
+    matchId: string | import("mongoose").Types.ObjectId;
+    teams: {
+        score: number;
+        teamId: string | import("mongoose").Types.ObjectId;
+    }[];
+}>;
+export declare const ScoreResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    data: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        metadata: z.ZodOptional<z.ZodObject<{
+            page: z.ZodNumber;
+            size: z.ZodNumber;
+            totalElements: z.ZodNumber;
+            totalPages: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }>>;
+        documents: z.ZodArray<z.ZodType<{
+            _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;
+        }, z.ZodTypeDef, {
+            _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;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        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;
+    }, {
+        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;
+    }>, z.ZodType<{
+        _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;
+    }, z.ZodTypeDef, {
+        _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;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    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;
+}, {
+    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;
+}>;
+export type UpdateMatchScoreInputDTO = DTO<typeof UpdateMatchScoreSchema>;
+//# sourceMappingURL=score.validation.d.ts.map

package/dist/lib/modules/tournament/score/score.validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"score.validation.d.ts","sourceRoot":"/","sources":["modules/tournament/score/score.validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,GAAG,EAAiB,MAAM,2DAA2D,CAAC;AAI/F,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWjC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA8C,CAAC;AAE/E,MAAM,MAAM,wBAAwB,GAAG,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/lib/modules/tournament/score/score.validation.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScoreResponseSchema = exports.UpdateMatchScoreSchema = void 0;
+const zod_1 = require("zod");
+const global_validation_1 = require("@lyxa.ai/core/dist/utilities/validation/global-validation");
+const validation_1 = require("@lyxa.ai/core/dist/utilities/validation");
+const match_validation_1 = require("../match/match.validation");
+exports.UpdateMatchScoreSchema = zod_1.z.object({
+    tournamentId: global_validation_1.ZodValidation.objectId('Tournament id'),
+    matchId: global_validation_1.ZodValidation.objectId('Match id'),
+    teams: zod_1.z
+        .array(zod_1.z.object({
+        teamId: global_validation_1.ZodValidation.objectId('Team id'),
+        score: global_validation_1.ZodValidation.number('Score', { min: 0, isInt: true }),
+    }))
+        .length(2, 'Exactly 2 teams are required'),
+});
+exports.ScoreResponseSchema = (0, validation_1.createResponseSchema)(match_validation_1.TournamentMatchSchema);
+//# sourceMappingURL=score.validation.js.map

package/dist/lib/modules/tournament/score/score.validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"score.validation.js","sourceRoot":"/","sources":["modules/tournament/score/score.validation.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,iGAA+F;AAC/F,wEAA+E;AAC/E,gEAAkE;AAErD,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC3C,YAAY,EAAE,iCAAa,CAAC,QAAQ,CAAC,eAAe,CAAC;IACrD,OAAO,EAAE,iCAAa,CAAC,QAAQ,CAAC,UAAU,CAAC;IAC3C,KAAK,EAAE,OAAC;SACH,KAAK,CACF,OAAC,CAAC,MAAM,CAAC;QACL,MAAM,EAAE,iCAAa,CAAC,QAAQ,CAAC,SAAS,CAAC;QACzC,KAAK,EAAE,iCAAa,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;KAChE,CAAC,CACL;SACA,MAAM,CAAC,CAAC,EAAE,8BAA8B,CAAC;CACjD,CAAC,CAAC;AAEU,QAAA,mBAAmB,GAAG,IAAA,iCAAoB,EAAC,wCAAqB,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport { DTO, ZodValidation } from '@lyxa.ai/core/dist/utilities/validation/global-validation';\nimport { createResponseSchema } from '@lyxa.ai/core/dist/utilities/validation';\nimport { TournamentMatchSchema } from '../match/match.validation';\n\nexport const UpdateMatchScoreSchema = z.object({\n    tournamentId: ZodValidation.objectId('Tournament id'),\n    matchId: ZodValidation.objectId('Match id'),\n    teams: z\n        .array(\n            z.object({\n                teamId: ZodValidation.objectId('Team id'),\n                score: ZodValidation.number('Score', { min: 0, isInt: true }),\n            })\n        )\n        .length(2, 'Exactly 2 teams are required'),\n});\n\nexport const ScoreResponseSchema = createResponseSchema(TournamentMatchSchema);\n\nexport type UpdateMatchScoreInputDTO = DTO<typeof UpdateMatchScoreSchema>;\n"]}

package/dist/lib/modules/tournament/statistics/statistics.builder.d.ts

@@ -0,0 +1,10 @@
+import { TournamentParticipant, Tournament } from '@lyxa.ai/core/dist/libraries/mongo/models';
+import { UserTournamentStatsOutputDTO } from './statistics.validation';
+export declare class StatisticsBuilder {
+    static buildUserTournamentStats(participant: TournamentParticipant & {
+        createdAt?: Date;
+    }, tournament: Tournament, couponCodeMap: Map<string, string>): UserTournamentStatsOutputDTO;
+    private static formatScore;
+    private static resolveResult;
+}
+//# sourceMappingURL=statistics.builder.d.ts.map

package/dist/lib/modules/tournament/statistics/statistics.builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.builder.d.ts","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAC9F,OAAO,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAC;AAEvE,qBAAa,iBAAiB;IAC1B,MAAM,CAAC,wBAAwB,CAC3B,WAAW,EAAE,qBAAqB,GAAG;QAAE,SAAS,CAAC,EAAE,IAAI,CAAA;KAAE,EACzD,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC,4BAA4B;IA0C/B,OAAO,CAAC,MAAM,CAAC,WAAW;IAK1B,OAAO,CAAC,MAAM,CAAC,aAAa;CAQ/B"}

package/dist/lib/modules/tournament/statistics/statistics.builder.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatisticsBuilder = void 0;
+class StatisticsBuilder {
+    static buildUserTournamentStats(participant, tournament, couponCodeMap) {
+        const selectedTeam = tournament.teams.find(t => t._id.toString() === participant.teamId.toString());
+        const matchViews = participant.predictions
+            .map(prediction => {
+            const match = tournament.matches.find(m => m._id.toString() === prediction.matchId.toString());
+            if (!match)
+                return null;
+            return {
+                id: match._id.toString(),
+                teams: `${match.team1.name} vs ${match.team2.name}`,
+                date: match.startingDate ? match.startingDate.toISOString() : null,
+                prediction: StatisticsBuilder.formatScore(prediction.score),
+                realScore: StatisticsBuilder.formatScore(match.score),
+                result: StatisticsBuilder.resolveResult(prediction.score, match.score),
+                coupon: prediction.coupon
+                    ? couponCodeMap.get(prediction.coupon.toString()) ?? null
+                    : null,
+            };
+        })
+            .filter((m) => m !== null);
+        return {
+            name: tournament.name,
+            joinedAt: participant.createdAt ?? null,
+            selectedTeam: {
+                name: selectedTeam?.name ?? 'Unknown',
+                flag: selectedTeam?.picture ?? null,
+            },
+            stats: {
+                predictionsMade: matchViews.length,
+                correctPredictions: matchViews.filter(m => m.result === 'won').length,
+                couponsWon: matchViews.filter(m => m.coupon != null).length,
+            },
+            matches: matchViews,
+        };
+    }
+    static formatScore(s) {
+        if (!s || s.team1 == null || s.team2 == null)
+            return null;
+        return `${s.team1} - ${s.team2}`;
+    }
+    static resolveResult(predicted, realScore) {
+        if (realScore?.team1 == null || realScore?.team2 == null)
+            return 'pending';
+        const correct = predicted?.team1 === realScore.team1 && predicted?.team2 === realScore.team2;
+        return correct ? 'won' : 'lost';
+    }
+}
+exports.StatisticsBuilder = StatisticsBuilder;
+//# sourceMappingURL=statistics.builder.js.map

package/dist/lib/modules/tournament/statistics/statistics.builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.builder.js","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { mongoose } from '@typegoose/typegoose';\nimport { TournamentParticipant, Tournament } from '@lyxa.ai/core/dist/libraries/mongo/models';\nimport { UserTournamentStatsOutputDTO } from './statistics.validation';\n\nexport class StatisticsBuilder {\n    static buildUserTournamentStats(\n        participant: TournamentParticipant & { createdAt?: Date },\n        tournament: Tournament,\n        couponCodeMap: Map<string, string>\n    ): UserTournamentStatsOutputDTO {\n        const selectedTeam = tournament.teams.find(\n            t => t._id.toString() === (participant.teamId as mongoose.Types.ObjectId).toString()\n        );\n\n        const matchViews = participant.predictions\n            .map(prediction => {\n                const match = tournament.matches.find(\n                    m => m._id.toString() === (prediction.matchId as mongoose.Types.ObjectId).toString()\n                );\n                if (!match) return null;\n\n                return {\n                    id: (match._id as mongoose.Types.ObjectId).toString(),\n                    teams: `${match.team1.name} vs ${match.team2.name}`,\n                    date: match.startingDate ? match.startingDate.toISOString() : null,\n                    prediction: StatisticsBuilder.formatScore(prediction.score),\n                    realScore: StatisticsBuilder.formatScore(match.score),\n                    result: StatisticsBuilder.resolveResult(prediction.score, match.score),\n                    coupon: prediction.coupon\n                        ? couponCodeMap.get((prediction.coupon as mongoose.Types.ObjectId).toString()) ?? null\n                        : null,\n                };\n            })\n            .filter((m): m is NonNullable<typeof m> => m !== null);\n\n        return {\n            name: tournament.name,\n            joinedAt: participant.createdAt ?? null,\n            selectedTeam: {\n                name: selectedTeam?.name ?? 'Unknown',\n                flag: selectedTeam?.picture ?? null,\n            },\n            stats: {\n                predictionsMade: matchViews.length,\n                correctPredictions: matchViews.filter(m => m.result === 'won').length,\n                couponsWon: matchViews.filter(m => m.coupon != null).length,\n            },\n            matches: matchViews,\n        };\n    }\n\n    private static formatScore(s: { team1: number | null; team2: number | null } | null | undefined): string | null {\n        if (!s || s.team1 == null || s.team2 == null) return null;\n        return `${s.team1} - ${s.team2}`;\n    }\n\n    private static resolveResult(\n        predicted: { team1: number | null; team2: number | null } | null | undefined,\n        realScore: { team1: number | null; team2: number | null } | null | undefined\n    ): 'won' | 'lost' | 'pending' {\n        if (realScore?.team1 == null || realScore?.team2 == null) return 'pending';\n        const correct = predicted?.team1 === realScore.team1 && predicted?.team2 === realScore.team2;\n        return correct ? 'won' : 'lost';\n    }\n}\n"]}

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

@@ -0,0 +1,80 @@
+import { mongoose } from '@typegoose/typegoose';
+export declare const statisticsRouter: 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 | 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;
+    }>;
+}>>;
+//# sourceMappingURL=statistics.router.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.router.d.ts","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAShD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAU3B,CAAC"}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statisticsRouter = void 0;
+const typegoose_1 = require("@typegoose/typegoose");
+const trpc_1 = require("@lyxa.ai/core/dist/libraries/trpc");
+const auth_1 = require("@lyxa.ai/core/dist/libraries/auth");
+const auth_2 = require("@lyxa.ai/core/dist/libraries/trpc/middlewares/auth");
+const error_handler_1 = require("@lyxa.ai/core/dist/utilities/error-handler");
+const response_1 = require("@lyxa.ai/core/dist/utilities/response");
+const statistics_service_1 = require("./statistics.service");
+const statistics_validation_1 = require("./statistics.validation");
+exports.statisticsRouter = (0, trpc_1.createTRPCRouter)({
+    getActiveByUser: (0, auth_2.createAuthenticatedProcedure)({ entityTypes: [auth_1.AuthEntityType.CRM] })
+        .input(statistics_validation_1.GetUserTournamentStatsSchema)
+        .output(statistics_validation_1.UserTournamentStatsResponseSchema)
+        .query(async ({ input }) => error_handler_1.ErrorHandler.wrapAsync(async () => {
+        const result = await statistics_service_1.statisticsService.getActiveByUser(new typegoose_1.mongoose.Types.ObjectId(input.userId));
+        return (0, response_1.response)('User tournament stats fetched successfully', result);
+    })),
+});
+//# sourceMappingURL=statistics.router.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.router.js","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.router.ts"],"names":[],"mappings":";;;AAAA,oDAAgD;AAChD,4DAAqE;AACrE,4DAAmE;AACnE,6EAAkG;AAClG,8EAA0E;AAC1E,oEAAiE;AACjE,6DAAoE;AACpE,mEAA0G;AAE7F,QAAA,gBAAgB,GAAG,IAAA,uBAAgB,EAAC;IAChD,eAAe,EAAE,IAAA,mCAA4B,EAAC,EAAE,WAAW,EAAE,CAAC,qBAAc,CAAC,GAAG,CAAC,EAAE,CAAC;SAClF,KAAK,CAAC,oDAA4B,CAAC;SACnC,MAAM,CAAC,yDAAiC,CAAC;SACzC,KAAK,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAC1B,4BAAY,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE;QACjC,MAAM,MAAM,GAAG,MAAM,sCAAO,CAAC,eAAe,CAAC,IAAI,oBAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;QACxF,OAAO,IAAA,mBAAQ,EAAC,4CAA4C,EAAE,MAAM,CAAC,CAAC;IACvE,CAAC,CAAC,CACF;CACF,CAAC,CAAC","sourcesContent":["import { mongoose } from '@typegoose/typegoose';\nimport { createTRPCRouter } from '@lyxa.ai/core/dist/libraries/trpc';\nimport { AuthEntityType } from '@lyxa.ai/core/dist/libraries/auth';\nimport { createAuthenticatedProcedure } from '@lyxa.ai/core/dist/libraries/trpc/middlewares/auth';\nimport { ErrorHandler } from '@lyxa.ai/core/dist/utilities/error-handler';\nimport { response } from '@lyxa.ai/core/dist/utilities/response';\nimport { statisticsService as service } from './statistics.service';\nimport { GetUserTournamentStatsSchema, UserTournamentStatsResponseSchema } from './statistics.validation';\n\nexport const statisticsRouter = createTRPCRouter({\n\tgetActiveByUser: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(GetUserTournamentStatsSchema)\n\t\t.output(UserTournamentStatsResponseSchema)\n\t\t.query(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.getActiveByUser(new mongoose.Types.ObjectId(input.userId));\n\t\t\t\treturn response('User tournament stats fetched successfully', result);\n\t\t\t})\n\t\t),\n});\n"]}

package/dist/lib/modules/tournament/statistics/statistics.service.d.ts

@@ -0,0 +1,11 @@
+import { mongoose } from '@typegoose/typegoose';
+import { UserTournamentStatsOutputDTO } from './statistics.validation';
+export declare class StatisticsService {
+    private participantRepository;
+    private configRepository;
+    private rewardRepository;
+    constructor();
+    getActiveByUser(userId: mongoose.Types.ObjectId): Promise<UserTournamentStatsOutputDTO | null>;
+}
+export declare const statisticsService: StatisticsService;
+//# sourceMappingURL=statistics.service.d.ts.map

package/dist/lib/modules/tournament/statistics/statistics.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.service.d.ts","sourceRoot":"/","sources":["modules/tournament/statistics/statistics.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAKhD,OAAO,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAC;AAEvE,qBACa,iBAAiB;IAC1B,OAAO,CAAC,qBAAqB,CAAkC;IAC/D,OAAO,CAAC,gBAAgB,CAA6B;IACrD,OAAO,CAAC,gBAAgB,CAAmB;;IAQ9B,eAAe,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC;CAkB9G;AAED,eAAO,MAAM,iBAAiB,mBAAmC,CAAC"}