gambling-bot-shared 0.1.54 → 1.0.1

package/dist/predictions/services/prediction.db.d.ts

@@ -0,0 +1,55 @@
+import type { Model } from 'mongoose';
+import type { TPrediction } from '../types/prediction';
+import type { TAddPredictionBet, TCreatePrediction, TGetOldPredictions, TGetPrediction, TUpdatePredictionStatus } from './types';
+export declare function createPredictionDb(predictionModel: Model<TPrediction>): {
+    getPredictionById: ({ predictionId, guildId }: TGetPrediction) => Promise<(import("mongoose").Document<unknown, {}, TPrediction, {}, import("mongoose").DefaultSchemaOptions> & TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    } & {
+        id: string;
+    }) | null>;
+    getPredictionToLock: ({ status, useAutolock }: {
+        status?: TPrediction["status"];
+        useAutolock?: boolean;
+    }) => Promise<(import("mongoose").Document<unknown, {}, TPrediction, {}, import("mongoose").DefaultSchemaOptions> & TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    } & {
+        id: string;
+    })[]>;
+    getOldPredictions: ({ statuses, olderThanDays }: TGetOldPredictions) => Promise<(import("mongoose").Document<unknown, {}, TPrediction, {}, import("mongoose").DefaultSchemaOptions> & TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    } & {
+        id: string;
+    })[]>;
+    createPrediction: ({ predictionId, guildId, channelId, creatorId, title, choices, autolock, status }: TCreatePrediction) => Promise<void>;
+    updatePredictionStatus: ({ predictionId, guildId, fromStatus, toStatus }: TUpdatePredictionStatus) => Promise<(import("mongoose").Document<unknown, {}, TPrediction, {}, import("mongoose").DefaultSchemaOptions> & TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    } & {
+        id: string;
+    }) | null>;
+    deletePrediction: ({ predictionId }: {
+        predictionId: string;
+    }) => Promise<void>;
+    findPredictions: (query: Record<string, unknown>) => Promise<(import("mongoose").Document<unknown, {}, TPrediction, {}, import("mongoose").DefaultSchemaOptions> & TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    } & {
+        id: string;
+    })[]>;
+    addPredictionBet: ({ predictionId, guildId, choiceName, userId, amount, betId }: TAddPredictionBet) => Promise<(import("mongoose").Document<unknown, {}, TPrediction, {}, import("mongoose").DefaultSchemaOptions> & TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    } & {
+        id: string;
+    }) | null>;
+};
+export type PredictionDb = ReturnType<typeof createPredictionDb>;

package/dist/predictions/services/prediction.db.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPredictionDb = createPredictionDb;
+function createPredictionDb(predictionModel) {
+    const getPredictionById = async ({ predictionId, guildId }) => {
+        return predictionModel.findOne({ predictionId, guildId });
+    };
+    const getPredictionToLock = async ({ status = 'active', useAutolock = true }) => {
+        const now = new Date();
+        return predictionModel.find({
+            status,
+            ...(useAutolock ? { autolock: { $lte: now } } : {})
+        });
+    };
+    const getOldPredictions = async ({ statuses, olderThanDays }) => {
+        const cutoffDate = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000);
+        return predictionModel.find({
+            status: { $in: statuses },
+            updatedAt: { $lte: cutoffDate }
+        });
+    };
+    const createPrediction = async ({ predictionId, guildId, channelId, creatorId, title, choices, autolock, status }) => {
+        await predictionModel.create({
+            predictionId,
+            guildId,
+            channelId,
+            creatorId,
+            title,
+            choices,
+            autolock,
+            status
+        });
+    };
+    const updatePredictionStatus = async ({ predictionId, guildId, fromStatus, toStatus }) => {
+        return predictionModel.findOneAndUpdate({
+            predictionId,
+            guildId,
+            status: Array.isArray(fromStatus) ? { $in: fromStatus } : fromStatus
+        }, { $set: { status: toStatus } }, { returnDocument: 'after' });
+    };
+    const deletePrediction = async ({ predictionId }) => {
+        await predictionModel.deleteOne({ predictionId });
+    };
+    const findPredictions = async (query) => {
+        return predictionModel.find(query).limit(25);
+    };
+    const addPredictionBet = async ({ predictionId, guildId, choiceName, userId, amount, betId }) => {
+        return predictionModel.findOneAndUpdate({
+            predictionId,
+            guildId,
+            'choices.choiceName': choiceName
+        }, {
+            $push: {
+                'choices.$.bets': {
+                    userId,
+                    amount,
+                    betId
+                }
+            }
+        });
+    };
+    return {
+        getPredictionById,
+        getPredictionToLock,
+        getOldPredictions,
+        createPrediction,
+        updatePredictionStatus,
+        deletePrediction,
+        findPredictions,
+        addPredictionBet
+    };
+}

package/dist/predictions/services/predictionLifecycle.service.d.ts

@@ -0,0 +1,25 @@
+import type { CasinoBetService } from '../../casino/services/casinoBet.service';
+import type { TPrediction } from '../types/prediction';
+import type { PredictionDb } from './prediction.db';
+import type { PayPredictionResult } from './types';
+type PredictionLifecycleDeps = {
+    predictionDb: PredictionDb;
+    casinoBet: Pick<CasinoBetService, 'refundLockedBet' | 'settleCasinoWinnings'>;
+};
+export declare function createPredictionLifecycleService({ predictionDb, casinoBet }: PredictionLifecycleDeps): {
+    endPrediction: ({ predictionId, guildId }: {
+        predictionId: string;
+        guildId: string;
+    }) => Promise<TPrediction | null>;
+    cancelPrediction: ({ predictionId, guildId }: {
+        predictionId: string;
+        guildId: string;
+    }) => Promise<TPrediction | null>;
+    payoutPrediction: ({ predictionId, guildId, winnerChoice }: {
+        predictionId: string;
+        guildId: string;
+        winnerChoice: string;
+    }) => Promise<PayPredictionResult>;
+};
+export type PredictionLifecycleService = ReturnType<typeof createPredictionLifecycleService>;
+export {};

package/dist/predictions/services/predictionLifecycle.service.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPredictionLifecycleService = createPredictionLifecycleService;
+const predictionSummary_1 = require("./predictionSummary");
+function createPredictionLifecycleService({ predictionDb, casinoBet }) {
+    const { getPredictionById, updatePredictionStatus } = predictionDb;
+    const { refundLockedBet, settleCasinoWinnings } = casinoBet;
+    const finalizePaid = async (predictionId, guildId) => {
+        const paid = await updatePredictionStatus({
+            predictionId,
+            guildId,
+            fromStatus: 'paying',
+            toStatus: 'paid'
+        });
+        if (!paid)
+            throw new Error('FINALIZE_FAILED');
+        return paid;
+    };
+    const rollbackPaying = async (predictionId, guildId) => {
+        await updatePredictionStatus({
+            predictionId,
+            guildId,
+            fromStatus: 'paying',
+            toStatus: 'ended'
+        });
+    };
+    const endPrediction = async ({ predictionId, guildId }) => {
+        return updatePredictionStatus({
+            predictionId,
+            guildId,
+            fromStatus: 'active',
+            toStatus: 'ended'
+        });
+    };
+    const cancelPrediction = async ({ predictionId, guildId }) => {
+        const updatedPrediction = await updatePredictionStatus({
+            predictionId,
+            guildId,
+            fromStatus: ['active', 'ended'],
+            toStatus: 'canceled'
+        });
+        if (!updatedPrediction)
+            return null;
+        const allBets = updatedPrediction.choices.flatMap((c) => c.bets);
+        for (const bet of allBets) {
+            await refundLockedBet({
+                userId: bet.userId,
+                guildId,
+                amount: bet.amount,
+                betId: (0, predictionSummary_1.resolvePredictionBetId)(bet, predictionId),
+                game: 'prediction'
+            });
+        }
+        return updatedPrediction;
+    };
+    const payoutPrediction = async ({ predictionId, guildId, winnerChoice }) => {
+        const prediction = await getPredictionById({ predictionId, guildId });
+        if (!prediction)
+            return { ok: false, code: 'NOT_FOUND' };
+        if (prediction.status !== 'ended') {
+            if (prediction.status === 'paid' || prediction.status === 'paying') {
+                return { ok: false, code: 'ALREADY_HANDLED' };
+            }
+            return { ok: false, code: 'INVALID_STATUS' };
+        }
+        const winner = prediction.choices.find((c) => c.choiceName === winnerChoice);
+        if (!winner)
+            return { ok: false, code: 'INVALID_WINNER' };
+        const locked = await updatePredictionStatus({
+            predictionId,
+            guildId,
+            fromStatus: 'ended',
+            toStatus: 'paying'
+        });
+        if (!locked)
+            return { ok: false, code: 'ALREADY_HANDLED' };
+        try {
+            const allBets = prediction.choices.flatMap((c) => c.bets);
+            if (winner.bets.length === 0) {
+                for (const bet of allBets) {
+                    await refundLockedBet({
+                        userId: bet.userId,
+                        guildId,
+                        amount: bet.amount,
+                        betId: (0, predictionSummary_1.resolvePredictionBetId)(bet, predictionId),
+                        game: 'prediction'
+                    });
+                }
+                const paid = await finalizePaid(predictionId, guildId);
+                return { ok: true, outcome: 'refunded', prediction: paid };
+            }
+            for (const bet of winner.bets) {
+                await settleCasinoWinnings({
+                    userId: bet.userId,
+                    guildId,
+                    totalBet: bet.amount,
+                    winnings: bet.amount * winner.odds,
+                    betId: (0, predictionSummary_1.resolvePredictionBetId)(bet, predictionId),
+                    game: 'prediction'
+                });
+            }
+            const losingChoices = prediction.choices.filter((c) => c.choiceName !== winnerChoice);
+            for (const choice of losingChoices) {
+                for (const bet of choice.bets) {
+                    await settleCasinoWinnings({
+                        userId: bet.userId,
+                        guildId,
+                        totalBet: bet.amount,
+                        winnings: 0,
+                        betId: (0, predictionSummary_1.resolvePredictionBetId)(bet, predictionId),
+                        game: 'prediction'
+                    });
+                }
+            }
+            const paid = await finalizePaid(predictionId, guildId);
+            return {
+                ok: true,
+                outcome: 'paid',
+                prediction: paid,
+                winnerChoice
+            };
+        }
+        catch (error) {
+            await rollbackPaying(predictionId, guildId);
+            throw error;
+        }
+    };
+    return {
+        endPrediction,
+        cancelPrediction,
+        payoutPrediction
+    };
+}

package/dist/predictions/services/predictionSummary.d.ts

@@ -0,0 +1,30 @@
+import type { TPrediction } from '../types/prediction';
+export declare function resolvePredictionBetId(bet: TPrediction['choices'][number]['bets'][number], predictionId: string): string;
+export type PredictionChoiceSummary = {
+    choiceName: string;
+    odds: number;
+    betCount: number;
+    totalBetAmount: number;
+    payoutIfWins: number;
+    bets: TPrediction['choices'][number]['bets'];
+};
+export type PredictionCheckSummary = {
+    totalBetAmount: number;
+    bettorCount: number;
+    choices: PredictionChoiceSummary[];
+};
+export declare function getPredictionCheckSummary(prediction: TPrediction): PredictionCheckSummary;
+export type PayoutBetSummary = {
+    userId: string;
+    betAmount: number;
+    winAmount: number;
+};
+export type PredictionPayoutSummary = {
+    participants: number;
+    winners: PayoutBetSummary[];
+    losers: PayoutBetSummary[];
+    totalWon: number;
+    totalLost: number;
+    casinoProfit: number;
+};
+export declare function calculatePredictionPayoutSummary(prediction: TPrediction, winnerChoice: string): PredictionPayoutSummary | null;

package/dist/predictions/services/predictionSummary.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePredictionBetId = resolvePredictionBetId;
+exports.getPredictionCheckSummary = getPredictionCheckSummary;
+exports.calculatePredictionPayoutSummary = calculatePredictionPayoutSummary;
+function resolvePredictionBetId(bet, predictionId) {
+    return bet.betId ?? `${predictionId}:${bet.userId}`;
+}
+function getPredictionCheckSummary(prediction) {
+    const allBets = prediction.choices.flatMap((c) => c.bets);
+    const bettorCount = new Set(allBets.map((b) => b.userId)).size;
+    const totalBetAmount = allBets.reduce((acc, b) => acc + b.amount, 0);
+    const choices = prediction.choices.map((choice) => {
+        const totalBet = choice.bets.reduce((acc, b) => acc + b.amount, 0);
+        const payoutIfWins = choice.bets.reduce((acc, b) => acc + b.amount * choice.odds, 0);
+        return {
+            choiceName: choice.choiceName,
+            odds: choice.odds,
+            betCount: choice.bets.length,
+            totalBetAmount: totalBet,
+            payoutIfWins,
+            bets: choice.bets
+        };
+    });
+    return {
+        totalBetAmount,
+        bettorCount,
+        choices
+    };
+}
+function calculatePredictionPayoutSummary(prediction, winnerChoice) {
+    const winner = prediction.choices.find((c) => c.choiceName === winnerChoice);
+    if (!winner)
+        return null;
+    const totalBets = prediction.choices.flatMap((c) => c.bets);
+    const winners = winner.bets.map((b) => ({
+        userId: b.userId,
+        betAmount: b.amount,
+        winAmount: b.amount * winner.odds
+    }));
+    const losers = prediction.choices
+        .filter((c) => c.choiceName !== winnerChoice)
+        .flatMap((c) => c.bets.map((b) => ({
+        userId: b.userId,
+        betAmount: b.amount,
+        winAmount: 0
+    })));
+    const totalWon = winners.reduce((acc, w) => acc + w.winAmount, 0);
+    const totalLost = losers.reduce((acc, l) => acc + l.betAmount, 0);
+    return {
+        participants: totalBets.length,
+        winners,
+        losers,
+        totalWon,
+        totalLost,
+        casinoProfit: totalLost - totalWon
+    };
+}

package/dist/predictions/services/types.d.ts

@@ -0,0 +1,27 @@
+import type { TPrediction, TPredictionOption } from '../types/prediction';
+export type TCreatePrediction = Omit<TPrediction, 'createdAt' | 'updatedAt'>;
+export type TGetPrediction = Pick<TPrediction, 'predictionId' | 'guildId'>;
+export type TGetOldPredictions = {
+    statuses: TPrediction['status'][];
+    olderThanDays: number;
+};
+export type TUpdatePredictionStatus = Pick<TPrediction, 'predictionId' | 'guildId'> & {
+    fromStatus: TPrediction['status'] | TPrediction['status'][];
+    toStatus: TPrediction['status'];
+};
+export type TAddPredictionBet = Pick<TPrediction, 'predictionId' | 'guildId'> & {
+    choiceName: TPredictionOption['choiceName'];
+    userId: TPredictionOption['bets'][number]['userId'];
+    amount: TPredictionOption['bets'][number]['amount'];
+    betId: TPredictionOption['bets'][number]['betId'];
+};
+export type PayPredictionResult = {
+    ok: true;
+    outcome: 'paid' | 'refunded';
+    prediction: TPrediction;
+    winnerChoice?: string;
+} | {
+    ok: false;
+    code: 'NOT_FOUND' | 'INVALID_STATUS' | 'ALREADY_HANDLED' | 'INVALID_WINNER';
+};
+export type PredictionLifecycleErrorCode = 'NOT_FOUND' | 'INVALID_STATUS' | 'ALREADY_HANDLED';

package/dist/raffle/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types/raffle';
+export * from './services/types';
+export * from './services/raffle.db';
+export * from './services/raffleLifecycle.service';
+export * from './schemas/raffle.forms';
+export { RaffleSchema } from './raffle.mongoose';

package/dist/raffle/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RaffleSchema = void 0;
+__exportStar(require("./types/raffle"), exports);
+__exportStar(require("./services/types"), exports);
+__exportStar(require("./services/raffle.db"), exports);
+__exportStar(require("./services/raffleLifecycle.service"), exports);
+__exportStar(require("./schemas/raffle.forms"), exports);
+var raffle_mongoose_1 = require("./raffle.mongoose");
+Object.defineProperty(exports, "RaffleSchema", { enumerable: true, get: function () { return raffle_mongoose_1.RaffleSchema; } });

package/dist/{mongoose/raffle.schema.d.ts → raffle/raffle.mongoose.d.ts}

@@ -1,18 +1,8 @@
 import { Schema } from 'mongoose';
-import { TRaffle } from '../types';
-export declare const RaffleSchema: Schema<TRaffle, import("mongoose").Model<TRaffle, any, any, any, (import("mongoose").Document<unknown, any, TRaffle, any, import("mongoose").DefaultSchemaOptions> & TRaffle & {
-    _id: import("mongoose").Types.ObjectId;
-} & {
-    __v: number;
-} & {
-    id: string;
-}) | (import("mongoose").Document<unknown, any, TRaffle, any, import("mongoose").DefaultSchemaOptions> & TRaffle & {
-    _id: import("mongoose").Types.ObjectId;
-} & {
-    __v: number;
-}), any, TRaffle>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+import { TRaffle } from './types/raffle';
+export declare const RaffleSchema: Schema<TRaffle, import("mongoose").Model<TRaffle, any, any, any, any, any, TRaffle>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
     id: string;
-}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+}, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
     _id: import("mongoose").Types.ObjectId;
 } & {
     __v: number;
@@ -21,7 +11,7 @@ export declare const RaffleSchema: Schema<TRaffle, import("mongoose").Model<TRaf
 }, {
     drawId?: import("mongoose").SchemaDefinitionProperty<string, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -30,7 +20,7 @@ export declare const RaffleSchema: Schema<TRaffle, import("mongoose").Model<TRaf
     }> | undefined;
     raffleId?: import("mongoose").SchemaDefinitionProperty<string, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -39,7 +29,7 @@ export declare const RaffleSchema: Schema<TRaffle, import("mongoose").Model<TRaf
     }> | undefined;
     guildId?: import("mongoose").SchemaDefinitionProperty<string, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -48,7 +38,7 @@ export declare const RaffleSchema: Schema<TRaffle, import("mongoose").Model<TRaf
     }> | undefined;
     channelId?: import("mongoose").SchemaDefinitionProperty<string, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -57,7 +47,7 @@ export declare const RaffleSchema: Schema<TRaffle, import("mongoose").Model<TRaf
     }> | undefined;
     creatorId?: import("mongoose").SchemaDefinitionProperty<string, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -66,7 +56,7 @@ export declare const RaffleSchema: Schema<TRaffle, import("mongoose").Model<TRaf
     }> | undefined;
     ticketPrice?: import("mongoose").SchemaDefinitionProperty<number, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -75,7 +65,7 @@ export declare const RaffleSchema: Schema<TRaffle, import("mongoose").Model<TRaf
     }> | undefined;
     maxTicketsPerUser?: import("mongoose").SchemaDefinitionProperty<number, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -84,7 +74,7 @@ export declare const RaffleSchema: Schema<TRaffle, import("mongoose").Model<TRaf
     }> | undefined;
     nextDrawAt?: import("mongoose").SchemaDefinitionProperty<Date, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -93,7 +83,7 @@ export declare const RaffleSchema: Schema<TRaffle, import("mongoose").Model<TRaf
     }> | undefined;
     lastDrawAt?: import("mongoose").SchemaDefinitionProperty<Date | undefined, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -102,28 +92,25 @@ export declare const RaffleSchema: Schema<TRaffle, import("mongoose").Model<TRaf
     }> | undefined;
     drawIntervalMs?: import("mongoose").SchemaDefinitionProperty<number, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
     }, "id"> & {
         id: string;
     }> | undefined;
-    status?: import("mongoose").SchemaDefinitionProperty<"active" | "canceled", TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+    status?: import("mongoose").SchemaDefinitionProperty<import("./types/raffle").TRaffleStatus, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
     }, "id"> & {
         id: string;
     }> | undefined;
-    participants?: import("mongoose").SchemaDefinitionProperty<{
-        userId: string;
-        tickets: number;
-    }[], TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+    participants?: import("mongoose").SchemaDefinitionProperty<import("./types/raffle").TRaffleParticipant[], TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -132,7 +119,7 @@ export declare const RaffleSchema: Schema<TRaffle, import("mongoose").Model<TRaf
     }> | undefined;
     createdAt?: import("mongoose").SchemaDefinitionProperty<Date, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -141,7 +128,7 @@ export declare const RaffleSchema: Schema<TRaffle, import("mongoose").Model<TRaf
     }> | undefined;
     updatedAt?: import("mongoose").SchemaDefinitionProperty<Date, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;

package/dist/raffle/schemas/raffle.forms.d.ts

@@ -0,0 +1,11 @@
+import z from 'zod';
+export declare const raffleChannelsFormSchema: z.ZodObject<{
+    actions: z.ZodString;
+    logs: z.ZodString;
+}, z.core.$strip>;
+export declare const raffleCreateFormSchema: z.ZodObject<{
+    ticketPrice: z.ZodString;
+    maxTickets: z.ZodNumber;
+    drawTime: z.ZodString;
+    interval: z.ZodString;
+}, z.core.$strip>;

package/dist/raffle/schemas/raffle.forms.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.raffleCreateFormSchema = exports.raffleChannelsFormSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.raffleChannelsFormSchema = zod_1.default.object({
+    actions: zod_1.default.string(),
+    logs: zod_1.default.string()
+});
+exports.raffleCreateFormSchema = zod_1.default.object({
+    ticketPrice: zod_1.default.string().min(1),
+    maxTickets: zod_1.default.number().int().min(1).max(100),
+    drawTime: zod_1.default.string().min(1),
+    interval: zod_1.default.string().min(2)
+});