@lyxa.ai/marketing 1.0.47 → 1.0.49

package/dist/types/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, {
+    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;
+    score: {
+        team1: number;
+        team2: number;
+    };
+}>;
+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, {
+    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;
+    score: {
+        team1: number;
+        team2: number;
+    };
+}>;
+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;
+    matchId: import("mongoose").Types.ObjectId;
+    score: {
+        team1: number | null;
+        team2: number | null;
+    };
+    predictionTime?: Date | null | undefined;
+    succeeded?: boolean | null | undefined;
+}, {
+    _id: string | import("mongoose").Types.ObjectId;
+    matchId: string | import("mongoose").Types.ObjectId;
+    score: {
+        team1: number | null;
+        team2: number | null;
+    };
+    predictionTime?: Date | null | undefined;
+    succeeded?: boolean | null | undefined;
+}>;
+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;
+    matchId: import("mongoose").Types.ObjectId;
+    score: {
+        team1: number | null;
+        team2: number | null;
+    };
+}, {
+    _id: string | import("mongoose").Types.ObjectId;
+    matchId: string | import("mongoose").Types.ObjectId;
+    score: {
+        team1: number | null;
+        team2: number | null;
+    };
+}>;
+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;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+        }, z.ZodTypeDef, {
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        documents: {
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }, {
+        documents: {
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }>, z.ZodType<{
+        _id: string | import("mongoose").Types.ObjectId;
+        matchId: string | import("mongoose").Types.ObjectId;
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+    }, z.ZodTypeDef, {
+        _id: string | import("mongoose").Types.ObjectId;
+        matchId: string | import("mongoose").Types.ObjectId;
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+    data?: {
+        _id: string | import("mongoose").Types.ObjectId;
+        matchId: string | import("mongoose").Types.ObjectId;
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+    } | {
+        documents: {
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | undefined;
+}, {
+    message: string;
+    success: boolean;
+    data?: {
+        _id: string | import("mongoose").Types.ObjectId;
+        matchId: string | import("mongoose").Types.ObjectId;
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+    } | {
+        documents: {
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | undefined;
+}>;
+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;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            predictionTime?: Date | null | undefined;
+            succeeded?: boolean | null | undefined;
+        }, z.ZodTypeDef, {
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            predictionTime?: Date | null | undefined;
+            succeeded?: boolean | null | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        documents: {
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            predictionTime?: Date | null | undefined;
+            succeeded?: boolean | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }, {
+        documents: {
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            predictionTime?: Date | null | undefined;
+            succeeded?: boolean | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }>, z.ZodType<{
+        _id: string | import("mongoose").Types.ObjectId;
+        matchId: string | import("mongoose").Types.ObjectId;
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        predictionTime?: Date | null | undefined;
+        succeeded?: boolean | null | undefined;
+    }, z.ZodTypeDef, {
+        _id: string | import("mongoose").Types.ObjectId;
+        matchId: string | import("mongoose").Types.ObjectId;
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        predictionTime?: Date | null | undefined;
+        succeeded?: boolean | null | undefined;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+    data?: {
+        _id: string | import("mongoose").Types.ObjectId;
+        matchId: string | import("mongoose").Types.ObjectId;
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        predictionTime?: Date | null | undefined;
+        succeeded?: boolean | null | undefined;
+    } | {
+        documents: {
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            predictionTime?: Date | null | undefined;
+            succeeded?: boolean | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | undefined;
+}, {
+    message: string;
+    success: boolean;
+    data?: {
+        _id: string | import("mongoose").Types.ObjectId;
+        matchId: string | import("mongoose").Types.ObjectId;
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        predictionTime?: Date | null | undefined;
+        succeeded?: boolean | null | undefined;
+    } | {
+        documents: {
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            predictionTime?: Date | null | undefined;
+            succeeded?: boolean | null | undefined;
+        }[];
+        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;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            predictionTime?: Date | null | undefined;
+            succeeded?: boolean | null | undefined;
+        } | null, z.ZodTypeDef, {
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            predictionTime?: Date | null | undefined;
+            succeeded?: boolean | null | undefined;
+        } | null>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        documents: ({
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            predictionTime?: Date | null | undefined;
+            succeeded?: boolean | null | undefined;
+        } | null)[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }, {
+        documents: ({
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            predictionTime?: Date | null | undefined;
+            succeeded?: boolean | null | undefined;
+        } | null)[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }>, z.ZodType<{
+        _id: string | import("mongoose").Types.ObjectId;
+        matchId: string | import("mongoose").Types.ObjectId;
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        predictionTime?: Date | null | undefined;
+        succeeded?: boolean | null | undefined;
+    } | null, z.ZodTypeDef, {
+        _id: string | import("mongoose").Types.ObjectId;
+        matchId: string | import("mongoose").Types.ObjectId;
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        predictionTime?: Date | null | undefined;
+        succeeded?: boolean | null | undefined;
+    } | null>]>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+    data?: {
+        _id: string | import("mongoose").Types.ObjectId;
+        matchId: string | import("mongoose").Types.ObjectId;
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        predictionTime?: Date | null | undefined;
+        succeeded?: boolean | null | undefined;
+    } | {
+        documents: ({
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            predictionTime?: Date | null | undefined;
+            succeeded?: boolean | null | undefined;
+        } | null)[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | null | undefined;
+}, {
+    message: string;
+    success: boolean;
+    data?: {
+        _id: string | import("mongoose").Types.ObjectId;
+        matchId: string | import("mongoose").Types.ObjectId;
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        predictionTime?: Date | null | undefined;
+        succeeded?: boolean | null | undefined;
+    } | {
+        documents: ({
+            _id: string | import("mongoose").Types.ObjectId;
+            matchId: string | import("mongoose").Types.ObjectId;
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            predictionTime?: Date | null | undefined;
+            succeeded?: boolean | null | undefined;
+        } | null)[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | null | undefined;
+}>;
+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/types/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/types/modules/tournament/reward/handlers/coupon-reward.handler.d.ts

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

package/dist/types/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":"AAIA,OAAO,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAM9C,qBACa,mBAAoB,YAAW,cAAc;IACtD,OAAO,CAAC,2BAA2B,CAA8B;IACjE,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,eAAe,CAAuD;;YAQhE,WAAW;IAKnB,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAerD"}

package/dist/types/modules/tournament/reward/reward.builder.d.ts

@@ -0,0 +1,6 @@
+import { mongoose } from '@typegoose/typegoose';
+import { RewardContext } from './reward.types';
+export declare class RewardBuilder {
+    static buildCouponRewardContext(matchId: mongoose.Types.ObjectId, tournamentId: mongoose.Types.ObjectId, winnerIds: mongoose.Types.ObjectId[]): RewardContext;
+}
+//# sourceMappingURL=reward.builder.d.ts.map

package/dist/types/modules/tournament/reward/reward.builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reward.builder.d.ts","sourceRoot":"/","sources":["modules/tournament/reward/reward.builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAE9C,OAAO,EAAC,aAAa,EAAC,MAAM,gBAAgB,CAAC;AAO7C,qBAAa,aAAa;IACtB,MAAM,CAAC,wBAAwB,CAC3B,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAChC,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EACrC,SAAS,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,GACrC,aAAa;CAiCnB"}

package/dist/types/modules/tournament/reward/reward.factory.d.ts

@@ -0,0 +1,6 @@
+import { RewardType } from './reward.types';
+import { IRewardHandler } from './reward.interface';
+export declare class RewardFactory {
+    static getHandler(type: RewardType): IRewardHandler;
+}
+//# sourceMappingURL=reward.factory.d.ts.map

package/dist/types/modules/tournament/reward/reward.factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reward.factory.d.ts","sourceRoot":"/","sources":["modules/tournament/reward/reward.factory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGpD,qBAAa,aAAa;IACtB,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,cAAc;CAQtD"}

package/dist/types/modules/tournament/reward/reward.interface.d.ts

@@ -0,0 +1,5 @@
+import { RewardContext } from './reward.types';
+export interface IRewardHandler {
+    grant(context: RewardContext): Promise<void>;
+}
+//# sourceMappingURL=reward.interface.d.ts.map

package/dist/types/modules/tournament/reward/reward.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reward.interface.d.ts","sourceRoot":"/","sources":["modules/tournament/reward/reward.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,gBAAgB,CAAC;AAE7C,MAAM,WAAW,cAAc;IAC3B,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD"}

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

@@ -0,0 +1,6 @@
+import { RewardContext, RewardType } from './reward.types';
+export declare class RewardService {
+    grant(type: RewardType, context: RewardContext): Promise<void>;
+}
+export declare const rewardService: RewardService;
+//# sourceMappingURL=reward.service.d.ts.map

package/dist/types/modules/tournament/reward/reward.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reward.service.d.ts","sourceRoot":"/","sources":["modules/tournament/reward/reward.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,aAAa,EAAE,UAAU,EAAC,MAAM,gBAAgB,CAAC;AAGzD,qBACa,aAAa;IAChB,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAIvE;AAED,eAAO,MAAM,aAAa,eAA+B,CAAC"}

package/dist/types/modules/tournament/reward/reward.types.d.ts

@@ -0,0 +1,11 @@
+import { mongoose } from '@typegoose/typegoose';
+export declare enum RewardType {
+    COUPON = "coupon"
+}
+export interface RewardContext {
+    userIds: mongoose.Types.ObjectId[];
+    tournamentId: mongoose.Types.ObjectId;
+    matchId: mongoose.Types.ObjectId;
+    payload: Record<string, unknown>;
+}
+//# sourceMappingURL=reward.types.d.ts.map

package/dist/types/modules/tournament/reward/reward.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reward.types.d.ts","sourceRoot":"/","sources":["modules/tournament/reward/reward.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAE9C,oBAAY,UAAU;IAClB,MAAM,WAAW;CACpB;AAED,MAAM,WAAW,aAAa;IAC1B,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;IACnC,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC;IACtC,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC"}

package/dist/types/modules/tournament/score/score.repository.d.ts

@@ -0,0 +1,6 @@
+export declare class ScoreRepository {
+    private participantModel;
+    constructor();
+}
+export declare const scoreRepository: ScoreRepository;
+//# sourceMappingURL=score.repository.d.ts.map

package/dist/types/modules/tournament/score/score.repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"score.repository.d.ts","sourceRoot":"/","sources":["modules/tournament/score/score.repository.ts"],"names":[],"mappings":"AAGA,qBACa,eAAe;IACxB,OAAO,CAAC,gBAAgB,CAAoC;;CAK/D;AAED,eAAO,MAAM,eAAe,iBAAiC,CAAC"}

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

@@ -0,0 +1,6 @@
+export declare class ScoreService {
+    private repository;
+    constructor();
+}
+export declare const scoreService: ScoreService;
+//# sourceMappingURL=score.service.d.ts.map

package/dist/types/modules/tournament/score/score.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"score.service.d.ts","sourceRoot":"/","sources":["modules/tournament/score/score.service.ts"],"names":[],"mappings":"AAGA,qBACa,YAAY;IACrB,OAAO,CAAC,UAAU,CAAkB;;CAKvC;AAED,eAAO,MAAM,YAAY,cAA8B,CAAC"}