@lyxa.ai/marketing 1.0.48 → 1.0.50

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

@@ -0,0 +1,27 @@
+export declare const scheduleRouter: 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;
+    }>;
+}>>;
+//# sourceMappingURL=schedule.router.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.router.d.ts","sourceRoot":"/","sources":["modules/tournament/schedule/schedule.router.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;GAQzB,CAAC"}

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

@@ -0,0 +1,10 @@
+export declare class ScheduleService {
+    private configRepository;
+    private matchRepository;
+    private templateRepository;
+    private notificationService;
+    constructor();
+    dispatchPending(): Promise<void>;
+}
+export declare const scheduleDispatchService: ScheduleService;
+//# sourceMappingURL=schedule.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.service.d.ts","sourceRoot":"/","sources":["modules/tournament/schedule/schedule.service.ts"],"names":[],"mappings":"AAMA,qBACa,eAAe;IACxB,OAAO,CAAC,gBAAgB,CAA6B;IACrD,OAAO,CAAC,eAAe,CAA4B;IACnD,OAAO,CAAC,kBAAkB,CAAiC;IAC3D,OAAO,CAAC,mBAAmB,CAAgC;;IAS9C,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;CAyBhD;AAED,eAAO,MAAM,uBAAuB,iBAAiC,CAAC"}

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

@@ -0,0 +1,13 @@
+import { mongoose } from '@typegoose/typegoose';
+import { Tournament as Model } from '@lyxa.ai/core/dist/libraries/mongo/models';
+export declare class ScoreRepository {
+    private model;
+    constructor();
+    findMatchInTournament(tournamentId: mongoose.Types.ObjectId, matchId: mongoose.Types.ObjectId): Promise<Model | null>;
+    updateMatchScore(tournamentId: mongoose.Types.ObjectId, matchId: mongoose.Types.ObjectId, score: {
+        team1: number;
+        team2: number;
+    }): Promise<Model | null>;
+}
+export declare const scoreRepository: ScoreRepository;
+//# sourceMappingURL=score.repository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"score.repository.d.ts","sourceRoot":"/","sources":["modules/tournament/score/score.repository.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAC,UAAU,IAAI,KAAK,EAAkB,MAAM,2CAA2C,CAAC;AAE/F,qBACa,eAAe;IACxB,OAAO,CAAC,KAAK,CAAyB;;IAMhC,qBAAqB,CAAC,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAMrH,gBAAgB,CAClB,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EACrC,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAChC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GACxC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;CAS3B;AAED,eAAO,MAAM,eAAe,iBAAiC,CAAC"}

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

@@ -0,0 +1,98 @@
+export declare const scoreRouter: 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;
+    }>;
+}>>;
+//# sourceMappingURL=score.router.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"score.router.d.ts","sourceRoot":"/","sources":["modules/tournament/score/score.router.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAUtB,CAAC"}

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

@@ -0,0 +1,13 @@
+import { UpdateMatchScoreInputDTO } from './score.validation';
+import { TournamentMatchOutputDTO } from '../match/match.validation';
+export declare class ScoreService {
+    private repository;
+    constructor();
+    private getMatch;
+    private resolveScore;
+    private resolveWinner;
+    private extractUpdatedMatch;
+    updateMatchScore(input: UpdateMatchScoreInputDTO): Promise<TournamentMatchOutputDTO>;
+}
+export declare const scoreService: ScoreService;
+//# sourceMappingURL=score.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"score.service.d.ts","sourceRoot":"/","sources":["modules/tournament/score/score.service.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAErE,qBACa,YAAY;IACrB,OAAO,CAAC,UAAU,CAAkB;;YAMtB,QAAQ;IAQtB,OAAO,CAAC,YAAY;IAuBpB,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,mBAAmB;IASd,gBAAgB,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC;CASpG;AAED,eAAO,MAAM,YAAY,cAA8B,CAAC"}

package/dist/types/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/types/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/types/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/types/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/types/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/types/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/types/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