npm - @lyxa.ai/marketing - Versions diffs - 1.0.47 → 1.0.48 - Mend

@lyxa.ai/marketing 1.0.47 → 1.0.48

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (329) hide show

package/dist/types/index.d.ts CHANGED Viewed

@@ -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;
@@ -7741,8 +7745,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 +7761,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 +7799,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 +7815,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 +7863,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 +7885,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 +7941,1341 @@ 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: {
+                    startDate: string | Date;
+                    endDate: string | Date;
+                    tag: string;
+                    status?: import("@lyxa.ai/core/dist/utilities/enum").Status | undefined;
+                };
+                output: {
+                    message: string;
+                    success: boolean;
+                    data?: {
+                        status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                        _id: string | import("mongoose").Types.ObjectId;
+                        tag: string;
+                        createdAt?: Date | null | undefined;
+                        startDate?: Date | null | undefined;
+                        endDate?: Date | null | undefined;
+                        updatedAt?: Date | null | undefined;
+                        matches?: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            team1: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            team2: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            stage: string;
+                            endDate?: Date | null | undefined;
+                            startingDate?: Date | null | undefined;
+                            additionalTag?: string | undefined;
+                            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                        }[] | undefined;
+                        teams?: {
+                            name: string;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            picture?: string | null | undefined;
+                        }[] | undefined;
+                    } | {
+                        documents: {
+                            status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            tag: string;
+                            createdAt?: Date | null | undefined;
+                            startDate?: Date | null | undefined;
+                            endDate?: Date | null | undefined;
+                            updatedAt?: Date | null | undefined;
+                            matches?: {
+                                _id: string | import("mongoose").Types.ObjectId;
+                                team1: {
+                                    name: string;
+                                    teamId: string | import("mongoose").Types.ObjectId;
+                                };
+                                team2: {
+                                    name: string;
+                                    teamId: string | import("mongoose").Types.ObjectId;
+                                };
+                                score: {
+                                    team1: number | null;
+                                    team2: number | null;
+                                };
+                                stage: string;
+                                endDate?: Date | null | undefined;
+                                startingDate?: Date | null | undefined;
+                                additionalTag?: string | undefined;
+                                winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                            }[] | undefined;
+                            teams?: {
+                                name: string;
+                                _id: string | import("mongoose").Types.ObjectId;
+                                picture?: string | null | undefined;
+                            }[] | undefined;
+                        }[];
+                        metadata?: {
+                            page: number;
+                            size: number;
+                            totalElements: number;
+                            totalPages: number;
+                        } | undefined;
+                    } | undefined;
+                };
+                meta: object;
+            }>;
+            getAll: import("@trpc/server").TRPCQueryProcedure<{
+                input: void;
+                output: {
+                    message: string;
+                    success: boolean;
+                    data?: {
+                        status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                        _id: string | import("mongoose").Types.ObjectId;
+                        tag: string;
+                        createdAt?: Date | null | undefined;
+                        startDate?: Date | null | undefined;
+                        endDate?: Date | null | undefined;
+                        updatedAt?: Date | null | undefined;
+                        matches?: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            team1: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            team2: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            stage: string;
+                            endDate?: Date | null | undefined;
+                            startingDate?: Date | null | undefined;
+                            additionalTag?: string | undefined;
+                            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                        }[] | undefined;
+                        teams?: {
+                            name: string;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            picture?: string | null | undefined;
+                        }[] | undefined;
+                    }[] | {
+                        documents: {
+                            status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            tag: string;
+                            createdAt?: Date | null | undefined;
+                            startDate?: Date | null | undefined;
+                            endDate?: Date | null | undefined;
+                            updatedAt?: Date | null | undefined;
+                            matches?: {
+                                _id: string | import("mongoose").Types.ObjectId;
+                                team1: {
+                                    name: string;
+                                    teamId: string | import("mongoose").Types.ObjectId;
+                                };
+                                team2: {
+                                    name: string;
+                                    teamId: string | import("mongoose").Types.ObjectId;
+                                };
+                                score: {
+                                    team1: number | null;
+                                    team2: number | null;
+                                };
+                                stage: string;
+                                endDate?: Date | null | undefined;
+                                startingDate?: Date | null | undefined;
+                                additionalTag?: string | undefined;
+                                winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                            }[] | undefined;
+                            teams?: {
+                                name: string;
+                                _id: string | import("mongoose").Types.ObjectId;
+                                picture?: string | null | undefined;
+                            }[] | undefined;
+                        }[][];
+                        metadata?: {
+                            page: number;
+                            size: number;
+                            totalElements: number;
+                            totalPages: number;
+                        } | undefined;
+                    } | undefined;
+                };
+                meta: object;
+            }>;
+            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;
+                        _id: string | import("mongoose").Types.ObjectId;
+                        tag: string;
+                        createdAt?: Date | null | undefined;
+                        startDate?: Date | null | undefined;
+                        endDate?: Date | null | undefined;
+                        updatedAt?: Date | null | undefined;
+                        matches?: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            team1: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            team2: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            stage: string;
+                            endDate?: Date | null | undefined;
+                            startingDate?: Date | null | undefined;
+                            additionalTag?: string | undefined;
+                            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                        }[] | undefined;
+                        teams?: {
+                            name: string;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            picture?: string | null | undefined;
+                        }[] | undefined;
+                    } | {
+                        documents: {
+                            status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            tag: string;
+                            createdAt?: Date | null | undefined;
+                            startDate?: Date | null | undefined;
+                            endDate?: Date | null | undefined;
+                            updatedAt?: Date | null | undefined;
+                            matches?: {
+                                _id: string | import("mongoose").Types.ObjectId;
+                                team1: {
+                                    name: string;
+                                    teamId: string | import("mongoose").Types.ObjectId;
+                                };
+                                team2: {
+                                    name: string;
+                                    teamId: string | import("mongoose").Types.ObjectId;
+                                };
+                                score: {
+                                    team1: number | null;
+                                    team2: number | null;
+                                };
+                                stage: string;
+                                endDate?: Date | null | undefined;
+                                startingDate?: Date | null | undefined;
+                                additionalTag?: string | undefined;
+                                winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                            }[] | undefined;
+                            teams?: {
+                                name: string;
+                                _id: string | import("mongoose").Types.ObjectId;
+                                picture?: string | null | undefined;
+                            }[] | undefined;
+                        }[];
+                        metadata?: {
+                            page: number;
+                            size: number;
+                            totalElements: number;
+                            totalPages: number;
+                        } | undefined;
+                    } | undefined;
+                };
+                meta: object;
+            }>;
+            update: import("@trpc/server").TRPCMutationProcedure<{
+                input: {
+                    _id: string | import("mongoose").Types.ObjectId;
+                    status?: import("@lyxa.ai/core/dist/utilities/enum").Status | undefined;
+                    startDate?: string | Date | undefined;
+                    endDate?: string | Date | undefined;
+                    tag?: string | undefined;
+                };
+                output: {
+                    message: string;
+                    success: boolean;
+                    data?: {
+                        status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                        _id: string | import("mongoose").Types.ObjectId;
+                        tag: string;
+                        createdAt?: Date | null | undefined;
+                        startDate?: Date | null | undefined;
+                        endDate?: Date | null | undefined;
+                        updatedAt?: Date | null | undefined;
+                        matches?: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            team1: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            team2: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            stage: string;
+                            endDate?: Date | null | undefined;
+                            startingDate?: Date | null | undefined;
+                            additionalTag?: string | undefined;
+                            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                        }[] | undefined;
+                        teams?: {
+                            name: string;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            picture?: string | null | undefined;
+                        }[] | undefined;
+                    } | {
+                        documents: {
+                            status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            tag: string;
+                            createdAt?: Date | null | undefined;
+                            startDate?: Date | null | undefined;
+                            endDate?: Date | null | undefined;
+                            updatedAt?: Date | null | undefined;
+                            matches?: {
+                                _id: string | import("mongoose").Types.ObjectId;
+                                team1: {
+                                    name: string;
+                                    teamId: string | import("mongoose").Types.ObjectId;
+                                };
+                                team2: {
+                                    name: string;
+                                    teamId: string | import("mongoose").Types.ObjectId;
+                                };
+                                score: {
+                                    team1: number | null;
+                                    team2: number | null;
+                                };
+                                stage: string;
+                                endDate?: Date | null | undefined;
+                                startingDate?: Date | null | undefined;
+                                additionalTag?: string | undefined;
+                                winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                            }[] | undefined;
+                            teams?: {
+                                name: string;
+                                _id: string | import("mongoose").Types.ObjectId;
+                                picture?: string | null | undefined;
+                            }[] | undefined;
+                        }[];
+                        metadata?: {
+                            page: number;
+                            size: number;
+                            totalElements: number;
+                            totalPages: number;
+                        } | undefined;
+                    } | undefined;
+                };
+                meta: object;
+            }>;
+        }>>;
+        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;
+                        _id: string | import("mongoose").Types.ObjectId;
+                        tag: string;
+                        createdAt?: Date | null | undefined;
+                        startDate?: Date | null | undefined;
+                        endDate?: Date | null | undefined;
+                        updatedAt?: Date | null | undefined;
+                        matches?: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            team1: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            team2: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            stage: string;
+                            endDate?: Date | null | undefined;
+                            startingDate?: Date | null | undefined;
+                            additionalTag?: string | undefined;
+                            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                        }[] | undefined;
+                        teams?: {
+                            name: string;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            picture?: string | null | undefined;
+                        }[] | undefined;
+                    } | {
+                        documents: {
+                            status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            tag: string;
+                            createdAt?: Date | null | undefined;
+                            startDate?: Date | null | undefined;
+                            endDate?: Date | null | undefined;
+                            updatedAt?: Date | null | undefined;
+                            matches?: {
+                                _id: string | import("mongoose").Types.ObjectId;
+                                team1: {
+                                    name: string;
+                                    teamId: string | import("mongoose").Types.ObjectId;
+                                };
+                                team2: {
+                                    name: string;
+                                    teamId: string | import("mongoose").Types.ObjectId;
+                                };
+                                score: {
+                                    team1: number | null;
+                                    team2: number | null;
+                                };
+                                stage: string;
+                                endDate?: Date | null | undefined;
+                                startingDate?: Date | null | undefined;
+                                additionalTag?: string | undefined;
+                                winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                            }[] | undefined;
+                            teams?: {
+                                name: string;
+                                _id: string | import("mongoose").Types.ObjectId;
+                                picture?: string | null | undefined;
+                            }[] | undefined;
+                        }[];
+                        metadata?: {
+                            page: number;
+                            size: number;
+                            totalElements: number;
+                            totalPages: number;
+                        } | undefined;
+                    } | undefined;
+                };
+                meta: object;
+            }>;
+            getAll: import("@trpc/server").TRPCQueryProcedure<{
+                input: {
+                    tournamentId: string | import("mongoose").Types.ObjectId;
+                };
+                output: {
+                    message: string;
+                    success: boolean;
+                    data?: {
+                        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;
+                            startingDate?: Date | null | undefined;
+                            additionalTag?: string | undefined;
+                            winnerId?: string | import("mongoose").Types.ObjectId | 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;
+                                startingDate?: Date | null | undefined;
+                                additionalTag?: string | undefined;
+                                winnerId?: string | import("mongoose").Types.ObjectId | 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;
+                        team1Id: string | import("mongoose").Types.ObjectId;
+                        team2Id: string | import("mongoose").Types.ObjectId;
+                        startingDate: string | Date;
+                        endDate?: string | Date | undefined;
+                        additionalTag?: string | undefined;
+                    }[];
+                };
+                output: {
+                    message: string;
+                    success: boolean;
+                    data?: {
+                        status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                        _id: string | import("mongoose").Types.ObjectId;
+                        tag: string;
+                        createdAt?: Date | null | undefined;
+                        startDate?: Date | null | undefined;
+                        endDate?: Date | null | undefined;
+                        updatedAt?: Date | null | undefined;
+                        matches?: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            team1: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            team2: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            stage: string;
+                            endDate?: Date | null | undefined;
+                            startingDate?: Date | null | undefined;
+                            additionalTag?: string | undefined;
+                            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                        }[] | undefined;
+                        teams?: {
+                            name: string;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            picture?: string | null | undefined;
+                        }[] | undefined;
+                    } | {
+                        documents: {
+                            status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            tag: string;
+                            createdAt?: Date | null | undefined;
+                            startDate?: Date | null | undefined;
+                            endDate?: Date | null | undefined;
+                            updatedAt?: Date | null | undefined;
+                            matches?: {
+                                _id: string | import("mongoose").Types.ObjectId;
+                                team1: {
+                                    name: string;
+                                    teamId: string | import("mongoose").Types.ObjectId;
+                                };
+                                team2: {
+                                    name: string;
+                                    teamId: string | import("mongoose").Types.ObjectId;
+                                };
+                                score: {
+                                    team1: number | null;
+                                    team2: number | null;
+                                };
+                                stage: string;
+                                endDate?: Date | null | undefined;
+                                startingDate?: Date | null | undefined;
+                                additionalTag?: string | undefined;
+                                winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                            }[] | undefined;
+                            teams?: {
+                                name: string;
+                                _id: string | import("mongoose").Types.ObjectId;
+                                picture?: string | null | undefined;
+                            }[] | undefined;
+                        }[];
+                        metadata?: {
+                            page: number;
+                            size: number;
+                            totalElements: number;
+                            totalPages: number;
+                        } | undefined;
+                    } | undefined;
+                };
+                meta: object;
+            }>;
+            getAll: import("@trpc/server").TRPCQueryProcedure<{
+                input: {
+                    tournamentId: string | import("mongoose").Types.ObjectId;
+                };
+                output: {
+                    message: string;
+                    success: boolean;
+                    data?: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        team1: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        team2: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        stage: string;
+                        endDate?: Date | null | undefined;
+                        startingDate?: Date | null | undefined;
+                        additionalTag?: string | undefined;
+                        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                        prediction?: {
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            succeeded?: boolean | null | undefined;
+                        } | null | undefined;
+                    }[] | {
+                        documents: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            team1: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            team2: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            stage: string;
+                            endDate?: Date | null | undefined;
+                            startingDate?: Date | null | undefined;
+                            additionalTag?: string | undefined;
+                            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                            prediction?: {
+                                score: {
+                                    team1: number | null;
+                                    team2: number | null;
+                                };
+                                succeeded?: boolean | null | undefined;
+                            } | null | undefined;
+                        }[][];
+                        metadata?: {
+                            page: number;
+                            size: number;
+                            totalElements: number;
+                            totalPages: number;
+                        } | undefined;
+                    } | undefined;
+                };
+                meta: object;
+            }>;
+            start: import("@trpc/server").TRPCMutationProcedure<{
+                input: {
+                    tournamentId: string | import("mongoose").Types.ObjectId;
+                    matchId: string | import("mongoose").Types.ObjectId;
+                };
+                output: {
+                    message: string;
+                    success: boolean;
+                    data?: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        team1: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        team2: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        stage: string;
+                        endDate?: Date | null | undefined;
+                        startingDate?: Date | null | undefined;
+                        additionalTag?: string | undefined;
+                        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                        prediction?: {
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            succeeded?: boolean | null | undefined;
+                        } | null | undefined;
+                    } | {
+                        documents: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            team1: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            team2: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            stage: string;
+                            endDate?: Date | null | undefined;
+                            startingDate?: Date | null | undefined;
+                            additionalTag?: string | undefined;
+                            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                            prediction?: {
+                                score: {
+                                    team1: number | null;
+                                    team2: number | null;
+                                };
+                                succeeded?: boolean | null | undefined;
+                            } | null | undefined;
+                        }[];
+                        metadata?: {
+                            page: number;
+                            size: number;
+                            totalElements: number;
+                            totalPages: number;
+                        } | undefined;
+                    } | undefined;
+                };
+                meta: object;
+            }>;
+            updateScore: import("@trpc/server").TRPCMutationProcedure<{
+                input: {
+                    tournamentId: string | import("mongoose").Types.ObjectId;
+                    matchId: string | import("mongoose").Types.ObjectId;
+                    team1Score: number;
+                    team2Score: number;
+                    winnerId?: string | import("mongoose").Types.ObjectId | undefined;
+                };
+                output: {
+                    message: string;
+                    success: boolean;
+                    data?: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        team1: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        team2: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        stage: string;
+                        endDate?: Date | null | undefined;
+                        startingDate?: Date | null | undefined;
+                        additionalTag?: string | undefined;
+                        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                        prediction?: {
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            succeeded?: boolean | null | undefined;
+                        } | null | undefined;
+                    } | {
+                        documents: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            team1: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            team2: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            stage: string;
+                            endDate?: Date | null | undefined;
+                            startingDate?: Date | null | undefined;
+                            additionalTag?: string | undefined;
+                            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                            prediction?: {
+                                score: {
+                                    team1: number | null;
+                                    team2: number | null;
+                                };
+                                succeeded?: boolean | null | undefined;
+                            } | null | undefined;
+                        }[];
+                        metadata?: {
+                            page: number;
+                            size: number;
+                            totalElements: number;
+                            totalPages: number;
+                        } | undefined;
+                    } | undefined;
+                };
+                meta: object;
+            }>;
+            end: import("@trpc/server").TRPCMutationProcedure<{
+                input: {
+                    tournamentId: string | import("mongoose").Types.ObjectId;
+                    matchId: string | import("mongoose").Types.ObjectId;
+                    endDate?: string | Date | undefined;
+                    winnerId?: string | import("mongoose").Types.ObjectId | undefined;
+                };
+                output: {
+                    message: string;
+                    success: boolean;
+                    data?: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        team1: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        team2: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        stage: string;
+                        endDate?: Date | null | undefined;
+                        startingDate?: Date | null | undefined;
+                        additionalTag?: string | undefined;
+                        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                        prediction?: {
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            succeeded?: boolean | null | undefined;
+                        } | null | undefined;
+                    } | {
+                        documents: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            team1: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            team2: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            stage: string;
+                            endDate?: Date | null | undefined;
+                            startingDate?: Date | null | undefined;
+                            additionalTag?: string | undefined;
+                            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                            prediction?: {
+                                score: {
+                                    team1: number | null;
+                                    team2: number | null;
+                                };
+                                succeeded?: boolean | null | undefined;
+                            } | null | undefined;
+                        }[];
+                        metadata?: {
+                            page: number;
+                            size: number;
+                            totalElements: number;
+                            totalPages: number;
+                        } | undefined;
+                    } | undefined;
+                };
+                meta: object;
+            }>;
+            delete: import("@trpc/server").TRPCMutationProcedure<{
+                input: {
+                    tournamentId: string | import("mongoose").Types.ObjectId;
+                    matchId: string | import("mongoose").Types.ObjectId;
+                };
+                output: {
+                    message: string;
+                    success: boolean;
+                    data?: {
+                        status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                        _id: string | import("mongoose").Types.ObjectId;
+                        tag: string;
+                        createdAt?: Date | null | undefined;
+                        startDate?: Date | null | undefined;
+                        endDate?: Date | null | undefined;
+                        updatedAt?: Date | null | undefined;
+                        matches?: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            team1: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            team2: {
+                                name: string;
+                                teamId: string | import("mongoose").Types.ObjectId;
+                            };
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            stage: string;
+                            endDate?: Date | null | undefined;
+                            startingDate?: Date | null | undefined;
+                            additionalTag?: string | undefined;
+                            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                        }[] | undefined;
+                        teams?: {
+                            name: string;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            picture?: string | null | undefined;
+                        }[] | undefined;
+                    } | {
+                        documents: {
+                            status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                            _id: string | import("mongoose").Types.ObjectId;
+                            tag: string;
+                            createdAt?: Date | null | undefined;
+                            startDate?: Date | null | undefined;
+                            endDate?: Date | null | undefined;
+                            updatedAt?: Date | null | undefined;
+                            matches?: {
+                                _id: string | import("mongoose").Types.ObjectId;
+                                team1: {
+                                    name: string;
+                                    teamId: string | import("mongoose").Types.ObjectId;
+                                };
+                                team2: {
+                                    name: string;
+                                    teamId: string | import("mongoose").Types.ObjectId;
+                                };
+                                score: {
+                                    team1: number | null;
+                                    team2: number | null;
+                                };
+                                stage: string;
+                                endDate?: Date | null | undefined;
+                                startingDate?: Date | null | undefined;
+                                additionalTag?: string | undefined;
+                                winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                            }[] | undefined;
+                            teams?: {
+                                name: string;
+                                _id: string | import("mongoose").Types.ObjectId;
+                                picture?: string | null | undefined;
+                            }[] | undefined;
+                        }[];
+                        metadata?: {
+                            page: number;
+                            size: number;
+                            totalElements: number;
+                            totalPages: number;
+                        } | undefined;
+                    } | undefined;
+                };
+                meta: object;
+            }>;
+        }>>;
+        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: {
+                    teamId: string | import("mongoose").Types.ObjectId;
+                    tournamentId: string | import("mongoose").Types.ObjectId;
+                };
+                output: {
+                    message: string;
+                    success: boolean;
+                    data?: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                        tournamentId: string | import("mongoose").Types.ObjectId;
+                        createdAt?: Date | null | undefined;
+                    } | {
+                        documents: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                            tournamentId: 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;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                        tournamentId: string | import("mongoose").Types.ObjectId;
+                        createdAt?: Date | null | undefined;
+                        updatedAt?: Date | null | undefined;
+                        predictions?: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            matchId: string | import("mongoose").Types.ObjectId;
+                            coupon?: string | import("mongoose").Types.ObjectId | undefined;
+                            succeeded?: boolean | null | undefined;
+                            predictionTime?: Date | null | undefined;
+                        }[] | undefined;
+                    }[] | {
+                        documents: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            userId: string | import("mongoose").Types.ObjectId;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                            tournamentId: string | import("mongoose").Types.ObjectId;
+                            createdAt?: Date | null | undefined;
+                            updatedAt?: Date | null | undefined;
+                            predictions?: {
+                                _id: string | import("mongoose").Types.ObjectId;
+                                score: {
+                                    team1: number | null;
+                                    team2: number | null;
+                                };
+                                matchId: string | import("mongoose").Types.ObjectId;
+                                coupon?: string | import("mongoose").Types.ObjectId | undefined;
+                                succeeded?: boolean | null | undefined;
+                                predictionTime?: Date | 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: {
+                    score: {
+                        team1: number;
+                        team2: number;
+                    };
+                    tournamentId: string | import("mongoose").Types.ObjectId;
+                    matchId: string | import("mongoose").Types.ObjectId;
+                };
+                output: {
+                    message: string;
+                    success: boolean;
+                    data?: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        matchId: string | import("mongoose").Types.ObjectId;
+                    } | {
+                        documents: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            matchId: string | import("mongoose").Types.ObjectId;
+                        }[];
+                        metadata?: {
+                            page: number;
+                            size: number;
+                            totalElements: number;
+                            totalPages: number;
+                        } | undefined;
+                    } | undefined;
+                };
+                meta: object;
+            }>;
+            edit: import("@trpc/server").TRPCMutationProcedure<{
+                input: {
+                    score: {
+                        team1: number;
+                        team2: number;
+                    };
+                    tournamentId: string | import("mongoose").Types.ObjectId;
+                    matchId: string | import("mongoose").Types.ObjectId;
+                };
+                output: {
+                    message: string;
+                    success: boolean;
+                    data?: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        matchId: string | import("mongoose").Types.ObjectId;
+                    } | {
+                        documents: {
+                            _id: string | import("mongoose").Types.ObjectId;
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            matchId: string | import("mongoose").Types.ObjectId;
+                        }[];
+                        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;
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        matchId: string | import("mongoose").Types.ObjectId;
+                        succeeded?: boolean | null | undefined;
+                        predictionTime?: Date | null | undefined;
+                    } | {
+                        documents: ({
+                            _id: string | import("mongoose").Types.ObjectId;
+                            score: {
+                                team1: number | null;
+                                team2: number | null;
+                            };
+                            matchId: string | import("mongoose").Types.ObjectId;
+                            succeeded?: boolean | null | undefined;
+                            predictionTime?: Date | null | undefined;
+                        } | null)[];
+                        metadata?: {
+                            page: number;
+                            size: number;
+                            totalElements: number;
+                            totalPages: number;
+                        } | undefined;
+                    } | null | undefined;
+                };
+                meta: object;
+            }>;
+        }>>;
+    }>>;
 }>>;
 export type MarketingMicroServiceRouter = typeof marketingMicroServiceRouter;
 export {};