@lyxa.ai/marketing 1.0.46 → 1.0.48

package/dist/lib/modules/tournament/prediction/prediction.validation.d.ts

@@ -0,0 +1,575 @@
+import { z } from 'zod';
+import { DTO } from '@lyxa.ai/core/dist/utilities/validation/global-validation';
+export declare const CreatePredictionSchema: z.ZodObject<{
+    tournamentId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    matchId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    score: z.ZodObject<{
+        team1: z.ZodNumber;
+        team2: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        team1: number;
+        team2: number;
+    }, {
+        team1: number;
+        team2: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    score: {
+        team1: number;
+        team2: number;
+    };
+    tournamentId: import("mongoose").Types.ObjectId;
+    matchId: import("mongoose").Types.ObjectId;
+}, {
+    score: {
+        team1: number;
+        team2: number;
+    };
+    tournamentId: string | import("mongoose").Types.ObjectId;
+    matchId: string | import("mongoose").Types.ObjectId;
+}>;
+export declare const EditPredictionSchema: z.ZodObject<{
+    tournamentId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    matchId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    score: z.ZodObject<{
+        team1: z.ZodNumber;
+        team2: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        team1: number;
+        team2: number;
+    }, {
+        team1: number;
+        team2: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    score: {
+        team1: number;
+        team2: number;
+    };
+    tournamentId: import("mongoose").Types.ObjectId;
+    matchId: import("mongoose").Types.ObjectId;
+}, {
+    score: {
+        team1: number;
+        team2: number;
+    };
+    tournamentId: string | import("mongoose").Types.ObjectId;
+    matchId: string | import("mongoose").Types.ObjectId;
+}>;
+export declare const GetPredictionSchema: z.ZodObject<{
+    tournamentId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    matchId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+}, "strip", z.ZodTypeAny, {
+    tournamentId: import("mongoose").Types.ObjectId;
+    matchId: import("mongoose").Types.ObjectId;
+}, {
+    tournamentId: string | import("mongoose").Types.ObjectId;
+    matchId: string | import("mongoose").Types.ObjectId;
+}>;
+export declare const PredictionSchema: z.ZodObject<{
+    _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    matchId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    score: z.ZodObject<{
+        team1: z.ZodNullable<z.ZodNumber>;
+        team2: z.ZodNullable<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        team1: number | null;
+        team2: number | null;
+    }, {
+        team1: number | null;
+        team2: number | null;
+    }>;
+    predictionTime: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    succeeded: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    _id: import("mongoose").Types.ObjectId;
+    score: {
+        team1: number | null;
+        team2: number | null;
+    };
+    matchId: import("mongoose").Types.ObjectId;
+    succeeded?: boolean | null | undefined;
+    predictionTime?: Date | null | undefined;
+}, {
+    _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;
+}>;
+export declare const MutatePredictionSchema: z.ZodObject<{
+    _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    matchId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    score: z.ZodObject<{
+        team1: z.ZodNullable<z.ZodNumber>;
+        team2: z.ZodNullable<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        team1: number | null;
+        team2: number | null;
+    }, {
+        team1: number | null;
+        team2: number | null;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    _id: import("mongoose").Types.ObjectId;
+    score: {
+        team1: number | null;
+        team2: number | null;
+    };
+    matchId: import("mongoose").Types.ObjectId;
+}, {
+    _id: string | import("mongoose").Types.ObjectId;
+    score: {
+        team1: number | null;
+        team2: number | null;
+    };
+    matchId: string | import("mongoose").Types.ObjectId;
+}>;
+export declare const MutatePredictionResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    data: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        metadata: z.ZodOptional<z.ZodObject<{
+            page: z.ZodNumber;
+            size: z.ZodNumber;
+            totalElements: z.ZodNumber;
+            totalPages: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }>>;
+        documents: z.ZodArray<z.ZodType<{
+            _id: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            matchId: string | import("mongoose").Types.ObjectId;
+        }, z.ZodTypeDef, {
+            _id: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            matchId: string | import("mongoose").Types.ObjectId;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        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;
+    }, {
+        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;
+    }>, z.ZodType<{
+        _id: string | import("mongoose").Types.ObjectId;
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        matchId: string | import("mongoose").Types.ObjectId;
+    }, z.ZodTypeDef, {
+        _id: string | import("mongoose").Types.ObjectId;
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        matchId: string | import("mongoose").Types.ObjectId;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    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;
+}, {
+    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;
+}>;
+export declare const PredictionResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    data: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        metadata: z.ZodOptional<z.ZodObject<{
+            page: z.ZodNumber;
+            size: z.ZodNumber;
+            totalElements: z.ZodNumber;
+            totalPages: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }>>;
+        documents: z.ZodArray<z.ZodType<{
+            _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;
+        }, z.ZodTypeDef, {
+            _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;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        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;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | 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;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }>, z.ZodType<{
+        _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;
+    }, z.ZodTypeDef, {
+        _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;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    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;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | undefined;
+}, {
+    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;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | undefined;
+}>;
+export declare const PredictionNullableResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    data: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        metadata: z.ZodOptional<z.ZodObject<{
+            page: z.ZodNumber;
+            size: z.ZodNumber;
+            totalElements: z.ZodNumber;
+            totalPages: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }>>;
+        documents: z.ZodArray<z.ZodType<{
+            _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, z.ZodTypeDef, {
+            _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>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        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;
+    }, {
+        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;
+    }>, z.ZodType<{
+        _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, z.ZodTypeDef, {
+        _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>]>>;
+}, "strip", z.ZodTypeAny, {
+    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;
+}, {
+    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;
+}>;
+export type CreatePredictionInputDTO = DTO<typeof CreatePredictionSchema>;
+export type EditPredictionInputDTO = DTO<typeof EditPredictionSchema>;
+export type GetPredictionInputDTO = DTO<typeof GetPredictionSchema>;
+export type MutatePredictionOutputDTO = DTO<typeof MutatePredictionSchema>;
+export type PredictionOutputDTO = DTO<typeof PredictionSchema>;
+//# sourceMappingURL=prediction.validation.d.ts.map

package/dist/lib/modules/tournament/prediction/prediction.validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prediction.validation.d.ts","sourceRoot":"/","sources":["modules/tournament/prediction/prediction.validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,GAAG,EAAiB,MAAM,2DAA2D,CAAC;AAQ/F,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIjC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI/B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;EAG9B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS3B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOjC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA+C,CAAC;AAC3F,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAyC,CAAC;AAC/E,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAoD,CAAC;AAElG,MAAM,MAAM,wBAAwB,GAAG,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC1E,MAAM,MAAM,sBAAsB,GAAG,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACtE,MAAM,MAAM,qBAAqB,GAAG,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACpE,MAAM,MAAM,yBAAyB,GAAG,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC3E,MAAM,MAAM,mBAAmB,GAAG,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/lib/modules/tournament/prediction/prediction.validation.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredictionNullableResponseSchema = exports.PredictionResponseSchema = exports.MutatePredictionResponseSchema = exports.MutatePredictionSchema = exports.PredictionSchema = exports.GetPredictionSchema = exports.EditPredictionSchema = exports.CreatePredictionSchema = void 0;
+const zod_1 = require("zod");
+const global_validation_1 = require("@lyxa.ai/core/dist/utilities/validation/global-validation");
+const validation_1 = require("@lyxa.ai/core/dist/utilities/validation");
+const PredictionScoreSchema = zod_1.z.object({
+    team1: global_validation_1.ZodValidation.number('Team 1 predicted score', { min: 0, isInt: true }),
+    team2: global_validation_1.ZodValidation.number('Team 2 predicted score', { min: 0, isInt: true }),
+});
+exports.CreatePredictionSchema = zod_1.z.object({
+    tournamentId: global_validation_1.ZodValidation.objectId('Tournament id'),
+    matchId: global_validation_1.ZodValidation.objectId('Match id'),
+    score: PredictionScoreSchema,
+});
+exports.EditPredictionSchema = zod_1.z.object({
+    tournamentId: global_validation_1.ZodValidation.objectId('Tournament id'),
+    matchId: global_validation_1.ZodValidation.objectId('Match id'),
+    score: PredictionScoreSchema,
+});
+exports.GetPredictionSchema = zod_1.z.object({
+    tournamentId: global_validation_1.ZodValidation.objectId('Tournament id'),
+    matchId: global_validation_1.ZodValidation.objectId('Match id'),
+});
+exports.PredictionSchema = zod_1.z.object({
+    _id: global_validation_1.ZodValidation.objectId(),
+    matchId: global_validation_1.ZodValidation.objectId('Match id'),
+    score: zod_1.z.object({
+        team1: global_validation_1.ZodValidation.number('Team 1 score').nullable(),
+        team2: global_validation_1.ZodValidation.number('Team 2 score').nullable(),
+    }),
+    predictionTime: zod_1.z.date().nullable().optional(),
+    succeeded: zod_1.z.boolean().nullable().optional(),
+});
+exports.MutatePredictionSchema = zod_1.z.object({
+    _id: global_validation_1.ZodValidation.objectId(),
+    matchId: global_validation_1.ZodValidation.objectId('Match id'),
+    score: zod_1.z.object({
+        team1: global_validation_1.ZodValidation.number('Team 1 score').nullable(),
+        team2: global_validation_1.ZodValidation.number('Team 2 score').nullable(),
+    }),
+});
+exports.MutatePredictionResponseSchema = (0, validation_1.createResponseSchema)(exports.MutatePredictionSchema);
+exports.PredictionResponseSchema = (0, validation_1.createResponseSchema)(exports.PredictionSchema);
+exports.PredictionNullableResponseSchema = (0, validation_1.createResponseSchema)(exports.PredictionSchema.nullable());
+//# sourceMappingURL=prediction.validation.js.map

package/dist/lib/modules/tournament/prediction/prediction.validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prediction.validation.js","sourceRoot":"/","sources":["modules/tournament/prediction/prediction.validation.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,iGAA+F;AAC/F,wEAA+E;AAE/E,MAAM,qBAAqB,GAAG,OAAC,CAAC,MAAM,CAAC;IACnC,KAAK,EAAE,iCAAa,CAAC,MAAM,CAAC,wBAAwB,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAC9E,KAAK,EAAE,iCAAa,CAAC,MAAM,CAAC,wBAAwB,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;CACjF,CAAC,CAAC;AAEU,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC3C,YAAY,EAAE,iCAAa,CAAC,QAAQ,CAAC,eAAe,CAAC;IACrD,OAAO,EAAE,iCAAa,CAAC,QAAQ,CAAC,UAAU,CAAC;IAC3C,KAAK,EAAE,qBAAqB;CAC/B,CAAC,CAAC;AAEU,QAAA,oBAAoB,GAAG,OAAC,CAAC,MAAM,CAAC;IACzC,YAAY,EAAE,iCAAa,CAAC,QAAQ,CAAC,eAAe,CAAC;IACrD,OAAO,EAAE,iCAAa,CAAC,QAAQ,CAAC,UAAU,CAAC;IAC3C,KAAK,EAAE,qBAAqB;CAC/B,CAAC,CAAC;AAEU,QAAA,mBAAmB,GAAG,OAAC,CAAC,MAAM,CAAC;IACxC,YAAY,EAAE,iCAAa,CAAC,QAAQ,CAAC,eAAe,CAAC;IACrD,OAAO,EAAE,iCAAa,CAAC,QAAQ,CAAC,UAAU,CAAC;CAC9C,CAAC,CAAC;AAEU,QAAA,gBAAgB,GAAG,OAAC,CAAC,MAAM,CAAC;IACrC,GAAG,EAAE,iCAAa,CAAC,QAAQ,EAAE;IAC7B,OAAO,EAAE,iCAAa,CAAC,QAAQ,CAAC,UAAU,CAAC;IAC3C,KAAK,EAAE,OAAC,CAAC,MAAM,CAAC;QACZ,KAAK,EAAE,iCAAa,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,QAAQ,EAAE;QACtD,KAAK,EAAE,iCAAa,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,QAAQ,EAAE;KACzD,CAAC;IACF,cAAc,EAAE,OAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAC9C,SAAS,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;CAC/C,CAAC,CAAC;AAEU,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC3C,GAAG,EAAE,iCAAa,CAAC,QAAQ,EAAE;IAC7B,OAAO,EAAE,iCAAa,CAAC,QAAQ,CAAC,UAAU,CAAC;IAC3C,KAAK,EAAE,OAAC,CAAC,MAAM,CAAC;QACZ,KAAK,EAAE,iCAAa,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,QAAQ,EAAE;QACtD,KAAK,EAAE,iCAAa,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,QAAQ,EAAE;KACzD,CAAC;CACL,CAAC,CAAC;AAEU,QAAA,8BAA8B,GAAG,IAAA,iCAAoB,EAAC,8BAAsB,CAAC,CAAC;AAC9E,QAAA,wBAAwB,GAAG,IAAA,iCAAoB,EAAC,wBAAgB,CAAC,CAAC;AAClE,QAAA,gCAAgC,GAAG,IAAA,iCAAoB,EAAC,wBAAgB,CAAC,QAAQ,EAAE,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport { DTO, ZodValidation } from '@lyxa.ai/core/dist/utilities/validation/global-validation';\nimport { createResponseSchema } from '@lyxa.ai/core/dist/utilities/validation';\n\nconst PredictionScoreSchema = z.object({\n    team1: ZodValidation.number('Team 1 predicted score', { min: 0, isInt: true }),\n    team2: ZodValidation.number('Team 2 predicted score', { min: 0, isInt: true }),\n});\n\nexport const CreatePredictionSchema = z.object({\n    tournamentId: ZodValidation.objectId('Tournament id'),\n    matchId: ZodValidation.objectId('Match id'),\n    score: PredictionScoreSchema,\n});\n\nexport const EditPredictionSchema = z.object({\n    tournamentId: ZodValidation.objectId('Tournament id'),\n    matchId: ZodValidation.objectId('Match id'),\n    score: PredictionScoreSchema,\n});\n\nexport const GetPredictionSchema = z.object({\n    tournamentId: ZodValidation.objectId('Tournament id'),\n    matchId: ZodValidation.objectId('Match id'),\n});\n\nexport const PredictionSchema = z.object({\n    _id: ZodValidation.objectId(),\n    matchId: ZodValidation.objectId('Match id'),\n    score: z.object({\n        team1: ZodValidation.number('Team 1 score').nullable(),\n        team2: ZodValidation.number('Team 2 score').nullable(),\n    }),\n    predictionTime: z.date().nullable().optional(),\n    succeeded: z.boolean().nullable().optional(),\n});\n\nexport const MutatePredictionSchema = z.object({\n    _id: ZodValidation.objectId(),\n    matchId: ZodValidation.objectId('Match id'),\n    score: z.object({\n        team1: ZodValidation.number('Team 1 score').nullable(),\n        team2: ZodValidation.number('Team 2 score').nullable(),\n    }),\n});\n\nexport const MutatePredictionResponseSchema = createResponseSchema(MutatePredictionSchema);\nexport const PredictionResponseSchema = createResponseSchema(PredictionSchema);\nexport const PredictionNullableResponseSchema = createResponseSchema(PredictionSchema.nullable());\n\nexport type CreatePredictionInputDTO = DTO<typeof CreatePredictionSchema>;\nexport type EditPredictionInputDTO = DTO<typeof EditPredictionSchema>;\nexport type GetPredictionInputDTO = DTO<typeof GetPredictionSchema>;\nexport type MutatePredictionOutputDTO = DTO<typeof MutatePredictionSchema>;\nexport type PredictionOutputDTO = DTO<typeof PredictionSchema>;\n"]}

package/dist/lib/modules/tournament/reward/handlers/coupon-reward.handler.d.ts

@@ -0,0 +1,8 @@
+import { IRewardHandler } from '../reward.interface';
+import { RewardContext } from '../reward.types';
+export declare class CouponRewardHandler implements IRewardHandler {
+    private couponService;
+    constructor();
+    grant(context: RewardContext): Promise<void>;
+}
+//# sourceMappingURL=coupon-reward.handler.d.ts.map

package/dist/lib/modules/tournament/reward/handlers/coupon-reward.handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coupon-reward.handler.d.ts","sourceRoot":"/","sources":["modules/tournament/reward/handlers/coupon-reward.handler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,qBACa,mBAAoB,YAAW,cAAc;IACtD,OAAO,CAAC,aAAa,CAA8B;;IAM7C,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAMrD"}