@lyxa.ai/marketing 1.0.47 → 1.0.49

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

@@ -0,0 +1,352 @@
+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;
+                startingDate: string | Date;
+                team1Id: string | import("mongoose").Types.ObjectId;
+                team2Id: string | import("mongoose").Types.ObjectId;
+                endDate?: string | Date | undefined;
+                additionalTag?: string | undefined;
+            }[];
+        };
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                name: string;
+                tag: string;
+                _id?: string | import("mongoose").Types.ObjectId | undefined;
+                createdAt?: Date | null | undefined;
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+                updatedAt?: Date | null | undefined;
+                reward?: {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                } | {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                    maxDiscountPerOrder?: number | null | undefined;
+                    couponNamePrefix?: string | undefined;
+                    percentage?: number | undefined;
+                } | undefined;
+            } | {
+                documents: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    name: string;
+                    tag: string;
+                    _id?: string | import("mongoose").Types.ObjectId | undefined;
+                    createdAt?: Date | null | undefined;
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                    updatedAt?: Date | null | undefined;
+                    reward?: {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                    } | {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                        maxDiscountPerOrder?: number | null | undefined;
+                        couponNamePrefix?: string | undefined;
+                        percentage?: number | 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;
+                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;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    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;
+    }>;
+    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;
+                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;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    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;
+    }>;
+    end: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            finalScore?: {
+                team1: number;
+                team2: number;
+            } | 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;
+                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;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    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;
+    }>;
+    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;
+                name: string;
+                tag: string;
+                _id?: string | import("mongoose").Types.ObjectId | undefined;
+                createdAt?: Date | null | undefined;
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+                updatedAt?: Date | null | undefined;
+                reward?: {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                } | {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                    maxDiscountPerOrder?: number | null | undefined;
+                    couponNamePrefix?: string | undefined;
+                    percentage?: number | undefined;
+                } | undefined;
+            } | {
+                documents: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    name: string;
+                    tag: string;
+                    _id?: string | import("mongoose").Types.ObjectId | undefined;
+                    createdAt?: Date | null | undefined;
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                    updatedAt?: Date | null | undefined;
+                    reward?: {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                    } | {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                        maxDiscountPerOrder?: number | null | undefined;
+                        couponNamePrefix?: string | undefined;
+                        percentage?: number | undefined;
+                    } | undefined;
+                }[];
+                metadata?: {
+                    page: number;
+                    size: number;
+                    totalElements: number;
+                    totalPages: number;
+                } | undefined;
+            } | undefined;
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=match.router.d.ts.map

package/dist/types/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDtB,CAAC"}

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

@@ -0,0 +1,19 @@
+import { mongoose } from '@typegoose/typegoose';
+import { AddTournamentMatchesInputDTO, EndTournamentMatchInputDTO, StartTournamentMatchInputDTO, TournamentMatchOutputDTO } from './match.validation';
+import { TournamentConfigOutputDTO } from '../config/config.validation';
+export declare class MatchService {
+    private repository;
+    private notificationScheduler;
+    constructor();
+    private getTournament;
+    private getMatch;
+    private resolveMatchTeams;
+    private applyMatchUpdate;
+    add(input: AddTournamentMatchesInputDTO): Promise<TournamentConfigOutputDTO>;
+    getAll(tournamentId: mongoose.Types.ObjectId): Promise<TournamentMatchOutputDTO[]>;
+    start(input: StartTournamentMatchInputDTO): 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/types/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":"AACA,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAG9C,OAAO,EACH,4BAA4B,EAC5B,0BAA0B,EAC1B,4BAA4B,EAC5B,wBAAwB,EAC3B,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAC,yBAAyB,EAAC,MAAM,6BAA6B,CAAC;AAKtE,qBACa,YAAY;IACrB,OAAO,CAAC,UAAU,CAA4B;IAC9C,OAAO,CAAC,qBAAqB,CAA+B;;YAO9C,aAAa;IAM3B,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,iBAAiB;YAQX,gBAAgB;IAYjB,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;IAW7E,GAAG,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAsBzE,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"}