gambling-bot-shared 1.0.0 → 1.0.1

package/dist/predictions/prediction.mongoose.d.ts

@@ -0,0 +1,102 @@
+import { Schema } from 'mongoose';
+import { TPrediction } from './types/prediction';
+export declare const PredictionSchema: Schema<TPrediction, import("mongoose").Model<TPrediction, any, any, any, any, any, TPrediction>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
+    id: string;
+}, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, {
+    predictionId?: import("mongoose").SchemaDefinitionProperty<string, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    guildId?: import("mongoose").SchemaDefinitionProperty<string, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    channelId?: import("mongoose").SchemaDefinitionProperty<string, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    creatorId?: import("mongoose").SchemaDefinitionProperty<string, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    title?: import("mongoose").SchemaDefinitionProperty<string, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    choices?: import("mongoose").SchemaDefinitionProperty<import("./types/prediction").TPredictionOption[], TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    status?: import("mongoose").SchemaDefinitionProperty<"active" | "ended" | "paying" | "paid" | "canceled", TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    autolock?: import("mongoose").SchemaDefinitionProperty<Date | null | undefined, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    createdAt?: import("mongoose").SchemaDefinitionProperty<Date, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    updatedAt?: import("mongoose").SchemaDefinitionProperty<Date, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+}, TPrediction>;

package/dist/predictions/schemas/prediction.forms.d.ts

@@ -0,0 +1,20 @@
+import z from 'zod';
+export declare const predictionChannelsFormSchema: z.ZodObject<{
+    actions: z.ZodString;
+    logs: z.ZodString;
+}, z.core.$strip>;
+export declare const predictionChoiceSchema: z.ZodObject<{
+    choiceName: z.ZodString;
+    odds: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>, z.ZodNumber>;
+}, z.core.$strip>;
+export declare const createPredictionFormSchema: z.ZodObject<{
+    title: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        choiceName: z.ZodString;
+        odds: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>, z.ZodNumber>;
+    }, z.core.$strip>>;
+    autolock: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const payoutPredictionFormSchema: z.ZodObject<{
+    winnerChoice: z.ZodString;
+}, z.core.$strip>;

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

@@ -0,0 +1,6 @@
+import type { TPredictionOption } from '../types/prediction';
+import { parsePredictionAutolock } from './parsePredictionAutolock';
+import { parsePredictionChoices } from './parsePredictionChoices';
+export type PredictionChoiceInput = string | Pick<TPredictionOption, 'choiceName' | 'odds'>[];
+export declare function normalizePredictionChoices(input: PredictionChoiceInput): ReturnType<typeof parsePredictionChoices>;
+export declare function normalizePredictionAutolock(input: string, format: 'iso' | 'discord'): ReturnType<typeof parsePredictionAutolock>;

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

@@ -0,0 +1,9 @@
+export type ParsePredictionAutolockError = 'INVALID_FORMAT' | 'INVALID_DATE' | 'PAST_DATE';
+export type ParsePredictionAutolockResult = {
+    ok: true;
+    autolock: Date;
+} | {
+    ok: false;
+    error: ParsePredictionAutolockError;
+};
+export declare function parsePredictionAutolock(input: string, timezone?: string): ParsePredictionAutolockResult;

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

@@ -0,0 +1,11 @@
+import type { TPredictionOption } from '../types/prediction';
+export type ParsePredictionChoicesError = 'INVALID_COUNT' | 'INVALID_FORMAT';
+export type ParsePredictionChoicesResult = {
+    ok: true;
+    choices: TPredictionOption[];
+} | {
+    ok: false;
+    error: ParsePredictionChoicesError;
+    detail?: string;
+};
+export declare function parsePredictionChoices(input: string): ParsePredictionChoicesResult;

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/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/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/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/predictions/types/prediction.d.ts

@@ -0,0 +1,21 @@
+export type TPredictionOption = {
+    choiceName: string;
+    odds: number;
+    bets: {
+        userId: string;
+        amount: number;
+        betId: string;
+    }[];
+};
+export type TPrediction = {
+    predictionId: string;
+    guildId: string;
+    channelId: string;
+    creatorId: string;
+    title: string;
+    choices: TPredictionOption[];
+    status: 'active' | 'ended' | 'paying' | 'paid' | 'canceled';
+    autolock?: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+};

package/dist/predictions/utils/validatePredictionBet.d.ts

@@ -0,0 +1,13 @@
+export type PredictionBetValidationError = 'BELOW_MIN_BET' | 'ABOVE_MAX_PER_CHOICE';
+export type PredictionBetValidationResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: PredictionBetValidationError;
+};
+export declare const validatePredictionChoiceBet: ({ userChoiceTotal, parsedBetAmount, maxBet, minBet }: {
+    userChoiceTotal: number;
+    parsedBetAmount: number;
+    maxBet: number;
+    minBet: number;
+}) => PredictionBetValidationResult;

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/raffle.mongoose.d.ts

@@ -0,0 +1,138 @@
+import { Schema } from 'mongoose';
+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").DefaultSchemaOptions> & Omit<TRaffle & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, {
+    drawId?: import("mongoose").SchemaDefinitionProperty<string, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    raffleId?: import("mongoose").SchemaDefinitionProperty<string, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    guildId?: import("mongoose").SchemaDefinitionProperty<string, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    channelId?: import("mongoose").SchemaDefinitionProperty<string, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    creatorId?: import("mongoose").SchemaDefinitionProperty<string, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    ticketPrice?: import("mongoose").SchemaDefinitionProperty<number, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    maxTicketsPerUser?: import("mongoose").SchemaDefinitionProperty<number, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    nextDrawAt?: import("mongoose").SchemaDefinitionProperty<Date, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    lastDrawAt?: import("mongoose").SchemaDefinitionProperty<Date | undefined, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    drawIntervalMs?: import("mongoose").SchemaDefinitionProperty<number, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    status?: import("mongoose").SchemaDefinitionProperty<import("./types/raffle").TRaffleStatus, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    participants?: import("mongoose").SchemaDefinitionProperty<import("./types/raffle").TRaffleParticipant[], TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    createdAt?: import("mongoose").SchemaDefinitionProperty<Date, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    updatedAt?: import("mongoose").SchemaDefinitionProperty<Date, TRaffle, import("mongoose").Document<unknown, {}, TRaffle, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+}, TRaffle>;

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/services/raffle.db.d.ts

@@ -0,0 +1,51 @@
+import type { Model } from 'mongoose';
+import type { TRaffle } from '../types/raffle';
+import type { TAddRaffleTickets, TUpsertRaffle } from './types';
+export declare function createRaffleDb(raffleModel: Model<TRaffle>): {
+    getRaffleById: ({ raffleId, guildId }: {
+        raffleId: string;
+        guildId: string;
+    }) => Promise<(import("mongoose").Document<unknown, {}, TRaffle, {}, import("mongoose").DefaultSchemaOptions> & TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    } & {
+        id: string;
+    }) | null>;
+    upsertRaffle: ({ guildId, drawId, raffleId, creatorId, channelId, ticketPrice, maxTicketsPerUser, nextDrawAt, drawIntervalMs }: TUpsertRaffle) => Promise<import("mongoose").Document<unknown, {}, TRaffle, {}, import("mongoose").DefaultSchemaOptions> & TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    } & {
+        id: string;
+    }>;
+    addRaffleTickets: ({ raffleId, guildId, userId, tickets, maxTicketsPerUser }: TAddRaffleTickets) => Promise<boolean>;
+    cancelRaffleAtomic: ({ raffleId, guildId }: {
+        raffleId: string;
+        guildId: string;
+    }) => Promise<(import("mongoose").Document<unknown, {}, TRaffle, {}, import("mongoose").DefaultSchemaOptions> & TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    } & {
+        id: string;
+    }) | null>;
+    searchRafflesForAutocomplete: ({ guildId, query }: {
+        guildId: string;
+        query: string;
+    }) => Promise<any[]>;
+    getRafflesReadyToDraw: () => Promise<(import("mongoose").Document<unknown, {}, TRaffle, {}, import("mongoose").DefaultSchemaOptions> & TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    } & {
+        id: string;
+    })[]>;
+    completeRaffleDraw: ({ raffleId, nextDrawAt, lastDrawAt, drawId }: {
+        raffleId: string;
+        nextDrawAt: Date;
+        lastDrawAt: Date;
+        drawId: string;
+    }) => Promise<void>;
+};
+export type RaffleDb = ReturnType<typeof createRaffleDb>;

package/dist/raffle/services/raffleLifecycle.service.d.ts

@@ -0,0 +1,15 @@
+import type { CasinoBetService } from '../../casino/services/casinoBet.service';
+import type { RaffleDb } from './raffle.db';
+import type { CancelRaffleResult } from './types';
+type RaffleLifecycleDeps = {
+    raffleDb: RaffleDb;
+    casinoBet: Pick<CasinoBetService, 'refundRafflePurchase'>;
+};
+export declare function createRaffleLifecycleService({ raffleDb, casinoBet }: RaffleLifecycleDeps): {
+    cancelRaffle: ({ raffleId, guildId }: {
+        raffleId: string;
+        guildId: string;
+    }) => Promise<CancelRaffleResult>;
+};
+export type RaffleLifecycleService = ReturnType<typeof createRaffleLifecycleService>;
+export {};

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

@@ -0,0 +1,27 @@
+import type { TRaffle } from '../types/raffle';
+export type TAddRaffleTickets = {
+    raffleId: string;
+    guildId: string;
+    userId: string;
+    tickets: number;
+    maxTicketsPerUser: number;
+};
+export type TUpsertRaffle = {
+    raffleId: string;
+    drawId: string;
+    guildId: string;
+    creatorId: string;
+    channelId: string;
+    ticketPrice: number;
+    maxTicketsPerUser: number;
+    nextDrawAt: Date;
+    drawIntervalMs: number;
+};
+export type CancelRaffleResult = {
+    ok: false;
+    code: 'NOT_FOUND';
+} | {
+    ok: true;
+    raffle: TRaffle;
+    refundErrors: string[];
+};

package/dist/raffle/types/raffle.d.ts

@@ -0,0 +1,21 @@
+export type TRaffleStatus = 'active' | 'canceled';
+export type TRaffleParticipant = {
+    userId: string;
+    tickets: number;
+};
+export type TRaffle = {
+    drawId: string;
+    raffleId: string;
+    guildId: string;
+    channelId: string;
+    creatorId: string;
+    ticketPrice: number;
+    maxTicketsPerUser: number;
+    nextDrawAt: Date;
+    lastDrawAt?: Date;
+    drawIntervalMs: number;
+    status: TRaffleStatus;
+    participants: TRaffleParticipant[];
+    createdAt: Date;
+    updatedAt: Date;
+};

package/dist/transactions/constants/gameRecordFields.d.ts

@@ -0,0 +1,8 @@
+export declare const GAME_RECORD_FIELDS: {
+    readonly slots: readonly ["winMultipliers", "symbolWeights"];
+    readonly lottery: readonly ["winMultipliers"];
+    readonly roulette: readonly ["winMultipliers"];
+    readonly plinko: readonly ["binMultipliers"];
+};
+export type GameWithRecords = keyof typeof GAME_RECORD_FIELDS;
+export type RecordKey = (typeof GAME_RECORD_FIELDS)[GameWithRecords][number];

package/dist/transactions/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './transaction';
+export * from './gameRecordFields';

package/dist/transactions/constants/transaction.d.ts

@@ -0,0 +1,2 @@
+export declare const TRANSACTION_TYPES: readonly ["deposit", "withdraw", "bet", "win", "refund", "bonus", "vip"];
+export declare const TRANSACTION_SOURCES: readonly ["command", "manual", "web", "system", "casino"];

package/dist/transactions/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './constants/gameRecordFields';
+export * from './types/transaction';
+export * from './constants/transaction';