@lyxa.ai/marketing 1.0.47 → 1.0.49

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

@@ -0,0 +1,1082 @@
+export declare const tournamentRouter: 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<{
+    config: 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<{
+        create: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                name: string;
+                startDate: string | Date;
+                endDate: string | Date;
+                tag: string;
+                status?: import("@lyxa.ai/core/dist/utilities/enum").Status | undefined;
+                reward?: {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                } | {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                    couponNamePrefix: string;
+                    percentage: number;
+                    maxDiscountPerOrder?: number | null | undefined;
+                } | 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: void;
+            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;
+                        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;
+                            percentage?: number | undefined;
+                        } | undefined;
+                    }[][];
+                    metadata?: {
+                        page: number;
+                        size: number;
+                        totalElements: number;
+                        totalPages: number;
+                    } | undefined;
+                } | undefined;
+            };
+            meta: object;
+        }>;
+        getById: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                tournamentId: 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;
+        }>;
+        update: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                _id: string | import("mongoose").Types.ObjectId;
+                status?: import("@lyxa.ai/core/dist/utilities/enum").Status | undefined;
+                name?: string | undefined;
+                startDate?: string | Date | undefined;
+                endDate?: string | Date | undefined;
+                tag?: string | undefined;
+                reward?: {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                } | {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                    couponNamePrefix: string;
+                    percentage: number;
+                    maxDiscountPerOrder?: number | null | undefined;
+                } | 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;
+        }>;
+    }>>;
+    team: 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;
+                teams: {
+                    name: string;
+                    picture?: 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?: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    tag: string;
+                    tournamentId: string | import("mongoose").Types.ObjectId;
+                    teams: {
+                        name: string;
+                        _id: string | import("mongoose").Types.ObjectId;
+                        picture?: string | undefined;
+                    }[];
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                } | {
+                    documents: {
+                        status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                        tag: string;
+                        tournamentId: string | import("mongoose").Types.ObjectId;
+                        teams: {
+                            name: string;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            picture?: string | undefined;
+                        }[];
+                        startDate?: Date | null | undefined;
+                        endDate?: Date | null | undefined;
+                    }[];
+                    metadata?: {
+                        page: number;
+                        size: number;
+                        totalElements: number;
+                        totalPages: number;
+                    } | undefined;
+                } | undefined;
+            };
+            meta: object;
+        }>;
+        getMatches: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                filter: "completed" | "upcoming";
+                tournamentId: string | import("mongoose").Types.ObjectId;
+            };
+            output: {
+                message: string;
+                success: boolean;
+                data?: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    tag: string;
+                    tournamentId: string | import("mongoose").Types.ObjectId;
+                    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;
+                        prediction: {
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            succeeded: boolean | null;
+                        } | null;
+                        canPredict: boolean;
+                        endDate?: Date | null | undefined;
+                        additionalTag?: string | undefined;
+                        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                        startingDate?: Date | null | undefined;
+                    }[];
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                } | {
+                    documents: {
+                        status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                        tag: string;
+                        tournamentId: string | import("mongoose").Types.ObjectId;
+                        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;
+                            prediction: {
+                                score: {
+                                    team1: number | null;
+                                    team2: number | null;
+                                };
+                                succeeded: boolean | null;
+                            } | null;
+                            canPredict: boolean;
+                            endDate?: Date | null | undefined;
+                            additionalTag?: string | undefined;
+                            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                            startingDate?: Date | null | undefined;
+                        }[];
+                        startDate?: Date | null | undefined;
+                        endDate?: Date | null | undefined;
+                    }[];
+                    metadata?: {
+                        page: number;
+                        size: number;
+                        totalElements: number;
+                        totalPages: number;
+                    } | undefined;
+                } | undefined;
+            };
+            meta: object;
+        }>;
+    }>>;
+    match: 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;
+        }>;
+    }>>;
+    participant: 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<{
+        join: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                tournamentId: string | import("mongoose").Types.ObjectId;
+                teamId: string | import("mongoose").Types.ObjectId;
+            };
+            output: {
+                message: string;
+                success: boolean;
+                data?: {
+                    _id: string | import("mongoose").Types.ObjectId;
+                    tournamentId: string | import("mongoose").Types.ObjectId;
+                    teamId: string | import("mongoose").Types.ObjectId;
+                    createdAt?: Date | null | undefined;
+                } | {
+                    documents: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        tournamentId: string | import("mongoose").Types.ObjectId;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                        createdAt?: Date | null | 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;
+                    userId: string | import("mongoose").Types.ObjectId;
+                    tournamentId: string | import("mongoose").Types.ObjectId;
+                    teamId: string | import("mongoose").Types.ObjectId;
+                    createdAt?: Date | null | undefined;
+                    updatedAt?: Date | null | undefined;
+                    predictions?: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        matchId: string | import("mongoose").Types.ObjectId;
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        coupon?: string | import("mongoose").Types.ObjectId | undefined;
+                        predictionTime?: Date | null | undefined;
+                        succeeded?: boolean | null | undefined;
+                    }[] | undefined;
+                }[] | {
+                    documents: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        userId: string | import("mongoose").Types.ObjectId;
+                        tournamentId: string | import("mongoose").Types.ObjectId;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                        createdAt?: Date | null | undefined;
+                        updatedAt?: Date | null | undefined;
+                        predictions?: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            matchId: string | import("mongoose").Types.ObjectId;
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            coupon?: string | import("mongoose").Types.ObjectId | undefined;
+                            predictionTime?: Date | null | undefined;
+                            succeeded?: boolean | null | undefined;
+                        }[] | undefined;
+                    }[][];
+                    metadata?: {
+                        page: number;
+                        size: number;
+                        totalElements: number;
+                        totalPages: number;
+                    } | undefined;
+                } | undefined;
+            };
+            meta: object;
+        }>;
+    }>>;
+    prediction: 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<{
+        create: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                tournamentId: string | import("mongoose").Types.ObjectId;
+                matchId: string | import("mongoose").Types.ObjectId;
+                score: {
+                    team1: number;
+                    team2: number;
+                };
+            };
+            output: {
+                message: string;
+                success: boolean;
+                data?: {
+                    _id: string | import("mongoose").Types.ObjectId;
+                    matchId: string | import("mongoose").Types.ObjectId;
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                } | {
+                    documents: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        matchId: string | import("mongoose").Types.ObjectId;
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                    }[];
+                    metadata?: {
+                        page: number;
+                        size: number;
+                        totalElements: number;
+                        totalPages: number;
+                    } | undefined;
+                } | undefined;
+            };
+            meta: object;
+        }>;
+        edit: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                tournamentId: string | import("mongoose").Types.ObjectId;
+                matchId: string | import("mongoose").Types.ObjectId;
+                score: {
+                    team1: number;
+                    team2: number;
+                };
+            };
+            output: {
+                message: string;
+                success: boolean;
+                data?: {
+                    _id: string | import("mongoose").Types.ObjectId;
+                    matchId: string | import("mongoose").Types.ObjectId;
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                } | {
+                    documents: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        matchId: string | import("mongoose").Types.ObjectId;
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                    }[];
+                    metadata?: {
+                        page: number;
+                        size: number;
+                        totalElements: number;
+                        totalPages: number;
+                    } | undefined;
+                } | undefined;
+            };
+            meta: object;
+        }>;
+        get: import("@trpc/server").TRPCQueryProcedure<{
+            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;
+                    matchId: string | import("mongoose").Types.ObjectId;
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    predictionTime?: Date | null | undefined;
+                    succeeded?: boolean | null | undefined;
+                } | {
+                    documents: ({
+                        _id: string | import("mongoose").Types.ObjectId;
+                        matchId: string | import("mongoose").Types.ObjectId;
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        predictionTime?: Date | null | undefined;
+                        succeeded?: boolean | null | undefined;
+                    } | null)[];
+                    metadata?: {
+                        page: number;
+                        size: number;
+                        totalElements: number;
+                        totalPages: number;
+                    } | undefined;
+                } | null | undefined;
+            };
+            meta: object;
+        }>;
+    }>>;
+    getActive: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                name: string;
+                tag: string;
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+            } | {
+                documents: ({
+                    name: string;
+                    tag: string;
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                } | null)[];
+                metadata?: {
+                    page: number;
+                    size: number;
+                    totalElements: number;
+                    totalPages: number;
+                } | undefined;
+            } | null | undefined;
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=tournament.router.d.ts.map