@lyxa.ai/marketing 1.0.47 → 1.0.49

package/dist/lib/index.d.ts

@@ -6098,6 +6098,7 @@ declare const marketingMicroServiceRouter: import("@trpc/server").TRPCBuiltRoute
                         secondaryVendorCut?: number | undefined;
                     } | undefined;
                     couponDetails?: Record<string, unknown> | undefined;
+                    couponInfo?: Record<string, unknown> | undefined;
                 } | {
                     documents: {
                         message?: string | undefined;
@@ -6115,6 +6116,7 @@ declare const marketingMicroServiceRouter: import("@trpc/server").TRPCBuiltRoute
                             secondaryVendorCut?: number | undefined;
                         } | undefined;
                         couponDetails?: Record<string, unknown> | undefined;
+                        couponInfo?: Record<string, unknown> | undefined;
                     }[];
                     metadata?: {
                         page: number;
@@ -6155,6 +6157,7 @@ declare const marketingMicroServiceRouter: import("@trpc/server").TRPCBuiltRoute
                         secondaryVendorCut?: number | undefined;
                     } | undefined;
                     couponDetails?: Record<string, unknown> | undefined;
+                    couponInfo?: Record<string, unknown> | undefined;
                 } | {
                     documents: {
                         message?: string | undefined;
@@ -6172,6 +6175,7 @@ declare const marketingMicroServiceRouter: import("@trpc/server").TRPCBuiltRoute
                             secondaryVendorCut?: number | undefined;
                         } | undefined;
                         couponDetails?: Record<string, unknown> | undefined;
+                        couponInfo?: Record<string, unknown> | undefined;
                     }[];
                     metadata?: {
                         page: number;
@@ -6481,8 +6485,8 @@ declare const marketingMicroServiceRouter: import("@trpc/server").TRPCBuiltRoute
             input: {
                 user: string | import("mongoose").Types.ObjectId;
                 shop: string | import("mongoose").Types.ObjectId;
-                minimumOrderValue: number;
                 marketing: string | import("mongoose").Types.ObjectId;
+                minimumOrderValue: number;
                 targetOrder: number;
                 couponValueType: import("@lyxa.ai/core/dist/utilities/enum").ValueType;
                 couponValue: number;
@@ -7523,37 +7527,26 @@ declare const marketingMicroServiceRouter: import("@trpc/server").TRPCBuiltRoute
                 meta: object;
             }>;
             getActive: import("@trpc/server").TRPCQueryProcedure<{
-                input: void;
+                input: {
+                    latitude?: number | undefined;
+                    longitude?: number | undefined;
+                };
                 output: {
                     message: string;
                     success: boolean;
                     data?: {
-                        status: import("@lyxa.ai/core/dist/utilities/enum").LimitedTimeOfferCampaignStatus;
                         _id: string | import("mongoose").Types.ObjectId;
-                        campaignNumber: number;
-                        createdAt?: Date | null | undefined;
-                        startDate?: Date | null | undefined;
-                        endDate?: Date | null | undefined;
-                        updatedAt?: Date | null | undefined;
                         title?: string | undefined;
-                        subTitle?: string | undefined;
-                        discountOptions?: number[] | undefined;
-                        maxDiscountCaps?: number[] | undefined;
-                        archivedAt?: Date | null | undefined;
+                        subtitle?: string | undefined;
+                        startTime?: Date | null | undefined;
+                        endTime?: Date | null | undefined;
                     } | {
                         documents: ({
-                            status: import("@lyxa.ai/core/dist/utilities/enum").LimitedTimeOfferCampaignStatus;
                             _id: string | import("mongoose").Types.ObjectId;
-                            campaignNumber: number;
-                            createdAt?: Date | null | undefined;
-                            startDate?: Date | null | undefined;
-                            endDate?: Date | null | undefined;
-                            updatedAt?: Date | null | undefined;
                             title?: string | undefined;
-                            subTitle?: string | undefined;
-                            discountOptions?: number[] | undefined;
-                            maxDiscountCaps?: number[] | undefined;
-                            archivedAt?: Date | null | undefined;
+                            subtitle?: string | undefined;
+                            startTime?: Date | null | undefined;
+                            endTime?: Date | null | undefined;
                         } | null)[];
                         metadata?: {
                             page: number;
@@ -7741,8 +7734,8 @@ declare const marketingMicroServiceRouter: import("@trpc/server").TRPCBuiltRoute
                     data?: {
                         _id: string | import("mongoose").Types.ObjectId;
                         shop: string | import("mongoose").Types.ObjectId;
-                        joinedAt: Date;
                         isEntireMenu: boolean;
+                        joinedAt: Date;
                         campaign: string | import("mongoose").Types.ObjectId;
                         isOrderCapacityEnabled: boolean;
                         isWithdrawn: boolean;
@@ -7757,8 +7750,8 @@ declare const marketingMicroServiceRouter: import("@trpc/server").TRPCBuiltRoute
                         documents: {
                             _id: string | import("mongoose").Types.ObjectId;
                             shop: string | import("mongoose").Types.ObjectId;
-                            joinedAt: Date;
                             isEntireMenu: boolean;
+                            joinedAt: Date;
                             campaign: string | import("mongoose").Types.ObjectId;
                             isOrderCapacityEnabled: boolean;
                             isWithdrawn: boolean;
@@ -7795,8 +7788,8 @@ declare const marketingMicroServiceRouter: import("@trpc/server").TRPCBuiltRoute
                     data?: {
                         _id: string | import("mongoose").Types.ObjectId;
                         shop: string | import("mongoose").Types.ObjectId;
-                        joinedAt: Date;
                         isEntireMenu: boolean;
+                        joinedAt: Date;
                         campaign: string | import("mongoose").Types.ObjectId;
                         isOrderCapacityEnabled: boolean;
                         isWithdrawn: boolean;
@@ -7811,8 +7804,8 @@ declare const marketingMicroServiceRouter: import("@trpc/server").TRPCBuiltRoute
                         documents: {
                             _id: string | import("mongoose").Types.ObjectId;
                             shop: string | import("mongoose").Types.ObjectId;
-                            joinedAt: Date;
                             isEntireMenu: boolean;
+                            joinedAt: Date;
                             campaign: string | import("mongoose").Types.ObjectId;
                             isOrderCapacityEnabled: boolean;
                             isWithdrawn: boolean;
@@ -7859,8 +7852,8 @@ declare const marketingMicroServiceRouter: import("@trpc/server").TRPCBuiltRoute
                             maxDiscountCaps?: number[] | undefined;
                         } | undefined;
                         participant?: {
-                            joinedAt: Date;
                             isEntireMenu: boolean;
+                            joinedAt: Date;
                             isOrderCapacityEnabled: boolean;
                             productIds?: (string | import("mongoose").Types.ObjectId)[] | undefined;
                             marketingId?: string | import("mongoose").Types.ObjectId | undefined;
@@ -7881,8 +7874,8 @@ declare const marketingMicroServiceRouter: import("@trpc/server").TRPCBuiltRoute
                                 maxDiscountCaps?: number[] | undefined;
                             } | undefined;
                             participant?: {
-                                joinedAt: Date;
                                 isEntireMenu: boolean;
+                                joinedAt: Date;
                                 isOrderCapacityEnabled: boolean;
                                 productIds?: (string | import("mongoose").Types.ObjectId)[] | undefined;
                                 marketingId?: string | import("mongoose").Types.ObjectId | undefined;
@@ -7937,6 +7930,1087 @@ declare const marketingMicroServiceRouter: import("@trpc/server").TRPCBuiltRoute
             }>;
         }>>;
     }>>;
+    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;
+        }>;
+    }>>;
 }>>;
 export type MarketingMicroServiceRouter = typeof marketingMicroServiceRouter;
 export {};