@lyxa.ai/marketing 1.0.47 → 1.0.48

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

@@ -0,0 +1,489 @@
+export declare const matchRouter: 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<{
+    add: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            matches: {
+                stage: string;
+                team1Id: string | import("mongoose").Types.ObjectId;
+                team2Id: string | import("mongoose").Types.ObjectId;
+                startingDate: string | Date;
+                endDate?: string | Date | undefined;
+                additionalTag?: string | undefined;
+            }[];
+        };
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                _id: string | import("mongoose").Types.ObjectId;
+                tag: string;
+                createdAt?: Date | null | undefined;
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+                updatedAt?: Date | null | undefined;
+                matches?: {
+                    _id: string | import("mongoose").Types.ObjectId;
+                    team1: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    stage: string;
+                    endDate?: Date | null | undefined;
+                    startingDate?: Date | null | undefined;
+                    additionalTag?: string | undefined;
+                    winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                }[] | undefined;
+                teams?: {
+                    name: string;
+                    _id: string | import("mongoose").Types.ObjectId;
+                    picture?: string | null | undefined;
+                }[] | undefined;
+            } | {
+                documents: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    _id: string | import("mongoose").Types.ObjectId;
+                    tag: string;
+                    createdAt?: Date | null | undefined;
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                    updatedAt?: Date | null | undefined;
+                    matches?: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        team1: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        team2: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        stage: string;
+                        endDate?: Date | null | undefined;
+                        startingDate?: Date | null | undefined;
+                        additionalTag?: string | undefined;
+                        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                    }[] | undefined;
+                    teams?: {
+                        name: string;
+                        _id: string | import("mongoose").Types.ObjectId;
+                        picture?: string | null | undefined;
+                    }[] | undefined;
+                }[];
+                metadata?: {
+                    page: number;
+                    size: number;
+                    totalElements: number;
+                    totalPages: number;
+                } | undefined;
+            } | undefined;
+        };
+        meta: object;
+    }>;
+    getAll: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            tournamentId: 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;
+                };
+                team2: {
+                    name: string;
+                    teamId: string | import("mongoose").Types.ObjectId;
+                };
+                score: {
+                    team1: number | null;
+                    team2: number | null;
+                };
+                stage: string;
+                endDate?: Date | null | undefined;
+                startingDate?: Date | null | undefined;
+                additionalTag?: string | undefined;
+                winnerId?: string | import("mongoose").Types.ObjectId | 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;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    stage: string;
+                    endDate?: Date | null | undefined;
+                    startingDate?: Date | null | undefined;
+                    additionalTag?: string | undefined;
+                    winnerId?: string | import("mongoose").Types.ObjectId | 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;
+    }>;
+    start: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            matchId: 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;
+                };
+                team2: {
+                    name: string;
+                    teamId: string | import("mongoose").Types.ObjectId;
+                };
+                score: {
+                    team1: number | null;
+                    team2: number | null;
+                };
+                stage: string;
+                endDate?: Date | null | undefined;
+                startingDate?: Date | null | undefined;
+                additionalTag?: string | undefined;
+                winnerId?: string | import("mongoose").Types.ObjectId | 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;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    stage: string;
+                    endDate?: Date | null | undefined;
+                    startingDate?: Date | null | undefined;
+                    additionalTag?: string | undefined;
+                    winnerId?: string | import("mongoose").Types.ObjectId | 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;
+    }>;
+    updateScore: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            team1Score: number;
+            team2Score: number;
+            winnerId?: string | import("mongoose").Types.ObjectId | undefined;
+        };
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                _id: string | import("mongoose").Types.ObjectId;
+                team1: {
+                    name: string;
+                    teamId: string | import("mongoose").Types.ObjectId;
+                };
+                team2: {
+                    name: string;
+                    teamId: string | import("mongoose").Types.ObjectId;
+                };
+                score: {
+                    team1: number | null;
+                    team2: number | null;
+                };
+                stage: string;
+                endDate?: Date | null | undefined;
+                startingDate?: Date | null | undefined;
+                additionalTag?: string | undefined;
+                winnerId?: string | import("mongoose").Types.ObjectId | 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;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    stage: string;
+                    endDate?: Date | null | undefined;
+                    startingDate?: Date | null | undefined;
+                    additionalTag?: string | undefined;
+                    winnerId?: string | import("mongoose").Types.ObjectId | 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;
+    }>;
+    end: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            endDate?: string | Date | undefined;
+            winnerId?: string | import("mongoose").Types.ObjectId | undefined;
+        };
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                _id: string | import("mongoose").Types.ObjectId;
+                team1: {
+                    name: string;
+                    teamId: string | import("mongoose").Types.ObjectId;
+                };
+                team2: {
+                    name: string;
+                    teamId: string | import("mongoose").Types.ObjectId;
+                };
+                score: {
+                    team1: number | null;
+                    team2: number | null;
+                };
+                stage: string;
+                endDate?: Date | null | undefined;
+                startingDate?: Date | null | undefined;
+                additionalTag?: string | undefined;
+                winnerId?: string | import("mongoose").Types.ObjectId | 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;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    stage: string;
+                    endDate?: Date | null | undefined;
+                    startingDate?: Date | null | undefined;
+                    additionalTag?: string | undefined;
+                    winnerId?: string | import("mongoose").Types.ObjectId | 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;
+    }>;
+    delete: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+        };
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                _id: string | import("mongoose").Types.ObjectId;
+                tag: string;
+                createdAt?: Date | null | undefined;
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+                updatedAt?: Date | null | undefined;
+                matches?: {
+                    _id: string | import("mongoose").Types.ObjectId;
+                    team1: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    stage: string;
+                    endDate?: Date | null | undefined;
+                    startingDate?: Date | null | undefined;
+                    additionalTag?: string | undefined;
+                    winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                }[] | undefined;
+                teams?: {
+                    name: string;
+                    _id: string | import("mongoose").Types.ObjectId;
+                    picture?: string | null | undefined;
+                }[] | undefined;
+            } | {
+                documents: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    _id: string | import("mongoose").Types.ObjectId;
+                    tag: string;
+                    createdAt?: Date | null | undefined;
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                    updatedAt?: Date | null | undefined;
+                    matches?: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        team1: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        team2: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        stage: string;
+                        endDate?: Date | null | undefined;
+                        startingDate?: Date | null | undefined;
+                        additionalTag?: string | undefined;
+                        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                    }[] | undefined;
+                    teams?: {
+                        name: string;
+                        _id: string | import("mongoose").Types.ObjectId;
+                        picture?: string | null | undefined;
+                    }[] | undefined;
+                }[];
+                metadata?: {
+                    page: number;
+                    size: number;
+                    totalElements: number;
+                    totalPages: number;
+                } | undefined;
+            } | undefined;
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=match.router.d.ts.map

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

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

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchRouter = void 0;
+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 match_service_1 = require("./match.service");
+const match_validation_1 = require("./match.validation");
+const config_validation_1 = require("../config/config.validation");
+exports.matchRouter = (0, trpc_1.createTRPCRouter)({
+    add: (0, auth_2.createAuthenticatedProcedure)({ entityTypes: [auth_1.AuthEntityType.CRM] })
+        .input(match_validation_1.AddTournamentMatchesSchema)
+        .output(config_validation_1.TournamentConfigResponseSchema)
+        .mutation(async ({ input }) => error_handler_1.ErrorHandler.wrapAsync(async () => {
+        const result = await match_service_1.matchService.add(input);
+        return (0, response_1.response)('Matches added successfully', result);
+    })),
+    getAll: trpc_1.publicProcedure
+        .input(match_validation_1.GetTournamentMatchesSchema)
+        .output(match_validation_1.TournamentMatchListResponseSchema)
+        .query(async ({ input }) => error_handler_1.ErrorHandler.wrapAsync(async () => {
+        const result = await match_service_1.matchService.getAll(input.tournamentId);
+        return (0, response_1.response)('Matches fetched successfully', result);
+    })),
+    start: (0, auth_2.createAuthenticatedProcedure)({ entityTypes: [auth_1.AuthEntityType.CRM] })
+        .input(match_validation_1.StartTournamentMatchSchema)
+        .output(match_validation_1.TournamentMatchResponseSchema)
+        .mutation(async ({ input }) => error_handler_1.ErrorHandler.wrapAsync(async () => {
+        const result = await match_service_1.matchService.start(input);
+        return (0, response_1.response)('Match started successfully', result);
+    })),
+    updateScore: (0, auth_2.createAuthenticatedProcedure)({ entityTypes: [auth_1.AuthEntityType.CRM] })
+        .input(match_validation_1.UpdateMatchScoreSchema)
+        .output(match_validation_1.TournamentMatchResponseSchema)
+        .mutation(async ({ input }) => error_handler_1.ErrorHandler.wrapAsync(async () => {
+        const result = await match_service_1.matchService.updateScore(input);
+        return (0, response_1.response)('Match score updated successfully', result);
+    })),
+    end: (0, auth_2.createAuthenticatedProcedure)({ entityTypes: [auth_1.AuthEntityType.CRM] })
+        .input(match_validation_1.EndTournamentMatchSchema)
+        .output(match_validation_1.TournamentMatchResponseSchema)
+        .mutation(async ({ input }) => error_handler_1.ErrorHandler.wrapAsync(async () => {
+        const result = await match_service_1.matchService.end(input);
+        return (0, response_1.response)('Match ended successfully', result);
+    })),
+    delete: (0, auth_2.createAuthenticatedProcedure)({ entityTypes: [auth_1.AuthEntityType.CRM] })
+        .input(match_validation_1.EndTournamentMatchSchema.pick({ tournamentId: true, matchId: true }))
+        .output(config_validation_1.TournamentConfigResponseSchema)
+        .mutation(async ({ input }) => error_handler_1.ErrorHandler.wrapAsync(async () => {
+        const result = await match_service_1.matchService.delete(input.tournamentId, input.matchId);
+        return (0, response_1.response)('Match deleted successfully', result);
+    })),
+});
+//# sourceMappingURL=match.router.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"match.router.js","sourceRoot":"/","sources":["modules/tournament/match/match.router.ts"],"names":[],"mappings":"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","sourcesContent":["import { createTRPCRouter, publicProcedure } 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 { matchService as service } from './match.service';\nimport {\n\tAddTournamentMatchesSchema,\n\tEndTournamentMatchSchema,\n\tGetTournamentMatchesSchema,\n\tStartTournamentMatchSchema,\n\tTournamentMatchListResponseSchema,\n\tTournamentMatchResponseSchema,\n\tUpdateMatchScoreSchema,\n} from './match.validation';\nimport { TournamentConfigResponseSchema } from '../config/config.validation';\n\nexport const matchRouter = createTRPCRouter({\n\tadd: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(AddTournamentMatchesSchema)\n\t\t.output(TournamentConfigResponseSchema)\n\t\t.mutation(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.add(input);\n\t\t\t\treturn response('Matches added successfully', result);\n\t\t\t})\n\t\t),\n\n\tgetAll: publicProcedure\n\t\t.input(GetTournamentMatchesSchema)\n\t\t.output(TournamentMatchListResponseSchema)\n\t\t.query(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.getAll(input.tournamentId);\n\t\t\t\treturn response('Matches fetched successfully', result);\n\t\t\t})\n\t\t),\n\n\tstart: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(StartTournamentMatchSchema)\n\t\t.output(TournamentMatchResponseSchema)\n\t\t.mutation(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.start(input);\n\t\t\t\treturn response('Match started successfully', result);\n\t\t\t})\n\t\t),\n\n\tupdateScore: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(UpdateMatchScoreSchema)\n\t\t.output(TournamentMatchResponseSchema)\n\t\t.mutation(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.updateScore(input);\n\t\t\t\treturn response('Match score updated successfully', result);\n\t\t\t})\n\t\t),\n\n\tend: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(EndTournamentMatchSchema)\n\t\t.output(TournamentMatchResponseSchema)\n\t\t.mutation(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.end(input);\n\t\t\t\treturn response('Match ended successfully', result);\n\t\t\t})\n\t\t),\n\n\tdelete: createAuthenticatedProcedure({ entityTypes: [AuthEntityType.CRM] })\n\t\t.input(EndTournamentMatchSchema.pick({ tournamentId: true, matchId: true }))\n\t\t.output(TournamentConfigResponseSchema)\n\t\t.mutation(async ({ input }) =>\n\t\t\tErrorHandler.wrapAsync(async () => {\n\t\t\t\tconst result = await service.delete(input.tournamentId, input.matchId);\n\t\t\t\treturn response('Match deleted successfully', result);\n\t\t\t})\n\t\t),\n});\n"]}

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

@@ -0,0 +1,29 @@
+import { mongoose } from '@typegoose/typegoose';
+import { AddTournamentMatchesInputDTO, EndTournamentMatchInputDTO, StartTournamentMatchInputDTO, TournamentMatchOutputDTO, UpdateMatchScoreInputDTO } from './match.validation';
+import { TournamentConfigOutputDTO } from '../config/config.validation';
+export declare class MatchService {
+    private repository;
+    private notificationScheduler;
+    private notificationService;
+    private participantService;
+    private predictionRepository;
+    private rewardService;
+    constructor();
+    private getTournament;
+    private getMatch;
+    private validateWinner;
+    private resolveMatchTeams;
+    private applyMatchUpdate;
+    handleMatchEnded(tournamentId: mongoose.Types.ObjectId, matchId: mongoose.Types.ObjectId, finalScore: {
+        team1: number;
+        team2: number;
+    }): Promise<void>;
+    add(input: AddTournamentMatchesInputDTO): Promise<TournamentConfigOutputDTO>;
+    getAll(tournamentId: mongoose.Types.ObjectId): Promise<TournamentMatchOutputDTO[]>;
+    start(input: StartTournamentMatchInputDTO): Promise<TournamentMatchOutputDTO>;
+    updateScore(input: UpdateMatchScoreInputDTO): Promise<TournamentMatchOutputDTO>;
+    end(input: EndTournamentMatchInputDTO): Promise<TournamentMatchOutputDTO>;
+    delete(tournamentId: mongoose.Types.ObjectId, matchId: mongoose.Types.ObjectId): Promise<TournamentConfigOutputDTO>;
+}
+export declare const matchService: MatchService;
+//# sourceMappingURL=match.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"match.service.d.ts","sourceRoot":"/","sources":["modules/tournament/match/match.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGhD,OAAO,EACH,4BAA4B,EAC5B,0BAA0B,EAC1B,4BAA4B,EAC5B,wBAAwB,EACxB,wBAAwB,EAC3B,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAYxE,qBACa,YAAY;IACrB,OAAO,CAAC,UAAU,CAA4B;IAC9C,OAAO,CAAC,qBAAqB,CAA+B;IAC5D,OAAO,CAAC,mBAAmB,CAAgC;IAC3D,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,oBAAoB,CAAuB;IACnD,OAAO,CAAC,aAAa,CAAgB;;YAWvB,aAAa;IAM3B,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,iBAAiB;YAQX,gBAAgB;IAajB,gBAAgB,CACzB,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EACrC,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAChC,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAC7C,OAAO,CAAC,IAAI,CAAC;IA8BH,GAAG,CAAC,KAAK,EAAE,4BAA4B,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAoB5E,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,wBAAwB,EAAE,CAAC;IAKlF,KAAK,CAAC,KAAK,EAAE,4BAA4B,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAgB7E,WAAW,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAO/E,GAAG,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAqBzE,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,yBAAyB,CAAC;CASnI;AAED,eAAO,MAAM,YAAY,cAA8B,CAAC"}